diff --git a/.gitignore b/.gitignore index 8df86855..e9525c12 100644 --- a/.gitignore +++ b/.gitignore @@ -161,3 +161,5 @@ examples/demo2d/**/results # Cmake generated files CMakeUserPresets.json +# Claude Code +.claude/ \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json index 86e54207..15e5a83f 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -49,4 +49,7 @@ "mypy-type-checker.reportingScope": "workspace", "mypy-type-checker.preferDaemon": true, "ruff.configurationPreference": "filesystemFirst", + "cSpell.words": [ + "effecient" + ], } \ No newline at end of file diff --git a/CLAUDE..md b/CLAUDE..md new file mode 100644 index 00000000..b33b75a3 --- /dev/null +++ b/CLAUDE..md @@ -0,0 +1,81 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## Project Overview + +**axtreme** is a Python library extending Ax (Facebook's Adaptive Experimentation) and BoTorch (Bayesian Optimization in PyTorch) for design of experiments, active learning, and extreme response analysis. It targets reliability engineering scenarios like estimating 50-year storm loads from surrogate models. + +## Build & Development Commands + +```bash +uv sync # Install all dependencies (dev included) +uv sync --extra cuda # With CUDA support +uv sync --extra examples # With example dependencies (openturns, numba) +uv run pre-commit install # Setup pre-commit hooks + +# Testing +uv run pytest # Run all tests +uv run pytest tests/path/test_file.py::test_name # Single test +uv run pytest -m "not system" # Skip long-running system tests +uv run pytest --cov # With coverage + +# Linting & Formatting +uv run ruff format # Format code +uv run ruff check --fix # Lint with auto-fix +uv run pyright # Type checking (primary) +uv run mypy # Type checking (secondary) +uv run pre-commit run --all-files # Run all checks (ruff, pyright, mypy) +``` + +## Architecture + +### Core Protocols (structural subtyping via `typing.Protocol`) + +The codebase is designed around three key protocols that define the extension points: + +- **`Simulator`** (`simulator/base.py`): `__call__(x: ndarray[n_points, n_dims], n_simulations_per_point) -> ndarray[n_points, n_sims, n_outputs]` -- wraps any simulation model. +- **`QoIEstimator`** (`qoi/qoi_estimator.py`): `__call__(model: Model) -> Tensor[n_estimates]` -- estimates a scalar quantity of interest from a BoTorch surrogate model. Has `mean()` and `var()` methods for aggregation (overridable for special samplers like UT). +- **`PosteriorSampler`** (`sampling/base.py`): `__call__(posterior: GPyTorchPosterior) -> Tensor` -- draws samples from GP posteriors with different strategies. + +### Bayesian Optimization Loop (how modules connect) + +1. **Experiment setup** (`experiment.py`): Create Ax Experiment, initialize with Sobol points +2. **Simulation** (`evaluation.py`): `EvaluationFunction` wraps a `Simulator`, runs it, fits a distribution (Gumbel) to outputs -> `SimulationPointResults` +3. **Ax integration** (`runner.py` + `metrics.py`): `LocalMetadataRunner` executes evaluation, stores results in trial metadata; `LocalMetadataMetric` fetches them back +4. **Surrogate model**: Ax/BoTorch fits a GP to collected data +5. **QoI estimation** (`qoi/`): Either `GPBruteForce` (full-period simulation) or `MarginalCDFExtrapolation` (CDF^N extrapolation) estimates the extreme response quantity +6. **Acquisition** (`acquisition/qoi_look_ahead.py`): `QoILookAhead` uses fantasy models to select the next point that most reduces QoI variance +7. Repeat from step 2 + +### Key Module Purposes + +- **`qoi/`**: Two strategies for extreme value estimation. `GPBruteForce` simulates all timesteps per period. `MarginalCDFExtrapolation` approximates via single-timestep CDF raised to power N -- much faster for large N. +- **`sampling/`**: `MeanSampler` (no uncertainty), `IndependentMCSampler` (diagonalizes cross-point covariance), `NormalIndependentSampler`, `UTSampler` (unscented transform, needs custom mean/var). +- **`distributions/`**: `ApproximateMixture` (conservative tail extrapolation for safety-critical use), `icdf` (inverse CDF via root-finding for distributions without analytic inverse). +- **`data/`**: PyTorch Dataset/Sampler wrappers including `NumpyFileDataset` (memory-mapped), importance sampling support, custom batch samplers. +- **`utils/transforms.py`**: Converts Ax transforms to BoTorch space so models can operate in problem space rather than Ax's normalized space. +- **`eval/`**: `QoIJob`/`QoIJobResult` for organizing and serializing QoI evaluation runs. + +### Tensor Dimension Conventions (BoTorch notation) + +- `*b`: batch dimensions (arbitrary) +- `n`: number of input points +- `m`: output dimensionality +- GP posterior shape: `(*b, n, m)` + +## Code Style + +- **Formatter/Linter**: Ruff (configured in `ruff.toml`). Selects ALL rules then ignores specific ones. +- **Line length**: 120 characters +- **Docstrings**: Follow Google style. +- **Type hints**: Required on all functions. Pyright in basic mode with strict-ish overrides. Stubs in `stubs/` directory for untyped third-party libraries. +- **Imports**: Absolute only (no relative imports). Grouped: stdlib, third-party, local. +- **Test markers**: `integration`, `external`, `system` (very long), `non_deterministic`. Tests mirror `src/` structure. +- **TODOs**: Use `# @TODO: Description. AUTHOR, YYYY-MM-DD` format. + +## Important Constraints + +- **numpy < 2.0**: Pinned for compatibility with the scipy/torch/botorch ecosystem. +- **ax-platform == 0.3.7**: Pinned exact version; Ax APIs can change significantly between versions. +- **Single output only**: Multi-output GP support is not yet implemented across the QoI pipeline. diff --git a/STYLEGUIDE.md b/STYLEGUIDE.md index b55aadee..e26080be 100644 --- a/STYLEGUIDE.md +++ b/STYLEGUIDE.md @@ -305,31 +305,27 @@ If you are interested in the long story including the why‘s, read these discus ## Docstrings -* All Docstrings should be written in [Numpy](https://numpydoc.readthedocs.io/en/latest/format.html) format. For a good tutorial on Docstrings, see [Documenting Python Code: A Complete Guide](https://realpython.com/documenting-python-code) +* All Docstrings should be written in [Google](https://google.github.io/styleguide/pyguide.html#38-comments-and-docstrings) format. For a good tutorial on Docstrings, see [Documenting Python Code: A Complete Guide](https://realpython.com/documenting-python-code) * In a Docstring, summarize function/method behavior and document its arguments, return value(s), side effects, exceptions raised, and restrictions * Wrap Docstrings with triple double quotes (""") * The description of the arguments must be indented ```py - def some_method(name, print=False): - """This function does something - - Parameters - ---------- - name : str - The name to use - print: bool, optional - A flag used to print the name to the console, by default False - - Raises - ------ - KeyError - If name is not found - - Returns - ------- - int - The return code + def some_method(name: str, print: bool = False): + """Short description of some_method's purpose. + + More in depth description of some_method's behavior, side effects, etc. + + Args: + name: description of the arguments purpose. Only provide type info not in signature. + print: Some long description that might need to be wrapped to multiple lines. This + is done using an indent. + + Returns: + Semantic description of the return value + + Raises: + IOError: What condition this error might be raised. """ ... return 0 diff --git a/src/axtreme/distributions/mixture.py b/src/axtreme/distributions/mixture.py index 8cb48bff..41d9c4a3 100644 --- a/src/axtreme/distributions/mixture.py +++ b/src/axtreme/distributions/mixture.py @@ -1,5 +1,7 @@ """Mixture model variants.""" +import warnings + import torch from torch.distributions import Categorical, Distribution, MixtureSameFamily @@ -7,7 +9,7 @@ class ApproximateMixture(MixtureSameFamily): - """Mixture distributions where extreme caclulations are approximated. + """Mixture distributions where extreme calculations are approximated. Some distribution only support a limited range of quantiles (e.g :math:`[.01, 99]`) due to numerical issues (see "Details"). When calculation such as :math:`q=cdf(x)` or :math:`x=icdf(q)` fail outside this range the function then @@ -26,11 +28,11 @@ class ApproximateMixture(MixtureSameFamily): Approximation principles: - It is assumed we want to conservatively estimate (:math:`1-cdf(x)`), the chance the a value will exceed some - level :math:`x`. For example, x could represent the strength a structure is designed to withstand, and + It is assumed (:math:`1-cdf(x)`) represent the chance of failure, and we want to avoid underestimating this. + For example, x could represent the strength a structure is designed to withstand, and (:math:`1-cdf(x)`) represents the chance of experiencing a force that will break the structure (e.g the - risk). It is better to overestimate the risk (conservative), rather than underestimate it. In other words, - if the :math:`cdf_est(x)` over estimates the :math:`cdf_true(x)`, then the true risk of exceeding x is. e.g: + risk). It is better to overestimate the risk (resulting in a conservative design), rather than underestimate + risk. In other words: TLDR: @@ -47,11 +49,13 @@ class ApproximateMixture(MixtureSameFamily): Approximate results. ApproximateMixture provides exact results within the quantile bounds ``[finfo.eps, 1 - finfo.eps]`` (where - ``finfo = torch.finfo(component_distribution.dtype)``) For details regarding why this range is selected see - ``_lower_bound_x`` and ``_upper_bound_x``. Values smaller than ``finfo.eps`` are approximated - according to ``_lower_bound_x``. Values larger than ``1 - finfo.eps`` are approximated according to - ``_upper_bound_x``. Note the range ``[finfo.eps, 1 - finfo.eps]`` is still used even if the component - distribution supports a greater range. + ``finfo = torch.finfo(component_distribution.dtype)``). NOTE: while ``TransformedDistribution`` says it + supports ``[finfo.tiny, 1 - finfo.eps]``, behaviour is unreliable below ``finfo.eps`` + (see `tests/distributions/test_mixture.py:test_lower_bound_x' ). When outside these bounds: + - x > icdf(1 - finfo.eps): we return :math:`cdf(x) = 1 - finfo.eps` (conservative estimate) + - x < icdf(finfo.eps): we return :math:`cdf(x) = 0` (conservative estimate) + + See 'Impact of Approximation' for details of why this is conservative. Impact of Approximation: @@ -62,9 +66,9 @@ class ApproximateMixture(MixtureSameFamily): - it will give q = 1.0-finfo.eps - in reality it could be as high as 1.0 - - so the q give is finfo.eps too small (at worst) + - so the q error is finfo.eps(at worst) - - The marginal cdf is calcualted from the underlying distributions: + - The marginal cdf is calculated from the underlying distributions: - e.g :math:`q_marginal = w_1 * q_1 + ... + w_n * q_n` - :math:`sum(w_i) = 1` @@ -73,10 +77,6 @@ class ApproximateMixture(MixtureSameFamily): - Underling distribution: q give is finfo.eps too small (at worst) - weight = 1 - - Note: - It is worth ensuring that the ApproximateMixture distribution has suitable numeric precision for its intended - use. See ``axtreme.distributions.utils.mixture_dtype`` for more details. """ def __init__( @@ -113,85 +113,159 @@ def __init__( self.dtype = component_dtype finfo = torch.finfo(component_dtype) + # NOTE: Even though internally TranformedDistribution sets its lowerbound with finfo.tiny, it appears to have # issues below finfo.eps. See `docs\source\marginal_cdf_extrapolation.md` "Distribution lower bound issue" + # TODO(sw 2026-04-08): The referenced doc is missing, find it or update the link self.quantile_bounds = torch.tensor([finfo.eps, 1 - finfo.eps], dtype=component_dtype) + # the q value to be returned when the cdf is run with an x that is outside the supported q range (lower, upper) + # See "Approximation principles" for why these values are selected. + self.cdf_out_of_bounds_q = torch.tensor([0.0, 1 - finfo.eps], dtype=component_dtype) # NOTE: bounds are stored here so we don't need to be recomputed every `.pdf()` or `.cdf()` call. # Can put in the call if we want to save memory. - self.x_bound_lower = ApproximateMixture._lower_bound_x(component_distribution) - self.x_bound_upper = ApproximateMixture._upper_bound_x(component_distribution) + self.x_bound_lower, self.x_bound_upper = ApproximateMixture.calculate_x_bounds( + dist=component_distribution, + q_upperbound=self.quantile_bounds[1].item(), + q_lowerbound=self.quantile_bounds[0].item(), + weights=mixture_distribution.probs, + ) @staticmethod - def _lower_bound_x(dist: Distribution) -> torch.Tensor: - """Returns the x lowerbound for each of the component distributions. - - If :math:`cdf(x)` recieves values that are too small, it throws an error. We instead find a suitable lower - bound and later clip the x values to this range. The lower bound should: - - - Not throw an error when it is used in :math:`cdf(lower_bound).` - - As per "Approximation principles" it should not result in overestimate of the analytical cdf. + def _check_cdf_numeric_precision( + dist: Distribution, + q: float, + weights: torch.Tensor | None = None, + ) -> dict[str, bool | float | None | torch.Tensor]: + """Helper to check if the dtype can represent the result ICDF(q)=x value with enough precision (so CDF(x)=q). + + We store the x bounds associated with quantile bounds. We need to ensure we have enough numerical precision to + store these bounds accurately. This can often fail if location and scale have very different values. + + Example: + ```python + finfo32 = torch.finfo(torch.float32) + dist = Gumbel(loc=torch.tensor(25000, dtype=torch.float32), scale=torch.tensor(1e-6, dtype=torch.float32)) + top_eps_quantile = dist.icdf(torch.tensor(1 - finfo32.eps)) + print(top_eps_quantile.item()) # 25000.0 + # Problem: top_eps_quantile can't be represented with enough accuracy + print(dist.cdf(top_eps_quantile).item()) # -> .3678 not 1-finfo.eps + ``` Args: - dist: The component distribution. - - Return: - Tensor of shape (dist.batch_shape). + dist: The distribution with batch_shape (*b) + q: The quantile to check the bound for. + weights: (shape (*b,)) The weights of each distribution in the mixture (if applicable). - Details: - TransformedDistribution are officially bounded between ``(finfo.tiny, 1 - finfo.eps)``. The CDF does not - match the mathematical CDF across this whole region (due to numeric errors) - Specifically the region - (finfo.tiny, finfo.eps). - - in the region (finfo.tiny, finfo.eps): - - - :math:`cdf(x)`: will output 0 for most of the region - - :math:`cdf(x)`: `x` corresponding q = finfo.tiny will produces error about being outside of the - allowed range, - due to numerical issues. :math:`x` in the region will produce the same error. - - Solution: Pick an x value corresponsing to the middle q range (finfo.tiny, finfo.eps). This should produce - cdf(x)=0, which underestimates the true cdf value by up to `finfo.eps`. As per "Approximation principles" - this is acceptable. + Returns: + dict with keys: + - "has_violation": bool, if any of the batch has precision issue + - "percent_violating": float, percentage of the batch that has precision issue + - "mean_violation_q": float, the mean q value calculated for the batch that has precision issue + (should be close to q) + - "total_weight_of_violations": tensor or None, the total weight of the items in the batch with issues. """ dtype = dist_dtype(dist) - finfo = torch.finfo(dtype) - tiny = torch.tensor(finfo.tiny, dtype=dtype) - eps = torch.tensor(finfo.eps, dtype=dtype) - - # See unit test visualisation for whne a q between tiny and eps can't be used directly - return (dist.icdf(tiny) + dist.icdf(eps)) / 2 + q_expected = torch.tensor(q, dtype=dtype) + # Appears to always produce x value inside the supported q range (even with numeric issues). Assume this is the + # case, and if not we will get an error and can update. + x_value = dist.icdf(q_expected) + q_actual = dist.cdf(x_value) + + # As value is between (0,1), should be correct with eps/2, but allow some small buffer + bound_violation_mask = ~torch.isclose(q_actual, q_expected, atol=torch.finfo(dtype).eps, rtol=0.0) + + percent_violating = bound_violation_mask.to(torch.float).mean().item() + mean_violation_q = q_actual[bound_violation_mask].mean().item() + + total_weight_of_violations = None + if weights is not None: + weights_expanded: torch.Tensor = weights.clone().expand_as(q_actual) # expand if required + total_weight_of_violations = weights_expanded[bound_violation_mask].sum(dim=-1) + + return { + "has_violation": bound_violation_mask.any().item(), + "percent_violating": percent_violating, + "mean_violation_q": mean_violation_q, + "total_weight_of_violations": total_weight_of_violations, + } @staticmethod - def _upper_bound_x(dist: Distribution) -> torch.Tensor: - """Returns the x upperbound for each of the component distributions. - - If :math:`cdf(x)` recieves values that are too large, it throws an error. We instead find a suitable upper bound - and later clip the x values to this range. The upper bound should: - - - Not throw an error when it is used in :math:`cdf(upperbound)`. - - As per "Approximation principles" it should not result in overestimates of the analytical cdf. + def calculate_x_bounds( + dist: Distribution, + q_upperbound: float, + q_lowerbound: float, + weights: torch.Tensor | None = None, + ) -> tuple[torch.Tensor, torch.Tensor]: + """Check the dtype has suitable numeric precision to represent the bound with the required precision. + + We store the x bounds associated with quantile bounds. We need to ensure we have enough numerical precision to + store these bounds accurately. This can often fail if location and scale have very different values. + + Example: + ```python + finfo32 = torch.finfo(torch.float32) + dist = Gumbel(loc=torch.tensor(25000, dtype=torch.float32), scale=torch.tensor(1e-6, dtype=torch.float32)) + top_eps_quantile = dist.icdf(torch.tensor(1 - finfo32.eps)) + print(top_eps_quantile.item()) # 25000.0 + # Problem: top_eps_quantile can't be represented with enough accuracy + print(dist.cdf(top_eps_quantile).item()) # -> .3678 not 1-finfo.eps + ``` + Note: + Potential fixes for this issues include: + - Use a higher precision dtype + - Reduce the magnitude of difference between location and scale (failure is not significantly effected by q) Args: - dist: The component distribution. - - Return: - Tensor of shape (``dist.batch_shape``). + dist: The distribution with batch_shape (*b) + q_upperbound: The upper quantile bound to check (e.g 1-finfo.eps) + q_lowerbound: The lower quantile bound to check (e.g finfo.eps) + weights: (shape (*b,)) The weights of each distribution in the mixture (if applicable). - Details: - TransformedDistribution are officially bounded btween ``(finfo.tiny, 1 - finfo.eps)``. There do not appear - to be issues using :math:`cdf(x)` for x values corresponding to slighly larger than ``1-finfo.eps``. These - produce values up to 1. + Returns: + Upper and lower x bounds corresponding to the given quantiles (shape (*b,)). - NOTE: IF we can confirm distribution behaviour is safe outside of the offical bounds specified on the - distribution (``1-finfo.eps``) this value could be increased. Currently we underestimates any value outside - ``1-finfo.eps`` as we are unsure of the behaviour within the range ``[1-finfo.eps, 1]``.As per - "Approximation principles" this is acceptable. + Dev notes: + - This issue is partly remedied in `cdf` because values that are outside x_bounds have results calculated + manually (not useing the cdf function). For example for the upper bound, the exact location of the x_bounds is + not correct, but values above this bound will return cdf(x)=1-eps (rather than e.g. .3678) """ - dtype = dist_dtype(dist) - finfo = torch.finfo(dtype) - eps = torch.tensor(finfo.eps, dtype=dtype) + upper_bound_violation_statistics = ApproximateMixture._check_cdf_numeric_precision(dist, q_upperbound, weights) + lower_bound_violation_statistics = ApproximateMixture._check_cdf_numeric_precision(dist, q_lowerbound, weights) + + for bound_name, stats in [ + ("upper", upper_bound_violation_statistics), + ("lower", lower_bound_violation_statistics), + ]: + if stats["has_violation"]: + q_bound = q_upperbound if bound_name == "upper" else q_lowerbound + cdf_direction = "smaller" if bound_name == "upper" else "LARGER" + estimate_type = "more conservative" if bound_name == "upper" else "NON-conservative" + + msg = ( + f"Insufficient precision to represent {bound_name} bound ({estimate_type} result).\n" + f"When insufficient precision is used, the x_bound value associated with q_{bound_name}bound " + f"cannot be stored with enough precision, as a result cdf(x_bound)!=q_{bound_name}bound). " + f"cdf(x_bound) will produce a {cdf_direction} value than q_{bound_name}bound, which will " + f"lead to a {estimate_type} cdf estimate. See ApproximateMixture " + "`Approximation principles` for more details.\n" + "Possible fixes:\n" + " - Use a higher precision dtype\n" + " - Reduce the magnitude of difference between location and scale\n" + "Violation statistics:\n" + f"percent of batch violating: {stats['percent_violating']:.2f}%\n" + f"average result of cdf(x_bound) for violating batch (should be {q_bound}): " + f"{stats['mean_violation_q']:.2e}\n" + ) + + if weights is not None: + msg += f"total weight of violating batch: {stats['total_weight_of_violations']:.2e}\n" + + warnings.warn(msg, category=RuntimeWarning, stacklevel=1) - return dist.icdf(1 - eps) + dtype = dist_dtype(dist) + x_bound_lower = dist.icdf(torch.tensor(q_lowerbound, dtype=dtype)) + x_bound_upper = dist.icdf(torch.tensor(q_upperbound, dtype=dtype)) + return x_bound_lower, x_bound_upper def cdf(self, x: torch.Tensor) -> torch.Tensor: """Return the CDF. @@ -199,7 +273,7 @@ def cdf(self, x: torch.Tensor) -> torch.Tensor: Identical to MixtureSameFamily implementation except for clamping. Args: - x: Values to calcuate the CDF for. Must be broadcastable with the ``ApproximateMixture.batch_shape``. E.g + x: Values to calculate the CDF for. Must be broadcastable with the ``ApproximateMixture.batch_shape``. E.g - ``self.component_distribution.batch_shape = (2,5)`` (last dimension is the components that are combined to make a single Mixture distribution) @@ -216,14 +290,35 @@ def cdf(self, x: torch.Tensor) -> torch.Tensor: " This can lead to loss of precision." ) raise TypeError(msg) - - # Expected x already broadcasts to `self.batch_dimension`. - # Padding is added so x broadcasts to each of the component distributions that make up the mixture + x = x.clone() + # Expected x already broadcasts to `self.batch_dimension` (same as MixtureSameFamily) + # The final expanded x shape need to be (*b, component_dist.batch_shape, component_dist.event_shape) + # where masking will be done on out of bounds values across component_dist.batch_shape + x_batch_shape = x.shape[: -len(self.batch_shape)] if self.batch_shape != torch.Size([]) else x.shape + # resulting shape (*b, component_dist.batch_shape[:-1],1, component_dist.event_shape) x = self._pad(x) - clipped_x = torch.clamp(x, self.x_bound_lower, self.x_bound_upper) - cdf_x = self.component_distribution.cdf(clipped_x) - mix_prob = self.mixture_distribution.probs + # resulting shape + x = x.expand(x_batch_shape + self.component_distribution.batch_shape + self.component_distribution.event_shape) + # find where input is outside the allowed range + # bounds have shape (component_dist.batch_shape, component_dist.event_shape) + too_large_mask = x > self.x_bound_upper + too_small_mask = x < self.x_bound_lower + + # replace out of bounds values with a placeholder value + dummy_value = self.component_distribution.mean # shape (component_dist.batch_shape, component_dist.event_shape) + # Convert to x.dtype. Once .cdf() runs the output will conform to MixtureSameFamily (biggest dtype used) + dummy_value = dummy_value.to(x.dtype) + x = x.clone() + x[too_large_mask | too_small_mask] = dummy_value.expand_as(x)[too_large_mask | too_small_mask] + + cdf_x = self.component_distribution.cdf(x) + + # Manually replaces the result of the out of bound CDF calc (follow MixtureSafeFamily for dtype convention) + cdf_x[too_large_mask] = self.cdf_out_of_bounds_q[1].expand_as(x)[too_large_mask].to(cdf_x.dtype) + cdf_x[too_small_mask] = self.cdf_out_of_bounds_q[0].expand_as(x)[too_small_mask].to(cdf_x.dtype) + + mix_prob = self.mixture_distribution.probs # This is the approach found in torch. Can introduce small numerical errors, but we assume these are neglible. return torch.sum(cdf_x * mix_prob, dim=-1) @@ -305,4 +400,15 @@ def icdf_value_bounds(dist: MixtureSameFamily, q: torch.Tensor) -> torch.Tensor: lower_bound = values.min(dim=-1).values upper_bound = values.max(dim=-1).values + # Handle edge cases where the lower and upper bound are the same. + # NOTE: This only sets the starting bounds for optimisation, so its not an issue if the bounds are a little large. + identical = torch.isclose(lower_bound, upper_bound) + # If working with very small number eps with will comparatively large - but should still find correct result. + finfo_eps = torch.finfo(lower_bound.dtype).eps + # large numbers: a difference of eps will be truncated by numeric precision, so find a relative value + # Small number: Could use a value smaller than eps, but don't bother + offset = (lower_bound.abs() * finfo_eps * 10).clamp(min=finfo_eps) + lower_bound = torch.where(identical, lower_bound - offset, lower_bound) + upper_bound = torch.where(identical, upper_bound + offset, upper_bound) + return torch.stack([lower_bound, upper_bound]) diff --git a/src/axtreme/evaluation.py b/src/axtreme/evaluation.py index e2d4a329..2b1b937f 100644 --- a/src/axtreme/evaluation.py +++ b/src/axtreme/evaluation.py @@ -7,7 +7,7 @@ from scipy.stats import rv_continuous from axtreme.simulator import Simulator -from axtreme.utils import distibution_helpers +from axtreme.utils import distribution_helpers # QUESTION: is this the right place for this? @@ -177,10 +177,10 @@ def post_process_simulation_output(self, y: np.ndarray[tuple[int], np.dtype[np.f """ # NOTE: the order/index matches that returned by rv_continous.fit # This can be explicity collected by using distribution_parameter_names_from_scipy(rv_continous) - param_means, cov = distibution_helpers.fit_dist_with_uncertainty(y, self.output_dist) + param_means, cov = distribution_helpers.fit_dist_with_uncertainty(y, self.output_dist) # TODO(sw): Will need to change when we look at correlated output becuase will need to look at the covariances # Will address this once we know what the correlated GP requires as input and output - param_names = distibution_helpers.distribution_parameter_names_from_scipy(self.output_dist) + param_names = distribution_helpers.distribution_parameter_names_from_scipy(self.output_dist) return SimulationPointResults(metric_names=param_names, means=param_means, cov=cov) diff --git a/src/axtreme/experiment.py b/src/axtreme/experiment.py index a7fe0abd..fb9feb0f 100644 --- a/src/axtreme/experiment.py +++ b/src/axtreme/experiment.py @@ -17,7 +17,7 @@ from axtreme.metrics import LocalMetadataMetric from axtreme.runner import LocalMetadataRunner from axtreme.simulator import Simulator -from axtreme.utils.distibution_helpers import distribution_parameter_names_from_scipy +from axtreme.utils.distribution_helpers import distribution_parameter_names_from_scipy def make_experiment( diff --git a/src/axtreme/qoi/marginal_cdf_extrapolation.py b/src/axtreme/qoi/marginal_cdf_extrapolation.py index daf9266f..97ceb798 100644 --- a/src/axtreme/qoi/marginal_cdf_extrapolation.py +++ b/src/axtreme/qoi/marginal_cdf_extrapolation.py @@ -2,6 +2,7 @@ # pyright: reportUnnecessaryTypeIgnoreComment=false # %% +import inspect import warnings from collections.abc import Iterable from contextlib import ExitStack @@ -125,38 +126,23 @@ def __call__(self, model: Model) -> torch.Tensor: torch.Tensor: A tensor, with shape (n_posterior_samples,), of the estimated QoI for each of the functions sampled from the GP using the posterior sampler. """ - # resulting shape is (n_posterior_samples, n_env_samples, n_targets) and _posterior_samples, n_env_samples) - params, weigths = self._parameter_estimates(model) + # resulting shape is (n_posterior_samples, n_env_samples, n_targets) and (n_posterior_samples, n_env_samples) + params, weights = self._parameter_estimates(model) - if params.dtype != self.dtype or weigths.dtype != self.dtype: + if params.dtype != self.dtype or weights.dtype != self.dtype: msg = ( - f"The model produced parameters of dtype {params.dtype} and weigths of dtype {weigths.dtype}." + f"The model produced parameters of dtype {params.dtype} and weights of dtype {weights.dtype}." f" This does not match the specified dtype {self.dtype}." " Parameters and weights will be converted to this dtype to create a suitable distribution." " NOTE: underlying parameters are still only accurate to float32 precision, this may effect overall" - " accuracy. Recommended make float64 preicitons with the model." + " accuracy. Recommended make float64 precisions with the model." ) warnings.warn(msg, stacklevel=8) - params, weigths = params.type(self.dtype), weigths.type(self.dtype) - - # Create the the marginal distribution for the parameters. The categorical distribution handles weights scaling - # resulting batch shape (n_posterior_samples) - if self.response_distribution is Gumbel: - assert issubclass(self.response_distribution, Gumbel) # help mypy determine the type - loc = params[..., 0] - scale = params[..., 1].clamp(min=1e-6) # Ensure scale is positive - component_dist = self.response_distribution(loc, scale) - else: - # To support other distribution need to to apply parameter constraints (list on the distribution), to the - # the input params. Additionally need to know the order (name) of params in params. - raise NotImplementedError("Only Gumbel distributions are currently supported.") - - # ApproximateMixture is appropriate becuase it produces conservative estimate. The optimisation method - # later check that the dist has suitable resolution for the required accuracy. - dist = ApproximateMixture( - mixture_distribution=Categorical(weigths), - component_distribution=component_dist, + params, weights = params.type(self.dtype), weights.type(self.dtype) + + dist, _ = _mixture_distribution_from_importance_samples( + weights, params, component_dist_class=self.response_distribution ) # determine the timestep quantile to be found, and the acceptable margin of error @@ -165,6 +151,18 @@ def __call__(self, model: Model) -> torch.Tensor: # calculated the icdf values qtimestep = torch.tensor(_qtimestep, dtype=torch.float64) + + # Check that the quantile searching for in not in the degenerate distribution added + # TODO(sw 2026-4-12): this assume event dim (,). + # TODO(sw 2026-4-12): Look for a more elegant way to handle this + if (dist.mixture_distribution.probs[..., -1] > qtimestep).any(): + msg = ( + "The quantile being searched for is in the degenerate distribution added. This will give incorrect" + " results as because the degenerate distribution is only intended to add baseline mass, and its " + " location is meaningless. Consider the quantile being searched for, and the importance bounds used." + ) + raise RuntimeError(msg) + opt_bounds = icdf_value_bounds(dist, qtimestep) qois = icdf.icdf(dist, qtimestep, max_qtimestep_error, opt_bounds) # TODO(sw 2024-12-16): Gradient should be reattached here. @@ -173,8 +171,8 @@ def __call__(self, model: Model) -> torch.Tensor: def _parameter_estimates(self, model: Model) -> tuple[torch.Tensor, torch.Tensor]: """Estimate the parameters of the individual distributions the make up the marginal distribution. - Estimate the parameters of the component distribtuions (individual distribution that will later be marginalised) - , and the associated mixure weights (importance weight of each of the samples in the marginalisation). + Estimate the parameters of the component distributions (individual distribution that will later be marginalised) + , and the associated mixture weights (importance weight of each of the samples in the marginalisation). Args: model: The GP model to use for the QOI estimation. The number of output distributions should match that @@ -192,10 +190,9 @@ def _parameter_estimates(self, model: Model) -> tuple[torch.Tensor, torch.Tensor # Adding context to the stack according to the configuration if self.no_grad: stack.enter_context(torch.no_grad()) - # Unclear the impact of this sett, but accoring the this shouldn't have downside. https://arxiv.org/abs/1803.06058 + # Unclear the impact of this setting, but according to this it shouldn't have downside. https://arxiv.org/abs/1803.06058 stack.enter_context(gpytorch.settings.fast_pred_var()) - # make sure transforms are on the right device. if self.input_transform: assert isinstance(self.input_transform, Module) self.input_transform = self.input_transform.to(self.device) @@ -254,6 +251,188 @@ def _parameter_estimates(self, model: Model) -> tuple[torch.Tensor, torch.Tensor return posterior_samples, importance_weights +def _mixture_distribution_from_importance_samples( + weights: torch.Tensor, + params: torch.Tensor, + component_dist_class: type[Distribution], + lower_bound: float | None = None, +) -> tuple[ApproximateMixture, torch.Tensor]: + """Creates a mixture distribution from importance samples using special assumptions to relax sampling constraints. + + Importance sampling that is unique to marginalising CDFs. Often there are regions where the random variable the CDF + describes can be assumed to be 0. Using this assumption, we can relax the requirements on the importance sampling + distribution q(x) and allow it to exclude these regions. This allows: + - more efficient importance sampling + - (when distribution params are selected using a GP) avoid surrogate fitting step function at operation boundaries. + + Background: + Assuming importance sampling is defined as: + + E_p[f(x)] = E_q[f(x) * p(x)/q(x)] + + Where: + - f(x) is the function being evaluated (when marginalising CDFs, f(x) = CDF(r|x)). + - p(x) is the true distribution. + - q(x) is the importance distribution. + + Assumption of standard importance sampling: + - q(x) = 0 -> f(x)*p(x) = 0 + + Assumption for this importance sampling approach. + - q(x) = 0 -> f(x) = 1 OR p(x) = 0 # TODO: check if the second part holds. + - In other words: supp(q(x)) can be a subset of supp(p(x)), as long as f(x) = 1 outside of supp(q(x)). + + For details of method see TODO(sw 2026-04-07): put link to the write up, and later to pre-print. + + Args: + weights: importance weights associated with each sample. + shape: (*b, n_env_samples) + params: parameters of the distribution associated with each weight. + shape: (*b, n_env_samples, n_params) where n_params are the parameters to construct the distribution, in the + same order as the `component_dist_class` constructor. + component_dist_class: the distribution class which the params can be used to construct a distribution. + lower_bound: If a lower bound for the distribution is known it can be provided so the correction factor (for + region outside supp(q)) is applied before this point. + + Returns: + A tuple of: + - mixture distribution representing the marginal. Will have `batch_shape` of (*b) + - tensor of standard errors (shape (*b,)). + - This is the standard error associate with estimating the mass of p(x) in the region not covered by supp(q). + - This gives a confidence interval of how wrong icdf estimate could be wrong due to the estimation. + - The error introduced by the estimate in the region covered by supp(q) is NOT captured in this. + + Todo: + - Thing to add to the explanatory note: + - after the meths have s section about the approximation (e.g why value should never exceed 1, what to do in + that case.) + """ + # NOTE: currently only support distributions parameterised by loc and scale currently because know how to produce + # degenerate dist for this. + dist_args = inspect.signature(component_dist_class).parameters + if set(dist_args.keys()) != {"loc", "scale", "validate_args"}: + msg = ( + "Currently only distribution parameterised with {'loc', 'scale', 'validate_args'} are supported. ", + f"Got: {set(dist_args.keys())}", + ) + raise NotImplementedError(msg) + # loc and scale provided could be any values, do minimum to enforce distribution bounds + loc = params[..., 0] + # Ensure scale is positive and make sure it is large enough to avoid numeric issues (ApproximateMixture for details) + scale = params[..., 1].clamp(min=abs(loc) * torch.finfo(params.dtype).eps * 100) + params = torch.concat([loc.unsqueeze(-1), scale.unsqueeze(-1)], dim=-1) + + # Calculate the correction factor for missing mass as per XXX TODO(sw 2026-04-07): Put link to note explaining. + integral_p_over_q_est = torch.mean(weights, dim=-1, keepdim=True) + integral_p_over_q_var = torch.var(weights, dim=-1, keepdim=True) / weights.shape[-1] + integral_p_over_q_std_err = integral_p_over_q_var.sqrt() + + if (integral_p_over_q_est > 1).any(): + msg = ( + "Some batches in weighs have average which exceeds 1, values will be clipped to 1. This means the " + "importance sampling estimate of p(x) over supp(q) is exceeds 1, which is not possible a p(x) is " + "probability distribution. Small violation with large number of sample is okay. Large violation indicate " + "importance sampling weights should be investigated." + f"\nAverage weights per batch {integral_p_over_q_est}\n" + f"batch standard error {integral_p_over_q_std_err}" + ) + warnings.warn(msg, stacklevel=1) + # We know weights must be too big, so should re-weight. Clamping ends up being equivalent to re-weighting the + # weights to sum to 1.(integral_p_over_not_q=0, and ApproximateMixture distribution automatically make + # sum(weights) = 1). + integral_p_over_q_est = integral_p_over_q_est.clamp(max=1) + + integral_p_over_not_q = 1 - integral_p_over_q_est + weights_n = weights / weights.shape[-1] + + # Create a degenerate dist which contributes all its cdf mass because any contributions from component dist + component_dist_uncorrected = component_dist_class(*torch.unbind(params, dim=-1)) + # Output shape: (*b, n_params) + correction_params = _create_lowerbound_degenerate_distribution_params( + component_dist_uncorrected, lower_bound=lower_bound + ) + + # append the weight and degenerate params to the existing weights and params + updated_weights = torch.concat([weights_n, integral_p_over_not_q], dim=-1) + updated_params = torch.concat( + [ + params, # shape (*b, n_env_samples, n_params) + correction_params.unsqueeze(-2), # shape (*b, 1, n_params) + ], + dim=-2, + ) + + dist = ApproximateMixture( + mixture_distribution=Categorical(updated_weights), + component_distribution=component_dist_class(*torch.unbind(updated_params, dim=-1)), + ) + + return dist, integral_p_over_q_std_err + + +# %% +def _create_lowerbound_degenerate_distribution_params( + component_dist: Distribution, lower_bound: float | None = None +) -> torch.Tensor: + """Pick the parameters to produce the degenerate distribution at lowerbound of component dist. + + Picks the parameters to create a degenerate distribution which represents the missing mass as per XXX + TODO(sw 2026-04-07): Put link to note explaining. This distribution should add all its mass prior to any other + component distribution adding mass. + + Args: + component_dist: The component distribution to generate the parameters for. + The last dimension of the batch shape will be aggregated across to make the mixture dist. + lower_bound: + - None: the degenerate distribution is placed just before any distribution on the component dist starts + adding mass. + - Benefits: This is tight and robust (will always give correct optimisation results). + - Cons: Placing this mass before the input domain starts would be more conceptually representative. + - Value: The lowerbound of the input domain. + - Benefits: Distribution better represent conceptual problem + + Returns: + A tensor of parameters with shape (*component_dist.batch_shape[:-1], n_params) + - n_params is the number of parameters required to construct the distribution. + """ + # Only know how to handle loc and scale for the time being + dist_args = inspect.signature(component_dist.__init__).parameters + if set(dist_args.keys()) != {"loc", "scale", "validate_args"}: + msg = ( + "Currently only distribution parameterised with {'loc', 'scale', 'validate_args'} are supported. ", + f"Got: {set(dist_args.keys())}", + ) + raise NotImplementedError(msg) + dtype = component_dist.loc.dtype # pyright: ignore[reportAttributeAccessIssue] + + # Find the lowest point where mass is added to the cdf. + # NOTE: torch.finfo(dtype).eps based on the lower bound in ApproximateMixture) + lower = component_dist.icdf(torch.finfo(dtype).eps) + # aggregate across the same dimension as the mixture dist + lower = lower.min(dim=-1).values + + if lower_bound is not None: + if (lower_bound > lower).any(): + msg = ( + f"lower_bound provided {lower_bound} is larger than some of the component distribution lower" + f"bounds {lower.min()}. lower_bound must be greater" + ) + raise ValueError(msg) + + lower = torch.ones_like(lower) * lower_bound + + # degenerate distribution needs to have finished adding mass by this point. + # Pick a scale and check the offset required to the dist to be finished. + scale = lower.abs() * torch.finfo(dtype).eps * 100 # 100 is some buffer + temp_dist = type(component_dist)(loc=0, scale=scale) + # offset for the centered distribution to be finish + x_offset = temp_dist.icdf(1 - torch.finfo(dtype).eps) + loc = lower - x_offset + + params = torch.concat([loc.unsqueeze(-1), scale.unsqueeze(-1)], dim=-1) + return params + + def q_to_qtimestep(q: float, period_len: int) -> float: """Convert a long term quantile to an equivalent single timestep quantile. @@ -265,8 +444,8 @@ def q_to_qtimestep(q: float, period_len: int) -> float: The equivalent quantile for a single timestep with error +- Note: - This funciton exists because there were numerical concerns for this process. Having a function allows us to - document them in tests. It is appropriately accuract for very large periods. Periods of 1e13 creates an error of + This function exists because there were numerical concerns for this process. Having a function allows us to + document them in tests. It is appropriately accurate for very large periods. Periods of 1e13 creates an error of less that 1e-3 in q (the full quantile estimate). See `test/qoi/test_margianl_cdf_extpolation/test_q_to_qtimestep_numerical_precision_period_increase` for details. """ diff --git a/src/axtreme/utils/__init__.py b/src/axtreme/utils/__init__.py index 9bcc8af2..01cd55ff 100644 --- a/src/axtreme/utils/__init__.py +++ b/src/axtreme/utils/__init__.py @@ -1,7 +1,7 @@ """Utilities for axtreme.""" from axtreme.utils import ( - distibution_helpers, + distribution_helpers, modelbridge_utils, transforms, ) diff --git a/src/axtreme/utils/distibution_helpers.py b/src/axtreme/utils/distribution_helpers.py similarity index 100% rename from src/axtreme/utils/distibution_helpers.py rename to src/axtreme/utils/distribution_helpers.py diff --git a/tests/distributions/test_mixture.py b/tests/distributions/test_mixture.py index e4a7951a..b3ada8d2 100644 --- a/tests/distributions/test_mixture.py +++ b/tests/distributions/test_mixture.py @@ -1,3 +1,4 @@ +# %% import matplotlib.pyplot as plt import pytest import torch @@ -46,9 +47,18 @@ class TestApproximateMixture: # TODO(sw 2024-12-14): Test more distributions @pytest.mark.parametrize("dtype", [torch.float32, torch.float64]) @pytest.mark.parametrize("dist_class", [Gumbel, LogNormal]) - def test_lower_bound_x(self, dtype: torch.dtype, dist_class: type[Distribution], *, visualise: bool = False): # noqa: PT028 - """Fnd bounds that do not throw error and produce 0.""" - dist = dist_class(torch.tensor(0, dtype=dtype), 1) # type: ignore # noqa: PGH003 + def test_show_lower_bound_x_issue( + self, + dtype: torch.dtype, + dist_class: type[Distribution], + *, + visualise: bool = False, # noqa: PT028 + ): + """Mostly to demo behaviour that happens between q = [finfo.tiny, finfo.eps]. + + Test fails if the lower bound is changed so developer will be made aware of the issues + """ + dist = dist_class(torch.tensor([0], dtype=dtype), torch.tensor([1], dtype=dtype)) # type: ignore # noqa: PGH003 if visualise: # visualise the reverse relationship: @@ -61,6 +71,7 @@ def test_lower_bound_x(self, dtype: torch.dtype, dist_class: type[Distribution], icdfs = dist.icdf(qs) _ = plt.axvline(finfo.eps, color="red", label="eps") + _ = plt.axvline(finfo.tiny, color="blue", label="tiny") _ = plt.scatter(qs, icdfs, label="icdf(x) -> q") _ = plt.ylabel("x (icdf(q)-> x)") _ = plt.xlabel("q ") @@ -69,20 +80,32 @@ def test_lower_bound_x(self, dtype: torch.dtype, dist_class: type[Distribution], _ = plt.legend() plt.pause(5) - lower_bound_x = ApproximateMixture._lower_bound_x(dist) + xs = icdfs + q = dist.cdf(xs) + _ = plt.scatter(xs, q) + _ = plt.yscale("log") + _ = plt.ylim(finfo.tiny, 5e-5) + _ = plt.ylabel("q") + _ = plt.xlabel("x ") + _ = plt.title("CDF: cdf(x)->q") + _ = plt.axhline(finfo.eps, color="red", label="eps") + _ = plt.axhline(finfo.tiny, color="blue", label="tiny") + plt.pause(5) - assert dist.cdf(lower_bound_x) == 0 + mixture_dist = ApproximateMixture(Categorical(probs=torch.tensor([1], dtype=dtype)), dist) + assert mixture_dist.quantile_bounds[0] == pytest.approx(torch.finfo(dtype).eps) @pytest.mark.parametrize("dtype", [torch.float32, torch.float64]) @pytest.mark.parametrize("dist_class", [Gumbel, LogNormal]) def test_upper_bound_x(self, dtype: torch.dtype, dist_class: type[Distribution], *, visualise: bool = False): # noqa: PT028 - dist = dist_class(torch.tensor(0, dtype=dtype), 1) # type: ignore # noqa: PGH003 + """Mostly to demo behaviour that happens between q = [1 - finfo.eps, 1].""" + dist = dist_class(torch.tensor([0], dtype=dtype), torch.tensor([1], dtype=dtype)) # type: ignore # noqa: PGH003 if visualise: finfo = torch.finfo(dtype) max_x = dist.icdf(torch.tensor(1 - finfo.eps, dtype=dtype)) - # NOTE: these bounds may beed to be adjsuted for different dists - x = torch.linspace(max_x - 1, max_x + 0.5, 1000, dtype=torch.float32) + # NOTE: these bounds may need to be adjusted for different dists + x = torch.linspace(max_x - 1, max_x + 0.5, 1000, dtype=dtype) cdfs = dist.cdf(x) _ = plt.axhline(1 - finfo.eps, color="red", label="eps") @@ -94,13 +117,50 @@ def test_upper_bound_x(self, dtype: torch.dtype, dist_class: type[Distribution], _ = plt.legend() plt.pause(5) - upper_bound_x = ApproximateMixture._upper_bound_x(dist) + mixture_dist = ApproximateMixture(Categorical(probs=torch.ones(1, dtype=dtype)), dist) + assert mixture_dist.quantile_bounds[1] == pytest.approx(1 - torch.finfo(dtype).eps) + + @pytest.mark.parametrize( + "component_distribution_shape, input_shape", + [ + # unbatched mixture, unbatched input + (torch.Size([3]), torch.Size([1])), + # batched mixture, unbatched input + (torch.Size([5, 3]), torch.Size([1])), + # unbatched mixture, unbatched input + (torch.Size([3]), torch.Size([7, 1])), + # batched mixture, batched input + (torch.Size([5, 3]), torch.Size([7, 5])), + # larger_batch_mixture + (torch.Size([10, 5, 3]), torch.Size([7, 10, 1])), + ], + ) + def test_cdf_shape_equivalent_to_mixture(self, component_distribution_shape: torch.Size, input_shape: torch.Size): + """Check the input and output shape behaves the same way as MixtureSameFamily. + + TODO: + - Test distribution with ``.event_shape!=torch.Size([])`` + """ + x = torch.rand(input_shape) + + loc = torch.zeros(component_distribution_shape) + scale = torch.ones(component_distribution_shape) + + dist = Gumbel(loc, scale) + mix = Categorical(torch.ones(component_distribution_shape)) + + approx_mixture = ApproximateMixture(mix, dist) + mixture = MixtureSameFamily(mix, dist) - assert dist.cdf(upper_bound_x) == 1 - torch.finfo(dtype).eps + # Run through both of the methods. + actual_value = approx_mixture.cdf(x) + expected_value = mixture.cdf(x) + + assert actual_value.shape == expected_value.shape # Nothing interesting should happen with different shapes, just checking that here. @pytest.mark.parametrize( - "shape", + "component_distribution_shape", [ # Unbatch mixture distribution, with only a single component torch.Size([1]), @@ -122,7 +182,9 @@ def test_upper_bound_x(self, dtype: torch.dtype, dist_class: type[Distribution], ), ], ) - def test_equivalent_to_mixturesamefamily_within_range(self, shape: torch.Size, q: float, dtype: torch.dtype): + def test_cdf_equivalent_to_mixturesamefamily_within_range( + self, component_distribution_shape: torch.Size, q: float, dtype: torch.dtype + ): """ApproximateMixture and MixtureSameFamily should have identical behaviour within the component range. Within the range the component distribution supports, behaviour should be identical. @@ -139,25 +201,75 @@ def test_equivalent_to_mixturesamefamily_within_range(self, shape: torch.Size, q - And the input is the in the range - The output should be identical """ - # Create the x value wich represents that quantile. The gumbel here matches the one we use as dist. + # Create the x value which represents that quantile. The gumbel here matches the one we use as dist. # This has shape (1,) which can be broadcast in the CDF step to any underlying distribution x = Gumbel(loc=torch.zeros(1, dtype=dtype), scale=1).icdf(q) - loc = torch.zeros(shape, dtype=dtype) - scale = torch.ones(shape, dtype=dtype) + loc = torch.zeros(component_distribution_shape, dtype=dtype) + scale = torch.ones(component_distribution_shape, dtype=dtype) dist = Gumbel(loc, scale) - mix = Categorical(torch.ones(shape, dtype=dtype)) + mix = Categorical(torch.ones(component_distribution_shape, dtype=dtype)) approx_mixture = ApproximateMixture(mix, dist) mixture = MixtureSameFamily(mix, dist) - # Run through bothe of the methods. + # Run through both of the methods. actual_value = approx_mixture.cdf(x) expected_value = mixture.cdf(x) assert torch.allclose(actual_value, expected_value) + @pytest.mark.parametrize( + "loc, scale, q, dtype, expect_violation", + [ + # ## Standard case: loc and scale are close and this can be represented numerically + (1, 1, 1 - torch.finfo(torch.float32).eps, torch.float32, False), + (1, 1, 0.5, torch.float32, False), + (1, 1, torch.finfo(torch.float32).eps, torch.float32, False), + # Real failure: float32 can reliabilty represent the first 7 digits. For this problem would need 11+ digits + (25_000, 1e-6, 1 - torch.finfo(torch.float32).eps, torch.float32, True), + (25_000, 1e-6, 0.5, torch.float32, True), + (25_000, 1e-6, torch.finfo(torch.float32).eps, torch.float32, True), + # float64 is precise to 15 places. + (25_000, 1e-6, 1 - torch.finfo(torch.float64).eps, torch.float64, False), + # Float64: 10 digits for loc, 6 for scale -> leads to failure + (25_000 * 10e5, 1e-6, 1 - torch.finfo(torch.float64).eps, torch.float64, True), + ], + ) + def test_check_cdf_numeric_precision( + self, + loc: float, + scale: float, + q: float, + dtype: torch.dtype, + expect_violation: bool, # noqa: FBT001 + ): + """Test can detect when don't have the precision to represent the bounds needed.""" + dist = Gumbel(loc=torch.tensor([loc], dtype=dtype), scale=torch.tensor([scale], dtype=dtype)) + results = ApproximateMixture._check_cdf_numeric_precision(dist, q) + assert results["has_violation"] == expect_violation + + # @pytest.mark.parametrize( + # "x,expected_q", + # [ + # # above bounds + # (100_000, 1 - torch.finfo(torch.float32).eps), + # # below bounds + # (-100_000, 0), + # ], + # ) + # def test_cdf_value_outside_bounds(self, x: float, expected_q: float): + # dtype = torch.float32 + # loc = torch.tensor([1], dtype=dtype) + # component_dist = Gumbel(loc=loc, scale=1) + # mixture_dist = Categorical(probs=torch.ones_like(loc)) + + # dist = ApproximateMixture(mixture_dist, component_dist) + # x_tensor = torch.tensor([x], dtype=dtype) + # cdf_value = dist.cdf(x_tensor) + # assert cdf_value == pytest.approx(expected_q) + @pytest.mark.integration # Relies on `dist_cdf_resolution` otherwise not really an integration test. @pytest.mark.parametrize("dtype", [torch.float32, torch.float64]) def test_cdf_outside_of_component_range_single_component(self, dtype: torch.dtype): @@ -167,7 +279,7 @@ def test_cdf_outside_of_component_range_single_component(self, dtype: torch.dtyp weighted sum. As such finner grain tests of output can be performed. The test demonstrates the following: - The cdf does not fail for extremely larges of small inputs. - - It produces the expected quantils for these results (up to the accuracy specifed by `dist_cdf_resolution`) + - It produces the expected quantiles for these results (up to `dist_cdf_resolution` accuracy). """ loc = torch.tensor([0.0], dtype=dtype) scale = torch.ones_like(loc, dtype=dtype) @@ -326,6 +438,40 @@ def test_cdf_input_should_have_float64_dtype(self): # difference is 5.45e-10 torch.testing.assert_close(q_32, q_64, atol=1e-10, rtol=0) + def test_calculate_x_bounds_returns_correct_values(self): + """calculate_x_bounds should return dist.icdf(q_lowerbound) and dist.icdf(q_upperbound).""" + dtype = torch.float64 + finfo = torch.finfo(dtype) + q_lower = finfo.eps + q_upper = 1 - finfo.eps + + loc = torch.tensor([0.0], dtype=dtype) + scale = torch.ones_like(loc) + dist = Gumbel(loc, scale) + + x_lower, x_upper = ApproximateMixture.calculate_x_bounds(dist, q_upperbound=q_upper, q_lowerbound=q_lower) + + torch.testing.assert_close(x_lower, dist.icdf(torch.tensor(q_lower, dtype=dtype))) + torch.testing.assert_close(x_upper, dist.icdf(torch.tensor(q_upper, dtype=dtype))) + + def test_calculate_x_bounds_warns_on_precision_violation(self): + """calculate_x_bounds should emit a RuntimeWarning when the dtype lacks precision to represent the bounds. + + Uses loc=25_000, scale=1e-6 with float32 — a case proven to trigger violations in + _check_cdf_numeric_precision (both upper and lower bounds). + """ + dtype = torch.float32 + finfo = torch.finfo(dtype) + q_lower = finfo.eps + q_upper = 1 - finfo.eps + + loc = torch.tensor([25_000.0], dtype=dtype) + scale = torch.tensor([1e-6], dtype=dtype) + dist = Gumbel(loc, scale) + + with pytest.warns(RuntimeWarning, match="Insufficient precision"): + ApproximateMixture.calculate_x_bounds(dist, q_upperbound=q_upper, q_lowerbound=q_lower) + @pytest.mark.parametrize( "q, bounds1, bounds2", @@ -333,14 +479,14 @@ def test_cdf_input_should_have_float64_dtype(self): # a simple q applied to each mixture model ( torch.tensor(0.5), - # This are known upfront becuase of the loc and scale specifiec in the test + # This are known upfront because of the loc and scale specified in the test (Gumbel(0, 1).icdf(0.5), Gumbel(1, 1).icdf(0.5)), # expected bound for 1s mixture model (Gumbel(1, 1).icdf(0.5), Gumbel(2, 1).icdf(0.5)), # expected bound for 2nd mixture model ), - # Minture model specific quantiles + # Mixture model specific quantiles ( torch.tensor([0.5, 0.9]), - # This are known upfront becuase of the loc and scale specifiec in the test + # This are known upfront because of the loc and scale specified in the test (Gumbel(0, 1).icdf(0.5), Gumbel(1, 1).icdf(0.5)), # expected bound for 1s mixture model (Gumbel(1, 1).icdf(0.9), Gumbel(2, 1).icdf(0.9)), # expected bound for 2nd mixture model ), @@ -354,7 +500,7 @@ def test_icdf_value_bounds(q: torch.Tensor, bounds1: tuple[float, float], bounds NOTE: Bounds are specified verbosely in areguments to make it clearer where they come from. Could simplfy this to just a tensor of bounds. """ - # Set to the require compoents + # Set to the require components # fmt: off loc = torch.tensor([[0.0, 1.,], [1.0, 2.,]], dtype=torch.float64) # fmt: on @@ -371,3 +517,34 @@ def test_icdf_value_bounds(q: torch.Tensor, bounds1: tuple[float, float], bounds torch.testing.assert_close(actual_bouds1, torch.tensor(bounds1), atol=1e-5, rtol=0) actual_bouds2 = bounds[:, 1] torch.testing.assert_close(actual_bouds2, torch.tensor(bounds2), atol=1e-5, rtol=0) + + +@pytest.mark.parametrize( + "loc", + [ + # Negative loc: check not using multiplication/division which will invert bounds. + -10.0, + # Near-zero loc: offset must not collapse to 0 + 0.0, + # Positive loc: sanity check that the fix doesn't break the normal case + 10.0, + # Large loc: check the offset is not + 1e12, + ], +) +def test_icdf_value_bounds_identical_components_lower_lt_upper(loc: float): + """Handles edge case of picking bounds when components all give identical icdf value (e.g. components are identical) + + Check that in all cases lower_bounc < upper_bound. + """ + q = torch.tensor(0.5) + identical_loc = torch.tensor([loc, loc], dtype=torch.float64) + scale = torch.ones_like(identical_loc) + comp = Gumbel(loc=identical_loc, scale=scale) + mix = Categorical(torch.ones_like(identical_loc, dtype=torch.float64)) + dist = MixtureSameFamily(mix, comp) + + bounds = icdf_value_bounds(dist, q) + lower, upper = bounds[0], bounds[1] + + assert lower < upper, f"Expected lower < upper for loc={loc}, got lower={lower}, upper={upper}" diff --git a/tests/qoi/data/importance_sampling/scripts/brute_force.py b/tests/qoi/data/importance_sampling/scripts/brute_force.py new file mode 100644 index 00000000..bd5d0839 --- /dev/null +++ b/tests/qoi/data/importance_sampling/scripts/brute_force.py @@ -0,0 +1,205 @@ +"""Obtain a brute force estimate of the Extreme Response Distribution (ERD). + +This script creates brute force ERD samples for the importance sampling test case. +It uses the simulator and environment distribution defined in the sibling scripts. + +The environment distribution is ``MultivariateNormal(mean=[0.1, 0.1], cov=0.2*I)`` +truncated to positive values. The response follows a Gumbel distribution with loc and +scale determined by ``_true_underlying_func`` from ``simulator.py``. + +Usage:: + + python brute_force.py + +Output: + ``tests/qoi/data/importance_sampling/brute_force_solution.json`` +""" + +# pyright: reportUnnecessaryTypeIgnoreComment=false + +# %% +import json +from dataclasses import asdict, dataclass +from pathlib import Path +from typing import Any + +import matplotlib.pyplot as plt +import numpy as np +import torch +import tqdm +from numpy.typing import NDArray +from scipy.stats import gumbel_r +from torch.utils.data import DataLoader, RandomSampler, TensorDataset + +torch.set_default_dtype(torch.float64) + +# This allows us to run as interactive and as a module. +if __name__ == "__main__": + from simulator import _true_underlying_func # type: ignore[import-not-found] +else: + from .simulator import _true_underlying_func +# for typing +_: Any + +# %% +_results_dir: Path = Path(__file__).parent.parent +_results_file: Path = _results_dir / "brute_force_solution.json" + + +@dataclass +class ResultsObject: + """The results object saved (as json) after brute force is run.""" + + statistics: dict[str, float] + samples: list[float] + env_data: list[float] + + @classmethod + def from_samples(cls, samples: torch.Tensor, env_data: torch.Tensor) -> "ResultsObject": + """Create the object directly from samples.""" + statistics = {"median": float(samples.median()), "mean": float(samples.mean())} + return ResultsObject(statistics=statistics, samples=samples.tolist(), env_data=env_data.tolist()) + + +# %% +def collect_or_calculate_results(period_length: int, num_estimates: int = 2_000) -> tuple[torch.Tensor, torch.Tensor]: + """Return saved results if available, otherwise calculate, save, and return them. + + Args: + period_length: The number of environment samples per period of the ERD. + num_estimates: The number of brute force estimates of the QoI. A new period is drawn for each estimate. + + Returns: + Tuple of: + ERD samples: (num_estimates,) samples of the ERD for that period length. + X_max: (num_estimates, d) The environment location that produced the ERD sample. + """ + samples = torch.tensor([]) + max_location = torch.tensor([]) + + if _results_file.exists(): + with _results_file.open() as fp: + results = json.load(fp) + samples = torch.tensor(results["samples"]) + max_location = torch.tensor(results["env_data"]) + + # Make additional samples if required + if len(samples) < num_estimates: + new_samples, new_max_location = brute_force(period_length, num_estimates - len(samples)) + + samples = torch.concat([samples, new_samples]) + max_location = torch.concat([max_location, new_max_location]) + + # Save results + with _results_file.open("w") as fp: + json.dump(asdict(ResultsObject.from_samples(samples, max_location)), fp) + + elif len(samples) > num_estimates: + samples = samples[:num_estimates] + max_location = max_location[:num_estimates] + + return samples, max_location + + +def brute_force(period_length: int, num_estimates: int = 2_000) -> tuple[torch.Tensor, torch.Tensor]: + """Produce brute force samples of the Extreme Response Distribution. + + Args: + period_length: The number of environment samples per period of the ERD. + num_estimates: The number of brute force estimates of the QoI. A new period is drawn for each estimate. + + Returns: + Tuple of: + ERD samples: (num_estimates,) samples of the ERD for that period length. + X_max: (num_estimates, d) The environment location that produced the ERD sample. + """ + data: NDArray[np.float64] = np.load(_results_dir / "environment_distribution.npy") + dataset = TensorDataset(torch.Tensor(data)) + + dataloader = DataLoader( + dataset, + batch_size=4096, + sampler=RandomSampler(dataset, num_samples=period_length, replacement=True), + ) + + return _brute_force_calc(dataloader, num_estimates) + + +def _brute_force_calc( + dataloader: DataLoader[tuple[torch.Tensor, ...]], num_estimates: int = 2_000 +) -> tuple[torch.Tensor, torch.Tensor]: + """Calculate the QOI by brute force. + + Args: + dataloader: The dataloader providing environment samples. + - Each batch should have shape (batch_size, d) + - The sum of the batch sizes returned by iterating through the dataloader should be a period length. + - To get different results for each estimate, use e.g. a RandomSampler. + num_estimates: The number of brute force estimates of the QoI. + + Returns: + Tuple of: + ERD samples: (num_estimates,) samples of the ERD for that period length. + X_max: (num_estimates, d) The environment location that produced the ERD sample. + """ + maxs = torch.zeros(num_estimates) + + _, d = next(iter(dataloader))[0].shape + maxs_location = torch.zeros(num_estimates, d) + + for i in tqdm.tqdm(range(num_estimates)): + current_max = float("-inf") + + for batch in dataloader: + x = batch[0] + params = _true_underlying_func(x) + loc = params[:, 0].numpy() + scale = params[:, 1].numpy() + + gumbel_samples: np.ndarray[tuple[int,], Any] = gumbel_r.rvs(loc=loc, scale=scale) # type: ignore # noqa: PGH003 + + simulator_samples_max = gumbel_samples.max() + if simulator_samples_max > current_max: + current_max = simulator_samples_max + + max_index = np.argmax(gumbel_samples) + maxs_location[i] = x[max_index, :] + + maxs[i] = current_max + + return maxs, maxs_location + + +# %% +if __name__ == "__main__": + # %% + N_ENV_SAMPLES_PER_PERIOD = 1000 + NUM_ESTIMATES = 100_000 + + samples, x_max = collect_or_calculate_results(N_ENV_SAMPLES_PER_PERIOD, NUM_ESTIMATES) + + print(f"ERD samples shape: {samples.shape}") + print(f"ERD median: {samples.median():.4f}") + print(f"X_max shape: {x_max.shape}") + + # %% + _ = plt.hist(samples, bins=100, density=True) + _ = plt.axvline(samples.median(), color="red", linestyle="--", label=f"Median: {samples.median():.4f}") + _ = plt.title( + f"Extreme response distribution\n" + f"(each result represents the largest value seen in a {N_ENV_SAMPLES_PER_PERIOD}-length period)" + ) + _ = plt.xlabel("Response size") + _ = plt.ylabel("Density") + _ = plt.legend() + plt.grid(True) # noqa: FBT003 + plt.show() + + # %% + _ = plt.scatter(x_max[:, 0], x_max[:, 1]) + _ = plt.title("Environment locations producing the maximum response") + _ = plt.xlabel("x1") + _ = plt.ylabel("x2") + plt.show() + +# %% diff --git a/tests/qoi/data/importance_sampling/scripts/create_environment.py b/tests/qoi/data/importance_sampling/scripts/create_environment.py new file mode 100644 index 00000000..b1f56390 --- /dev/null +++ b/tests/qoi/data/importance_sampling/scripts/create_environment.py @@ -0,0 +1,116 @@ +"""Generate the environment distribution for the importance sampling test. + +This script creates the environment data used in +``test_marginal_cdf_extrapolation.test_system_marginal_cdf_with_importance_sampling``. + +The environment distribution is ``MultivariateNormal(mean=[0.1, 0.1], cov=0.2*I)``, +truncated to positive values. This places the bulk of environment samples away from the +extreme response region (which peaks at [1, 1]), so that only few environment samples cover +the subregion where the extreme response occurs. This motivates the use of importance sampling. + +Usage:: + + python create_environment.py + +Output: + ``tests/qoi/data/importance_sampling/environment_distribution.npy`` + Shape: (10000, 2), dtype: float64 +""" + +# %% +from pathlib import Path + +import matplotlib.pyplot as plt +import numpy as np +import torch +from torch.distributions import MultivariateNormal + +torch.set_default_dtype(torch.float64) + +# Environment distribution: MultivariateNormal(mean=[0.1, 0.1], cov=diag(0.2)) +# Samples are filtered to keep only positive values in both dimensions. +ENV_MEAN = torch.tensor([0.1, 0.1]) +ENV_COV = torch.tensor([[0.2, 0], [0, 0.2]]) + +N_SAMPLES = 10_000 +SEED = 42 + +OUTPUT_DIR = Path(__file__).parent.parent + + +def generate_environment_data( + n_samples: int = N_SAMPLES, + seed: int = SEED, +) -> np.ndarray: + """Generate environment samples from a truncated MultivariateNormal. + + Samples from ``MultivariateNormal(mean=[0.1, 0.1], cov=0.2*I)`` and discards any + samples with negative values. + + Args: + n_samples: Number of samples to generate. + seed: Random seed for reproducibility. + + Returns: + Array of shape (n_samples, 2) of environment samples. + """ + env_mvn = MultivariateNormal(ENV_MEAN, covariance_matrix=ENV_COV) + + # This was how the samples were originally generated but I have decided to keep all samples to prevent any issues + # with the brute force + # with torch.random.fork_rng(): + # _ = torch.manual_seed(seed) + # valid_samples: list[np.ndarray] = [] + + # while len(valid_samples) < n_samples: + # samples = env_mvn.sample(torch.Size([n_samples])) + # mask = (samples >= 0).all(dim=1) + # batch_valid = samples[mask].numpy() + # for sample in batch_valid: + # if len(valid_samples) < n_samples: + # valid_samples.append(sample) + # else: + # break + + return np.array(env_mvn.sample(torch.Size([n_samples]))) # np.array(valid_samples[:n_samples]) + + +def env_pdf(x: torch.Tensor) -> torch.Tensor: + """Evaluate the environment PDF at given points. + + This is the PDF of the underlying (untruncated) MultivariateNormal. This is passed to the + importance sampling algorithm as ``env_distribution_pdf``. + + Args: + x: Tensor of shape (n_points, 2). + + Returns: + Tensor of shape (n_points,) with PDF values. + """ + env_mvn = MultivariateNormal(ENV_MEAN, covariance_matrix=ENV_COV) + return torch.exp(env_mvn.log_prob(x)) + + +# %% +if __name__ == "__main__": + # %% + env_data = generate_environment_data() + + print(f"Shape: {env_data.shape}") + print(f"Mean: {env_data.mean(axis=0)}") + print(f"Std: {env_data.std(axis=0)}") + print(f"Min: {env_data.min(axis=0)}") + print(f"Max: {env_data.max(axis=0)}") + + # %% Save the environment data + output_path = OUTPUT_DIR / "environment_distribution.npy" + np.save(output_path, env_data) + print(f"\nSaved to {output_path}") + + # %% Plotting the generated data to visualize the distribution + + _ = plt.figure(figsize=(6, 6)) + _ = plt.scatter(env_data[:, 0], env_data[:, 1], alpha=0.5, s=10) + _ = plt.title("Generated Environment Samples") + +# %% diff --git a/tests/qoi/data/importance_sampling/scripts/create_importance_samples.py b/tests/qoi/data/importance_sampling/scripts/create_importance_samples.py new file mode 100644 index 00000000..b97151d8 --- /dev/null +++ b/tests/qoi/data/importance_sampling/scripts/create_importance_samples.py @@ -0,0 +1,99 @@ +"""Generate importance samples and weights for the importance sampling test. + +This script creates the importance samples and weights used in +``test_marginal_cdf_extrapolation.test_system_marginal_cdf_with_importance_sampling``. + +The importance sampling uses ``importance_sampling_distribution_uniform_region`` which: +1. Draws ``num_samples_total=10_000`` uniform samples from the bounding region ``[[0, 0], [2, 2]]``. +2. Filters to keep only samples where ``env_pdf(x) > threshold (=1e-3)``. +3. Computes importance weights as ``w(x) = env_pdf(x) / h(x)`` where ``h(x)`` is the + estimated uniform importance PDF over the filtered sub-region. + +The environment PDF is ``MultivariateNormal(mean=[0.1, 0.1], cov=0.2*I)`` — the same +distribution used to generate the environment data. +""" + +# %% +import sys +from pathlib import Path + +import torch + +# Add the crest_heights_north_sea example to import the importance sampling function +_SCRIPT_DIR = Path(__file__).resolve().parent +_REPO_ROOT = _SCRIPT_DIR.parents[4] +sys.path.insert(0, str(_REPO_ROOT / "examples" / "crest_heights_north_sea")) +sys.path.insert(0, str(_SCRIPT_DIR)) +from create_environment import env_pdf +from importance_sampling import importance_sampling_distribution_uniform_region # type: ignore[import-not-found] + +torch.set_default_dtype(torch.float64) + +# Importance sampling parameters +REGION = torch.tensor([[0.5, 0.5], [2.0, 2.0]]) +THRESHOLD = 1e-3 +NUM_SAMPLES_TOTAL = 10_000 +SEED = 42 + +OUTPUT_DIR = Path(__file__).parent.parent + + +def generate_importance_samples( + seed: int = SEED, +) -> tuple[torch.Tensor, torch.Tensor]: + """Generate importance samples and weights. + + Uses uniform sampling within the region, filtering by the environment PDF threshold, + and computing weights as ``env_pdf(x) / h(x)``. + + Args: + seed: Random seed for reproducibility. + + Returns: + Tuple of (importance_samples, importance_weights). + """ + _ = torch.manual_seed(seed) + + samples, weights = importance_sampling_distribution_uniform_region( + env_distribution_pdf=env_pdf, + region=REGION, + threshold=THRESHOLD, + num_samples_total=NUM_SAMPLES_TOTAL, + ) + + return samples, weights + + +# %% +if __name__ == "__main__": + # %% + samples, weights = generate_importance_samples() + + print(f"Samples shape: {samples.shape}") + print(f"Samples range: [{samples.min():.4f}, {samples.max():.4f}]") + print(f"Weights shape: {weights.shape}") + print(f"Weights range: [{weights.min():.6f}, {weights.max():.6f}]") + print(f"Weights sum: {weights.sum():.4f}") + + samples_path = OUTPUT_DIR / "importance_samples.pt" + weights_path = OUTPUT_DIR / "importance_weights.pt" + + # %% Save the samples and weights + torch.save(samples, samples_path) + torch.save(weights, weights_path) + print(f"\nSaved to {OUTPUT_DIR}") + + # %% + # Plot the samples colored by weights to visualize the importance sampling distribution + # Compare the existing ones with the newly generated ones next to each other + import matplotlib.pyplot as plt + + fig, axes = plt.subplots(1, 1, figsize=(5, 5)) + _ = axes.scatter(samples[:, 0], samples[:, 1], c=weights, cmap="viridis", s=10) + _ = axes.set_title("Generated Importance Samples") + _ = axes.set_xlim(REGION[0, 0], REGION[1, 0]) + _ = axes.set_ylim(REGION[0, 1], REGION[1, 1]) + _ = fig.colorbar(plt.cm.ScalarMappable(cmap="viridis"), ax=axes, label="Importance Weight") + + +# %% diff --git a/tests/qoi/data/importance_sampling/scripts/plot_response_surface.py b/tests/qoi/data/importance_sampling/scripts/plot_response_surface.py new file mode 100644 index 00000000..797bbd9e --- /dev/null +++ b/tests/qoi/data/importance_sampling/scripts/plot_response_surface.py @@ -0,0 +1,54 @@ +"""Plot the response surface of the ImportanceSamplingTestSimulator.""" + +# %% +import matplotlib.pyplot as plt +import numpy as np +import torch +from matplotlib import cm +from simulator import _true_underlying_func + +# %% +# Create a grid over the input space +n = 200 +x1 = np.linspace(-1.0, 3.0, n) +x2 = np.linspace(-1.0, 3.0, n) +X1, X2 = np.meshgrid(x1, x2) + +# Evaluate the true underlying function on the grid +grid_points = torch.tensor(np.column_stack([X1.ravel(), X2.ravel()]), dtype=torch.float64) +params = _true_underlying_func(grid_points) +loc = params[:, 0].numpy().reshape(n, n) +scale = params[:, 1].numpy().reshape(n, n) + +# %% +# --- Plot --- +fig = plt.figure(figsize=(16, 5)) + +# 1) 3D surface of loc(x) +ax1 = fig.add_subplot(131, projection="3d") +ax1.plot_surface(X1, X2, loc, cmap=cm.viridis, edgecolor="none", alpha=0.9) +ax1.set_xlabel("x1") +ax1.set_ylabel("x2") +ax1.set_zlabel("loc(x)") +ax1.set_title("Gumbel loc (3D surface)") + +# 2) Contour of loc(x) +ax2 = fig.add_subplot(132) +cf = ax2.contourf(X1, X2, loc, levels=40, cmap=cm.viridis) +ax2.set_xlabel("x1") +ax2.set_ylabel("x2") +ax2.set_title("Gumbel loc (contour)") +fig.colorbar(cf, ax=ax2) + +# 3) Contour of scale(x) — constant but shown for completeness +ax3 = fig.add_subplot(133) +cf2 = ax3.contourf(X1, X2, scale, levels=40, cmap=cm.plasma) +ax3.set_xlabel("x1") +ax3.set_ylabel("x2") +ax3.set_title("Gumbel scale (contour)") +fig.colorbar(cf2, ax=ax3) + +fig.suptitle("Response surface: Gumbel(loc(x), scale(x))", fontsize=14, y=1.02) +fig.tight_layout() + +# %% diff --git a/tests/qoi/data/importance_sampling/scripts/response_surface.png b/tests/qoi/data/importance_sampling/scripts/response_surface.png new file mode 100644 index 00000000..fde43a62 Binary files /dev/null and b/tests/qoi/data/importance_sampling/scripts/response_surface.png differ diff --git a/tests/qoi/data/importance_sampling/scripts/simulator.py b/tests/qoi/data/importance_sampling/scripts/simulator.py new file mode 100644 index 00000000..84712a39 --- /dev/null +++ b/tests/qoi/data/importance_sampling/scripts/simulator.py @@ -0,0 +1,103 @@ +"""Simulator for the importance sampling test data. + +This simulator wraps the true underlying function used in +``test_marginal_cdf_extrapolation.test_system_marginal_cdf_with_importance_sampling``. + +The underlying function defines a Gumbel response distribution where: +- loc(x) = exp(log_prob(x)) with x ~ MultivariateNormal(mean=[1, 1], cov=diag(0.03)) +- scale(x) = 0.1 (constant) + +The response at each environment point is a sample from Gumbel(loc(x), scale(x)). +""" + +# %% +from typing import cast + +import numpy as np +import torch +from numpy.typing import NDArray +from scipy.stats import gumbel_r +from torch.distributions import MultivariateNormal + +from axtreme.simulator.base import Simulator + +torch.set_default_dtype(torch.float64) + + +def _true_underlying_func(x: torch.Tensor) -> torch.Tensor: + """Compute the Gumbel distribution parameters (loc, scale) for each input point. + + This is the same function used in the test as the deterministic GP mean function. + + Args: + x: Input tensor of shape (n_points, 2). + + Returns: + Tensor of shape (n_points, 2) where columns are [loc, scale]. + """ + dist_mean, dist_cov = torch.tensor([1, 1]), torch.tensor([[0.03, 0], [0, 0.03]]) + dist = MultivariateNormal(loc=dist_mean, covariance_matrix=dist_cov) + loc = torch.exp(dist.log_prob(x)) + + scale = torch.ones(x.shape[0]) * 0.1 + + return torch.stack([loc, scale], dim=-1) + + +class ImportanceSamplingTestSimulator(Simulator): + """A seeded simulator for the importance sampling test. + + At each environment point x, the response follows a Gumbel distribution with location and scale + determined by ``_true_underlying_func``. Each unique point gets a deterministic seed for reproducibility. + """ + + def __call__( + self, x: np.ndarray[tuple[int, int], np.dtype[np.float64]], n_simulations_per_point: int = 1 + ) -> np.ndarray[tuple[int, int, int], np.dtype[np.float64]]: + """Evaluate the simulator at given points. + + Args: + x: An array of shape (n_points, n_input_dims) of points at which to evaluate the model. + n_simulations_per_point: The number of simulations to run at each point. + + Returns: + An array of shape (n_points, n_simulations_per_point, n_output_dims) of the model evaluated at the input + points. + """ + params = _true_underlying_func(torch.tensor(x)) + loc = params[:, 0].numpy() + scale = params[:, 1].numpy() + + seeds = [self._hash_function(*tuple(x_i)) for x_i in x] + + samples = [] + for loc_i, scale_i, seed_i in zip(loc, scale, seeds, strict=True): + sample = cast( + "NDArray[np.float64]", + gumbel_r.rvs(loc=loc_i, scale=scale_i, random_state=seed_i, size=n_simulations_per_point), + ) + samples.append(sample) + + return np.expand_dims(np.stack(samples), axis=-1) + + @staticmethod + def _hash_function(x1: float, x2: float) -> int: + """Hash 2 floats to an integer between 0 and 2**32 - 1.""" + return abs(hash((x1, x2)) % (2**32 - 1)) + + +# %% +if __name__ == "__main__": + # %% + sim = ImportanceSamplingTestSimulator() + x = np.array([[1.0, 1.0], [0.5, 0.5], [0.0, 0.0]]) + result = sim(x, n_simulations_per_point=3) + print(f"Input shape: {x.shape}") + print(f"Output shape: {result.shape}") + print(f"Results:\n{result}") + + # Verify reproducibility + assert (sim(x, n_simulations_per_point=5) == sim(x, n_simulations_per_point=5)).all() + print("Reproducibility check passed.") + +# %% diff --git a/tests/qoi/results/gp_bruteforce/26_04_12-15_08_49__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/ground_truth.png b/tests/qoi/results/gp_bruteforce/26_04_12-15_08_49__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/ground_truth.png new file mode 100644 index 00000000..18307b7d Binary files /dev/null and b/tests/qoi/results/gp_bruteforce/26_04_12-15_08_49__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/ground_truth.png differ diff --git a/tests/qoi/results/gp_bruteforce/26_04_12-15_08_49__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_gp_deterministic.png b/tests/qoi/results/gp_bruteforce/26_04_12-15_08_49__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_gp_deterministic.png new file mode 100644 index 00000000..eb75e20e Binary files /dev/null and b/tests/qoi/results/gp_bruteforce/26_04_12-15_08_49__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_gp_deterministic.png differ diff --git a/tests/qoi/results/gp_bruteforce/26_04_12-15_08_49__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_gp_high_uncertainty.png b/tests/qoi/results/gp_bruteforce/26_04_12-15_08_49__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_gp_high_uncertainty.png new file mode 100644 index 00000000..b03f9a1d Binary files /dev/null and b/tests/qoi/results/gp_bruteforce/26_04_12-15_08_49__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_gp_high_uncertainty.png differ diff --git a/tests/qoi/results/gp_bruteforce/26_04_12-15_08_49__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_gp_low_uncertainty.png b/tests/qoi/results/gp_bruteforce/26_04_12-15_08_49__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_gp_low_uncertainty.png new file mode 100644 index 00000000..b0f29f96 Binary files /dev/null and b/tests/qoi/results/gp_bruteforce/26_04_12-15_08_49__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_gp_low_uncertainty.png differ diff --git a/tests/qoi/results/gp_bruteforce/26_04_12-15_08_49__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_job_results.json b/tests/qoi/results/gp_bruteforce/26_04_12-15_08_49__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_job_results.json new file mode 100644 index 00000000..a408a2ff --- /dev/null +++ b/tests/qoi/results/gp_bruteforce/26_04_12-15_08_49__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_job_results.json @@ -0,0 +1 @@ +[{"mean": 33.5927926645127, "var": 0.7326602122884222, "samples": [31.270710854817235, 32.62551732133869, 32.595391939739024, 32.2971109566495, 32.93574864716496, 32.51767185662366, 33.80076808881839, 33.77173493386264, 33.43791496338639, 34.537007112263, 33.4679594227669, 34.180930403322314, 32.30522891423824, 34.108138998350626, 33.08303041550598, 32.36068422461373, 33.31123954940705, 34.95838232601712, 34.072457029397874, 32.821761283845255, 35.1866887158572, 33.6531992513928, 34.18400561868216, 34.123078349240224, 34.41524475797448, 34.956180406046705, 34.51186420597999, 33.1329319643727, 33.610209493615926, 32.54158400700153, 33.3183092624288, 33.25230006232904, 33.1122906003855, 32.97577351793752, 33.35056965516189, 34.31081870503988, 34.01204544578669, 33.4827316304134, 34.47870920930262, 33.25742716068735, 33.767379378282094, 35.417414402105244, 34.006271435668204, 33.67929222287148, 32.98530491766117, 33.33467489002963, 34.613057431694656, 33.44659004640947, 33.1012949886864, 34.9630022504619], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.6240037157318, "var": 0.5638006436952159, "samples": [34.47044136707532, 33.431906101485545, 33.321265613352686, 33.37997323829935, 33.68198952733772, 31.724876654126614, 33.82732043188354, 34.13915490705348, 33.23611284861508, 35.081832370733544, 35.3955405162164, 33.76638588068294, 32.97554745452036, 32.97475988208664, 35.08200898725701, 32.65471206318666, 33.098495753738504, 33.831084992299, 33.11944833259521, 34.01838586689516, 34.43486314597958, 34.48534045457693, 32.8756050095819, 33.29489153617379, 33.69641412715729, 33.50517448532835, 32.71001255278354, 34.647047003409774, 33.681229186624876, 32.19907670152693, 34.23652978025986, 33.20892716478522, 33.179959690323656, 32.15043427183009, 33.13893180593879, 34.344328500966554, 33.02082032900757, 34.18562107521667, 34.03996133649641, 34.21917736410705, 32.98379639728201, 33.74009131870573, 32.92001518110689, 33.87811857245183, 34.35705985672863, 33.83093704365637, 33.83268677721816, 33.8861255536844, 33.95027355742057, 33.355493216819944], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.5822981773148, "var": 0.5691316132245879, "samples": [33.180225532610486, 33.48282737675029, 32.2360647125423, 33.6802909165648, 34.57690683001203, 34.14318598920329, 34.410554228978945, 33.74843336947795, 33.679276439243154, 33.01236970261262, 35.01603922433248, 33.68413403478322, 32.862454956117915, 34.332571391156584, 34.081506457200305, 31.88478236082008, 33.221965268218554, 32.48845407825185, 32.96515207924412, 33.711419074056344, 33.463104451452324, 33.07502473892607, 33.835714140295124, 33.1697400513542, 34.2233794137986, 34.46845162725232, 33.190790968912815, 33.98800088139325, 34.28648707224433, 34.03342090697296, 34.33839303171541, 33.36116984303669, 32.55197461698272, 33.66139857998729, 32.970202576366674, 33.22207336204568, 34.37770645802056, 33.85652511311981, 34.86502791739503, 31.655195230517087, 33.60496277880855, 33.26453435652722, 33.76275311369555, 34.22434074304962, 33.0079971942241, 33.91247530819642, 32.27690619829423, 33.4883639203121, 33.63383474986739, 34.94634549879853], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.681934661878984, "var": 0.6417390702837013, "samples": [32.68874867538856, 35.17346751892556, 35.07577764415612, 33.62398736883289, 33.418374563269786, 34.60367411590029, 34.104900010658945, 33.641972725477565, 33.005929709580734, 32.219517564896584, 33.162142650996216, 34.41574527820298, 32.014859330251326, 34.444390849042, 34.24121899865101, 32.889231424237906, 33.657842352739735, 34.09262177237725, 34.3872442820648, 33.65525959820116, 34.473365798063, 34.35577311747262, 34.62254445009296, 35.47511689507185, 32.425233595241664, 33.37393446787326, 34.50734054835635, 32.80972405363752, 32.95394455021661, 33.24431204005253, 33.38746401568807, 33.25975909081987, 33.6095085446466, 33.846424274263306, 32.67843593240818, 33.59069316843205, 34.477320913839186, 32.831676764565316, 33.7495953488376, 33.606004448263064, 33.51065115118423, 33.62454189778665, 34.11562475041342, 34.125326184053606, 32.85681414213394, 35.043840964937516, 32.97428775524055, 33.964703630416096, 32.423311794212054, 33.662552371878284], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.720006241498375, "var": 0.6184895712553691, "samples": [34.682210724923905, 32.18218948986135, 32.23036988672224, 32.505498322107364, 33.28903448010241, 33.0699304155428, 32.85915175081854, 34.85223283434567, 33.67257526296116, 33.322511874501366, 33.896512512225975, 34.25073612298666, 34.40198785006972, 33.84725101553641, 31.963103036298065, 34.35296960038976, 34.089805786847606, 34.00906313201196, 33.93736510409067, 32.4859755648445, 34.806747185932274, 32.13093112436559, 33.74639364021501, 32.62160080779009, 34.14698058696322, 34.444961127818516, 33.40403579960646, 34.01284607561345, 34.003957934465205, 34.921445381982494, 33.32936351303054, 34.519951727383706, 32.74533623549248, 33.93736510409067, 34.28960836520184, 32.4611792312335, 34.31371307536322, 34.03685637302218, 34.275259402974676, 34.094848046612896, 33.78117009380205, 34.335477666184524, 34.8732906286826, 34.20208695978921, 34.13030879511604, 33.275046788404474, 33.91950162629708, 33.45737926083693, 34.00616372458242, 33.87603102487732], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.60148794082991, "var": 0.5504957533563668, "samples": [35.43222018345997, 33.27211217394993, 33.95447188955332, 33.56007694656096, 34.38189297722696, 32.29665888971417, 33.95474622740412, 33.25436291177341, 32.52876067261385, 33.65715048291574, 33.668699966267226, 32.79913879245831, 34.52866996863076, 32.98802871946449, 32.9237212115536, 33.53659908251307, 33.82319722948175, 33.7146605405474, 34.166466648497526, 33.30612410910946, 33.16220103141664, 33.87347386108453, 33.58456694394336, 32.28789552586472, 33.99994570747794, 35.11035937295257, 33.39001007065651, 32.89990032839421, 32.237820842061694, 34.26742888003663, 33.11438918589168, 33.33475125104921, 32.89425402898481, 33.93340537688446, 32.630783600857704, 34.81056531407957, 34.7680220614443, 33.75090933201956, 33.92329035408229, 33.17973507431207, 33.87884295778454, 34.1237337426099, 34.04672625246455, 34.64212037547401, 33.23475825833842, 34.08772624896404, 32.68559462721053, 32.802052077391046, 33.12300974106243, 34.54836499300567], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.58697389562937, "var": 0.4949903444660336, "samples": [33.556700995147295, 32.83071727987675, 34.39264283539759, 33.935134229593196, 34.11938455335299, 32.8662358652748, 33.93346450115517, 32.65918067660013, 33.73951719578175, 33.76373331621397, 33.21232136745652, 32.982953823333446, 33.45601676454851, 33.5362612238078, 33.04753324607474, 32.33822013472657, 32.14460157264847, 33.96063686915067, 33.49052718561044, 33.100494181432595, 33.33996657799858, 33.813427374695905, 34.28920533913197, 33.54982215469379, 33.83237875890531, 35.450658215914686, 33.39792775861116, 33.46917859787596, 34.341271774815546, 34.4158642158421, 32.71573928239214, 34.77222058969706, 32.89500589149675, 34.86889138832753, 33.58745991289385, 32.83864645275694, 33.820489662402274, 34.38908311163005, 32.2266135517082, 33.52135126819679, 34.77415990422084, 34.12909112367602, 33.37099953654717, 33.560823253055766, 32.878582523795025, 33.83220160057838, 33.432451746530276, 33.91802356283347, 34.09204863036662, 32.75883320269499], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.715688771397005, "var": 0.5118911236034285, "samples": [31.79032447003168, 33.98490488622154, 33.92714282613063, 33.16154420787059, 34.27672718844265, 33.367981622758265, 33.42838289536093, 34.710296587388974, 34.1767173442594, 34.536567835110304, 33.10662867094007, 33.38907291694368, 33.242599482730014, 34.44318848403562, 32.06811184868485, 33.65388463544251, 32.90517486439237, 34.50692173042911, 33.391870237682284, 33.11641673263986, 32.93214385011682, 33.26829643333252, 34.53396080497761, 34.22587121386292, 33.91442685230107, 34.60671911892673, 33.914256740206824, 33.45725293624729, 33.55276252162931, 33.685583805616034, 32.8442163020935, 33.56856759326797, 34.13699874105073, 33.10747288803594, 34.089234007010205, 33.460959559808714, 33.572289314260146, 34.49128801456721, 33.95129782338331, 34.192953633161046, 33.59345151894532, 33.01660020724, 33.76421155543074, 32.98956464925438, 33.9869416287222, 35.070242727482274, 33.590052217166544, 35.86797895853512, 33.82939117577516, 33.38499230994735], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.59872249277983, "var": 0.5019364013737098, "samples": [33.38103115213622, 34.80208041849261, 33.34744759668846, 34.866165290958, 33.241277871423335, 33.662993980178875, 33.85100936286276, 34.45579004058083, 33.26937599938174, 34.402884754680585, 33.6080355524975, 32.66529773467442, 34.92464504138338, 34.4917943284602, 33.44610881584413, 35.390857762569325, 32.42612697587671, 33.364198363167624, 32.98680401886241, 33.271788375136516, 32.344946054593315, 33.96523642814447, 33.35696912946553, 32.800477526116296, 33.21061239102911, 33.01750989693066, 33.852950498314044, 32.73325375939431, 32.952277606306055, 34.16472008407693, 33.24158818200914, 33.26149622335995, 33.57462548809314, 33.797160704532516, 32.360224114776734, 33.83801587809636, 33.78913996972002, 34.27777078233776, 33.40310138084718, 33.32432790630191, 32.45410304871398, 33.7411539752592, 34.01234141660814, 33.94546211415285, 34.82035083597595, 33.636697465415445, 32.815048106732306, 34.207970044833594, 33.859371915151975, 33.32150827584675], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.80648869120562, "var": 0.5563570269620925, "samples": [33.06594764077577, 34.379847788612786, 33.421588708022945, 33.50921516604199, 33.09003976506713, 33.583541098684634, 33.79364279210623, 33.7125345059084, 34.819130270541926, 33.34684568251103, 33.479734490391664, 34.36952300491516, 33.98383088982917, 33.48260913878195, 33.90239686217733, 34.38333464362908, 34.29641140332057, 33.09832077529018, 35.15416594210552, 33.30025895357065, 34.13830504508614, 33.853006438582774, 34.72301592674885, 34.09536955874507, 33.509110697310504, 33.7495953488376, 34.01603607695778, 33.86613832541695, 33.270152536740405, 33.220772274462675, 34.32616823328395, 34.59243104467017, 35.93846674957408, 33.31555653109317, 33.52693553561453, 34.70120677363691, 33.46614603268368, 33.59427745183392, 33.2774849485805, 34.26579985006788, 34.22791191017534, 32.38886653496632, 33.18599294944476, 34.015155171214, 32.83837717093279, 34.977646649410005, 32.72411754717481, 35.02898673917331, 33.49288501884719, 31.82559996673091], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.3589514282827, "var": 0.4201460481836993, "samples": [34.31353949623793, 33.39578541631677, 33.629660447884014, 33.767886162676945, 33.59404775949188, 32.758574616269335, 32.83845591269524, 33.42528322053672, 33.540184381790624, 34.155694819393815, 34.752184247593135, 32.283680188719785, 34.20687165536954, 34.01678772799901, 32.36390581898391, 33.49683337820086, 33.83046067054674, 34.011825431555714, 34.4209341924552, 32.971825083154094, 32.52912792152066, 32.5666034342853, 33.47378732881842, 32.69048693860882, 32.568145383658205, 32.77541255609199, 31.926047929972153, 33.50565877213893, 33.42146294507504, 32.693847365846246, 33.35653020773744, 33.90454010402963, 32.70573190352679, 33.45478757363749, 34.04053883601561, 33.77298571841067, 33.144145734403864, 33.448621602513356, 33.207107306657775, 33.43116053065431, 33.55125708814536, 32.49284405665451, 33.35653020773744, 33.4807431627592, 33.35091833816125, 33.70544963270756, 33.975581220491726, 32.65023839217485, 32.4163281497586, 34.57653044407063], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.67428293683188, "var": 0.6382924847296813, "samples": [35.70009413806693, 33.80521564702343, 33.222268820858346, 32.80807903808182, 34.84835199252792, 32.48930125118807, 32.982681016218734, 33.94546211415285, 33.75742257546261, 32.79547755024957, 33.93223111223819, 34.70546016973118, 32.62537756542504, 32.849754945784355, 33.91548477747005, 34.61684473128738, 33.55150989528629, 35.48475173551961, 34.90108555337312, 33.81734753275804, 34.550992672725236, 33.309948665539075, 33.41214923852908, 32.72296661209683, 33.522578957384866, 34.462580471185916, 32.65295706887959, 32.71000999407988, 33.93403020205738, 33.792042360389175, 33.678845215826804, 33.48467763548247, 34.06176400324572, 34.67238915448443, 32.70191445758295, 34.57161138472938, 34.07766493286362, 33.43987905353022, 32.56015120491678, 33.6911681781398, 32.63239552412241, 34.82136283070399, 33.4808646935205, 33.72491546786423, 33.62628946285977, 32.55535255677152, 33.354242489258546, 34.01240948164538, 33.788981781362324, 32.952808927113004], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.826943827535224, "var": 0.5290885123088414, "samples": [34.83409232250517, 35.833620756879846, 32.91814748395091, 33.52851737972511, 33.63814023361932, 33.78989072788121, 32.672906665439044, 33.179958368073436, 33.146851518294376, 33.545974154902495, 33.48338716846651, 34.01884336589898, 34.15252561179712, 34.12315179380574, 32.66237325026649, 34.37278590925415, 35.84138324390883, 34.85398229400964, 32.90744095748639, 33.74483886240081, 33.31315968525421, 33.777126048344094, 33.71562396984287, 33.4202088611889, 34.023631089777936, 34.423151892900215, 34.537007112263, 34.25357817027645, 33.37855129748906, 33.86932138143795, 32.78397706805213, 33.33187444078332, 33.94494706385416, 33.47928032562319, 34.311150653900555, 33.56537791824112, 33.73311369148066, 34.054122709366766, 33.144861338922844, 33.56624481616431, 33.78836816457009, 34.348586455766764, 33.47555016204188, 33.799933821105434, 32.93436672150989, 32.707571211223815, 34.49823010299832, 34.138182803178864, 34.4887182303149, 35.292562100322044], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.56423455717165, "var": 0.5198464443854577, "samples": [34.028762441826, 32.45210139485059, 34.046318860379486, 33.53200453632811, 33.537532929437674, 33.73311369148066, 33.2085619264674, 34.78245832388811, 33.910823949727614, 32.535569391760234, 33.10136354186162, 33.78987842023912, 32.800623519376714, 33.88921795337621, 34.24379685199055, 33.376940168381736, 33.74112101331262, 34.25655880779069, 32.65609954492068, 33.66363219483418, 34.379847788612786, 34.16701486975298, 33.20950146156502, 33.654056273574575, 35.61239471329393, 33.97043380307902, 32.461220480068725, 32.29898092170968, 33.99927375284569, 34.244735650335656, 32.91726481296979, 33.07967768966437, 32.95824297322284, 33.52430211117452, 32.44785798651724, 33.86360118625648, 33.46531118805851, 34.23908065217879, 32.43025758310651, 32.51442976104134, 34.95758883938481, 32.67843593240818, 34.546472163390824, 33.793133441693215, 33.84498129459126, 33.741398857505466, 33.47710574091138, 33.62139010029013, 33.5855309448372, 33.24172542231144], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.752487627037624, "var": 0.4174138599218445, "samples": [34.01950627215179, 34.411607736725905, 33.55293407000954, 34.59557775067715, 33.756387229559394, 33.216538813869946, 33.91525877586992, 32.852144491783044, 33.476621074658965, 33.99244402463535, 33.42508717827343, 34.06811769942778, 35.1822142081925, 34.85927269288846, 34.08079410042698, 33.599050858485, 33.36832532610525, 33.60768494053221, 33.88825451219886, 33.07524071632971, 33.340488961356385, 34.18551685618252, 33.730379927846315, 33.023347699465745, 33.867149422463854, 33.49195337394549, 33.29079611216906, 34.810458354814685, 34.346997984832775, 33.072397859836336, 34.92953944156449, 33.6777273562, 33.89431941361051, 33.35728087939097, 35.12837044775347, 33.715320978827656, 33.73057592952839, 32.85703056139537, 33.45407060875605, 34.2536555665181, 33.407719051102895, 32.646936203002305, 32.120639504007364, 33.73074190425193, 34.38046056413188, 33.7046578029516, 34.55574385149239, 33.729725862190335, 32.873574125576354, 33.373742273915], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.71206230334046, "var": 0.7308114009462539, "samples": [33.98740560876344, 33.783218666152884, 34.116414328801255, 32.026175081241504, 34.06720991640572, 34.63018183921404, 34.47050279585127, 34.193221404109515, 32.40342384864578, 34.01551896328047, 34.17527700792109, 34.11405866935566, 33.35648391282964, 33.031757321797244, 35.116741444227735, 33.130232393955716, 34.10559849348006, 33.55794990835407, 33.11482644707312, 35.3746008705192, 32.98696955948266, 33.09404990033845, 33.53587659307448, 32.68978242213966, 32.5363798063827, 33.80571335204758, 33.265132436077835, 32.91819447701577, 32.96978525239335, 32.82106096814823, 33.60271169187772, 36.20669002550873, 34.403865957475595, 34.55465400959015, 34.4729382646395, 33.09503320035396, 32.61242222072992, 33.60791980698423, 33.66281385777078, 33.08029234058778, 33.68679090102361, 34.382720892808216, 35.24500397637047, 32.88691766612077, 33.20909405123008, 32.70387464224161, 33.72364546498965, 33.80405042383545, 34.10827107244664, 35.159661011358324], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.62571559462885, "var": 0.6180068525992499, "samples": [32.75851761339268, 34.07792182299983, 32.681984926276584, 32.840017195150764, 33.455674565293094, 33.864366747392125, 33.21194718324161, 34.536173478902505, 33.838408973462506, 32.45974790149186, 34.17637068945436, 32.26594126503613, 32.771799278888224, 34.65084233600483, 33.501378108980916, 34.61179850191643, 34.448747740755074, 33.61249134923324, 33.936763248329335, 32.35403519996455, 33.36020394493899, 34.24373792863286, 32.192363900769664, 33.74623116962118, 32.40146458138971, 34.60188966822027, 33.69521063392325, 34.165709614328264, 33.88481916729052, 33.30714392590013, 34.00545121808259, 33.07075324848576, 34.41251806562519, 33.02397818225018, 33.746867126693836, 35.750621957883055, 34.033535176179505, 34.1415187226318, 33.545036057230895, 35.036266867335414, 33.69285012032474, 32.148436860751474, 34.34201449486934, 33.47885731048778, 33.804569102170895, 33.74466322017945, 32.60612669538572, 33.19210101807346, 33.86607856170148, 33.9898330639185], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.54999743352451, "var": 0.3840552278149315, "samples": [32.90512687492699, 32.85088495041862, 33.02154559709083, 33.05734783593563, 32.079090075036525, 33.83744637475488, 33.41163648814753, 33.31435703492384, 32.36948105321414, 33.4489114798121, 33.699849121487006, 34.693124530548815, 34.215927340188124, 33.523900229018295, 33.85906967268158, 34.784137032245184, 33.41322532361154, 33.60954020650027, 33.61589136451284, 33.35342785878683, 33.59401401019571, 33.973010459512075, 33.0932050461325, 33.43777218972696, 34.441066464545806, 33.41111241022138, 32.68110864129482, 32.78309891991051, 34.781405380911, 33.520954614188675, 32.70976628577559, 33.01294127617073, 33.704284862311646, 34.21723737380908, 33.9869416287222, 33.1516142791105, 33.55125708814536, 33.58549032514107, 33.98966724966416, 34.676795603470886, 33.09330367848566, 33.74025113630972, 33.93721212170794, 32.9126764619791, 33.694970700220615, 34.48501414038882, 32.829226125963594, 33.43804154563358, 34.33421030334318, 33.66830090939117], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.5879593185028, "var": 0.509306287796072, "samples": [33.923979696836824, 32.47794553155205, 33.445059727796135, 33.9718584980128, 33.38191716007501, 35.02205686623072, 34.14778635712664, 34.27972121077797, 33.38399018253613, 33.21228307929582, 34.44695360339214, 32.33734710543935, 33.50012383109211, 33.14123205283698, 33.423859812931795, 32.77937265085213, 34.01246264180289, 34.47463069360897, 34.80455523065189, 33.08147475080733, 34.11594541800426, 33.04245508393201, 32.83714730081242, 32.9915154800688, 33.52840779019977, 32.431347021155254, 33.65040155006318, 33.811242471697554, 32.66501191698055, 34.97305531992607, 33.653706774688104, 33.113118662003984, 32.87553579887002, 32.65043146471332, 33.82343231317232, 33.41025698158379, 33.86198404879959, 34.5128303085119, 33.32528710599723, 33.41621263797832, 33.242957504198095, 34.68193583445012, 34.2916833708751, 33.582811203940096, 34.843946896245214, 33.866606798860914, 32.023897617568366, 33.55942558844481, 33.40820209446995, 33.95856288327311], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.57509327045077, "var": 0.5750807842340198, "samples": [33.921211260933674, 32.85195091587792, 32.95901644385562, 34.485084870350136, 32.150268051208606, 32.63988579423723, 33.78769287977344, 33.70863189706278, 32.59202817358095, 33.54165231070458, 34.69730646284522, 33.86190362602957, 33.18688934771465, 33.42748281422893, 33.77855745926817, 35.148809148719785, 33.7627005742064, 34.12195939181644, 33.68951692807909, 31.950045909005127, 34.81601694108128, 35.1290121373771, 33.73027385046551, 33.18053647906265, 34.18141426925237, 33.71163326783106, 33.19140031125889, 33.5335424602272, 33.116989435318885, 32.437299968306526, 34.48390794963697, 34.685216097390565, 33.96738590156176, 33.45130110746434, 33.28264302675293, 33.92190255558985, 32.58148053246823, 32.45654852130663, 33.55899553884243, 34.59790070260848, 33.83906019363555, 32.827222396174896, 32.82172671088664, 33.03344296766362, 33.409647249793444, 34.01942635292433, 34.41494455435574, 32.857872323460484, 34.14682847585361, 33.106496984488565], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.841588821023414, "var": 0.8507367858868088, "samples": [34.15145270380887, 33.78469502278189, 33.43611624664137, 35.11962249985788, 34.89897133976256, 32.60192509730596, 33.24353501236453, 33.74747053515736, 34.496464382285154, 33.212752278550326, 33.9584180358375, 34.27680767190954, 33.22001075301794, 34.2410515637318, 33.385406374108705, 32.16509337338953, 33.59618322492428, 35.499004305425096, 33.24488594783865, 32.55738676542612, 34.174029726866706, 33.56529324749159, 35.257552671124316, 35.1799227967219, 33.434750298968645, 34.66160534570471, 32.60256252664229, 33.64049464764906, 33.84439535228294, 32.29050622969005, 33.17937102889603, 33.92455364306477, 34.77388089470633, 36.31235451626064, 33.29506507989417, 33.26252221773178, 34.66585493797167, 34.28273456340899, 32.52421379054993, 33.586498816762145, 36.21645372972932, 34.020531577775465, 33.7885898787161, 33.776486945178625, 33.76640736041176, 34.02958703831706, 33.39043750541625, 33.990701981047685, 32.65435390866413, 33.15047565940035], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.51947539784935, "var": 0.3507930938261889, "samples": [33.64222566164121, 34.39993267263813, 33.56191199276534, 33.34564009434643, 33.32827122323847, 33.36407536174672, 33.9525806543728, 35.07493291188877, 33.60419984525144, 32.925943293973965, 33.71119803071244, 33.75611698041727, 32.790650647112855, 33.221965268218554, 33.306851356290665, 33.72130983025616, 33.12535744550718, 34.436647229567875, 33.02575060898448, 33.62739064760539, 33.485910862342934, 32.264830586940086, 34.95227105814108, 33.202188899769645, 33.74907869355846, 33.665295581624726, 32.55844503060791, 34.210020071848675, 33.58941648660631, 33.90232706966046, 32.85493986990521, 33.46094300082755, 33.02902411533697, 33.77028814124964, 33.602357637245625, 34.43372756113876, 33.489990274349815, 32.84947108681989, 32.79944031025859, 33.15383754052453, 33.17034701403923, 33.39745941792645, 34.63027889710981, 34.01103920180179, 32.822690735206145, 33.36436358143839, 33.23073645254605, 32.96515937339473, 34.287682028054334, 33.1472575556573], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.48599561272551, "var": 0.6011518547373592, "samples": [32.39124756117628, 33.31046677537259, 33.500918791742514, 32.84293302833131, 33.129616639951706, 35.16224392050667, 34.25143224885815, 33.047957508145515, 33.15643557691531, 34.730624939429276, 33.36239242030267, 32.8060382028801, 32.89827592966166, 31.887316960654637, 33.967621844448615, 33.249838818873215, 33.64007564716483, 32.19619193815378, 34.799403517892515, 34.23149648448271, 33.96329785379857, 33.3445026022827, 32.39560759188323, 33.872680015158004, 34.96507111151472, 33.536762407023055, 33.47007808095499, 32.68351946192253, 32.92723316156174, 32.83628126128797, 33.91570658857634, 33.09569347748465, 33.68072928905237, 32.994154370494726, 34.32723487378102, 34.95213771046209, 33.95942627010325, 32.50481351937401, 33.062753338676195, 33.35320265606647, 32.85602651546483, 33.62857455258715, 32.74131327977537, 33.22270114716293, 34.27431842313988, 34.79758457760304, 34.01563339159501, 33.92529334114762, 32.58773655291255, 33.84718445848457], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.649249879527005, "var": 0.6237982235795578, "samples": [33.575563024407, 33.65978547030984, 34.96204674503936, 34.821800863807404, 33.2972653927656, 34.82164337076546, 34.12994340872563, 33.560034032221914, 34.09806709351179, 32.694016553393524, 33.222933860264035, 33.47735327533321, 33.982865083565265, 33.24418840615427, 32.93069260453585, 34.92319514305559, 33.833727116933545, 34.07812446055445, 30.97415256127067, 33.77435664550559, 33.93196721759039, 34.03685637302218, 33.97828294607764, 33.916176575622934, 33.357048991628915, 33.99340920394607, 32.75226187020831, 33.150387624795144, 34.38404655839576, 34.33317487457199, 32.05804969232579, 34.58993466270236, 33.132941498378166, 33.382208100588045, 34.16509745384893, 33.12536419621594, 35.33261775539979, 32.89123475331947, 32.87603787124276, 33.673216951449966, 34.10381312255564, 33.88645100208968, 33.69453255186093, 32.930001974966416, 32.903690237697454, 32.83605392169863, 34.3012256949802, 32.68865796529365, 33.87938444994205, 34.116612771814935], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.59348918212253, "var": 0.43734727127791334, "samples": [34.055722134535465, 33.231397609904505, 33.2747566647223, 33.14770556479545, 34.16492102001862, 33.04434722325608, 34.34794057032034, 32.43588082854287, 34.39010833951857, 34.10281383298382, 34.46786746747764, 32.77021869460979, 33.072136642189726, 32.793158412872835, 34.6718253873052, 34.45868798006388, 33.02816607661868, 34.49673094560409, 32.86158453116308, 33.5259799029666, 34.39046211993355, 34.72182780566428, 33.48366026923681, 33.83451006503058, 33.66063306111131, 32.900630217501316, 34.588040459855236, 32.81463134580355, 33.26129457338418, 33.78827168936401, 33.96051754945456, 34.56786183047898, 32.76471291832257, 33.34640776494418, 33.92170745681334, 33.45000527752592, 33.140137625674456, 33.26829477568498, 34.785969185779194, 32.82175889701368, 33.30960617174892, 32.34989666362184, 34.29468357126872, 33.40017990484757, 33.618008423237924, 32.997907026747946, 33.04956086026147, 33.5376788526754, 33.873570407307206, 33.43008250636316], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.669445332209136, "var": 0.6019389089776881, "samples": [33.884072265327205, 32.48339473340802, 32.577521736951276, 32.74045393158889, 33.32251038296623, 33.28645034614453, 33.35937616046549, 34.52315724581533, 33.739925570579416, 35.78212368663982, 33.897133000530545, 34.777593152901126, 32.905868759866365, 34.308359482613874, 33.309225970871736, 32.598873718576215, 34.199953315373016, 34.04980105828036, 32.801064844352524, 33.2363445476483, 34.126064539239074, 32.847221179797444, 33.74703503549159, 32.78026033267233, 33.21274278360869, 33.04686800983573, 34.00235317016255, 33.60155136711149, 34.011428103102936, 34.02722804978267, 34.706771762747266, 33.98754031834646, 34.45323824276092, 33.29347672727013, 33.482005313099144, 33.364672296644194, 32.642095623868705, 32.5615738149376, 34.57141970584117, 34.61714834145155, 32.22621712720958, 34.01344542362182, 33.07063964069202, 33.31067368819742, 34.46150666176067, 34.612142240463044, 35.06361275515522, 33.902771949510445, 33.50798042667914, 34.437378068495725], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.78094457151074, "var": 0.48020878404835127, "samples": [33.500326723874025, 33.03505614654011, 32.62232349451614, 33.495676796148295, 33.62495498489912, 34.396647201653586, 33.504609860931815, 35.53638678714673, 34.51164067335281, 34.05906477016439, 34.34176331092519, 34.37233039736743, 33.343724812511724, 33.780121972658904, 35.06917822504692, 34.186315667448945, 33.50157001875955, 33.70025293565476, 35.206853498596054, 34.82182840031777, 34.39732821714402, 33.197244632254495, 32.83816151165095, 33.84364572810981, 33.870938743215454, 32.73650362122015, 33.43845547511976, 32.753235348340574, 33.99410976982511, 33.13922118859323, 32.86582706024348, 34.27474240540867, 32.67741357326783, 34.05891207114928, 33.67748417343211, 34.021123268939476, 33.52532877723176, 34.57213407582014, 34.34592542630166, 32.970674020416155, 33.759865870641086, 33.29290075813252, 33.810507649886794, 33.33028980381001, 33.98596143334949, 33.23754301542524, 33.57772706991725, 34.5347455024745, 32.970256817726735, 34.73839488797526], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.80281037623423, "var": 0.7956173875299144, "samples": [32.41420061408397, 33.267010125052245, 32.40195924526866, 34.72632497360263, 34.043614277973035, 33.317684621431155, 34.02201753637859, 32.96286545531587, 34.21747444777161, 32.64838171758391, 34.549166991071324, 32.92696096828609, 32.75386290463934, 33.34213902859126, 32.79190218676122, 34.632497393210826, 33.76683265366747, 32.864372567306866, 33.328743977556925, 33.579944573457986, 34.27193134754165, 36.13782696043508, 34.111890308213674, 34.598837407965334, 35.39568909116173, 33.802362644112804, 34.66358786118105, 33.09854452400827, 34.834391624621006, 34.749726684842784, 32.83755247793562, 35.097672073050255, 35.08477489667078, 32.70874872302014, 34.19705822580972, 34.51617436160787, 32.961602905529745, 34.7971308287439, 33.37789446394897, 33.79227820902971, 34.1618208200742, 33.42921036014773, 33.161191765535975, 32.84869474598268, 34.52673921044724, 35.312744477616405, 33.07688940389383, 33.38595628125919, 33.64987546196185, 32.993764406351275], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.61444531231154, "var": 0.6033574869665471, "samples": [35.053474515098486, 33.816204185076266, 32.924840889353284, 34.18523740990509, 34.594496786644434, 34.787486375313854, 34.31945411834725, 33.94189707785658, 31.786715855479045, 33.75016895808133, 32.856698900656724, 33.288837806409, 33.992176557481876, 34.3388041720068, 32.7664513369127, 33.13157067435958, 34.21101473950272, 34.59981095266172, 33.97512748385324, 32.89990032839421, 33.64741473040252, 33.21486223068805, 34.85199329311962, 34.131641587657356, 34.17592798066492, 33.459259422673696, 33.87346923269507, 33.925487600953986, 32.93368980965459, 33.091435060583464, 32.61332250127701, 34.12179676607898, 33.787583369260325, 33.81975279304646, 33.7286273897797, 33.18679403780148, 32.60768994821036, 33.257311642565185, 34.64052884483914, 32.62583524997243, 33.906617272512676, 31.312508526525363, 32.924341881493234, 33.315568576557666, 33.827845149158684, 34.62934030950024, 34.012559134952106, 32.779040364312046, 33.93416031188265, 33.16549147336358], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.69802126234023, "var": 0.5160179947037388, "samples": [33.516008404976766, 32.472112445715815, 34.109632542506006, 33.73951719578175, 34.73493450493641, 34.28706499637721, 33.265132436077835, 34.72518890927231, 33.261379651898785, 33.13791294394047, 33.412911949532756, 33.5855309448372, 34.7029552597003, 33.05620999621518, 33.389406899877336, 33.258999232321706, 34.69688044100786, 32.95394455021661, 34.92930628958532, 34.16545684355259, 35.443366295242086, 34.41907809871292, 33.544484354499474, 32.45403399201962, 32.859204651821294, 34.43254396242539, 33.62738326815872, 34.67076248131619, 33.48731249943855, 32.89873954744257, 33.407111161898946, 33.05629747490874, 33.46838232594303, 33.80931291696062, 33.15896411953927, 33.78541325783355, 33.073304282384896, 34.10574663144177, 34.7551779426464, 33.9096819110268, 34.66077587924207, 32.75843745844679, 33.19539169975762, 33.593623594688886, 34.80097133189243, 33.11363798856716, 33.70940469213093, 32.98126549157415, 33.19467902668107, 33.126088340038955], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.539069661068744, "var": 0.4514233727492317, "samples": [33.73590141828205, 33.09472559026207, 34.46980809492489, 33.92741135875253, 34.36736779002234, 33.117892285428404, 32.77441484091314, 33.22841116267881, 34.08423841941046, 33.63870771474973, 33.635387559160954, 33.44307079626632, 34.59572544083352, 32.793553836366, 34.16162552435748, 33.64584245523221, 33.28725421764303, 32.241789640533504, 32.472836806211966, 32.98564977540572, 33.88425923645711, 33.69658762779827, 33.0997351081964, 35.48785678735685, 34.154537975413554, 33.423828375959076, 33.466787709326496, 34.35868017710823, 33.29120473344081, 33.43930072728315, 33.26832968319237, 33.189392784778214, 32.834784291059336, 34.54003004461887, 32.93146865931151, 34.560679188590186, 33.19869233691296, 34.242917454750604, 32.95049736821436, 32.92812123426995, 33.43469502918079, 33.62155752930287, 32.83459358169859, 34.042853779042, 32.3002492459463, 33.46821649556147, 34.478978926501426, 32.88261546030076, 34.060592870839265, 33.17982390359045], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.63102801634345, "var": 0.6069827527501828, "samples": [34.1543700293594, 33.539896466752225, 33.0067873011033, 34.437378068495725, 32.621736364682796, 35.057556590500255, 33.077808301139186, 33.55815160280582, 35.033540174448305, 34.72202162582723, 34.244735650335656, 33.65024646505134, 33.59492155445411, 34.04618758853699, 32.35352183586471, 32.66255658824896, 33.58943343310368, 33.756182713906725, 33.194276692552265, 33.03981239874045, 33.83137856191732, 32.69040612432299, 33.94494706385416, 34.06019302798708, 33.46291639923137, 33.78891569639247, 33.48665609225028, 32.416724932243724, 33.68604120703521, 33.78156631508396, 32.61453879344782, 33.27380938290162, 34.00027334515437, 33.915640901886434, 32.922478360145995, 34.50935933855374, 32.961792150099875, 33.41271422479319, 34.397296441606194, 32.68931589884645, 34.58209093233209, 32.80023368205849, 32.07063861362332, 33.83545836564985, 35.85708095601134, 34.49506456693552, 34.5332259194833, 33.344949486070824, 33.5957225274193, 33.24885006392526], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.639664107783496, "var": 0.6961476210521569, "samples": [34.165709614328264, 33.83906019363555, 32.95003257840553, 33.74902331764657, 33.48025208520868, 33.69316775444237, 33.35155743935627, 33.37011829257081, 33.56115638187348, 33.04631116145309, 34.78193154404611, 35.66111368778267, 32.39926233614811, 33.12030942668819, 32.30470235827137, 33.19744415183726, 33.0517638186717, 33.3610224091243, 34.37278590925415, 32.260562518224134, 32.81813288262676, 33.99787012854376, 33.750145334693805, 33.99556051717546, 32.0014212551489, 33.28249618186238, 34.956766872609315, 33.464640579399045, 34.2582330141769, 33.68574548484707, 33.67557546502114, 32.661977456043246, 35.05398516859822, 33.68331238352795, 34.412333889299674, 34.80593105488739, 32.89521278665117, 35.09134748084074, 34.65334788114055, 33.78398587742634, 33.41230928952044, 33.021205676301356, 33.833192580354954, 34.771416184173795, 33.355874130015565, 33.04163962543673, 34.13050726014281, 33.89480546357209, 31.773329815780766, 34.103616690387895], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.689080601499356, "var": 0.7940543564872464, "samples": [32.888615909501915, 33.36247165161416, 34.370811155972476, 33.322511874501366, 33.46869266677941, 32.1283976811464, 33.749453187617846, 32.52979159892768, 33.96233545709686, 32.75305194111703, 34.868493769262834, 34.51798769135973, 33.07075324848576, 34.15680177947039, 34.04592826076316, 33.41214195651483, 32.849145876150324, 33.39673545440505, 34.570187720557094, 33.51284834739162, 33.43873645223633, 34.28272446074201, 35.02055595475653, 33.18232350827906, 32.62973070054616, 33.84159418942655, 32.32607024611101, 32.587830431544326, 33.05296302828284, 33.919444048427536, 35.03384366271934, 34.76778381133532, 33.04359247218402, 33.922911974870495, 35.051940131023656, 33.28573645068189, 34.381243988595, 34.04495051461705, 35.723226982066606, 34.67235163651236, 34.53446523284184, 33.815672276170226, 33.918807543606775, 34.444961127818516, 32.948597897141546, 33.94852143121475, 32.80082065099895, 32.12336428423159, 31.867654911859486, 34.904452845490276], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.63035809293726, "var": 0.5021495080925938, "samples": [32.128550111441676, 32.83469050090722, 33.808366042450665, 32.829224868155, 34.9990146357363, 33.8061685896799, 34.543183574979935, 33.12158486287406, 32.69510552929573, 33.61107240673109, 33.0209666252948, 34.34720655846427, 34.285010853601975, 33.858577356000815, 33.30125108161649, 34.37329798497119, 33.03545443084079, 32.992167473570596, 33.65388463544251, 33.99411091533243, 32.831099419170755, 33.49099003445391, 33.51998376535058, 33.67209457242173, 32.88192644578159, 34.454348429666844, 33.380105767248196, 33.15372421346388, 32.35652341323435, 35.210854653146114, 33.475013769291806, 32.26564592315966, 33.66949633919989, 34.28121476043927, 34.425794362251736, 32.64633919181178, 34.3183969558954, 33.48066575121175, 33.54417091813708, 33.81381507995925, 33.894415445919904, 34.04982906499662, 34.29775082682919, 32.896183117361765, 34.6786624591107, 34.3183969558954, 33.9288597231559, 34.05849097069642, 34.09230125070248, 33.191922029511495], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.59270065579883, "var": 0.5607046726253513, "samples": [35.85844163579011, 34.399493137980755, 33.920513444621456, 33.41666783170267, 33.53524811062186, 32.022269923972736, 34.02050702681773, 33.97450680471891, 32.673943061801914, 33.030862686643594, 34.51255423718994, 32.62851967195253, 32.181913162000924, 33.49606853556019, 33.51536037364884, 33.90191349587668, 32.824094799568144, 34.21862302549804, 33.655842910210026, 33.85333986880094, 34.77388089470633, 34.28735920134977, 32.77986621344791, 34.026703915657706, 33.925161955056446, 33.67995810601954, 33.202663089260724, 34.33105183806738, 34.00650497745923, 34.12396610050217, 34.432343535439266, 33.12118897107768, 33.07899329145731, 32.240570584857785, 33.989094786325516, 33.0336330446003, 34.383263414995604, 33.047935877763145, 33.20500177520479, 33.307059032069105, 33.27805594353699, 34.00391676508856, 33.64985267455128, 33.92984900871251, 34.04483653674723, 32.18425187071519, 32.70979634231179, 34.33631997681354, 33.629738242320954, 33.251531078847385], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.4791582796185, "var": 0.3857189199578571, "samples": [34.272681303888106, 33.3033659129131, 33.517906894825444, 33.048000754618556, 33.90267288317016, 33.501471149341064, 33.87412391833786, 33.625007127874326, 32.81833844643469, 33.09751730682573, 32.42672533312165, 33.33736543466155, 33.49250092048104, 33.8456814239377, 33.23177748407946, 33.89975941610367, 33.602446110674705, 33.87517740282131, 33.96805182119992, 33.82988833151702, 33.640599927364306, 33.54307471300973, 33.83071309607992, 32.74115091757477, 34.766428747763946, 33.13787167200699, 33.193796313847116, 32.0986904817467, 34.17808765475048, 32.85461325890129, 32.54172228202594, 33.57724505798742, 32.92936998081031, 32.75883815808428, 33.196282305602914, 33.471078845336415, 34.163686670819665, 33.19441757991337, 34.038130618739515, 32.78921307391033, 34.363551603004616, 34.0373086985165, 32.23311433791238, 34.267535547473365, 34.827919458060215, 33.62328314556788, 32.449951972725266, 33.34192843751825, 34.12613022106031, 33.571719825983905], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.68805373788207, "var": 0.6574858527365085, "samples": [35.266913922220496, 34.186650047240754, 32.82483774206187, 34.436002972782916, 32.60164054539002, 34.14390591498821, 33.81537088011231, 33.337033799891636, 34.077953313623254, 34.537205274525725, 34.69236547831732, 34.55726703575438, 33.461795247236616, 34.57976325319244, 32.99900429589588, 32.45267849662842, 34.11844000204435, 33.17865448288167, 33.96376822158749, 33.25847229791925, 33.70025293565476, 34.81873908844474, 34.43973334828752, 34.20630802289628, 34.851829422630225, 33.253615904337416, 34.537373626747424, 34.6363305065035, 32.66255658824896, 32.65748733804357, 33.70032390294762, 33.29392096334038, 33.70534590765075, 34.72632497360263, 32.2743961748145, 32.865817889768316, 34.12761908132882, 33.41584903202657, 32.16388494723288, 32.45047847702223, 33.177196159301914, 33.60248389855926, 33.482566379196406, 33.17408075090972, 32.363890536387174, 33.561460732005365, 34.33804001079447, 33.224468928750845, 35.09286909127148, 33.407719051102895], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.46951093967429, "var": 0.602103792966445, "samples": [32.95889559270715, 33.837590806959575, 32.0461280224988, 34.019748783340845, 33.239697079500615, 33.169986314149185, 33.513708809947616, 33.50509276328117, 32.747232498508296, 34.47639207461998, 34.800197095044176, 33.182115988302264, 33.39392933406084, 33.816382599347875, 34.43740542587288, 33.263684126108195, 33.23850561144135, 33.66572749875556, 33.402743513288094, 32.97342389259634, 32.701423655673935, 33.46531281724835, 33.482005313099144, 35.10569906077211, 34.14277448298711, 34.12728915589052, 33.06178138371076, 32.28885450420748, 33.87347386108453, 34.3668194726018, 33.58398153628847, 34.38585849329358, 31.474027062390665, 33.22700213213529, 33.43742259738801, 34.04895540970441, 34.88431422373457, 34.17926090212504, 34.21134064707199, 33.99275677290389, 32.48898175980683, 33.78911490177606, 32.03366012370306, 34.00306476619436, 33.28741690458654, 33.49517486714597, 32.54477749545461, 33.012486161538874, 32.13325505455817, 32.95867363430759], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.61927524602125, "var": 0.5515691516046791, "samples": [33.715320978827656, 33.95411165436198, 32.77201795410347, 34.11701760995734, 33.23066310932615, 33.58866504522044, 33.448653642774126, 33.92984900871251, 33.266589931904434, 33.62908680171434, 34.05263710207879, 32.88056852260526, 33.731924429577326, 33.25217043254677, 34.72281991682804, 33.14504708316393, 33.696624353925834, 34.82144245623023, 33.0517848337372, 34.45540809464684, 34.72761866053682, 33.12129775660593, 33.50592442232635, 34.36964682545575, 33.57046741246554, 33.651711675936305, 32.41053514964998, 35.27791921707874, 32.446013792923885, 33.51741834262837, 32.05765045797191, 32.28562289156703, 32.33468655439697, 33.65086107945993, 34.64599454249941, 34.57206800381775, 34.59149805862858, 33.25393784716457, 34.23642546339609, 34.194836119772205, 34.172855026551936, 32.94650300393688, 32.8405763925179, 34.380587670458446, 34.121526598918614, 33.30103090714869, 32.8756050095819, 33.126999239772445, 34.086359804599695, 33.22718141105138], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.74662659676557, "var": 0.6668821516785084, "samples": [33.80465967237426, 35.661844474624125, 32.70072740957748, 33.331072143629925, 32.67965256430569, 35.15606273226939, 32.921792066716506, 33.40861165719613, 33.18960750683644, 32.776862151093816, 33.376910867796745, 32.99831249337962, 33.52764524131079, 32.88921301136848, 36.03140842195522, 32.99992891933286, 33.04735396847694, 34.822086271912355, 33.34450945693323, 33.62463889801686, 35.01838906812306, 33.97679299526267, 33.79989467250564, 34.727304573153205, 33.613284738422045, 34.683324696640575, 33.75611698041727, 32.187989303775886, 34.027128545687454, 34.11274042467905, 34.52593710386709, 33.72245086452017, 35.657992274182625, 33.15511059100294, 33.25911484772668, 33.13821316786356, 33.363123343910964, 34.011278105621926, 33.849250384364574, 34.32819644968319, 34.24963665164562, 33.796013314793235, 32.97849351581507, 33.58858469976949, 33.84182266070579, 33.518222715964804, 34.077500341742834, 33.38701280776472, 33.479793010449086, 33.20771705911035], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.72927172233193, "var": 0.554151971913637, "samples": [33.8873794637162, 33.950152080160606, 33.382380888484406, 34.20599353742619, 33.74222833131145, 33.58005489762071, 33.90838275572626, 33.57110459282084, 33.04313381382109, 33.87742529287598, 34.11668978768758, 33.21197203774018, 32.74131327977537, 34.233392047989604, 33.409111505221254, 33.023110496578916, 33.16455605464195, 34.28784214926197, 32.963839260380695, 34.028565896680675, 32.939349322143755, 35.09242417341201, 32.478327585531765, 33.949776140532855, 34.546698049104776, 34.2270743601401, 34.2428279132463, 35.16089730659592, 35.50965147065034, 33.9282363796287, 32.914768486191974, 33.85550038907999, 33.37916967168919, 32.321741260468364, 34.06601050652416, 33.856914710097286, 33.55299378267468, 32.41961276252341, 33.70532697068569, 33.12176614960392, 34.537652138812135, 32.71186970436411, 33.67277631076366, 33.44750636266939, 33.89207653233619, 34.1093367204147, 32.36505530441638, 34.964823531868134, 34.22463092905378, 34.940163021450964], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.745398240135074, "var": 0.7538074064368079, "samples": [33.67235369173326, 33.14629568251409, 34.91093283982421, 34.79645310428417, 34.1234936180609, 33.007561263556816, 33.49962637793293, 33.381875108283396, 35.050433844198594, 34.58681185047104, 34.110944139190906, 35.32635161138742, 32.48831290128698, 32.79897227819955, 33.51239232893676, 32.388577563096504, 32.345577308687886, 34.90556453850132, 34.86050806820955, 34.113666945609644, 34.06111069209766, 34.39310757239803, 32.765330902351955, 34.52611771058037, 33.59870069541802, 34.15886021397293, 33.28295448240611, 33.39407174074881, 32.77380768897043, 33.03634721798719, 32.04191549128275, 33.07769074639334, 34.48512112304502, 32.889295450770014, 34.12396610050217, 33.07267605680364, 34.06109506133864, 34.86214361753903, 34.65181974731121, 35.79292459815047, 33.2988590734526, 34.37786702069749, 33.56435660628429, 32.967176208735424, 34.12125046758479, 33.314731041616746, 33.701428931316855, 33.02502757659096, 32.64654805999747, 34.17690504644315], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.48312831022681, "var": 0.5925959400175326, "samples": [34.725374711512735, 34.07752833111871, 34.79829133547855, 33.02683602136244, 32.91540154068097, 33.38762630173544, 33.85257310586831, 32.38687714968433, 33.47566286718745, 33.337601185223846, 33.60907674664098, 32.44338364037059, 33.59184890025661, 32.05945043797867, 34.24899500803077, 33.33068149464524, 32.819883957450536, 33.622754589984396, 33.506796671598714, 33.03620033738412, 32.345055190284896, 33.37011829257081, 34.3644924855972, 35.11423467586919, 32.28394361512836, 33.55082495695978, 33.734876039180755, 33.61944950497834, 33.1640269453411, 33.982932298534394, 32.73693027473049, 34.279123946128905, 33.449728281443974, 33.399653657412856, 34.86565784651769, 32.56800837114303, 33.40013527051144, 34.04192256399915, 33.65550896309325, 33.45305947964883, 32.423024956880155, 33.04087167925393, 32.253470384746834, 33.15329300795575, 33.03459648495921, 33.329714605050995, 34.7483507086329, 35.323679799849934, 33.64986209027931, 33.56702480046388], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.75034945856149, "var": 0.3599206603283205, "samples": [33.0147367057061, 33.21464859078454, 33.60394775422567, 33.51784388497545, 34.015565533041745, 33.51062423488847, 34.04980105828036, 33.956254814690745, 34.4014949746205, 32.79628231100679, 34.01234141660814, 33.433204994351144, 33.6468957862719, 33.70488312141161, 33.2452515020505, 32.96797851707945, 33.29356033596879, 34.80301845509186, 34.11461937676921, 33.669399135791124, 33.594800549630655, 32.90559833771707, 32.98927910563886, 34.12246374932529, 34.977646649410005, 33.99123458434313, 34.44891504328519, 33.8820279321058, 33.11545814187633, 33.520348429148704, 33.68254831006728, 35.15811776675021, 32.6780289549212, 33.648824189330895, 33.37235008859363, 33.828853624960495, 33.791351247387944, 34.52011865766833, 33.41306402636696, 34.33387875392311, 33.976177048644374, 35.105494764948126, 33.40528444008533, 33.146976646362944, 33.88326677411414, 34.40384532626939, 33.37949740247356, 33.93074405286946, 34.478634855613414, 32.860290970628576], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.563924226378774, "var": 0.5596654611232443, "samples": [32.723347839104974, 33.50395064770994, 32.76663740379327, 34.82533492765616, 33.5908544386057, 33.76392848764142, 33.992863112273675, 34.18562107521667, 34.35333880394697, 33.619854495980576, 32.47696211758336, 32.610671214320575, 32.96069024183709, 34.24597793680422, 34.00121505728663, 33.987181039910645, 32.82759031083929, 33.671714077718185, 34.569799235967366, 33.04355045242195, 33.89746765692362, 32.893682468668516, 33.45226513687426, 33.890623262188505, 33.28614982469965, 35.0773871782157, 31.971364131680872, 32.782812412300764, 32.243712866255585, 33.31362765338308, 33.04735396847694, 33.344169572661386, 33.29352114863068, 34.06415384904954, 33.11139431522594, 33.55255135970054, 34.284477537655384, 33.3016882459537, 34.674004041054786, 35.29355348654752, 32.61600912844132, 33.92030070827706, 33.2528071721329, 32.98656879130008, 33.2160113739708, 34.347700860893035, 34.330709614562835, 33.916506520461425, 32.671684961590046, 34.4408691545434], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.586497549529696, "var": 0.47295018955145246, "samples": [34.36232401979254, 34.64550987749063, 33.882523404703264, 33.318126998909406, 33.08264770687604, 33.52286562237943, 34.578990463972275, 33.74326723921336, 34.25477915240589, 32.6628161058051, 33.43942282881131, 33.49343017970345, 33.832556746562304, 34.22005572846119, 34.29321340396935, 33.26546983645127, 32.30976320299664, 33.03857777716723, 33.75630984923977, 33.36205737576032, 33.234789039654984, 33.459443968524994, 32.02450268046718, 33.58239644839117, 34.774426043374, 33.634197290316706, 33.1333692817611, 31.997730268932738, 33.466478671208186, 33.24518252927314, 34.242127375069245, 33.36784014167361, 34.82141274329644, 34.46576555027785, 33.65898234092647, 33.31422409621141, 34.58066786713722, 34.13123674261868, 33.60400806844464, 33.317552534674164, 33.92461344890065, 34.56481179303884, 33.3895971636346, 34.05079655667805, 32.15221121984659, 32.72529993556723, 33.42401074623451, 33.59262328326585, 32.98027190706956, 33.3996002193443], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.66585043350206, "var": 0.5086118682646695, "samples": [33.93540337433784, 33.19043871953943, 33.863915570221295, 33.259130622633826, 33.11146787138708, 33.54468167405075, 34.57665905785799, 33.45696885672943, 34.24349788708829, 33.2747566647223, 33.29970127591987, 35.20802566158654, 34.24628196031147, 33.101590068965955, 33.495512065426794, 32.110895334997075, 33.65880437974667, 33.0622042448961, 33.56510902081655, 33.899598615663606, 33.98297913865068, 33.18708052130804, 34.00282329794011, 33.73752920410619, 33.54076544725315, 33.48680554884218, 33.50460289153917, 34.33730480873886, 33.93526213626332, 34.87679828997646, 32.25306766639873, 33.55815160280582, 33.90123580067099, 33.13104352857384, 33.605991752438506, 34.60058060266618, 33.591698004021474, 33.36105319903068, 34.50244579888392, 33.072620881222655, 34.08132335935978, 33.2608676514235, 32.810802606612164, 33.68486588592501, 34.85010007842549, 32.18151375866699, 34.17336718268136, 32.260023536091644, 34.68979359196962, 35.025380975717624], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.679376389291996, "var": 0.5630499129996972, "samples": [34.43769584813316, 32.85918504548363, 33.91563366510313, 33.46734620601295, 33.44748578899951, 33.80956377425242, 33.86337215212585, 33.8139155528874, 34.23776664188107, 32.77937265085213, 32.72154866764911, 32.3918250475579, 33.9732877436164, 33.97474409377739, 33.30299559658242, 35.174867427931474, 34.29064970276939, 34.45804005221802, 33.38791778461395, 33.30282630750544, 33.86060280791918, 32.71193597902247, 32.408455541451524, 32.66627961563046, 33.00044091988821, 33.987542157562736, 33.78464843256716, 33.93949184808487, 33.57409272442513, 35.43056331448067, 34.184699325023274, 33.31092980238473, 33.63080342910237, 33.57251424512717, 34.99442449243453, 34.21764997744531, 33.59933769043707, 33.2225303111599, 33.243255119795165, 35.32560668921122, 32.74668691752045, 34.429123801776676, 34.4917943284602, 33.76697141215202, 33.55566888709229, 34.522237847332796, 33.83426275771417, 32.37933573470587, 32.601099091817815, 33.36579451292141], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.53061492825038, "var": 0.6033099839303652, "samples": [32.77730110544738, 33.82830700741889, 32.940891163423, 33.117406704340866, 34.338602035596494, 34.08200110519502, 32.50989143452028, 34.256496712265175, 34.501958746630464, 33.765213954817405, 34.63774962977633, 33.90310830541474, 33.54074729773536, 31.595546224175227, 34.77492363712463, 33.604658174251774, 33.965598143251114, 33.00404027709652, 33.65288160188519, 33.75328397259572, 32.66325066436628, 32.212894157230494, 33.63970381654125, 32.555020317669985, 34.47935975536713, 32.62379844961557, 32.92482988893387, 33.02901343636587, 34.176648206168565, 32.745370902650706, 32.64037359351142, 34.02781446214752, 34.090147920089606, 33.54160513509011, 33.13346366747675, 32.53338894768719, 33.524695780003775, 33.75168898390331, 35.1292135493193, 34.429814196280454, 34.77247236291356, 32.244344344909514, 34.21687164544785, 33.09024712092292, 33.99196351448756, 33.53205457254126, 32.89956342693822, 33.70256062819629, 34.179277192710565, 33.49868854007048], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.768506703495206, "var": 0.4360702061348793, "samples": [33.76496032167575, 34.265003664926844, 33.36627587859719, 33.17170057139663, 33.53525981573699, 34.42648554714292, 32.59428269798805, 34.400462654789415, 33.08142186665527, 34.466185449326126, 34.506057557659354, 33.41886820395571, 33.94127354065376, 34.289673713514524, 35.23823966806992, 33.617283621660135, 33.55976812803851, 34.09569051717857, 33.932125107153205, 32.525341588130274, 32.98240520894559, 34.0715714684408, 33.29625923201978, 33.48891041456578, 33.59826253638903, 33.92034551088704, 33.7203857685438, 33.85043007890333, 33.97021033897787, 33.72696605988109, 32.77944027887009, 32.936781448429514, 33.43243422908929, 32.57188576836, 35.03789009289017, 34.807945356397106, 34.981514732980685, 32.65617620471128, 33.18721789803506, 33.472992055381255, 34.729209333132495, 33.65070494244813, 33.60053889568728, 34.25579976313142, 34.047433545267864, 34.092081950464056, 34.33604501601333, 33.132137840171254, 34.24240505315668, 33.65259403833997], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.20087099075317383, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "923425"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.51930922712855, "var": 0.7045052236142737, "samples": [33.53360624093007, 33.23183201692105, 33.163665609081406, 32.96072222759872, 35.52334220891842, 34.24760372884014, 34.744345632319146, 33.885400342368115, 32.941268740298185, 32.01218797506753, 33.0557868298017, 33.539147454808514, 33.74150106986258, 32.30496639319965, 32.50985032332184, 32.39654761250712, 35.14983804198441, 33.48523675247827, 33.13952872888643, 33.47128125457036, 33.537037533334576, 34.12530214976717, 33.52427960747682, 32.93583127657206, 33.82420439907834, 33.00819451718472, 33.433195467544955, 33.881173548701625, 34.17101933773457, 33.34825847147047, 33.091043138501476, 32.67172112551377, 33.33976678309559, 34.99727280138069, 34.42637853052939, 35.33134059016032, 32.78480329226771, 34.97740122720138, 32.49963364952249, 33.70032345736009, 33.03943028027098, 33.45639585209818, 34.307053593181756, 32.63566721186245, 32.45938898891309, 34.762669100577256, 33.1061252635393, 32.90174503013797, 33.972868392336196, 32.6782775553487], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1675276756286621, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "263100"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.480855669946365, "var": 0.5161307518366245, "samples": [34.34889183188608, 34.06224081319603, 32.938787735680485, 32.35828819533306, 33.95595074300863, 34.11658356748016, 34.80821124563234, 33.11378786138191, 32.895629919389506, 34.45664614674886, 33.72702588938128, 32.941806149172216, 34.02000282727158, 32.33210636825417, 32.65166911121955, 34.04293454199969, 32.56142872249276, 33.34639503287609, 33.023574882450426, 34.169941392796616, 33.65276399465475, 33.64416704616532, 33.69481909477641, 33.40653978242206, 34.089968448537334, 32.94921863884004, 33.49127710744102, 32.96272824663293, 33.164279858146806, 33.12908019763493, 33.94589697539841, 32.581606198046856, 33.47955090901524, 33.309071026173406, 33.763558933733584, 33.08889040682107, 31.565565699965155, 32.713293423895166, 32.2393821647847, 34.26506283337996, 35.063916422564716, 34.74437645452678, 33.35793677368048, 33.50945118949229, 34.1239739130819, 34.093122874855666, 34.05875069402886, 33.38984940294928, 33.158430298617624, 33.53435150940416], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.17325043678283691, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "330275"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.70392710870837, "var": 0.6675554515068047, "samples": [34.73613798155636, 33.66623661103804, 33.50663215270753, 32.758080727912116, 33.26738435347494, 32.523946038373495, 33.38784180664097, 33.897085857093145, 34.254865165599355, 33.13838294200851, 33.20527770628782, 34.26749173873367, 32.29915349492898, 32.98503468254074, 35.1351098460771, 35.465379383309966, 33.48252471010396, 32.96336762626569, 34.675554279376456, 32.88010139616536, 35.24242089840565, 34.10767275773182, 33.749044881641815, 32.88607981252815, 34.64244514647381, 33.419608285107856, 33.49246861534023, 33.37721321184496, 32.90423729608153, 33.02659980111161, 33.86473765487083, 32.91441458761281, 34.6052861917308, 33.949942383235935, 33.4455930124405, 34.65818435308794, 33.598144321019916, 32.69525904130254, 33.887517972480154, 33.84153497429111, 33.01987512479376, 34.96476423979933, 32.661969686511554, 35.22874088814859, 34.758903049308955, 34.0914447058444, 33.545062331108255, 34.488014760218746, 32.8217088273784, 32.81187812377234], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1719365119934082, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "27387"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.818015130292494, "var": 0.7674698776066373, "samples": [34.224968422520085, 35.14069844511345, 34.46276378917202, 32.95853699569652, 34.29079371625994, 33.67504734140051, 33.61178359499062, 32.684516605079295, 33.458780744685285, 33.57715250036039, 34.534709272360175, 34.13271591190938, 31.98896449675893, 33.034776915441604, 34.37578729127919, 32.53481033782175, 34.29101167061866, 32.8886647939847, 32.157513519701, 34.16618211644279, 33.56273990236429, 33.88489905782056, 33.71377434631286, 34.7596064973792, 34.669914636457435, 34.20097195512826, 33.78628366635254, 33.89716361184462, 32.768419685532564, 32.9699405292114, 32.56308990095605, 34.3361587476754, 35.226184468010885, 33.85797548560703, 33.84505630709526, 33.67929491875031, 34.864561574542066, 33.16251442925846, 33.23981934134091, 33.87732598989504, 34.08192191635691, 34.40924425617818, 34.38285572868661, 34.09903536893118, 34.679272257633876, 32.01103528204864, 35.70899199588627, 34.33389226840712, 32.63538432701795, 35.50324958034632], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.18583989143371582, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "891120"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.61240931605103, "var": 0.33413589766708135, "samples": [33.232850637862626, 34.67539736301197, 33.776003079002905, 34.09888092016595, 33.1160951152909, 33.06948884285637, 32.90013458379006, 34.36834893753291, 33.836078806714916, 33.685420764787764, 33.47672748517332, 33.52887837659375, 33.75168575353125, 33.92444292618991, 32.240237796220136, 33.65554550945093, 34.23794351452503, 33.33572741789021, 34.63385025167544, 33.78492578004384, 33.72665926883516, 33.01776552140007, 34.27392490109911, 33.36965828147087, 33.811242711578494, 33.83177472116485, 33.990471557702314, 33.837830765718905, 32.9553860037004, 33.71395688525011, 33.55833294758233, 33.02446311984343, 33.4493886821345, 34.215071442903636, 33.769183264095886, 34.43143267179737, 34.32812482615731, 34.078415638484806, 32.54719035172332, 32.95109570765162, 34.2507711127742, 33.0098617115258, 33.251861933613114, 33.2927257969424, 34.11293822513291, 32.73538865378664, 32.65564230116226, 34.02203000954338, 32.77994709162175, 34.29926583384453], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16940569877624512, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "475670"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.49900356511733, "var": 0.7416354598839668, "samples": [33.344221211694475, 34.53694395125311, 32.97098973620754, 33.7739216359321, 32.1386504054927, 33.1177667749109, 32.919030886547695, 32.3761750853935, 33.19199546876595, 34.860603797321374, 33.52884605597291, 34.567134929287434, 32.042709490368956, 31.897982902140676, 33.69541953896591, 33.64063052522053, 34.0668653904915, 35.204521958012485, 33.380642265071856, 34.053851840580634, 33.296649229319996, 32.04153830405984, 33.11784399650854, 32.54840086935725, 33.57606719088136, 34.10068007615676, 34.483347401984894, 31.84027252740983, 33.19096053635573, 33.85231620317598, 33.89192392567522, 34.700276469901894, 33.393054765784775, 33.34362022498574, 32.29486600999745, 33.79476782101261, 33.415103365102674, 32.50922158774705, 32.56529246743912, 33.034620513918206, 33.30750431844895, 33.783492159503126, 33.80145347193334, 33.81074101012783, 33.51391896341125, 33.347049457243315, 34.62967132299208, 34.71287607758421, 34.492302569360206, 35.2514415688549], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.15746712684631348, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "722118"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.71461887638387, "var": 0.5954122448034821, "samples": [33.29279883766192, 34.55228952331555, 33.64361980759732, 33.631996259914146, 32.39587594981057, 33.39644571766285, 33.26827264843047, 33.33610080451387, 33.23703433176917, 33.6241946585736, 35.180646828579405, 34.404727207648854, 33.33385741987189, 32.96198227721844, 32.06671900025923, 32.38252899327703, 33.37702560296832, 34.3485542704524, 34.974255570334385, 33.60687508922069, 33.59717428417953, 33.143870286010426, 33.373734101351715, 34.915698711539605, 34.03557276427948, 32.17621325589765, 34.89312405488646, 33.00961137221121, 35.2373729896304, 33.89504354338701, 33.013655680250146, 34.22444800546793, 33.400241781142384, 34.300866685647875, 33.58111969665351, 33.29777683554667, 33.75931564072753, 32.89597287817525, 35.439281461643155, 34.01015903082006, 33.96663465104571, 33.16353087358939, 34.34699210024683, 33.75022044721803, 33.58806085313578, 34.2279802425045, 33.98932682344362, 33.54413673753902, 33.29187901978809, 34.646128212154345], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.15205717086791992, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "54297"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.65489182151008, "var": 0.49325452917844753, "samples": [33.82777855681162, 33.98751833341001, 33.467439512266225, 32.78851396386514, 33.57166463120285, 32.34384123526784, 33.33888213053466, 32.657612629952055, 33.60583851933932, 34.65037128240385, 33.85454903328608, 32.80679363733975, 33.68809558828175, 33.440268306615465, 34.14305336140993, 34.39077748149795, 31.97439176668164, 32.22623690243296, 32.69359558773131, 34.85430651922275, 33.828591808503035, 33.61818923199843, 34.30856472692933, 33.534422432171716, 34.22128128093696, 34.947772521621935, 34.879932247351334, 33.2887019492861, 33.4597517073202, 33.438613158571265, 33.33813230836346, 32.88476365834306, 33.94562685430569, 34.28927156205283, 34.61992125068048, 33.898572414252456, 33.234832549502805, 33.74742382555323, 33.93226366499378, 33.591514169189225, 32.92422796614979, 33.03036766773379, 33.22759248166416, 33.625325993329085, 34.07770461220143, 34.45143917470073, 33.134622578578245, 33.884750899514074, 34.852198510691785, 34.21668888946024], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16646122932434082, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "812861"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.55967394292757, "var": 0.6952578450815607, "samples": [33.50088326589091, 35.27347667528936, 34.0259721471286, 35.333326524849504, 33.0120058820476, 32.33570033124131, 32.9255838305959, 32.99317771654964, 33.983679457547865, 33.53572925185873, 32.78223418576007, 34.08059851897242, 32.834417779320184, 32.8769117930146, 32.17088455057414, 32.622306900651424, 32.38597918574328, 32.81468382298011, 32.5941935662477, 33.45161554172871, 34.62482065217812, 32.0779415513222, 33.18814269063145, 33.94535464978842, 34.30236564846727, 34.91089315727846, 34.79719732858529, 33.957902564300056, 34.42062782811684, 33.530457608214036, 32.42675048112569, 33.51778753099458, 33.34541653096385, 33.17647865928576, 33.58003082930507, 34.83307560255279, 33.63307124483935, 33.66041470172502, 33.95466660362897, 32.46043080123877, 34.61457396413095, 33.70163504465157, 33.29049818020958, 33.41132188638944, 33.25790668342271, 34.963754465816876, 33.06312741150213, 34.58962318385494, 33.64328562331989, 33.57078311054613], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1479184627532959, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "92462"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.54047523050017, "var": 0.49763007363472644, "samples": [32.86980920370955, 33.939759006609734, 32.96648024292468, 33.63736217240111, 33.81630188319753, 33.23975713504184, 33.276277149769584, 31.848123114185764, 34.571563635439446, 34.08605120181098, 32.98438528693691, 32.75294910699367, 33.68850157234847, 33.19132930696217, 33.52880377008324, 34.33892904757568, 34.178783314048374, 32.95884801057991, 32.33740150037845, 33.07946466617189, 33.73897760517196, 33.27238351411273, 33.366483555421354, 32.57114942191842, 32.76261392295325, 34.705602257683566, 33.397701714546045, 34.27924060854461, 33.03970673463552, 34.246658879672225, 34.03103071127559, 34.410407635781986, 32.83300971688766, 33.808431329046215, 34.022408424559416, 34.24534232260774, 34.56823614433274, 33.94933625668366, 33.83763894420465, 33.63443930773944, 34.23122897071973, 33.63644962881871, 33.104534452964884, 35.43403672452358, 33.95519358808764, 32.7223500296856, 32.439211356771864, 33.06509745916767, 33.458393623304296, 32.96558635601678], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1562330722808838, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "360550"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.93087800236677, "var": 0.4282858844915083, "samples": [32.9269514224176, 33.73521008538639, 33.99095135918137, 34.47018915251349, 33.530665771914144, 33.0175321411116, 34.12763892263459, 33.635678643216366, 34.112695372022365, 34.78448127668171, 34.213994774532324, 34.8824644210524, 33.4318163398745, 33.74080339499297, 34.05623386466742, 34.770533741300135, 33.40224155123881, 32.674044216667504, 34.740136857649496, 35.04579386724225, 33.97869385322786, 33.647121416219555, 32.81817721286302, 33.4900945993283, 33.797492017401275, 34.137542660372205, 33.68706332754298, 34.48700469821398, 34.31246297114554, 33.63170369486731, 32.8430634277194, 35.47967856393835, 34.276484549388854, 33.533271167957544, 33.428081873417256, 34.64092319641005, 33.44797817711855, 33.57242902648156, 33.49018931626411, 34.02907814972125, 34.35361015963834, 35.29408367018917, 34.345297921185846, 33.09739114179298, 33.79198735490807, 34.44668530972694, 33.59590417574101, 34.80186891937317, 33.51802096361909, 33.28045942626744], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16393208503723145, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "602728"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.761130824462754, "var": 0.5484414963663002, "samples": [33.95154365416051, 33.762560792114385, 34.353765966431716, 33.381193849078166, 33.70932406702502, 33.420915537772935, 34.079312286829285, 34.51095399863068, 34.684726336215036, 33.853593049186095, 35.09176076954237, 34.747429151673714, 34.72908935828759, 32.58520185250759, 34.4685368483193, 34.275126675778566, 33.22621465163305, 33.133130508872384, 34.22451786650102, 34.43266560324225, 33.630742610893584, 33.43987177685951, 32.80322851358381, 32.92229282794615, 33.10246837282109, 32.83235105052297, 32.57930191136158, 34.104896251765254, 35.28718375441839, 33.40801682583238, 33.17817638386572, 33.714194766685566, 33.393214557264, 33.7777750849906, 34.55688181744679, 33.81552405006225, 32.137419360610835, 33.47776421353999, 34.06465189676618, 33.71000659031495, 33.319791209887484, 32.95189018585339, 34.054832553561724, 34.95470097614501, 34.483269787240616, 32.7345167422327, 34.42048967961482, 32.59997801749125, 34.60993731162144, 33.36960931813594], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16671109199523926, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "272437"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.833170782400614, "var": 0.6821138458877927, "samples": [34.35381888607088, 34.195472393894114, 32.63685081172222, 33.58126784487831, 34.21517760615875, 32.18617515500481, 33.62734398634504, 33.651096207071795, 33.22294563433445, 33.94739021316997, 33.83082535646343, 32.8647911856616, 33.93920474177004, 33.550888797367726, 32.74553768358389, 35.10856214759392, 33.14125923791434, 33.823827765739, 33.21053890417279, 35.48320178458113, 32.95979541801403, 31.87970603621422, 34.29779116971747, 34.107187991847496, 34.76244091837627, 32.92462338491042, 34.08204113703793, 33.35310072760154, 33.98491430262165, 34.457704334737755, 34.273596140391405, 34.49182306820579, 34.81209149911553, 33.561828383986715, 33.5926188954158, 36.00427110211435, 33.89409407503656, 32.83699847890882, 35.348858625637845, 34.64518093996825, 34.3786351563599, 34.29809501989601, 33.937087176546314, 33.86278368730379, 34.49671616961695, 32.63793824348886, 33.179716758882634, 33.32069461904011, 33.93228837323804, 34.02774094230012], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.15796446800231934, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "998465"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.719954373303864, "var": 0.4838905410064383, "samples": [33.40484410728983, 33.87990353222889, 33.17195007556272, 34.12566375734195, 32.86875167140844, 32.92557582251582, 34.310639409046736, 34.4937085575726, 33.1820856888063, 33.66361354599359, 34.49787632615656, 32.738923422822914, 34.01335486622185, 33.62023509692066, 33.71191357591945, 33.27527560533011, 33.69791368820168, 33.34029334857494, 34.157026597287924, 35.643164905281736, 32.00088534117964, 32.758392372767005, 33.70857732944303, 34.0288088982091, 33.62498805066496, 33.22779226446962, 34.12068287153975, 34.08220364092377, 33.939631946348264, 33.551504940683344, 33.87486923094806, 33.79120873046484, 33.54129141215502, 34.11140680847435, 34.42472546379001, 34.61776117086668, 34.85022731481825, 32.30060907038698, 33.16130712310632, 33.90662049120059, 35.19883547504976, 33.88773602827497, 34.049388364875654, 33.26389031422459, 34.538393408965234, 33.81317238982024, 33.57193760499287, 32.970629517945774, 32.67930315953803, 33.67822432858186], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.14952397346496582, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "393229"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.77864800176074, "var": 0.7728121383154571, "samples": [34.68593846574068, 34.45418779570613, 32.56854383080244, 34.21485163518915, 34.24451539912629, 33.9882464957852, 32.94262556040125, 32.41067846964012, 34.10198783939335, 34.880188541276596, 33.49297684153498, 34.01057333842772, 33.033032386079796, 34.36404031409375, 34.16909268786162, 33.933415735308586, 33.43040459251924, 35.087593012996685, 34.27746983622725, 34.89662882675755, 33.352104446604905, 34.20099740804499, 34.27848998428673, 34.968817264803164, 32.21457558443166, 32.15520896189238, 33.434525495658015, 33.686621882952494, 34.41138797577333, 35.3430021998721, 32.54754800003474, 34.46555315627616, 32.75699348828173, 34.6157977869651, 32.95309597138063, 32.88459383934436, 34.17787175200595, 32.986176804279054, 33.07366224269277, 32.336148180517945, 33.613435820363875, 33.644794396193035, 35.038198741304626, 32.94739165791076, 35.26276153659681, 33.65669456370394, 33.02788885804714, 33.57815031621735, 33.00110284972777, 35.131817317005414], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1510477066040039, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "438119"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.69735285826377, "var": 0.6174650444316204, "samples": [33.084593256268505, 33.50531056613947, 35.15381552615577, 33.501617560681794, 33.34646691968403, 32.709868000938684, 34.44660336865454, 32.965518314573, 32.83076372395033, 32.736381888349555, 33.55049221309933, 33.858529533565545, 33.50048476051895, 33.2981784922408, 33.73665973575243, 33.38026534404171, 34.26009742315944, 34.223417578971066, 31.984913595044688, 33.66002145486675, 34.4872727954336, 33.53339913535872, 34.41315437120504, 33.78556601132409, 33.75414722512369, 33.60733913847971, 32.8837048081228, 33.338740228061816, 34.69013769652909, 34.738557451878584, 34.71404153286065, 32.56909628439898, 32.89051157081779, 34.661884331996866, 34.006398010552374, 32.19628242266683, 34.71640789646218, 34.365650887882765, 33.65231089509003, 34.050645773259596, 34.32606040750779, 31.935413343226323, 33.93175969247386, 33.7130319633135, 34.4147904205585, 33.94965066267228, 33.52634930943314, 35.600453878552926, 33.27398974376723, 33.40689576752125], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1781320571899414, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "887072"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.59188389263079, "var": 0.6619454962956313, "samples": [34.75502521357675, 34.39184031456075, 32.91145811284155, 33.35123205607919, 32.49906121809024, 34.680815614331216, 33.800462583189756, 34.83747721130455, 33.438058773259456, 33.739652374004265, 35.06089793891382, 34.01853955326422, 31.862221844550927, 32.78375610558154, 34.0149535803598, 33.857793577462985, 33.46329225428669, 32.96070208409637, 33.17687204568141, 33.294204090171704, 34.463539345332805, 33.349939381470094, 34.343391552302066, 32.7854625460922, 32.98129783534418, 34.833958284740326, 33.095470294044446, 32.76262927174888, 32.943918030445516, 33.47001196230103, 34.34049978092523, 34.48700259179283, 34.50705984343958, 33.832430641422015, 33.29075505811016, 34.31471295941972, 32.614547679797965, 33.28241687510518, 34.24483801128281, 32.62529836714693, 33.65796630683856, 33.663506713228, 32.85118581106961, 32.09602440567558, 32.98558555224767, 33.709503562785926, 33.27591685560269, 35.72784460748318, 33.1956442638036, 32.96351969493347], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16103172302246094, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "532597"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.50915094879922, "var": 0.34381725771639426, "samples": [33.6116425148327, 32.523463019457864, 32.69716472007689, 32.970912729436336, 33.45332756466301, 33.70446941320802, 33.16881007921107, 33.11781080319903, 33.78911496146088, 33.373922292574875, 33.20158910759266, 32.848555288099725, 33.0157338459029, 34.33163397937154, 34.318835330107646, 34.62938526935904, 34.08587293205171, 33.53360651010203, 33.310853748357644, 32.457129788845236, 33.4276555511389, 33.73762904092276, 33.12823970728815, 32.62386870938666, 32.98768217854834, 33.87392495133777, 33.43858614106994, 34.053894136106614, 33.81565143516906, 32.61217922070007, 33.79419440511924, 33.618470425806656, 33.501902387424195, 33.52501662666067, 33.798546288543264, 33.12758559661715, 34.79337429826957, 33.306580050939786, 34.092831863012776, 33.311271455812204, 32.07615161985366, 33.07938407423105, 33.83169233694479, 33.59031867741153, 33.613934315118215, 34.149248982654896, 33.83172185395922, 34.6025485989626, 33.70118168301207, 34.268446930028006], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16603302955627441, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "154019"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.63835457314394, "var": 0.4675564064184779, "samples": [33.65585320888433, 34.00036468571265, 33.10007796457617, 32.69554664025604, 33.647301422022196, 33.297103476883635, 33.90118305426303, 34.46319995680788, 33.32905930719495, 33.58417167660875, 34.22673303105731, 33.86081290384171, 34.86188372492539, 34.033111366432394, 32.830171403836516, 33.464377302438635, 34.54147177158264, 33.9570889114094, 33.935259370318256, 33.90980358534374, 32.67428486148545, 34.37691645537462, 34.342340742565135, 33.982745578271434, 33.72731729125667, 34.36817508527325, 33.964197700709306, 32.62538822750554, 33.827004512170205, 33.61729553725264, 33.634500967274086, 34.806647762883316, 32.40319564065548, 32.48416593441843, 32.696272418213695, 33.61589958452846, 32.958008457621396, 33.86763282866578, 32.817347245536595, 33.0588257574616, 33.20626049130581, 34.87091073306285, 34.69924967993648, 33.244334400906176, 33.654210965581704, 32.39225572676496, 34.19340207168316, 32.65874681200218, 34.38372550919614, 33.47189491323889], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1662449836730957, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "300136"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.58202720013887, "var": 0.5886842306736074, "samples": [34.70088920956559, 34.96127391376035, 33.018943455805214, 34.04572689005616, 32.98492152784265, 35.1740238593454, 32.995597152564486, 33.91025064268097, 34.46056441313222, 33.75850727869833, 33.033826692064764, 33.724105406846654, 33.28397045880383, 34.19524694426877, 31.814360456616136, 33.36537987547422, 33.95681658868196, 34.913808732187924, 34.024574517273656, 34.116987300157845, 34.074339275092825, 33.93238804192452, 34.114408276600706, 33.39301404696822, 33.38202032446441, 34.25305769882762, 33.613763949943255, 33.97482089372498, 32.81386433721535, 32.68844895802202, 33.47616414351751, 33.29336996980646, 33.678445858657476, 34.33411389437788, 33.8674833195291, 34.12953575218962, 32.90341709607206, 32.68863110454191, 33.825877181523836, 33.07498712077241, 32.855459203936825, 34.38792077962576, 32.50693648320917, 34.768448069899, 32.747524998696484, 32.147060759266274, 32.79631693018915, 32.81760210213862, 32.3278463011808, 33.794317819201865], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.143021821975708, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "325102"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.67862885115599, "var": 0.5335818446032782, "samples": [32.67341069390951, 34.32823496690285, 33.87478224425814, 33.190839356062625, 33.68896837879363, 33.84750779027062, 36.148587337090454, 33.276923030266786, 33.24155572269663, 34.11601198122082, 33.72862006083927, 34.488820619841626, 33.54829162673582, 32.62369457170031, 34.13846292282421, 33.777294082445266, 34.5028889844323, 34.14745402820855, 32.99410002951765, 33.848256278804776, 34.578029119245556, 34.073089905696946, 32.546475712126735, 34.02933254347022, 33.775931352978766, 33.68295704255609, 33.84295233372142, 33.08238606387813, 34.29847583564066, 34.63988691271375, 32.42274765984506, 33.66099305924722, 32.85255346852861, 33.698729274397735, 32.89302705282404, 34.08965139922822, 33.57110306579706, 33.476118925057705, 34.17692844390219, 32.41474541901199, 33.16189720935694, 33.495968124747804, 34.251450856154605, 32.44906167081673, 34.568118312133386, 33.23839042734655, 32.56250697915911, 34.046313970951914, 33.57906705276022, 34.587848657682436], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16631579399108887, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "568115"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.80819198104734, "var": 0.7717073510873784, "samples": [34.3929924181502, 32.31345257511298, 34.24944638386822, 32.34537872133703, 34.02881489829492, 33.25574065956422, 34.747113553170195, 33.34128637573202, 32.849116547073194, 34.67201574646377, 34.97005871667082, 33.096051137659316, 35.16085975048117, 35.44064081340574, 32.87551267588726, 33.46681192435403, 33.84461521445387, 34.37991336903939, 34.12431910933224, 32.74965915675082, 33.284775561614055, 33.5779251539413, 32.95364703274104, 34.24117981043527, 32.85511740991365, 33.30387885247866, 33.818375753180526, 34.12673214890848, 33.693610275682005, 34.31350587746323, 33.48198761017056, 35.4056273202567, 33.084732559714084, 32.60413962357984, 35.280268477412996, 33.37697459892863, 33.66539919194266, 33.72272032618104, 34.78633562443015, 34.09209074130363, 32.92123973485565, 32.54157665903866, 35.703183338603175, 34.448900127587486, 34.291434548038765, 34.83117299925258, 33.735525551555405, 33.25940730552784, 32.43701066891876, 34.26732442190893], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.18227076530456543, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "410173"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.57213267798166, "var": 0.37794158353640833, "samples": [33.644960755086025, 33.9106443064821, 33.746931935675995, 33.897326297127606, 33.33595747522318, 33.02358745500676, 34.26033795960191, 33.65249793563946, 32.724898100495565, 33.19891919942516, 33.995084035424256, 34.15467455605795, 33.65147147022869, 34.22098771384883, 33.616741933470884, 32.45745451317791, 32.69136502431128, 34.627441111998, 33.503809669032066, 33.34361019414384, 34.24384767670138, 33.4597741119545, 33.334416375722455, 34.60161243073539, 33.239182186722054, 33.682083469457766, 33.01341464753951, 33.60239208970056, 33.443726708866805, 33.33361970615093, 33.73913870325846, 33.01880036583873, 33.945900270921314, 32.09142379141515, 32.901396477132955, 33.74042150606979, 33.41572847548238, 33.30621156294679, 33.382510830911286, 32.60236333637934, 33.91172096355445, 33.61102910876896, 34.42347490162914, 32.411048585839, 33.4117866918341, 33.495018684173615, 35.23709009953731, 33.733166007230835, 34.42010408465395, 34.19552840649635], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.18142414093017578, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "210799"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.48674172164026, "var": 0.5470514712697068, "samples": [33.26329572788165, 34.97100621710751, 34.671976211925774, 33.91402692866984, 34.59583850367274, 31.828866359698324, 34.214846157450275, 32.839923419754626, 33.12125025417316, 33.38088944991745, 33.6052386521802, 32.690314117724, 33.269331226942164, 32.53110471689854, 33.733392619569415, 33.69485389316979, 33.72315461596856, 33.74051249956293, 33.77798047440507, 33.064208395018795, 33.100774664750844, 34.29059043482194, 33.31037977123856, 33.66665244563143, 34.09538990789515, 34.03075570076141, 33.874633175658815, 32.747345541446805, 33.731064313059704, 32.83169423318991, 33.57332675195801, 33.520198059502285, 33.277019665573235, 35.14381994195753, 33.42270683452582, 33.46438908780522, 31.708574342978547, 31.849741492552795, 33.25377089740352, 34.00193455655123, 33.04034566248023, 33.2379071070947, 34.19349229682882, 33.50526754063142, 32.714860999896224, 34.14376472000235, 33.84863543915966, 34.39240809287882, 33.42038215949043, 32.31324980259672], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1829221248626709, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "205664"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.73277717038342, "var": 0.5139758536917263, "samples": [33.081983921250504, 32.457441977797615, 33.50313309693321, 34.52081394031194, 34.7642786102697, 33.37667883212294, 32.00116355876392, 32.78827320745036, 33.48923996398794, 33.663679003230506, 34.73050749094241, 33.35468087848945, 34.023486120946785, 33.21031438886419, 33.15216445975128, 33.05141335617191, 33.859105055250104, 33.09038600402471, 34.5780160928655, 33.29641353700512, 32.37544704550842, 33.76863597233536, 35.03389508695278, 34.083870535082, 34.67755995851111, 34.57583878692981, 33.73057721990977, 33.81279061516409, 35.13559273016098, 32.98253039538028, 34.26464035507897, 33.96131843281665, 34.03002387039334, 33.44518007466063, 34.17759393226895, 33.74969913828857, 33.51203041086447, 34.07702730181588, 33.08748685920203, 34.189107676887936, 34.25457984367127, 34.260562713381326, 33.46391638414832, 32.492973971451974, 33.814733902063935, 33.51247160647992, 33.02815595632876, 34.138547136461185, 34.103979925904454, 34.904917184638116], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.15006327629089355, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "835940"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.52015488046966, "var": 0.7167217518690815, "samples": [34.55471055549466, 33.3889752085026, 34.440484107772164, 32.76562302668414, 33.464637653795364, 33.04021885408707, 32.86725482502284, 33.57472941645335, 33.08833086545002, 33.421059837187, 33.649561976863346, 33.25355429585578, 34.029721173993124, 32.92414341759398, 35.427636190903975, 33.02407234047732, 32.24590050060687, 33.14869471549325, 33.214800526234555, 33.25396416661873, 32.89126444972966, 33.92207367893226, 33.78680167536767, 34.09603511019907, 32.09786607183674, 33.31635702267452, 33.70516865998051, 32.57425528804342, 34.893083513086516, 34.11184599740262, 33.4991565270053, 34.35255017308796, 32.30847096742646, 33.34902472167769, 32.36041827656873, 33.064775370220644, 34.582793613315594, 33.882912299095665, 33.83498928407383, 33.66347139941997, 32.512142410116994, 32.82914365866715, 34.858571777950274, 34.82549619579507, 34.420107919670656, 32.97592425378801, 35.22903137727761, 31.74186792492442, 34.67404388636002, 32.87002686469795], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1499032974243164, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "107607"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.634483689855415, "var": 0.565758498147776, "samples": [32.89072636829824, 33.424680281563916, 33.07529197496281, 32.67292666294552, 34.33277208731347, 33.53792181461215, 34.24251503564262, 33.34326597083293, 32.91212896327508, 34.54238170555565, 33.67688989167486, 33.59751746485956, 33.31397969750424, 33.828164754685886, 33.842202141254674, 33.01482907761251, 34.6696034333984, 32.95811878580175, 34.59812267025759, 33.83678763688252, 33.038841673150586, 32.93930322243094, 34.10765482279462, 34.55247712390505, 32.10655240139236, 32.18302245059371, 32.686824893880384, 34.736024984373, 33.83320730709868, 32.538961259585854, 33.654983846298805, 34.43660936795671, 32.779956785853614, 33.98052095432692, 33.69313892979889, 34.5583878361597, 34.38466265925156, 32.4503933000445, 33.045933428326265, 34.5890850167208, 33.55657241148083, 34.37725160144917, 33.47410076855846, 34.44541189244592, 34.14278990051516, 34.45604414024714, 33.31409636639474, 32.44545956333601, 34.78530655580238, 34.119782609663744], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.18219852447509766, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "558777"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.35758902922726, "var": 0.38653821498800145, "samples": [33.213366214414165, 33.1731178717037, 32.70834927758652, 33.51333767283898, 32.26419719427717, 32.73173226185204, 33.02446517308927, 34.72702153240058, 33.342337823688254, 33.01368337521272, 34.06960763148338, 34.915142160058096, 33.5592167490948, 32.758535544336006, 34.24526755726589, 32.819100318711904, 33.72971903650974, 33.755960276887535, 32.85397006757209, 32.018365612649326, 32.83172032672619, 33.855180244189604, 33.350622334982944, 32.64778959325824, 34.29166579753298, 33.65618035395698, 34.24300675616423, 33.259870516391445, 33.70704304091794, 33.71357020812075, 34.144961099081996, 32.794920281743885, 33.44637785399217, 32.98165086558518, 33.57472549914542, 33.76146388674694, 33.36473824869607, 33.1871417410052, 34.099186438876444, 32.47435135287905, 33.76393237384492, 32.760028326316096, 33.15776440507506, 32.86497945697639, 34.11314498611065, 33.269442470635674, 32.90552000536515, 33.146490286122855, 33.52191740922419, 32.55357195006659], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1388249397277832, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "756490"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.83006826506022, "var": 0.5047813958015048, "samples": [33.52082601675613, 33.6186163991786, 33.544725951019565, 33.52819331817402, 33.14906477043175, 32.918499126818084, 33.725227495999206, 33.57029965289377, 33.92823924329412, 35.02951578511817, 32.53678941865828, 34.16575572262105, 34.867944731043195, 33.218107830719475, 34.29033805576204, 34.728045796493554, 34.42381364100331, 34.620469851219234, 34.52002290702636, 34.8109637096196, 33.658157823272326, 35.547740788255986, 32.51335508827782, 33.924382463732535, 33.315268119150296, 32.722176625065494, 33.314726621322315, 33.24570895860479, 34.15282678513201, 32.72296011569762, 33.663505083212, 32.979361361220995, 33.814367158049954, 33.925564654775876, 32.959667976547586, 33.92166143228374, 34.316108559984976, 33.96631843021501, 34.05288541710355, 35.00428334385077, 33.68451945514378, 34.09475962878049, 33.609616302184335, 33.99248056994284, 34.71673008637525, 32.43074673736547, 33.959172270101696, 33.90053118225935, 34.58083305127675, 34.09753773997591], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.14565277099609375, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "907895"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.65270700966114, "var": 0.4941589813541718, "samples": [33.44339223576857, 32.44342405688742, 34.1933354339807, 33.46262327033361, 33.02649546126612, 33.21668087922728, 32.65774434534667, 33.89087014141585, 33.1608640671725, 33.75198913828896, 33.86500612442573, 33.05966373089338, 32.88695531693534, 32.54700127542193, 34.593503841764495, 32.78570109443196, 34.00076659764498, 33.77218817747603, 33.947971257414856, 34.01893060561791, 34.49427666095091, 35.53743965435655, 34.61213207730821, 33.25209231407614, 34.56017841898448, 33.1282435095649, 33.27740368292568, 32.99701040121691, 34.83098191536343, 33.6830427851311, 34.299946217148594, 33.235996458282244, 34.610371263643, 34.7207496927609, 33.72376836994036, 34.009733460395616, 34.29726984475403, 33.90739786646123, 33.34310772893902, 32.49793908292264, 33.53872515973671, 34.02860609226504, 32.696129422644816, 34.322179120013466, 33.32632218629366, 33.438421707705, 32.49531892172827, 33.324291725962226, 33.823118928234805, 33.89804876163293], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16832852363586426, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "76301"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.746572814435815, "var": 0.5261782001627179, "samples": [33.28364606813648, 34.96632905546366, 33.81542480941624, 34.02595460333891, 33.57830455328681, 33.941379359072506, 33.515431978357554, 35.10316344458219, 33.85722991358985, 34.35154114553754, 34.61766698055652, 33.961003632397585, 33.03188208740553, 33.26648062091155, 33.137954225018944, 33.914797933204774, 33.35352489391538, 33.94976289170533, 35.20602055445861, 34.75318704711654, 33.85013212216533, 32.98190020797972, 32.18666710539122, 33.634167899631535, 32.86572104819581, 33.50222879326719, 32.80843411718028, 34.53145241663513, 32.578114797549915, 32.91157871616095, 33.81885512240757, 35.575931572932156, 35.13215549425668, 33.244026479230804, 32.665328706303924, 33.2610780073107, 33.495904520926736, 33.888882595151266, 33.20137177952861, 33.570361131181386, 33.666098980663065, 33.38932142036414, 34.068147308125944, 33.03797671594555, 34.19690167371572, 34.50514730578112, 34.01218705756187, 33.67956605885082, 33.66730337892308, 33.77101239099997], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16591382026672363, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "687341"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.80087093124975, "var": 0.7103608175243016, "samples": [33.49555125470727, 33.87346103737657, 35.00647250989157, 33.51777431824104, 33.294938551497296, 33.70061359562763, 32.98119064327282, 33.53177475794215, 32.48372485203507, 35.42578448413425, 33.81180512653812, 33.73910636649187, 33.9251941102917, 32.529682024498, 33.80184171957462, 35.48881973244595, 33.94472738050155, 34.03602339335708, 32.44366017364402, 33.971735275418915, 33.056506900317245, 33.22152717139791, 33.634339243796674, 33.4635598868625, 33.15827660452243, 33.511262123058614, 34.77871594567884, 32.705371706410915, 33.025185150069746, 33.61931921674652, 35.91357997552797, 34.86649991464403, 34.34090106894056, 33.403238255678886, 33.05890057283321, 33.450639481373805, 33.83390073495492, 32.81777884515804, 34.2826635967876, 32.48061976532048, 34.738014704956626, 34.62233366207203, 33.78677540955258, 33.348921135677664, 34.59377663233021, 33.6065839151271, 33.7445532754536, 34.92634131917348, 33.37747034574046, 35.67210869483524], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16743111610412598, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "152743"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.724822327853744, "var": 0.6289551547495675, "samples": [32.71449077645681, 34.638607081078995, 32.88794982521355, 33.291426565289335, 33.15791395768814, 32.89420677044515, 33.81978497562771, 34.054486192233085, 32.96605362681176, 34.15504851127171, 33.23897130668547, 33.65638381815462, 34.50443856787619, 33.657687750419456, 33.67326146838585, 35.73512963241658, 34.25124315017261, 32.898723452917004, 32.41374769252339, 32.9151125829862, 33.12890928634715, 33.78904079384428, 36.02472412839613, 32.778532407616666, 34.330863048943684, 33.317680107681866, 34.126422140072386, 33.73115598441526, 33.92217695372356, 34.11880265931836, 33.495120091346394, 34.18024862354266, 33.024525750612504, 33.57081188216398, 33.5606277654446, 34.427895360962864, 33.20094326756315, 32.90812963939013, 34.00489145466664, 34.39500172924998, 33.216536789168, 32.85651123754499, 35.37221776629728, 33.10107997987958, 34.189643202937, 33.19575764171413, 32.973435429121636, 34.80037274707445, 34.848730006076735, 34.125660812917566], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.186262845993042, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "29867"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.64808574597602, "var": 0.5909696206281735, "samples": [33.026991759369636, 32.76344644006009, 34.23825601473024, 34.33487486757462, 33.85839281956804, 34.09010049265524, 34.56567700347147, 31.99176438429801, 33.09578884504933, 33.75454205237719, 34.35441381345217, 34.17110502832503, 33.111451611105956, 34.29773359572275, 32.789445400899844, 34.003830867280236, 33.89846969369867, 33.01275821198426, 32.79405347338026, 33.15305200783848, 33.806623173884105, 33.59406007921896, 33.52017372617078, 34.16844831435783, 32.95737874020617, 33.731444877580984, 33.64822333436264, 33.014528960963055, 32.68361964446953, 32.874176723859, 33.58877630618711, 34.028527389883536, 33.32079844759248, 33.095434815494855, 34.29559425258346, 33.909113506711634, 32.6974655360833, 34.46065309828022, 33.77099172069645, 32.95723539290288, 36.00350237294353, 32.844059341799664, 33.76482460936289, 32.94252671710052, 33.947121504367814, 35.428313688042905, 32.80813056296332, 35.13366680704503, 34.09757324693409, 34.00515202391059], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16373038291931152, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "516126"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.68500415915232, "var": 0.48222272657618137, "samples": [33.30544016127407, 33.6303563391256, 33.340281171642715, 34.74320105856969, 33.17063772824177, 34.24176735761668, 31.918939571585174, 33.59639719777182, 34.77389565584272, 35.11654222460744, 33.05566121101642, 33.37008730256704, 34.69021276937065, 32.57529729736337, 33.98027433961223, 32.73639937769792, 34.371640779451916, 33.22830424302519, 33.4134678583152, 33.16870155886395, 33.90206815555707, 32.8623569146663, 33.88899497283985, 33.192876814592, 33.81460305034576, 33.95877844521537, 34.364394902522086, 33.46609383086085, 34.61388758677586, 33.5984915591233, 34.52186346037301, 34.59761545977242, 33.68945180766774, 33.232648246821775, 33.54895777939685, 33.38125938240763, 32.110172064872586, 33.9767224573809, 35.014106484909505, 34.37168556965811, 33.99362796223518, 34.02658079913103, 33.02533090075707, 33.87355834411327, 33.8424325127177, 33.49758865483103, 33.71201644242617, 32.97090967725269, 33.397574019522025, 33.376054495309134], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.165755033493042, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "956506"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.640569176117154, "var": 0.5800418319221292, "samples": [36.183035366508165, 33.213991854515726, 33.431763473886825, 34.0739656072058, 32.77577566537413, 32.442611755378906, 34.0565856457139, 33.23583229721336, 34.039908413282035, 34.26618922182316, 33.78780903920628, 33.232039398745364, 32.80681517763385, 33.465207091403336, 34.40312258781673, 34.298433662224326, 32.81054066726786, 32.569541032990415, 32.59792702838378, 33.163042471066404, 33.4879013967703, 34.31623498269752, 33.24363397955662, 33.11583940997256, 33.821246999130494, 33.16956808034099, 33.950622886286766, 32.89891896422228, 32.97033089152738, 33.73764763809819, 33.34763105504476, 34.59948717223443, 34.643095779555786, 33.22080222528772, 34.38405523730417, 32.99732023197062, 34.32684797276288, 33.185730552044916, 33.89680062571272, 33.72697732066496, 34.36730073365005, 34.470199316995036, 34.708459897070746, 34.608232185824015, 33.11404683049862, 34.411082479126556, 32.75382789675528, 32.15056447130118, 33.70060924941335, 33.8493048863965], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.15106701850891113, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "203100"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.519287284251234, "var": 0.4494567691294412, "samples": [34.59442283850754, 33.27146821857865, 35.17311361675111, 33.172436225834645, 33.44248588860047, 33.61379328229758, 33.024989763484484, 33.29196980557419, 33.51622485646723, 35.1980314495383, 33.7881693284753, 33.63515001814941, 33.654914411736996, 34.62538865975537, 33.142499404903724, 32.76384913690123, 33.25365333564661, 33.235573676851786, 33.423064647733426, 33.059171236403785, 33.56450930812388, 33.389643382569005, 34.393067801848254, 33.75195970939325, 33.47737257670433, 33.41561518311759, 33.111300774398515, 33.58442564279093, 32.972787936918024, 34.01672807329312, 33.374035821844224, 33.15078981460622, 33.5350817125841, 32.70555252016035, 32.91428062105312, 34.97545931510917, 34.24619940739533, 33.03873585950907, 33.456328062965724, 33.028501157760886, 34.07944516949091, 33.022309454791284, 32.922352109545955, 33.982546506085015, 32.970964842231155, 32.869345602870595, 31.877643142261576, 32.653809867841176, 34.37485906274442, 34.228343970362694], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16549301147460938, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "779885"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.61703270105, "var": 0.4724055930755273, "samples": [33.95454927181758, 34.185671250648085, 33.016667313895894, 33.8084460839551, 33.469918487700966, 33.910177192083545, 33.17199587207579, 33.27021146842611, 33.38288171632338, 33.40440584769016, 33.37758430942364, 33.98114882651299, 33.9526331464909, 32.82879254458568, 33.259692996428804, 34.469700037467184, 32.77225139688106, 34.847406111144714, 32.82675134274425, 33.07661592287566, 33.86902686887629, 33.887929430078884, 34.94902792055054, 33.461848590407826, 33.71270069171162, 34.3376461888316, 33.98948009423695, 32.88423333957692, 33.18902985818687, 32.18394157404809, 34.90516911307376, 33.63059395628209, 34.257960461195324, 33.309534321302166, 34.446124052992225, 34.64748054079651, 32.771490618152654, 34.40894332789391, 33.01843319092104, 33.05420571484028, 33.011976586186805, 34.42721110028758, 34.09564557543786, 32.45357984251187, 32.49688990097813, 33.52408664597266, 34.570912967655744, 33.566277377799395, 32.8232201859614, 33.99953387658178], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1776421070098877, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "438052"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.59002265982723, "var": 0.5729067161313194, "samples": [34.277054371043974, 35.457663151720105, 32.928881014467684, 32.902566328102395, 34.73673287090409, 33.71273308230228, 33.08942394829448, 32.02527095020697, 33.386188288091006, 33.02264896011238, 33.69014477054411, 33.781166439652154, 34.28718152499159, 32.96560104969011, 33.873434905840945, 33.84747417806125, 33.416984331402666, 34.43401606434862, 34.252990023778004, 33.92070292875733, 33.37685414769843, 33.549232154964734, 33.31079283662545, 32.541680788078246, 33.41582054973795, 33.70775855171762, 32.43883550012522, 32.42167881211687, 33.176403993544945, 33.30919345081172, 34.71661781262456, 34.300589093218726, 33.63446968922114, 33.124561039517886, 35.5082498888588, 34.023351032921, 33.02245631571057, 33.90693373187116, 32.58461310617346, 33.68358352155663, 33.35950187589617, 34.20757932087407, 33.70509412509314, 34.347958837822034, 32.53267364494515, 32.5896485184461, 34.79571471839114, 33.694312805143625, 33.48377913303639, 33.02233481230634], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.183302640914917, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "777897"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.73457196548535, "var": 0.5022967767150757, "samples": [33.64082025582931, 36.30913841250967, 34.349591609282, 33.56418126629933, 33.95788685920561, 33.03777904202214, 33.55282734541691, 32.12117603030348, 33.767771347614286, 34.140854046491775, 32.90508911124023, 33.77868515013908, 33.09580552684282, 34.047992419028844, 34.52254850763584, 34.16952458039585, 33.121050496786026, 34.37166240039305, 34.071222235751705, 35.05045304851451, 33.63508793097442, 34.41467445854745, 33.48216364070983, 33.249228779847996, 33.12033526248712, 34.244536230935516, 33.21571365599503, 33.283733607024516, 33.279843291442006, 33.3349911155018, 34.20454876335057, 34.13653935814771, 33.62369682891653, 34.8716103698245, 33.18700271985052, 34.07651009943375, 33.593964439385246, 33.545307165384905, 34.14083703943617, 32.31647475486762, 34.4889725582654, 33.42584385618787, 32.926633642446845, 32.97974413560813, 33.286560293788206, 33.86170423633035, 34.32473666520467, 34.09086724239132, 33.07586785107917, 33.734808589200156], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1771538257598877, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "941318"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.77468066923698, "var": 0.6692375564349236, "samples": [33.568925757673725, 34.93327613884256, 34.78335061956406, 33.60390683605529, 34.06763244363081, 33.435194435158174, 34.05954593441909, 33.876291232595754, 35.08410534912464, 35.23990894021952, 35.963921527485596, 34.08221449753007, 33.1913591773423, 34.5341190962057, 32.52926976305473, 33.75273249408, 32.98896614106357, 32.35301289378171, 33.636078134725906, 33.419488164192956, 33.355789367735234, 32.6740743468441, 33.07416976325609, 35.07067096177958, 33.89591819957258, 33.98314688011945, 34.25429106633895, 34.86732086040093, 33.13223508719967, 33.64860427114265, 34.971833813206906, 34.41071297038091, 33.652382477362075, 33.72306498841918, 32.27627044093465, 33.80880904976096, 33.79449232425392, 33.67320145248355, 33.55472921213151, 33.375635348575514, 32.95546574715623, 33.7026946022045, 34.131893722573935, 33.66428528957122, 33.55821752598758, 33.18946208150746, 32.799552313891155, 35.04239436799353, 32.39164296851203, 32.99777238380662], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.20780539512634277, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "646892"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.68225732281995, "var": 0.5897180513150164, "samples": [36.77198118163415, 33.52219994624697, 34.26009504866637, 33.7740895620435, 32.46467822977273, 33.77702991608193, 33.9747498386358, 33.30185691650586, 33.62172404948456, 33.65052397974757, 32.68842540730846, 34.176278660355706, 33.73231354597585, 34.0495911672733, 32.98277007163275, 32.80139043410203, 33.781690783625045, 34.38194464546331, 33.43575204022444, 33.288631064673666, 35.70219243228559, 33.425798489853605, 33.204134111285256, 32.938470442819565, 33.54817715957199, 33.11773330967069, 33.403724132353275, 34.90932521734382, 33.08772999798359, 32.62674748236593, 33.27369626537833, 33.86692015706361, 34.15423502875212, 33.29090487436743, 34.20161323413607, 33.13867869906981, 34.227146735580156, 33.311058097413834, 32.71239405730591, 33.8917895030822, 33.422331324667525, 35.002942571275725, 33.74944956795596, 34.07457440192709, 33.89604567285565, 32.741780813952744, 33.64407090136498, 33.416022908123345, 33.877329467092714, 33.81813259464508], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.20140695571899414, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "101413"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.66707780283121, "var": 0.49910024788552027, "samples": [34.06992879341824, 33.20704659928582, 33.54319405866256, 33.72037634381466, 35.200362972038036, 33.171150481455655, 33.05148422998203, 34.02260136007429, 33.54198645325604, 33.43146110592047, 34.42860123756071, 33.20033135159541, 33.31221331354067, 33.005253614926715, 34.00769198725972, 34.10276805500772, 34.60695562680151, 33.83899876228906, 32.944465527086535, 32.60064017905577, 33.61009727944261, 32.765828192392796, 33.55751237362009, 34.46754509629507, 34.751088473002525, 33.03355585132877, 33.991370776957595, 32.40616134040795, 32.50381867674801, 33.14542171657993, 33.53653336186044, 33.58241513693075, 34.051898796134736, 33.51487794438063, 33.721374209801134, 33.73246959047025, 33.342809899301784, 32.25047927471967, 34.91082956968994, 35.859954119271535, 33.54449967177614, 33.91039465987655, 34.052628826110336, 33.82075023843011, 33.507720459381815, 33.07144229604379, 33.57038884246646, 33.610190275924694, 33.893698312306604, 34.62862282687617], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.18270421028137207, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "206298"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.70704998617779, "var": 0.6244655857054738, "samples": [33.116178333911485, 34.15647492610028, 32.947072723213715, 32.732567458606106, 34.584471870470935, 34.52867725422256, 36.438097829950394, 34.037236340387324, 33.50207944364707, 32.96188449995293, 33.704130519103785, 33.52217086427665, 33.51147362273709, 34.68180090457307, 34.194957535631076, 34.350116730097355, 33.80076368694551, 34.164876182766, 34.93600659762244, 33.692928608590705, 33.21298501231172, 32.526927215756785, 32.88993417877537, 33.6741104923143, 33.41728313237009, 33.70174069192676, 34.37213047004147, 34.10918797383474, 33.297022581387125, 35.26381194558178, 32.58719231054506, 33.62615966312897, 33.24772604818087, 34.86708062107567, 32.88996665693276, 34.20269803904727, 33.42015919560377, 32.97826804079442, 33.78092307622097, 32.995926521644755, 32.917977486305254, 32.627602320521206, 34.02931164663329, 33.626284644141684, 33.86832734930532, 32.99504378882287, 34.063139833241166, 34.56420805168942, 33.65960822010486, 32.37579616784346], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1646566390991211, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "135030"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.855374629786176, "var": 0.48781806194006183, "samples": [33.54569248553634, 33.1336134186414, 32.456316081237105, 34.08014145415828, 33.261817636675, 33.58537446555064, 33.97802830360343, 34.08780821566391, 33.52863505065899, 33.71573590727799, 34.199744417033926, 33.71467995498685, 33.44138851968641, 35.016596529355944, 33.22782837913938, 33.400467795523745, 33.556660669208306, 32.77152141464467, 33.29893032376198, 32.466034243006476, 34.017995254704964, 34.571785844504355, 34.17254135593245, 34.022759982801354, 33.65877991642794, 33.23395818748629, 34.846822101281575, 34.1245409684077, 34.21399019915842, 33.50280773028249, 34.13366931632444, 35.42446251125235, 34.048767079152725, 33.337864460426296, 33.51497386542691, 35.20869779623604, 34.075469600964155, 33.709070808744535, 34.0151852435209, 32.60983171215008, 34.88405707366701, 34.30207345083237, 33.36363394199577, 34.012369900519055, 32.75562246642134, 35.083403707787554, 34.07062276356466, 33.81440637654359, 34.91565442715814, 34.655898180282584], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16547560691833496, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "426127"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.41948529717449, "var": 0.5956166092876863, "samples": [32.93876640099492, 33.6470047431054, 32.56334099376386, 35.14656595567668, 35.25822961872574, 32.52328863144142, 31.99521725040746, 33.23138601742686, 33.03932345419326, 33.223135423428154, 33.65601905764479, 33.83441160658558, 34.996152795249344, 34.13334270216677, 32.86409132748701, 33.07360626528011, 32.91203840835347, 33.05259823017582, 33.54466494225706, 34.14488814538472, 33.104408227698215, 33.738678007563664, 33.85695137256142, 33.133180704380166, 33.19884305267618, 34.89033162929858, 31.80795323744517, 33.1903435911459, 33.31882401726229, 33.741508473008125, 33.34467690514175, 33.27096923977631, 32.258984084440655, 35.08274113278183, 32.933629799632655, 34.08392171490565, 33.7068424784284, 33.73816552439038, 33.638098379764415, 33.57570776660508, 33.116545429966294, 34.16017475839259, 32.853337061394924, 33.505601942439924, 32.8893088913851, 33.514547361565704, 33.4093297632974, 31.958554730581653, 32.96219831695154, 33.21183529409414], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16645359992980957, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "670289"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.51221916775477, "var": 0.444763123770222, "samples": [34.53127815000877, 33.06580004089282, 33.93580756638349, 34.12913249213977, 33.79024982347033, 34.29215760893318, 33.57884568575234, 32.3061982506551, 32.71309560629763, 34.096816599556504, 32.84932913972881, 32.79647215722154, 32.21222653557483, 33.78029386623059, 33.60170551274258, 34.1415471535442, 33.028806772709615, 33.18491431630142, 33.31460533624059, 33.6113793647465, 33.766817218947835, 33.053991512855234, 32.49182938804317, 32.979991803162406, 33.950724409539916, 33.28438027182356, 32.895062613751534, 33.28674249638419, 35.13458254317976, 33.958808631384656, 33.43080632638115, 33.35062696986588, 33.749006231794056, 33.71728856801515, 32.03356746831274, 34.11763415877551, 32.63475239863304, 34.16435684830861, 34.99302931603407, 33.50415442429134, 33.05389102179886, 33.80715548787357, 34.03376994262162, 33.84611611357131, 34.08330285950917, 33.96771714045832, 32.75173424809964, 33.622179286967906, 33.05753163956067, 33.92874506866307], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16632604598999023, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "554566"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.59673415104025, "var": 0.5837749899533355, "samples": [33.76144668138, 33.90043634540021, 35.303067659540474, 33.79605541057088, 33.33693435471118, 32.39510828249244, 33.754788914170966, 33.14031804335519, 33.31898070041095, 32.4783225899512, 33.11587158188554, 32.86052330802572, 35.022050599283865, 33.59681135515094, 34.354252056607784, 33.64157182051241, 32.64140932045029, 34.6229411924061, 34.122203375484446, 32.149906811188146, 33.229164434712025, 33.51905758339548, 32.771151967722076, 33.16294659590897, 33.99198330732164, 34.410419458735085, 32.98321728040305, 35.49167645252607, 33.32985261088274, 32.4617851753829, 34.700625680948804, 33.16698323129708, 34.127003638378994, 33.684571309185884, 34.314044631011214, 34.03074472114225, 32.74667398720694, 35.008009673411486, 33.227919854899625, 33.56273840226593, 33.413368708635446, 33.64119430490483, 34.23822059494602, 33.33715715841491, 32.66578127568678, 33.00093323272009, 34.11022938926714, 33.036965848901254, 33.70172247959168, 33.45756415922759], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16632485389709473, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "449355"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.6855573404911, "var": 0.39895903832678276, "samples": [33.28304584191676, 34.147186775857, 33.1733309516512, 33.77779173179237, 33.40156250470265, 33.26737555687349, 33.78960999749012, 32.91142489924995, 32.948390565202295, 33.87337978794206, 34.28847412272687, 33.95646858619527, 33.670594551477436, 32.95742857942688, 34.69499578687927, 33.464301060207575, 34.20134132398357, 34.62866732161881, 34.092924843893805, 34.50820940689566, 33.245856094521905, 33.371847793762825, 33.42962001489367, 33.39479446791319, 33.47155000900513, 33.65588898235049, 33.268858380294475, 34.006623164471904, 33.833448642848474, 34.475665045723005, 33.18643190796011, 33.22168187727254, 33.28692411315419, 32.50906957243103, 33.7636322053972, 34.14932717506879, 33.66920860417199, 33.73401182059519, 32.786850185182665, 34.46506849741326, 33.19336908342477, 32.497401868168026, 34.294527864088934, 33.99845197812876, 34.022875333656, 33.57770631385346, 34.43970160927074, 35.01305466386061, 35.01446050397681, 32.26345505571193], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16999030113220215, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "363691"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.66128893000394, "var": 0.5361699899761371, "samples": [33.08288171349571, 33.65682415092038, 33.00865828199154, 34.979335423479, 34.28752813761374, 33.28998366896017, 35.29815422350475, 32.95838357731508, 32.78536055089362, 33.47816977141356, 33.73525599261815, 34.18606269853536, 32.86034372930751, 35.145890192483904, 34.14672669020056, 33.60033536776898, 35.16598069859515, 34.30334806044088, 32.992300372823806, 33.61710153366294, 33.53872724224998, 33.05462302003198, 33.79822654908672, 33.46886315919224, 33.135727945196535, 33.4958971251454, 33.70938087993806, 34.56424044075591, 33.30591108489302, 34.79340134687931, 33.4595592187138, 34.70183475793664, 33.383694983566535, 33.50093163762831, 32.18636466241997, 33.87346359493859, 33.94267754832775, 33.47700283669203, 33.31481488075207, 33.08902204554773, 32.98207789519711, 33.415475996094465, 32.88821498916764, 34.92677118992942, 33.315713867343526, 32.44691070647069, 33.22921797693836, 33.98555244874172, 32.98245059645707, 34.519071037939625], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.8182895183563232, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "635086"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.44305291963398, "var": 0.5361589739862478, "samples": [33.61026085979127, 33.29081698697324, 33.91131999906072, 33.40020637735687, 33.63410564958528, 32.92880574105805, 34.93774552362812, 32.949037613594044, 33.767647091328556, 33.83269069068333, 33.235059190326275, 32.49618878608449, 32.59186042836034, 33.80011569928296, 33.165656665523244, 33.88138654040111, 35.454110826708295, 34.87927726549669, 33.970703243736686, 33.52617471680486, 33.89275989473132, 32.196232052016704, 33.46703344656277, 33.115269560785094, 33.85134096642974, 33.32939918746842, 32.39173770694766, 33.298830484586155, 32.593974709856894, 33.52182348298847, 33.74673226540005, 33.190483388986316, 33.66849463244015, 33.858412201808605, 33.96598743449738, 32.403101908658506, 32.947395205411304, 33.88982617012392, 32.4580622457786, 33.67280973845196, 33.10709670155917, 32.12274727647091, 33.95026615415027, 33.356499966154864, 32.768188262598265, 32.71544888219445, 34.63448831543955, 34.513290568819976, 34.00955454187609, 32.25218873272081], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7363440990447998, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "842069"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.45008110820213, "var": 0.69557244646935, "samples": [32.92746009897538, 32.52231660876238, 33.15524869692235, 33.58544608172586, 33.33651366781742, 33.810418039178046, 34.36958267580265, 33.59219744469312, 33.46820404905453, 33.267173928903986, 35.17194072887049, 33.55528260474714, 33.27655278208325, 32.439758344986494, 33.65768539564389, 34.8652090881236, 33.30691084108548, 33.77579496625783, 34.019584893265964, 33.754523976645714, 34.30020396083522, 32.89785139664204, 33.3079773771661, 34.75300015339178, 33.80188775352278, 33.65343241881708, 33.87879401259047, 33.14405664379942, 33.721983434353206, 33.94296453171273, 32.51355314176433, 34.795986751057015, 34.57072146646417, 34.31930632591755, 32.175977568815796, 32.19667064810411, 31.998215884652133, 33.75006651104205, 33.80478214029251, 32.3849907367095, 34.47958884726882, 32.2696358470202, 33.461745501784904, 33.55469678283247, 33.71946432990344, 33.697911322734846, 32.37579507773157, 33.18973209917388, 33.055583655078905, 30.929674175382058], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 2.112165927886963, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "440491"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.635817816845105, "var": 0.44876115802788097, "samples": [33.37287328837028, 33.902025717852986, 32.659628397827326, 33.59035401102027, 33.47719459263494, 34.54249206947624, 33.690974228647626, 32.83097885812054, 33.66748733941297, 33.127584531759226, 35.07432524389519, 34.30553553277841, 33.00303871008897, 32.76113258932581, 34.343101888742815, 33.398782564000946, 32.92350492704092, 33.18576995421883, 33.644771523669306, 34.41697299373237, 32.999712395206984, 33.9468146678095, 33.358684211875186, 34.230408904288545, 33.495014188173016, 32.43336927341661, 34.19490494022008, 34.09250700830451, 33.18340994394494, 32.887841670132204, 34.09764067868842, 32.82778104911701, 33.95702292811224, 32.42867953654025, 34.02873199439372, 33.80996335791186, 33.90499064590097, 34.06767088084422, 33.9455489990593, 33.731660592068216, 34.0237345380066, 33.40128232801805, 34.99594501684289, 32.43055209709537, 34.81045294817504, 33.31071075499061, 33.930429338818605, 32.70965242511893, 34.47415450025048, 34.16309006631479], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 2.029649019241333, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "837971"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.63564415969372, "var": 0.510516363697341, "samples": [33.11951435429894, 31.992632248476962, 32.92183364872538, 35.233559923074914, 33.622178185395384, 33.78221762159799, 33.288033521653965, 34.1122990005585, 33.958308633585254, 33.587149411681246, 32.07034915880042, 33.68019232026571, 33.843694659271925, 34.53272675337792, 33.61513521611751, 33.36943242178306, 33.03370447102112, 33.981873888332814, 34.09902920022388, 33.010074406710714, 33.642888020313165, 33.82214447254184, 32.897180479012, 33.583491279128275, 33.56121732862521, 33.98978926142816, 33.24824427593598, 34.333172845268116, 33.99108632197793, 32.704772837870905, 33.34503589238738, 33.681374965746414, 32.27069340880982, 33.357366921580756, 33.52212732993318, 34.04599785218785, 33.3882867076426, 33.38688319114671, 35.353431481565025, 32.68009541514087, 33.62133955709603, 35.10736234627763, 34.05322885571764, 33.56480419768589, 34.060423497029795, 35.34898180565348, 33.695635459002006, 33.591123727140314, 33.4245477498646, 33.655541456023016], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.9659383296966553, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "498712"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.58796110234988, "var": 0.5423559781405418, "samples": [33.74483879706113, 33.65284585692605, 33.611944664573116, 34.44974037304063, 32.16292225157464, 34.40214440714326, 33.23166558523771, 34.14509189711762, 33.10591733408514, 35.51218259291918, 33.27501327242942, 33.818308011114105, 34.41501297603159, 32.86594216670412, 34.608939108300255, 34.220331068717925, 33.27424663977463, 33.67993019145692, 33.6176123939198, 33.66791961487756, 32.9971008922098, 33.9769115423621, 32.42825529874552, 32.91185149980866, 32.15646806507158, 33.05859448183172, 34.74105897819161, 33.17421171931019, 33.764039308092805, 33.19415064803567, 33.11418008743903, 34.03552101466517, 33.656842006648205, 33.10751314722119, 32.947979780249845, 34.82824447919473, 33.05208281485039, 33.16740966702699, 33.18954897834881, 33.40167387532624, 33.22377075658577, 34.331107705057065, 33.49371680791707, 33.751578606830954, 35.41535024878167, 33.118842412600145, 32.266055313210515, 33.652042012699994, 33.774387114240604, 34.00501665193497], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 2.1161997318267822, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "128127"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.469130359995226, "var": 0.5248306846288774, "samples": [33.42731640800916, 32.82991355561354, 34.88727337015519, 32.49024506298938, 33.333941660205284, 33.64503843159716, 32.72133601549969, 32.41887127240749, 32.477967149536, 35.48941308029461, 33.39252046072609, 33.831729669625986, 33.52258351262937, 34.347164694864574, 33.59718609496566, 32.7495530590125, 32.25784261081818, 34.37981249023279, 33.77282270773222, 34.54761806599893, 33.69318746844637, 32.900716862086036, 34.77282343813375, 32.95809400670044, 32.77071912595706, 33.403602573605255, 33.09336451582651, 33.395321506771225, 32.815927661136335, 33.97933853870909, 33.27698667072524, 33.96914985312047, 33.62833810403435, 33.774634021023886, 34.29056810262667, 33.53510851150906, 33.48650204936544, 32.47615204273122, 32.64064565623623, 33.61171388866789, 32.558044013738375, 33.7042195639849, 32.447880037056656, 33.62403443967338, 34.522283490623835, 33.91764265986808, 34.15798113742638, 33.42737044544195, 33.635205698589935, 32.86881254303166], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7994377613067627, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "796273"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.59053476591885, "var": 0.5120995115319894, "samples": [33.0660580154749, 33.090223276393125, 33.63083007608701, 33.70490230403608, 33.7698761547212, 34.86141975536615, 32.65764528308451, 32.449697599569454, 32.571252661170064, 33.21293171869004, 32.861542601648765, 33.65292611478612, 33.20755674047572, 33.93860097866658, 34.73486256060449, 34.441857233270774, 34.70929439234316, 33.65811677019295, 33.662744254386126, 34.322197655395854, 32.31316786684758, 32.21787027358716, 32.38771995124134, 34.56549900809904, 34.42329766909796, 34.209883257044, 33.34763120637732, 33.52595779989783, 33.68523253944633, 33.32021147943696, 33.95170227143636, 33.602451684302004, 32.784718391522496, 35.36263949182821, 33.27728002165576, 33.24677626444645, 33.49578875054047, 33.623212461055346, 33.77833809127453, 34.68035732515084, 34.06838608131121, 33.45031048236517, 34.09196536873237, 33.583071266597194, 33.3847056358678, 34.22801965880084, 32.482688202760265, 33.35168990268728, 33.7010999562306, 33.18052978993859], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.852281093597412, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "503497"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.63105522704862, "var": 0.5224420585816782, "samples": [33.91743586062696, 34.22557724139142, 34.655064280191226, 32.48173054371241, 33.15244363149955, 33.10806215578628, 33.36978922480531, 33.50209219614681, 33.065177653133695, 34.324784799269516, 34.609356445496125, 33.788878383884956, 33.680118606508145, 32.8654892282776, 32.45918670075772, 33.5858739292576, 33.17961249650967, 34.846850865897665, 33.76598601446614, 33.125614311068865, 33.98326463197211, 33.762275863868105, 33.72434152645167, 33.54771534810133, 34.09470256067902, 33.01559048616038, 32.90447679900124, 32.54462158574646, 33.51349266144541, 33.11808693760664, 32.6670831187998, 34.54123778884857, 33.7436835931213, 34.044936745957095, 35.22375253945589, 33.22789303506855, 33.73857461143399, 32.95389779851059, 34.496934882718854, 33.995279842966426, 34.42677784378873, 34.71894781227491, 34.76934482402204, 32.97975630831918, 33.518910615850594, 32.5878508216234, 34.60363002997373, 34.050044306183835, 32.97439976601351, 32.37213209777996], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 2.007272720336914, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "507260"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.5533468317845, "var": 0.44425031068051457, "samples": [33.901895627435195, 33.32163366529608, 33.25661042610518, 32.97442047621819, 34.10302125590536, 32.775869535382206, 32.659095469354526, 34.55267382148219, 34.11277285081414, 32.90851349066444, 32.7545097388929, 33.79329967406783, 33.34545137876791, 33.04722241553045, 33.80559704234237, 33.41261130222304, 33.69374966647198, 34.50493837431188, 33.08936417337014, 33.3813276468815, 32.743005705669646, 34.620892821557106, 35.19181398002185, 33.676944772171865, 32.67861432515958, 33.845068501846725, 33.49867197766307, 34.2445666597806, 34.576017923770834, 34.21249185073322, 34.2045301836854, 33.3566587854624, 35.33564000022199, 32.729359971982646, 34.164105757315134, 33.178404217345545, 33.450556872817266, 33.273000269767834, 33.71675149201549, 32.787802005910095, 33.38061772677931, 32.72409426659364, 33.504097299264174, 32.419038647690414, 33.46170097467904, 33.10456593183831, 33.302929259114514, 33.25536662365005, 34.08092043441358, 33.554534318786374], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.9833922386169434, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "614178"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.97567702901233, "var": 0.655252514597983, "samples": [34.429360076936995, 31.8597600835538, 34.44581117184175, 34.49767722965809, 33.72738384933773, 34.629318985853544, 34.0500873557691, 33.15661868278267, 33.778575129846345, 34.58992947693836, 33.788243868133925, 33.45249201959472, 34.13389073118977, 33.62749646847386, 33.640573559447624, 33.528547698851156, 34.900497922427995, 33.33406022302271, 34.262187943817445, 32.893321790041206, 33.87582358605501, 33.73109145348981, 34.74779381799408, 34.414605196937345, 34.617818888555746, 33.76453231292173, 33.708498037408454, 33.92948213635873, 34.94580878689073, 34.07578295548561, 33.51339122567751, 34.812822611263336, 34.48034253666833, 33.426218491215984, 33.850844429088575, 33.039125308216995, 32.8905226386789, 33.560947660717936, 35.37802131816216, 35.61773168304277, 35.803411283083015, 35.03214545859915, 35.416147549069024, 33.46618749090444, 33.22083733243831, 34.19185541462069, 32.892393539838515, 33.25208979001273, 33.92182620778632, 32.47991804191564], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.8505561351776123, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "501590"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.70802758969826, "var": 0.443371585109369, "samples": [31.955247342271722, 32.950931321565555, 33.748294210388785, 34.819336570728936, 33.884362629226125, 33.57740561591902, 34.13490946187785, 33.24461525986539, 33.622953271410076, 33.79912772915205, 34.49203947040473, 33.489072385229754, 34.57102539396477, 32.976829900481846, 32.68371294299122, 33.06727547619457, 33.87400563144938, 33.6389393382292, 34.035193533062994, 33.446614182020156, 33.03555053781815, 34.222863139656724, 35.04632287385231, 34.51185182979518, 33.963403375680215, 33.729362905824416, 33.84216204551779, 33.64940376179872, 34.121187118963526, 33.29474382479524, 32.73924444339924, 33.438549977926236, 33.602187631998646, 33.40801905060693, 33.210889608331854, 33.46952826600836, 33.612319482881915, 34.770927620821645, 33.63602935623215, 34.40184888184362, 33.18272475877188, 34.19122893168361, 32.76650959150046, 34.22593559912806, 33.65422602539123, 33.867821401342454, 34.98897942540774, 33.62890700332706, 32.40944873640146, 34.767310611771975], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.8607995510101318, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "326579"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.75388536598146, "var": 0.45177432087964375, "samples": [33.311319524198865, 34.57929998456165, 33.79044385410945, 33.450338930132226, 33.65009384900972, 32.819411521549256, 34.01268579917429, 33.79222996384515, 34.046667186991314, 33.949168982468755, 34.09951678825999, 32.32232593492405, 34.92974400871229, 33.67118359047137, 35.22213477774175, 33.58814609270028, 32.792458220217284, 34.14263746951672, 33.15849995099645, 34.10338374245947, 34.097341901113474, 34.30566975051958, 33.29086890102891, 33.11210453659069, 33.50254505164149, 33.05601692861816, 35.393678390381986, 33.053587269047014, 32.921003243704426, 32.87156036321691, 34.03172545224154, 34.58348604725409, 33.04338306107869, 34.275004990834944, 33.491774020862316, 33.8314988955982, 34.5132293177632, 33.63152750639763, 33.75165758455451, 33.67146183918295, 33.24507533746314, 34.363859524854924, 34.48710636170859, 33.67616533227128, 33.7345476135275, 33.38801508868858, 33.1947779058523, 34.25640727802755, 34.852088061935866, 32.635410571072335], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.866114854812622, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "213523"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.44742286983097, "var": 0.6059901620746073, "samples": [31.659085326722558, 33.89302345879116, 33.859411456025704, 34.46680618473606, 32.82100779792662, 32.86177466944074, 33.724907626009504, 33.33376291697188, 33.36118155706316, 33.63287313681833, 33.65285555241213, 32.707766051762185, 31.789460013253308, 33.11346939299054, 32.835872163851455, 34.152265983364444, 33.75417350318107, 34.197983179992264, 33.068220877781684, 33.746692688558056, 33.0387994243753, 33.49890846914861, 32.46412523540734, 33.567906635802935, 33.191050485985855, 33.012710681588906, 32.843903248884395, 34.72527887025851, 32.73378381248159, 33.70343394619989, 32.31361127178333, 33.62304191169721, 32.98262434223683, 32.77325783467463, 32.552339253099994, 34.603477217594815, 35.17281134331508, 32.84661519884874, 32.6055593066617, 33.84945029966865, 33.005767655916536, 33.59345620238639, 34.04363441879377, 34.35343162029928, 34.238973438440105, 34.33180753321757, 32.71809488204636, 34.857536320553095, 34.47017275325819, 34.022986339270005], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7879879474639893, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "572229"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.59042330376731, "var": 0.43548701081658875, "samples": [33.70124057031893, 34.07501541095746, 33.877448411698914, 34.11489791595449, 33.39233657692152, 34.08767308401987, 33.373694536342306, 34.04523440841491, 33.37461322006023, 34.27951512798014, 33.51349856687698, 33.25864353926874, 34.22872498807532, 34.265767508377685, 34.290642957718056, 33.351544876343965, 33.25996205237914, 33.04219443345187, 33.693311558998275, 33.2031004435769, 33.2578322625749, 34.75504815961793, 32.93558307854461, 33.0099742240166, 33.84611673000943, 33.58787860574226, 33.22614382091136, 33.47263703558876, 34.31734436232019, 33.970953167534326, 33.243703911753656, 34.04167353939538, 34.071379701342266, 34.22467774885177, 33.72494885681968, 34.71675896865089, 33.20997565929561, 32.40047031564184, 33.05102013629728, 32.79517873585229, 33.37273865239049, 32.46349240673768, 33.83028714675696, 32.15094603065219, 34.08199563770851, 33.684461026598726, 32.53011343927708, 33.74666318742196, 32.12645097825456, 35.24565747407056], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.8496479988098145, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "618347"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.47327383945142, "var": 0.4148795632748306, "samples": [34.10265015275463, 33.68899860907868, 31.840543613903602, 34.5393145404775, 33.29685490569398, 34.503903143663464, 33.61202815750848, 33.353490832007274, 33.29591965030178, 33.459502327774935, 32.49076158256159, 33.24226988541413, 33.40426754256158, 32.80693170763115, 33.88287599894222, 33.40329969352867, 33.731301456623406, 33.06688412843907, 33.951134671304736, 34.29662822830822, 33.158362516235506, 33.385192162197455, 34.059737624856915, 33.026576779042585, 33.48453190308753, 33.8500593124065, 32.89185891927769, 33.68150336530549, 33.67211513569334, 32.60455365977899, 34.453709800865724, 32.274558709778496, 34.230276549225955, 33.998443175654685, 32.648258508784835, 32.93974131555168, 33.738013381287686, 33.39169271768487, 34.88738602266787, 32.388838631077704, 33.97947619719383, 33.681111999858466, 33.929095132007205, 33.905320733929905, 33.413293848634225, 32.89993087888183, 33.36406604591332, 34.10807131648068, 32.36003754896878, 33.28831725176197], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7802009582519531, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "625640"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.39483759091463, "var": 0.6185226415027137, "samples": [33.34582873408691, 33.166468158405415, 34.91277545345254, 32.971742335453044, 32.91733897136608, 33.385005221580116, 32.96906681660124, 34.02859861320263, 34.24262599107523, 33.395172896543215, 32.56895728492651, 34.880941817406296, 33.85217959168782, 32.949189109239605, 34.43558383186091, 33.6527562399296, 34.91215250744915, 33.59269879056064, 32.67245249481145, 33.48415487399554, 31.874496032353864, 33.922990924930254, 33.0082177478875, 34.806638469372636, 33.4556866010738, 33.19323435578769, 33.61388029172116, 32.53386823700681, 33.949813161653395, 32.490569962800265, 33.89083283893645, 32.67838020300609, 32.42823683788392, 32.68955495341185, 33.887204110213084, 32.7664735313816, 32.83212205043331, 34.0262093659592, 31.583342826973627, 33.18314861181519, 33.68797460833567, 32.5727487172494, 33.03320742408662, 33.26223934011326, 34.67928705559802, 33.26613895038812, 33.52946135461268, 32.22254781271072, 34.47834469539194, 33.85933873900942], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7980287075042725, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "439827"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.73890424817573, "var": 0.4945620111248525, "samples": [35.1481606378978, 33.69677176004343, 32.60773600934294, 34.13594108095821, 34.40118333699015, 34.519909531647095, 33.42726815519077, 32.96395548943242, 33.6965528680254, 34.57164882813146, 33.823900739969716, 32.74640061578858, 33.48337129217296, 32.61991536387965, 32.9300608833667, 34.264802226155055, 35.168802676471905, 34.37903678071335, 32.318791535276176, 33.80257465952175, 33.27797204373344, 34.158679556285165, 33.98294326753364, 33.53940071195734, 33.77319943162602, 32.81315688402474, 33.580652472075506, 32.63389114251482, 34.00534376115581, 32.514157155916266, 34.028148384437884, 34.69403025634709, 33.85234894324186, 33.87880341147755, 33.8283803735793, 32.852786988648404, 33.81328837677707, 34.097553719607, 33.63793273246943, 33.93056471132937, 33.91643655997259, 35.31728218899307, 33.976185449272, 32.82256049805207, 33.070964470746745, 33.899636073841414, 34.19858611551504, 34.178101350125715, 33.793541958685395, 34.17189894786945], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.922649621963501, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "763533"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.57602180799202, "var": 0.4494888189299466, "samples": [33.42263077275378, 34.359022040277864, 33.31990620859604, 34.655434202508204, 32.30236268131787, 33.47426493381307, 33.658905491436435, 34.03330192285021, 33.18597698703915, 33.62102860985544, 32.3615082596812, 32.77473605375988, 31.741425674741844, 32.646308954752975, 33.832146834800284, 34.153536148565664, 34.18110648744504, 33.300077453716376, 33.58975558668903, 33.505009607319195, 33.184020241527755, 34.096109154502955, 33.310249347335635, 34.3305532354165, 33.48468141489558, 34.66506318080378, 33.60215206046975, 34.339576096277625, 33.035654457054996, 34.18420165542217, 33.56693678235235, 34.04112401630621, 35.04175361352211, 33.19327790015665, 33.18683064843654, 33.713717694621096, 33.63083823255351, 32.734817613709104, 33.00328131312888, 32.942057799983495, 33.10072720796481, 33.705681211329185, 33.6673801617859, 33.70545094386903, 34.32715986450596, 34.20091938590439, 34.606199839484475, 32.7433290436357, 33.257053277060244, 34.081848093665045], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.8064560890197754, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "34930"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.553992592237925, "var": 0.2968319899098905, "samples": [33.42359177297327, 33.499408870193655, 33.72047441641881, 33.95951142979347, 33.34333612476247, 35.298885097374615, 33.05230673032118, 34.35203924018552, 33.80777636468905, 34.69997178342241, 33.611867820379764, 32.95839907310648, 33.43681602748257, 34.41413199792535, 33.24882148305979, 32.76954190124482, 33.34666096431745, 33.30735745705893, 34.187956213038724, 33.038643893914454, 32.79013094492256, 33.039263248606765, 33.231429551922346, 33.21708889410201, 34.031359653846316, 33.387604708812525, 33.91231459944866, 34.39796887325249, 33.38058051226896, 33.23097357701793, 33.518702446570785, 34.20608964642461, 32.993890566009064, 33.66436187666709, 32.760919229219866, 33.489763436180084, 33.53040338887963, 33.21334250767226, 33.94573203265662, 33.23808869799702, 34.00446029851858, 33.523078902820416, 33.42632451855657, 33.2103736266016, 32.532646404985535, 33.56605955785995, 34.30385882703734, 33.709250987884154, 33.77516593886897, 32.99090349462281], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7543420791625977, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "52770"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.5957388237053, "var": 0.5930965253343263, "samples": [33.542223737706436, 34.41165486060902, 32.5054001032518, 35.092180062244005, 34.270058063843095, 33.000426828418966, 33.19292250727001, 33.4759755857108, 34.44856921433889, 34.56170525702694, 33.83033476278467, 33.811433947264845, 32.85039634427627, 34.238917324103504, 34.92898792869337, 32.83085771285347, 33.81087727502474, 33.387911998797854, 33.983233561140125, 33.54838338269864, 34.03435266093847, 35.0485679300203, 32.37038906703514, 32.87260394479356, 33.22288355892547, 33.7992527015042, 32.92788334333876, 32.50544961104283, 32.35362727598365, 34.6506003903876, 34.61861640887257, 33.425189854101895, 33.056584906552274, 34.37220388349664, 32.9755827397027, 32.82935166991324, 33.22027056948799, 34.22767642755222, 33.92308196254178, 33.65860870457912, 33.4276719514844, 33.817978459288604, 33.302438381709415, 33.31940625850232, 35.33323848741616, 32.40092987856056, 32.71725891611749, 33.69925093148955, 32.88233752149281, 33.071202330375534], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.755183219909668, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "247621"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.592021311765805, "var": 0.4936088893583362, "samples": [34.059072567958566, 34.052535800510974, 32.19070860685866, 33.849929962060386, 34.37234631911612, 33.342590379599834, 33.931723998231064, 33.19618494290849, 34.53631420442865, 33.881255400263726, 33.04515662497737, 33.43422713211564, 32.842760289872324, 33.62454847669788, 33.865255209297864, 33.013364768436254, 35.137286207714205, 32.720581721149784, 33.92888163726577, 33.095666047570546, 34.59247426098412, 33.80633196613853, 33.51621671344406, 34.02445060121708, 32.76025195201516, 34.796544905493654, 33.452068394576045, 34.21714069117866, 32.58274781110629, 32.246805891496955, 34.18784570996918, 34.430579394162365, 34.007886242134106, 34.27922318011579, 33.75698152332628, 32.9701032660824, 32.893455372941844, 33.67931186271657, 33.249920213078134, 33.47456494073132, 32.822818998061564, 33.46202084637328, 32.59546037518311, 33.233680406036335, 33.612351787882865, 32.764523774125, 32.808400757207636, 34.34944401454269, 33.927831746235846, 34.979237692699485], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.8285303115844727, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "259887"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.526878386215834, "var": 0.46299805388698984, "samples": [33.792623276605795, 32.30460591860129, 32.88464309325177, 33.266489036902804, 33.064812132666226, 34.17137127400593, 32.49506585675884, 33.24827672231169, 33.75994483130852, 33.85340253068281, 34.05670287922702, 33.79402504482858, 33.125282056559676, 32.98233690471389, 33.23903759326811, 33.38800793009332, 34.47372720054712, 34.151230990757035, 34.0865926818514, 33.74572223741499, 33.50832374992573, 33.66908589460914, 33.23730859544359, 33.5340634844372, 33.04376619737393, 35.30388735324211, 33.97029538935159, 34.3782078341031, 33.146619002356196, 33.25490213583909, 34.40447190350017, 33.08553589686041, 33.1553192637389, 33.480350328643276, 34.66760136481068, 33.77068098452881, 34.90724756075171, 32.67711299575437, 33.66298715582025, 32.403558359416884, 33.16257804303887, 33.407350165217444, 32.18715448540574, 33.880268864032985, 33.96202572805803, 34.38137431702905, 33.64002379481039, 32.267853820426446, 32.780613095661884, 33.529451354247016], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7471137046813965, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "847954"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.65989144442186, "var": 0.49856475928355454, "samples": [33.093110597639786, 32.61751816203525, 34.42582307940176, 34.369161254765025, 32.428919341257526, 34.137356905922466, 33.68615508254528, 33.71141370856554, 33.0321368126508, 33.48912183328224, 34.263223026038375, 33.00884611317833, 33.451673559429246, 32.853429092705746, 34.50359325564419, 34.09253317890809, 33.02436096902144, 34.11034081399293, 33.544567562630625, 33.541814365364765, 33.71017086352191, 32.406783979892474, 33.55329157160793, 33.73924098575805, 33.8390855243526, 32.897302804183795, 34.52974282568972, 34.92474234788837, 32.42988841207676, 32.965334733117444, 32.58842757351748, 33.737508355051084, 33.721043156712604, 33.39858168933918, 32.44065235673895, 34.45679518177215, 33.854693610704516, 34.13778384181604, 33.28555924168529, 34.17423682763756, 33.83215302685966, 33.9170448083557, 34.3837103759446, 34.47597561675753, 34.707082512853745, 33.693838791871066, 34.49150364862778, 33.06368994875027, 35.200707227220924, 33.05290166580832], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.8012549877166748, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "567813"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.424691194674736, "var": 0.4688196188963803, "samples": [33.09254839605477, 32.58678556674794, 33.89121643344977, 32.05882854978719, 32.90535330623726, 34.29538092058752, 32.74346060648825, 33.55001375955474, 33.011090330925455, 35.019413232236204, 33.03821671339114, 32.936787273645145, 33.060584606452785, 33.42162581944716, 33.299573573079954, 33.73169631076677, 32.9201622362953, 32.673434427493675, 32.700307043992666, 33.236498884804824, 34.50235100104503, 33.534681863439985, 33.878005692565836, 33.954498754437886, 32.54078524630016, 33.640019913371034, 32.08978529760185, 34.2207415112792, 33.629408632042015, 33.3099551359666, 32.59012784574107, 35.015080488341574, 33.562444754071954, 33.760916820381325, 33.56818759413662, 33.057474841480406, 33.81905119667136, 34.154446329698665, 34.111289922206026, 33.53122415188573, 32.263060650755556, 34.019266973531735, 32.98069286395525, 33.26075287602166, 33.54072141297369, 34.215060392998964, 33.2162525003902, 33.482033699302804, 34.612865598190815, 33.00039778151304], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.9666380882263184, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "659129"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.63891455668224, "var": 0.7987154324187913, "samples": [33.5222278931478, 35.51569333745676, 32.351929320147924, 34.05009724048518, 33.43012157446477, 33.39566706072174, 32.78745758846865, 33.44371755349893, 34.25252629570197, 34.674554387759976, 32.38674672464097, 33.95624547860178, 33.63430773873704, 33.588948819990144, 33.2007915625581, 32.5670089200034, 34.060615547483664, 33.64715925227651, 33.469975069680615, 34.229218575741506, 31.875706677969944, 33.90833862412749, 34.217036166458264, 33.59398361747168, 33.50445037908883, 33.458057501128856, 32.541520585716114, 33.05339220536384, 33.96395157732615, 33.09470023983969, 33.37476337388921, 35.435569199966864, 34.91790798976347, 34.30272104701292, 34.8112694581463, 33.43577136868376, 31.16374265317253, 36.09664330754921, 33.39209247604066, 33.52219460538032, 33.93987617349829, 33.13195078505993, 33.82466264631853, 33.52343883717482, 33.45876286307511, 33.79962758988712, 32.56600936540842, 33.54490064925226, 34.93204824640903, 33.39562768236512], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7118721008300781, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "393657"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.55414298071264, "var": 0.6520375373440164, "samples": [33.38878329943056, 34.034600239158976, 34.08451191631534, 32.82252333028991, 32.83228942422857, 32.16900060241743, 33.26069882232747, 32.99837804390834, 33.93490344471153, 34.68414554972899, 32.75605823643655, 34.25089729143291, 33.5157861115806, 33.91343701608703, 33.69993756259064, 32.33862054999652, 34.412897480020824, 33.717657302040244, 34.60035286851136, 32.85088809054536, 32.344659185141644, 34.339880006358044, 33.728060685958425, 33.69452820263405, 34.26421972681548, 33.373868670493394, 34.252062608301244, 33.84968149113285, 33.440381559638496, 34.35694589897697, 33.88980318873828, 34.63529076874406, 34.16457592482996, 33.28769142781292, 35.22304458557892, 33.063213839306194, 31.88118610373921, 33.0805446376895, 33.31384177724419, 33.39969462701315, 33.972851675417175, 33.44099379181524, 33.70910502811398, 31.781397972404488, 35.5797396634689, 33.851948675338285, 33.326076202827, 32.98141175248894, 32.74507891691429, 32.46900325893763], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7035624980926514, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "999040"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.57591794676871, "var": 0.6102382627997748, "samples": [32.36430366184824, 33.95004834093827, 34.228001327972144, 32.76236872205026, 34.46991516619563, 35.551948796205366, 32.32750981495017, 33.69453384553173, 33.02628308523516, 33.877615895168034, 33.285508135421495, 32.48363783841381, 35.008480748113136, 33.49223734904835, 33.76864033008252, 33.92352688986178, 34.03169693350014, 33.01131382893522, 34.262814642965274, 33.626113266650776, 33.98199142527244, 32.46184520964251, 33.19084875698671, 33.227601657325025, 32.98914816832555, 33.28031912130479, 33.94413327700973, 33.114524483225594, 33.27189254413106, 33.4038746653157, 33.139277030656004, 33.05555979562933, 32.87930755683784, 33.92547108515547, 33.61942075732805, 34.881706688388306, 33.80615262715321, 33.051668089109455, 33.03713509386097, 32.652657721759375, 32.503222827560684, 35.38419641220564, 33.27485238011472, 35.03905151193416, 33.30199596487053, 34.232146589036965, 34.580743952604436, 33.663103183951435, 32.68356825753646, 34.07198188511569], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.8239939212799072, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "729041"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.454141831356736, "var": 0.46168169764605865, "samples": [33.8925962588081, 34.20233653626713, 34.0514848306915, 33.894682475356255, 34.15837249813865, 33.234799673364506, 32.57790074444181, 32.5937174631898, 33.895130973649835, 33.32381410435308, 34.00026351406639, 34.50969848486322, 33.32563794631738, 33.94036057512536, 31.866576779471725, 32.666168948934626, 34.30271705248104, 33.976423315331225, 33.46230437674021, 33.26237545145184, 33.16587186151636, 33.42220873155476, 33.31205954802584, 33.05571625550921, 33.88779902639524, 32.919741148214605, 35.21266070215772, 33.73022159045502, 33.21482922617189, 33.172165582236204, 33.26314979059881, 33.376643309006525, 33.54039234238097, 32.3094913091748, 32.19710172060253, 34.0778087468198, 34.43332393985893, 32.66955307134461, 33.75580224614532, 34.18701692575301, 34.563972840847335, 33.95307662175679, 33.25952476828591, 33.17211496631144, 33.15657256439515, 32.87782538412397, 32.81013339547594, 33.45814856761989, 32.48727730995344, 32.92752607210096], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7669849395751953, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "589373"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.58298123474254, "var": 0.5947476567111534, "samples": [32.97398023038328, 34.356367233825324, 34.15264146321596, 31.906536956134545, 33.795497306914704, 32.34075408555926, 33.98591043082005, 34.20686928241174, 34.9213254015657, 34.42129764194292, 33.60695864829315, 32.658122448059885, 33.86167602877213, 33.51517057141036, 34.632731017374326, 33.191928165167454, 34.38544346332085, 34.74704220302842, 35.22855529414398, 31.91809903163781, 32.85746465175935, 34.02590147474385, 33.68427723127052, 33.2736615989552, 33.163703420720424, 32.622328548473924, 32.199051923682575, 34.07147905046233, 34.24106905235085, 34.81200261942444, 33.61504315089353, 33.650312383687364, 33.154496989306416, 33.31398920419224, 34.115463007558844, 32.52282876935742, 33.22637556673712, 33.51558550293686, 33.85291372520832, 34.31265573352104, 33.30299032428654, 33.15015268887304, 34.32896061061402, 33.0661944115006, 33.39508417558516, 32.62415599351682, 33.741362159407785, 33.22112324640417, 33.42193476853865, 33.85959284917591], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.8080816268920898, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "146332"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.67323429461546, "var": 0.7485193326912841, "samples": [33.52928130404333, 35.02350209560976, 34.94350683926809, 34.0435331655805, 32.11038203557706, 34.461351302222695, 33.780032532353275, 33.41130936502564, 33.780910754307605, 33.26856863124066, 35.303492574192155, 33.567291185809154, 34.48357230417537, 32.932491699171656, 32.81553591817258, 33.44458061299994, 33.06602553049153, 33.06212716066118, 32.866724354273835, 34.9448304566194, 34.36784974856974, 33.32663836272014, 35.58749987167661, 33.04968504952635, 33.95736174679144, 34.338020300976474, 33.167262742550655, 32.04214094164908, 32.89472512778255, 34.20390068957347, 33.095239717074335, 35.27876466446267, 33.537944606443205, 33.28430459938042, 34.32055086723708, 33.85305829172695, 34.27610095343774, 33.25352724963441, 32.64451006030607, 32.9882667996349, 34.29030870058175, 34.35444389036486, 32.52830623598764, 32.585128177802794, 33.799875625283256, 34.131345775121446, 32.2026475117895, 32.95744336908831, 33.70658461688708, 34.799228614916665], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.8800725936889648, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "478236"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.74578290181812, "var": 0.8773615243241754, "samples": [33.87814399745419, 34.54975937800684, 34.68019927901047, 33.62261579898068, 35.20131486602935, 33.42016627249772, 34.073382944451694, 34.201478785889904, 32.44282882980151, 33.61255152737513, 33.8286380626631, 35.185814762299756, 33.30924725717181, 33.979858715485925, 33.61391632356702, 32.95182737501436, 32.97283731492495, 32.70040523227467, 33.13232586025005, 31.478637897697766, 34.46105538893833, 32.66230479906832, 31.879193587984794, 34.27202378540946, 34.14709399219211, 34.50725107131704, 34.29928366830359, 32.89221150631208, 33.96953290907718, 32.56113278356923, 33.01757090173352, 35.28567575808712, 34.49781091172123, 33.92678999261919, 33.71227001076367, 35.333167972291264, 33.25817933822361, 31.993521512260475, 34.03279287074293, 32.52724055868131, 34.197464436205, 34.24624371853595, 34.36650988331483, 33.81061135749909, 34.431626783664626, 34.840511962612226, 33.86438140693295, 32.13887419206504, 34.090783768824274, 35.230083781108696], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7661700248718262, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "655050"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.49870264729563, "var": 0.7524235118849003, "samples": [33.81173941732747, 32.94098875045195, 34.159168280616086, 33.33860827165957, 33.51830514599058, 32.69038639596957, 32.873547444801126, 32.71691562734187, 34.30677557723016, 33.3758412147508, 33.727368095228265, 33.52076047553949, 33.46746411012732, 34.09009543027349, 33.431232482274716, 32.85830621776988, 32.30422788488484, 35.4359203139323, 32.442181743728895, 34.67953897634569, 33.62825448754016, 33.390057669740614, 34.5243853991318, 33.515241243496725, 33.72171364682029, 32.83774970556794, 32.401137886955375, 32.7386966604766, 32.02634463727635, 34.74985726756595, 33.437356099873895, 32.91663185249186, 31.715998872285372, 33.431226190933494, 33.972286898273225, 33.55049551266106, 33.80344950364671, 33.84622651191375, 33.319825614007335, 33.340233481793234, 32.80959670044695, 32.75908681515462, 33.816864160470445, 36.071560930267324, 33.8197433531392, 34.3481739063111, 32.54021337882644, 32.52941358708483, 34.72906880250038, 34.954869731884116], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.74639892578125, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "272627"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.43794188631147, "var": 0.5315630318275213, "samples": [33.832132569512204, 33.78475091785736, 32.847490658737954, 34.05214817776198, 33.46598069085492, 34.889142888959384, 33.90772005724917, 33.59522381351216, 33.95730161488152, 33.32000748622012, 32.35088302755558, 32.92011809487248, 32.05191981482941, 33.801452409654125, 33.30143456921257, 32.16379874198882, 33.57627628827096, 33.73289156574265, 33.277215492343416, 34.571909197851426, 32.27232360232797, 33.13177863902736, 33.0430614834451, 33.78243928461683, 32.78609719067381, 32.88315175313095, 35.038141152821474, 32.775319108052905, 34.14521198860627, 33.219355818564715, 32.893666222920075, 33.7438826334773, 34.68333028580322, 34.361070301166386, 33.43160843990596, 32.78493413442643, 34.836038981001884, 33.909591422064146, 33.64559820558225, 33.64567174490787, 32.83128595110643, 32.13522415249673, 33.34329592834755, 33.27908315042598, 33.12285308015133, 32.99913563375085, 33.11247690254895, 32.47351341206798, 34.27814003474129, 33.91001559954551], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7538189888000488, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "300034"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.654508736040526, "var": 0.822096077353642, "samples": [32.81575212449253, 34.48454864979888, 34.698548478716845, 33.54325494411067, 35.114406458970954, 33.77913175920563, 34.7855789430864, 33.74843741328319, 33.75649327220292, 34.130593355532625, 32.699393300408026, 34.82808528897643, 33.01824200713262, 35.4594090846806, 36.03771012145458, 33.27954820768498, 32.67732437743518, 32.82134928317867, 32.98638841304337, 35.11970389489937, 33.598758655175764, 33.74524231718507, 32.834241360125766, 33.7856481601629, 33.97357832565811, 33.348738433499214, 32.71819608120233, 33.71336659598045, 35.42063589477383, 33.87747853561681, 33.941402408801146, 33.18262076516165, 33.84371673330511, 32.848268810748344, 33.774829902410566, 34.19054963916506, 32.53244146164229, 32.7639866095745, 32.0298947171684, 33.147397973056414, 32.979516898202014, 32.60625078870389, 33.83493734055835, 33.77363654383727, 32.42421700437481, 34.026938794541486, 33.09788498672115, 33.843541996917764, 32.25926471455575, 34.82435497490564], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7635586261749268, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "472"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.67541695500771, "var": 0.5871793955458747, "samples": [33.28795065631607, 33.93017911946826, 33.36647915709655, 32.505764190104564, 33.55989103855421, 33.6400855358631, 34.253388172852574, 33.37342610085317, 34.688132998859146, 32.94857743419589, 34.004871178754755, 32.26510380806459, 34.02412476926067, 32.82211073483878, 34.52900501478357, 33.42760436154302, 34.03918941309924, 33.3158948327898, 34.7800837726615, 33.96822461506257, 34.60245626660465, 34.02057339198878, 35.54142782160518, 32.29947568453675, 33.65646075352549, 34.47517037415221, 32.66791896220557, 33.52564337075111, 32.585074915696865, 33.81956744316918, 32.98321088678841, 33.87692067186444, 33.3106837575483, 33.92330761202149, 33.41091132232582, 34.334542587416415, 33.47248066718033, 32.95337837195799, 34.779229459059195, 33.06862835586033, 33.94786477526675, 35.74504389581416, 33.60604439022818, 32.99147275948782, 33.048132599567076, 33.17204914734145, 33.36638296696692, 34.28765178542972, 34.56389983726464, 33.00515601173808], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7324447631835938, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "929679"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.803288855337115, "var": 0.6675922967259722, "samples": [34.02758390296291, 34.400855450932355, 32.60715127743931, 33.68811726055889, 34.14206131805349, 32.251778380865275, 32.96556732430534, 34.54941804697989, 34.13729483303799, 33.688660790896016, 33.33666787702758, 33.460860514657035, 33.695212393024164, 33.44305207783746, 33.052453145208304, 34.13545205000005, 34.21294164682042, 34.48489157607613, 34.37262066348659, 34.23254960636776, 34.70317337956741, 33.38441258131592, 36.04643469542196, 34.72369249932535, 33.488527102943735, 33.767710257083735, 32.55484523735144, 35.861589946804386, 33.94347933752194, 32.65633244907686, 33.94114975480517, 33.522627713811474, 33.500440282937596, 32.71218584794063, 34.00869750882909, 33.56020477381612, 32.98513190258599, 33.36568295945341, 33.25378822019889, 34.21792897334124, 34.793450975418665, 34.195122788699344, 32.75236059376353, 33.2896245417938, 34.00709034615736, 34.489626494228965, 35.26135343752687, 32.23807424278327, 33.85079901214807, 34.203714773666796], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7495872974395752, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "727622"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.61437399142802, "var": 0.6297779324421866, "samples": [35.131174105631366, 33.848452382543464, 32.53117190161291, 32.84535339822796, 34.44233342207771, 35.54256803007584, 33.10437374317216, 33.46229443770088, 33.03708481730742, 33.52151561651189, 32.44474700254951, 33.74073699923185, 33.284973892309054, 34.33461476409648, 34.08071292889816, 33.16981687669207, 33.53266017406461, 34.274374565922685, 32.57834007626809, 33.22684921647507, 34.61487484223183, 32.76401155541148, 33.46447166711067, 32.81781038051054, 33.39090530732092, 35.5332204525166, 34.11921717077218, 32.810985788402654, 33.498499574795844, 34.88542744024413, 34.1079489623447, 33.19577961174323, 34.29791740187459, 33.753892826158236, 34.489680216862496, 32.486397675855926, 33.06429695203646, 33.19075637861674, 32.458362442901944, 33.11859845960452, 32.90336369543783, 34.62453505019589, 33.544538816406245, 34.447613471110685, 32.62151528313128, 33.55063969510446, 33.370052898231656, 33.430153251510944, 34.42612579402124, 33.60295815756569], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.8003771305084229, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "350005"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.49157514922055, "var": 0.6353499033559408, "samples": [32.4985516065823, 33.76525665324755, 33.48206348781586, 35.04164444368528, 33.278440620147975, 33.09464435765384, 32.903328116603845, 33.407640819652066, 34.875987592349865, 33.14840178003896, 34.83041972921558, 33.5517127221997, 33.76991020344348, 32.80163484501637, 33.01553211376171, 34.75496476107307, 32.85676383684322, 33.768308734529334, 33.42873793224375, 34.48905000935223, 34.486196985814445, 34.48413051400924, 32.767914714718046, 33.98073545396572, 34.22699573864637, 31.3952842566002, 33.12330871527405, 33.14634530337609, 33.177713928803826, 34.99418930404626, 34.37916456848552, 33.53844014300187, 31.83476403864875, 33.13900108742846, 34.51129263685047, 32.79609599563361, 33.83038927977216, 33.554777971106404, 32.63543692160153, 32.65017500962383, 33.277714975856576, 32.970872399233286, 33.761505026712356, 33.10353860101746, 33.86696068757848, 32.82670687300684, 33.54757468823516, 32.923912561126905, 32.75414339593248, 34.13048131946504], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7039353847503662, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "219935"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.35689223503433, "var": 0.5683496622936651, "samples": [32.287710316498355, 34.024478279396014, 32.70655061511183, 33.3455723746289, 33.293161950914886, 33.74536401715125, 33.703418458727995, 32.57072892181028, 33.2927151920322, 32.97557576875617, 32.706247680238114, 34.774985920166635, 32.71978038285947, 32.96144859579723, 33.54193381243053, 33.484904750577904, 33.41707594590915, 33.95160601599309, 34.33931762712078, 33.35209715601552, 33.831530182010965, 33.56765494977212, 32.74768708210293, 33.72562177197024, 32.40913419474349, 33.1743444562896, 33.581290586683565, 34.18614864828526, 32.86105677364413, 31.89830548548401, 34.46194518179352, 33.551773906644634, 33.80211703628569, 33.2722868481572, 32.89201210020813, 33.926078326114315, 32.414243578695896, 32.84415242732967, 32.574188724037015, 34.35940855008878, 32.442539959833766, 32.14084162699355, 33.13627099185495, 33.81255035876059, 33.82271874716764, 35.11406881727572, 32.47795680266557, 33.52215509854334, 32.785963184865345, 35.31389157127841], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7013530731201172, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "926278"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.46741846827818, "var": 0.6715144190249722, "samples": [33.67643716957522, 33.35835312583825, 33.85872828543242, 32.56930344203068, 33.40342747102217, 33.346793907505464, 34.07810178358855, 32.36443339442563, 33.5977084907874, 32.49030424720499, 33.510437763755725, 34.02787237780009, 33.13134868302914, 32.951629422043105, 33.862662107287555, 35.7754711924672, 35.11178126519697, 33.068845924645615, 33.48967855923301, 33.329853933023244, 34.62539940934958, 34.05532901718987, 33.62066734868057, 33.78228294399865, 34.16723263189384, 32.92501305445089, 33.344179226566126, 32.60469911829608, 31.98331167776648, 32.207637997287705, 33.20500839722101, 33.519810482062255, 33.559949709975456, 34.39600487904, 34.211609133389736, 34.08466469203555, 33.97532123485136, 31.418276613492417, 33.199288104798796, 33.25158545520651, 33.447772886224705, 35.0912700529491, 33.96410624087301, 33.03195084136831, 34.249185809653326, 32.84054263690397, 32.559790063819065, 32.19632092616637, 33.682427982265985, 33.16711230024002], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7841987609863281, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "891770"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.81901945357912, "var": 0.49462033966015184, "samples": [33.63127888617376, 33.65269857765834, 33.65449060548151, 33.64008935058296, 34.078554726345324, 33.60433380100198, 34.8401596713151, 34.85300980388531, 33.48388379927338, 34.81773686898841, 33.752962095076384, 34.19380801627023, 33.06227778390906, 33.5927027327574, 34.657763747752256, 33.78131710625014, 33.18844926604025, 33.54077422104607, 33.92216019358949, 34.757103929328345, 34.48077044980241, 33.88243888030857, 32.49610424991382, 33.71312919767807, 34.13957659546026, 33.84502326074706, 33.39377616203518, 34.49010762463135, 32.20810217251319, 32.24226581570608, 34.90053918699355, 33.60268152227151, 33.90108990879751, 34.81231451010495, 34.396006972829106, 33.876467632874814, 32.688643999903356, 33.1619497908311, 35.01433653423242, 33.733323507259044, 33.03873728101274, 34.20007747335384, 34.62392503762062, 33.85109470770439, 33.40889203974053, 33.064022853138205, 33.7504963828967, 34.951850161683126, 33.13484047238236, 33.2428331118049], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7285263538360596, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "350799"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.6153570393722, "var": 0.4350768169376655, "samples": [32.99934385544564, 34.128983086295136, 34.495190214235535, 34.47328578412894, 33.641212511739475, 33.128565052028264, 31.907860416337485, 33.46774716546421, 34.365892423563515, 32.523055868364835, 32.95363679694461, 32.91965662733584, 33.66085461138531, 34.32454066496484, 33.65576247801316, 33.246495132263725, 33.79784261529454, 34.2237018864876, 33.60345094099062, 32.56783461260671, 34.03774389443027, 33.01728163016528, 34.57873430630064, 33.76976844591816, 33.284037639737974, 34.05250860752241, 34.147747876688165, 32.9638140683022, 32.78540772991785, 33.84667183658726, 33.18896945133961, 34.63563455689673, 33.86932431929255, 33.25660752722445, 33.81371233086852, 33.48554831369988, 32.436097004534695, 35.164889116785474, 33.590469840208435, 33.277619982069695, 33.420660979556494, 34.48934554051165, 32.87058405348459, 33.813969865665776, 34.307823297111234, 34.25518691920423, 33.164446861440325, 33.859905557070356, 33.66627789441582, 33.632149777769605], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7044804096221924, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "66977"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.60680014071974, "var": 0.5115317730344505, "samples": [33.434981554113435, 32.950524293688076, 32.79334089790169, 34.63274264160307, 32.68142725029188, 32.30203750652251, 33.79034305073283, 33.25530374616592, 32.70292253742548, 34.61575532456177, 34.309543227059734, 33.70311541024683, 35.17454573729872, 34.8715254782921, 35.37956670350978, 33.68635520953256, 33.492823858592665, 32.92930576108258, 32.756748560808035, 33.420330149258625, 33.968982231808816, 33.79340422408032, 33.34549432199072, 33.955381373301826, 33.215083715698206, 32.934194333461065, 32.82191313734511, 34.45017963007924, 34.18522303513665, 34.42387815513865, 32.916393526130726, 33.24200730220669, 33.8376864811066, 33.175725255571635, 33.96759370049857, 33.86478242229566, 33.720197429446124, 32.93001306319697, 33.2400931157148, 34.11522677904597, 33.62427067419154, 32.838200052159344, 34.19632738013617, 33.12454106964083, 33.501782525173056, 34.65834453417958, 33.257667658734235, 32.95512076278662, 32.77224865372341, 34.42481159331932], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.8909671306610107, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "820745"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.55142672742133, "var": 0.5145695281946411, "samples": [33.58269550823283, 35.52449376152594, 34.047601164123904, 34.42748602225505, 34.03238439357335, 32.98505592654243, 33.35055562386422, 33.553805438838154, 33.84997493276501, 34.085982278826116, 33.14563671416062, 32.40213629689937, 32.454939631234836, 32.973236646435396, 33.38682511480707, 32.788737970265565, 33.89659185454518, 33.17925194796298, 34.675647830623916, 33.023459083030566, 34.50989382817403, 32.90563691211614, 34.379619379685955, 33.25633179085753, 33.54163104154311, 33.7569017161359, 34.25760408425818, 33.42259540393902, 33.8878912965658, 33.30344554445269, 32.88553341570608, 33.5531327659574, 33.88498484842148, 33.85977331235189, 33.40448779549954, 33.52198679296679, 33.65572934745592, 33.613230345288635, 31.957549233735506, 35.37256991140884, 32.78416792803572, 33.82020526687468, 34.41629424042982, 32.95626856781692, 33.67698048876047, 32.07141089944372, 32.88676907457613, 33.66951092594776, 33.282212220763384, 33.71048985138516], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7355647087097168, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "815517"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.75327201210105, "var": 0.5541537708389641, "samples": [33.077462194499034, 32.89755947790256, 31.891572950327387, 33.4835842623466, 33.662478857049926, 33.80379606792499, 34.057923744512436, 34.13115721896199, 34.22247344280841, 33.547569564121204, 33.20084094515086, 34.42747696441536, 35.2848536297579, 33.24562260304922, 34.179207120478196, 33.45244464749644, 34.160253914132674, 33.570163529019226, 34.40804459623081, 34.86994013973951, 33.11483845564487, 33.035170655971896, 33.99425884024223, 34.63982230539551, 33.82757957344519, 32.716258461279544, 33.60037766441198, 33.76998107745683, 33.115755506446696, 33.12479997164446, 33.383432398777494, 32.73666611084402, 33.15468175020908, 34.92745396897221, 34.8561782319069, 32.753025133480406, 33.70413467988823, 33.344495829837804, 33.827751927236854, 34.34758116333237, 32.78571791793164, 34.52442388309091, 33.69827660520359, 34.43284638351744, 33.57286879509435, 35.41359040362823, 34.27330828458127, 34.58974628412837, 32.672638830727365, 34.15151364080018], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7349138259887695, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "621077"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.45626577224, "var": 0.5540156665285126, "samples": [33.25585329082569, 33.32583761856359, 34.19036112500791, 32.094092530089625, 32.52484338100121, 33.49231723156626, 34.12269878752062, 33.524742451274236, 34.4010634991892, 33.571411631573525, 32.98596348919702, 33.649207395988356, 32.956907672025416, 33.62611643021295, 33.265165200895225, 34.66316495389331, 32.62968734993399, 34.093000341301924, 32.382567234299245, 31.923326670886908, 33.76382925112257, 33.4688965761378, 32.79230869968179, 33.16717093839538, 32.908217063337226, 33.029642048002856, 33.65579608274882, 33.28672441229261, 32.26526306360742, 32.99258029432883, 35.628910297032796, 34.266128888677976, 33.44394526659637, 33.21347801833487, 34.575277612242516, 33.677417577998014, 33.52912667979875, 32.28801428791924, 33.116440360170714, 33.054802459632036, 34.22328844699052, 33.508146721561275, 33.458342257312516, 32.98714079868708, 34.33897287900175, 35.02193836665135, 33.58499091923919, 33.24578745907141, 34.20514758825224, 33.437235011927655], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7450480461120605, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "527332"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.64080989454844, "var": 0.6719931449121477, "samples": [32.33397034034531, 36.019882010486675, 34.61371132599946, 34.20493700274579, 32.42029805586214, 33.28855394545026, 34.132287706192216, 32.89065355985814, 31.531509601306194, 35.17539364042158, 33.71650726564808, 34.403878120249885, 34.107102837189046, 33.43475134610154, 32.897011633663894, 33.48887238052737, 33.613700097324596, 32.698931018856285, 32.85993465766483, 32.78771555003149, 33.29139311280434, 33.944107271249855, 34.04657275165239, 34.0841150515753, 32.967334786243384, 33.7144941633631, 33.45237138628243, 33.650228796554636, 34.17116720589103, 33.882826674853725, 32.34434839504578, 34.51397178699123, 33.48718868516856, 34.07859784842957, 34.03923096040252, 33.57956588494688, 33.50282645982557, 35.73516703539689, 33.53789322670182, 33.68170198304665, 34.32045862869145, 34.0251129025913, 33.45959513127466, 33.50056579997202, 32.53213548206248, 34.1631590442045, 32.994446063658614, 33.61891287261483, 33.847695743403655, 33.25370749659789], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7794513702392578, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "511807"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.589170497739, "var": 0.5337779671608679, "samples": [34.41687718108684, 34.21437483765624, 34.92641074196717, 31.98689805995753, 32.850526698767425, 33.07101468297212, 34.18420736830816, 33.5497037309658, 34.25267211982111, 34.94267542380517, 32.81459937660256, 34.393735472355644, 34.03688547900362, 34.401201511975394, 32.71107485817186, 35.163225482658305, 34.81385314262015, 33.56939475828297, 33.31792900691308, 34.201659192363294, 33.978728067386164, 33.57347777283783, 33.761102173958164, 33.39859389785953, 32.826461729620476, 33.80068628603012, 33.279178983415925, 33.63323121774633, 33.501945423735336, 33.441683484499244, 33.210904109071556, 32.78250822676099, 32.53746928313776, 33.57274804087285, 32.97193466680177, 33.56197137306574, 34.14595005243433, 32.77532647572566, 32.772248041051306, 33.54541375054304, 33.59314001836013, 34.26777253154148, 34.92228100870493, 33.683262323719894, 32.655122925070856, 33.657709824523664, 32.83067092559262, 33.033976603211684, 32.582628849485026, 33.34147769393079], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7613458633422852, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "9114"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.7620140939367, "var": 0.7811176416300999, "samples": [34.31127633829925, 33.34554156172458, 35.018627800225815, 34.70365313431381, 33.4562218283589, 35.60716087372697, 32.48833084080357, 33.53489151838161, 34.167378389148446, 34.52707051712179, 33.971658060748766, 33.768366399993674, 34.02021669442862, 34.280740308945354, 33.858111774009735, 33.418349163135304, 33.78103704841879, 33.36306053562888, 32.88290917603982, 34.56901243862527, 33.639837245320095, 34.46156330805921, 33.1024606345391, 32.45806791515033, 32.24493826919124, 34.40014460033671, 33.88916011254334, 32.87813137339678, 34.80281242347785, 35.050679145425086, 32.65919914512644, 34.02112009003975, 33.59649408946938, 34.646043510786605, 34.6487802221879, 33.13199387068403, 33.362529158518164, 34.57681625553607, 32.624312682586456, 35.15524778708999, 33.78336506398767, 32.337276288523704, 34.27417596595911, 32.33555256445958, 35.05218568437544, 34.15752619580723, 32.42645741521574, 33.38228724003666, 32.02923819140035, 33.89869384552595], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 1.7172513008117676, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "342940"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.654962082596676, "var": 0.5827942021949316, "samples": [34.14179031644779, 34.14415356772209, 31.973527272099187, 34.46506974932773, 33.32783832219618, 32.973085851710195, 31.869114881528162, 33.47994453832941, 33.45435490333331, 33.9980305843184, 33.707669908465135, 33.88038173592725, 33.943787546173596, 35.03239358128042, 33.48516504336853, 33.66485221711689, 34.309517968413, 32.91418784328513, 33.95889407604594, 33.78745445568794, 34.630590419548106, 33.42440833212117, 33.29371170667605, 34.259793369494815, 33.22100906473657, 33.87352892025982, 32.78361416184179, 34.92693877222997, 34.5382698002013, 33.71045656644534, 33.82967090158314, 33.30738404637942, 35.20471181713078, 33.77149533234591, 34.39146043655934, 33.69397299585843, 32.52311229398589, 34.05085848557375, 32.107133976752706, 33.894569156885254, 33.02804164693519, 34.079982226500796, 33.8385884795601, 34.82735881156014, 32.654232100159845, 33.60671102779125, 32.80013445039733, 32.42643554487828, 34.18503889151186, 33.353676031153334], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8994386196136475, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "64705"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.44196663584649, "var": 0.5973872789178464, "samples": [33.80909054013531, 33.68826871998196, 32.447916875873794, 33.11951089340013, 34.114594278130376, 33.66196679726863, 33.68371871564414, 33.608884564410616, 33.277126546944004, 32.25435503753015, 35.24940941816661, 34.660080162574054, 32.66044170247185, 33.45274384488426, 33.69163123785001, 32.79364632284699, 33.04741695579463, 32.404456823728715, 34.65738437006363, 33.70383999319828, 33.9784397649307, 33.14925632485513, 33.57972276500031, 34.00934950749287, 33.02857214072464, 33.67209349943237, 34.264622997802235, 32.75238321030815, 33.96150922758188, 32.524089190638264, 34.26020859381915, 32.79392655530857, 33.43351842236174, 34.236351662664404, 33.62108752794791, 34.02564325613211, 32.706658618667056, 34.671415523503825, 32.17308449263129, 33.01336827719778, 32.46775604571563, 34.49709307884992, 33.59720249886302, 32.314935720225535, 33.929589065924645, 33.4402769996305, 34.48383281270871, 31.736186650630124, 32.83581902913147, 32.953854530746405], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.9675309658050537, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "240583"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.5706170375094, "var": 0.44164148368441775, "samples": [32.84995823405955, 33.578069968363806, 34.91238916302248, 33.658442846282306, 32.70533788752866, 34.334547841662086, 32.70052496067314, 32.867280066548446, 33.13541292569787, 34.107786506620734, 33.39451978183157, 34.53100129715262, 32.27758759133286, 33.15363641420983, 33.14551758359387, 33.45267937118668, 34.013251335656875, 33.33262655150797, 33.27794698424261, 33.35346187887758, 33.57355513423827, 32.611009024397, 33.11562260071582, 32.90632857529853, 32.8897570480754, 34.89593955889678, 33.727750125614165, 33.769815095733726, 34.76726930225429, 32.39960446676755, 34.089102473098215, 33.02932991882405, 34.21905379177064, 33.31512441604243, 33.275136287872165, 34.02901726702041, 32.84595544774519, 34.867270550236235, 33.776448425848564, 33.03446306296732, 34.731536757716604, 33.63045602620698, 33.6747857350652, 34.331855640352416, 33.42911088509019, 34.01290970736697, 33.82206684125166, 33.89958471550358, 33.500488659932344, 33.578525143515826], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8622148036956787, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "619952"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.625472616493305, "var": 0.6019722768782415, "samples": [34.23587133807476, 32.2603933079624, 33.30112741530324, 32.51738951734858, 33.515871435366954, 32.95962625740491, 33.143861221719305, 33.9871891848974, 33.5443152538436, 33.554753452025466, 35.052016285342624, 32.39857052342246, 33.98648227825473, 33.29577390382473, 33.31807023195567, 33.54482943624253, 34.64372794164786, 32.3526455584871, 34.439879595230735, 34.597833164017494, 33.812281216766536, 33.99001380763176, 32.00413512364907, 34.15634925268508, 34.63931301050314, 33.99776214501454, 34.16444260040254, 34.279093433448836, 33.1975226906662, 33.61598058522859, 32.124076094205144, 33.66630602258959, 32.987827572746575, 33.6100746235934, 33.7470189570809, 35.14680533240435, 32.88504158234773, 33.00280022769531, 32.9827294871504, 33.06056125717669, 33.97512082585237, 32.8459969719225, 35.21442366371724, 33.83249044024932, 33.95035683054257, 33.60006848489838, 33.400245612911675, 33.64474724588791, 34.55981398850859, 34.53000443481575], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8341572284698486, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "358654"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.782358257748236, "var": 0.5000181790726328, "samples": [32.649333929753794, 34.2311679630688, 34.59951692477984, 34.67822678518885, 32.840178164270554, 34.06306051273802, 34.64244772024395, 34.67926324346219, 34.52648426972903, 34.57568758946992, 33.10521364465455, 33.23243766853192, 34.0578473102844, 33.92090760839432, 32.5319131555124, 33.58039915209027, 33.17776684309186, 33.01064745399292, 33.274464683647096, 33.683860871118085, 33.50886715151827, 34.47676773823779, 33.708998934617476, 33.37923937598193, 32.760066413251046, 33.450869776161824, 34.51102940535211, 33.09293701976498, 34.67968771656382, 33.316346971083284, 34.13516377498406, 35.38793785445256, 32.910867974917245, 32.91209977509738, 34.36153107193074, 33.63079104608964, 34.706488301539835, 33.87470924132409, 33.90984311272114, 33.28465071834576, 34.01192088523233, 33.68062447321139, 33.203558261723614, 33.6349460934275, 35.069363019905765, 33.20632462241212, 33.15691861942507, 34.83207075827306, 34.180372124189766, 33.08209516165323], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8741214275360107, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "533570"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.660713030956195, "var": 0.36106051650237375, "samples": [33.321047497508715, 33.36232143598798, 33.485409615922094, 33.79366584380929, 33.66177628465023, 34.017320213024284, 33.83439095911761, 33.30336289354343, 33.343249878968514, 33.37346006947537, 33.38227860235581, 32.32569571269439, 32.88562957484401, 34.458830014763194, 33.57611433547153, 33.779306351566106, 35.097228439586786, 34.217620064465834, 32.639251159752874, 33.0153258780624, 33.9142314656138, 33.8988733397556, 33.511630856147946, 33.97441080480941, 34.10495274600879, 33.44597022155196, 33.98011583955097, 33.136675432548365, 34.206432811088796, 34.674737724577895, 32.07160506920087, 33.33067560302203, 34.199158346014215, 32.5415939933326, 34.660645662262745, 33.759605538092906, 33.55661753487766, 33.694277231548476, 34.01126100832558, 33.68629756121918, 34.24154023931286, 34.31567176811571, 33.7282227805497, 33.31992115438134, 34.47904774524316, 33.627789312113485, 33.45199072847607, 33.928026093509665, 33.92505027009482, 32.78533784089259], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8469891548156738, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "79329"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.48570746649436, "var": 0.5362997259488, "samples": [33.20323911684029, 32.545309275301726, 34.11172396621984, 32.704875251202985, 32.646692814218106, 33.60311380324763, 33.00222694436324, 33.69509489933786, 32.65807521816125, 32.722108081386466, 32.503862784208984, 33.23662516696906, 33.63089886230763, 33.15099386434876, 33.168867559025564, 32.60803246275176, 34.80626489554957, 33.549444838706165, 34.6270036655627, 33.332257218026314, 34.81502784594711, 32.098434660520276, 34.25803151583978, 34.038324624673194, 34.4809693234863, 33.870335386854215, 34.06133423079754, 33.14239182288263, 34.14692870402377, 34.29073163244629, 33.71942871495216, 33.01133591118985, 32.997898783585484, 33.62473527116504, 32.6588000922558, 32.35959851870102, 33.29728262495521, 33.78515570785696, 32.886654685163094, 34.11733301039164, 33.23229140044769, 33.923403982478106, 32.77559531555242, 33.197116043021424, 34.86210777995328, 33.931079045172126, 33.8878216954991, 35.10029764905611, 32.7095470712327, 33.498669586881825], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8016178607940674, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "832522"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.61625193504282, "var": 0.6823594755147899, "samples": [34.042211235577454, 33.29512497666841, 33.479981810695236, 32.51341046355325, 33.778649268696064, 34.88973763382299, 33.221904189655824, 33.244757758795316, 32.068865735453265, 35.961946301277976, 32.40447471004854, 33.662873285783746, 32.441996513189935, 34.613518260005954, 32.95879060801067, 33.19600476369594, 33.44534076487436, 34.44001637485884, 33.01141033446174, 32.15292081670993, 32.957945467252216, 33.310229171936236, 33.75903712105518, 35.13100227070392, 34.12473184777154, 34.984266685544796, 32.49826038457027, 33.52155915228514, 33.885599857711625, 33.26542687833893, 33.794870122525815, 33.6997704111061, 34.209137911375166, 33.63980608320258, 33.026740687056666, 34.62438963984434, 32.95100929708903, 34.277900183212395, 33.48101038162173, 32.30104217445078, 34.19263311601009, 33.671765283343106, 32.98705888546216, 33.793878089093695, 34.19225257160942, 34.960500504239896, 33.96870061327316, 33.460599583184305, 34.18168398854945, 33.135852582885676], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.782745122909546, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "145032"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.72094154190036, "var": 0.6360020609195979, "samples": [33.34649902737973, 35.19744336355955, 33.12942030415325, 33.170264889775595, 32.70051664878748, 32.97161038796678, 33.9590766316589, 33.723755154871256, 32.52087602373046, 34.025747641282145, 32.90171664587413, 32.25282823055961, 33.18390036883273, 35.06006031711908, 34.68492593495532, 32.38133306556709, 34.72025890138879, 33.95379982316244, 34.352735909575394, 32.762410153010734, 34.23701144643661, 34.414474494943036, 33.62945804905242, 33.36112153074992, 34.05958790869261, 35.09606871211382, 33.256613544075776, 33.871539050969396, 33.33160242521615, 33.897113438167764, 34.11278406520532, 33.27557857794075, 34.72019145882458, 33.773191322905696, 33.5458456364621, 31.822854596639665, 34.061683292625574, 33.069241804361155, 33.86554649797535, 33.74815840515462, 33.169278341274875, 34.877199335003326, 33.53083426269388, 33.626046498264124, 34.02697259725746, 35.107938429053604, 32.583426454620025, 34.38146654996909, 34.431170804730634, 34.16389814042791], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8795971870422363, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "161377"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.67250332595873, "var": 0.3556339505566865, "samples": [33.42378418681041, 33.64052344310881, 33.55355085846338, 33.49973908484622, 33.89825268663266, 34.400055477034414, 33.07476791451444, 33.868653590234516, 32.896573505340335, 32.85747426034185, 33.794754276421195, 32.93072797886488, 33.46970336681064, 32.90066979710129, 33.183112614006866, 33.92314347441081, 32.72834619077857, 32.81762683890139, 33.18625459020092, 33.872910724111584, 33.683000699601415, 34.07654446087384, 34.27326093214414, 34.504898971635704, 34.62430587448703, 34.27772127208173, 33.64948495888248, 34.81687373005024, 33.8603759465463, 32.75721621243036, 34.28768707769513, 33.995208379697374, 32.783659098213896, 34.41016952817501, 34.152626768891906, 34.20513471913538, 33.67950871162342, 33.060629443216754, 33.45302611990614, 33.642078175440176, 33.16232515235986, 33.023727410103554, 33.6782256791922, 33.03131262463714, 34.055011514064475, 34.22083884544662, 33.73330258670701, 35.0608494723897, 34.38753602967185, 33.15800104370029], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8346338272094727, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "422082"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.69734618579949, "var": 0.4914472872335065, "samples": [33.63922653558905, 34.39540688143002, 34.106593127389445, 33.617102740730125, 34.77426837104637, 33.54163845582954, 33.821486869044996, 33.48852178794094, 35.018684171693344, 33.20792786726332, 33.00404777945987, 34.310294613865956, 33.78843295145117, 32.98440363558782, 33.00291799738534, 34.06116838486216, 33.80601125537525, 35.30304578871071, 33.651571936148876, 33.712645526449506, 35.189400051518895, 33.43501276865695, 34.102252980551306, 34.58597549753936, 34.23305199486257, 33.629943314983734, 33.98153341751488, 33.38904712287586, 34.46892951430453, 33.51925098901873, 33.274376088164615, 33.79894668377136, 33.28828638042921, 33.00018857256593, 32.62263810137248, 34.205740412148394, 34.774798165453305, 34.04257688193796, 32.93613159338244, 32.83109711168649, 33.37482471772544, 33.97095517867036, 32.941418267657724, 34.00704495953025, 33.73752714660711, 33.39601803559336, 33.00655476867122, 32.87891272571982, 33.361647036768524, 31.647832133037515], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8465099334716797, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "914889"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.9303445294417, "var": 0.7201526877422662, "samples": [32.09472985143474, 32.92976016059601, 33.617802168955016, 32.82667329514974, 33.93178983826288, 33.60109088272143, 33.59874982597066, 35.678388664684725, 34.32388205096863, 34.38538602307949, 34.74021289970961, 33.886314706119094, 33.73777813304621, 35.534280113758115, 35.01626965771638, 34.03169750218945, 33.523169574044864, 33.623678784700694, 33.29454406478996, 34.124251167426614, 34.55746151657966, 34.80256597933789, 33.85508870854523, 33.1207428376389, 34.22342561793067, 33.85938033274727, 35.2625086025512, 33.4542065307119, 34.53512950998673, 34.62161169240922, 32.209966607975375, 35.983549169654154, 33.6014279590765, 33.622432284366404, 33.88399618700381, 32.44346276625529, 35.1103503495994, 33.38820995996035, 34.17476527317354, 34.17777771878142, 33.90955705682693, 33.258884107332854, 32.9240732070978, 35.166396830695334, 34.06333226390336, 33.942897573213486, 33.59994551472603, 32.72563496875815, 33.63742080950989, 33.900575170411905], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8606374263763428, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "115567"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.658098793924154, "var": 0.5192792334347268, "samples": [32.93023412280257, 33.82188926462953, 32.586426128402806, 33.57492376260641, 33.73398933228657, 32.7717365913574, 32.78365609531036, 34.3025220094329, 33.54147683856656, 34.288512791475476, 32.38034486497996, 33.84881975383493, 33.96638318758693, 33.41593259266338, 32.94818821871958, 34.237714290717754, 33.82718911556748, 34.2324109373651, 34.05024293896025, 33.79329543413146, 33.97402072553202, 34.017052665386984, 34.51096911345278, 33.78472290953281, 34.261963335021164, 32.65719224227014, 34.97573383062103, 34.064144023312245, 33.259598369189895, 33.08226832138294, 32.638609368363355, 33.17261020089517, 34.61800553888029, 33.10087804576116, 33.70391239603081, 35.08367809279892, 33.15090467929641, 33.766024096119224, 34.59440443308938, 34.33577586150247, 32.25195906341791, 33.11359490588796, 33.31039303515938, 33.78492269242349, 34.67357180299247, 33.29060837816751, 34.017793787263116, 34.19370701258615, 34.45210185262742, 32.02793064584555], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.9531443119049072, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "320298"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.539268651244335, "var": 0.5561846704867914, "samples": [32.99527299239871, 32.254540840372705, 33.905754184685165, 33.31780148271561, 34.543722637068115, 34.13408164996134, 33.05239012153799, 33.18212065802548, 33.72510694493463, 32.42748030435649, 34.006452586134, 33.71168552547078, 33.367943098788515, 33.86561886905579, 35.346069888389806, 35.19856939398598, 31.938088596559407, 33.373827937903805, 35.04201270025993, 33.92572445880287, 32.055846793404434, 33.566061007425894, 33.52039306704838, 34.26824452547278, 34.23886915285163, 32.985369791123716, 33.26922092338802, 33.94396443239171, 33.25179912833461, 32.49114308844721, 33.13922587514954, 33.54691901543381, 34.14475004281283, 33.1365845007929, 32.27215843639901, 34.38252725764268, 33.42158187377461, 34.11252244085818, 33.77920399817024, 32.70461362976853, 33.97966357093367, 33.37093456919429, 33.55121858906292, 33.364680214289805, 33.48598259176018, 33.27221286428427, 34.574715800832465, 33.41066443790569, 33.33637930674192, 33.071716765114004], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8036179542541504, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "47587"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.55215857073569, "var": 0.6456839898438576, "samples": [32.1851846440549, 34.67387462205836, 33.40886488909248, 33.867567857082804, 33.51740238626396, 32.807533551058356, 35.30971715361838, 33.9230542232928, 34.37474055807054, 32.1782870765923, 33.282058791146184, 34.626141950292514, 35.13863502532469, 33.90121044824093, 34.07830913612452, 32.9771772454797, 32.75172927556011, 32.13504819534809, 33.056885955004695, 33.406347224268096, 33.64564026033645, 33.98691317157844, 33.67490140462127, 32.42148450976012, 34.11582008488455, 33.77786822950281, 33.00470164919978, 32.14897780649872, 34.700242316617725, 33.00419397229594, 34.23280892677543, 32.92895308662676, 33.73280245078397, 33.30630561314666, 32.88721889229323, 32.90263453184309, 33.69377658306082, 32.62119153195982, 33.4542635330289, 33.414730458752686, 32.323097551060044, 34.51870885437104, 33.4654362105036, 33.899625857793005, 34.11964376108993, 33.43495319253759, 35.31360069720923, 33.81279607329253, 33.877115826412464, 33.58775129097351], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8828859329223633, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "557885"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.60533772623142, "var": 0.36491462681209225, "samples": [35.17187049083958, 34.19399681910805, 33.2910489780127, 32.85087898018038, 33.97520217433197, 32.572038146257334, 33.582100905248595, 33.569717589633925, 33.57982804414698, 32.83285172095638, 34.02403702805356, 34.54333764419656, 32.75100878330182, 33.83166253108364, 33.110826366401625, 33.90650527330545, 33.54958905334069, 34.51760051733993, 33.94878225488223, 34.0722431920741, 33.702160343627696, 32.752645315929215, 33.61558767952412, 33.42717205127668, 32.56312060189092, 32.869033693059166, 33.62713876873888, 33.934696822338786, 33.721582844094314, 33.594988823875084, 34.101640356549055, 33.74061331949166, 32.74270238421392, 33.696674559149905, 34.23224012073015, 33.11961845812988, 34.66822992796578, 34.77682549608235, 33.9214428080989, 34.015851335353105, 32.6092406845727, 33.104223517747805, 33.217576917643804, 33.82870145613944, 33.134287953115475, 33.473016582102645, 32.92660280867997, 33.74591299557308, 34.00508451815512, 33.523146675025984], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8165292739868164, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "431105"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.566892416599366, "var": 0.579740933514086, "samples": [33.18231149801374, 34.044982581235494, 34.04209879221359, 33.76747667266854, 33.61298460334564, 33.02592088659175, 33.862057672753146, 33.317890289221914, 33.06744373313349, 34.304312763042084, 36.2235683301599, 34.643884434984756, 32.62002050046629, 34.38231854735152, 33.21685437097075, 32.518003975661465, 33.033557551315845, 32.05673485822772, 33.68420412270175, 34.921712698224646, 33.60579922933697, 33.12186748436496, 33.20357306860485, 34.180668916747074, 33.38795396608373, 33.54410388841184, 34.26347716350459, 33.18502172069899, 33.84362965206278, 33.11510552346329, 33.18445350966029, 32.90115788100011, 35.049286484434944, 33.814263751076, 33.010871782973425, 34.36036791742397, 32.99413324078789, 34.48901532954608, 32.70691421000698, 33.247759960732225, 33.1409105372324, 33.39898949253383, 33.36744014431067, 32.72443332729487, 33.896303344131155, 32.79643737372386, 33.20325639048559, 33.20059606202967, 34.789852979463845, 33.08863761555742], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8225882053375244, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "468689"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.48216893102409, "var": 0.750376116680041, "samples": [35.62879294620864, 32.469294725516335, 33.76823620847789, 33.809876244370486, 31.762130703327177, 33.334250325455386, 34.03437404628221, 33.521101144239005, 35.021833522805444, 33.1086686147079, 32.64676911424378, 33.539353761181104, 33.613199365143934, 34.13769263974996, 33.26688362641423, 33.44859692653156, 33.482955633848654, 32.37622890819283, 32.34897164460014, 34.11469235534285, 33.49153276871564, 32.476326227389485, 32.32485008271619, 34.27017225109371, 33.73689008354485, 33.22716367403323, 34.047366693672366, 32.96063604637925, 33.290302604735324, 35.214295688426574, 31.68022510326124, 32.84821036325836, 34.381511375376085, 33.87731276344216, 33.445967600597605, 32.14458979185256, 31.879331314837188, 34.112230122909054, 33.88542644298903, 34.81521251546274, 33.45464947153642, 34.04821512567621, 33.87492489245154, 33.98963463560759, 33.26488137669811, 33.471779362694555, 34.70516986047986, 33.34329469077556, 33.73413798816422, 32.6783031757883], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8957397937774658, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "73899"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.63649088292722, "var": 0.6938605214609443, "samples": [33.775064923586065, 34.63186766177793, 33.93512576247126, 33.27280826513183, 32.80705528411616, 33.176649432326435, 34.65822176124072, 33.59446067978246, 33.63951011564226, 32.880278446412355, 32.72280366955812, 32.06515464884672, 32.245678043340014, 32.73767203733685, 34.92192304258496, 34.36699424792145, 33.88000633927678, 34.569678672990996, 32.38747672255882, 32.70797174497509, 34.18837462921441, 32.91275725431872, 33.67608749466156, 34.93720460377492, 34.68567022561723, 33.75769115348283, 32.47893879158206, 34.65768354434372, 34.63859728266735, 33.66746983349617, 32.71491561446061, 34.82478487785792, 33.081070739130325, 34.065768310970306, 34.40964099332496, 33.2222253518967, 34.47008949772431, 33.769878744985604, 33.213484802812694, 32.38778699315462, 34.04318349182258, 32.12061653124985, 33.22349357057044, 33.76114166610503, 34.14652474827967, 34.44599209569964, 34.164222044311174, 33.89222525534002, 32.70779283659754, 34.58282966503083], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.7849555015563965, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "556405"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.5675409228144, "var": 0.5584492126677504, "samples": [33.931505068059735, 33.12317905614541, 33.470345314785675, 33.969868798731916, 33.99516152783115, 33.12600288561628, 32.94816335060122, 33.71029385875218, 34.01914676812131, 33.69122729239055, 33.814317509280954, 32.61464469783819, 32.837618944762376, 34.239390405782906, 34.347241163503604, 33.88208157938838, 33.61787281990435, 33.374340058162346, 34.236690982215485, 32.62930681844725, 33.830644588006834, 32.636508528272785, 34.344422664401066, 33.4938636995542, 33.82275439529982, 34.40569293005085, 34.525097385226324, 32.21199514562962, 34.02815572155153, 33.66090536505226, 32.57323147505086, 33.02360341406169, 33.60170947736531, 33.67715912047904, 34.30456988052353, 32.087344908712794, 34.24654134469342, 34.048377559309785, 34.212250588103515, 33.3382207333249, 35.90553149075452, 32.759718685181994, 34.8089457434497, 32.67137305223811, 33.004120075757946, 32.27473646930263, 33.20667131987654, 33.777398054249275, 33.601801982759255, 32.71530144215878], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8001463413238525, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "961264"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.57860464883194, "var": 0.4899999496707134, "samples": [33.74818381431491, 33.84403258175171, 32.94236009897704, 33.898622149305105, 32.81116542417478, 33.759015017656225, 34.76672228327066, 33.96636369374545, 34.042974011883224, 33.89058056763299, 33.57679773847925, 33.7365369786694, 34.75480357633707, 33.3954360452162, 33.956377897620854, 32.886810015695204, 32.72308624526952, 33.36849166502384, 33.22700243626502, 33.71232394600533, 33.15431793821159, 32.95132898829309, 33.153736809546956, 33.45605169938852, 33.116391485188764, 34.23192994598687, 32.141284792923734, 34.137979065256864, 34.45140976264672, 33.190995188311305, 34.31170618950251, 32.282307258360305, 33.20154033180112, 33.717991176054035, 34.45216292131566, 34.26814905606421, 32.11235397904252, 34.08877897420603, 32.97058638201136, 32.92882084171789, 33.158491311078144, 34.88192400331293, 32.46336770424722, 33.099226378944, 33.857112154725854, 33.979593025345615, 33.576575967789296, 33.55792888971503, 33.78364983485444, 35.24485419846094], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8903462886810303, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "971177"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.53970417351524, "var": 0.4534774442532603, "samples": [34.47659304292151, 33.619201695782145, 34.19675485628084, 33.503754096108146, 32.23837119904169, 34.34283777059071, 33.95381286860631, 32.93307223563243, 34.13551425003692, 33.18314629562878, 32.69017196031792, 32.934875189585306, 34.05428382949381, 33.432687284909555, 33.0804517962717, 34.79686532736037, 34.508697739677956, 33.06359879535623, 33.458198346527034, 33.79761593278703, 32.54608461517182, 32.74623136874265, 34.67887586693699, 33.56905752312883, 32.90666798125189, 33.44612182486789, 34.71902027643767, 32.646172010939225, 33.34895378223221, 33.65128067533811, 34.38828343829832, 33.32680906853289, 33.18151748431411, 33.90267100215163, 32.401046000839116, 33.8445134926344, 32.64596459946263, 34.97109724750507, 33.811976221847665, 33.33132964881777, 34.005326114659816, 33.27147365750577, 32.75710286473674, 33.0882277134387, 33.61994410889858, 34.139283072682716, 33.45370267782092, 33.65161045474222, 32.73484360261923, 33.799515766289964], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.7951688766479492, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "104099"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.608048481544195, "var": 0.6261010542694434, "samples": [34.06563606260838, 35.85461314308509, 34.282402228720855, 34.248292796695, 34.25851417033762, 34.060688684616714, 33.82557349791203, 32.77298036734487, 35.24330599933707, 33.03837711248899, 33.52977194715838, 32.22187006580979, 32.7714107596023, 33.08601823390456, 34.598067561943246, 33.67890617610107, 33.03939678076145, 33.60724660006923, 34.291713237969496, 33.28181076556484, 33.86312635166442, 33.43201859390116, 32.93965784080794, 33.39462014756726, 34.6790876161036, 32.641802248761465, 33.77572100971252, 33.23217258182075, 33.19911986009479, 32.82882435880239, 32.88019114761287, 33.69149395867603, 32.97990211808118, 33.889008693693505, 32.77220089140628, 33.31955336242418, 34.37393292686363, 32.26659773956403, 33.43123196705678, 32.84852402957861, 34.710760853556266, 33.25258768854325, 34.01595809957545, 32.89670728751402, 34.864858727730464, 34.486331431756604, 33.199920813340725, 34.00790916013278, 34.43818595272667, 32.33382042610892], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8017992973327637, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "353160"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.50270235094276, "var": 0.5832131203332097, "samples": [32.797750205019234, 33.224951690885426, 32.52235295061472, 34.070996920166614, 34.03048714338008, 34.2993292781132, 32.74229441754889, 33.67370482045393, 33.25705196845218, 32.14153458826422, 33.51556635892974, 33.72604745160614, 33.125274289375035, 34.56108042248521, 33.444306181329765, 34.31731329950915, 34.338520234863054, 33.86376712204496, 35.434458753694244, 35.16564075766729, 33.42882664021112, 33.45874651799507, 33.88894939713383, 33.00688490364246, 33.99068808664174, 33.230629131547765, 33.22691765249379, 33.30481931204895, 33.423134575885946, 34.052239684896826, 34.02604131310422, 34.411909331537196, 34.58217690442491, 32.205552263863595, 32.71516854002925, 33.62214987097767, 33.29798303267637, 32.8120394034479, 33.199358050931615, 33.26081012911053, 32.39559521385787, 33.426563238137675, 33.04875631333573, 33.462826713370426, 33.40598807982708, 35.2493798761129, 32.433519243963765, 33.2290320708305, 32.420620315570105, 32.66538288512812], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8838300704956055, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "151517"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.70279345998614, "var": 0.670607828089219, "samples": [32.85703585365153, 34.13646053635959, 33.9833158511423, 33.08422990994538, 32.84232771902115, 34.23069230274218, 33.241373307421306, 33.06652748653495, 34.562986928811405, 34.17787996144843, 34.31151868600657, 34.311522827043156, 31.988006092833523, 32.576424415081036, 33.34254804425367, 33.31698972950697, 33.4752312355988, 33.55052706289905, 34.577215965544504, 34.65086775092737, 33.51695442751807, 31.607733583217616, 33.43027425610297, 34.41700553976014, 33.691324430286045, 32.49404913283995, 34.22796657626465, 32.7164423710454, 34.20221517354586, 34.00128471546417, 34.91547916646521, 34.20988392607724, 34.762398895750096, 33.411607030414146, 34.468446713325754, 34.26332938180926, 35.943939623203065, 32.93655806332505, 33.18743450253853, 34.16753016307225, 33.58261528200895, 34.591596892350324, 33.75555328662561, 33.54212919750124, 34.15889617596898, 34.309750004573225, 32.46198724690359, 33.35574762016691, 32.77043296954521, 33.755424984864526], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8013699054718018, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "783352"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.56124429912649, "var": 0.585721654078655, "samples": [33.807351920421134, 32.584452756117166, 33.517364499309444, 33.68728320218794, 33.45690356255078, 33.99699825410708, 33.420630769128145, 33.586915290036934, 33.537868629969736, 32.893526465031265, 32.99365508605109, 32.61787912044922, 35.50628549193286, 33.362364718523466, 33.7652152550665, 33.98051517603128, 34.4715356837059, 33.39874263344168, 31.880859762313534, 34.817170449864726, 33.833277979046585, 32.91954468529381, 33.84007412004324, 33.91619008936508, 32.07115473274236, 33.707233078762826, 33.77320178233472, 32.10059164279684, 34.0427553638078, 33.167225628485674, 34.418066758449655, 34.080677715815334, 32.79278689276194, 33.58431802278091, 33.81070345269998, 33.005178231885644, 33.37406123500353, 33.65262431950643, 34.97575728724232, 34.51598265194103, 34.263187972504376, 33.237907250619735, 33.19835437440501, 32.78934801147798, 32.9298925174032, 33.57757289185538, 35.06196322336493, 32.71451115328337, 32.89538469306562, 34.52916847133929], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8990623950958252, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "178260"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.74221762803034, "var": 0.5048386676464505, "samples": [33.94321565005092, 33.988419753764354, 33.85223909214796, 33.71312019440625, 35.89485514232291, 34.1908760207168, 33.113039406286966, 33.83069608767148, 32.891206648096585, 33.83636016828254, 33.72702323182061, 33.63522959804112, 34.48300541762491, 34.07881953945115, 33.70510964690983, 33.97260039686152, 33.03273666376259, 33.55943754866623, 33.2638877912461, 32.57225736285923, 33.808257459821604, 35.30208476400983, 33.635109249307945, 34.454062237329424, 32.499551807555484, 33.98229730702689, 34.35268035226151, 32.9872971860764, 33.374449780482664, 33.38130640041009, 35.32077162199105, 32.36561361031919, 34.70083432050495, 33.44398300440008, 33.89664760351957, 34.65232179983677, 33.41286202850001, 33.737036814722565, 33.59050054503269, 32.86408355412932, 34.573664565864725, 33.75469945498004, 33.88838128421114, 32.68460320810235, 33.716817337081984, 33.45983499542377, 33.80476334806692, 33.84629892250886, 33.547032631550316, 32.78889884549843], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.9348058700561523, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "122799"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.76776161990088, "var": 0.5306004629900104, "samples": [33.50370664643989, 34.6222822790883, 33.20428392648308, 33.053530911097916, 32.69734241851135, 34.238360036407926, 33.23628281422418, 32.936938551408446, 33.30001145687655, 33.126857880005296, 34.92000890911016, 35.082380161306375, 34.65565499170242, 33.275098879250876, 34.015730916293116, 33.696354395343924, 33.58961654754332, 32.77014483934898, 33.93441024881517, 34.14088163908033, 33.53724088205054, 34.20680561437603, 34.59469134356511, 32.572128054977455, 32.8968065417545, 32.63774226749144, 34.20377804347366, 32.89654693010096, 34.21740736232209, 33.372965394151514, 34.02370811738313, 33.08867877519648, 33.30890752616895, 34.179353450840864, 33.34701650098947, 34.78694535957942, 33.63220391740664, 33.558210563891954, 34.025323758814345, 33.84147036966746, 33.999890204511914, 34.42971954213538, 34.39652387161422, 33.51336880908699, 32.62619149729173, 33.305360248069114, 35.722862238187155, 34.3242821701641, 34.251141151200386, 34.89093204024363], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.821653127670288, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "219769"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.54564134587741, "var": 0.5901595136656244, "samples": [33.20616388020304, 33.52293687291922, 34.224829851915395, 32.611517021777615, 32.40032194648543, 34.47303776739591, 34.790458789157995, 32.99470199348426, 32.82738514818157, 32.90700003603156, 33.60264962614672, 32.91219469058638, 34.314212190814764, 33.07134364995167, 32.80161424320073, 33.224966158427165, 34.7840784963621, 34.378763934539776, 34.33662567408906, 33.68517771369545, 33.81610386291855, 33.66887653455342, 34.32474026310727, 32.11495603689787, 33.3154337308159, 32.89822501049393, 31.71175277451893, 34.48651128273694, 33.77173659769779, 34.62569575179897, 33.38374133270881, 34.02055257520204, 33.8372792407853, 34.66282357158414, 32.69342814079029, 33.25601099600744, 33.301966523559294, 33.044010555332314, 34.259289510759054, 33.51535443738035, 32.60788491140623, 35.235668994688204, 32.33511396370662, 33.66947255406032, 33.58698125758626, 33.39706382689137, 33.216497905635485, 34.16326147043071, 33.894220940943676, 33.3974330535071], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8713033199310303, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "35012"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.66914806706808, "var": 0.35733785920425876, "samples": [33.67057747302157, 34.53276073862798, 33.15497209449045, 33.444514402432844, 32.94569737020572, 34.71266949749763, 33.58951438066647, 33.5116649698545, 33.37202970704274, 32.9241508994795, 33.316051539739526, 33.86396108898807, 33.66734449823772, 33.629238501894946, 34.02948695324306, 33.240158909943155, 33.16522941379604, 34.25569695314651, 33.64927587624845, 33.54284144920896, 34.524974785405306, 33.50485460786113, 34.12155928623348, 34.645828276138126, 34.73692770847417, 34.14238730665369, 33.76736844936479, 34.258487753689174, 33.59121015367169, 32.79384673138268, 32.78932364712841, 34.14205887899747, 33.64973698997568, 34.28732517113275, 34.251636159816215, 33.372984646456736, 34.51692364429618, 33.655938157219026, 34.106958330550206, 32.784349915683634, 33.89087931032195, 33.21064044686245, 32.64808849043252, 33.233429729486524, 32.812198060986184, 33.993623340405165, 32.174132758026026, 34.050663354457214, 33.334491490606055, 34.246739053923456], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.018747568130493, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "687277"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.46526305663232, "var": 0.47542202487963703, "samples": [33.10941633862856, 33.54032830790923, 34.250699581482074, 33.693436186012896, 33.26009333042232, 33.808198722394984, 33.124261769143565, 33.37211433047475, 32.44840587533469, 32.45126977077435, 32.26786896619569, 34.811293554638716, 33.85020957016698, 33.930193485216606, 32.881880866992205, 33.711673823139, 32.446842610838964, 33.86098472582662, 33.87291633070954, 33.20082446039884, 34.13187574451005, 34.82071589830069, 32.138454616798626, 33.66178031315147, 34.408373058844894, 33.06984374928584, 32.721275534510504, 34.31817988382543, 34.46226512358857, 33.640857708160716, 33.19016539684178, 32.84245128742604, 33.765398293267985, 34.178448756169914, 34.04799027940411, 32.88593599157216, 33.168682417184044, 32.117086603850865, 33.89953635141125, 33.51190671331449, 32.57584172699438, 33.23680151819874, 33.22327500633028, 34.330925476056784, 33.79727201441416, 33.39181123851459, 33.97638406966565, 34.21594925793749, 32.91346011374777, 32.727296081636204], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.832451581954956, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "573619"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.78077574943553, "var": 0.6058219698778305, "samples": [33.71455671699773, 32.58670224516412, 32.32715548615434, 34.478881740304296, 32.8252847167787, 33.811029967625615, 33.743483359215354, 34.95132550612627, 32.863926496520385, 33.27014165686468, 34.20485280068149, 35.12239740303968, 34.87655946080131, 32.959311065469116, 33.21590066578515, 32.945370353992026, 33.46605438180466, 34.382074626458355, 33.921307069678626, 32.596972700129584, 34.51016083357393, 33.1351229688696, 34.07086191694012, 33.7634190652272, 33.0738490144373, 34.50704686963111, 34.17725923901728, 33.83591021378362, 33.15899075989376, 32.86335788243066, 32.923785701915996, 34.40786283566341, 34.44666049469238, 32.606491710153826, 33.662330814447756, 33.472559560099285, 32.89993926499902, 33.42047160072762, 33.9092019947238, 34.548328673802, 34.7443673275451, 34.83411194881982, 34.846562961312465, 34.27998044716491, 34.28794359479675, 33.32671443814831, 32.885530766418206, 34.92973406131906, 34.441738646093505, 34.80520344553714], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.822751760482788, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "93191"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.81337891224992, "var": 0.471758742111111, "samples": [33.78142299840462, 33.9089575764807, 34.10152752269772, 34.524096545026815, 34.631103847323736, 34.29699620248677, 32.33358118267967, 33.68648348249259, 35.35979193482438, 33.723879832681824, 32.67947542381472, 33.551567599156456, 33.27382059231058, 34.68374995606543, 34.36113862400309, 32.86912825276447, 34.05362695562572, 32.66068962056796, 33.90065848913005, 34.7722358329449, 34.18831055947116, 32.943011733332035, 33.295794986743275, 34.15937069838222, 33.427984489073545, 33.78540774726563, 34.54246271165934, 35.28830914480185, 33.1329078845492, 34.106188196842496, 34.27295795164683, 32.988129666959075, 33.901792494965136, 34.10881128379986, 33.40702419309989, 33.67729277132024, 33.50619939759399, 34.09577793587693, 34.92597880627933, 34.155865595017126, 33.13052284171092, 34.296775979526835, 33.37682007871302, 32.95081362431758, 34.40915954670266, 34.36562319631317, 33.58128153913406, 32.90595683238679, 33.2865779601573, 33.30190329337191], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.9168198108673096, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "551957"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.586748555742794, "var": 0.704736046893491, "samples": [33.42728922766423, 32.56207797317919, 32.76600319679315, 33.14647222497617, 32.894320120369194, 33.731750064258954, 34.55792281935974, 34.379564154140375, 33.52771537609746, 35.16763001436549, 32.965509947422426, 33.91350327848771, 33.62471556240238, 33.457749098693824, 33.000814989511774, 34.14627573427478, 33.41763079861923, 32.9625434272972, 32.61403037816615, 31.938177061850332, 33.42813968655112, 35.017524748053134, 34.82207037568196, 32.881980189835154, 33.39319298468143, 34.47046368239875, 34.109215465020775, 32.18173295284122, 35.132443156087454, 33.31695372874774, 34.10858876543365, 33.72962432072212, 33.96993138103989, 33.67337433930969, 33.33723562215361, 33.088641048137646, 32.30052441387957, 34.27430102063693, 33.75512309499821, 34.782028589684835, 33.323099540545684, 32.61756601865077, 32.14149834719519, 35.855491115130484, 33.492201724968986, 34.05072512168202, 33.91758955168247, 33.394082477010876, 33.327257532450034, 33.24313134399883], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.000109910964966, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "838013"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.532415731000086, "var": 0.7961366374875628, "samples": [33.08682528626459, 34.24936908111494, 34.70943258605142, 32.26227963368518, 33.30475492142838, 33.46418593686247, 32.998565020601305, 32.73362314969446, 33.36435275285005, 32.35474471070046, 33.00708439838852, 32.7293972251864, 33.39790513827827, 34.35943831212285, 32.26375065998569, 33.883516754446376, 33.418127423930514, 34.662009063817585, 32.594369672512826, 33.63272586174567, 33.28019734650292, 31.847446770810187, 33.44179395469803, 35.03166037126431, 33.84103336561238, 32.27386277147373, 33.34697461258642, 35.172674019664754, 32.96150200059311, 34.65426821618009, 33.444510446623426, 35.07194080992005, 34.48927189678019, 32.426486609520296, 33.96103595526724, 32.43378854996607, 33.67024341001921, 33.963010122461874, 34.738443631080955, 34.24162966473466, 32.64172961245048, 33.89159856724494, 32.072150551771315, 34.56076346440392, 33.27126215695123, 32.781811379812254, 33.67597070630666, 34.47990921671533, 33.37438614126583, 35.10297263765418], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.9085423946380615, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "847521"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.64264465178254, "var": 0.5181128441311906, "samples": [33.52409242948995, 33.40734485858416, 33.6191309813683, 32.98009636357718, 32.55953268397561, 33.10223839625951, 33.85108142843799, 33.11845216448382, 34.14754681079127, 32.93569560508475, 32.77968447739699, 34.093895550990254, 33.47116922037255, 33.17924564236977, 33.852499609450405, 32.73352461516524, 32.607582464963, 34.12400585377616, 34.287645405043435, 34.57984789750851, 33.401154194173614, 34.41881537441873, 34.32412022974213, 32.85845362685418, 33.84496327662885, 32.394743117144635, 32.150594659939145, 35.073778944266515, 34.56131391971579, 32.85624416632064, 34.39382573774265, 33.52327398401255, 34.357267469474955, 34.122703062813514, 34.57925756617874, 32.900683451966025, 34.01983395807237, 33.86548707913179, 34.45551336937771, 34.626675489139565, 32.67584522820733, 34.402240029484936, 33.9918197918693, 32.980206920968165, 34.04073985868513, 32.71666185778504, 34.316903622832854, 33.41993069812271, 33.59743532553239, 34.30743411943608], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.1804516315460205, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "355612"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.42473997308823, "var": 0.47989351524914675, "samples": [33.4931339732327, 32.19118404413161, 34.07023961703946, 33.17370750024753, 34.76715782645767, 32.304845120479435, 33.107481781709936, 32.943410420173215, 32.72681097858602, 33.481971329560515, 32.81936621150024, 33.54484743273346, 32.93205973440697, 34.55956814014937, 33.17698278763063, 34.32074841233461, 32.43643066198751, 33.26090407400992, 34.701636272747464, 34.7182664396219, 33.606006613377936, 33.44660783691204, 34.38881740915197, 33.2942695209142, 32.67787081799754, 34.655489315635194, 34.54223800860942, 33.35566730240322, 33.65692991366375, 32.913240963357055, 33.01588272129159, 34.03366033285617, 33.21063947114209, 33.32390341632616, 33.13855651130851, 32.62380855862876, 33.27837816437953, 33.66880530100847, 32.78312841292487, 33.49114234425503, 33.32109029457209, 34.50367573977605, 33.159106561474665, 32.11133182137812, 33.604381536304786, 33.42915139560425, 34.16313944555476, 32.89168648841351, 32.90979921878621, 33.3078404576632], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.9550838470458984, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "692442"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.777615757456616, "var": 0.46851109018859344, "samples": [34.09105202374689, 34.65581507980378, 32.08825104639709, 33.32339771615689, 34.525676858607966, 32.977538746599436, 33.96041373060939, 34.616487376783276, 33.48716028614307, 33.46097095634568, 33.75343160441875, 34.138877982976965, 33.68494395786867, 33.4701284351565, 33.807161387384504, 34.037222203024974, 32.85531780197667, 33.9587489420104, 34.24268598710424, 32.78404278147982, 34.7044596132593, 33.33066176540722, 32.99032295884006, 33.45053081533541, 34.34948672443523, 33.98057745167659, 33.597379207618864, 33.405649631699475, 34.04125431313465, 34.10830590616152, 34.269866271008674, 32.8712733338494, 34.062971099147695, 34.97779959497682, 32.86835300927761, 33.681976112245614, 33.265203214235825, 34.605184218992605, 35.20891442782629, 34.38872012395793, 33.66207973149035, 34.76086645855844, 33.964655651893956, 32.29193251023657, 33.4816435488829, 33.95621052431179, 33.08843324833888, 32.93497387840319, 34.53424504859586, 34.127532574436756], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.9766724109649658, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "474038"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.68512339532292, "var": 0.46237154281874593, "samples": [33.322722761582924, 34.46263232274843, 34.2126658869168, 33.429720929035575, 34.283792019930694, 34.596593859484564, 33.55702735830113, 33.84010741182888, 33.79842941861252, 33.47780502971746, 33.13366666937782, 34.11187360803164, 33.711482987179004, 33.328944496493285, 33.39018122389767, 35.67488030417573, 33.30537255384255, 34.293149886575556, 33.43575809675218, 34.04930644849298, 33.49754392283998, 34.23624145746906, 32.667515515888, 34.18507018906738, 32.26480063045995, 33.19184642028918, 34.1267536688241, 34.33299006929007, 32.28432132221055, 33.52512074120747, 32.58906504426395, 34.21714930147153, 33.56561752328724, 34.45653731948189, 33.710260491465334, 33.90174059003767, 33.11724008271336, 33.889271412105074, 34.334327282048264, 33.32637347540085, 32.47645020622376, 33.800370101527456, 34.42824669207894, 33.827275884113796, 32.93402339242247, 34.1713865466361, 34.14521587636066, 32.524762587997536, 32.87036382168257, 34.24217492430419], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.113689422607422, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "105957"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.67654445875152, "var": 0.2916472852709464, "samples": [34.19199265206512, 34.32502202549949, 33.88067273210718, 33.31093290230172, 33.18972113987295, 33.674306515169846, 33.821423124959836, 33.136563494451615, 33.478856271102046, 33.13802023802053, 33.66058641644361, 33.89482162659633, 33.62880069997219, 32.76084124067759, 33.20072911112443, 34.027378133953455, 33.30108567754922, 32.73065951501192, 32.652980936329115, 34.47989635391275, 34.095588604792276, 33.837314327464675, 34.04957062329339, 33.43988888928503, 33.51385002459639, 34.313881368431495, 33.49561217490034, 33.58125193465503, 34.48205051861789, 33.06210456284754, 33.895070595920345, 34.506002110800885, 33.46446579310522, 34.05276605393197, 33.48955009652447, 33.769547415597515, 33.790777686879544, 34.435377933097094, 33.47128635549035, 33.62778703859978, 32.734095547722475, 33.6762601831497, 34.56996924330559, 33.829713140723506, 32.80944869848652, 33.745383639683645, 33.209158786851845, 34.88363624349015, 33.07244174848139, 34.43808078972908], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.959120512008667, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "226268"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.57213810386009, "var": 0.5216135685456582, "samples": [33.972441260509456, 33.98136299439393, 34.073481258516544, 34.00043762626825, 33.536646508995155, 33.84701534090448, 33.83177278936125, 33.835571719378834, 35.26487874144803, 33.193280591196626, 32.62753099434512, 31.99975329950598, 33.716002051053636, 34.75760849437901, 33.17308213112079, 34.27110250483904, 33.464608062752994, 33.83427547162572, 32.87049284726016, 32.59190752500374, 34.624389483343066, 32.431736474628515, 33.95961219586454, 33.586413890759104, 33.921572217271056, 34.046249474944105, 32.98193157788418, 34.88607421778356, 33.32427527137739, 32.782372216275576, 32.51883539828461, 33.05388812954278, 33.29793535544188, 33.78946532935753, 33.541828747036796, 32.11365835697192, 33.24314557972781, 33.48312754801289, 34.31219562530842, 33.4851652854352, 33.08189336231703, 33.32614918750276, 32.71533979563912, 32.938323561985165, 33.13514597432776, 34.61339198604372, 34.09417628056757, 34.482518048872876, 34.47811160330358, 33.51473080433521], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8409640789031982, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "162675"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.41503673200597, "var": 0.3890590127941612, "samples": [32.74288775071098, 33.53334100918877, 34.19566842998512, 32.75549423016092, 33.25127477670183, 35.20182561643508, 33.462372906099304, 32.918462768889015, 33.74571154452663, 33.17640382708756, 34.62707370380827, 33.28150857842152, 33.45767474692087, 32.81017968362723, 33.03148882263185, 33.10618350512956, 33.35218550033299, 32.4703728881082, 33.44847756736392, 33.774529023871764, 33.024598266226015, 32.911074574472885, 32.82154056365441, 33.498161085575234, 32.976297140003524, 32.269417515526015, 33.381580729352386, 33.99869420428436, 33.680494492053356, 32.99034235134566, 33.191168615484585, 33.391317766095135, 33.22895521713316, 33.82533639456002, 33.24789595057954, 33.289961920319456, 33.9423737818147, 34.36366371581761, 35.43763535688549, 33.92787638611037, 32.99648070167294, 34.03296668720402, 32.89059165075442, 33.642871720678414, 32.68483386085429, 33.08770396679556, 34.02699036051854, 33.17549106249583, 33.032402238780165, 33.440001443248995], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8333640098571777, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "63553"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.54499482361802, "var": 0.4568177778205206, "samples": [34.260495898837505, 33.05166523824944, 33.323258890387955, 33.796707658461145, 33.948732658590764, 33.361513117868206, 32.10142006073312, 33.904613064191835, 33.76839246042621, 32.65564633073128, 33.872550539861386, 33.2354533867826, 33.005659085673585, 34.144319815472635, 33.88411742751024, 33.014264174867925, 32.88712653047672, 35.32320961137515, 34.04292190439813, 33.07368363475132, 33.11127672858628, 34.549804776351536, 33.52612686886013, 33.23908441784783, 34.274264025382486, 33.052554889386634, 33.46299420002348, 32.40869274518708, 32.89170990317243, 34.46147321238843, 32.51712405613328, 33.48094417703095, 34.31165186321154, 33.273636087687485, 33.95140660493774, 33.280021217186906, 33.47980699392299, 32.58298030291094, 34.83051762409977, 33.2421378493889, 34.95190845537984, 33.41936469190488, 32.77421806443325, 33.92207733956856, 33.09897781714744, 33.57051515742473, 33.31317263173689, 33.57697662072498, 34.37490482404518, 33.663665545191535], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.9662964344024658, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "698227"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.7454854416233, "var": 0.616237022965635, "samples": [32.38862340923776, 35.68123937936652, 33.30721044299331, 33.34994917172532, 32.83973448995206, 33.840351806008684, 33.825740037513924, 33.3000069086888, 33.70816302188456, 34.597972690540644, 34.032700892881, 33.62065598484614, 34.169268213690316, 34.18792638711203, 35.11718099423824, 34.30872118357506, 33.979248560064406, 33.696414959923196, 34.30985301843213, 34.02646001823687, 34.716490239996425, 33.40413886377899, 33.540840796073525, 33.32149967951642, 32.81267737734931, 34.83524671151717, 33.49414140480059, 33.69637379911788, 32.88585175184908, 33.2013928163531, 33.01468408750941, 33.10618664216501, 33.555298445643764, 32.5991897648908, 34.99674654392208, 34.197196916264325, 34.299564116280095, 33.8574495771521, 32.571137515663246, 33.365909832812015, 36.081453221913144, 32.88568409106321, 32.509181695076535, 33.03006167471134, 33.86645389528101, 34.011491323830874, 33.07326548691532, 33.929288146430956, 33.97774407742513, 34.150210014951114], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8389410972595215, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "752777"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.61705812598088, "var": 0.4551800838404396, "samples": [33.11012399339189, 35.110604233125976, 33.9306950821688, 32.856635419677545, 33.05328582096894, 33.33112184179352, 34.18119833792416, 34.36533774822628, 34.01475220397245, 33.84380716498063, 33.53249208351142, 34.403984897597844, 32.62879118500286, 33.59664463029923, 34.47423924223976, 33.67794509602133, 32.94278676189055, 32.886273769520436, 32.6341097688304, 32.47557956210959, 33.02367109032859, 34.43877164694865, 33.945124030906776, 33.81730950412788, 33.923683896360885, 32.960082262744415, 33.505305516972754, 33.932403611649455, 33.745103625322365, 34.262286488318516, 32.12546851311135, 33.58915470128925, 33.42455950332987, 33.33958235621844, 33.167890224334755, 34.542603761507486, 33.66823095449961, 32.908755950071985, 34.644418704888345, 32.598614485740455, 34.42248150342329, 34.56455518792129, 33.70999091693013, 33.84990354522345, 33.12871097358683, 34.14007491593934, 33.187073662226005, 32.85854515835963, 33.81756476751782, 34.560575995990746], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8543546199798584, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "627683"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.567254792420854, "var": 0.5256506850153262, "samples": [34.970182221908786, 32.40347481017396, 33.17429586433235, 34.160860085202444, 34.77342313005104, 33.25078611306904, 35.29433447861011, 32.622918338841224, 33.816191947565585, 34.678089605001375, 33.478852761162344, 33.62549826616562, 33.563875750422156, 32.86185591046827, 33.20691486203087, 34.17493599001608, 33.20038747347337, 32.517022868957625, 33.24774621707599, 34.82134402570761, 33.38846940198188, 33.53631607358564, 33.98571054679208, 32.1054782129358, 32.842101600327254, 32.98907587694755, 33.248294614574014, 32.66905382303531, 34.55170760940758, 34.54011448142404, 33.52948820470125, 33.13207389778476, 34.21962590606012, 33.38923775839827, 33.47575049749512, 34.33123265223964, 33.95445953140182, 32.785516188838876, 33.848914170903456, 32.685653526843055, 32.71520943834704, 33.80008500639965, 33.04408428096309, 33.813653793642935, 33.492479614218794, 33.10429682037534, 33.37485968033986, 33.41919732973084, 34.2349809284331, 34.31262743267854], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.931413173675537, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "238738"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.4903385032653, "var": 0.6209361555166345, "samples": [32.88440240252123, 33.639864916791836, 34.15563615693332, 32.578781789772066, 33.27722097527134, 32.99444879111381, 33.718157535651024, 33.86575542402024, 34.50065528374536, 33.270626312895445, 34.48796765616667, 33.38128565998591, 33.904352637953295, 33.44520811435613, 34.27705998098502, 33.21718332759937, 32.706851685276774, 33.60307023239454, 33.380087301264595, 34.03891471949845, 34.09941170695947, 33.61253417800186, 33.01147008555143, 32.61408421212816, 33.84073954763031, 34.28725004471922, 33.63890739849588, 32.50161690811332, 36.162890638349644, 32.727838782290455, 33.02864709929239, 32.093334438278625, 34.67852791645031, 33.0967210790672, 33.253160465846165, 32.64518390176071, 33.30524741041038, 32.90639221750194, 34.28665062707791, 33.21481630716556, 33.94476223518734, 33.16534948241322, 33.46553403057934, 32.70024985331979, 32.9088654270545, 34.552054106806125, 33.56187018485239, 33.361815385352365, 31.61620293458553, 34.90726565382708], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8492863178253174, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "350746"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.55529587641454, "var": 0.49239001600486443, "samples": [34.24967208312462, 33.27125751613628, 32.975190049367534, 32.9247506284314, 34.03169784750294, 34.34424469890692, 34.02477935292638, 33.66149394474333, 34.85101772877839, 33.15320402730963, 32.6836766110346, 33.53097691737178, 33.67057497899004, 33.43763889527535, 32.80566118842448, 34.21776897468166, 33.23211280781036, 33.91451222074457, 33.59116468125896, 32.67540604270288, 34.07170635277559, 32.89781441130972, 33.1741268762607, 32.391944199708185, 33.73166039251123, 32.216623686009996, 33.06920110331069, 32.46554581185735, 33.68236617603353, 33.48397411461958, 34.76171149580834, 32.95094439722908, 33.21074938641039, 33.81696427884079, 33.133539407132076, 33.799350681058904, 31.852761546914103, 33.70116292963606, 34.197729530917236, 33.09555620344933, 34.54911029512086, 33.573669135657404, 34.28412895163296, 34.64252562179022, 34.50095825675592, 34.025848236058785, 34.08720539244819, 34.676896302767105, 32.85240024567548, 33.61981720550517], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.8320724964141846, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "41283"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.59334086050705, "var": 0.5010715176250702, "samples": [34.15245931302253, 32.399762844279486, 34.0023297696538, 33.903467605067924, 33.40231550508476, 33.48319747276659, 34.2702955593596, 33.3406919525341, 34.21361345990136, 32.80482891583555, 33.36132794074109, 32.82268884071029, 33.46174560593573, 33.539000114549026, 33.87358048001262, 32.07953915325458, 33.5069991392504, 33.91423520570457, 34.06509725506248, 33.62040964286414, 33.063456853028065, 32.51093488055607, 33.56675561842002, 33.032979050212305, 33.87680155878517, 34.70011752140696, 33.63592315724101, 33.28335651992, 34.591696564161055, 33.115538259204, 34.479622881253235, 34.9249288569706, 33.54237829387812, 33.5195531078349, 32.4554015149497, 33.16539443952575, 32.555852752695, 33.76558487526148, 34.82617656870009, 33.07116809180012, 33.232879991465055, 34.12611151306457, 34.38370970249499, 32.81686332963153, 34.422282944681506, 33.73298661794162, 34.23410555374824, 32.095085207437755, 34.56394869658408, 34.157862326908855], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.922485589981079, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "553162"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.496436391918486, "var": 0.6701372144689914, "samples": [32.67998784347059, 33.53971071982256, 34.16382925478222, 34.594750796577785, 35.03944701107837, 34.126023170649404, 33.449831641596845, 33.0352033977298, 31.95616895035617, 32.10196189989476, 33.91253249772648, 34.95197439207607, 32.08299706629394, 31.793290673248865, 32.67696492964877, 33.71133835169812, 33.15217912498953, 33.38364331421546, 35.01060120744875, 33.50311780093097, 32.885697787222306, 32.85656721872634, 33.460311765147885, 33.331973592066056, 32.88460039517202, 33.20557459203561, 33.964540623484716, 34.48048763508322, 34.71265615795255, 33.269873758260104, 33.85456279459059, 34.91749696627981, 33.504018469670875, 33.39647078316963, 32.73806478367378, 34.382672859986926, 34.008203534394816, 34.289554859967176, 33.83440206102258, 33.7571320655048, 32.54662830945153, 34.00700781705524, 32.9429527167862, 33.08129108723206, 32.902706186285435, 33.54276012564746, 32.162776237420914, 34.181822953319, 33.28171295143222, 33.57174446364697], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 1.9289278984069824, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "34011"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.7727221649748, "var": 1.7942556277491504, "samples": [35.33402279643118, 33.71793807813721, 32.1277143985408, 34.97029698992282, 35.27879746495327, 33.66468858775976, 35.34818682497564, 32.4890751044468, 36.51426504071781, 31.253902991941928, 33.8951268562676, 34.54928374353316, 35.5760552382906, 32.65112601707336, 34.10634343105847, 33.406986066775744, 34.52743543790896, 32.12223067735044, 31.735782802083758, 32.05085055606397, 34.070909918473134, 32.824021931333085, 34.36006015759265, 31.608384197744854, 33.40549080797429, 34.382773503635306, 35.68773630260601, 33.09313616016402, 34.80200618894978, 35.272046338604504, 32.65178148502853, 34.438179165068114, 33.480394321657265, 34.384800488828816, 32.662311443973906, 33.60551210505724, 34.1180793372165, 35.58171940444665, 31.205712275052466, 32.38716056018608, 35.53229286769463, 32.3706763107934, 33.0578279207814, 35.19386438005976, 31.584538556097147, 33.38944715031538, 35.107106321132115, 33.740350857661795, 34.41016145981191, 34.90751722656603], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.38911867141723633, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "463952"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.58717559383568, "var": 1.5898135345678996, "samples": [34.96082956401051, 33.36585253447601, 33.31568965308463, 33.04766112388209, 32.36884808351974, 32.76317858764791, 32.98333842022468, 30.650976304920178, 34.42284326251468, 32.89450535266985, 35.248558078541365, 34.26651771689805, 33.32611775446935, 34.61427216205169, 33.45239135990712, 33.2497195310889, 33.75776902605705, 33.45141436584059, 32.0692090110257, 35.22888244910261, 31.814657032777575, 32.61137012231029, 32.98279057169987, 35.0420497561693, 32.581845051963995, 33.79867074455597, 33.338015397940175, 30.678247199205774, 36.21799055885616, 33.2669845930908, 33.07568511071541, 31.86142680231529, 34.28171227728368, 34.12231034606205, 32.696202340092015, 34.1794239808318, 33.51238657861168, 34.08202212752481, 34.51092119325399, 35.8193350310126, 33.55149433854878, 35.67423519186867, 34.440612876852406, 35.554000733017034, 32.4572149503466, 33.29283691899908, 34.00595950165741, 31.067718938851346, 34.63457114275442, 34.76751394068254], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3544323444366455, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "672998"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.308984480806615, "var": 1.9756692614558393, "samples": [31.50625287072269, 33.831068244403596, 34.666735299127595, 34.60447087009486, 34.242637256904, 33.57728767786899, 33.2866829766173, 34.52419243392952, 34.75950865201475, 32.07765313924134, 32.19536909845392, 33.23941715528612, 31.980988766109544, 32.70161246980604, 33.358836748089615, 33.12841350484842, 33.65591421816165, 37.207904901986666, 31.39445463007979, 32.06565274942618, 36.038424489951694, 33.68356840435637, 32.877595192876186, 32.14009577333117, 33.26121968732896, 32.0258993808279, 34.347298355702044, 34.5635495689398, 34.53726983180683, 33.97722245492022, 32.83086916135814, 33.15427714808239, 30.667263947960084, 32.93244551692721, 32.93061878091293, 31.66620013357063, 34.18718753724478, 33.93189767149812, 30.984502374518804, 34.696933934796185, 33.17916753665155, 33.27759113081039, 32.0945973727911, 36.41281502561068, 32.58011238606039, 33.291337363372904, 33.295495299756865, 31.738320680534, 30.679023912834342, 35.461370321825555], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.43320584297180176, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "342475"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.72280313543682, "var": 1.5360466501894372, "samples": [36.32089595703875, 32.697017528568225, 32.6276038148359, 34.25007568077885, 32.19523705994042, 32.90387627766788, 35.401399956532735, 31.067035369067813, 33.562047134830564, 32.99155535811444, 32.5666143738234, 34.81179822975396, 33.115558749019, 33.595875056298624, 35.94759042922494, 33.301695706364036, 30.98868893376066, 35.70325685329132, 34.263886678559686, 33.5080722559155, 32.1282078280632, 36.337701732407865, 33.37099707288658, 33.05621721186498, 33.517595298865736, 34.56894077647146, 32.41539847182603, 34.13552206019627, 33.809452272443835, 33.90324151463082, 32.88036477080374, 34.08024401317041, 33.84492526370505, 31.471565801878285, 34.87633331547596, 33.841050017491995, 33.25090893332728, 34.16796714187218, 33.143415999613396, 34.04683166502025, 32.72907394638344, 32.88610797836974, 33.91470811498253, 35.557136429843474, 33.131364906402574, 34.83874172149472, 35.69686056443246, 34.71519784303637, 34.392674387386926, 33.611628314106724], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3630228042602539, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "812223"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.74901319838778, "var": 2.1948632447475913, "samples": [31.133753585639607, 33.72501251528526, 32.463062979460446, 34.26086317240436, 35.151801517065614, 31.467271777667058, 33.456120301172106, 32.3507327838629, 33.05888783637319, 33.787446783956014, 36.673329174996475, 34.26821333044437, 36.777076927452825, 34.85179758559063, 32.32431280350144, 33.35344969045757, 33.511296378280235, 32.64452521022589, 34.74161252236411, 35.707355608947545, 34.20568723243868, 34.82366457700607, 34.76227433706098, 38.10071711846023, 32.038387450289136, 34.13017810648315, 33.131845150616854, 32.59909595675929, 34.33381048052612, 32.35066641195097, 33.299084483746554, 35.49175821340107, 34.2934325093284, 33.325084729149935, 33.503275597053545, 35.71235183481093, 31.63540647371631, 32.79180603750147, 35.009475262291915, 31.358691620147372, 32.63131205605043, 33.73353538667965, 33.30812538394903, 35.18778469691991, 33.105988735764356, 34.13715366456946, 31.89657689559349, 32.15988674652373, 35.38053081139924, 33.305149474052975], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.38032054901123047, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "248183"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.57843504773698, "var": 1.108543064248547, "samples": [31.411453199979807, 33.551466828583116, 32.52434911205899, 34.375519186333236, 34.04460485156063, 32.21698949804934, 34.12960398233168, 31.64014075262206, 35.18525744177056, 33.09069982221833, 33.612238581178985, 33.145934029314304, 31.724173639643244, 33.165742440492686, 34.28229482969758, 32.83259441384441, 32.470161131551315, 33.340725145059224, 34.0098444977519, 32.506765126178955, 33.791036883710376, 33.92913028420908, 34.18951870458591, 34.01236466927233, 33.596319140127704, 34.98507287479849, 34.9838304458431, 33.03328129352931, 34.765136052783, 35.6834145527512, 34.02169594006624, 33.18674915664013, 33.895522483341054, 36.48887216309609, 32.440329602337314, 33.69564414285861, 32.62864889039082, 33.4928339492345, 32.671988437492075, 34.02640782510157, 34.861980843117294, 31.948223443743625, 34.02750322764004, 33.62833619083608, 34.045165621736466, 34.728596555101475, 33.869873373349705, 32.616976660518176, 32.45306519930899, 33.96367526910828], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3668482303619385, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "605234"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.92089369552127, "var": 1.7475685505340632, "samples": [33.9174139671875, 34.91381757857844, 34.491564682124064, 34.16917332887219, 33.389153594139486, 32.28413220917983, 35.054019466411866, 33.278679577101734, 34.1512014724258, 31.42705299608453, 33.7510617372921, 33.32737684390253, 33.79607855718207, 35.62590028264471, 35.752249019709886, 31.41220868782875, 35.268086254371624, 34.721013373393546, 32.04759029938552, 33.60598345529888, 33.857472056593615, 32.546810634488104, 34.183822224908525, 33.2219896941907, 34.37959236919967, 31.399603876141555, 34.38355848012237, 33.712338866508595, 33.801214784201996, 32.03415372604054, 34.7188702089092, 32.76611984326795, 34.47063985714281, 32.28832992903327, 34.07913490586936, 34.71385589135035, 36.454233045200425, 31.277008522993334, 34.02145386080893, 37.10590856276796, 32.46443683623844, 34.62841306605811, 35.1458398477993, 34.1980623501503, 34.570152558142524, 35.93821609600474, 35.11723980735366, 33.00918844917819, 34.101478700960726, 35.071788341323305], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3547837734222412, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "474001"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.68628045998189, "var": 1.723567127342747, "samples": [34.50672996935724, 33.25952565121392, 33.81695561865952, 32.09862189273283, 36.889995567636724, 32.1158822333643, 32.09682468067784, 33.909615451292126, 33.78058374669262, 33.271429058510996, 32.40895597552479, 31.99966771480806, 33.96174044519142, 34.46287639113891, 36.333042606813216, 31.674364009846986, 32.10232959967395, 32.57496807067336, 32.8400822260994, 31.71781811377987, 34.00885986932983, 30.467809608961335, 34.28314679031252, 32.077778581175636, 33.85373614369306, 34.91386504170071, 33.15246547988193, 35.522547038197054, 33.1630260026474, 34.45516463231946, 34.21291599961691, 34.326342573821954, 34.448164512358055, 33.6887514924381, 33.81261354401171, 35.42733630675662, 34.66809308167267, 35.4766353328158, 33.39961191564565, 34.11129594386799, 34.36181629891409, 35.03958473842799, 34.70358058916335, 34.83066415348996, 35.09816233441468, 34.58083646258244, 33.15124402773219, 32.66270969581242, 32.61241660904282, 31.980839174602302], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3831052780151367, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "412648"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.764258528713206, "var": 2.0165232674303133, "samples": [34.135683808203275, 34.466222637663755, 36.852362074810536, 32.122747422308635, 34.193564030560225, 34.72127270366074, 33.722575511423834, 31.541228103900394, 32.519793386668624, 31.903704625713807, 34.68530863084538, 32.179605867972576, 33.24871126525734, 37.21567423831528, 33.90851662793145, 34.52809777648474, 33.069256632320894, 34.108935903228875, 35.731672901566746, 33.587337667486025, 34.10157275971901, 35.04176955138793, 34.2446810886757, 34.354147733122055, 36.11896813262891, 33.63157885448258, 33.434797409651466, 34.874141570626875, 35.33872867214424, 33.99649103653934, 33.69429177063355, 31.582741326594103, 30.221917321920227, 33.53216579661579, 32.696540279574, 32.31497252811186, 34.19568095634057, 33.079220011385, 36.10469046645042, 33.180106152567376, 35.95699960652285, 33.18368952233814, 33.6647269063225, 32.0310272609664, 33.368486613778764, 32.51670000666059, 32.71542922112372, 32.90478972808812, 35.20191485775256, 32.48768747661254], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.35068297386169434, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "681087"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.516027100126294, "var": 2.723933457655218, "samples": [33.82175384415723, 33.47872119203797, 34.71248288656717, 36.0025022592289, 33.62817991929717, 34.69929451192753, 31.101750209907408, 33.82264440362884, 31.39965547573443, 32.187681376679265, 34.80951047383783, 36.979457809208455, 33.60104220180579, 32.97917756073736, 34.36759407479778, 32.70275794721619, 32.80298374315467, 34.182763345181385, 33.13202288584357, 29.13748055191348, 31.446210257958917, 31.33036620376691, 31.48474113614686, 34.320851869478105, 35.40577788306733, 34.527030807939745, 32.189146944578525, 33.021519922336836, 33.6557585198268, 35.59557736191205, 34.93474085409553, 31.01652716681386, 35.443872858072666, 31.736172249125595, 34.19357984661765, 31.984434539966365, 33.679261488862444, 34.806610673838925, 34.08896927387204, 35.357173164227746, 31.940905655613605, 35.12180750502648, 30.315703901663362, 33.981170501597525, 34.78892462217896, 32.9091479081771, 33.51816137880607, 35.61306092883159, 35.6816757558026, 32.163017153250365], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3836944103240967, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "927882"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.537213186402596, "var": 1.5941002157305426, "samples": [34.15613070805902, 33.27624619067277, 31.55399846789713, 33.42128861858953, 33.63042014836156, 33.45263016364741, 32.81178600525013, 33.6574812960428, 33.84710638555706, 33.44094712143458, 34.43292977155818, 32.71500400627716, 33.71237675788174, 33.075107728456935, 32.834978505051026, 32.853155980149474, 34.841149235776705, 31.218940438931014, 36.30827727061236, 32.5941180352154, 33.74033092895474, 33.83725451519983, 32.50252065961631, 33.41247824340585, 35.522827485241564, 35.8092567076371, 33.57078935666554, 33.51706732916631, 33.66719969387148, 32.80085567272213, 32.51787210305174, 31.780390224675497, 35.380462142759384, 33.4595369555235, 31.58261327726908, 34.386750189592476, 32.98117956799854, 36.96323457422993, 35.16673768267771, 34.00239143695463, 33.035930536475064, 34.314770179644036, 34.41478509003266, 32.61405597135987, 32.295945777628866, 31.935978376079902, 36.14663322419418, 33.08317251074765, 32.56724511244361, 32.016320958888606], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3777446746826172, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "395318"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.52279288653885, "var": 1.2820943198949486, "samples": [34.10907090945963, 33.287194431295816, 33.02768375011234, 32.00222919789968, 31.463416649846803, 32.917553530649315, 34.55105647304933, 34.781748597391434, 34.318495747932324, 33.293294364356036, 33.008428324234906, 34.72649389452173, 31.83943708114486, 33.21565598094882, 33.30078134880068, 34.746137010095296, 31.848315606726388, 31.836074534569896, 32.5067759972512, 34.97733737816741, 33.699714740997, 35.555769200913375, 33.6822944824793, 33.91313283687826, 33.49520909208026, 35.07086192009365, 34.209029077362565, 32.95840870281078, 33.40575839134664, 34.39912972389608, 37.218272525369564, 33.37217822554281, 32.83280003941233, 32.65922142460506, 33.546991249070054, 32.504069960771695, 33.57156501796293, 34.73836525224617, 32.13639909710103, 32.683762975629335, 31.78555623015855, 33.436258618790184, 33.57317769283398, 34.15284933423446, 32.05207197373665, 34.83536079896598, 33.812293236777656, 34.2199102050817, 32.842397571557754, 34.01965391978288], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.4001152515411377, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "682770"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.49036720291155, "var": 1.6774666895927435, "samples": [33.27512444462426, 33.23557658785014, 31.56127615097577, 36.06076539537813, 33.18538338078381, 32.24070560737515, 33.22129794440774, 34.04116403794601, 33.53798785876638, 30.685498114744554, 33.59463129320425, 33.33586635534996, 32.83014885915408, 31.892606240795022, 31.843471897634604, 34.49723634789999, 34.76233341224744, 36.530486631262924, 34.03473098172911, 33.52117162323122, 37.08959864226566, 35.8704015143077, 35.21602386896545, 32.230983967169216, 33.524119693326824, 34.02834974291973, 34.02343449262652, 32.46893077097404, 31.444714254444833, 33.216595151622066, 34.14732472990129, 33.98733359096256, 33.16744402536422, 34.49319657194179, 33.81206325915716, 31.949760541076383, 34.11121164512378, 33.173605433804696, 33.71183055513396, 33.64448793317053, 32.199144798417784, 31.575417700930572, 32.37160376027319, 33.80949852128147, 32.887222446485694, 32.9647908257991, 33.59601908796283, 34.90077015781971, 34.1140408609736, 32.900978436014334], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3623664379119873, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "820385"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.78145569018513, "var": 1.3472796720724007, "samples": [34.16536990737602, 33.01406730377975, 33.923359547365784, 31.77096321062423, 32.54379295142076, 34.145273024535264, 33.66527646271989, 32.943171979008774, 34.99350348497391, 33.62298782271904, 33.952269775255495, 33.16576160519235, 32.67904128908438, 33.007825322689165, 35.37426844011459, 34.929649581741536, 32.36974381755081, 34.023526002187204, 32.425838934169604, 33.16518842351637, 33.590297929194286, 34.388308521768245, 34.94731918564691, 33.15286855959283, 33.69611977780604, 37.094801820443884, 34.16502920797025, 34.368744391007866, 33.5289909690502, 32.930657887924376, 32.929624765750596, 33.28669952987612, 33.00480581359333, 35.392716479910895, 34.57861788685471, 33.82704660124947, 32.130744939701685, 34.13237760903532, 35.41587744562225, 32.59236187409581, 32.614295794209134, 32.4038379897498, 35.67363537176164, 33.845844839815435, 32.8119623759148, 33.788483855266925, 36.359074160138384, 32.48836640979751, 34.122664106145464, 35.92972952433759], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.35092616081237793, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "665133"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.802593107216424, "var": 1.7198265392970558, "samples": [34.58392075028781, 33.700670000634574, 32.641900200611516, 32.99128918195568, 32.64508592668166, 33.91343004491932, 33.745948415402864, 34.236225400674805, 33.964547725118344, 32.52567034291976, 33.33539566542156, 33.932442323519595, 31.98351630932371, 35.77043011090211, 35.427627138503944, 34.002248334531906, 32.2906026362771, 34.05841949265068, 35.52734623002603, 34.46426256539581, 35.36808213770108, 32.92939010387646, 32.68073205269401, 33.87180041425787, 37.40375779437969, 34.288944002213626, 36.38427322666991, 32.54328417306164, 34.003624688828296, 33.412099252368165, 33.19212928530796, 34.20420440537939, 33.148241658185626, 33.967785800964954, 35.64848492657607, 31.931742656201738, 33.478220818081304, 34.37895775317003, 33.04300536223228, 31.493234107762706, 32.66954845136284, 33.37981717232422, 32.812532055261904, 33.575805069758516, 35.01248105819087, 33.17935583848635, 36.263222544998115, 34.88294669180043, 30.63919231461147, 34.60178074835498], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.37224674224853516, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "69425"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.80128135751504, "var": 2.567537366807933, "samples": [33.51833982997409, 33.08138076224915, 34.296768217535444, 35.68315443309309, 31.265183197274858, 34.2405940843427, 33.044816225298284, 34.39242095743017, 32.63759691850712, 33.01375231460182, 36.28663528739473, 35.4461180940811, 33.98480273932494, 35.972572594142946, 34.36670471405614, 34.60632582196332, 32.41272179302291, 32.553543033288044, 34.879498970601766, 31.40490972196504, 34.34633998261838, 33.33659506464305, 34.99516784501223, 35.66034060404636, 34.35734353695788, 33.318288156115806, 34.9452775810458, 34.14708695153178, 36.1982775097861, 33.57024965074045, 36.46599084510377, 33.558534463070096, 36.021020681018605, 33.2897358484763, 30.31722651198445, 31.743139921042623, 33.8345455283525, 34.03373371755057, 32.46340263815985, 36.38753942706633, 33.9594886494069, 32.46757463793371, 36.91628699770605, 30.725212124566884, 30.85432454958779, 31.90989302303371, 34.485818759156594, 33.25308178000755, 32.930837105439025, 32.483874074443136], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3824925422668457, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "317633"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.54249397487927, "var": 2.2999561862705207, "samples": [34.02676949699419, 34.00529764715073, 33.58557949187851, 33.01085663639861, 34.084929893141336, 33.949754332487345, 34.28873210184872, 32.214243700333355, 34.70295418010389, 31.46166370238509, 30.911421069006643, 33.356285528963255, 32.4341414027167, 35.10130414122533, 34.38724186586981, 32.09364642535242, 33.83163117082284, 33.96373001716682, 33.49062434254159, 30.979020537569653, 36.16131902255701, 32.5808126090716, 34.067035791903336, 32.329830544808495, 31.1774031800322, 37.20488109006888, 32.92256241967586, 35.07394755803913, 34.57104236703871, 31.36619059631291, 31.79573127973488, 31.968752370932982, 34.23116660412009, 32.03991537043382, 32.734606860415695, 35.643212035624025, 34.94222030502622, 33.84135780023549, 33.64679692388942, 33.1775055872969, 31.785495702487797, 36.78154534735771, 34.84068439097308, 32.65100536037576, 36.136221487580876, 34.37933556981457, 32.6447169719571, 35.40858437644333, 33.278223680199034, 31.862767855600154], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3855128288269043, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "326496"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.77114452719308, "var": 1.4047319098454827, "samples": [33.06428255443076, 34.34212995220061, 32.743195262408996, 34.69383757707229, 34.489703852867464, 32.51312841035828, 31.77971109219227, 35.9358004865414, 33.64644449292757, 33.582411846447066, 33.843471916055236, 34.34681272586344, 32.44329887075427, 32.77821073428655, 33.08996003367077, 32.92512139524522, 34.02574106107879, 36.18638820758569, 33.70115802167766, 32.425229787734104, 32.642174257228284, 33.29794574343352, 32.62081072876294, 33.94864820613893, 34.84029262245696, 35.054665388029875, 34.958617850224506, 32.720047320849396, 31.998592233233218, 34.09431399500031, 35.770639215151576, 33.23755608167095, 32.13219319253214, 33.536757121123074, 33.98594138689307, 34.666919689540016, 33.41615465406449, 31.59395291394064, 35.18733036736646, 35.624846428674154, 35.21372642322969, 35.90157746080001, 35.32069323603353, 32.691394126929524, 33.09398140805379, 32.81319947329672, 34.04965406272148, 33.38647348904851, 33.17236926566148, 35.029719736166705], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.35080480575561523, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "88288"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.76627639942724, "var": 1.4325442540667213, "samples": [33.92408367855544, 32.838508652121774, 33.55731236961216, 33.35911545618998, 32.61257904066034, 33.6832270484643, 33.26988946877654, 33.22189695476223, 31.309082971922983, 34.04120842779099, 32.8407818160734, 34.30093503383188, 32.43083170034621, 35.32122717164623, 32.914449575407026, 30.59114849480441, 34.761066767784975, 34.89942002928822, 34.1927832512947, 34.77569891281067, 33.419787514894374, 33.92729518425608, 35.03713309944903, 34.93988891498116, 35.12701357943939, 33.4617723804274, 34.07359122978925, 34.67520729481001, 32.529796183935446, 32.8636598863807, 33.89108709509457, 34.04361753336442, 34.1030541202375, 35.05889859808505, 32.500697124719004, 32.88448847194715, 33.68904194580013, 34.25668867526929, 32.8429952337205, 34.811532495912246, 36.14245313862454, 32.50967840689924, 36.648645450895536, 32.733466344036835, 31.930213481134757, 33.14621009460316, 34.04367337301293, 36.0789598889704, 34.65930742470771, 33.43871898381964], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.4006776809692383, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "601472"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.71078004690421, "var": 1.5515691915791037, "samples": [32.575712334914414, 32.024006788249515, 32.058262381510126, 34.718655487229896, 35.092737111900846, 34.595272893109545, 36.13828017132656, 33.687292188303665, 34.656287789312174, 33.57544876263907, 32.05491286799523, 34.480886718489714, 34.783331551237076, 35.690884987664745, 33.75941688318118, 31.622891981042365, 36.60424492126004, 34.91249138266659, 33.20175557922809, 32.741595750890916, 32.2832016321172, 33.78570980080379, 35.44547520876306, 33.0104582396758, 34.04417599548336, 32.622498214608825, 33.30730843278236, 33.94251683830452, 33.308435415493676, 36.02833457840274, 35.155956477935625, 33.270150903007845, 33.29691626670996, 32.45382983963077, 34.68302880357718, 34.61669836821508, 34.51147247504238, 34.32668838426987, 31.367014647177708, 33.14012691880648, 32.30434642549084, 33.91327416452665, 33.93045022621949, 32.463191328907236, 32.12804889303048, 33.60407340327233, 34.37063844439385, 34.03278894556496, 33.124469416640764, 32.09335512420376], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3861086368560791, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "421371"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.87154472473932, "var": 1.8812924334634327, "samples": [32.74320774307014, 34.639771547436276, 36.5715707288876, 34.62768898466112, 34.460109195620475, 31.68596137766243, 31.89853743474024, 32.9522494084254, 32.089076714202136, 32.743191788936166, 32.884545808534575, 33.65369134156049, 34.48788927819237, 34.90457308981531, 33.24194503493581, 34.425450173606336, 35.253072159404205, 35.1214047614594, 34.391435624880025, 34.28786489761145, 34.07287535496751, 33.10167564623134, 33.50673091444608, 34.6213534762362, 32.5648627707135, 31.359613514331137, 34.65435105496767, 36.011248615157825, 34.58317269312029, 34.10840363808942, 35.40514047253695, 33.353408742752514, 35.71228510282747, 33.17438077014434, 32.9349547508636, 35.09916525500071, 34.863605919906846, 31.635043344251635, 35.9620321853328, 32.9025799936933, 31.848227223345337, 33.721030647063, 33.918921354021, 34.50214009859158, 29.99434925668067, 34.17818794549184, 34.857113014693184, 33.32189398226152, 35.95978300900265, 34.585468396602344], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.37938618659973145, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "903923"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.9120407047281, "var": 1.7133839720446362, "samples": [34.642546431078884, 36.059266982805234, 34.147642304050116, 35.38735262676819, 33.65848728186896, 33.978256164796576, 35.011636978464594, 33.0135625177664, 34.084708057863196, 32.1253224218857, 33.295698883012705, 36.461178586176175, 33.70344843989331, 34.73175482545322, 34.76332679898323, 31.49238035956797, 33.421746152043426, 35.442445497468114, 33.862331446741585, 32.74350192511075, 34.55560447445267, 34.32132971835313, 34.26978889875444, 34.41539443032588, 34.01852664730022, 31.853961291701584, 36.884295040485235, 34.27433406090333, 33.52813125858027, 34.83966272635384, 32.021499298132234, 32.94183681391876, 34.80474291328167, 32.07953862882428, 34.30384950227516, 35.15933813857772, 31.09693892434193, 35.443849502315764, 34.90819412691396, 33.744296783966035, 31.842886681529087, 32.530278147448215, 33.22214346595448, 31.51839308039763, 35.41814317324442, 34.760287018996685, 33.760190941817115, 33.03709919448941, 33.784509342012804, 34.23639632895856], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3649423122406006, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "366658"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.34974967228901, "var": 0.8312788274281208, "samples": [34.41425070879038, 33.63113290142143, 32.02981749625864, 32.75361009497702, 33.08919544964428, 32.73871238184742, 33.2241110878547, 31.92333044355566, 31.908707222762057, 34.057425427783826, 32.78753060041495, 33.58564727924255, 32.6309600612297, 32.89017774560783, 34.65202331253523, 33.6759166727082, 34.28476001080987, 35.17983682091952, 33.98363745874992, 34.31181422216113, 34.13244983600296, 32.563708098787224, 31.205661446642676, 32.90059497260811, 32.83726857387863, 33.50031047453732, 35.00331124007173, 33.80748930003207, 32.61850719146068, 32.615802866143234, 33.113711439605396, 33.05829678918982, 33.28899561194953, 34.24682823073047, 33.92781403787145, 35.16459201965598, 33.584899571620326, 32.79320070723869, 32.24386005214956, 33.987831952712334, 32.80663410263705, 34.51793868853757, 33.32706938577933, 33.44018465356039, 32.40657963849787, 33.848030984524776, 33.15918626371678, 32.7133587611776, 34.82511097789803, 32.09565834595862], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3835916519165039, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "349120"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.51967507982807, "var": 1.1819287497818762, "samples": [33.37326840838537, 33.98898481646584, 33.03800326394919, 31.80548725337568, 33.319879242874904, 33.6051160104293, 32.542141102989724, 32.84193398144841, 34.049546721394236, 34.48359453720254, 33.72415132992173, 33.39137263575291, 33.27158782875291, 32.388123192452966, 33.31577815330223, 35.968548808258475, 33.97153840801573, 32.47355477591338, 36.83446570975533, 33.52044164136999, 33.42205978947707, 30.744691700964726, 31.898209927995957, 32.51345019831181, 34.42283176370133, 35.37118532320974, 31.727214836948225, 34.11687322566774, 34.37311266694277, 33.171266530745356, 32.80248677745348, 32.405145653287796, 32.088343903899556, 34.02731184504842, 34.47347686334594, 33.485955319234186, 34.36276631587286, 33.75931789211115, 34.33642994854646, 33.57633041859656, 34.562708839562426, 35.05012426160242, 32.76047254210393, 32.8480311327347, 33.11687260986622, 33.60302912947453, 34.008502678021344, 34.377945355285306, 33.395882796498185, 33.27420592288223], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3757152557373047, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "1719"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.657651689910494, "var": 1.6666127511644686, "samples": [34.51666393577113, 32.7797939214984, 34.09860409583197, 35.39050305438583, 36.03472921820419, 33.595038457632306, 34.98714156251179, 34.39989951163431, 33.061854063651694, 33.28997740267049, 34.247421900877995, 34.609751495882946, 34.47253534346401, 33.07910132688599, 31.651499792165982, 34.90051003361838, 31.050170001018365, 34.60108523761458, 34.44506963136817, 33.24633433630516, 33.546106373995855, 32.771165059615804, 34.886526475378204, 31.890868099124706, 33.52836703780142, 31.262859533363375, 35.06289204633204, 34.68841501572952, 33.23338610629806, 32.66705221087141, 32.969509177344875, 33.33692438543024, 33.25685921060084, 30.56481166418447, 36.00768104450686, 32.09645475584895, 32.3663684118251, 32.88804912156644, 32.80422471691802, 33.33274803222108, 37.07848959009921, 34.3854865421057, 33.46824652379152, 35.05009169404933, 33.34682959943668, 33.44114091950878, 32.98485670901238, 33.470950282461004, 34.442843580109276, 33.594696252999995], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.35486388206481934, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "658315"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.807746941200826, "var": 1.3032378388669215, "samples": [31.829253508485433, 32.86000533124992, 33.9515382901241, 33.13606088412568, 31.88799535190255, 33.50807956216424, 34.69564838505335, 33.79010779549567, 34.11031405112524, 34.02277188292508, 32.04245614475411, 34.58519177663426, 35.14299205790045, 32.45467976653936, 32.822628253638136, 32.938773536324284, 33.329564246464365, 33.18836052709866, 35.399962880037364, 32.52222366190305, 33.80622805741222, 35.01276704286506, 33.89595155347013, 32.584134875604654, 33.274009830965504, 34.045840668574996, 32.8576102867047, 34.02445416301423, 35.51586812649577, 33.87395165086875, 35.768549919792186, 32.78285238804925, 34.81813940944942, 34.9678185819669, 34.10529522343236, 36.234766072309455, 33.090875391329526, 33.89796193140135, 34.32025969444148, 35.20344215866525, 33.62675098777471, 32.00421029280873, 34.479785277903886, 32.103448013675006, 32.136699322597316, 34.086119339451, 34.31235709954233, 34.550375133343145, 36.26524594801521, 34.52297072417151], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3600773811340332, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "961549"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.56026019296812, "var": 2.2202105693890277, "samples": [31.490198251826747, 31.666288117542067, 33.45262401551446, 36.373014536188734, 34.8167676641178, 33.269589423135585, 30.69836357797715, 35.05015087105478, 36.0187553980155, 34.98637365162176, 33.84959216896696, 36.620611106785894, 30.89438745825054, 33.91539827464305, 33.403288947679336, 32.47047411265816, 32.97926800603973, 33.91827712733162, 32.003757385027335, 33.945863315716736, 31.857082448294427, 34.27212122352195, 31.98669867755322, 33.34520015271086, 31.889089204376525, 32.19655306403394, 32.437340244510025, 35.03199186866207, 35.95128288445917, 34.37161536174704, 35.53444028821674, 33.312953677876784, 34.16432003960859, 31.747764803498878, 31.177536191468803, 35.40279862676022, 34.16020768322901, 33.970066403144656, 32.68428041799022, 32.84768525876305, 33.57378071345166, 35.41303095141521, 34.38088122511015, 33.60137730377374, 33.330573011918304, 33.535533448475995, 34.82797807157164, 31.53564837932332, 35.05696169654332, 32.59317291630299], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3884453773498535, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "513911"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.66930717233813, "var": 2.5586460827522615, "samples": [32.54774771975927, 34.52522366422098, 32.86094435611139, 33.47861439054771, 33.04525902675334, 32.611068354127895, 32.22849724796995, 35.651165812540945, 30.76581763242575, 36.70176559093254, 33.15056110811498, 32.97911386047732, 30.886574535330894, 31.654988316285564, 32.24612249552574, 33.26715215065836, 33.35592648758211, 34.19023406385814, 37.757259309141006, 35.4940307112467, 34.2112958299932, 32.45113324638309, 33.020767031325846, 31.513679264034238, 37.352721697665636, 32.72731944805192, 32.87828814558019, 33.58972262541807, 34.610208841250426, 34.66301077625154, 34.29415905835291, 37.122868175473336, 31.70181582464845, 34.20767253927161, 31.88502611878579, 33.638397725566065, 34.57781349196387, 34.235658613492184, 36.37964601323379, 32.09515428139237, 34.59568367339973, 33.41890446912359, 33.246419355740564, 34.39300493336998, 33.295315183518696, 33.48312449834582, 34.611174580319194, 32.10476104829107, 35.05377702660323, 32.70876826644957], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3669452667236328, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "185093"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.648825520055745, "var": 0.9984540150446853, "samples": [32.89994525008947, 33.39393798239476, 31.829048918432868, 34.70941300003371, 34.463206798489296, 33.98868150419709, 33.127071813983584, 33.7618475270251, 32.94387635627947, 34.45675213648896, 35.86813166740935, 33.25675700656266, 33.97741777560636, 35.583550989488565, 33.63808142861291, 32.37868669929372, 32.49095073768398, 32.92391429874199, 33.5209365601054, 33.217111522309956, 35.0764971938353, 35.153324956647964, 33.845452260601725, 33.258711497061654, 32.80329110679245, 32.282849484979415, 33.08452599441423, 33.811639863252665, 35.720999973935825, 34.31191525514976, 33.2547311461939, 34.6049839173194, 34.94381592736846, 32.9320878941944, 33.17075767499743, 34.10314764034538, 34.09000988465735, 33.65752718852973, 32.714825562497325, 32.438293446557154, 33.54472578806775, 32.37276948070976, 31.653417257148817, 33.2767967936913, 34.04219992280495, 34.17261076901162, 33.05224130072911, 33.818901239911085, 35.61905006278618, 33.19985554536579], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.36289072036743164, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "122371"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.54273753717495, "var": 1.827766145977019, "samples": [34.440830077267115, 32.91776670970813, 34.703799767624616, 35.215993923488455, 34.77847353850478, 34.70418332856262, 33.038426477190775, 33.48169466456888, 33.80385329901056, 32.56844490206774, 34.07200407911655, 34.89076052274074, 33.43410262578221, 36.92258205682369, 32.024834847541726, 35.011330455545924, 34.44472233356296, 32.251288371678214, 33.60412022793097, 33.12630143106971, 32.178511801914354, 32.07304333742707, 34.055823861676586, 30.72732288740109, 33.467362238939124, 34.42509025169703, 33.96050472690399, 33.55818193252208, 31.275239191654318, 35.624590738235796, 32.90226342410761, 35.30878030289656, 32.017078195736616, 31.798454754748935, 30.462635850833053, 32.62584716074306, 35.35710215242914, 34.0452654750112, 34.22191754908978, 34.08670097036934, 34.38022732084792, 34.32506795949, 32.213790353647084, 34.219613208173875, 34.45800422513053, 30.977547696658963, 33.96953671929714, 33.64002414148499, 33.21031838130958, 32.13551640858432], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3908352851867676, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "994588"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.75411881455122, "var": 2.0935866137394545, "samples": [34.55633273002052, 35.393899808481564, 32.94325868298115, 29.040981018368967, 35.79970023845862, 32.028140532556506, 34.95412028094569, 33.68297411908916, 33.399421803479214, 33.359243189256425, 33.14482550722562, 32.86003677139821, 37.32892817767848, 35.31085073533171, 33.64614045510003, 33.35722939489708, 35.34875607413723, 35.56217569517557, 33.76135914101887, 31.48075514726925, 35.37015346765603, 32.68096837779953, 34.83307403228687, 32.975761412718974, 36.36538662470773, 32.814366078016036, 33.4254460917714, 34.28463208577195, 34.1507184252688, 34.65472742974318, 31.854366390199193, 34.72909666982606, 32.67223693991179, 34.229285853916885, 33.406612846549145, 31.978565948151644, 34.580736259123576, 33.05847983106205, 32.52217093264408, 33.831377709940455, 33.13497307919958, 32.091403608565415, 33.25885239622636, 32.699958455483, 35.3415839563312, 34.03206047067207, 32.31217470591147, 35.81331309987372, 33.93555838068893, 33.70876966467374], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.41675758361816406, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "265310"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.48049093949235, "var": 1.7196703734546712, "samples": [33.71678656302169, 35.520480486390966, 32.80647859455226, 31.25719400848205, 33.66379238831997, 33.15270853840362, 32.886083640682116, 33.2459203823692, 31.638937485156994, 34.39982845225715, 34.223653991139564, 33.39110556188881, 33.75723585392055, 34.11482408187625, 33.34564520707781, 32.26801531114234, 31.46470983868924, 32.14216755823985, 33.23946283515744, 35.44584296304207, 33.49538204929651, 34.71645082156111, 33.09644631069579, 33.05792743250806, 33.64575631257246, 34.6575446506273, 36.38200237294689, 32.00479376758278, 35.28704327377944, 31.493275326264612, 33.11316643372711, 31.281286697006422, 33.97455984681149, 31.844917259388637, 32.39559803958825, 35.055359902564334, 34.55280241415844, 33.57281467725609, 36.32689576780185, 34.37186079171247, 34.738147709242305, 34.47931742741009, 32.72897008906665, 32.19893087703522, 35.8567613076175, 33.22748152966479, 32.194703832339606, 33.736935377505596, 32.903370243803224, 31.953170691272533], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.40926074981689453, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "858559"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.83809539427709, "var": 2.0693363079964797, "samples": [34.3719172643398, 34.554447183401734, 33.63814655047566, 33.29148864581157, 32.721782912013424, 35.41695574716015, 35.17880891945204, 35.06985364467985, 32.97109275921245, 34.581122111212935, 31.38838360536882, 30.948138244690853, 35.10814985261794, 32.65807061247399, 31.031043012094127, 32.03333351693198, 34.60132601877493, 34.897670175065095, 33.468175734192016, 35.12658427294754, 34.86608119996431, 32.35129677515697, 34.278340069516965, 32.727323953490796, 33.849499374532805, 34.83613018718306, 33.544098721945275, 33.59049991816048, 33.578914719001624, 34.764579870061624, 32.34243013751604, 35.57370467211039, 37.673852582939105, 34.98124142525589, 33.623952293028815, 32.92962144279789, 32.58677597460861, 36.50262093424685, 32.12408454741362, 33.29320236823521, 34.6489850451728, 32.399668852385936, 35.49108626812841, 34.981974556396786, 32.297666261259934, 33.19705068823779, 35.73650350605941, 31.822573449585676, 33.201017195544445, 35.05350194100022], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.37461328506469727, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "883019"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.88882752413143, "var": 1.5395286543988929, "samples": [33.738725388833856, 32.84774576494086, 33.43238835981814, 34.10029366882227, 31.940196133891302, 32.1398891017367, 31.4814149399935, 33.987452980375224, 32.01559054168903, 34.79833742065002, 33.64597333730266, 32.696861443964245, 33.93782469255036, 34.577584889695395, 36.1214522958244, 33.90928369957567, 34.02204856851168, 33.21603029038656, 33.71070580192164, 33.95461563422489, 36.87857917556336, 34.73103095717884, 34.928229648481036, 35.04785511189904, 32.624143107509994, 34.147484280584464, 34.88774487957068, 32.303241103596505, 32.35060444821028, 34.987988562840464, 33.2799450167851, 34.472139747564846, 36.27229693480908, 33.561476818235015, 33.750046918809545, 35.611397882533986, 34.358903642264984, 33.06432535520788, 34.98909883645744, 36.12786914421849, 32.70532427610803, 32.66464400151093, 34.77959094789687, 34.43855321239471, 31.951695390243966, 32.71991787199251, 34.18742146054785, 32.74071406894723, 34.8627929982656, 34.74190545163448], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.4347670078277588, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "755854"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.76199557660952, "var": 1.5935164223782174, "samples": [35.67649229878653, 33.32431479097443, 32.387425564614844, 35.961140433836384, 35.33518466721057, 33.61347950118815, 31.601498816167965, 32.85106944989297, 30.94699218159018, 35.46826752829836, 32.92113934674318, 35.28774052160525, 32.06206091134659, 34.95326339996632, 34.76652027545473, 33.389984865066005, 34.94127986600105, 33.311027496388995, 35.2548202316373, 34.308695663468356, 34.54314368498079, 34.480028262005106, 33.61342466577838, 32.87854436475476, 31.995616981476857, 34.07244328714243, 32.13905058998203, 32.602924952236876, 35.70532298698586, 33.03218306364169, 32.57671354624416, 33.62735581525044, 33.56845072359275, 33.66699623852876, 34.527457429065976, 32.815309231279905, 34.14836822919222, 33.58754887292852, 34.628716054743215, 34.863290083183465, 35.277523879253344, 31.368397047849342, 34.04633112401347, 32.90382079176435, 33.32605829178311, 35.36629642385454, 34.44535875228304, 31.84186143448718, 33.14737345996549, 34.94147075198996], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.37171196937561035, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "518046"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.88845549130231, "var": 1.033453640046524, "samples": [34.59919209795247, 33.836016881765396, 32.6375130679395, 34.252410830033696, 34.30695423029996, 33.110904435292014, 34.156103749741014, 34.02335753318121, 32.74411151948206, 34.285901247351966, 33.49340075567886, 34.05129364632549, 33.631865494117214, 34.25240992174104, 34.72019347614018, 35.177985605967436, 32.67171655707589, 33.891119693956995, 33.253306586962694, 33.29170508501874, 33.889624722154934, 33.269598855905286, 32.10282515432591, 36.767076126508705, 34.20029955288872, 33.68104006569284, 34.661983234473425, 32.89803996751844, 35.165749153216254, 34.65903512818138, 35.410740498096374, 34.75635331411731, 32.52150423247703, 33.88891124629825, 33.52647193102088, 33.19857393407839, 32.938930342995945, 33.33552670070309, 36.14711123664348, 32.91100608716359, 34.68551912839027, 34.46801987669215, 33.95430485101931, 34.17436883915661, 33.432400234049325, 34.83150098270423, 35.426473619197374, 33.05408526419799, 31.56375954325585, 32.514478325968525], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3836088180541992, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "755515"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.68455176683547, "var": 1.9711541067211207, "samples": [33.92946522689391, 35.14339022502193, 32.20398972889892, 33.914526920695224, 31.107063140878445, 32.25584894741376, 34.41326718774733, 34.75277945067473, 33.852715635427835, 33.69659141650643, 34.69662291663189, 33.85970511951506, 36.25872664252539, 34.142656052270176, 35.46701421961832, 32.81908193296562, 33.754760482416835, 30.087286159270484, 32.74545475236659, 36.64367447894932, 34.021523205763536, 33.0931472135217, 32.839594755923834, 33.489041842205054, 32.71814977627728, 31.168214125384686, 35.28144230900777, 34.4534798870545, 30.66606953641265, 34.934507003351115, 33.53847096662307, 32.21015382218181, 34.9603783976181, 32.42091413969207, 34.7684960603877, 35.71860091085075, 34.3677724241219, 33.166091449277175, 33.198893911517786, 32.25143511541451, 35.580902362832056, 33.72518425636581, 32.30100385313957, 33.648768309592505, 35.4162918391197, 34.09461056743045, 33.58916068640551, 32.86809807356555, 33.05733663216017, 34.93523427188675], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.4001777172088623, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "428541"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.7279070621918, "var": 2.018950572308275, "samples": [35.18149304411557, 34.3284335189815, 33.08896403332105, 33.13161780632533, 32.9503703012228, 33.01082241831525, 32.6166418644092, 33.57665764090055, 33.97775869983938, 32.96046661874149, 31.562730523219457, 35.40055898083202, 36.675948069882764, 34.65366052034664, 34.68055749110472, 32.5104746450753, 35.690811887926635, 33.67712040391832, 33.9770613072524, 33.43584141290543, 34.34997575840823, 32.781450068573996, 33.657974470053446, 32.9711127043281, 35.49616608586474, 34.148940667188505, 34.208722288773316, 35.426484296416646, 32.383995910011876, 32.16282349204856, 33.76187470926235, 31.320488955712346, 33.630818593870366, 33.54709848015633, 34.29314749246381, 31.93467562456361, 38.14930963558272, 31.499166756063893, 30.1508433105425, 34.084786378815544, 34.795666769464546, 32.93532896606933, 33.35305630034891, 33.817041721120304, 34.452600789718524, 35.25436301598034, 34.44643732457253, 34.2792158792242, 31.73102148531218, 34.28277399044231], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3503096103668213, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "372291"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.42873099401617, "var": 2.1579018903999048, "samples": [30.488539007773912, 33.543380329358705, 34.52587842183075, 35.83868195532973, 32.31748805309848, 33.5453825439729, 32.32381785091275, 34.16778288897233, 33.812783766511636, 33.10991882970253, 32.83417052906313, 33.470140871839824, 33.14182456532504, 36.54504464871767, 31.905034489086283, 33.34155722605606, 35.49497550744892, 35.58849844203415, 32.711567325949694, 34.33496600172781, 31.079199040199725, 33.62281194493458, 33.7766205262197, 32.913639628050454, 32.551377122197756, 33.47502890490843, 35.350605819071724, 31.687028823220547, 31.99465037813292, 33.473258572835306, 33.15577220449585, 35.48311051042809, 35.994934924236695, 33.53530974702838, 30.436317391792144, 32.110201300063025, 34.06593336031836, 33.92094241508244, 34.83932031335968, 34.240419711130095, 33.75818229479442, 35.22236766008943, 31.675983979168926, 31.321045684193507, 32.72338058448061, 34.36922494201851, 31.30782985882055, 31.862057251923684, 35.49531789447407, 32.95324365842668], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.38254427909851074, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "558872"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.57661668317234, "var": 2.213781471972614, "samples": [31.99113714949094, 34.515252623945685, 32.73292758665114, 31.39948353287304, 30.864020372104655, 34.41851618430979, 34.39147416458773, 35.2129990938009, 32.876899812971956, 31.32220567623799, 33.84449205070024, 33.93626232145041, 33.025596011113855, 33.36505892970131, 34.3560525695282, 34.73945905518913, 30.530670474909538, 33.76319897551886, 31.800849955590053, 35.159967646562215, 33.04716097913015, 35.40267325264011, 32.682199473510465, 35.614884972949326, 35.82635947778884, 33.61409562274831, 31.71850978062357, 33.60078938599102, 36.53766048245645, 30.819147950372184, 34.72590541553033, 33.03949112691593, 35.10284774822742, 34.11320874981559, 32.71317143470218, 36.42208842945434, 32.04141559286897, 32.84891703581817, 33.607808302027195, 33.900727338896445, 32.35767988495012, 33.993957411735316, 33.37979389131252, 35.76628935006637, 33.80671576086259, 35.41467547766593, 32.313530612047764, 34.652074135274, 31.85518733454021, 33.665343560457515], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.38862156867980957, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "28924"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.875533753444714, "var": 1.7354618442798588, "samples": [33.5646492367465, 33.64273835602333, 32.707303357544575, 32.47313532530944, 34.450315086083144, 34.06887573508341, 32.418528811926265, 33.64954590210075, 33.4032999706577, 33.061512861027346, 32.70762713835318, 36.4947539912195, 35.11220808049104, 35.93058785637175, 33.854189478107195, 36.194051019372644, 33.958040212724164, 34.48747126731039, 33.13793787907261, 32.718311737683244, 34.163565119677564, 32.08427778209189, 33.41018613258495, 31.674658862962325, 32.45970481079896, 31.992321618645995, 32.960798575816796, 31.271790089245574, 33.47902431877138, 36.0364352071106, 35.37145494471923, 33.08766730345362, 35.91112609791878, 34.026709087517794, 35.010222102598306, 35.01000814724462, 34.733077096733616, 35.39922484602572, 32.04804091039481, 34.00491911603116, 33.670571692444646, 35.79164175159578, 34.015148698281294, 34.75364412831455, 32.99167455366815, 35.70536229203958, 34.36767085342935, 31.99969368454886, 35.050012942398745, 33.26097160196296], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.4006211757659912, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "965110"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.405843810412925, "var": 1.5485557481246985, "samples": [31.151533610665687, 32.993058230175464, 34.11923406629841, 31.903605281001074, 33.026664874178756, 34.380549730932174, 32.90025462179878, 33.47797212625113, 33.006697305868805, 33.60460630865352, 32.78108089524002, 33.61355538531209, 33.59399517640006, 31.263770736259968, 33.06728351309127, 33.0512274092629, 32.759637745411155, 34.3304901343004, 34.635335207811195, 33.65934801444935, 31.981455483052518, 33.99641261565482, 32.49292849443438, 32.810580944442954, 33.77227569121637, 35.382484572558965, 34.7293529224091, 32.282453917600314, 34.441991415623676, 31.505985665190796, 33.77511936945757, 36.61776574943623, 32.534184225228834, 35.50672225186236, 34.04256260108896, 31.83349253186351, 34.14491818759164, 34.04603397215154, 31.89357762834758, 33.10301250492614, 31.8484071812434, 36.261095431965096, 31.916732902299596, 33.64655417564662, 34.08345725763921, 33.08970467794758, 35.5466241390143, 34.61001718888285, 32.35355096733749, 32.722835481169625], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3539743423461914, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "369527"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.69182949946705, "var": 1.7151339390034426, "samples": [33.62686664056958, 33.16624486526872, 31.023135015921504, 35.45886878478302, 33.174876257260905, 32.73492139581012, 31.23469721968486, 36.152056491497326, 34.352423869764344, 32.86037957884574, 31.729461574970777, 34.81021554054102, 32.49574800928856, 32.53258852997226, 33.33332193674416, 32.03291522553835, 36.22762438411424, 35.59371981527614, 33.84988190122856, 34.756793914592045, 33.516991792508506, 32.23802642912147, 33.65220969228276, 32.26331155101384, 34.128546645966765, 35.08966865788354, 35.813968121386786, 32.944055167178725, 34.772997216528964, 33.435066332767605, 35.00390227185027, 33.65764710264439, 32.32240215625382, 32.75781095086655, 33.26276121157858, 33.52450703359761, 32.87723124987104, 33.640016103663484, 34.81765064037471, 33.19549412609983, 34.17588717487209, 32.55405748541467, 34.78758638847176, 32.95933763419682, 35.820625532007874, 36.51500296695553, 34.220852234783045, 32.53119240563547, 33.78233957918049, 33.183588166723176], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.36946702003479004, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "762546"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.520942225624076, "var": 1.6796564096424345, "samples": [33.03163853679215, 35.228664273038696, 36.25017582805262, 33.566975393357254, 32.226167146480655, 36.87219179825942, 35.57490009409415, 33.2693468312378, 33.06180137692939, 35.88162504876309, 33.688678726715615, 32.02498961867181, 34.02695592696989, 33.253550499055194, 31.25009130898993, 32.99078334659892, 33.83759589094403, 31.54427965923677, 33.77980542855838, 32.673187399458264, 33.07773118135521, 34.39046558703029, 32.83003259690321, 34.56582777027341, 31.05652274226331, 31.75198028332911, 32.58127709363358, 33.20779600827022, 32.73746637957029, 34.786883191338475, 31.942373638586066, 34.63353446426841, 34.05756499240563, 34.63916530290906, 34.000295559232576, 32.35167648905473, 34.26486096096151, 34.147723586569434, 34.90833080940292, 33.91971607226231, 32.503356418751096, 31.72551100912224, 33.14002078657295, 34.41131257638167, 34.338331831147656, 34.437218650311884, 31.960581872621564, 32.88442563231521, 32.51530217768032, 34.24642148447541], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.38231348991394043, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "514184"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.79344926576748, "var": 1.7809985516937703, "samples": [32.38908212766608, 33.902302490849, 32.11469267120876, 34.17521382183354, 35.343488979561265, 33.3545348622687, 34.99147841029564, 31.749616761156435, 35.116123962967166, 33.05541949319135, 32.449876797824686, 36.17198341424177, 35.34026448002052, 33.43256199199983, 33.04561306181532, 33.44806926716997, 35.26359122857081, 32.379195042076745, 34.82095538269466, 33.97138374255539, 33.79957078839115, 37.04099951289367, 32.41384845872638, 34.56946920906301, 35.21953125963242, 34.111447775488294, 33.016756319826634, 35.892741193155366, 34.62400121151438, 33.68936964989946, 34.34547672383968, 34.83940282277857, 33.0634339952822, 32.267278758140044, 32.720798204635614, 33.30814475209515, 32.98376613404079, 31.345262398690803, 33.15886606364991, 32.61833937020324, 32.72714623113858, 33.93236871644498, 34.99482386067238, 32.96101963132887, 33.131521991288004, 33.413556425036354, 32.84963113933512, 31.761535267232667, 35.60512670585546, 36.75178072812695], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.35413646697998047, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "44473"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.7415290365861, "var": 2.3378944424821184, "samples": [32.95639569595219, 35.820311494396186, 33.57731170718195, 32.981442269237476, 32.94017244949267, 35.11778261971508, 33.71989606308797, 34.58606003365822, 32.16443975071592, 32.640037531044435, 30.403268403799636, 32.95982722404851, 30.051598511635994, 33.88539780596889, 35.282270370306385, 31.86320116085354, 33.00627649467428, 34.1789532526148, 33.78990164916467, 34.06873964155455, 35.07164488846231, 33.89126445777741, 35.58232063813606, 35.154424909602135, 31.859383032129568, 34.533515722141544, 36.305664607930424, 35.00097201755046, 32.33368999814469, 32.35227743781894, 32.98415376447281, 36.071357969540394, 34.43229423354829, 32.906705477224286, 31.565998146032648, 33.77163094883141, 32.11068497856214, 34.11325404889318, 31.868657726101965, 34.600318928211095, 36.704235257166914, 33.0640431012373, 36.39092596368593, 34.101483779911305, 31.37530454494109, 34.10606603621375, 33.989594240351934, 35.49546523066043, 34.14035012216538, 35.205485492755884], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3496549129486084, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "773821"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.265027487542575, "var": 1.280766339815837, "samples": [34.38477229951641, 34.38845413227182, 32.21713112862132, 35.409079831854754, 33.14169832728297, 33.37607316832332, 32.233226418959816, 32.10353041639536, 31.772419950996564, 32.04776272916731, 33.26508754035722, 34.907781896376356, 34.38500157555785, 34.92801523265638, 33.82848264173627, 31.88918783080907, 32.15079581482514, 31.944513610827475, 33.206649321217526, 33.42996813967898, 32.712115507443684, 32.95184177992764, 33.61803961738083, 32.89813994084846, 32.958046571639564, 33.31065672405608, 32.72605687081144, 35.083114475138885, 32.202148276110535, 33.25727949254645, 35.37037090010339, 33.79320683022304, 32.69978707549701, 33.56285692191215, 32.60317977141701, 34.557315081398436, 34.176014247004176, 32.09597060519781, 33.27401734307009, 35.483551684195135, 32.32767152353157, 34.578262318774264, 32.843058799893356, 30.861320865509523, 33.63969598114298, 33.33720551517574, 34.58186193626882, 33.37762758591858, 30.923082024380378, 32.438246103179615], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.34996724128723145, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "980858"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.92369405643627, "var": 1.307926098383648, "samples": [35.27100255178196, 33.67766069703236, 36.1488811359591, 34.70089231469639, 32.042815395536756, 33.18636978658375, 34.28657033369724, 34.94206712240971, 32.494456361038964, 31.192872890024404, 35.198907024350056, 34.603220294647954, 35.45285951711279, 35.18991143511833, 32.88394899050344, 34.99364287683122, 33.745629428435876, 34.25737340075183, 34.33755357914925, 32.7504143242225, 33.219988285318244, 33.49554323322047, 36.028527935959126, 33.46577982758681, 35.03953701791429, 32.00258658421858, 32.70388581707844, 34.1387808678037, 33.80147570354334, 32.39612212931205, 33.162747644701405, 33.3779079462103, 34.467734613374354, 33.65240394019391, 36.208316540137574, 35.170581502141154, 33.74963691270372, 32.54641310351003, 33.47519225623487, 32.57180710334561, 34.664429600571026, 32.78288646689557, 34.55843843783243, 33.21974900527162, 33.79098802191459, 33.10106149179097, 35.02290644251903, 34.66865325212689, 34.68057430960655, 33.66299736889316], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.4161102771759033, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "339680"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.40414438786779, "var": 1.3216674300509463, "samples": [31.061787296864416, 30.63155048178257, 33.71748582196645, 34.62043661530973, 34.13736223644394, 33.979650408828874, 33.17419022184913, 32.54892072480821, 33.67359022684432, 33.96764191372136, 33.20972697768032, 33.457857817171124, 34.372698157130635, 35.222536479214945, 33.75992630142831, 31.438555501947157, 32.243805608914215, 33.51741408723475, 32.71738006221542, 31.301693963314808, 32.20312896419346, 34.783543150292495, 34.47068216980883, 34.695614043850846, 34.53084553578362, 33.93208324688011, 32.24017676109692, 33.78846391733405, 34.17886697775422, 35.06795137504105, 33.791802551667175, 33.54847622438561, 33.51674505735972, 34.035864981644885, 31.973676191777944, 32.688054682846776, 31.850965058154642, 34.04922517227268, 31.167300912067784, 32.32360227834985, 36.048215463880126, 33.976793944263406, 33.779892636409336, 34.08158875470809, 33.37349008988677, 33.60569937918971, 33.48065625124726, 32.71135346354402, 33.751706418535456, 33.80654283449198], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.3754234313964844, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "657391"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.58855416057472, "var": 2.3540725943515235, "samples": [33.05267251933337, 38.008078097200226, 34.17209918749355, 33.87737789393886, 32.31688105785699, 30.720659817359795, 35.02445513382502, 36.270915242396434, 35.49808090196117, 33.2421903584797, 32.98881442935712, 33.793171160346745, 33.07122822951706, 31.355010585254753, 31.389917584427828, 34.80878049846679, 34.81136210291737, 33.03685317947146, 34.91215511050744, 35.68950022231304, 31.294193189321593, 32.80947854545708, 31.964282012348985, 31.76180654079753, 35.4659214217207, 32.13577971264996, 33.10609172449395, 32.95549241529572, 33.96222822741884, 32.04609460211256, 33.76584394581781, 32.1427123862451, 35.29279685937957, 33.39524630836186, 32.429137589390585, 32.217365059219595, 31.30098454573959, 34.641368150871656, 34.92681093212501, 33.008419884946264, 34.78797067299024, 35.72365980443797, 32.527395778730636, 34.53294603469462, 33.36184911236381, 34.96901703525225, 35.31235417235427, 34.0486022832132, 33.166199675743286, 32.33545609281728], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 0.4241197109222412, "qoi": {"__class__": "", "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "None", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "767437"}, "erd_samples_per_period": "1", "shared_surrogate_base_samples": "False", "device": "cpu", "no_grad": "True", "seed": "None"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}] \ No newline at end of file diff --git a/tests/qoi/results/gp_bruteforce/26_04_12-15_08_49__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_no_gp.png b/tests/qoi/results/gp_bruteforce/26_04_12-15_08_49__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_no_gp.png new file mode 100644 index 00000000..73688471 Binary files /dev/null and b/tests/qoi/results/gp_bruteforce/26_04_12-15_08_49__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_no_gp.png differ diff --git a/tests/qoi/results/marginal_cdf_extrapolation/26_04_12-15_13_14__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/ground_truth.png b/tests/qoi/results/marginal_cdf_extrapolation/26_04_12-15_13_14__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/ground_truth.png new file mode 100644 index 00000000..1fe7a743 Binary files /dev/null and b/tests/qoi/results/marginal_cdf_extrapolation/26_04_12-15_13_14__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/ground_truth.png differ diff --git a/tests/qoi/results/marginal_cdf_extrapolation/26_04_12-15_13_14__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_gp_deterministic.png b/tests/qoi/results/marginal_cdf_extrapolation/26_04_12-15_13_14__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_gp_deterministic.png new file mode 100644 index 00000000..698f07b3 Binary files /dev/null and b/tests/qoi/results/marginal_cdf_extrapolation/26_04_12-15_13_14__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_gp_deterministic.png differ diff --git a/tests/qoi/results/marginal_cdf_extrapolation/26_04_12-15_13_14__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_gp_high_uncertainty.png b/tests/qoi/results/marginal_cdf_extrapolation/26_04_12-15_13_14__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_gp_high_uncertainty.png new file mode 100644 index 00000000..914689e7 Binary files /dev/null and b/tests/qoi/results/marginal_cdf_extrapolation/26_04_12-15_13_14__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_gp_high_uncertainty.png differ diff --git a/tests/qoi/results/marginal_cdf_extrapolation/26_04_12-15_13_14__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_gp_low_uncertainty.png b/tests/qoi/results/marginal_cdf_extrapolation/26_04_12-15_13_14__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_gp_low_uncertainty.png new file mode 100644 index 00000000..e3b8141c Binary files /dev/null and b/tests/qoi/results/marginal_cdf_extrapolation/26_04_12-15_13_14__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_gp_low_uncertainty.png differ diff --git a/tests/qoi/results/marginal_cdf_extrapolation/26_04_12-15_13_14__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_job_results.json b/tests/qoi/results/marginal_cdf_extrapolation/26_04_12-15_13_14__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_job_results.json new file mode 100644 index 00000000..f63d9898 --- /dev/null +++ b/tests/qoi/results/marginal_cdf_extrapolation/26_04_12-15_13_14__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_job_results.json @@ -0,0 +1 @@ +[{"mean": 33.529885323786196, "var": 0.4625617830768072, "samples": [32.90804111975019, 34.06765636677017, 33.80896935145505, 32.334746756190555, 33.823158120907905, 33.18089942825212, 34.01645965413769, 33.025104689825284, 34.75183903702536, 33.78465791233695, 33.26473061479624, 33.512771731944916, 32.97626647878835, 33.10058500080583, 34.68965055259755, 32.22184431680105, 33.2404027975295, 33.047596159232086, 33.281572791974035, 33.48585047942335, 32.289737301547476, 33.42198486730296, 33.70243472473144, 34.94941321860627, 33.15735018599735, 33.207513888796335, 34.9500166518022, 33.110820990339164, 33.8620104439527, 33.31640565307585, 34.328199735136074, 32.5466057979264, 33.35070365135851, 33.18652899431108, 32.688726398146336, 34.4112909955863, 33.021236699840415, 34.1186203513083, 33.78770595154306, 33.10113609081357, 32.419854197018324, 33.756075579948, 33.107713075472226, 33.8793028693287, 34.509914183486046, 34.34564901878406, 34.223517129296674, 33.631353073254274, 34.026703915657706, 33.56293719439783], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.72662659070493, "var": 0.4393062357677631, "samples": [33.561583841385236, 34.45093641863972, 33.517648881044266, 33.92755096740474, 33.78093338862703, 33.90059738869072, 33.82447545185697, 32.808580353603084, 33.78027851126851, 32.42156281396081, 33.1552847252965, 33.957999656531484, 33.06574710425011, 33.884926048906976, 32.7756924024322, 33.90914301407223, 33.92146748001962, 33.788990945035444, 33.53844666046615, 33.741339485776, 34.32194870826534, 33.36550858844861, 32.956072561955224, 33.364505302079394, 33.880287343046255, 34.8189081776441, 33.19141982083217, 33.95338645426761, 33.69070646447474, 33.19368217111075, 33.625007127874326, 32.24016850922032, 34.88401315709876, 34.189260695576046, 35.33297771723887, 33.04109229818594, 33.540184381790624, 32.63428004428515, 34.293238498523394, 33.83208099270761, 32.856361260965606, 34.834952182337815, 33.828953737480326, 34.00383931249426, 34.80152640854015, 34.70829079708009, 33.55877997102675, 33.28165528233514, 34.46795531652848, 33.927100712564965], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.40836601242138, "var": 0.6264375300915633, "samples": [34.93725808693539, 34.096580668093615, 34.27685323385734, 33.75720117627274, 33.267602695779644, 33.052582487650916, 33.41353793975435, 33.556492418359326, 32.727825512383355, 34.194328394760376, 32.704574983617086, 33.94009707698951, 32.04269454240184, 33.02099706275934, 32.83761188973951, 34.35100409734191, 33.53341420213093, 33.42908236455635, 33.50047815076807, 32.99688071229927, 34.29004783425214, 34.03171692432693, 32.64540202721696, 33.55214854208882, 34.5292029024345, 33.49110976459929, 32.282797535711076, 33.218848343372926, 32.70653854424619, 34.04553377192045, 32.92021072770026, 33.2481871518896, 35.80544395158806, 34.05179274752312, 33.49483479029762, 33.39593028778075, 31.620374518020494, 32.977443692254845, 32.58269160976064, 32.28079008986564, 33.88902075082885, 33.660724351610035, 32.256122522828214, 32.544045871890596, 34.16687778410922, 32.982681016218734, 33.46773188052802, 34.095744937430865, 33.951420674363675, 32.5957873779596], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.87384216998687, "var": 0.6230981001345648, "samples": [34.51662113238701, 35.189300379974625, 32.94162172338302, 33.82325259023276, 34.78565947242501, 33.16905585516085, 34.904985616210844, 34.91654273668901, 33.52307564740855, 35.15174053006995, 35.3782182817058, 34.488768090013195, 34.46581987172889, 33.91820527555574, 33.64154812244367, 34.673475580038144, 34.166524073613274, 32.412949211578024, 33.467025152207235, 33.56572107416177, 32.370933048780465, 33.83722728766289, 33.6254472599916, 33.55038279274628, 33.85194910997001, 35.223336656669225, 33.38871336376952, 33.72949869389352, 33.65430721394593, 32.753235348340574, 33.286413166889865, 33.25401608697844, 35.34117257893537, 33.194024158410066, 33.36873241311894, 34.064684308766445, 34.147170351220474, 32.63954466589989, 33.41495788696537, 33.209319508992394, 33.49311989357314, 33.81714208150923, 34.561376544850376, 32.84964818264653, 34.61188448300471, 33.24393959153947, 33.68691663651291, 34.77732400230232, 34.512814103962704, 33.132766660507755], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.66720982838922, "var": 0.713040545981996, "samples": [33.3899552946455, 34.19409776416207, 34.48887223620915, 33.446901267667876, 32.45985829641576, 35.115469177474836, 34.095044287359784, 33.935675162875526, 32.98938189376346, 32.99777618954784, 33.99994570747794, 33.24317533629261, 34.094915652858795, 33.83093704365637, 35.56125289697894, 32.308166267395144, 34.3714400627827, 34.606588428155085, 34.66318535043726, 33.992198852354655, 32.65609954492068, 32.65295706887959, 32.74066771337108, 32.87428760560566, 33.92323822304308, 33.70960757080974, 32.98328256305639, 34.30093823671543, 33.84999476010302, 32.779040364312046, 33.34989212362356, 34.09459487651408, 31.607547907633027, 33.34532373879435, 34.33617706011651, 32.96524128111723, 34.49468251928748, 34.57647776696889, 35.16167564564681, 33.187405595648286, 33.78709463548217, 32.505399118185174, 34.0786224190932, 34.11332540102127, 32.01293491537007, 33.08298661675182, 33.86190808031091, 34.07490137951169, 33.89407041682819, 34.575279102228144], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.655835467523325, "var": 0.32701318645334415, "samples": [33.102636519719546, 34.172477000482125, 33.706071679029826, 32.96515207924412, 33.602421733569805, 34.19717652356496, 34.487311984443544, 33.34662308256509, 34.00580576099461, 33.23189214915789, 34.4090309761107, 33.78709463548217, 33.00644718132641, 33.38872300684262, 33.71630255788125, 33.307298002572246, 32.855763043204874, 34.12396610050217, 33.379730592935296, 34.94751825795672, 33.712392442726205, 33.82100898112958, 32.940083031384596, 33.30363782308822, 32.3277235963302, 33.77216505245937, 34.65641082057254, 34.10477269295394, 33.91921413971869, 33.83036554918018, 33.59877420100954, 34.228849468578225, 33.99522961696222, 34.195501849530864, 33.55823072728833, 33.909847084994375, 34.73859294482324, 33.9756068343287, 32.684548565137334, 33.97033837325344, 32.610103836511655, 33.8214499452426, 33.52243392003395, 34.13466248724607, 33.39749195940241, 33.132865839254386, 33.85899326628438, 32.7764395111953, 33.49425382197302, 33.06034212598654], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.61758115757071, "var": 0.48488479885604546, "samples": [33.2716219067438, 34.19108027471154, 32.83179484758633, 33.39924415883347, 34.12852235150808, 33.36106141729484, 33.6108067316615, 34.18123720799242, 34.656194910166256, 33.189340787905294, 33.17609215219144, 34.50104078406163, 34.63110143781583, 32.32354818942994, 32.891686407685945, 33.4435244268553, 32.90292686586317, 32.92551635358604, 33.391804505864485, 34.518853271451604, 33.692021402021126, 32.991958731469374, 33.92708438105714, 32.35792117276668, 33.795040638601094, 33.26261735000159, 33.1447853429733, 34.89042702242674, 33.88818622719167, 33.871017088670726, 33.14914523935298, 33.34945810384954, 32.889642608930124, 33.34971625205659, 32.85138767435635, 33.50014839164002, 34.78565947242501, 33.36401650547504, 34.537205274525725, 32.33178706249556, 34.13534722934003, 34.058396065864606, 34.80532071421087, 32.71322390984975, 34.439582254131835, 33.88115521455834, 33.46148500946937, 33.25009100955526, 34.77224910265841, 33.90598243740175], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.55382244624456, "var": 0.412875916135604, "samples": [33.48598909573938, 33.65545012613906, 33.840079640749764, 34.50627350218871, 34.178623486499696, 34.28825902750348, 33.59457115267446, 34.37283400005096, 32.96916321302186, 34.2234438050313, 34.29841123793548, 33.11545814187633, 34.30144073995509, 32.86679474220564, 32.83624438582851, 33.74745812943467, 32.67923230442419, 33.371684669042125, 33.19407392426263, 33.886686255880484, 32.52806653132103, 33.60760278864922, 31.516448760226112, 33.6371758852154, 33.95840072456405, 33.662552371878284, 34.02047050010395, 33.04680180374864, 33.94494490481581, 32.2391517615177, 32.65840938561089, 33.756700657613344, 33.55524552009187, 33.31927083958147, 33.007410777529394, 34.43756183451512, 33.70036746343505, 34.00509690461262, 33.77454103812772, 33.41392291515548, 33.05163589563561, 33.6123997678423, 33.92592322990153, 33.294922975025386, 33.33009538493421, 33.61699301931348, 34.95824740411176, 32.86453111850373, 34.251845996317165, 33.582212571885904], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.64425035139445, "var": 0.5769758390901211, "samples": [34.04120588482073, 33.09759743378846, 34.009343964952095, 33.774591208792486, 33.2666076694787, 34.551892165750374, 33.169098612430965, 34.827398018968005, 33.50460289153917, 35.55633925945569, 32.86611630056539, 33.59387929608774, 33.41339571768503, 32.893429652343144, 33.996851552635334, 32.484723282474135, 32.85440574301899, 32.91342813870494, 34.60546364644181, 33.13518345302824, 33.263751097816325, 34.024147361049955, 33.87884295778454, 33.00734980989039, 33.56624481616431, 34.1303506414112, 34.637176463540484, 34.85684215742759, 33.55725851098607, 33.681947448149245, 33.101703508726956, 33.798843973913634, 31.673931436224226, 34.10477530826745, 33.26546983645127, 33.1880716326274, 33.88997824492662, 34.54266196453016, 33.056348091465985, 35.029286457125316, 33.192383964214216, 34.250476343658384, 33.27435135896706, 34.17051457876823, 33.73933164723275, 33.01682565851468, 32.53479973824425, 33.89386510533295, 34.7434690179749, 32.58596454537414], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.8056848089485, "var": 0.6789919765424562, "samples": [32.78397706805213, 34.76819795512055, 34.443247280388526, 33.22410677934372, 33.46291293981338, 31.91598798594069, 33.411023145282854, 33.482566379196406, 33.06900959621205, 32.54446546121987, 33.31451731221066, 33.98797688954331, 34.22138001381449, 32.912152609957104, 33.65456823838248, 32.947452942099304, 34.374446721003935, 33.95523823088022, 34.10258962850172, 33.474455328147386, 34.383694015912766, 33.07169719279147, 34.646713066660254, 34.922133603224054, 33.956276236220056, 34.28851884061501, 33.443634237392814, 35.538578419780755, 33.67857086319274, 34.94528447757783, 33.08207127771304, 34.24752611067461, 33.01809220229081, 33.5774523227996, 34.249846170493626, 33.582108812586974, 35.39691737309221, 35.51100127658334, 34.633577252512616, 33.65434679194454, 32.36765020599092, 32.09709179001654, 34.30640745644125, 34.02361257298236, 33.13497081162328, 34.23802763716233, 33.65272655894627, 33.89325247902569, 34.160059525529476, 34.532128360536696], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.64991239672619, "var": 0.5338484538620675, "samples": [34.48931744814976, 33.49007215280346, 33.08264770687604, 33.56063080343502, 34.44758808768574, 34.09707781488006, 34.26967846308952, 33.57772706991725, 33.314678842335795, 33.09054633811129, 32.13671200475433, 33.87138763047935, 34.20349767421658, 33.21852288437675, 33.28959960511134, 34.27864632336326, 33.97456481132626, 34.75249902825755, 33.30401172215082, 33.81624685022956, 34.2285773794066, 33.99280288035509, 33.5960355000823, 33.7867099907891, 32.89941828310962, 33.56951728202098, 32.588061876172645, 33.43791496338639, 34.276687971990036, 34.20153331493556, 33.171509229166276, 33.78050255980129, 33.91247926907648, 32.26794098857012, 33.350228521289566, 34.043614277973035, 31.890995690443138, 35.072181226447135, 33.63580677157985, 33.277300818257416, 33.23900404536048, 33.24675970779837, 34.97303841222914, 33.35443439742007, 34.73667030651013, 33.188642389113085, 33.98322306565634, 32.725276511097114, 32.611489806403554, 35.19160913831878], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.60708279899619, "var": 0.592260176628364, "samples": [34.08529635913746, 33.71830981492185, 33.01197605250608, 32.83071727987675, 33.30040112906347, 32.72188117722432, 33.98560710443051, 33.07468532803205, 33.9162209760566, 33.62680857650695, 33.273285149619184, 32.94819674138916, 32.61643041557241, 33.4932685401494, 33.4155596234613, 32.93564271753472, 31.63498130124765, 33.14525807285929, 35.06963872158923, 33.662570035888756, 34.743690424417046, 33.55766819530431, 35.461695439485986, 34.50975659925394, 34.06456673475953, 32.93003362232576, 33.908057392693244, 32.76580427114487, 33.89431941361051, 33.12381825670752, 32.876766526407515, 33.52782266816483, 34.97211576114155, 34.56884957234171, 34.09707781488006, 34.09791910152206, 33.168989840679274, 34.3749392304137, 33.033202270546006, 32.95889559270715, 33.95504337774955, 33.90268445271468, 34.335375849873714, 32.226645002624366, 34.193221404109515, 33.66232488502265, 34.46508599115624, 33.53418253172174, 34.41550166240297, 32.56135094686039], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.426331870773545, "var": 0.6618134268182246, "samples": [33.17228685616385, 32.26440833089259, 33.17315756247848, 33.360536971711475, 33.9705667862598, 32.89509918170205, 33.41728626246415, 33.63128900499418, 34.72600153702829, 32.97150176482329, 34.02692480898407, 35.23781713623095, 35.319112414901305, 32.39460146145422, 33.71597834275525, 32.48037829220259, 33.49072805067765, 32.987444464012185, 34.73841822666639, 32.65091954191933, 32.81682900671587, 32.71587057673777, 34.81305865736772, 34.290465893520604, 33.164238793924056, 32.81237495944782, 34.398033733977215, 34.646022579526715, 33.413956292285754, 33.433024934296824, 32.05953975888684, 33.49460671767215, 32.82054809062781, 33.61632802450971, 32.514389333804225, 32.765241134409706, 33.13233996379001, 32.395950602780815, 32.895542165401096, 33.769130391691874, 33.429009280398034, 33.47317893480974, 33.21424751824665, 32.89531014436615, 34.33638795208793, 32.31772291924567, 34.36758058025874, 32.864051547115, 33.18459142905104, 34.64256462340161], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.72907619076901, "var": 0.514059395001577, "samples": [33.41495788696537, 33.85906461148284, 32.7301420485365, 33.06051722232794, 33.81124343779677, 33.5516207088379, 33.619648003662114, 33.62047382047271, 34.792815088289515, 32.72653014894907, 35.158657344292514, 32.900296258052535, 33.03385329104074, 32.93214385011682, 33.561473205717185, 34.31996704625222, 33.91039348622056, 34.44983341574316, 34.39781259420895, 34.35110115867521, 34.62177280334832, 34.45466184029123, 32.567472403362935, 34.35955560760147, 32.55560312141682, 33.59332480239119, 33.8078401816215, 34.25286165044165, 34.35671058345559, 34.217181812829196, 34.270968954597706, 33.19828346969169, 34.65540529392411, 33.50802253744967, 33.73887563251854, 33.62984767261149, 33.40865032743377, 33.268070876444035, 34.747003999643134, 33.1344511532692, 32.80716870436615, 32.5419007376972, 34.24580240691313, 33.50625182488552, 35.356143569909094, 33.41184083463883, 34.610883179026956, 32.8857587902755, 33.21340015319595, 33.32554998555812], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.402959570372744, "var": 0.44553912584158983, "samples": [32.93206998632999, 33.77350151116448, 32.410357124344166, 33.03624051912221, 34.151114168667505, 33.62789169659874, 33.261439725765136, 34.32389161891125, 33.62640874948451, 33.34164245052523, 33.85257310586831, 33.048614571417126, 33.43937422188819, 32.66627961563046, 32.94396682731984, 32.63138144179586, 32.76494821880319, 32.8027776593046, 34.63552690326094, 33.18588421519219, 33.613832002139624, 33.48491706462139, 34.097090996927115, 33.09581261825837, 34.09810617171264, 32.21807623489525, 32.61008447124417, 33.41677062749329, 34.34398472502909, 34.85503396161221, 33.67650423614288, 34.006271435668204, 33.52750230645614, 33.45103639066555, 35.02440269281214, 34.74246051259029, 32.706988270717495, 33.423096655991344, 32.39850400412989, 33.54861315218072, 33.73265833391066, 32.70802394330161, 33.207263856921415, 33.044510970468295, 33.49735384953771, 32.63316539952694, 33.702641751148796, 32.91074518763265, 32.6505918277759, 33.26605053573148], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.65894874299275, "var": 0.6516313967182419, "samples": [33.767516981833026, 33.23470655315062, 33.70285323757122, 32.9281249993738, 32.62737823097703, 34.036897783006005, 32.02673468926619, 33.98195163724544, 33.956767062277436, 34.98505131329372, 32.798997540083576, 33.55821406366591, 34.51736521924833, 33.34477066159745, 31.75437751329045, 34.85703999256829, 33.408909771430736, 33.68911289887336, 33.58360903636828, 33.59407085095861, 33.07715403329335, 33.174871790136585, 34.214597069898105, 32.71930186163948, 33.84218330608365, 33.050173854409834, 32.96155256722206, 34.67903650154213, 33.73167056572393, 34.57264768564519, 33.80154498031159, 33.74001861500244, 33.55819481907606, 32.70984550940746, 33.71022369710144, 36.203139792997995, 33.77460409589963, 33.806997513713746, 33.85699907715268, 32.2144582521522, 33.45803759829586, 33.74221545495922, 34.727038099903325, 34.11485702836619, 33.86006609177365, 33.88481916729052, 35.00893106412601, 34.33174546310676, 33.0628416831579, 33.003219874169105], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.75820063104539, "var": 0.5712038412281714, "samples": [34.422701192016866, 35.667790391096815, 33.24821598111069, 34.625724834781586, 32.948105555511596, 34.084362201151194, 33.604874120898984, 33.771896203035766, 34.559732889220726, 33.32251038296623, 33.706426554511594, 33.66137827886023, 33.119863219065785, 34.3405401047007, 32.479741123180055, 34.03751775421165, 33.46917859787596, 34.26166071126538, 35.239371226031, 33.105379496300635, 33.30499361040047, 33.39408763265672, 34.51209694489708, 32.99525254340669, 34.52867203146614, 34.04667133586152, 32.11253283462736, 34.194267050811284, 34.43252254499562, 33.52113342218, 34.8663179536691, 32.47869977712846, 34.14071645016371, 33.627895326843145, 34.130773690681515, 34.12720499088573, 34.62709584937894, 33.2412390584257, 33.67365788261914, 33.52169475477835, 34.23260991535061, 34.9145177922019, 32.78947300585146, 33.799600116877954, 33.044960122094494, 33.629738242320954, 33.64871852379168, 33.53007285275203, 32.473011401271116, 32.692833076087126], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.70899601818122, "var": 0.7278903075045092, "samples": [34.344328500966554, 34.556054710309866, 32.53854904231401, 33.74414172623889, 34.69363985705455, 33.367981622758265, 32.630788735417525, 34.71262682513001, 32.906951259849585, 33.928857694549116, 32.08780767512808, 34.123706085389976, 34.63013596218529, 34.50491827621487, 33.73834994119937, 33.36524225000458, 32.34091097531222, 34.00002947331529, 33.51228857864863, 33.36806979716116, 34.17423716165556, 34.00936951566542, 33.32958806740261, 33.98960560576699, 33.56257143826587, 32.973650242658735, 35.56579873078753, 33.183083970783564, 33.77927356691864, 34.55845708095931, 32.247288278139436, 32.443849401253196, 35.4946353175711, 33.03751998271342, 33.263684126108195, 34.80969290961471, 32.38795432188353, 32.85456127182043, 33.24386077741542, 33.92888724862685, 33.31167548716016, 34.248705869108434, 33.195191272378665, 34.263721952854524, 34.836247812093546, 33.52038582091333, 33.76154379166843, 34.70252034869528, 34.909722973524836, 32.76713757550548], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.73991126830157, "var": 0.3774902693806619, "samples": [33.03369306819398, 33.92550668516975, 33.68911289887336, 32.933060971576204, 33.572067444077994, 34.83610628538371, 34.696874781066576, 33.28360665339314, 34.38541593561452, 33.814851897536926, 33.6384712132346, 34.239908663215004, 34.71834573800914, 33.76001304619347, 34.293825456301356, 33.05004628726989, 33.65784861066351, 33.28051265698136, 35.48645295588501, 33.66352585793118, 34.501996995112236, 34.92145879581853, 34.36839619406179, 33.57854833010354, 33.286413166889865, 32.46568403501953, 33.19072263469549, 33.37099953654717, 33.792344131017934, 34.04151376371791, 32.83162660784167, 33.34512646709393, 33.63606992194161, 33.43260051736879, 34.09388002723359, 33.20598537697342, 33.841175219042746, 33.55506659437039, 32.84136563521234, 34.12685040254571, 34.15974296859803, 34.17457358137479, 33.33459198307362, 32.97765612822639, 33.87975112524006, 33.74753155602546, 33.35109157682823, 34.25850945731273, 33.652107129999436, 33.07293644922089], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.64872178392869, "var": 0.7205844942610319, "samples": [33.057259067379654, 33.16193104255844, 33.04706284365288, 33.212731000762126, 33.927312528495946, 34.24922447252143, 33.41680813174121, 33.21821029026694, 34.69136705127113, 32.962027773253304, 33.122290531877425, 32.97423186765618, 33.43780244031888, 35.40112696994423, 32.76154759998021, 33.99145222354437, 33.152644247510196, 33.50852820250508, 33.62488540638193, 33.793389905443746, 32.58473595449511, 36.024197443654806, 33.50721940739764, 33.56572107416177, 34.04382793276385, 32.736560800247375, 32.883123389968816, 33.85652511311981, 35.509386720758805, 33.44659004640947, 33.19125592460036, 35.468957311645575, 33.97418914518236, 34.249231652862704, 34.0028067438348, 32.899751450770076, 34.0014027073128, 33.757095185780585, 33.83087738344615, 33.056348091465985, 36.07939777253445, 33.21426731490008, 34.19952590381459, 32.33979090777094, 33.183956067315016, 33.78097920297241, 33.09352358048496, 32.776842926417636, 33.321317174509346, 33.144851268770864], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.633662682002154, "var": 0.7785455452841367, "samples": [33.07681410445048, 33.24246575707874, 33.799082136988176, 33.22065347652684, 32.85195091587792, 33.312823916985586, 34.557306187063006, 34.41630979193814, 33.701339817113514, 31.431662346956738, 33.01604138405645, 35.9656103854918, 33.62945424066268, 33.70651717515122, 32.37658123341503, 33.653629079359305, 34.507920104891966, 32.45503792172694, 35.62118980587868, 33.601303529369154, 33.895957047084174, 32.99264374636497, 33.52575563216074, 34.00180204445749, 34.80367772804276, 34.48369823735438, 32.20533896092494, 33.97092042592342, 34.37914320737868, 33.464578602474546, 33.76353502205896, 33.932047955623176, 34.19642101257729, 34.25892047703644, 33.91351193452914, 32.935865911660045, 33.91652619250514, 35.16714596787336, 34.46422006965257, 33.50368998992634, 33.681229186624876, 32.76829449252044, 33.601303529369154, 34.49769551423642, 32.78618828220849, 32.49298942777408, 33.62287793615151, 33.3774211658296, 33.04659305107988, 31.88944803772205], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.592595166413645, "var": 0.4222578486124048, "samples": [33.53551188449713, 33.28864767747556, 34.03602846091751, 32.97626647878835, 33.72804953608805, 32.9787420305905, 34.39046211993355, 33.37948626014944, 32.31868303818266, 33.0059731602575, 34.06133817871761, 33.51278040601031, 34.67033965650306, 33.731018710706145, 33.855768849329, 33.52654821923554, 33.06176130135625, 33.35699549812499, 33.09609390298785, 33.83220160057838, 32.661224727172026, 34.181558875521254, 33.044490402105644, 32.71147523088948, 32.63803693911551, 34.57159978886135, 33.06347465035228, 34.16509745384893, 34.68499841177846, 33.24948828629093, 34.524226249048866, 34.318432140177094, 33.580904078992795, 33.22869574220568, 33.16154604367868, 33.2988590734526, 34.01328496203529, 33.37284774465193, 34.418660185168484, 34.403147877011406, 35.165171860927764, 32.85725499212787, 33.44780655623845, 33.48716761660227, 33.13076037653222, 33.470120312676904, 34.569911297539335, 33.74880545411759, 32.51769461270817, 33.60031940842359], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.51099472052955, "var": 0.5458976030073028, "samples": [33.30438738866815, 33.76293959785908, 33.00732717293585, 34.69182349109969, 34.50077141204756, 32.23877783478998, 33.614716788560976, 32.83845591269524, 33.19415460908318, 33.639429971081604, 33.16662796960163, 33.857815546641426, 33.78037025984828, 35.14001843786488, 33.77563799317588, 32.83221086781116, 32.93261903570474, 32.87459904292191, 32.81040905749458, 34.021559720487694, 34.855182188314245, 34.402101136358276, 32.593707012138026, 34.076278469121014, 33.30485182093578, 32.93619401192013, 33.11545814187633, 34.22753624398753, 33.4449100353125, 34.14030976372459, 32.72959493664798, 33.95657145778489, 34.316930756432704, 33.47247604841495, 33.494848686100575, 33.49475443854016, 32.17599372386519, 31.993274738423583, 35.18886273021212, 33.948110860549704, 33.31303920754173, 32.711949115684845, 34.001764127629826, 33.27006151098399, 32.43989565978358, 34.31712000841487, 33.30268112987405, 33.55010639337402, 33.731852567577334, 33.05866699457954], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.832644293551574, "var": 0.5756205478461336, "samples": [35.764124561982015, 34.06830845070375, 34.557163671352214, 34.81328421189865, 33.903828505814104, 33.92741135875253, 33.905438326318304, 33.31815780768056, 34.36773623823955, 33.46841134613614, 33.72288865198, 33.90024774905248, 33.62163845671614, 34.17752429308882, 35.32119995274476, 34.10011062205447, 34.25954139515674, 33.74812959625886, 34.30941581065815, 33.76373331621397, 34.450376293702384, 34.238550709244635, 33.00142189239558, 33.559892014155444, 33.51843223275292, 33.6327147684732, 34.020526815772634, 32.94745353759125, 32.48004979353567, 33.62640874948451, 32.21150508130389, 35.83322242292127, 35.026747598551296, 33.43739086831586, 33.645886523841526, 33.270195719897714, 33.49761763844116, 33.80187365645389, 32.73596248011439, 33.707404922510044, 32.87313313779886, 33.979813832542135, 33.44956323413796, 33.99614701596949, 33.2822407091235, 33.60680321347795, 32.952272248449226, 32.76702704886362, 35.21961751077816, 33.84366868417637], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.66924787156686, "var": 0.5099324935185848, "samples": [33.11531145776308, 34.231185331411375, 34.638705835710674, 33.56987551681216, 34.47196356856648, 32.78935830896527, 33.593701109764325, 33.72949869389352, 34.11621178118979, 33.66934986548587, 34.125117617355066, 34.02447364297274, 34.88284246055502, 33.56386482233547, 34.514299922030055, 34.30718138125538, 34.32037843090282, 35.168902638386655, 34.96025593647625, 32.39962242269809, 33.44686505681639, 32.58310953441961, 32.99691829929406, 33.30741333952309, 33.38572109242884, 33.02568608502145, 34.61861317532174, 34.127097082465575, 33.52627900920865, 33.65332834916099, 32.866092308553014, 32.48024954453017, 33.71369326335273, 33.02207486486622, 33.45000527752592, 33.15714143137899, 34.670290401250064, 32.635417970803736, 34.58363635272783, 32.752121569874504, 32.988232474688445, 32.83179484758633, 32.85605786845676, 33.82239318782324, 33.5466494231456, 33.51539688972214, 33.501471149341064, 34.60560859192903, 34.01483020499201, 33.586104187604704], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.506921264616516, "var": 0.5903183192982426, "samples": [33.115866849983355, 32.84991409431825, 33.460636968869956, 33.49072805067765, 33.04483797707297, 34.025373148825764, 34.02627391244039, 35.33413787411771, 33.42727140978382, 32.00792090470557, 33.71127386611782, 33.118047623895684, 35.20537785530144, 33.88436210139334, 33.72303129043727, 35.00632764512448, 33.71374085453989, 33.55942558844481, 34.25647388851799, 34.442679386567534, 33.08033001080724, 33.5130476828911, 33.86116869382343, 33.00974570251709, 33.68878179153316, 34.582956966434125, 33.66284770625348, 33.555137792719414, 33.465920246550574, 32.87807173190657, 34.84550479533053, 32.78801596057144, 31.641150782028557, 32.26794098857012, 34.037166884528546, 32.38141964991176, 33.53513238112554, 33.16656573079262, 33.03703452522191, 33.719509875346276, 33.311003947687354, 33.95813066355463, 32.16238465282032, 33.4489057901318, 33.071039505892244, 33.823812462857916, 33.85296007102867, 32.47650864258109, 33.70321080488213, 33.41695549939058], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.75157070740225, "var": 0.5346309944717134, "samples": [33.0002702635304, 34.117232491515125, 32.71014664567525, 34.85346797261885, 34.001418671872756, 32.91249621899217, 34.734567875345896, 33.96199712557625, 35.52700697314556, 34.086485043714255, 34.50554872277719, 33.367461849863595, 33.55330188794391, 33.64222566164121, 33.67437404380781, 35.15182800376614, 33.834533281678695, 33.449079310117696, 34.11823273842967, 32.69328750926001, 33.53951981805773, 33.87627218811535, 34.47005626535932, 34.045481479636834, 34.090189301413396, 33.28864767747556, 33.756477933202774, 34.396961368140424, 33.31535988417025, 33.25966596477534, 34.08354988806702, 35.567489397653915, 33.8395021044778, 33.78429281536991, 34.7508753876412, 32.242671336004896, 33.0249400712447, 33.02241531639356, 32.85133269154467, 33.21768125258289, 33.29315576165976, 34.22486349583811, 33.37423236046922, 32.97910111365982, 33.76695908252956, 34.10371690686458, 33.14565658843723, 33.331631254810446, 32.67305916695884, 34.367815206284995], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.65409919798038, "var": 0.3585990995405117, "samples": [33.46335043470831, 33.295657991703195, 34.48175187905737, 33.52103895789617, 33.64898330838417, 33.07468512528819, 33.36181522751366, 34.5554558648345, 34.41334863312319, 34.13896764207851, 34.6777282837008, 35.053620759683504, 33.57372523777148, 34.11656510481451, 33.49769102352457, 33.62845100403237, 33.502014000935354, 34.469598819586885, 33.068345449693304, 33.70036746343505, 34.06008420006306, 33.60031940842359, 32.516757913986936, 33.0142274682542, 33.914114905663766, 33.192710729184164, 33.66600672433917, 34.203813213409425, 33.31362093554111, 34.01328496203529, 33.45803759829586, 33.26132613614273, 34.15363484099827, 33.614929273600175, 32.9609775324797, 33.00980074304291, 35.26276850506333, 33.78669886647016, 32.548759764964714, 33.19959109003861, 33.74839598843208, 34.19255390516079, 33.109254248686455, 33.65550896309325, 32.76564216885802, 32.988232474688445, 33.469712037064824, 33.08243482551854, 33.98402512360201, 33.71457314015233], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.66755265589291, "var": 0.4940139004202806, "samples": [33.84139945979645, 34.4926803362763, 35.23777893056613, 34.21077200920909, 33.061757905931984, 33.605699414384254, 32.48470009208343, 33.575514656770714, 33.73587472764497, 33.70471044792011, 33.210182325452706, 32.983068328404705, 33.375208662296444, 33.62495498489912, 34.51723735544227, 33.96488425119293, 32.32744052551811, 34.75580007724004, 33.914446660117086, 33.9456348397361, 33.8570116122633, 34.07610065644438, 34.1615903924245, 34.48896893104315, 33.67714891268678, 34.52715065622917, 32.944671587009836, 33.7867099907891, 33.58360903636828, 32.78523357802682, 32.52443566500017, 34.73133295521947, 33.06949491720684, 34.706533493027564, 33.87279165977681, 32.30219483081692, 33.28051265698136, 34.08715441438484, 33.13792560324983, 33.09643915893996, 33.74366909943019, 33.3419560890153, 32.84136563521234, 34.82674286309768, 32.99549947160568, 33.84989379582415, 34.38068072530023, 32.75432255935432, 34.13162337981024, 33.24512247722346], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.599827053372294, "var": 0.7691845274405651, "samples": [34.03907210058834, 32.705279318098874, 32.2283851063801, 34.307862916327785, 32.637498502661664, 34.41658854893886, 34.727068631679394, 32.94446392801518, 33.03544549343632, 32.77894944066316, 34.34299384633456, 32.98968763394407, 33.05523215130759, 31.63460029414465, 33.8408201512504, 34.19360390687237, 33.33339784634001, 33.87556312246703, 32.48115060603768, 35.14588273098704, 33.7836625078831, 34.45746096743158, 33.27161451132932, 33.199786052422354, 34.67640989839188, 33.47839013360187, 34.0631695268297, 33.29719357645043, 33.62142872321357, 35.505379431085366, 34.5274055186817, 34.59149805862858, 34.1508616720949, 33.170152542409575, 33.54081750162998, 34.155311027521584, 33.86477083059099, 33.66006354699344, 32.42372555926504, 33.70288610814024, 33.34971625205659, 31.805428534158676, 32.58742060064108, 33.762917091993735, 32.730758245938645, 35.01093928624819, 32.819528270634244, 34.382063226046505, 34.85983995323924, 32.82720723658715], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.56950503592862, "var": 0.5041081090178591, "samples": [33.366758132553024, 32.81259317918067, 33.56350803551895, 32.47859600513267, 33.704286476578645, 33.625005996662225, 33.199494563872854, 33.43300531706012, 34.333984389758655, 33.68299308268536, 33.353531753672925, 33.5827181047333, 33.22883642721804, 33.68519326170788, 33.38664819153141, 33.45685470445017, 33.34815657859768, 34.11542173956931, 33.90190422843509, 35.443009605908195, 34.5654860887096, 32.78462124304813, 33.948110860549704, 32.978353225035434, 33.42174616255656, 32.788322735096564, 32.492701264012176, 34.44205968871552, 32.54023105991719, 34.70027926770856, 34.46576555027785, 34.49123710145588, 33.77538983770259, 34.98081266635778, 33.28362146448482, 34.027367710667114, 34.54026741807601, 33.15230323793758, 34.17641930729626, 32.59235353699143, 33.39538876860911, 34.49245963764569, 33.39791916228519, 32.47069426477727, 33.728129872181775, 33.58241165084399, 32.403171219429694, 32.739580348345775, 33.02313501049998, 33.39241266038878], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.551637346522114, "var": 0.636802284335394, "samples": [35.66072221349813, 33.289855595726024, 33.47921233727223, 32.964501563486955, 33.34192843751825, 33.24841362428495, 33.506247831990706, 32.3039084503814, 33.58669984394926, 33.58855137542435, 33.40506662852537, 33.77725256411114, 33.433349919709414, 34.335246918585916, 33.40428287152816, 33.546347847076156, 31.367038864634345, 35.89935709939014, 32.76408782310426, 33.11464869309133, 34.1295635028361, 33.39088974497742, 34.84474899098827, 32.46595506343302, 33.993185025124255, 31.82236482944972, 32.295165070376086, 33.32143741381925, 33.5255723757533, 34.07797500250402, 35.02273090061419, 34.27013503540912, 33.758048382266864, 33.74800110428928, 34.020693990431575, 33.462740054160776, 33.54687188102546, 33.62116380792059, 33.33299506717137, 32.99707291960718, 33.80895539378719, 33.5677208480336, 34.25603763922294, 33.216538813869946, 33.39230999660994, 33.636928505271584, 33.60838433271711, 33.546483645563555, 33.906821357357046, 32.97765612822639], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.51124602638028, "var": 0.5425016337128403, "samples": [32.33971600980246, 33.506783234442864, 33.424790274240436, 31.828565578270364, 32.99920967015639, 33.58528470328256, 34.63542438708021, 33.9148704386763, 34.176648206168565, 33.807608270223255, 33.88338651670164, 33.16819037644461, 33.7968474080699, 35.25045813460696, 33.41543748127084, 33.73792988721958, 33.4713004699665, 34.48678487468801, 34.20347218674534, 33.88025898592557, 34.84345475871857, 33.37285673989237, 32.9903614808161, 33.63058424917972, 32.34760017695246, 33.611728636663464, 33.433460202670766, 31.85232591584708, 33.279444018819646, 32.19648796459648, 33.60570475361185, 33.52546747039033, 33.1648958666837, 34.48628783089798, 32.92190077962049, 33.61992978405905, 34.35290084585268, 33.740332699215635, 33.58071427707337, 33.91247926907648, 32.233332680378545, 32.72827432906267, 33.80278493798731, 34.601288154434286, 33.52310637065556, 32.879849203524586, 33.037573358731024, 34.19255390516079, 33.06611556703902, 33.515537997419486], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.775485215635335, "var": 0.6329678870476741, "samples": [33.52632174503542, 33.810483178799416, 32.98094938676697, 33.664439221178405, 33.32788029367911, 33.567617711236316, 34.93717975838052, 33.010488895049534, 34.06339351438546, 34.022555304709705, 34.58482607318164, 34.29703622128784, 33.84693425523714, 34.64937801747103, 33.79137657188863, 33.240776306740074, 33.930902317044065, 34.27637200129593, 34.51305835986679, 33.06368054467677, 32.23811398942892, 32.246183433752506, 33.28606732524974, 33.840552842175356, 34.12203009749828, 33.752522759607416, 34.258339492773636, 33.71645914493651, 35.69157655439136, 34.68076934210792, 34.75799696324141, 33.62056145314861, 33.057515142902616, 34.32853023745353, 32.63869930016442, 34.031289291591904, 33.811340717707964, 34.133160018402606, 32.12966583106611, 33.64153452986818, 34.37808145531048, 33.17045973822644, 35.633040566731715, 32.3709861317035, 33.5485224513987, 33.659749370051316, 33.459478308120474, 35.09177394752278, 32.94469099407879, 33.42891967324257], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.56901566804045, "var": 0.44770397192851763, "samples": [32.55961397422567, 33.376910867796745, 33.260648691425644, 33.684533996027746, 33.95109568120709, 33.24789000953922, 33.339933829833015, 33.71305113521709, 32.69687525531073, 33.09717690132824, 35.93464209479809, 32.48770423292437, 34.03627903933793, 33.6123997678423, 33.2149274889893, 33.87975112524006, 33.63039019388706, 33.58883971989953, 34.308351624902045, 34.52481985055722, 33.756500513297986, 34.5612776826988, 33.9053852760811, 34.03470706116044, 33.9042361159637, 34.020689993519596, 33.58227137262698, 34.0270747401802, 33.535381960374785, 33.42777079411058, 32.32751212304922, 34.59593518708772, 32.970292340083816, 34.003220527764576, 32.31916232101061, 34.138182803178864, 33.349003255198404, 33.684533996027746, 33.25547690961014, 32.73009531549339, 33.880379801912525, 32.74789481709954, 33.26088440100823, 33.33068149464524, 33.42805361603242, 33.744506169332595, 34.49803545511331, 33.19451930166637, 33.53602717151608, 32.55525540488854], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.729034579867786, "var": 0.6559137738711631, "samples": [33.93843461274204, 34.86429801460678, 32.97880249163184, 33.242553482016405, 32.71655795024224, 34.626834822918894, 35.68289050735438, 33.066343191102256, 36.614026099297575, 33.02830136593448, 33.56313575865703, 33.769439959973205, 33.59461301253606, 33.47803402565795, 33.5058136560398, 33.382455805184364, 32.49160798345489, 33.45000527752592, 33.81124343779677, 34.35185646555069, 33.7465470207997, 33.98526899137551, 33.35369676086375, 32.903259557561874, 33.71732568727478, 33.40728571335557, 33.382214062178335, 33.5357363860567, 33.44074945718868, 32.31657580825231, 33.80465735200711, 34.07681961306495, 33.48241583720055, 33.66570175797934, 33.87733740892263, 33.565906394341496, 34.28601628165597, 33.43290635144112, 33.489049277679484, 32.94426811441158, 34.20850696575308, 31.850741489006243, 34.28074739166498, 35.14205878562688, 33.917223145162666, 34.46239627292317, 34.14055015617257, 33.02393132202203, 34.49107309034014, 34.363514620882604], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.71661825743109, "var": 0.48701260270265345, "samples": [33.6230996044851, 34.904985616210844, 33.57954520331338, 33.43095867087731, 34.31842506938406, 33.86387715035682, 34.448137423308516, 34.19439859636634, 33.90279977328713, 34.09602009676529, 33.4847897439523, 33.99556051717546, 34.25849470786237, 34.854740196901346, 33.93827753428217, 33.30512948355291, 33.24086770962264, 33.194551979920696, 33.5971185502547, 32.952445089578504, 33.2377143358029, 34.4510013371277, 33.199094706864784, 34.244339719173134, 32.259783903874784, 34.14897669799885, 33.673755935361015, 33.38889110676544, 32.602239858666046, 33.731924429577326, 34.971693349803864, 33.98152547191967, 32.5442567100597, 33.64454674929203, 32.2661849909627, 33.604015281324386, 33.25164559088019, 33.64898330838417, 32.63023047854933, 34.0869232573027, 34.76212885490073, 33.56845920878419, 34.364256389914864, 34.891645180003394, 32.32857283130277, 33.912835782578505, 34.44938159359638, 34.354225707571814, 33.135941163184654, 33.311516222568514], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.72841756607548, "var": 0.7924331946510165, "samples": [33.16764136207287, 33.66646367661889, 34.132396278559206, 33.67712799337778, 32.858896165251195, 35.21598957944912, 34.537323584507675, 32.65846235051916, 34.58917656064872, 34.05005484824281, 34.44205968871552, 35.38110553012585, 31.835249505027974, 33.14625628844929, 34.595904764329845, 34.67439083690509, 32.48115313404416, 32.24414666866364, 32.535939248829976, 34.09854309601552, 33.215626883763846, 34.86072622676551, 34.369106605552, 34.09876216567763, 34.114665637504274, 33.282820345542085, 34.49102610850661, 32.19151102844407, 35.16806109567818, 34.70677387377496, 34.16307172849727, 34.460322300382835, 32.822017572653046, 33.0070624899743, 32.9912438988034, 34.12156556190751, 33.01187852750618, 34.32370730735797, 33.55172790497644, 33.59493580073353, 35.04828145887912, 33.20911002384004, 32.481344024027244, 33.943383812588074, 33.47779785871991, 34.82734439193224, 33.48367363659938, 33.66374915178113, 33.10649544750139, 32.64480427354971], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.58570830928644, "var": 0.4904628503885144, "samples": [32.85550536748602, 34.045726806854034, 34.46210929976677, 33.12264938312884, 33.06716269940912, 33.595874403021206, 33.07574145616439, 34.60493648469986, 33.86802270739998, 35.67336452457279, 34.14227620053984, 34.263760059320454, 33.43873645223633, 33.931719532995714, 34.71624089444539, 32.862727087944336, 32.808837074268126, 34.26797447909654, 33.355344863773965, 32.727050522506346, 32.477813748615745, 34.24787411564097, 33.63964223637013, 33.27300196080037, 33.44637550315061, 33.133016290637364, 34.198910281399584, 32.31657580825231, 33.89265236573031, 33.930769959806945, 32.413491331339124, 34.444785453918435, 33.52274817210337, 33.952238830888554, 32.731952897620424, 33.959498799821375, 33.959065446203745, 33.435678753325455, 34.51358008307032, 33.5130476828911, 32.80105375942968, 32.67928966151835, 33.431747892780336, 33.147180920459064, 33.258579182051946, 32.89371418140015, 33.873949743186664, 34.57282321403214, 33.37417095802861, 33.364425930218445], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.46389183535393, "var": 0.5484843021985254, "samples": [33.61794242133607, 33.09569347748465, 34.20466282895216, 34.14540668398161, 33.28555578810202, 34.23740900903513, 33.415190495455334, 33.04338358054294, 32.03382837958396, 34.45258794998339, 35.30787018237284, 33.769434357233564, 33.32683304222367, 34.18055973741908, 32.73360188632822, 33.78589404361289, 32.28327341621845, 32.777108075986945, 32.48843886810165, 34.15832012191952, 32.05129119101738, 32.471654459766846, 33.60987988768508, 33.10737162121661, 34.36844224924049, 33.608720713743196, 33.23254731774963, 33.60642575438288, 34.363472445075814, 34.37582193216156, 32.86794059009776, 32.777849179244505, 34.00293369331185, 32.65846235051916, 33.27987246472045, 34.18061989353346, 33.66107044965479, 33.97250440157934, 33.45397681345847, 33.78003867784581, 32.93000090006648, 32.78017046668771, 33.652779945309184, 33.04678441201284, 33.19106227518057, 31.91565035915324, 33.86421821377034, 34.83449801623015, 33.55082495695978, 33.654711790446996], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.66604067168942, "var": 0.4740203119023288, "samples": [33.29406791618134, 35.16132890877573, 33.67914391287321, 34.30549416868019, 33.26473061479624, 33.35746565963196, 33.75539580984511, 33.760330699688915, 33.35905927533153, 33.28889219342663, 33.29867747096321, 32.397444283883445, 32.418674206466584, 33.379902362008835, 34.47353870172685, 33.78127057234279, 33.951420674363675, 34.15540528039314, 33.39607468062258, 34.6213961984524, 33.15503726217997, 33.34187904700301, 34.598837407965334, 33.18658027064974, 32.271650489534466, 33.81350362798304, 32.947075318792685, 34.50812756013505, 32.89175891401079, 33.833254036657635, 33.6437554603551, 33.256863713604766, 33.70287148164538, 33.02631448857049, 33.16737522034008, 33.69302246855074, 34.16333766610471, 35.13512705893076, 34.69397590530327, 34.21840196060012, 35.569067222059225, 33.11709034314787, 33.9045672234733, 33.87861249663253, 33.4033656231417, 33.281044266122414, 33.68242646357676, 33.362104872516056, 33.692303815602784, 33.0629883088271], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.6014887570645, "var": 0.6871654394043133, "samples": [32.56800837114303, 33.632846555042086, 33.98836763347959, 34.03195957280639, 32.90746140929516, 32.98112908544273, 34.174787711588685, 33.05607469543324, 32.521524523160735, 33.480552940324124, 33.459441272691116, 33.268167195703995, 33.013108246824764, 34.28630468037306, 35.702087074680584, 32.88673889458138, 32.50137592825712, 32.8734558681733, 34.98001769687563, 34.09742873569797, 33.1855985588109, 33.15000240380755, 33.88185359440165, 33.715273979797736, 32.94925243952709, 35.24081169670478, 32.832409614512144, 33.340877001143916, 32.94234603609565, 34.31267848467771, 34.363402718852925, 32.897778125328756, 33.96373685750561, 33.58496744240026, 34.5438607680801, 33.46320849451164, 34.78326406809724, 32.66410928728241, 33.758091421535774, 33.835072808622186, 33.38221525359329, 31.967049108083117, 35.52750258373004, 32.48427876917319, 33.81600290006362, 34.85911788958995, 34.28997780534591, 33.62003225117209, 33.08904775846306, 33.21977964073986], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.62422251998785, "var": 0.47487263412995545, "samples": [33.62181454292422, 34.64869659295878, 34.23652978025986, 33.50190483218849, 34.56291740085576, 32.934960382179675, 33.238048864845794, 34.90810777648854, 34.102555181337536, 33.700185561900575, 33.07566521359398, 34.22566640096791, 34.38411500247843, 33.56352883370343, 34.86519249395048, 34.159347145057296, 32.16395150792167, 32.604756758525404, 33.893758038641764, 33.098831764671, 33.82056664341826, 34.418318601893816, 34.0341333667948, 33.99642648771305, 34.07483596203596, 34.33639912504074, 33.14083524280664, 33.924228553891254, 34.01973527679892, 34.52502352522606, 33.15438416930787, 33.604720209236994, 33.06691344526522, 32.316184124918514, 33.287217636569125, 32.399465651949356, 33.51571958363564, 32.932904268489466, 32.83823156443325, 32.61335914418203, 33.98521864219935, 33.300031107520724, 33.46061189840308, 32.31198026050327, 34.07505361088123, 33.785636323528614, 33.56317521065511, 34.20311825558512, 33.11557965213928, 33.90058437891906], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.560419685579845, "var": 0.5453022679373981, "samples": [33.39342681664566, 33.92659385433027, 31.759820254146582, 33.37866219028641, 33.218871694689525, 32.940101657447784, 32.736524466096334, 33.97091644259205, 33.88232629929607, 33.26427796303561, 35.33293901821345, 34.7317934425105, 34.5947199896095, 32.26933132201082, 34.11198012997371, 34.68228336607387, 33.71916627496568, 33.247612824359855, 32.86247045811366, 33.22010599507499, 33.56885360892049, 33.61239992541397, 34.085236187806544, 32.86115696843424, 35.41922908300189, 33.98367638983626, 34.62856728774225, 33.213045230127975, 32.953943943511526, 32.86051351303601, 32.646264518530344, 33.59342815906537, 33.93140507024862, 33.71840348698714, 33.0855241479953, 33.979648468464646, 33.59427745183392, 32.98508834913065, 33.11271826618585, 34.459428525168946, 33.15165129554738, 33.10737162121661, 33.25027747814691, 32.83252192672705, 33.69175836870211, 34.38490838097771, 32.58379050485799, 33.62601746190418, 33.83520170497116, 34.020752495026805], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.464485389325375, "var": 0.5786287989144774, "samples": [34.35541295454613, 34.57386217747547, 33.536741774730416, 33.49948707909967, 32.83605392169863, 33.36020394493899, 33.59775918214865, 34.13222631341684, 31.86399884326332, 33.28706115491138, 33.11555963044862, 33.72202276846247, 33.0643319784336, 32.86846100402441, 34.56684789054387, 33.27369998628709, 33.40018834332855, 34.519951727383706, 34.445427935891345, 33.95450408256184, 34.09807597753768, 32.616610785956205, 33.02783715391692, 33.72859537278225, 33.65434679194454, 32.461816728382054, 33.00481553850961, 33.48025208520868, 33.8886618661184, 34.09003798520491, 34.29861264094448, 33.40311762676804, 35.761398299374626, 31.902214669034183, 32.592482933252015, 33.42118465312313, 33.77909432233505, 33.44609540987496, 32.529859969234536, 33.652779945309184, 32.85576814859876, 34.16570069695981, 33.40820209446995, 32.33576957442408, 34.163803762448396, 33.49095947400163, 33.79989467250564, 32.33075648241195, 32.385038317916376, 33.47668279412537], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.548637637701255, "var": 0.7091761117542039, "samples": [33.42885894245197, 34.97647914522968, 33.57074825211898, 34.378984985898846, 33.25760948717636, 33.22147541247249, 34.421010765435284, 31.803120402364584, 33.16942821432882, 34.42668625723399, 33.25436291177341, 32.29544081275543, 34.108867874960794, 33.65456823838248, 34.52921922557558, 32.84436889925925, 33.739467381939555, 33.45803759829586, 34.047475933811256, 33.07916110694892, 32.88505062209834, 34.17635770648594, 34.03159792512049, 31.565199998821793, 33.9282363796287, 33.3745704537022, 34.750656093376804, 32.52806653132103, 33.86777792856226, 33.51071081516323, 33.67292400020536, 33.87756910394179, 32.47128866477748, 34.712343479924726, 32.391374802320044, 32.699617081493436, 33.84860942080952, 33.06963595566065, 33.01437648591044, 32.09087172020919, 34.816046220672675, 32.9943965863351, 34.201642423159186, 32.63122386996661, 33.46439053117268, 33.72965749487239, 33.92431515796342, 34.405546646867805, 33.6237669255643, 35.508689010541374], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.74430599985933, "var": 0.7267695557457118, "samples": [34.1533007396974, 33.7723181377345, 33.90972694528627, 33.375922011154714, 32.05488636609783, 32.952263761916875, 33.65601238301294, 33.88598463890515, 32.65840938561089, 34.50912493754739, 35.538491683562555, 32.5783755495716, 34.708430952528445, 33.94403097193492, 33.41025698158379, 33.8021559308328, 32.8561816516351, 33.74625295222766, 34.5904515159963, 34.04161294816108, 35.24100377212827, 31.749007300280827, 33.48113208141089, 34.67755222158192, 33.13292707081265, 33.073504494436406, 33.9556072053484, 33.0144380548483, 32.562973063970574, 34.59712461636012, 34.85969345361434, 32.94626621767303, 33.5677208480336, 34.94665959064108, 33.37481658847753, 33.96914724718171, 34.595790415996305, 32.52509872983382, 34.462056175702095, 33.2457164744839, 32.714073156448784, 33.66090180540994, 33.06095898798593, 34.27501333153926, 33.23326962020701, 35.29830253214127, 34.15202287995078, 34.4857159648196, 34.29931405088868, 33.91330159576079], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.67405104980751, "var": 0.6096100271015188, "samples": [34.50938089734786, 34.46751484276085, 33.332083356990665, 33.94708021576973, 34.17900628636103, 32.95540552065261, 34.01179052763144, 33.929653553333836, 32.823900848802474, 34.546698049104776, 33.280552373150236, 34.36555622508667, 33.56651957417317, 34.23158760977919, 32.36642133199, 33.39985460626894, 33.74725503076372, 33.33863315817611, 33.436261970598274, 33.37949740247356, 33.98261367021066, 34.55430759216697, 32.74021371647474, 35.05623374616356, 33.829318958953074, 34.939942238938485, 34.008299917254575, 34.00989290894746, 32.95438663142112, 32.95918590165981, 33.27134002739235, 34.0631695268297, 33.05515454846547, 33.43175958139817, 32.14654540412612, 35.072130667612754, 32.10920550035419, 34.27417226957374, 33.21155499507847, 34.65227967749554, 33.140877341257536, 34.245149532419575, 33.106316286506306, 35.462107850953025, 32.45619856435772, 32.9818328846345, 33.34200499706674, 34.05326283988049, 32.736847451211275, 34.04159388035627], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.63670774132129, "var": 0.5615249920513429, "samples": [32.580229208764116, 33.74058921918153, 34.233395198767624, 34.23759459922562, 33.439215207968815, 33.750479854725505, 33.021825900706254, 34.3085142814114, 34.090991471745646, 33.58844094301584, 33.385406374108705, 33.02289211934947, 33.799626246887755, 34.546276805874825, 34.212546470388546, 35.33639837151255, 32.983890991074176, 33.42339804860271, 32.98564977540572, 33.85566509928755, 33.14078068308458, 34.92488921370005, 34.74188101256521, 32.93916262423547, 33.29480479556477, 33.029947314373885, 33.04206316301833, 33.92834776332859, 33.15019660151687, 32.55472717900099, 34.188744993694165, 32.55462678207865, 34.02095659655759, 34.04679285210899, 33.28725421764303, 34.42592666138694, 33.17592505145205, 33.847314600559415, 34.29593655719464, 33.0983618712527, 34.19191891839945, 33.35582233579127, 33.63651684150708, 32.99721743189393, 35.33750249306897, 33.769434357233564, 33.277524363936934, 32.03013325151833, 32.23712671288874, 34.770523637504915], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.6488882092225, "var": 0.5070605330503151, "samples": [34.1439529861468, 32.759983645466534, 33.68519326170788, 33.47073585681315, 32.65746283282819, 33.59948601559814, 34.838391233577454, 33.95414037904921, 34.73404060115641, 33.215803924225774, 32.54364529544157, 33.405277854887956, 33.10759844888923, 33.624755086035584, 33.89838912895245, 34.71127708533468, 33.207946960777306, 32.50551686431736, 33.89442114362616, 35.36495680651987, 33.39400290021353, 33.65525959820116, 33.95603662392862, 34.00686449669511, 34.50670716431715, 32.26163058088914, 32.96588780367097, 33.53539872288011, 34.67982336221223, 33.58682540794176, 33.174871790136585, 35.04335000704458, 34.61183294615885, 33.716600437085646, 32.59107131065463, 33.297361948028126, 32.869239530305386, 34.26893715129935, 33.85371453650045, 32.746363213751216, 33.51269522377726, 33.917223145162666, 34.49267033138808, 33.82607929692071, 33.5648718078312, 33.845370523161776, 33.9584180358375, 32.910696510172556, 33.110709209114916, 33.260921434491976], "tags": {"name": "ground_truth"}, "metadata": {}}, {"mean": 33.53898560040761, "var": 0.0, "samples": [33.53898560040761, 33.53898560040761, 33.53898560040761], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.17797327041625977, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "419555"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.53236610939152, "var": 0.0, "samples": [33.53236610939152, 33.53236610939152, 33.53236610939152], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.14930272102355957, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "294528"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.68418884643755, "var": 0.0, "samples": [33.68418884643755, 33.68418884643755, 33.68418884643755], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16112518310546875, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "838106"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.644897586301504, "var": 0.0, "samples": [33.644897586301504, 33.644897586301504, 33.644897586301504], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.14953899383544922, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "175519"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.712768244874134, "var": 0.0, "samples": [33.712768244874134, 33.712768244874134, 33.712768244874134], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.13254261016845703, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "79107"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.59844595086534, "var": 0.0, "samples": [33.59844595086534, 33.59844595086534, 33.59844595086534], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.15212440490722656, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "552809"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.68321574296243, "var": 0.0, "samples": [33.68321574296243, 33.68321574296243, 33.68321574296243], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1457669734954834, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "557655"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.36839140388459, "var": 0.0, "samples": [33.36839140388459, 33.36839140388459, 33.36839140388459], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.14951372146606445, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "174784"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.59587331772519, "var": 0.0, "samples": [33.59587331772519, 33.59587331772519, 33.59587331772519], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.15989279747009277, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "258040"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.46275143023313, "var": 0.0, "samples": [33.46275143023313, 33.46275143023313, 33.46275143023313], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1572883129119873, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "675373"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.604369318362664, "var": 0.0, "samples": [33.604369318362664, 33.604369318362664, 33.604369318362664], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.15770530700683594, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "406025"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.57894613483413, "var": 0.0, "samples": [33.57894613483413, 33.57894613483413, 33.57894613483413], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.17329168319702148, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "755152"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.52765356423426, "var": 0.0, "samples": [33.52765356423426, 33.52765356423426, 33.52765356423426], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.18243122100830078, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "74986"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.61093601499732, "var": 0.0, "samples": [33.61093601499732, 33.61093601499732, 33.61093601499732], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.14407801628112793, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "605201"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.411440436045645, "var": 0.0, "samples": [33.411440436045645, 33.411440436045645, 33.411440436045645], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16596269607543945, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "433116"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.6609536362037, "var": 0.0, "samples": [33.6609536362037, 33.6609536362037, 33.6609536362037], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.14886975288391113, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "77042"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.39387820136328, "var": 0.0, "samples": [33.39387820136328, 33.39387820136328, 33.39387820136328], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16597771644592285, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "381593"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.58566078772853, "var": 0.0, "samples": [33.58566078772853, 33.58566078772853, 33.58566078772853], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.14972877502441406, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "664238"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.580663078020315, "var": 0.0, "samples": [33.580663078020315, 33.580663078020315, 33.580663078020315], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1513833999633789, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "817059"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.412705829588965, "var": 0.0, "samples": [33.412705829588965, 33.412705829588965, 33.412705829588965], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16598749160766602, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "953627"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.69907654611831, "var": 0.0, "samples": [33.69907654611831, 33.69907654611831, 33.69907654611831], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16622376441955566, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "465896"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.57613734497697, "var": 0.0, "samples": [33.57613734497697, 33.57613734497697, 33.57613734497697], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16278934478759766, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "422703"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.47069343672107, "var": 0.0, "samples": [33.47069343672107, 33.47069343672107, 33.47069343672107], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1766979694366455, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "161502"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.71049994498077, "var": 0.0, "samples": [33.71049994498077, 33.71049994498077, 33.71049994498077], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.15080046653747559, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "551634"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.5409769163951, "var": 0.0, "samples": [33.5409769163951, 33.5409769163951, 33.5409769163951], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.14969229698181152, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "966713"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.58547583843498, "var": 0.0, "samples": [33.58547583843498, 33.58547583843498, 33.58547583843498], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16598224639892578, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "348183"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.682829838772555, "var": 0.0, "samples": [33.682829838772555, 33.682829838772555, 33.682829838772555], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16846179962158203, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "461381"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.733190481601405, "var": 0.0, "samples": [33.733190481601405, 33.733190481601405, 33.733190481601405], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.18308734893798828, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "475904"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.379535161484235, "var": 0.0, "samples": [33.379535161484235, 33.379535161484235, 33.379535161484235], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16628050804138184, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "890910"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.50948943113027, "var": 0.0, "samples": [33.50948943113027, 33.50948943113027, 33.50948943113027], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.13830065727233887, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "260299"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.51818901612097, "var": 0.0, "samples": [33.51818901612097, 33.51818901612097, 33.51818901612097], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1607224941253662, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "307905"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.54794129259034, "var": 0.0, "samples": [33.54794129259034, 33.54794129259034, 33.54794129259034], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.14805316925048828, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "320476"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.72980475910327, "var": 0.0, "samples": [33.72980475910327, 33.72980475910327, 33.72980475910327], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.15451431274414062, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "734634"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.774449907795805, "var": 0.0, "samples": [33.774449907795805, 33.774449907795805, 33.774449907795805], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1817770004272461, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "547532"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.71644573771019, "var": 0.0, "samples": [33.71644573771019, 33.71644573771019, 33.71644573771019], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.14948129653930664, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "882854"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.56653828037551, "var": 0.0, "samples": [33.56653828037551, 33.56653828037551, 33.56653828037551], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16530632972717285, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "628965"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.715955689743176, "var": 0.0, "samples": [33.715955689743176, 33.715955689743176, 33.715955689743176], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1779465675354004, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "687599"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.583441930302726, "var": 0.0, "samples": [33.583441930302726, 33.583441930302726, 33.583441930302726], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.17725038528442383, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "715079"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.48532996641732, "var": 0.0, "samples": [33.48532996641732, 33.48532996641732, 33.48532996641732], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.17624664306640625, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "920391"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.507466729076384, "var": 0.0, "samples": [33.507466729076384, 33.507466729076384, 33.507466729076384], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.16724658012390137, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "942144"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.533731885457655, "var": 0.0, "samples": [33.533731885457655, 33.533731885457655, 33.533731885457655], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.15930724143981934, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "800601"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.62692829023772, "var": 0.0, "samples": [33.62692829023772, 33.62692829023772, 33.62692829023772], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1666254997253418, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "95489"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.61064427335671, "var": 0.0, "samples": [33.61064427335671, 33.61064427335671, 33.61064427335671], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.15520763397216797, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "762339"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.58345753452129, "var": 0.0, "samples": [33.58345753452129, 33.58345753452129, 33.58345753452129], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.14922881126403809, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "740953"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.65591562453877, "var": 0.0, "samples": [33.65591562453877, 33.65591562453877, 33.65591562453877], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.21287798881530762, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "394053"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.60227513231608, "var": 0.0, "samples": [33.60227513231608, 33.60227513231608, 33.60227513231608], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.2024245262145996, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "330499"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.58942890927467, "var": 0.0, "samples": [33.58942890927467, 33.58942890927467, 33.58942890927467], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.2022852897644043, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "681392"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.494503968976794, "var": 0.0, "samples": [33.494503968976794, 33.494503968976794, 33.494503968976794], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.150038480758667, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "44867"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.693954460052666, "var": 0.0, "samples": [33.693954460052666, 33.693954460052666, 33.693954460052666], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.15210676193237305, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "957487"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.61814102749417, "var": 0.0, "samples": [33.61814102749417, 33.61814102749417, 33.61814102749417], "tags": {"name": "qoi_no_gp"}, "metadata": {"runtime_sec": 0.1625049114227295, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "980542"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.516144553578854, "var": 0.0, "samples": [33.516144553578854, 33.516144553578854, 33.516144553578854], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4487597942352295, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "207835"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.51117555632935, "var": 0.0, "samples": [33.51117555632935, 33.51117555632935, 33.51117555632935], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.5235326290130615, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "65340"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.661546762597325, "var": 0.0, "samples": [33.661546762597325, 33.661546762597325, 33.661546762597325], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.49846458435058594, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "274762"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.62259625971266, "var": 0.0, "samples": [33.62259625971266, 33.62259625971266, 33.62259625971266], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4293701648712158, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "725870"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.68911856814623, "var": 0.0, "samples": [33.68911856814623, 33.68911856814623, 33.68911856814623], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.46656370162963867, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "332824"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.57309249507569, "var": 0.0, "samples": [33.57309249507569, 33.57309249507569, 33.57309249507569], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.43408870697021484, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "974935"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.658206554293685, "var": 0.0, "samples": [33.658206554293685, 33.658206554293685, 33.658206554293685], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4322328567504883, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "806836"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.34502139975923, "var": 0.0, "samples": [33.34502139975923, 33.34502139975923, 33.34502139975923], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4655630588531494, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "658027"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.57323963028402, "var": 0.0, "samples": [33.57323963028402, 33.57323963028402, 33.57323963028402], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.44394874572753906, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "604642"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.44269340132164, "var": 0.0, "samples": [33.44269340132164, 33.44269340132164, 33.44269340132164], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.463329553604126, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "791891"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.57654708208817, "var": 0.0, "samples": [33.57654708208817, 33.57654708208817, 33.57654708208817], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4803886413574219, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "427027"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.55585182310974, "var": 0.0, "samples": [33.55585182310974, 33.55585182310974, 33.55585182310974], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4812586307525635, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "972457"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.50596913494621, "var": 0.0, "samples": [33.50596913494621, 33.50596913494621, 33.50596913494621], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4672267436981201, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "390406"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.58798282307389, "var": 0.0, "samples": [33.58798282307389, 33.58798282307389, 33.58798282307389], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4774439334869385, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "471937"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.38523769640086, "var": 0.0, "samples": [33.38523769640086, 33.38523769640086, 33.38523769640086], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4636106491088867, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "372859"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.637769294193745, "var": 0.0, "samples": [33.637769294193745, 33.637769294193745, 33.637769294193745], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4669651985168457, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "842710"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.369391077911686, "var": 0.0, "samples": [33.369391077911686, 33.369391077911686, 33.369391077911686], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4607205390930176, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "394056"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.56287689183553, "var": 0.0, "samples": [33.56287689183553, 33.56287689183553, 33.56287689183553], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4883410930633545, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "891173"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.555378643449096, "var": 0.0, "samples": [33.555378643449096, 33.555378643449096, 33.555378643449096], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.48198437690734863, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "133329"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.389679375924615, "var": 0.0, "samples": [33.389679375924615, 33.389679375924615, 33.389679375924615], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.45682382583618164, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "325416"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.679113544205826, "var": 0.0, "samples": [33.679113544205826, 33.679113544205826, 33.679113544205826], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.5978569984436035, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "512804"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.54997990649477, "var": 0.0, "samples": [33.54997990649477, 33.54997990649477, 33.54997990649477], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4723539352416992, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "260974"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.449697128181505, "var": 0.0, "samples": [33.449697128181505, 33.449697128181505, 33.449697128181505], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.499725341796875, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "714"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.68677625250598, "var": 0.0, "samples": [33.68677625250598, 33.68677625250598, 33.68677625250598], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4708390235900879, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "275496"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.51732517745463, "var": 0.0, "samples": [33.51732517745463, 33.51732517745463, 33.51732517745463], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4509255886077881, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "41968"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.565039698126, "var": 0.0, "samples": [33.565039698126, 33.565039698126, 33.565039698126], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.46146512031555176, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "980829"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.66036744861883, "var": 0.0, "samples": [33.66036744861883, 33.66036744861883, 33.66036744861883], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4771697521209717, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "282844"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.707471570299276, "var": 0.0, "samples": [33.707471570299276, 33.707471570299276, 33.707471570299276], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4659543037414551, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "237064"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.358111145258974, "var": 0.0, "samples": [33.358111145258974, 33.358111145258974, 33.358111145258974], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.487185001373291, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "434267"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.48789175788108, "var": 0.0, "samples": [33.48789175788108, 33.48789175788108, 33.48789175788108], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.47708606719970703, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "699725"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.49327484324919, "var": 0.0, "samples": [33.49327484324919, 33.49327484324919, 33.49327484324919], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.46599388122558594, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "508011"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.52497458836132, "var": 0.0, "samples": [33.52497458836132, 33.52497458836132, 33.52497458836132], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.47037506103515625, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "574103"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.70524799904838, "var": 0.0, "samples": [33.70524799904838, 33.70524799904838, 33.70524799904838], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.497450590133667, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "300521"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.747705153465596, "var": 0.0, "samples": [33.747705153465596, 33.747705153465596, 33.747705153465596], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.46617794036865234, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "91066"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.69270156703385, "var": 0.0, "samples": [33.69270156703385, 33.69270156703385, 33.69270156703385], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4700648784637451, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "494848"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.54434303474734, "var": 0.0, "samples": [33.54434303474734, 33.54434303474734, 33.54434303474734], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.48288536071777344, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "16336"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.6949050224559, "var": 0.0, "samples": [33.6949050224559, 33.6949050224559, 33.6949050224559], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.46584248542785645, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "535923"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.55846036178514, "var": 0.0, "samples": [33.55846036178514, 33.55846036178514, 33.55846036178514], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.46601200103759766, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "153251"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.465769171106, "var": 0.0, "samples": [33.465769171106, 33.465769171106, 33.465769171106], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4828331470489502, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "79410"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.48457677709215, "var": 0.0, "samples": [33.48457677709215, 33.48457677709215, 33.48457677709215], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4669170379638672, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "231702"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.50944556843442, "var": 0.0, "samples": [33.50944556843442, 33.50944556843442, 33.50944556843442], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4697914123535156, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "784570"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.60061890366016, "var": 0.0, "samples": [33.60061890366016, 33.60061890366016, 33.60061890366016], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4697282314300537, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "35216"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.58480914762079, "var": 0.0, "samples": [33.58480914762079, 33.58480914762079, 33.58480914762079], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.47456955909729004, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "850540"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.56001333847134, "var": 0.0, "samples": [33.56001333847134, 33.56001333847134, 33.56001333847134], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4577031135559082, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "705478"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.632930495134836, "var": 0.0, "samples": [33.632930495134836, 33.632930495134836, 33.632930495134836], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4702644348144531, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "49403"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.581319865063335, "var": 0.0, "samples": [33.581319865063335, 33.581319865063335, 33.581319865063335], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.469296932220459, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "891781"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.56706978824593, "var": 0.0, "samples": [33.56706978824593, 33.56706978824593, 33.56706978824593], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.48369836807250977, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "611728"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.472700045476145, "var": 0.0, "samples": [33.472700045476145, 33.472700045476145, 33.472700045476145], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.49832797050476074, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "974967"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.6686720252303, "var": 0.0, "samples": [33.6686720252303, 33.6686720252303, 33.6686720252303], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4825115203857422, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "759747"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.59667823613084, "var": 0.0, "samples": [33.59667823613084, 33.59667823613084, 33.59667823613084], "tags": {"name": "qoi_gp_deterministic"}, "metadata": {"runtime_sec": 0.4626343250274658, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([3])", "seed": "56529"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "training": "False"}}}, {"mean": 33.52859459331765, "var": 0.013385576465815056, "samples": [33.50365397807248, 33.53359952778213, 33.48566347344043, 33.34859936056612, 33.33829726917166, 33.54103717772105, 33.25534307722692, 33.63776547207106, 33.56023747164153, 33.5708736817922, 33.37536235566103, 33.52586604535763, 33.73063442930406, 33.70817504775061, 33.42288929611628, 33.447368300723326, 33.668368595914835, 33.45473326035092, 33.572958936239246, 33.47772066410474, 33.252781825866876, 33.79343995771012, 33.5360023432297, 33.57933588769517, 33.53699751887236, 33.49497923733634, 33.539245008681135, 33.38554972994638, 33.54324810087053, 33.612363154262596, 33.604120300106594, 33.68390993180429, 33.47443721730994, 33.581716019379115, 33.52011836917264, 33.597035590238306, 33.57243529488327, 33.53541835857583, 33.49805002662765, 33.45340907397035, 33.482949610168625, 33.595086355594546, 33.48366459516151, 33.39427178822668, 33.77328239336042, 33.44020155473376, 33.700456154385876, 33.51352082470131, 33.54695441068381, 33.545601611318396], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.1783664226531982, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "771660"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.53434615552675, "var": 0.012391512568328794, "samples": [33.39214668172133, 33.474105684587855, 33.33157977307463, 33.47485343530904, 33.486616404184446, 33.561328067302924, 33.64785108804432, 33.53585062436399, 33.61415187678759, 33.51959119125065, 33.68087253987819, 33.66606725716231, 33.42169697063081, 33.631264859840044, 33.42991145052834, 33.44931461833534, 33.504157500460295, 33.602688491712854, 33.33631542618047, 33.54221100354174, 33.45522863682422, 33.4281656213362, 33.46364912474243, 33.496155228337905, 33.33539161302012, 33.569110678000754, 33.55659760920658, 33.803336066356756, 33.68464745160895, 33.716181206301144, 33.571965423601696, 33.58715979342288, 33.49813768014936, 33.54951121830713, 33.64480576844178, 33.47905631523118, 33.407981482394426, 33.67177641653633, 33.62724019425043, 33.506043418448215, 33.63362685950025, 33.61051029420897, 33.511545914264126, 33.577942776307204, 33.62933215653288, 33.38412281386506, 33.289469938557765, 33.48440819677847, 33.563172782209016, 33.67846015269798], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.2032995223999023, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "211801"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.67149094759926, "var": 0.010986459524057296, "samples": [33.54514935025375, 33.687292967262685, 33.62595153658297, 33.599397135355794, 33.51432409736303, 33.68319959941209, 33.506148792729945, 33.57504729074463, 33.71183814166561, 33.756337363811625, 33.511356984718475, 33.642508927889736, 33.47032242267576, 33.72262796365305, 33.65359640610344, 33.87792108747551, 33.57997817148228, 33.54874373951647, 33.74646853944283, 33.59339753917646, 33.83417814451017, 33.77040315039062, 33.78938556692053, 33.78124929254282, 33.767041124355906, 33.72012842742283, 33.59570288569003, 33.65118907650724, 33.55097469298409, 33.634904081805175, 33.724924733958474, 33.76461798057862, 33.64501108562107, 33.64500028940133, 33.58365775836681, 33.606631701840634, 33.57237185550462, 33.59411189641519, 33.80253799355939, 33.77981496500597, 33.4957725341142, 33.86329940830829, 33.803820792338236, 33.82340341134112, 33.71306510376753, 33.715607808538664, 33.643793338291765, 33.62800561807085, 33.782747193936416, 33.73958741055837], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.195781707763672, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "862839"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.623794324365406, "var": 0.01257389446154827, "samples": [33.550299787135444, 33.64955547395991, 33.64328807374067, 33.8944066576308, 33.65942090468085, 33.54470029425863, 33.676489696947634, 33.578499064939486, 33.77977881317049, 33.581743183102255, 33.70162578385261, 33.60586594760475, 33.46376187319871, 33.688642162610925, 33.64249656571129, 33.75243859931127, 33.61019526662841, 33.62010463277847, 33.43878629722783, 33.40952673711141, 33.73162941105241, 33.371943401190286, 33.62762498639536, 33.43249082022214, 33.54733152414324, 33.56536286538292, 33.49713940124856, 33.57591425126052, 33.610757354872426, 33.6974364795046, 33.638648230093644, 33.59515829399754, 33.724753461835014, 33.71965724400445, 33.56692171334271, 33.416192155736034, 33.7032002938034, 33.739583693234025, 33.42190722448028, 33.66589923501614, 33.66121173053373, 33.630991970504596, 33.63025454220795, 33.654550157534324, 33.7956041310631, 33.622175292409494, 33.60287283685113, 33.7630523138071, 33.81481991854939, 33.673005468392006], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.1610283851623535, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "96010"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.724773629049885, "var": 0.011798465391406575, "samples": [33.70885047380199, 33.68376117579287, 33.74792930180699, 33.83370841077847, 33.646613879042235, 33.684866426716326, 33.81098841981658, 33.671587298308225, 33.74003750170151, 33.738528215489104, 33.81454879582454, 33.66692836298702, 33.86241180806974, 33.803451883314615, 33.55511607440741, 33.70275351718976, 33.63313083213338, 33.82552600172127, 33.92430855772961, 33.817293798664885, 33.62910396643649, 33.78033492651899, 33.65984654098964, 33.74666391127787, 33.67016767305103, 33.97130925769643, 33.79161110077666, 33.75854328361337, 33.64856102718569, 33.46875713534359, 33.689158104194846, 33.74801733714575, 33.81031088669447, 33.65555793270093, 33.780393066791966, 33.81706525539819, 33.586768233137285, 33.71032659973798, 33.51709979522944, 33.64370371928145, 33.75843328250306, 33.67132522803518, 33.680809197392385, 33.86047344460408, 33.66118474785478, 33.945678647645494, 33.90895574479227, 33.564719667829316, 33.611937566126244, 33.619523437213125], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.1994857788085938, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "418025"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.61161326938607, "var": 0.012913534468664565, "samples": [33.68869530812145, 33.79953508243801, 33.70706304768284, 33.64856440740447, 33.612296316484674, 33.81534042334548, 33.41492091485896, 33.50205022355185, 33.678054280134525, 33.50906144318199, 33.650118616429815, 33.51818275472328, 33.66780181417263, 33.71682115938212, 33.55200949671473, 33.63612445319111, 33.67486315168613, 33.768215304693925, 33.793143129691785, 33.80789944802248, 33.55280536461367, 33.517839517923576, 33.56658649008047, 33.55946424249851, 33.612236068365604, 33.55288845135352, 33.55273363271105, 33.53313669208664, 33.70453825395338, 33.47534251236301, 33.534850243106625, 33.59397196059053, 33.452490013041725, 33.4785167695837, 33.62754021650016, 33.542040209919776, 33.641760360149945, 33.62554004664848, 33.44587049208998, 33.37535225029775, 33.66367952519441, 33.50116318392301, 33.698495137431834, 33.659712020235126, 33.86056010691392, 33.66489163541556, 33.413074075845635, 33.654447487087396, 33.610882303424596, 33.747493430041494], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.1659340858459473, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "85943"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.65359759596461, "var": 0.01655370629522375, "samples": [33.87735791965035, 33.82923759005705, 33.786172924870904, 33.698251038181745, 33.50839045435542, 33.845808341160364, 33.51579670390134, 33.73223888140579, 33.60425311337102, 33.47978095694736, 33.541554221976774, 33.844455130363514, 33.59164510565495, 33.45508776224041, 33.76871697300411, 33.69540443188294, 33.40254279039455, 33.548869044901735, 33.7453674027014, 33.64033810064864, 33.52541441554559, 33.93722824089073, 33.47651649801492, 33.61456437045771, 33.60380956046753, 33.8067898636545, 33.780685970271506, 33.682605831562526, 33.73857807850439, 33.530728713278876, 33.56894323418098, 33.56956082660762, 33.87871464992576, 33.75729209434918, 33.66162826821228, 33.5626836692173, 33.74740410101648, 33.54889008927088, 33.52655967570476, 33.549833519639996, 33.71485686702336, 33.62066375833089, 33.70534935167137, 33.64218776842937, 33.597008392181266, 33.73537364073053, 33.77265576542042, 33.674595117027316, 33.44533629969355, 33.59215227927865], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.185692310333252, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "807651"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.36854652324502, "var": 0.010704715586349585, "samples": [33.4015412142057, 33.24688125820553, 33.206964992684, 33.26426984961485, 33.33643485738184, 33.476838331008075, 33.319474357678274, 33.1031392621208, 33.33035738158325, 33.29372618407426, 33.44487478716488, 33.20880973461446, 33.541220397061, 33.408912458191985, 33.2883821166107, 33.30438410391087, 33.548503197972366, 33.40238962653845, 33.40688662781944, 33.42137076127718, 33.15980274312643, 33.44663392257925, 33.52340949784309, 33.527204138350044, 33.254302507449275, 33.317266488118506, 33.466388315954596, 33.29302415997883, 33.29477876566406, 33.565889532215884, 33.35686033413918, 33.35400651195142, 33.52773275722313, 33.277583210336545, 33.34212888317757, 33.30329603071523, 33.545237340118916, 33.377555141334945, 33.31766001139166, 33.42032868886475, 33.42044744840666, 33.327235590593546, 33.39074542450435, 33.352573331223944, 33.407972067062786, 33.366745672055586, 33.36086184535389, 33.42860719450457, 33.310377687532174, 33.43530942076234], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.166443347930908, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "174394"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.564882349267734, "var": 0.009932635487881245, "samples": [33.67307562198969, 33.55140059070894, 33.719024498271494, 33.77449799004966, 33.48637554728343, 33.568541798535996, 33.558086533779914, 33.72198367824159, 33.67153743618989, 33.720520357348136, 33.649073359546165, 33.51626464452241, 33.516713646119584, 33.609659755031075, 33.49769739900177, 33.33116094100312, 33.56668463672678, 33.68327897609385, 33.48576371813039, 33.5401953540858, 33.47370203157163, 33.61995926894219, 33.53552287467671, 33.53726800647557, 33.51833876759311, 33.53322764384638, 33.51310860320658, 33.485667272995435, 33.500318307625875, 33.541064733251055, 33.63410412298297, 33.626629476267794, 33.594576992534385, 33.430835609964014, 33.473217921004654, 33.43020139594701, 33.73411484346283, 33.59716190343252, 33.56212813720482, 33.78342601764728, 33.516180336356065, 33.52637761033997, 33.63928305221848, 33.495429284283276, 33.660432537833714, 33.53972387811739, 33.4131293864163, 33.407893821270825, 33.46035939500274, 33.61919774825561], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.339162826538086, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "719867"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.43377507101977, "var": 0.011260828270323597, "samples": [33.442775312539005, 33.55863151428946, 33.588871643008815, 33.41816695551086, 33.190933283329464, 33.39320281028885, 33.473881254713504, 33.481336636347024, 33.341094160931455, 33.425824041290625, 33.45384238788999, 33.499468871861026, 33.444656164329835, 33.43173890770853, 33.30084930134901, 33.398323581865974, 33.408237414659226, 33.30709557491326, 33.509299291791734, 33.54697828021569, 33.4293097318514, 33.360929849760396, 33.54795595996993, 33.630099870777904, 33.38401099478543, 33.38002456483296, 33.50037883091034, 33.30450715876498, 33.62959055012628, 33.44274153163186, 33.50097281962979, 33.50421684800286, 33.26597086193379, 33.4866600250455, 33.58649461519493, 33.35968217104726, 33.573450172614116, 33.52834835433405, 33.27221894626849, 33.22046531351695, 33.45121412057303, 33.46407192379898, 33.42470290296745, 33.458723005346705, 33.49297662098585, 33.208878141223565, 33.4344992838713, 33.26705896644226, 33.473234196866166, 33.49015782908076], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.166450023651123, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "816229"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.5887621878915, "var": 0.009731722994933073, "samples": [33.51657200293049, 33.53909469515861, 33.664427606015785, 33.53889778003883, 33.571560869090305, 33.438427015741475, 33.532033328152515, 33.53450068678805, 33.77719085612872, 33.70252733544103, 33.66579934417754, 33.539803867106016, 33.62616464969876, 33.40779442533215, 33.48724723649985, 33.57158007428079, 33.56124520064902, 33.59198929125769, 33.49629737909099, 33.58160625075218, 33.67313443920229, 33.651586822715686, 33.673478957393016, 33.65102629658976, 33.53346772948138, 33.63639748703275, 33.490316232919106, 33.38313582401941, 33.604646691255326, 33.68539157960009, 33.5812672459769, 33.6403980881494, 33.61619901344442, 33.513026458519114, 33.49447349526701, 33.673499555878585, 33.570611763861315, 33.69955038598591, 33.40988023356441, 33.643577647646275, 33.74599534560297, 33.43494268435907, 33.8682826136312, 33.64488956348661, 33.46298406066328, 33.66224209329021, 33.57823458607321, 33.67326726660322, 33.6184195506937, 33.579025787338615], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.116100311279297, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "804429"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.5589312224158, "var": 0.007916118181060847, "samples": [33.629374004087104, 33.67340432697197, 33.55587212922005, 33.62537715783741, 33.63325761958944, 33.428809364403726, 33.709465078081564, 33.54847378834005, 33.62665333010393, 33.59288384660078, 33.63997930871687, 33.56960920139266, 33.65802165355071, 33.5955610784188, 33.376912520144636, 33.566226762718095, 33.625503996862776, 33.47072047909519, 33.5545732248922, 33.63145173871218, 33.70354502311869, 33.571631322508054, 33.5115185151804, 33.518684922438375, 33.54721382359252, 33.551780586161335, 33.54971096631734, 33.47759949028108, 33.52460605771446, 33.40237178291271, 33.53366136030454, 33.47528049675416, 33.585121783164006, 33.55637899185994, 33.58454682049204, 33.52176262044552, 33.44519797419474, 33.633484474186446, 33.51523660940703, 33.4826388200339, 33.736736550705864, 33.55242166616947, 33.58651076299815, 33.29844494251308, 33.616886609197465, 33.70153501929574, 33.46023860015397, 33.62222397267272, 33.521041431239794, 33.44641851503635], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.253429651260376, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "49693"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.52428015769924, "var": 0.015097715334702834, "samples": [33.59344600679348, 33.529697798131956, 33.53352540460429, 33.60356567995387, 33.51284704999788, 33.65196605713889, 33.48419368507959, 33.46347517652738, 33.737958885868125, 33.405971836351384, 33.47377875275586, 33.52301405677461, 33.611416239598576, 33.61297828525223, 33.528450530056375, 33.64237008205646, 33.524086194495695, 33.64680832680171, 33.49347802060045, 33.492682061938204, 33.53606012233003, 33.41731425589491, 33.4688803032642, 33.81415079813418, 33.41978742814196, 33.62351411051077, 33.511446503531054, 33.51875828996138, 33.698609049923334, 33.2904850744571, 33.267059630532046, 33.573706071834884, 33.3029758958658, 33.35043059600112, 33.67147188226665, 33.47830830156538, 33.36648565420692, 33.522564152638466, 33.38364513018338, 33.5928055291662, 33.685454564467136, 33.469674740249474, 33.710271869760064, 33.601385741697776, 33.55756315841409, 33.30406603288218, 33.361448104473965, 33.666449448917575, 33.44334921205013, 33.54017610086271], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.1491031646728516, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "628695"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.594320580621044, "var": 0.009341585169517287, "samples": [33.732953771616856, 33.60262093870825, 33.660633208460965, 33.682656883734964, 33.58327300529048, 33.49134351411994, 33.398152131291816, 33.47448362045038, 33.54425308742544, 33.60714100901274, 33.4400643553082, 33.70957236552578, 33.57526869992211, 33.7545111049019, 33.56865019740904, 33.60551711388737, 33.437299142218436, 33.63777185676113, 33.567421178480004, 33.76765150020457, 33.680668869809246, 33.54777717046751, 33.67441380124645, 33.51111514252788, 33.66954537287968, 33.48993890732247, 33.560848195139606, 33.62264550783765, 33.70574552730843, 33.410994910085265, 33.780152387723994, 33.715355738501266, 33.47438637569479, 33.56159373344312, 33.58493095217183, 33.57785722576223, 33.4421424503622, 33.56606122578557, 33.61181704737445, 33.59920792187032, 33.648332651372584, 33.7562204464005, 33.713267148128814, 33.598237829310335, 33.584767334412746, 33.575820139627254, 33.52968580030122, 33.61779213184107, 33.47798847207854, 33.58547992953471], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.194429874420166, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "738844"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.36599705714891, "var": 0.011230591697165893, "samples": [33.180780682621126, 33.3089570410568, 33.56795145000315, 33.25775563711371, 33.50494435390191, 33.53158293612932, 33.39437646691998, 33.26541486969074, 33.349538928288716, 33.28746260372733, 33.49228415341221, 33.25745602271918, 33.1662102061954, 33.39848664343727, 33.57786995137437, 33.22310791732596, 33.498461814521505, 33.37844206292669, 33.52331623427022, 33.38571524150679, 33.510724863428685, 33.42128804569273, 33.48814068003414, 33.41442640060067, 33.44091261511816, 33.382098437527965, 33.465173862013934, 33.34687678525437, 33.364484559376606, 33.36673219527234, 33.234340362961234, 33.26806640957895, 33.33519254389533, 33.37315670268146, 33.175139371960725, 33.472747265641516, 33.3562821091057, 33.344083932460684, 33.416300456811754, 33.2555822794671, 33.32798781449065, 33.271548398660954, 33.25975736018645, 33.32377320428293, 33.43415645946607, 33.35362394908291, 33.189939516468435, 33.327666958464704, 33.467029639488985, 33.36250446082714], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.2055625915527344, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "951161"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.632491127952534, "var": 0.014777802613899507, "samples": [33.45256074119055, 33.53380830092831, 33.591231084985026, 33.75705216708497, 33.640069435618365, 33.63161692776733, 33.63783264053537, 33.83137169940801, 33.647022984608796, 33.52585670030065, 33.61328812878416, 33.61232084691863, 33.58513573961736, 33.85946265631903, 33.566310901634644, 33.617015297332735, 33.79462734687236, 33.724658708517886, 33.58644892898553, 33.708106167841315, 33.784283881106276, 33.565834664118945, 33.469145532508, 33.61989284612037, 33.26228939962381, 33.752459856906555, 33.69433096478673, 33.54449249335467, 33.45255473998133, 33.74025766608968, 33.643798565498784, 33.76291366197492, 33.71795924968703, 33.78875860174656, 33.58073455074845, 33.652006681751544, 33.631622422161556, 33.46873573127994, 33.602264836490946, 33.536067929780806, 33.55998507868402, 33.85187519672761, 33.68196438681078, 33.57106452360881, 33.75393288149404, 33.56993743341923, 33.54118678273991, 33.5395857989214, 33.509936898226876, 33.858885736026195], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.109606981277466, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "918750"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.37023669259997, "var": 0.016367761783188117, "samples": [33.11007917531977, 33.39806488953867, 33.41749257859812, 33.38385666223821, 33.33061015810034, 33.48958234845909, 33.629440991559115, 33.59422577534002, 33.48106078947195, 33.46896619264638, 33.199490083935395, 33.535465826831576, 33.33856996835981, 33.4686094098554, 33.155786381812106, 33.369210009829175, 33.39050146513108, 33.372643702330144, 33.42813011205035, 33.54822620377277, 33.34609427647552, 33.433028702563306, 33.18234993225135, 33.24500375280531, 33.39425909130216, 33.527200612465705, 33.43650359645263, 33.42027644515301, 33.3565977999922, 33.348130632565486, 33.5390061821816, 33.43491218392038, 33.45036449649872, 33.07864315027215, 33.33424476628772, 33.22318079773458, 33.35769672021517, 33.37528577089978, 33.45137408229828, 33.36664480851298, 33.42065636002713, 33.4087858724848, 33.39688477259755, 33.21446910214835, 33.22367553382794, 33.1540210548733, 33.2140955730198, 33.17360821423322, 33.36655603203052, 33.528271588728266], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.248870372772217, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "743735"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.572999277828046, "var": 0.008801601912788743, "samples": [33.62779210464063, 33.6818461697788, 33.359481936471994, 33.510834676458465, 33.520936127680734, 33.57831945840364, 33.563091068977464, 33.6299225754412, 33.528677068256705, 33.73252170622692, 33.73164586220453, 33.681232093205274, 33.38825395795726, 33.598876985997435, 33.54769880154122, 33.50702247316284, 33.61132831870287, 33.6040023313606, 33.65803664738522, 33.6365165576764, 33.596273281224555, 33.30028219039364, 33.5339453865072, 33.61544973486415, 33.574072153495045, 33.44106883633872, 33.55799381090253, 33.47277391336872, 33.58470486714712, 33.54705047997907, 33.59279316660613, 33.680770830905864, 33.7078768316182, 33.67802798127576, 33.54638016601396, 33.56984456748708, 33.736891774678966, 33.57212324937745, 33.59352632604311, 33.50855952073409, 33.56823217392135, 33.539832752420615, 33.68890285083529, 33.631951506306144, 33.44598241660021, 33.595212069094615, 33.61928376874528, 33.47205975859542, 33.45655595247431, 33.52350465191753], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.1630356311798096, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "74333"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.56348914885305, "var": 0.015042006701114665, "samples": [33.51663789170672, 33.79200020873729, 33.56359007515625, 33.499422165685836, 33.46853358892607, 33.36163985631828, 33.645149187641444, 33.58224397048285, 33.63415672955569, 33.66828621768325, 33.699996320811216, 33.42681735416674, 33.46656552644145, 33.605337390692966, 33.512396946487506, 33.5687894007919, 33.41359587648488, 33.49900894578765, 33.45635366864808, 33.358669547225695, 33.46206210776361, 33.54490763936719, 33.47201888812983, 33.416926279702516, 33.5204417132567, 33.2977724531933, 33.50429512859871, 33.48713485058526, 33.71833525458875, 33.649299742627186, 33.52554929592295, 33.5722462080162, 33.640965742992506, 33.62796999610445, 33.5969416332917, 33.46367067705988, 33.56320677687624, 33.52313784987651, 33.71504708731555, 33.58585758582481, 33.77762966371426, 33.48678902318271, 33.719012418814884, 33.62088036242935, 33.662519083779614, 33.54678622144012, 33.37678269158853, 33.80602218910532, 33.78676341698094, 33.764294591091485], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.1903975009918213, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "635162"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.39713116044712, "var": 0.009653366205532041, "samples": [33.519968977409434, 33.30034575277833, 33.453484366927334, 33.572861579541254, 33.42174732974542, 33.27922453077516, 33.32551275348639, 33.35542182124494, 33.26174108000997, 33.4037497197961, 33.448322996745375, 33.38505054109171, 33.53510716352569, 33.43634230462172, 33.424053032521044, 33.443440535983044, 33.368054916315785, 33.32148752885093, 33.30220684449406, 33.28115247438979, 33.28116530072994, 33.337426053726425, 33.28036450351297, 33.28372916761291, 33.38841233753282, 33.34211174014645, 33.48325237447399, 33.33297917872526, 33.48866382904075, 33.282321208438134, 33.26304053722026, 33.27816952199828, 33.50133245662922, 33.62096848278736, 33.32519292778558, 33.33182545894265, 33.43208667081927, 33.44272157313546, 33.4267765402475, 33.419475087852405, 33.35353890275551, 33.56546477054002, 33.41037746770223, 33.37931748205038, 33.595775758950886, 33.500372626858955, 33.51019817678327, 33.54183131829314, 33.27341001925223, 33.344980297558166], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.3584952354431152, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "344002"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.687519943481696, "var": 0.015026725931254013, "samples": [33.598004607265594, 33.67985215569314, 33.51786067548803, 33.732576627058286, 33.70452749413877, 33.906177595767964, 33.41715079012792, 33.87806328339213, 33.557741412667156, 33.64779613102851, 33.72363873897488, 33.46101081323398, 33.879407684517815, 33.708489801026765, 33.54888246937343, 33.698186377757025, 33.80136305131923, 33.5900620932423, 33.73024103512016, 33.84873775848671, 33.836956718269775, 33.68587799067428, 33.620031311192676, 33.69483110528032, 33.668651937257025, 33.92307153628386, 33.64387536727267, 33.65086772644159, 33.709580217228286, 33.72790418391974, 33.85455067286902, 33.82356382047335, 33.6371832088887, 33.823710844074995, 33.48172754044457, 33.627939272087204, 33.61043726503258, 33.77419415671738, 33.583363219834375, 33.731900321984675, 33.786649965842614, 33.566464724300374, 33.70527560329384, 33.471141871003816, 33.651515579540636, 33.76441451776657, 33.562404317220725, 33.66845082454479, 33.596091196482114, 33.86359956218247], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.249608278274536, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "95626"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.555907218358776, "var": 0.01282834059490143, "samples": [33.55070300210117, 33.522761903495706, 33.77024294473773, 33.51224637452278, 33.569139543656604, 33.275386913576604, 33.61303273762335, 33.42602545413364, 33.48670157573691, 33.443022238069126, 33.614508663036645, 33.72480256905084, 33.58002685165376, 33.48428664733896, 33.51489458590326, 33.64633219202629, 33.448178092977706, 33.68720905374277, 33.540014911319034, 33.65305030425046, 33.419461490255884, 33.413604333569445, 33.613966168231, 33.48565796830262, 33.465258096380985, 33.527259742003984, 33.788279968848734, 33.46007301044377, 33.524702794954024, 33.509367359076734, 33.60581426600949, 33.74992006805405, 33.57536944964361, 33.340585164369095, 33.526493707535046, 33.30006524275241, 33.641850844512696, 33.69555308753726, 33.53810612504204, 33.6342207848788, 33.51539505283348, 33.514352816798684, 33.6416296708078, 33.750285096542726, 33.575591519189274, 33.606136032929406, 33.581741698026896, 33.58438946325581, 33.488902795842854, 33.658760540356624], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.1755311489105225, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "685345"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.46302163670859, "var": 0.010622177079662908, "samples": [33.311893013946325, 33.39794965682224, 33.3482386091724, 33.538637471879106, 33.479470014401464, 33.37702808902441, 33.5981893578325, 33.47836286261239, 33.34585659746749, 33.40135101339535, 33.25314452253829, 33.28525422331089, 33.39653171023531, 33.6350461197471, 33.61656578130982, 33.6308740748993, 33.458101345348766, 33.531382828424185, 33.35832350743464, 33.573139328242156, 33.44687205677573, 33.43995616850288, 33.58994359993888, 33.5804018133029, 33.40403938910653, 33.579076330462705, 33.35098963327446, 33.455683373910304, 33.49281119031399, 33.410410970102824, 33.415176775535315, 33.257232165302945, 33.400630281601615, 33.41192009468945, 33.52221842033401, 33.62434489254061, 33.51477566537371, 33.60995555286969, 33.434944518568386, 33.4653613350624, 33.45950506545805, 33.36291679284614, 33.48862685613388, 33.564750746817936, 33.585733234497184, 33.31454761972992, 33.397658136368804, 33.517022053948295, 33.505428851822714, 33.53280812219339], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.303856372833252, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "987047"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.672744273654196, "var": 0.007864387631286841, "samples": [33.70390646536954, 33.68990727507332, 33.67615386942249, 33.59013887140369, 33.71416043574573, 33.77987630243225, 33.825829512359604, 33.639727482579175, 33.71039003357353, 33.69880579223423, 33.5374556700921, 33.76262148639988, 33.574260251115625, 33.574002627529644, 33.62123931570793, 33.4839091523212, 33.622323329341114, 33.57849620329149, 33.695928197959695, 33.45363377314362, 33.74722563101547, 33.76566935917757, 33.59005203809586, 33.62996496879542, 33.87342374496953, 33.72469127216582, 33.76551194498148, 33.747257551667126, 33.75294843514748, 33.8541135692314, 33.64410032367893, 33.675138746407725, 33.62478356169812, 33.74645511851885, 33.59437348554964, 33.76857523157499, 33.62816991868384, 33.60965998146274, 33.651788131123844, 33.58494505498181, 33.701547920444966, 33.58905444158652, 33.77936529177911, 33.6836739535115, 33.56035818803437, 33.675775337109854, 33.64212677544507, 33.69279618158879, 33.72478434915063, 33.676117128035635], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.3089334964752197, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "399069"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.53666875190649, "var": 0.010933659421022217, "samples": [33.44950590268223, 33.48958903657178, 33.64158032193507, 33.505036751904996, 33.78912110400381, 33.51608350470858, 33.67797965668381, 33.51026457494991, 33.577554142299654, 33.51666599382599, 33.74299300419795, 33.46885398588658, 33.60372567104069, 33.466078690659316, 33.461067720032986, 33.708279194457276, 33.5498124187395, 33.501555029144825, 33.603609126515984, 33.56559390454499, 33.730490814431334, 33.59913855034208, 33.49145262865928, 33.65047598386301, 33.35523726572684, 33.553645884552346, 33.38731006243176, 33.289581082496106, 33.36656043377747, 33.485935424209984, 33.57614208068425, 33.46123603856412, 33.50263756862695, 33.51142509862105, 33.693664937420806, 33.495324637877665, 33.579245211011845, 33.38717478048924, 33.58274270261303, 33.61708407642546, 33.505903680974356, 33.6615412552206, 33.54504006454219, 33.50674643056183, 33.59969880716609, 33.44568600405368, 33.494353731224365, 33.38764732654705, 33.53388664168769, 33.49147865573603], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.136169195175171, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "427981"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.57974825064223, "var": 0.011733663830586341, "samples": [33.59184042612079, 33.59479681796876, 33.55684404115499, 33.59382204334488, 33.68010756633349, 33.52437952090045, 33.59902719853229, 33.3820643602155, 33.383763497795876, 33.631515218787676, 33.68415937854138, 33.644445359555014, 33.36768231239483, 33.477262377380455, 33.305152103752725, 33.53476213040685, 33.59771641826937, 33.545245794662314, 33.65512080418715, 33.423359990861535, 33.508628494281695, 33.49216131209622, 33.51673641535868, 33.50578114112869, 33.79619691462041, 33.51311484979559, 33.5906732044971, 33.6279429451642, 33.468814273506766, 33.47935914538533, 33.66486534150955, 33.67258301677013, 33.66329239326056, 33.62195318285551, 33.57491652806785, 33.71567543978641, 33.4686963561408, 33.682382109262406, 33.738196389229344, 33.44997453404562, 33.63141755556765, 33.6779275203063, 33.75673804583776, 33.661252227654394, 33.566755457794464, 33.59234607898378, 33.52463502697498, 33.63145369426807, 33.66468156087378, 33.75519401592109], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.22039794921875, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "200829"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.675710071504064, "var": 0.014946646152408732, "samples": [33.572843854833835, 33.42942893039551, 33.761603548145445, 33.792526956594486, 33.797306092596216, 33.761224441896054, 33.69648610901082, 33.51784520244583, 33.84139169096713, 33.54763345525247, 33.652140329434154, 33.6836440520528, 33.24030247224595, 33.55089221534865, 33.658362996118086, 33.67575676602183, 33.730942820889304, 33.63079317421773, 33.6309923033951, 33.60812575797973, 33.77545363804781, 33.795314167772, 33.50751620401589, 33.7626336728437, 33.68031972983836, 33.61720112307322, 33.69663966424401, 33.60432645481176, 33.80310040245716, 33.802399397981205, 33.77508129315555, 33.85248485335601, 33.7158851906329, 33.696734645548126, 33.6554825975674, 33.7380375320225, 33.52698176536392, 33.646589650836646, 33.87526537184614, 33.641405523350954, 33.581993727473105, 33.87367047042004, 33.730284198855195, 33.8002445572118, 33.5198365888006, 33.669264610992535, 33.7578933317717, 33.72753982276869, 33.551571448091146, 33.62410877021201], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.1832263469696045, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "659534"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.73264348672417, "var": 0.009260173225765347, "samples": [33.850127550518025, 33.73879617576753, 33.68535799610088, 33.717510367086014, 33.74592760404895, 33.62440728357351, 33.75826916466298, 33.86115099457862, 33.68149767276, 33.639590350401726, 33.64879295629324, 33.74317826561855, 33.89013937293115, 33.92114417084605, 33.66916988851502, 33.6559787854617, 33.73184465224095, 33.77118571047947, 33.5927795179176, 33.56846894329049, 33.64593400030811, 33.69602816905218, 33.84556010405186, 33.7507430009134, 33.59788005933573, 33.824206080184645, 33.768670115893435, 33.73110187481684, 33.73281635961884, 33.68911791029813, 33.58238826733119, 33.7121923997012, 33.66037661990518, 33.57007401259844, 33.86303518498375, 33.717732599657765, 33.78297908859184, 33.75238590747428, 33.9690242873571, 33.86796471628222, 33.614194856167096, 33.72685844619227, 33.771303674476066, 33.76362686555343, 33.5646124110136, 33.72271106634689, 33.815854722490094, 33.85556421745826, 33.74606573714049, 33.795854157922065], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.105017900466919, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "895253"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.377281313174066, "var": 0.013702566507128368, "samples": [33.347092989790504, 33.44739454081902, 33.2023494176401, 33.299797967151896, 33.23514840858079, 33.29161060562144, 33.577662100069055, 33.38816164103728, 33.48339794465339, 33.42454902102019, 33.49011400045474, 33.34016055285278, 33.54738302634631, 33.31459131412038, 33.25379070527961, 33.48761175510584, 33.37748148418868, 33.45144185222436, 33.300823980573504, 33.40123912340336, 33.406628162048946, 33.365134794513615, 33.221875242619866, 33.27369604529499, 33.52855968613775, 33.35399825596395, 33.404226668807276, 33.14974970838091, 33.551948613073016, 33.38193223487405, 33.32919774908013, 33.37163769034492, 33.38195057624684, 33.3004419710372, 33.41641280428666, 33.16377438025525, 33.545627683431896, 33.70037469358367, 33.510668277173735, 33.43488799985856, 33.25641705735519, 33.39406585496994, 33.23209503941783, 33.455612978701275, 33.42737012688676, 33.29135753689042, 33.381533393817534, 33.388878866860864, 33.43738809166107, 33.14482104419584], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.273768186569214, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "685629"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.52044278584498, "var": 0.012243908197474613, "samples": [33.500541202895675, 33.37265606604632, 33.65387927709634, 33.536556952634626, 33.635648131628436, 33.478246481285126, 33.57707222781185, 33.47403030572422, 33.685092847513715, 33.52677418630731, 33.523686358123285, 33.313316390042246, 33.5589335720023, 33.600815728858564, 33.59909023779439, 33.48746706484185, 33.451418627095705, 33.56486662977311, 33.43547530757397, 33.687980098932606, 33.560120030509914, 33.56231069381648, 33.52479505702703, 33.554939933897, 33.43743832408176, 33.55032038474494, 33.69714149663796, 33.39724204099435, 33.55075716104151, 33.63975196492884, 33.479626902043506, 33.66446741558277, 33.368173241936965, 33.314960052160124, 33.416823395277035, 33.55167285595104, 33.341599358396074, 33.65951344845047, 33.471230756197095, 33.498198442979316, 33.37176745840323, 33.36081992414328, 33.62610541768812, 33.46210343711276, 33.55197616705329, 33.56184487082277, 33.59507570764573, 33.80303161643363, 33.41696020409571, 33.367823838214434], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.3162150382995605, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "648602"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.50855417571804, "var": 0.010107634845269388, "samples": [33.683092708167, 33.63314121557306, 33.370562845451495, 33.45295581608253, 33.2985540289388, 33.59449991141583, 33.63827897501388, 33.551505101925606, 33.495643626892, 33.6468052430251, 33.5058922530168, 33.44834411257814, 33.486199188697356, 33.55072756603034, 33.548306894469775, 33.53872316669723, 33.45988510395663, 33.479496191064456, 33.5247753659376, 33.34406070628058, 33.532291677915595, 33.50225480733039, 33.63022900608825, 33.612603600331454, 33.36564167606658, 33.59267976359261, 33.44233760973097, 33.54563133699027, 33.53390193113972, 33.41672635873403, 33.37733838081692, 33.4470749568023, 33.43976606786368, 33.395993037294446, 33.36309956928146, 33.52884173630073, 33.39558516638435, 33.676806904722625, 33.56173390513677, 33.53244927788841, 33.5047696708717, 33.539176981163955, 33.50858379602654, 33.4666772328246, 33.66810323240827, 33.49192752791431, 33.703053038716796, 33.46804743586803, 33.30166133300654, 33.63127174547562], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.22151517868042, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "409243"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.54890927367077, "var": 0.010898657777195741, "samples": [33.625652859762674, 33.55780872269709, 33.513137410727104, 33.47042043952915, 33.50671826149336, 33.64637181627956, 33.44134062712084, 33.653900234908136, 33.54994035866207, 33.46684047489018, 33.667009473155616, 33.38609423071184, 33.586269000164386, 33.57807244022328, 33.369267113404234, 33.519559350287814, 33.55376078475441, 33.52314417954265, 33.395589204956615, 33.752599984549235, 33.43142643625126, 33.671970316124835, 33.57128565787419, 33.6021039683078, 33.45288390374852, 33.397857823811655, 33.63028876255371, 33.36042137254205, 33.40041173709297, 33.52825834429176, 33.64853476212205, 33.4231802380975, 33.57240407549464, 33.455346885130034, 33.527322794688466, 33.434160032235454, 33.532263672060616, 33.580335222844504, 33.6041129464077, 33.51804902732868, 33.722000809995535, 33.649169763690736, 33.571274506041696, 33.67815204743666, 33.59419084911575, 33.56151774524881, 33.575148238920896, 33.5926747598655, 33.854713780039184, 33.54050623635523], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.1493945121765137, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "801181"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.69930215744711, "var": 0.012148661132533529, "samples": [33.62151214041395, 33.46278314166588, 33.70118349434067, 33.48313800330205, 33.67771771601285, 33.65707019862711, 33.592614448105586, 33.73912228582514, 33.799496352033294, 33.624184380264, 33.832478443723836, 33.66079768064746, 33.699092042938176, 33.80005119508986, 33.65699172955437, 33.756852120039376, 33.70504667517587, 33.643189485037794, 33.896683762382935, 33.734969179376456, 33.72502931406144, 33.52935104463065, 33.685965793011626, 33.75437973362142, 33.63364464560538, 33.65915685859992, 33.60723929183423, 33.54824632966422, 33.8601576891192, 33.695471553239315, 33.73968364996491, 33.616323477631695, 33.708848839401576, 33.90132331784706, 33.55919590256993, 33.806162591490576, 33.93917285641713, 33.75341909812263, 33.83381772452187, 33.80907384520917, 33.598517786803086, 33.69892824525669, 33.647030282932285, 33.95025196868492, 33.570669695609375, 33.74876138886494, 33.70807707361496, 33.614432285463685, 33.606776079695166, 33.71102503430974], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.2272515296936035, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "182369"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.777890077205804, "var": 0.009193075682603531, "samples": [33.68298574886522, 33.77054115861282, 33.90381428713381, 33.74875305945925, 33.83961933128154, 33.90114819700435, 33.68368077490708, 33.667559920396585, 33.71243287764731, 33.973462492227945, 33.94261793272991, 33.84963509968408, 33.76340869093961, 33.57788028972141, 33.81856780735756, 33.67643626664024, 33.828358181498025, 33.7801371932685, 33.761713873841934, 33.68360003389232, 33.687343272669956, 33.78648275103943, 33.66135586777369, 33.73425715932869, 33.7354698977177, 33.71107367252726, 33.92227868490674, 33.6507897343835, 33.827498296635824, 33.85934704803687, 33.77185757293736, 34.08766262014372, 33.84433097315099, 33.69721029128811, 33.76665254190973, 33.71759595592064, 33.77914807403131, 33.71574424889337, 33.729169309941675, 33.88239921986033, 33.75279389130567, 33.700026457546876, 33.909708306603015, 33.703703832969495, 33.7807422554394, 33.85244662591361, 33.79256216401828, 33.814892320174664, 33.721381796281875, 33.73222579983094], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.176400899887085, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "891665"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.70110106482747, "var": 0.012047188785369587, "samples": [33.70488632799711, 33.73914514502429, 33.80095691605478, 33.550480836286745, 33.5975381773485, 33.85317979516118, 33.88351753398723, 33.54475998340331, 33.796819565936204, 33.54175232489479, 33.51692107098403, 33.94501863859551, 33.79145980202805, 33.61741996419383, 33.58967279511052, 33.41132506794023, 33.80895614866932, 33.79850319418593, 33.73379448931146, 33.67646428739428, 33.69248791471218, 33.624634964578334, 33.65923233055634, 33.77437977947114, 33.80050686341512, 33.73171044996144, 33.606431762805634, 33.60469936165058, 33.709915574843365, 33.62188916697838, 33.74959165081837, 33.72800146665061, 33.87013596299496, 33.775040483387805, 33.77694529766873, 33.62668602154645, 33.583309364508196, 33.82470577297373, 33.870942485228056, 33.69865709823584, 33.641386161295415, 33.59107545645387, 33.70948648690903, 33.75834387452837, 33.741891875146344, 33.708541707982164, 33.6766752052218, 33.724467624682234, 33.72726269954779, 33.54344631211376], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.1135637760162354, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "73602"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.5658508402051, "var": 0.01224611668911201, "samples": [33.54273219318862, 33.64459777818239, 33.60593020059779, 33.69593347204339, 33.585035774947585, 33.541361885337274, 33.54748028100975, 33.700997765823814, 33.42288899369441, 33.30421119108096, 33.653685638693844, 33.61015944524287, 33.681117967673394, 33.50295729523852, 33.82069665621426, 33.621903891688014, 33.4030793005815, 33.588075394443564, 33.468183933639104, 33.3953841815145, 33.409176072498205, 33.44475708854688, 33.63164546277998, 33.42512522944525, 33.706048285077834, 33.7258020975618, 33.51716284184938, 33.64074423589684, 33.59897957310816, 33.62355228240869, 33.650296134698465, 33.66766699402834, 33.55378844686162, 33.44512515486625, 33.48393534728261, 33.53085942820152, 33.686413242111335, 33.682715233518294, 33.37626076266617, 33.54205240866228, 33.496000710570314, 33.54084499924011, 33.403806507296956, 33.67583215897427, 33.61403207343725, 33.51564933469194, 33.516395205714545, 33.64039817896935, 33.70563271255642, 33.50543056589864], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.2294602394104004, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "557220"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.71782388197295, "var": 0.01583040430592033, "samples": [33.70438613454978, 33.78578474290988, 33.687445415826055, 33.850119139744415, 33.70880292733344, 33.97306127094982, 33.497313098243566, 33.58050119158489, 33.742798502580904, 33.73260494220901, 33.66659256770129, 33.507480621410366, 33.96838990109367, 33.73025785280056, 33.68123422391037, 33.56718892849781, 33.74596865862674, 33.7034052751945, 33.78542652912223, 33.893411904684996, 33.64173042845725, 33.780598273993526, 33.6023957347164, 33.7130038018726, 33.59239274203311, 33.81152285808928, 33.92115678434623, 33.80337706903983, 33.55415179903255, 33.69606409588624, 33.7527767661399, 33.72000550910253, 33.39366630979214, 33.735613457144495, 33.86965096334145, 33.84959278481014, 33.77408993291259, 33.82159760868414, 33.685250763320234, 33.61145358654223, 33.85361424247733, 33.81589273003984, 33.618071115001676, 33.5327598661338, 33.71016025103969, 33.525624633576626, 33.75916230427817, 33.87334590603569, 33.59701120310349, 33.76328674872946], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.2185592651367188, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "916622"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.56415743112221, "var": 0.008528793528763701, "samples": [33.46255478643606, 33.5905833441803, 33.46452022066812, 33.5879942832293, 33.563592195550484, 33.53902647264491, 33.544521213367155, 33.54567644673238, 33.52011539878608, 33.49747368142192, 33.645409748122546, 33.588249063246, 33.49902937092799, 33.6632153003074, 33.740672182900724, 33.457239325120554, 33.58662215608168, 33.619005174650226, 33.45342219437782, 33.547299433320326, 33.47986083680389, 33.54282408516806, 33.694918775357834, 33.65405888782288, 33.51264590895104, 33.41381916774121, 33.5929192142407, 33.65618548102553, 33.38061327850224, 33.44006157331051, 33.625148509650145, 33.467570602335776, 33.664183558230725, 33.60492557732577, 33.53599378449403, 33.71408526176037, 33.47590797075841, 33.506471050654035, 33.650744263129035, 33.460490899385576, 33.61756879339491, 33.68617591133546, 33.42353924906411, 33.572100206569665, 33.693904105129825, 33.562126969746906, 33.73429868460445, 33.700557870257825, 33.45061632738589, 33.57733275990192], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.2099530696868896, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "859119"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.47210366370177, "var": 0.012877147414004541, "samples": [33.3358580823334, 33.55331978945551, 33.670928808343604, 33.493472266963316, 33.63634947101579, 33.39503052731929, 33.44878511068219, 33.411329428644024, 33.42708888558024, 33.29348075526398, 33.37099419775221, 33.429216368705326, 33.582608789695584, 33.63665647341715, 33.326235083421366, 33.45519587273809, 33.25406332562604, 33.63447852257324, 33.38611615425701, 33.31980125026216, 33.54565988023676, 33.56177423310412, 33.48618459540802, 33.33232970725952, 33.40482429963194, 33.524153278169194, 33.48491095733645, 33.37106278266877, 33.484613521144134, 33.55402369482013, 33.562825692625275, 33.26756529787015, 33.516821144859776, 33.48911358131479, 33.622912731870194, 33.56843344823815, 33.37598759637098, 33.54653022089233, 33.36075381092633, 33.600484806725106, 33.38291178941241, 33.6893739502091, 33.4628044878025, 33.43865032163645, 33.48641259820673, 33.474316871832386, 33.60730546436196, 33.287265480519544, 33.61810129274402, 33.436066482841824], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.2224910259246826, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "6099"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.50612866433438, "var": 0.01763483739933334, "samples": [33.38334190814046, 33.37811189730282, 33.54397796638413, 33.40421583608906, 33.682893296830684, 33.631100274936024, 33.38798902247244, 33.62513016720733, 33.432388256973674, 33.667265569836765, 33.401198235898995, 33.62091886878524, 33.63906581862996, 33.26274977573342, 33.61907254976302, 33.409915330271176, 33.48787770948697, 33.60138004101368, 33.55341565276798, 33.40838010786078, 33.44051479104443, 33.81183886413216, 33.42734247910718, 33.701195571981344, 33.44732914487449, 33.54090922745256, 33.53606972349952, 33.32823647545538, 33.43461697348996, 33.40506285243307, 33.37285121455949, 33.76913849714014, 33.44182705631792, 33.35871609930119, 33.52576275999818, 33.39009956655774, 33.57148877655754, 33.52248277357384, 33.59336548455022, 33.40306352830997, 33.271773041958205, 33.69940364822942, 33.47562234044161, 33.483922566031175, 33.48736571439746, 33.62534515747577, 33.76303495702458, 33.29831632453999, 33.45512373724175, 33.58422558265809], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.127387046813965, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "770794"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.509110139704795, "var": 0.008936435253639869, "samples": [33.60822317168612, 33.55346089277073, 33.527278225810576, 33.39218331067976, 33.6741185829094, 33.6536705681426, 33.444921414165385, 33.516785290915976, 33.4750106338629, 33.46899949040382, 33.53807592823608, 33.54397090401272, 33.44289410114881, 33.60035054503405, 33.58399810169318, 33.472719326490754, 33.46907426021533, 33.61346392064713, 33.39083302032039, 33.543644386264184, 33.35816910338826, 33.547529442608806, 33.40524155519003, 33.72490278599465, 33.511457029899425, 33.41761577753659, 33.37536037723057, 33.5200659282574, 33.41438836350873, 33.461877422807525, 33.51422607620637, 33.69866911589832, 33.62103497281487, 33.46783161872021, 33.44380920609413, 33.419376406219854, 33.442226592363944, 33.43667657138824, 33.49441450795979, 33.633594274433385, 33.54237348382745, 33.35706057184145, 33.62077083278488, 33.488427484030325, 33.56709682034712, 33.62886682143669, 33.3686809694366, 33.48782912018094, 33.596693451416975, 33.37556422600621], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.2995362281799316, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "175595"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.61523388728826, "var": 0.013363424772105217, "samples": [33.45238243657997, 33.59199665244741, 33.63918122307742, 33.679697122585914, 33.47366266446835, 33.658888820224035, 33.68526163797361, 33.70102681257603, 33.81293662678485, 33.679949259766815, 33.51242340186272, 33.50950015356795, 33.74365253264782, 33.7647019442595, 33.67277444864718, 33.565764327423956, 33.4741294781928, 33.610364892799105, 33.647458749119444, 33.56380530476812, 33.58355303328812, 33.3564356799956, 33.719591694410305, 33.54500775638088, 33.416570908809604, 33.70844941376484, 33.565745684627665, 33.61998191473037, 33.5541782437808, 33.832195282683735, 33.92548252040462, 33.75989949486035, 33.404436162018314, 33.60912959155298, 33.64613581987067, 33.61937050322205, 33.58143650011537, 33.55420873554356, 33.45812471684615, 33.52612417381643, 33.52051004515821, 33.64457892124822, 33.75948073985869, 33.636081329835065, 33.714106671322575, 33.51143147890906, 33.73058648986937, 33.55280440328037, 33.613919482317684, 33.65257848211841], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.132800579071045, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "413126"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.60448164813184, "var": 0.012790649733512427, "samples": [33.67147476438351, 33.479457621889885, 33.57068352388883, 33.59197515057466, 33.6375230297255, 33.82373736748978, 33.56279762285895, 33.426958464079554, 33.68118043455803, 33.60093952044068, 33.616154688523295, 33.71178458415819, 33.671875676855265, 33.566188343064304, 33.74369551264694, 33.408589702560306, 33.64510510638028, 33.71736382789355, 33.68832015414519, 33.60742301940094, 33.65572403282213, 33.6529891713523, 33.545692505185194, 33.68879224111058, 33.614347668648136, 33.76533458661896, 33.72675148001907, 33.51514324079382, 33.45544915792183, 33.46554119220147, 33.46410296822987, 33.67702857985049, 33.33327045699184, 33.460789258750225, 33.69679614950003, 33.45541521274125, 33.58064531067109, 33.51004822016776, 33.71463391071803, 33.58425853219128, 33.481706500941826, 33.60161885842735, 33.797676178238305, 33.644584957702854, 33.59032613577575, 33.84932614674915, 33.627748204061604, 33.4400028710653, 33.61835953681465, 33.58675102481231], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.2471039295196533, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "361254"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.58628728485141, "var": 0.013249635935976247, "samples": [33.49437585474981, 33.65194276918643, 33.49252288101485, 33.60983639720102, 33.70236997239463, 33.79051254967545, 33.518151116705276, 33.54699763646919, 33.54722376583712, 33.59583077841073, 33.55596717334878, 33.50293044045019, 33.428357176820484, 33.51497697302067, 33.62373435398535, 33.46388432708861, 33.464957333426206, 33.47537271212057, 33.764010524807716, 33.812614808561385, 33.66290119216948, 33.49396319069459, 33.693150337954634, 33.62458623194997, 33.5258530570167, 33.72207525633903, 33.56688427802135, 33.5278766220324, 33.50848481556842, 33.706325565653046, 33.82505486260543, 33.43136911810447, 33.47889880705783, 33.41366958111331, 33.6301857464743, 33.47891876518813, 33.73511028691108, 33.64020293929281, 33.55410322114305, 33.8204134596792, 33.72014735870551, 33.63516437042485, 33.59197353706982, 33.50032772475574, 33.579419784028715, 33.34468338225052, 33.587237278681044, 33.51579937750548, 33.53176084514722, 33.711253703758], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.199371099472046, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "30483"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.61634598631903, "var": 0.011252885533680609, "samples": [33.61795592649155, 33.5858334088444, 33.62713609626665, 33.4985928595166, 33.577369667006195, 33.53394833791899, 33.8089751723287, 33.624012526730624, 33.4461989514598, 33.56602160697632, 33.699789036624864, 33.58128149513657, 33.55104486168383, 33.832747509989765, 33.620194676192064, 33.705312333681, 33.7025023368321, 33.731902796027235, 33.54271405737135, 33.41323168340491, 33.51219050437012, 33.601696299566726, 33.584952477772134, 33.64526799584725, 33.4792854405358, 33.62845351117621, 33.600238231808774, 33.63650607758448, 33.669682283341906, 33.54895608464811, 33.78785373217543, 33.867851369396575, 33.69009538095222, 33.724309162088716, 33.688466886234764, 33.57259015157892, 33.499919025235336, 33.5307035564617, 33.73569407333534, 33.41855356278251, 33.53845753936035, 33.69661096549588, 33.50736120569685, 33.61770045321959, 33.64923348477073, 33.46876821299096, 33.78086659369419, 33.55661283811374, 33.57569607453262, 33.735960800699864], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.201227903366089, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "732295"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.58588238163591, "var": 0.009953320603539312, "samples": [33.58318828256711, 33.58743158586958, 33.549051388013666, 33.63768666620316, 33.625837325770256, 33.635340305054406, 33.51527488379287, 33.60177702237691, 33.55694139252871, 33.42239377760683, 33.63171874032823, 33.601763201689614, 33.835268886559376, 33.58133226048062, 33.497712964233386, 33.49755805632452, 33.77124007810407, 33.57864355618972, 33.54641328464489, 33.55449041051598, 33.551545738660664, 33.6263496918283, 33.4512842577937, 33.58581255911352, 33.6430100493328, 33.705615552611064, 33.542942550976264, 33.37345309946648, 33.58062678943247, 33.65396446630574, 33.575233758414974, 33.515514767604785, 33.6622387818067, 33.63002335384319, 33.59143562071914, 33.707402057691716, 33.68158508741408, 33.5712392666955, 33.72580619242863, 33.37927269168811, 33.61267834973065, 33.474278207006755, 33.579643697573694, 33.60456395007228, 33.59866384353144, 33.59736694654263, 33.8178722783833, 33.59127934678586, 33.32235840736499, 33.52999365212213], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.1100902557373047, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "317865"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.57665878859972, "var": 0.014284841142643803, "samples": [33.419768072059995, 33.57162725025537, 33.604799185849714, 33.60990176245392, 33.66086797448159, 33.36763718784972, 33.70878252056394, 33.700439102484616, 33.56003134950352, 33.502527005139356, 33.518569039064346, 33.552778200210426, 33.71178333772456, 33.4647495191055, 33.868183563172245, 33.474159776287586, 33.510404324532885, 33.61175757826532, 33.55595294494012, 33.64455919751037, 33.503193663772976, 33.39066299760785, 33.48269045057318, 33.61417249462454, 33.61675454493508, 33.68059790306101, 33.74923074518069, 33.511284522056066, 33.52066584517154, 33.67431549999839, 33.45055117412674, 33.62858815138817, 33.563260342541454, 33.715045028096455, 33.69793070835418, 33.826350830753064, 33.67004748018658, 33.56717785296875, 33.56667817741855, 33.49827333999322, 33.55917343955987, 33.48279689315276, 33.5203855083501, 33.75443554946762, 33.59649370214983, 33.43167437274243, 33.59603863843966, 33.20608453204759, 33.550840360659954, 33.588265789152835], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.1169538497924805, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "926799"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.47117664700104, "var": 0.006544339862158495, "samples": [33.44206061221182, 33.49177660968849, 33.4312811074558, 33.46639054981832, 33.3446129483705, 33.47312809375831, 33.4767086732723, 33.392330781213225, 33.64983052412053, 33.53773213021366, 33.569399297608776, 33.35474869111464, 33.40129881693558, 33.43425399305421, 33.52211667255973, 33.36214931539557, 33.51464080050128, 33.39736947249435, 33.45081381180481, 33.447802507510836, 33.545747079620604, 33.505370521673974, 33.60882980019131, 33.4104721782125, 33.47931728162378, 33.46832426169778, 33.37871303184087, 33.56112876550526, 33.54823665389648, 33.564735201001206, 33.55501730717845, 33.22870622240624, 33.50147575054415, 33.474436709856285, 33.44027946300071, 33.5034182620953, 33.62060253301375, 33.5473357150749, 33.45680271041342, 33.46179654926034, 33.548077348643645, 33.34909059088603, 33.36343268687514, 33.47885524234328, 33.40595094865818, 33.54460854248987, 33.428644188842796, 33.530996141464215, 33.445641880090115, 33.44234337254867], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.2825958728790283, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "565617"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.669989972367695, "var": 0.009590268081807093, "samples": [33.73352211952862, 33.72347931615794, 33.85454962134699, 33.73761591668692, 33.585809306006546, 33.57191492384869, 33.51054023235231, 33.641179178423826, 33.56959655114016, 33.76302132615562, 33.748538459050586, 33.633830013437695, 33.500070452023856, 33.76602328413799, 33.632791461561276, 33.65614287735934, 33.66869117100076, 33.73195937297223, 33.60091091697768, 33.73619696838672, 33.58831429555275, 33.54103164143887, 33.74710882931953, 33.78407214618147, 33.81207506398815, 33.607435132690135, 33.644642797124106, 33.80989144718161, 33.60193000403995, 33.52888203632947, 33.692827861425755, 33.65162098544211, 33.80092981636435, 33.72346862557963, 33.63121612506371, 33.58706504557036, 33.50676797753075, 33.54893875776544, 33.78322005352155, 33.56336653162547, 33.7248669515968, 33.5366701780357, 33.58100097545181, 33.59369203473743, 33.81847696749671, 33.71999633664471, 33.79586106811264, 33.79454000650186, 33.748958904053254, 33.66424655346322], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.1570115089416504, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "310121"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.61684612579358, "var": 0.012084719276969184, "samples": [33.587355896464615, 33.499930419372774, 33.6719463375651, 33.43101822774085, 33.74486705865875, 33.64484894689534, 33.452509370222025, 33.56411557252922, 33.78776427477403, 33.67461108722751, 33.563123031355225, 33.65852699535914, 33.38859661911574, 33.765924156606786, 33.651629072719636, 33.63743181249623, 33.562437653898435, 33.75729743171881, 33.64820188224452, 33.68300809647349, 33.68253911644579, 33.58252007307316, 33.719649374141945, 33.72489131505181, 33.61554720369632, 33.3851269811201, 33.642783753456634, 33.56844435936277, 33.565403979769094, 33.64094922537018, 33.39875206341606, 33.570466152429866, 33.62596750047612, 33.735814023024034, 33.535167962426364, 33.7795986635314, 33.54807889406775, 33.583199496879466, 33.91755050787655, 33.77641559247623, 33.49722413458223, 33.61718797598456, 33.60076946485796, 33.52840286470321, 33.68831331411256, 33.68289866494743, 33.55136222320686, 33.584363409107354, 33.585826392809814, 33.531947663836924], "tags": {"name": "qoi_gp_low_uncertainty"}, "metadata": {"runtime_sec": 2.3132853507995605, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "322454"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 512, 2])", "train_targets": "torch.Size([2, 512])", "likelihood.noise": "torch.Size([2, 512])"}}}, {"mean": 33.19029716692434, "var": 0.8503201977665739, "samples": [32.205496065530944, 34.26886109203524, 34.00972928631448, 33.855689592242555, 33.17488698149763, 31.624001892278745, 31.957929292133596, 32.92331239444952, 33.469792546011924, 32.369930583425294, 31.149272846613506, 32.90962271302279, 33.314608126302794, 33.785310161419666, 33.369298538252394, 33.681689007805176, 32.654239519550416, 32.73366053261465, 33.9901197548579, 31.430942475937965, 32.19911443127325, 33.03126514958403, 33.10125085717611, 32.66666931450286, 33.82671085855862, 32.15912258543186, 34.397729454719304, 33.581722465274765, 33.7890904433577, 35.001514314212166, 33.824119113655364, 32.07255112360951, 34.59382576591921, 34.38344514328867, 32.995488835733084, 32.492097707982076, 33.66054300488253, 33.520044884322736, 32.56294618720771, 33.40418168428209, 34.063186621471104, 33.77456724504521, 32.636262262149536, 33.683683470746466, 32.028978252150374, 34.559105552918226, 34.08093963938306, 34.13752035254862, 33.11191305475852, 31.296875167775095], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.9700243473052979, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "494636"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.65434464854748, "var": 1.0555802796474116, "samples": [33.86781174816775, 33.11264873309933, 33.57722340662353, 33.145122410544595, 31.392140060116073, 33.52661107052416, 35.120062025925456, 31.99107629871398, 33.85396190970851, 32.98464904409301, 34.925455289426026, 35.329514432870866, 33.364847740460434, 34.547814211131026, 33.61853923281704, 34.388769919319806, 31.582125895360576, 33.27131646458145, 33.27583462849284, 34.236263305849526, 31.871541222134823, 34.98548332874485, 33.51038172690632, 33.752543067048336, 32.81319558810216, 35.57414740705951, 33.045521098715085, 34.43176102993861, 34.49283697970342, 33.588644740858804, 33.291861701651555, 32.98391173158461, 33.30545247322232, 35.73615724796799, 34.324192698721674, 32.60654202265847, 33.65841809309008, 33.61638553327389, 32.515003405356936, 32.39605378278666, 33.69368178841165, 33.19276394600535, 34.58411782744506, 33.66967306103329, 34.2142388639601, 32.64766898210271, 33.564459599334405, 34.89990049722949, 32.82913461418276, 35.80977054031702], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 2.1367106437683105, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "254655"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.74575650214507, "var": 1.1251816339986516, "samples": [32.84547373669507, 33.73168429573346, 32.28483672816807, 33.479530334969965, 35.153584855394485, 33.78904066126556, 31.865283196394287, 33.23177530901664, 34.19123150919526, 33.165736124185344, 34.24666428987975, 33.3394610505131, 33.22098877815823, 33.79151733805201, 32.55250044684902, 33.694713985998106, 32.73753823717636, 35.519948614488065, 34.403283084471234, 33.53021027360729, 35.187674456300314, 32.959028801083285, 31.903704575171147, 34.10312856057807, 35.10727916916379, 33.968781438754796, 31.895973187415468, 34.156714398025365, 35.13138141594761, 34.18853419021645, 33.281886551073114, 35.10125952707758, 31.931535617979996, 33.016363298848695, 34.228207672331784, 35.12955246568495, 33.26049287854578, 35.261184668099695, 33.868128828541295, 34.21339463418036, 33.17818043052838, 32.801581171455254, 36.60130696064959, 34.62868309165671, 34.067337180754826, 34.391209314937505, 34.04298160781643, 33.18104401119247, 33.80788101923707, 31.918411133794706], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 2.128933906555176, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "749904"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.586622911086195, "var": 0.8023960279876623, "samples": [33.837102328811326, 33.37014034934033, 33.22256052703387, 34.45531725304175, 34.44241042583178, 34.253736257871026, 34.043156841298234, 33.732370868197634, 33.35715451180791, 34.014051774419244, 33.46523986477533, 32.817136703549096, 32.87857758735445, 33.41989822790848, 33.33778684341029, 33.241613996067144, 32.39047124142465, 33.21277973568977, 34.49558581762429, 34.64955872634892, 34.907467348028256, 32.73526251118713, 34.42520197715949, 31.332920045613008, 34.19154897036628, 33.27705501154856, 33.622267551985715, 34.74679537815292, 32.39348425554384, 33.00626504821168, 34.029098595332684, 33.13233424570392, 32.666228566447096, 35.151761005105286, 34.65119499763516, 31.37696326833446, 33.830997923858206, 33.04988097126677, 33.583479918918755, 34.81395647935067, 32.615078315103474, 34.497469330145265, 34.0937688914921, 34.77988721115624, 34.35405061593038, 34.321062056818235, 33.60342162555987, 32.09247226028649, 32.506994147562, 32.90612714870043], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 2.0575430393218994, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "646874"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.30172029561395, "var": 0.9923233348451569, "samples": [33.97143273039204, 32.57005725918492, 33.378975639888296, 33.6153283205215, 33.68552567492068, 32.954173527168564, 33.402317981189285, 32.06369032358341, 35.57962190091935, 31.847185305767226, 33.28134710210996, 33.00509094687922, 32.19291936220151, 33.58997540869397, 32.20529915132158, 33.481359364367606, 32.6717607632735, 31.772400089007327, 34.219461424176394, 33.680126335055675, 33.82957907687531, 33.644076170494266, 33.16878230689594, 33.96483168997881, 34.06980031023244, 34.74759560009014, 32.75098008973442, 32.121441470537164, 32.5042867976554, 32.88571971977812, 33.8148638182837, 34.08837732420237, 34.33599945252107, 31.449363024571202, 32.843098103081424, 30.913514144830042, 33.19478951595292, 33.41852861502676, 34.12387088265105, 32.71777753543625, 32.23153660546195, 33.942600598134604, 34.916016982418306, 33.174576346435295, 33.28545008931126, 32.18678946423126, 35.36866362463816, 33.00480998880128, 35.10003647385904, 34.120210347955656], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 2.1650755405426025, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "68986"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.23299430358544, "var": 1.0255021002661917, "samples": [33.83960792183445, 33.915231611408316, 34.10860398671331, 32.71957261453567, 32.25154784220887, 34.1507038607187, 32.72333229898191, 33.517990712383195, 34.64753921879002, 32.07636507299781, 32.74927430780182, 33.73497054303135, 32.54703034797995, 34.02323078935697, 33.260095333866865, 33.569621737171275, 34.144488756100266, 32.440141832703745, 30.91134827132064, 33.107843003063564, 34.11698280375766, 31.915106081126027, 33.819686315124535, 33.142532394720526, 35.50119453899813, 31.220281910374666, 33.24642985605099, 33.740029877511006, 34.28858283903201, 33.136159857970526, 33.8687524947965, 33.64404533595218, 33.24608408596023, 31.714180081660615, 32.883342429432346, 31.898470378267824, 34.85001336516953, 32.75869563587666, 35.59090123974751, 32.44156243390425, 32.58997372864513, 33.6121040487069, 31.115763287551157, 33.591446909693765, 33.7735875351278, 32.809220832655335, 34.164077338726024, 32.859250875300354, 32.58865949965966, 33.08405710480363], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 2.0041110515594482, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "161042"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.7486276523816, "var": 1.3974880177124946, "samples": [33.971922343747025, 35.98062452276442, 35.064161277303235, 35.441843220492686, 35.46472736687989, 31.581882015673543, 34.252039564372474, 32.90420137392745, 32.437870245948844, 34.82683000316163, 33.15158897409628, 35.236243823212654, 34.37704452796333, 33.96680141270342, 36.2309378014222, 32.919294330743185, 34.891953736870185, 33.366284014863474, 33.85976478216741, 35.11987183975384, 33.09685047889112, 33.13345051673424, 33.15224114940379, 34.15489389789915, 33.077068618224224, 32.84448643347511, 34.84837992724319, 32.301221565617325, 32.55707733088382, 33.62293342402174, 33.73495971416364, 35.814220666799905, 32.69583093755625, 32.49303331648402, 32.60808088233486, 33.41249531353368, 34.1742542192146, 33.767694440768366, 35.53436287080058, 34.47409593322828, 31.79145701566433, 32.16773085194882, 32.78232658594002, 34.315693980600216, 31.99833759404956, 32.99949907710828, 32.318032366531604, 33.52695396843619, 34.760317173780756, 34.2275151896753], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 2.2049801349639893, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "873226"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.17117344774885, "var": 1.5821975519510214, "samples": [32.62018758527331, 31.491214489896596, 30.907187581524315, 35.325707857795564, 34.83865560329082, 35.45827170792079, 33.05325968590981, 32.531632189455756, 31.514282158608243, 31.00644778358577, 32.314434300627426, 33.204977426739745, 35.68095850544885, 31.87858784279437, 32.93894772012225, 33.51762179662345, 34.52207163972745, 33.483994575791606, 31.262739572991304, 33.782003514856, 34.36715898383496, 33.749120608854554, 31.31069816696442, 33.9651990471476, 32.37003372588777, 33.32769102586707, 32.46217501866475, 33.63946290801119, 33.266065883173475, 32.228784446350105, 32.75383433077832, 31.625203501877934, 33.95889495138595, 33.385119882088034, 35.11593375444588, 33.55952923757927, 33.231664827465764, 34.048140223180965, 34.29455049649141, 32.77216255621819, 33.17246614874541, 31.625463980395942, 35.66985387719288, 33.420957256739015, 33.11948493317326, 31.760464720752097, 33.14140285826224, 31.535195278865267, 33.44131777526824, 34.90745844279727], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.914154291152954, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "235760"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.37318188875697, "var": 1.0602449237978577, "samples": [34.0576261312398, 32.44801696450753, 32.61935366058863, 32.54277055805449, 33.08532845352003, 34.2769268443369, 31.81169575924782, 31.607543483853004, 32.65422032277233, 31.968906124026965, 32.65847402609476, 33.00192126645519, 33.02999113278171, 32.53289029738963, 34.872306801939075, 32.71119647758518, 34.509452781501096, 34.1777529638967, 33.899249204208644, 34.06369702252094, 33.038832312434295, 34.59075070496008, 33.10667261134556, 33.588225122401404, 33.33856242924264, 34.4763441668155, 32.57780381763998, 32.98971509950494, 32.802534942070736, 32.52714076651025, 34.624343284791564, 35.869853465489584, 33.5536530445253, 31.562261802871674, 34.00522724966082, 33.45457059876884, 32.75114791277144, 31.734334324636404, 33.830874945010024, 32.48779033960248, 35.245093781742064, 33.313243534024814, 34.52034879626676, 33.0897565253071, 33.65307494684659, 33.007789080652636, 35.6577607463205, 33.98554875625733, 34.498311207756025, 32.24820784510059], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.8632986545562744, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "841739"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.20293012311765, "var": 1.0146457743337383, "samples": [30.61597002090176, 32.56422682089914, 33.201565888018024, 32.09977007057408, 33.53701088468171, 32.99485819154076, 35.162606109952236, 33.77781827992737, 32.74658490263799, 34.1067537908198, 34.06239720278607, 32.91599344041213, 34.30734245020413, 31.661023084460545, 33.10967777155269, 33.30480892801783, 33.43562984506671, 34.32409187685557, 32.482812571001446, 32.28345971142391, 31.710218748672947, 31.202198631867784, 33.56701961744285, 34.37940201441877, 34.959385441408195, 32.671253508163154, 33.42553814188041, 32.35019605837598, 34.583488899391256, 31.841432612198243, 33.453773985864835, 34.1083581799866, 33.71086424654957, 32.13788341929125, 33.76424317619048, 32.193107270921374, 34.56645246883251, 34.05918915909066, 33.22164177270261, 33.66738898145632, 33.325543184725824, 33.13941941392374, 34.20233521598644, 32.119404123068996, 33.90727661026409, 33.12933600840853, 32.02563092723097, 32.00766471147015, 33.84993478035197, 34.17252300401223], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.992903709411621, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "141214"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.65324268460606, "var": 1.3301947611969143, "samples": [34.132046164696945, 33.88087244203181, 31.713584936709466, 35.07063097618859, 33.21989367900699, 32.07069952951077, 32.02621745011247, 36.38564871713903, 32.773443905455295, 32.673300151232745, 32.086094631929576, 33.47533297398006, 33.35152999850836, 32.61408146498737, 32.065316758516126, 36.429374747138006, 33.95320263943745, 34.216362661681124, 33.20578422377466, 32.44202360200574, 33.88235454842504, 34.43475551892654, 32.883813871128666, 33.49808148637397, 33.87557985614007, 32.669408112191796, 33.17917289511345, 34.128952904756154, 31.90013359357067, 33.49278796436474, 34.98055157143418, 33.2371452683661, 32.41208782915933, 33.834043868978306, 34.64607032075749, 34.44655813442821, 33.61878924791893, 35.098212953979576, 34.40444720463276, 35.452896690528796, 32.72655240225064, 33.88653083746519, 32.71473182421412, 35.266221314606796, 32.818819088783115, 33.6688881035497, 34.69585918721788, 35.38001316244058, 34.94995125650062, 32.693281558057215], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.8775782585144043, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "81156"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.76264735468025, "var": 1.2038729464297655, "samples": [34.32749897392744, 33.05782333890075, 33.71270197904506, 31.736164817610593, 34.56433160861377, 33.20496285121252, 35.16395461097955, 33.18407638962975, 34.641957372864084, 32.10500029918005, 35.8161709081823, 32.20882832554485, 33.972971490426936, 35.54808701446847, 35.54958871449517, 35.90872407697261, 32.21886840539646, 33.37813958795864, 33.00062983657368, 33.57965290517253, 32.86493749531793, 32.820525012722314, 32.68968050677269, 33.65909276549892, 32.48406571260715, 33.269409948016104, 33.60675581223373, 33.0758636386827, 34.86021693897234, 33.49372123119138, 34.339895018162075, 34.77244092982837, 34.62314582851706, 32.79162767254653, 32.579863174150155, 35.080229512150865, 33.659010475960464, 32.540242058721496, 35.93648280369251, 33.41594680397416, 34.62824406535277, 32.326937952675294, 33.97229622592618, 35.179316619478534, 33.949731600502936, 34.74496498803868, 34.229531127321806, 33.79127155732661, 32.920432755391374, 32.94635399512409], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 2.056191921234131, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "399017"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.211652583768426, "var": 1.0859217222735706, "samples": [31.91612265225355, 32.27297043048328, 32.00823097961523, 34.03149086868777, 33.368735475958346, 31.71468072843242, 32.637755678431816, 33.44889039784809, 33.705062081818404, 32.813245522629245, 33.12729930895953, 33.103851033695605, 32.84123548519446, 35.156412065817236, 32.8971468023615, 33.8100582155963, 32.685340506535404, 34.6964321046133, 34.31363542265195, 33.61625203342189, 31.97738117598049, 32.10364710829075, 35.43237967993226, 33.0103125614397, 32.66153062531026, 33.223637617403845, 32.13887550513851, 34.574393661611175, 35.40596454896274, 32.53120628499269, 31.938300152870326, 33.71596728391629, 32.04253364433246, 33.50781687913063, 35.644421170415406, 34.59022037808271, 34.327925679530644, 31.7096565260287, 32.555338937140235, 32.47738788234297, 34.01110029037871, 32.35738899859553, 33.74317797907947, 32.66393179906935, 33.91890719975206, 32.642404177793296, 32.49406601600356, 34.12299997052367, 32.4477172433067, 32.44719041606112], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.967179775238037, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "634820"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.394480251991524, "var": 0.8073875446608614, "samples": [33.05928108071318, 32.96556806918594, 34.32933192196834, 31.711014609189185, 32.08962787852795, 34.083096764751566, 34.16828618172303, 33.63964920401068, 33.29772246270975, 33.16236716963827, 32.02950503755988, 34.37556915523874, 34.113156820594554, 33.51202513253991, 31.808246605172865, 34.644570061679694, 33.53221723444879, 33.64403931718816, 33.45089153887369, 34.961900517709395, 32.94222420346319, 34.18763766493188, 34.675369559157446, 33.05588282868088, 31.97165244846357, 35.01040971927593, 33.359145021158454, 32.21350126835669, 33.86255852504984, 33.43607494937657, 32.68580929297945, 33.483727208399685, 34.065447033333776, 33.62738359794976, 32.476925196123325, 33.35205150539297, 34.00211272165515, 32.57777054406746, 34.935131644906164, 32.52116197411073, 32.485381961590946, 33.20668316819231, 32.529456826702656, 33.070417846463165, 32.82033278544282, 31.928977202810458, 34.83682563536539, 33.54225130070654, 34.58833410393779, 33.69530809810776], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.866166591644287, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "377132"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.24363496809147, "var": 1.446367217282699, "samples": [33.25709254462615, 34.750245936667824, 32.280573394744174, 32.382278721948715, 34.35560257031284, 32.74350926105523, 33.20930923874914, 31.89023972754995, 33.47011243757738, 32.94194330519634, 36.10933333880116, 33.20452531642379, 33.69576159014729, 32.99136301739228, 32.08604751926194, 33.203609179997486, 34.7366089256609, 35.173583756552304, 32.01413531466828, 35.668755415316575, 31.81896005420394, 32.82069115099331, 33.292695632174045, 33.39148026231561, 33.39824716950437, 33.11043667694668, 31.994764570883106, 31.941085416288345, 34.37367299046577, 34.72936017097794, 32.56831603833098, 33.05927852997356, 31.39926723878986, 33.10054662498111, 30.937814164008284, 36.179473706896545, 33.78890512378483, 33.88217282948931, 32.556464064820425, 31.688000890704608, 34.07480466174787, 33.736811574182894, 33.988633197688706, 32.41193427665301, 31.293171553036583, 32.343764828239586, 34.06297378321387, 34.220608193097334, 33.70684374020607, 32.14593877732537], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 2.0164451599121094, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "137453"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.63004654705061, "var": 1.376011012953892, "samples": [35.227594835115575, 34.15418831348353, 35.05397914220704, 33.37171185707477, 33.78416706093865, 33.00373574259893, 32.19417027566053, 31.965856164798087, 34.06087147363873, 32.474655853926585, 33.14371888038692, 33.958991849414055, 34.200526059763845, 34.65817524926191, 34.39709594298016, 32.97226766433404, 31.78362968519432, 31.667306113939336, 33.60535757416406, 35.07540985450138, 33.929862043382464, 33.57991769876889, 34.98911638002137, 32.47272155603072, 34.706573688953846, 33.70627814893253, 33.86386722774512, 35.39056035857603, 33.6138709605896, 31.6927422229798, 33.74408776523495, 33.41663609734546, 33.93428970784859, 33.45555027139366, 32.995265830425225, 33.029918086626154, 32.81667261314782, 33.388764978679475, 37.676550438733514, 32.87280018396434, 32.91378181990989, 34.848879372338395, 33.67413890608019, 32.056087447632954, 33.02109234123468, 32.14047129084963, 33.32408997189264, 36.10487321368851, 34.12976949298399, 33.259687643157655], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.9163060188293457, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "844045"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.672521380365176, "var": 1.4415083657231493, "samples": [35.124251308253946, 34.04960806706931, 31.665683855251494, 34.228714384521666, 33.69112980280206, 32.9623620796291, 33.02842693677591, 34.4823657878857, 32.20974669238188, 33.665478793167374, 36.43471537446132, 32.28533084918286, 32.75999822100653, 32.426408140516365, 32.217506973153306, 33.116152457783556, 32.1596222524684, 34.257526211764485, 35.24741846511745, 35.03818261713351, 34.840315415419326, 34.68333500057468, 33.298782369447814, 31.284019828423702, 35.507858315312326, 33.48798006784073, 34.8431695655671, 36.04537850069012, 33.081958757600134, 32.28935044309432, 32.98862365739006, 32.693490596075684, 33.397607619778846, 33.81561474199788, 32.046694004336906, 33.659389765935664, 34.98206563527511, 35.67774496525577, 33.06259458903996, 34.67358812318128, 32.246988723136944, 32.47239580049269, 33.951404749084304, 34.450327831255045, 35.01169570368863, 33.481906434661234, 32.98829222878916, 34.273797033721365, 33.62500038877904, 33.714068892086715], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.8890180587768555, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "767511"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.121679597176595, "var": 0.9320079225002725, "samples": [34.099389125769, 31.428179170656325, 33.93061029368157, 31.77802956575797, 32.278601881493636, 31.55023061528031, 32.64946856347167, 34.134074979411686, 35.22054002471843, 34.43685451537524, 33.09091031177451, 34.19070281757806, 31.82748970905788, 33.36527864351433, 33.140420841931615, 33.222313849735286, 32.52934780694233, 34.62038543866069, 32.76575376083105, 33.45885219576273, 34.07947764034886, 33.52539823334516, 34.67361250319883, 34.18201750970401, 32.266975066360374, 33.78993875664846, 31.826015407638057, 33.32432316592649, 32.602445451316655, 33.412047555117645, 33.747213334387915, 32.98029873024274, 33.15658011231668, 33.50932963255352, 32.56908530039822, 32.86563107355334, 32.54338940011226, 33.80417069183344, 35.73749105162451, 33.33232515283938, 33.222775538977636, 32.53477450124621, 32.59772797802031, 32.11646069061274, 32.49142911485516, 32.47467152160851, 31.745729796056924, 32.4452466095173, 33.028479868271404, 31.78148435879254], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 2.0332682132720947, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "69029"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.36872471593439, "var": 1.271650784660742, "samples": [31.36988560389837, 32.10873673055483, 35.06247332646261, 34.20318859479353, 33.387288986227034, 33.83732238348179, 32.59338783264211, 33.96502968935304, 33.45482519262081, 32.382517749758506, 35.57063228086787, 33.59483361649501, 33.60615340873275, 33.44324397538984, 32.26327425681992, 33.681442586446316, 31.98986018035757, 35.08108654147018, 33.688968353379956, 32.89499545552396, 31.974444233180268, 34.3323126337178, 32.77957853591351, 32.04722893577415, 33.388311403114876, 34.76403841314899, 34.46554021657262, 33.675140155479866, 33.65048243614955, 31.875956086892312, 32.02222137569116, 33.91743270056519, 33.64478542092993, 35.08815816695046, 35.483066683799606, 34.8184996309934, 32.492563462649535, 33.44461457951453, 33.342261591658584, 34.728502321054805, 34.74288763505824, 34.31666721147863, 32.14024028498956, 33.374125797258344, 31.756720939027257, 32.00058835987767, 32.528127595489096, 31.246693248036273, 32.5637619673217, 33.6521370291558], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.9127836227416992, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "705993"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.458669809058776, "var": 1.3438891466563538, "samples": [33.3961036423076, 35.89242848556814, 33.66632621607827, 35.496105625714705, 33.06774761670945, 32.03521192805995, 33.03952616725351, 33.2842308412994, 33.90625898686883, 34.37596030130601, 31.524316692035132, 32.4752382500848, 34.582562830507065, 34.05824565016791, 35.67011875058224, 32.84149183524635, 33.981172625643445, 34.25716597567905, 35.44332168929517, 32.15404439345088, 31.727016919455107, 32.27545796712904, 33.46097988565761, 32.775947751301835, 33.68212037284232, 33.576860297051276, 33.27880675793332, 33.0730971526641, 33.62037316270451, 31.91163715612506, 33.3775059208175, 33.87238535906336, 35.79526129276674, 31.567367552272575, 33.824060791134954, 34.55677902701095, 32.96765839107113, 33.547691578826615, 33.4775609639186, 33.275886047622926, 32.921479543406925, 31.685671145116945, 34.21148951102148, 32.63403522675832, 34.266724133837286, 34.395912332159845, 32.02450478262442, 34.278530346425676, 31.110856524273196, 34.612254056087494], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.9328429698944092, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "367535"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.947912744684224, "var": 1.089830398065106, "samples": [34.74976035520712, 35.09024182169941, 35.14787475933582, 34.18181457127228, 34.19944857970036, 33.97883529147332, 34.881995015816926, 33.92828782467096, 33.662799608117595, 33.64942786350468, 33.29685646308114, 33.636499078836664, 35.017068735943944, 33.348224277686455, 34.28948436665236, 33.80349017982424, 33.59958276245616, 31.520616528682655, 35.965784785443645, 32.68157243470137, 34.24593323798042, 34.865733714486794, 33.87754566854829, 33.035085838120004, 34.898332387052584, 32.898635339570966, 31.200688483177746, 33.8371596652071, 34.133248500134734, 35.291710374623655, 33.45841014039878, 34.20686576490948, 32.819267335077846, 35.03587267131309, 34.39615153709848, 33.665506331589356, 32.67314337150334, 32.93191522052306, 33.643084103165, 33.944338858165366, 31.330329412956576, 33.5114279876843, 35.270619193677746, 34.82132280649659, 34.978578331271066, 34.58073431313141, 34.85020946160055, 34.28912442385897, 35.463971336103576, 32.611026120677224], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 2.086986541748047, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "367944"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.34915474318918, "var": 1.4199090939077141, "samples": [36.59249495436717, 31.429896279363547, 32.159055312493514, 33.62512644798083, 34.1092894403441, 32.00319006049537, 33.772199789474406, 32.76041588011258, 34.20396724061262, 31.39917596252978, 34.7662982795668, 32.253406475122404, 34.97608811034412, 32.97733968199505, 33.29580614835388, 33.8736164310885, 32.38355470314164, 33.80750474642986, 33.95651555185421, 31.82145644440208, 34.614783016803464, 32.49416433282405, 33.00693717466103, 34.55490185877101, 33.63529293760509, 34.14989365070862, 32.791188383668064, 31.247907601493818, 32.26609211063025, 32.99951075599672, 34.13165125840672, 32.920723252080315, 33.55654880984149, 32.2233787637824, 32.82079563083817, 31.53875188634777, 35.02703267399037, 33.57396849527844, 33.98564726315369, 35.05207646895372, 35.00914507439767, 31.855443985585442, 32.67947729863054, 34.747380008897665, 34.4518892326471, 32.06518964924303, 34.67160776008629, 33.34469249191591, 32.07451878673468, 33.800748605413], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.8637967109680176, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "387183"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.46610082257347, "var": 1.190905291813169, "samples": [33.179007057715275, 35.799880395205115, 34.37488865264523, 34.591402694200866, 33.11771791955593, 35.467001301645396, 32.405229023739615, 31.397859624665912, 32.77007297656723, 33.16548667356107, 32.67872233579892, 32.84944073555072, 33.25007791590349, 32.40094335112738, 34.559544582581076, 33.06307394470142, 33.82128987618029, 32.033410064153244, 34.57887519638617, 33.318044479151865, 34.288841486881736, 33.175021527514815, 32.007057929328354, 33.07338151153195, 33.0646130626105, 35.75835027422199, 32.52292608236015, 33.028980008306725, 33.38900609145027, 33.54196072233469, 32.80470703315013, 31.75663168927995, 33.844402834262574, 32.16554539173187, 33.31097565880837, 33.480114056989024, 34.08803236291008, 34.78680436030832, 32.468188201566676, 33.57885940436025, 36.115555265383854, 34.195327814852526, 33.81398396006079, 34.675850898522505, 34.421965673415755, 31.321733058499632, 33.57212308501258, 32.59324040748376, 33.63182887520301, 34.00706359929468], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 2.1389524936676025, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "614699"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.625288660181134, "var": 1.098325862663957, "samples": [32.47919017872605, 33.872958263535004, 32.94320772036965, 33.358839892634705, 36.42884493492614, 32.75181160118533, 33.06552644360736, 32.76283534854654, 33.31730513447319, 34.85067280046602, 33.67922352232175, 34.37016030054274, 32.5983240945037, 34.84604612799731, 31.770403986862025, 35.18157618243063, 33.2146398168407, 32.977749863578666, 33.46143509381825, 34.293559031892386, 34.104612502503414, 31.955861886344962, 33.50045008326555, 33.31988921491153, 32.957023600152866, 31.913083972189376, 34.37501097628529, 34.10931515355574, 34.70679782549744, 33.61543259468853, 32.50900662518062, 33.445374936343924, 33.21543583134456, 33.52456464603917, 36.878228809151196, 33.636878687169556, 33.07685155269484, 33.190689237920886, 34.82221333450102, 35.444565820366364, 33.24895248591176, 33.73536157439782, 32.37880559584612, 34.16422479824813, 34.04826884583404, 32.79604072510073, 34.15798855599561, 33.05206796667625, 34.409889620346384, 32.747235211334974], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 2.012608766555786, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "862053"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.48739351278532, "var": 0.9678554198047077, "samples": [32.81959201816696, 32.99276430519422, 32.144583264980724, 34.276037468997544, 32.59701537743339, 32.64807677644217, 33.65119580106645, 33.27237297910343, 33.71554272136391, 34.52685362171732, 32.76739994007256, 33.30713679821402, 33.95602621315477, 33.81332137773751, 32.98513628621425, 33.8394417594495, 33.321830251005665, 31.219335249423864, 35.036679626056646, 35.66001808813665, 34.18614544042253, 33.10635394932514, 31.169309133108303, 33.27288822714344, 34.05322560593822, 31.591963649657153, 34.138423194684826, 33.95021514251194, 32.49956359765963, 33.47266180293703, 34.66424107248149, 33.21821905897413, 34.68685829327159, 32.32719803880386, 32.57338716427891, 34.273420202684676, 33.98239220429795, 33.779844824726304, 35.75813843609304, 33.32665344933443, 33.60932848323911, 33.77606591971457, 32.613664879099304, 33.77208956399779, 34.82346154846765, 32.31403207857668, 33.45368860484127, 34.32479467878768, 33.07172638692441, 34.029361083351084], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.8214426040649414, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "164763"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.495537064921436, "var": 1.2969473941952407, "samples": [33.81582800028911, 34.30655421448285, 34.95324487413291, 33.89911947806407, 33.57329382308374, 35.41399077108408, 33.09516522278219, 32.493110624737945, 34.951592336417576, 33.59650501054597, 32.71805955278965, 33.551969815733095, 32.77574937865252, 33.29904012441672, 34.51266295023857, 32.41982070802509, 35.19178643139925, 36.12186743219894, 32.464255049557536, 32.38662256225221, 33.377040054013314, 35.140181713413995, 31.951098446012796, 33.706427370045766, 33.147940033173946, 31.580777367722067, 32.405706509834594, 32.69259000452445, 33.78455994223814, 33.538785748482034, 31.511526120163225, 32.17513520168965, 33.950311326543435, 34.339429375587095, 34.20776296850903, 32.46465751393372, 33.209089408820624, 34.358181609473604, 32.17422382026193, 33.79306113147184, 33.0375683364634, 36.03773012407871, 32.75499285550925, 35.179522100063636, 32.29600689198431, 33.85225954535392, 34.377865012163696, 33.89776857968673, 31.82001801019829, 32.47439776377052], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 2.0162010192871094, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "151783"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.579479838288044, "var": 0.9660270174939056, "samples": [33.51125733260123, 33.95057090606322, 32.78225537233818, 34.36308291579328, 32.86487492830783, 32.865001959606104, 33.159875961091885, 33.898872752118564, 32.67898802579569, 32.484379289307924, 34.362359628701704, 33.948374605881774, 33.880029589142254, 31.419201186013662, 34.076005609048515, 33.18312667587215, 33.716475055219114, 32.5878691548859, 31.832442579079583, 32.6928352080871, 34.63470235328447, 33.984658478322146, 33.930793564250855, 34.68249489570174, 34.78550115779508, 33.27990253497687, 32.86540862438265, 32.92809608167189, 34.32107677589647, 35.076467906743105, 35.49794182150417, 33.979408338350474, 35.361707661845614, 32.390983717006236, 33.168802325722076, 33.43252084813691, 34.65088990844476, 33.30848828375634, 33.92268158351068, 33.87262752542925, 33.22985863265876, 34.34923689530357, 32.11011293114758, 32.374772918153354, 33.841980263288825, 32.36932591600789, 32.532768259219765, 33.921403227040116, 36.19932128977771, 33.712178460117016], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.865147590637207, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "668796"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.853080903329825, "var": 1.4175699764937417, "samples": [33.03049075921474, 32.32041960804158, 33.4089911439928, 33.97179779187676, 35.12246619042383, 33.9774507629175, 34.575134669946316, 33.65815023863232, 31.853812919039058, 34.89766416760235, 32.658863549247855, 33.498111512649224, 31.55605794113798, 31.292179465843386, 33.94557186698546, 35.15204845391185, 35.31413841368796, 34.95898928838348, 33.40970966526511, 35.33986798681103, 33.46400106980221, 32.817820580365215, 33.52372972549054, 36.88658955883739, 32.79796548202316, 36.01943767162332, 33.967520037025366, 33.983672718786096, 34.82763285715714, 32.064858965729194, 32.64045680344889, 33.425896615158216, 35.31410400197524, 34.24961043456756, 33.43363728936363, 33.792594267610326, 32.965415725379884, 35.783367408047056, 34.082916266396666, 34.169186784382134, 32.58145060202493, 32.84200310103712, 33.26523454577008, 35.5964980899696, 34.52430118193351, 34.81598659648822, 34.19746317264023, 33.03414618424098, 34.37003782697551, 33.27459320663139], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.8995826244354248, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "320094"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.253553059902785, "var": 1.0256027435464123, "samples": [32.33009723057038, 33.46643787702103, 33.39569536419329, 32.85202970936546, 34.16073085925797, 32.15762557340646, 33.37869736171509, 32.79012908956877, 34.13097092467531, 32.51068464106136, 33.675568744490675, 35.81847310774652, 33.71114838045851, 33.26259017083356, 36.178430153414126, 32.586139774495564, 30.92467992462278, 32.49401208216072, 33.537187200878144, 33.033555794670164, 33.35745805647133, 34.05083747576763, 34.2919072435654, 35.270611236517674, 33.72894167950684, 33.93891985571541, 33.387869211407036, 32.921235864777664, 31.818150778343153, 33.15446767355483, 32.790701093973425, 32.46499994641981, 32.96993943126581, 32.48090411415433, 34.5040596331532, 32.752519670058554, 33.1702814573169, 34.20848367660702, 34.67991513523091, 33.088206618063026, 32.97716611373615, 31.239902857031883, 32.56202934966641, 32.57068334316757, 34.03068131043, 33.35981223907469, 32.01447148449753, 33.343357623414754, 32.999507758357076, 32.1547470992875], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 2.0112431049346924, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "468550"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.31863847911813, "var": 1.0704061114713572, "samples": [32.94592235631295, 33.159366359042764, 32.72203454471472, 35.32513602138275, 31.814751668380342, 33.82679073780414, 34.0424832728377, 32.21383423439363, 34.505889293262605, 33.481179037770296, 34.82670718068099, 34.88458319906188, 32.17457605406195, 33.75194822698406, 32.7824638778625, 33.13383134629017, 34.080727974554975, 31.979617356935105, 33.45030137243774, 33.03173589825551, 30.61489462480588, 33.189364411243105, 34.72604914610179, 32.88878771047618, 30.731243789450733, 33.02189092409788, 34.583076038900494, 34.05631968383818, 33.55602465458596, 32.699257823141735, 32.06886378834467, 34.98863723227425, 33.082455000429924, 33.77055849491122, 33.13653660831866, 33.71999164102677, 32.83328235737077, 33.640656694565195, 32.464715286104536, 34.799459972749936, 33.54060974985598, 32.970202823863595, 33.90780944199903, 34.26395843845332, 33.234637813043285, 34.0042793341067, 33.19640462609647, 32.89651381075144, 31.34830086233046, 33.86326115964145], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.9982390403747559, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "908552"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.47025246093588, "var": 0.8962999800451812, "samples": [33.60235106502174, 32.32758795405632, 32.42536068192971, 33.37853102103333, 33.065360336821506, 34.75649682948929, 33.21536638527603, 34.3520183150978, 33.98844861006477, 32.08615357951006, 32.77084989730754, 33.851352041792204, 33.976454362843945, 34.68882030531742, 35.02225621541434, 34.07788553833969, 32.78981410234678, 33.35508219066445, 33.6803674755621, 32.2560962471039, 33.668194568168104, 33.34989996814113, 33.15012009524385, 34.81051523567893, 35.42130106767571, 31.150631790381983, 34.16803343085347, 31.676920354890406, 32.26121540566943, 32.85756124760657, 33.82680751288737, 33.00382476900259, 33.39638738230796, 33.33625421328162, 32.805088321420484, 32.985569413601, 33.25328635145034, 33.31235969743645, 33.22780110398571, 33.17420169164682, 31.520503519292728, 33.603927024832565, 33.347807384296196, 33.53945061828998, 35.36432345917651, 34.154424695909775, 34.66225690285652, 34.61637892047104, 33.84071334107422, 34.36021040427204], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 2.0196399688720703, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "274516"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.31601234272096, "var": 1.1526627342339202, "samples": [33.234423180902546, 31.048853428277564, 33.62568140242248, 33.49004470017779, 33.872555791544, 33.57863209090034, 32.96707018663093, 33.471333103968234, 33.334302370711946, 34.23930430974247, 33.47816154439607, 31.80825377729925, 31.444221354128953, 32.43252501262734, 32.10996685654186, 33.77965191510288, 33.37216315250236, 34.851015797867774, 35.26554047484939, 32.84837826654464, 35.94344992051409, 33.14404554934111, 33.034121247753475, 33.281302226038115, 35.02168690348384, 32.483369850648835, 31.672762932131544, 33.83380187530117, 32.76032833465065, 33.21487619196983, 33.29973150508783, 32.19638103228187, 35.56165526504831, 34.513565265106976, 33.555601567805226, 33.762314353476555, 33.621115248115046, 32.83009138577469, 30.661293513615664, 33.18390798602889, 33.56718947206027, 32.74588677061183, 32.48966026695635, 33.81462607691806, 33.49330443895415, 33.63974108091452, 33.542235694979425, 34.412823685499085, 31.8815398903756, 34.386128887466334], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.9485037326812744, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "893797"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.83719309594184, "var": 0.7666962131572742, "samples": [34.41315488468717, 34.12888661571208, 35.1721460783797, 32.90393024014063, 33.28158622820481, 31.49194021784737, 34.85429903116235, 32.97268525487251, 33.74985318758473, 35.10029801500032, 32.63614937551194, 34.443943323638784, 33.85211689780649, 33.57062355075278, 34.5475051161411, 34.227286879324645, 32.477801134777955, 33.073520894197635, 34.618280663761446, 34.783999716698126, 33.2388367443888, 33.8640787783871, 33.535980069415444, 34.12431920717831, 33.76402376190591, 33.40290432592064, 33.5796879581446, 32.93524767132641, 34.008979786539825, 35.32316623724621, 33.226677903536164, 35.04143740529511, 34.56653724443082, 33.299823596630134, 32.51385966218878, 33.01236931091219, 33.966936393044556, 34.248539473760395, 33.31844356999508, 35.392836446146404, 32.98946881182353, 34.41902173263507, 32.99810152328621, 34.76601624607931, 33.62972607457327, 34.558773010533734, 34.955952248891755, 34.181862730756556, 32.34859823698218, 34.347441328934856], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.9161789417266846, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "734322"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.716627203682854, "var": 1.2347382876977009, "samples": [34.12371785405552, 34.22547520525155, 34.16963837853014, 33.04539721882863, 33.39686098212438, 33.329495882019714, 34.916414113260196, 34.6569503313147, 33.96792160159944, 33.09698269306241, 34.36955934337678, 33.685543289433824, 32.098506262280885, 34.1932631993377, 34.03721241934053, 32.7250489362298, 30.988943823882096, 34.668758023184004, 32.53308595778498, 35.720363838489426, 35.528905712407344, 33.22022627122311, 31.875212449868954, 34.50151329971946, 32.01542185601518, 33.79323957122042, 33.1918196450694, 32.80634664679592, 34.01713261497254, 32.14109832255785, 33.44226404535233, 33.84178807841177, 34.25217553847739, 34.468800826754844, 32.8284373698505, 33.68927532957453, 35.68870345578839, 35.159873709798134, 33.551395177343, 35.79664715996026, 34.17255405472772, 35.83772305767459, 33.848357955614674, 33.79649035954483, 32.70831541170668, 34.32776345617435, 33.15229354775023, 31.394465948851582, 33.6326423391472, 33.20133761840286], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.9661788940429688, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "213532"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.68501682040704, "var": 1.082203985846385, "samples": [31.963897001769883, 32.3488142030725, 34.316852793039146, 34.55114380915731, 33.88634257293673, 34.4784704464791, 35.85415751816588, 33.009550098104505, 34.04197433159339, 34.65883642761052, 33.41935004988236, 34.92545742945037, 32.837970926688456, 32.61679220772335, 33.96503514779164, 34.64030361574852, 34.36902096260612, 34.27586578013049, 33.38560947597231, 35.19982855723223, 33.35865613677461, 34.35829777513162, 33.30327023958454, 33.400032968638094, 34.43029837300969, 33.87514027177119, 32.02734348379018, 33.11109056305691, 33.01768244352821, 34.199942077904694, 31.365518934636935, 32.74148959665569, 35.17386650229428, 33.85568377767192, 34.748673241038, 32.74908285716253, 32.05810190685491, 32.68177471541306, 32.86426140947093, 36.07763274874049, 34.207285802188146, 34.36797040174258, 34.202425839394316, 33.82371451252758, 33.126614212517374, 32.1961995129802, 32.04083540367145, 34.37028272905109, 33.80262290589712, 33.9697763220988], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.9152882099151611, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "63949"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.50095303727868, "var": 0.9725929175628936, "samples": [33.8559995283989, 34.31960150855179, 34.905592820434315, 32.92739482374692, 33.584694361983594, 31.88980831172076, 33.31018663457237, 34.67839197440354, 34.077853290520146, 35.40561984090323, 33.82048609570121, 31.375085906301923, 33.739112024212986, 33.35722608944812, 34.37627822107765, 33.3570795185387, 32.681435762487006, 33.472375420272755, 33.25905280912989, 34.876760313043505, 33.39014123295305, 34.11815588506708, 33.46935968712065, 32.00920662734173, 34.225464524739195, 31.784847563181405, 33.10019654979893, 33.02701581467257, 34.16723858226763, 33.05476164025058, 33.10760916491784, 33.14960429652739, 32.61558997428922, 32.105487643551676, 33.90522071632814, 33.944020597074164, 36.043154616851126, 32.79360776715509, 32.584919228310184, 33.48858227854024, 32.45988583638807, 32.604075145677974, 31.783267250976074, 33.12977970371919, 34.87359323939618, 33.7418039236358, 34.353137769017884, 34.88683338941735, 34.276581955884446, 33.58447400343381], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 2.066288471221924, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "565882"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.63888585095032, "var": 0.9273544708072551, "samples": [33.1331630122365, 34.48117719762372, 33.41923731624982, 32.30820729301028, 33.06951387933651, 35.259492144883275, 32.65757697644643, 33.24983161817693, 31.602237809362688, 33.06301362286913, 33.77618929505731, 34.492154662841806, 34.40407665823081, 34.232218352261995, 34.625146538243015, 33.129173195270475, 33.70274161266792, 34.65705241852006, 34.56116355252786, 32.795993192092766, 33.854193073792935, 34.1154483044452, 34.44392970381595, 34.08362447575225, 33.3970260436586, 33.36304359721549, 33.58784089960708, 34.148699494433274, 33.29804618977595, 33.546168298193244, 31.75455054852457, 32.24865153823597, 32.49067149790072, 32.890847297438285, 34.14329991722887, 34.04822701871954, 33.01298420553742, 33.37919988608609, 35.68566122626282, 31.973731419220684, 33.30080043374721, 33.97728978526364, 33.12624020244654, 32.235283694058886, 34.09895136103114, 33.078789980366686, 35.74843513296343, 34.49808447729149, 34.448813812903694, 35.34639868368871], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.9128684997558594, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "317856"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.420949018655776, "var": 1.1038936457772928, "samples": [34.61204090411959, 33.11040981198138, 34.547612213322445, 33.38692930824277, 33.13649224070105, 34.849279563377294, 33.2241404409624, 32.832792844506244, 34.081723573256824, 35.28591064293412, 33.691527477340266, 33.42634597184004, 34.43171719935549, 32.28663806764123, 32.408442979610655, 32.95275056113782, 35.74108093228576, 32.964488743757215, 34.171016291059956, 32.3867274133507, 33.451923328904236, 33.76584432227192, 35.14597135138676, 32.91373542445151, 32.91764525961277, 32.76416115112381, 33.610698433183614, 32.49373554326032, 32.94537937047203, 30.91805153312518, 34.574335329836224, 32.90364883229678, 31.901189120053978, 35.61351560651248, 33.95955310575714, 33.70920677111897, 32.239445515321314, 33.16252441612262, 32.80348027171808, 32.81691566415197, 31.311458546128176, 33.849424457608386, 33.919871743286755, 32.63890745790478, 33.182423411100785, 33.8329922606346, 33.11646171337073, 34.90920748843156, 31.839951097763503, 34.30772522509486], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.887502670288086, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "703127"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.36134768989985, "var": 1.1613969185578144, "samples": [33.97274534701482, 36.02328423216482, 32.95407444221349, 34.41896372150866, 32.52037406885117, 33.251570434883796, 31.55080106094844, 31.72173653241401, 32.481995066154916, 33.036635089130165, 34.70215923046919, 33.61971658214114, 33.18555549732029, 32.72842356621013, 33.02165375972476, 34.332696616691464, 32.51246586565513, 32.413223486826254, 34.618483369602, 34.34942677939975, 33.900002537123406, 35.34328366348712, 33.549115755122486, 33.3274074139314, 34.83265396923868, 33.45245536699006, 33.00007391719065, 32.92306812774516, 31.74253443425153, 34.58251115940513, 34.22976116730091, 34.8974681570835, 33.94478291425241, 31.729688543584725, 32.57689479551163, 33.492176024538274, 33.21704622168396, 34.46732575174121, 31.88957830894028, 33.34994150299582, 33.88361009725697, 31.602712319104572, 32.8337819878195, 30.732883593973817, 33.796610323844675, 33.27539117735987, 32.71021272344731, 33.379154924362794, 33.805579769131604, 34.183693097248735], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.94272780418396, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "875033"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.43379406928371, "var": 1.244024117947758, "samples": [33.47995040521264, 33.513793015657775, 31.764003425825184, 32.88249110902569, 34.34152749246023, 35.38984474114665, 31.815868201252297, 31.41814123314554, 31.81028349332405, 33.67985674806503, 32.711028297853304, 35.13606396298848, 34.3346072947425, 32.810850859969335, 33.73744117947011, 34.60459102149095, 33.90954484756137, 32.184530496570076, 31.95251782921253, 33.28290198654746, 34.179487014666584, 34.772289037551, 35.39598814008975, 32.47914769537319, 32.186645734269504, 33.24323962265597, 33.13746522844903, 33.948946422258246, 35.139636793416344, 34.62682527485022, 32.44690847368173, 32.31656508624675, 32.972783008063196, 33.68037529582763, 31.877895365438366, 33.846568101173645, 33.87755844838699, 32.65702508331964, 35.03950793879031, 34.20177070337839, 32.85651902086099, 31.74786204892236, 34.34084680890774, 34.02611806668998, 31.82285947973421, 33.46008799905821, 33.0544674638144, 35.042880946404956, 34.59565066212808, 33.95594485825676], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.9453165531158447, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "230479"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.55599492858128, "var": 1.0389774849349205, "samples": [32.86958644709231, 31.8695285408473, 32.50800688673959, 33.28610582487133, 32.65972732451483, 35.247799337601606, 31.79681422711894, 34.19547459136596, 32.42045834874529, 34.127104509812526, 32.32841512089233, 33.713561853098774, 34.251408023894605, 32.17912530405988, 32.40097855815767, 32.29073093119491, 33.07154189769044, 34.15361398208617, 32.589249868505135, 33.914057684644725, 35.25402677473201, 32.32740318877293, 34.71672209689907, 33.27555966331671, 33.04227750566347, 32.715457252712106, 33.830651825306326, 32.26460735034588, 33.28427713088842, 32.13115742341781, 33.823375901770596, 34.59564033147285, 33.82370360485306, 33.35048436073867, 33.305629428700954, 34.60085775861798, 32.75841986267161, 34.90135859964109, 34.6358456844198, 34.59274473284137, 34.43455160556093, 32.69684545894455, 34.01611630613677, 35.30447189946195, 33.95225510901537, 35.15995744377776, 34.676372881427184, 33.82911884026321, 33.47406154430539, 35.15250559945364], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.9563806056976318, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "612710"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.41637826013936, "var": 1.2760703422925344, "samples": [33.801226400213174, 34.046490216113945, 35.67640427104034, 31.897411568797875, 34.27841081184811, 32.345531881169656, 33.23644558071639, 32.395752421542376, 33.247624367077265, 33.19599373936464, 32.80459339948944, 33.36617825762672, 33.22789614370449, 35.30652471279657, 33.8333507050895, 34.32374822656043, 32.807813922375516, 32.39768112856974, 34.24805571097529, 32.95062646258391, 33.17916250502467, 32.44504665023959, 32.67391113384768, 32.45968186853476, 33.019450772903035, 32.386005680640785, 31.414171203303884, 32.013783403782305, 33.041013548611474, 32.97085106230536, 36.36449027528267, 34.71710158368626, 31.897286016334593, 33.49970720576511, 33.8164523483007, 32.626648247531115, 32.97308970763896, 35.43259870606562, 34.18298010048518, 33.48379540785757, 34.15830478369254, 33.92656984919094, 32.38101783459984, 31.23359192663204, 35.24808740178169, 33.29127944615735, 33.9300884913374, 35.69570534235722, 33.934342410797576, 33.03493816462482], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 2.0094962120056152, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "343455"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.48027646746331, "var": 1.202217574710307, "samples": [31.814910688748114, 33.75988075272378, 33.98662478692891, 33.075956649502494, 31.369452771278773, 34.07121144320527, 32.982367713243626, 33.503444188543824, 33.929932493644486, 32.55007583954709, 32.557035691962255, 35.70889921286514, 34.03881858339285, 33.63227532498884, 34.120831962468934, 30.93342860520585, 36.304087003251894, 32.71357519962147, 32.98803258889631, 33.53211166163138, 32.59434352123428, 32.264522354370875, 33.22616956481746, 33.38848793911805, 34.54780465813932, 31.695951834129247, 33.556670331973045, 33.79688258698921, 32.667982970953, 32.1122522477832, 34.29715398642693, 34.63978559040526, 34.3623659605569, 32.1139726791129, 33.68130990456908, 32.429760710440334, 33.93341086363955, 34.714656880140424, 34.75197728111665, 34.137845588640616, 33.81089394483086, 35.742723897031354, 33.41292910633266, 34.210250051597335, 34.30190015333686, 33.953670866416616, 32.208321160675666, 33.45440339096736, 32.79180810436817, 33.64066208140091], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 2.107485294342041, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "565181"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.655867266495484, "var": 1.1626619338402064, "samples": [33.279459819405844, 34.66729612535747, 33.24752865186067, 33.67273430679877, 34.739145297474316, 33.2692275070975, 32.50007012923193, 34.65997720109587, 36.01209151914973, 33.13342409747539, 33.18327400129233, 32.44573226398351, 33.62014010632098, 33.10910916282365, 33.02406844945669, 33.394843194071875, 31.609370203046783, 33.52045951327337, 33.335967834013566, 33.783708899475066, 34.148543671107696, 34.673676111111355, 34.00215901456885, 33.42514717050866, 33.57464111626007, 32.737471509188175, 33.04910721310946, 32.38675756228639, 32.32261997410006, 33.36819294105165, 35.04373030409256, 33.22777062193291, 35.94842633122816, 33.60217632785084, 31.922364123522723, 33.68842005790068, 30.677512891721, 34.098639344562635, 34.410527077458745, 33.332285863631206, 34.5239827534155, 33.17166924941221, 33.43869690961785, 34.905137236822554, 32.81783229644819, 33.29228124635339, 35.240291480161446, 35.10846340784547, 34.95532707957718, 35.49188415522132], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.8996717929840088, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "204553"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.559362671113334, "var": 0.7818948920629841, "samples": [32.91430791702759, 31.9789043800482, 32.45145437977373, 34.34357416632329, 34.512735235477116, 34.211793247628094, 32.40499958847828, 33.71355628454419, 33.17903235898756, 33.846956258129474, 34.38729698059524, 32.23781838611716, 33.679408432275046, 32.77927651060837, 33.903490645899, 33.187388454493444, 33.290496511906326, 34.33245452609819, 33.57166818686112, 32.75799502359972, 33.509898650393204, 34.67849807819158, 34.223527471695576, 33.798357758572955, 33.12367265878255, 34.75819522832102, 34.653835895919535, 32.51659844593802, 34.26030983586222, 35.1519058192337, 32.58361111514933, 32.6288887277125, 34.73990622109666, 34.85867641997501, 32.52388215758151, 33.28650731960921, 32.7048805010662, 33.71616621883463, 32.47870278099917, 32.57601396216247, 33.70235141079444, 33.191134543206125, 35.20812201336324, 33.448401363921406, 34.68948883408545, 32.61403887460032, 34.50141380065311, 33.5677207111285, 34.36674167760942, 32.22207758433657], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.9345285892486572, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "723267"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.50536161347367, "var": 1.142233322199402, "samples": [34.53429275791067, 32.99135510255792, 34.056284470064504, 33.40994648576531, 32.05938672540398, 33.83509783099842, 34.832984569627975, 32.9149639711314, 32.53241622906448, 32.405247137495074, 33.850847512018014, 33.17613580421199, 33.558749000773936, 33.54445654792744, 35.231498449569166, 33.37814094931593, 34.52732340225461, 32.64006287748647, 32.86354309837238, 32.04751356486251, 33.294487308183285, 31.9971241899918, 33.81775684851377, 31.68068460211619, 33.27245423336381, 34.10257427518868, 33.056836567692855, 32.85685390603149, 34.62824322119046, 31.739065604250932, 34.81890018237273, 32.5756057851064, 34.148377711053755, 32.72667655712138, 33.61050063548111, 32.91025455372885, 32.391048062561474, 35.00639204409498, 34.61448477527351, 34.47301449421314, 34.822820017599895, 33.73229841258582, 32.37684600085162, 35.88417317807038, 32.207683187554224, 34.32864845830059, 34.05488836251998, 31.8975743140446, 34.05719461847136, 35.794372079342146], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.9327795505523682, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "102519"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.394923750395975, "var": 0.7672472400387519, "samples": [34.05861352544756, 32.786350672156885, 34.14772595061265, 33.53193419456719, 34.35351843513991, 32.42403769246841, 32.37108010456216, 32.84471565072318, 32.94524407340824, 32.08322422174401, 33.680369281924605, 32.739168826978975, 33.130787699276944, 34.24875979736269, 31.338156464050194, 33.65483974051741, 33.582275218669075, 33.95261023986052, 34.98715531785234, 33.07543200981367, 32.106276022768796, 34.642536888446756, 33.46693704250975, 32.993406556322384, 33.22200289295043, 33.49391472082434, 33.71401772797806, 33.220212692060194, 34.574963455199, 32.86389461390897, 32.9724054611528, 31.28443582455652, 33.438935495858466, 33.0383851194745, 32.52487445209092, 33.56607225786168, 35.214290546771366, 33.33867058290612, 34.856168014690326, 35.10308671247552, 34.10959428259336, 32.67014657781593, 33.35790284846884, 32.790501373158335, 33.026693318430695, 32.986355811600696, 33.1914512404895, 34.06023187994947, 33.528394931105645, 34.45342905824284], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 2.084874153137207, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "472547"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.67196590386418, "var": 1.0989135783486044, "samples": [32.78757670511613, 33.86263291996098, 34.00943734204011, 34.08922210391024, 33.887908356613686, 35.70684471687382, 34.13984961239054, 34.617720840168374, 33.41181794078072, 34.01217843164755, 35.47761989404161, 34.12771856355314, 34.13419217984489, 33.247222377156774, 32.63429339890039, 34.545753961876386, 34.04640606206736, 34.141500536567456, 32.37725754081051, 35.35880615294691, 33.35648925799254, 34.08621302697493, 32.07394213308562, 32.914589181205976, 32.19456804832933, 33.63029785627313, 35.15394411584154, 32.58571911523717, 33.61858227651156, 35.08309984400756, 32.37772425137526, 33.268306861624055, 35.49654392117335, 33.751099840792364, 33.831172413588, 32.33047990217735, 32.44318166503779, 34.94830087649105, 34.55204568641764, 31.342211209530632, 35.60874556868983, 32.93217666286236, 33.344462813078664, 33.953291556932356, 33.4658830768474, 33.46392818021778, 31.759314303296875, 33.028361276745265, 32.82076313416923, 33.566897499434496], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.9042370319366455, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "548249"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.524299763330134, "var": 1.116340232849305, "samples": [35.46635284540553, 33.67706791076564, 34.169643259200775, 35.03778857601319, 33.440199320884844, 33.910719397307645, 33.44927680922285, 32.69476356734456, 32.15035679511085, 34.146577681074604, 34.49916392005505, 34.11607196130142, 33.73168765814173, 33.366646388994795, 33.1602961740203, 31.441712469733947, 33.15547860676733, 33.15689332807881, 32.59180307513225, 34.20880020158558, 33.68383211299765, 32.52910202427955, 34.17824907014492, 34.39016252913863, 31.75975746868561, 33.96912107925603, 32.705036076889115, 36.00270067519484, 33.91607730263358, 32.93669762647176, 32.10785629726685, 33.537195655129196, 32.51910585845018, 31.43352308294829, 33.4245596858087, 33.59903670208618, 33.97307025418942, 32.54900994490469, 34.48895440645315, 31.173211960105817, 33.762071714080136, 33.24751393514636, 35.16438273546435, 35.57485157141782, 34.11998420203242, 33.164217093809185, 33.4109689764996, 33.14856083579611, 34.95176557926516, 33.22311176381935], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 1.899519443511963, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "695095"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}, {"mean": 33.50650753426366, "var": 1.4454809780410791, "samples": [36.62048702719048, 32.657381823679906, 32.728089730898695, 33.400723148540685, 32.63841663177696, 34.68472676654105, 34.547768229883324, 34.79221534254116, 34.00348306146797, 34.46151590833495, 33.66586125799369, 33.696865657319265, 33.81592888376292, 33.38279187427316, 34.36686942118142, 32.930713092313944, 35.92473681396467, 30.992510321548213, 34.031270023082385, 33.111138012605544, 34.359478336740224, 35.069657149859275, 34.19883802190701, 32.96262688953537, 33.437165997706025, 33.25626650448592, 32.170151547728366, 34.76055249663847, 31.40306261482654, 32.132888810719955, 33.68323201710637, 32.00214876729865, 33.78853095436026, 33.04540870852698, 33.51278562915039, 32.1299056484452, 36.05845533296148, 32.69390219228448, 33.198743272898774, 30.778671231267033, 33.71677047655199, 32.378491644708994, 34.01939952221789, 33.14595920973335, 32.60051353245217, 33.17007141755556, 33.36722778070393, 32.510466204161304, 35.260427336511206, 34.0600844352398], "tags": {"name": "qoi_gp_high_uncertainty"}, "metadata": {"runtime_sec": 2.0569465160369873, "qoi": {"__class__": "", "quantile": {"__class__": "", "shape": "torch.Size([])"}, "env_iterable": {"__class__": "", "dataset": {"__class__": ""}, "num_workers": "0", "prefetch_factor": "None", "pin_memory": "False", "pin_memory_device": "", "timeout": "0", "worker_init_fn": "None", "batch_size": "512", "drop_last": "False", "sampler": {"__class__": ""}, "batch_sampler": {"__class__": ""}, "generator": "None", "collate_fn": {"__class__": ""}, "persistent_workers": "False"}, "period_len": "1000", "input_transform": "None", "outcome_transform": "None", "posterior_sampler": {"__class__": "", "training": "True", "sample_shape": "torch.Size([50])", "seed": "7318"}, "response_distribution": "", "quantile_accuracy": {"__class__": "", "shape": "torch.Size([])"}, "dtype": "torch.float64", "device": "cpu", "no_grad": "True"}, "model": {"__class__": "", "train_inputs": "torch.Size([2, 20, 2])", "train_targets": "torch.Size([2, 20])", "likelihood.noise": "torch.Size([2, 20])"}}}] \ No newline at end of file diff --git a/tests/qoi/results/marginal_cdf_extrapolation/26_04_12-15_13_14__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_no_gp.png b/tests/qoi/results/marginal_cdf_extrapolation/26_04_12-15_13_14__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_no_gp.png new file mode 100644 index 00000000..2a6aef94 Binary files /dev/null and b/tests/qoi/results/marginal_cdf_extrapolation/26_04_12-15_13_14__commit_0233e86f2efcf7dfea4a6bf6dcb36d2fbd8fba7a/qoi_no_gp.png differ diff --git a/tests/qoi/test_marginal_cdf_extrapolation.py b/tests/qoi/test_marginal_cdf_extrapolation.py index 2f067f24..478b3ad4 100644 --- a/tests/qoi/test_marginal_cdf_extrapolation.py +++ b/tests/qoi/test_marginal_cdf_extrapolation.py @@ -1,6 +1,7 @@ # %% import json from pathlib import Path +from unittest.mock import MagicMock, patch import matplotlib.pyplot as plt import numpy as np @@ -9,130 +10,102 @@ import torch from botorch.models.deterministic import GenericDeterministicModel from botorch.sampling.index_sampler import IndexSampler -from torch.distributions import Gumbel, MultivariateNormal +from setuptools import Distribution +from torch.distributions import Categorical, Gumbel, MultivariateNormal, Normal, Uniform from torch.utils.data import DataLoader from axtreme.data import FixedRandomSampler, ImportanceAddedWrapper, MinimalDataset +from axtreme.distributions.mixture import ApproximateMixture from axtreme.eval.qoi_job import QoIJob -from axtreme.qoi.marginal_cdf_extrapolation import MarginalCDFExtrapolation, acceptable_timestep_error, q_to_qtimestep +from axtreme.qoi.marginal_cdf_extrapolation import ( + MarginalCDFExtrapolation, + _create_lowerbound_degenerate_distribution_params, + _mixture_distribution_from_importance_samples, + acceptable_timestep_error, + q_to_qtimestep, +) torch.set_default_dtype(torch.float64) class TestMarginalCDFExtrapolation: """ - - Plan: + Test overview: - without importance sampling: - __call__: - - Unit test None - - Integration tests: - - batched params and weights - - dtype: - - float32 where safe - - float32 where not safe + - (unit) multiple posterior samples are handled correctly + - (unit) marginal CDF with insufficient precision is detected and raises error + - (integration) Using minimal input compare output to manually calculated expected value - _parameter_estimates: - - Integration test: - - batch produce same results as non batch - - 1 and multi (2) posterior samples. + - (unit) batched and non-batched env data produce the same result - with importance sampling: - - Unit test: - - _parameter_estimates: input and output weights are attached to the same samples - - System Test - - Show that that the QoI estimation with importance samples has less uncertainty in the result compared - to when using the regular approach of including the whole environment dataset. - - Other sub components we potentially should test? - - distributions with different batches get optimised/treated properly (e.g in optimisation_) + - _parameter_estimates: + - (unit): importance weight w_i is still attached to the correct sample at the end of the function + - (integration): toy example showing importance sampling can produce less variable QoI estimates. + - Helper: + - q_to_qtimestep: + - (unit) prove that log based calculation are not required for numerical stability + - (unit) Rough proof results stable for typical values in calculations we do. + - acceptable_timestep_error: + - (unit) Error raise when can't perform calculation with required precision """ - @pytest.mark.integration - @pytest.mark.parametrize( - "dtype, period_len", - [ - # Short period - (torch.float32, 3), - (torch.float64, 3), - # Realistic period length - (torch.float64, 25 * 365 * 24), - ], - ) - def test_call_basic_example( - self, gp_passthrough_1p: GenericDeterministicModel, dtype: torch.dtype, period_len: int - ): - """Runs a minimal version of the qoi using a deterministic model and a short period_len. - - Demonstrate both float32 and float64 can be used (with this short period) + def test___call__two_posterior_samples(self): + """__call__ with 2 posterior samples returns a result of shape (2,). - Take 2 posterior samples to confirm the shape can be supported throughout. + Mocks _parameter_estimates to return params with n_posterior_samples=2 and + checks the output shape is (2,), confirming the posterior sample dimension + propagates correctly through the mixture and icdf steps. """ - # Define the inputs - quantile = torch.tensor(0.5, dtype=dtype) - quantile_accuracy = torch.tensor(0.5, dtype=dtype) - # fmt: off - env_sample= torch.tensor( - [ - [[0], [1], [2]] - ], - dtype = dtype + dtype = torch.float64 + # Shape: (n_posterior_samples=2, n_env=3, n_targets=2) + params = torch.tensor( + [[[2.0, 1e-6], [2.0, 1e-6], [2.0, 1e-6]], [[2.0, 1e-6], [2.0, 1e-6], [2.0, 1e-6]]], + dtype=dtype, ) - # fmt: on + weights = torch.ones(2, 3, dtype=dtype) # shape: (n_posterior_samples=2, n_env=3) - # Run the method - qoi_estimator_non_batch = MarginalCDFExtrapolation( - env_iterable=env_sample, - period_len=period_len, - posterior_sampler=IndexSampler(torch.Size([2])), # draw 2 posterior samples - quantile=quantile, - quantile_accuracy=quantile_accuracy, + qoi_estimator = MarginalCDFExtrapolation( + env_iterable=[], # not used — _parameter_estimates is mocked + period_len=3, + quantile=torch.tensor(0.5, dtype=dtype), + quantile_accuracy=torch.tensor(0.5, dtype=dtype), dtype=dtype, ) - qoi = qoi_estimator_non_batch(gp_passthrough_1p) - - # Calculated the expected value directly. - # This relies on knowledge of the internals, specifically that the underlying distribution produce will be - # [Gumbel(0, 1e-6), Gumbel(1, 1e-6), Gumbel(2, 1e-6)]. The first two will be clipped to quantile q= 1-finfo.eps - # as per the bounds of ApproximateMixture - dist = Gumbel(torch.tensor(2, dtype=dtype), 1e-6) - q_timestep = (dist.cdf(qoi[0]) + (1 - torch.finfo(dtype).eps) * 2) / 3 - # check can be scaled up to the original timeframe with the desired accuracy - assert q_timestep**period_len == pytest.approx(quantile, abs=quantile_accuracy) + with patch.object(qoi_estimator, "_parameter_estimates", return_value=(params, weights)): + qoi = qoi_estimator(MagicMock()) - def test_call_insuffecient_numeric_precision(self, gp_passthrough_1p: GenericDeterministicModel): - """Runs a minimal version of the qoi using a deterministic model and a short period_len. + assert qoi.shape == torch.Size([2]) - Demonstrate both float32 and float64 can be used (with this short period) + def test___call__insufficient_numeric_precision(self): + """__call__ raises TypeError when float32 precision is too coarse for the period_len. - Take 2 posterior samples to confirm the shape can be supported throughout. + With float32 and a realistic 25-year period_len, the single-timestep CDF values + lack enough resolution for the required quantile_accuracy. The underlying icdf + solver detects this and raises TypeError. _parameter_estimates is mocked so the + test exercises only the __call__ precision-check logic. """ - # Define the inputs dtype = torch.float32 - quantile = torch.tensor(0.5, dtype=dtype) - quantile_accuracy = torch.tensor(0.5, dtype=dtype) - # fmt: off - env_sample= torch.tensor( - [ - [[0], [1], [2]] - ], - dtype = dtype - ) - # fmt: on + # Shape: (n_posterior_samples=1, n_env=3, n_targets=2) — simple Gumbel params + params = torch.tensor([[[2.0, 1e-6], [2.0, 1e-6], [2.0, 1e-6]]], dtype=dtype) + weights = torch.ones(1, 3, dtype=dtype) - # Run the method - qoi_estimator_non_batch = MarginalCDFExtrapolation( - env_iterable=env_sample, + qoi_estimator = MarginalCDFExtrapolation( + env_iterable=[], # not used — _parameter_estimates is mocked period_len=25 * 365 * 24, - posterior_sampler=IndexSampler(torch.Size([2])), # draw 2 posterior samples - quantile=quantile, - quantile_accuracy=quantile_accuracy, + quantile=torch.tensor(0.5, dtype=dtype), + quantile_accuracy=torch.tensor(0.5, dtype=dtype), dtype=dtype, ) - with pytest.raises(TypeError, match="The distribution provided does not have suitable resolution"): - _ = qoi_estimator_non_batch(gp_passthrough_1p) + with ( + patch.object(qoi_estimator, "_parameter_estimates", return_value=(params, weights)), + pytest.raises(TypeError, match="The distribution provided does not have suitable resolution"), + ): + _ = qoi_estimator(MagicMock()) - def test_parameter_estimates_env_batch_invariant( + def test__parameter_estimates_env_batch_invariant( self, gp_passthrough_1p_sampler: IndexSampler, gp_passthrough_1p: GenericDeterministicModel ): """Checks that batched and non-batch env data produce the same result. @@ -175,21 +148,14 @@ def test_parameter_estimates_env_batch_invariant( torch.testing.assert_close(param_non_batch, param_batch) torch.testing.assert_close(weight_non_batch, weight_batch) - def test_parameter_estimates_consistency_of_weights(self, gp_passthrough_1p: GenericDeterministicModel): - """ - Tests that the `_parameter_estimates` method in `MarginalCDFExtrapolation` correctly combines environment - samples and their associated importance weights, and that the outputs match expected values when using a - deterministic Gaussian Process (GP). The deterministic nature of the GP model leads to fully predictable - posterior samples, i.e. they are identical to the environment samples. + def test__parameter_estimates_consistency_of_weights(self, gp_passthrough_1p: GenericDeterministicModel): + """Minor check that the importance weights and samples don't get shuffled during the function. - This test ensures that: - - Posterior samples returned by `_parameter_estimates` are correctly ordered. - - Importance weights are preserved and correctly matched to the associated samples. + In other words, importance weight is attached to the correct sample at the end. + + Approach: + Use a deterministic GP so the inputs can be traced through to their output position. - Args: - gp_passthrough_1p is defined in conftest.py. It creates a deterministic GP which always produces identical - posterior samples. The output location is a direct pass through of the given input data, and the scale is - set to 1e-6. """ # MarginalCDFExtrapolation expects an iterable of env data. To use importance samples, each item is expected to # be of the following form [env_samples, importance_weights], where: @@ -227,32 +193,94 @@ def test_parameter_estimates_consistency_of_weights(self, gp_passthrough_1p: Gen # The calculated importance weights should be the same as the input importance weights assert torch.equal(torch.tensor([[0.1, 0.2, 0.3, 0.4]]), importance_weights_qoi) - @pytest.mark.system + @pytest.mark.integration + @pytest.mark.parametrize( + "dtype, period_len", + [ + # Short period + (torch.float32, 3), + (torch.float64, 3), + # Realistic period length + (torch.float64, 25 * 365 * 24), + ], + ) + def test__call__basic_example( + self, gp_passthrough_1p: GenericDeterministicModel, dtype: torch.dtype, period_len: int + ): + """Minimal MarginalCDFCExtrapolation calculation where expected value can be calculated directly. + + Uses 3 input points and a deterministic GP so expected result can be explicitly calculated. + """ + # Define the inputs + quantile = torch.tensor(0.5, dtype=dtype) + quantile_accuracy = torch.tensor(0.5, dtype=dtype) + # fmt: off + env_sample= torch.tensor( + [ + [[0], [1], [2]] + ], + dtype = dtype + ) + # fmt: on + + # Run the method + qoi_estimator_non_batch = MarginalCDFExtrapolation( + env_iterable=env_sample, + period_len=period_len, + posterior_sampler=IndexSampler(torch.Size([1])), + quantile=quantile, + quantile_accuracy=quantile_accuracy, + dtype=dtype, + ) + qoi = qoi_estimator_non_batch(gp_passthrough_1p) + + # Calculated the expected value directly. + # This relies on knowledge of the internals, specifically that the underlying distribution produce will be + # [Gumbel(0, 1e-6), Gumbel(1, 1e-6), Gumbel(2, 1e-6)]. The first two will be clipped to quantile q= 1-finfo.eps + # as per the bounds of ApproximateMixture + dist = Gumbel(torch.tensor(2, dtype=dtype), 1e-6) + q_timestep = (dist.cdf(qoi[0]) + (1 - torch.finfo(dtype).eps) * 2) / 3 + + # check can be scaled up to the original timeframe with the desired accuracy + assert q_timestep**period_len == pytest.approx(quantile, abs=quantile_accuracy) + + @pytest.mark.integration @pytest.mark.non_deterministic - # Ruff does not allow default arguments in test functions. Using a decorator circumvents that. - @pytest.mark.parametrize("error_tolerance, visualise", [(1, False)]) - def test_system_marginal_cdf_with_importance_sampling( + def test_marginal_cdf_with_importance_sampling( # noqa: PLR0915 self, - error_tolerance: float, + error_tolerance: float = 1.0, # noqa: PT028 *, - visualise: bool, + visualise: bool = False, # noqa: PT028 ): - """ - There is variability in the specific samples in the env_data used to instantiate a QoiEstimator, which creates - the variability of the QoIEstimator estimate. This can be seen by inspecting how the estimates given change when - the QoiEstimator has been instantiated with a different dataset. This test shows how (good) importance samples - can reduce the variability between estimates of QoIEstimators instantiated with different env_data. The effect - of GP uncertainty is removed by using a deterministic model, meaning all uncertainty in the estimate comes from - the environment samples. + """Toy example showing importance sampling can produce less variable QoI estimates. + + QoIEstimator need to integrate out (marginalise) the effect of the weather. This integration can be ESTIMATED + using sample based methods. This test demonstrates that importance sampling produces less variable (and still + correct) estimates compared to random sampling. + + NOTE: QoIEstimator output only shows GP variability. To understand the variability of the QoIEstimator due to + the environment samples the estimator must me run with different env samples (of the same size). + + Test overview: + Inputs + - Response functions: A tight normal distribution at (1,1) + - Environment distribution: Sample from std normal (with x1 > 0 and x2 > 0) + - Importance sampling distribution: Uniform samples within a circle of radius 1.75 (with x1 > 0 and x2 > 0) + + Process: + - 1) draw a subsample from the environment distribution or importance sampling distribution. + - 2) Run the QoIEstimator with this subsamples (The true underlying function is used inplace of the GP to + remove the effect of GP uncertainty and isolate the effect of the environment samples). The QoIEstimator + thus returns a single number per run. + - 3) Repeat set 1 and 2 many times. Compare the distribution of prediction. + + Expected result: + - Using the same number of samples, the importance sampling approach should have less variance in its + its estimates (and still be centered around the true value). Thresholds are set via visual inspection. Args: error_tolerance: The error allowed in assertions is multiplied by this number. visualise: Bool to specify if the QoI results shall be plotted. - - Expectation: - As we use a deterministic GP the QoI estimator will not be a distribution but a point representing the mean. - The std of the means of several runs of the QoI estimator should be lower with uncertainty sampling than - without. By visual inspection a threshold for the std for importance sampling is chosen. """ # Load precalculated importance samples and weights @@ -291,6 +319,36 @@ def _true_underlying_func(x: torch.Tensor) -> torch.Tensor: gp_deterministic = GenericDeterministicModel(_true_underlying_func, num_outputs=2) + if visualise: + _, ax = plt.subplots(1, 1, figsize=(10, 8)) + + # Plot 1: Overlay both distributions on a single scatter plot + _ = ax.scatter(env_data[:, 0], env_data[:, 1], alpha=0.2, label="Environment", color="steelblue", s=10) + _ = ax.scatter( + importance_samples[:, 0].numpy(), + importance_samples[:, 1].numpy(), + alpha=0.3, + label="Importance samples", + color="darkorange", + s=10, + ) + + # Plot 2: Heatmap of true underlying function (loc), only where value > 1 + all_x = np.concatenate([env_data[:, 0], importance_samples[:, 0].numpy()]) + all_y = np.concatenate([env_data[:, 1], importance_samples[:, 1].numpy()]) + x1_grid = np.linspace(all_x.min(), all_x.max(), 300) + x2_grid = np.linspace(all_y.min(), all_y.max(), 300) + X1, X2 = np.meshgrid(x1_grid, x2_grid) # noqa: N806 + grid = torch.tensor(np.stack([X1.ravel(), X2.ravel()], axis=1)) + with torch.no_grad(): + loc_values = _true_underlying_func(grid)[:, 0].numpy().reshape(X1.shape) + masked_values = np.where(loc_values > 1, loc_values, np.nan) + im = ax.pcolormesh(X1, X2, masked_values, cmap="viridis", shading="auto") + _ = plt.colorbar(im, ax=ax, label="loc (response)") + + _ = ax.set_title("Environment and importance samples with underlying response function") + _ = ax.legend + # Create jobs with with and without importance sampling qoi_jobs = [] datasets = {"full": env_data, "importance_sample": importance_dataset} @@ -356,7 +414,7 @@ def _true_underlying_func(x: torch.Tensor) -> torch.Tensor: df_jobs[df_jobs["dataset_name"] == "full"].hist(column="mean", ax=ax[0], grid=False) ax[0].axvline(brute_force_qoi, c="orange", label=f"Brute force ({brute_force_qoi:.2f})") - ax[0].set_title(f"Dataset: full, mean={std_qoi_means_full:.2f}, std={mean_qoi_means_full:.2f}") + ax[0].set_title(f"Dataset: full, mean={mean_qoi_means_full:.2f}, std={std_qoi_means_full:.2f}") ax[0].legend() # Plot results for importance sampling @@ -407,20 +465,23 @@ def test_q_to_qtimestep_numerical_precision_of_timestep_conversion( "q", [0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95] ) def test_q_to_qtimestep_numerical_precision_period_increase(q: float): - """Estimate the numerical error introduced through this operation. + """Rough check to ensure have enough numerical stability for type of calcs we commonly do. This calculates the "round trip error" of going q_longterm -> q_timestep -> q_longterm, as this is easier to test. This error may be larger than conversion q_longterm -> q_timestep. By default python uses float64 (on most machines). This has a precision of 1e-15. + Characteristics of common calcs: + - q = quantile of ERD, typically between 0.05 and 0.95 + - period_len = not expecting to be larger than 100 year simulation with 1 second time step is is approx 1e10. + - Absolute error typically acceptable in final quantile estimate q +- .001 + NOTE: - abs = 1e-10: all tests pass - abs = 1e-11: approx half the tests fail. - - By default python uses float64 (on most machines). This has a precision of 1e-15. """ - period_len = int(1e13) + period_len = int(1e13) # every second for 100 year = 1e10 q_step = q_to_qtimestep(q, period_len) assert q_step**period_len == pytest.approx(q, abs=1e-3) @@ -431,8 +492,236 @@ def test_acceptable_timestep_error_at_limits_of_precision(): _ = acceptable_timestep_error(0.5, int(1e6), atol=1e-10) +class TestMixtureDistributionFromImportanceSamples: + def test_unbatched_input(self): + dtype = torch.float64 + weights = torch.ones(4, dtype=dtype) / 4 + loc = torch.tensor([0.0, 10.0, 20.0, 30.0], dtype=dtype) + scale = torch.tensor([1.0, 1.0, 1.0, 1.0], dtype=dtype) + params = torch.concat([loc.unsqueeze(-1), scale.unsqueeze(-1)], dim=-1) + + dist, _ = _mixture_distribution_from_importance_samples(weights, params, Gumbel) + + # expected a new distribution with weight .75 to be added at the end + expected_weights = torch.tensor([0.0625, 0.0625, 0.0625, 0.0625, 0.75], dtype=dtype) + torch.testing.assert_close(dist.mixture_distribution.probs, expected_weights) + + # expect the component distribution size to be larger. + # Checking the additional value is appropriate is left to _create_lowerbound_degenerate_distribution_params + assert dist.component_distribution.loc.shape == torch.Size([5]) + + def test_basic_batched_input(self): + """Test batched inputs (e.g. params (*b, n_samples, n_targets)) are handled and each batch gets a unique + additional component""" + dtype = torch.float64 + weights = torch.ones(2, 4, dtype=dtype) + weights[0] /= 4 + weights[1] /= 5 + loc = torch.tensor([[0.0, 10.0, 20.0, 30.0], [40.0, 50.0, 60.0, 70.0]], dtype=dtype) + scale = torch.ones_like(loc) + params = torch.concat([loc.unsqueeze(-1), scale.unsqueeze(-1)], dim=-1) + + dist, _ = _mixture_distribution_from_importance_samples(weights, params, Gumbel) + + expected_weights = torch.tensor( + [[0.0625, 0.0625, 0.0625, 0.0625, 0.75], [0.05, 0.05, 0.05, 0.05, 0.8]], dtype=dtype + ) + torch.testing.assert_close(dist.mixture_distribution.probs, expected_weights) + + # Checking the add params finding adding cdf contribution before the component dist is left to + # TestCreateLowerboundDegenerateDistributionParams. Here small check that each batch got a unique addition. + assert dist.component_distribution.loc.shape == torch.Size([2, 5]) + # Rough sanity check that additional components are added to right place + assert dist.component_distribution.loc[0, -1].item() == pytest.approx(0 - 3, abs=3) + assert dist.component_distribution.loc[1, -1].item() == pytest.approx(40 - 3, abs=3) + + @pytest.mark.parametrize( + "p_dist, q_dist, expected_result", + [ + # Case supp(q) < supp(p). + (Normal(0, 1), Uniform(0, 3), 0.5), + # Case supp(q) >= supp(p). + (Uniform(0, 3), Normal(0, 1), 1.0), + ], + ) + def test_p_over_q_integral_estimate_and_uncertainty( + self, p_dist: Distribution, q_dist: Distribution, expected_result: float + ): + """Ignore the component distribution and check the integral int_supp(q){(p)} has good mean. + + Perform a calculation where the result is know analytically. + """ + # importance samples from q + with torch.random.fork_rng(): + _ = torch.manual_seed(10) + # Take a large number of sample as currently only interested in checking the integral estimate is good.b + sample = q_dist.sample((10_000,)) # pyright: ignore[reportAttributeAccessIssue] + + # Calculate the weights. This gets a bit convoluted because we need to manually set values outside the support. + in_p_support = p_dist.support.check(sample) # pyright: ignore[reportAttributeAccessIssue] + weights = torch.zeros_like(sample) + weights[in_p_support] = torch.exp(p_dist.log_prob(sample[in_p_support]) - q_dist.log_prob(sample[in_p_support])) # pyright: ignore[reportAttributeAccessIssue] + + dummy_params = torch.ones((*sample.shape, 2)) + + dist, _ = _mixture_distribution_from_importance_samples( + weights=weights, + params=dummy_params, + component_dist_class=Gumbel, # Note this is just a placeholder, we don't care about the component dist + ) + + # integral_p_over_not_q is added to the end of the weights + integral_p_over_q_est = 1 - dist.mixture_distribution.probs[-1] + assert integral_p_over_q_est.item() == pytest.approx(expected_result, abs=0.01) + + # TODO(sw 2026-04-12): could add test to check uncertainty is well calibrated. Skipping for now as the formula + # is pretty straight forward and we don't currently rely on the number. + + def test_p_over_q_integral_estimate_clipping_and_warning(self): + """Simple test to check weight clipping and warning when int_supp(q)(p) > 1.""" + dtype = torch.float64 + n_samples = 4 + # weights with mean = 2.0 > 1, simulating an over-estimated integral + weights = torch.full((n_samples,), 2.0, dtype=dtype) + loc = torch.tensor([0.0, 10.0, 20.0, 30.0], dtype=dtype) + scale = torch.ones(n_samples, dtype=dtype) + params = torch.concat([loc.unsqueeze(-1), scale.unsqueeze(-1)], dim=-1) + + with pytest.warns(UserWarning, match="exceeds 1"): + dist, _ = _mixture_distribution_from_importance_samples(weights, params, Gumbel) + + # When clipped: integral_p_over_not_q = 1 - 1 = 0, so the degenerate component has weight 0 + assert dist.mixture_distribution.probs[-1].item() == pytest.approx(0.0, abs=1e-10) + + def test_cdf_equivalent_when_q_subset_q(self, visualise: bool = False): # noqa: FBT001, FBT002, PT028 + """Tests importance sampling can exclude regions of 0 response (corresponding to CDF(R<=0) = 1). + + ``_mixture_distribution_from_importance_samples`` is designed to relax importance sampling requirements: + - from: q(x) = 0 -> f(x)p(x) = 0 + - to: q(x) = 0 -> f(x) = 1 OR p(x) = 0 + This test checks the CDF produced when q excludes regions of 0 response is correct. + + Inputs: + - Environment distributions: Uniform(0,1) + - Importance sampling distribution: Uniform(0.75,1) + - Response function: The conceptually show how the response is generated (the response function is not used in + the test) + - x in [0,.75]: 0 + - x in [.75,1]: Gumbel(loc = 1, scale = 1) + - true_underlying function: Generates the location and scale corresponding to the response function + - x in [0,.75] -> loc = 0, scale = 1e-6 (to approximate a step function) + - x in [.75,1] -> loc = 1, scale = 1 + + Process: + - 1) calculate the resulting CDF without importance sampling (or analytically) + - 2) calculate the CDF with importance sampling (where q excludes regions of 0 response) + + Expected result: + Both produce the same CDF + """ + env_dist = Uniform(0, 1) + is_dist = Uniform(0.75, 1) + + analytical_dist = ApproximateMixture( + mixture_distribution=Categorical(torch.tensor([0.75, 0.25])), # 75% mass on zero response, 25% on active + component_distribution=Gumbel(loc=torch.tensor([0.0, 1.0]), scale=torch.tensor([1e-6, 1.0])), + ) + + def true_underlying(x: torch.Tensor) -> torch.Tensor: + in_active_region = x >= 0.75 + loc = torch.where(in_active_region, torch.tensor(1.0), torch.tensor(0.0)) + scale = torch.where(in_active_region, torch.tensor(1.0), torch.tensor(1e-6)) + return torch.stack([loc, scale], dim=-1) + + # Importance sample (q subset p): + n_samples = 10_000 + with torch.random.fork_rng(): + _ = torch.manual_seed(10) + is_samples = is_dist.sample((n_samples,)) + # p(x)/q(x) = 1/0.25 = 4 + is_weights = torch.exp(env_dist.log_prob(is_samples) - is_dist.log_prob(is_samples)) + is_params = true_underlying(is_samples) + # NOTE: use arguement `lower_bound`` if want to plot over the entire domain. + # Typically our optimisation only searches in the importance region as we look for large q value + is_dist, _ = _mixture_distribution_from_importance_samples( + weights=is_weights, params=is_params, component_dist_class=Gumbel + ) + + # Check the distribution the approximately equal (within the important bounds) + x_range = torch.linspace(0.75, 1, 100) + expected_cdf = analytical_dist.cdf(x_range) + actual_cdf = is_dist.cdf(x_range) + torch.testing.assert_close(expected_cdf, actual_cdf, atol=0.01, rtol=0.0) + + if visualise: + # for demo purposes can also put the MC estimate on the plot: + # Direct monte carlo estimate: + n_samples = 10_000 + env_samples = env_dist.sample((n_samples,)) + params = true_underlying(env_samples) + # Not importance sampling, so no weights + weights = torch.ones_like(env_samples) + mc_dist = ApproximateMixture( + mixture_distribution=Categorical(weights), + component_distribution=Gumbel(loc=params[:, 0], scale=params[:, 1]), + ) + + _, ax = plt.subplots(1, 1, figsize=(10, 8)) + _ = ax.plot(x_range, mc_dist.cdf(x_range), label="MC CDF", color="green", linestyle="dotted") + _ = ax.plot(x_range, expected_cdf, label="Analytical CDF", color="blue") + _ = ax.plot(x_range, actual_cdf, label="IS CDF", color="orange", linestyle="dashed") + _ = ax.set_title("CDF comparison between analytical and importance sampling approach") + _ = ax.set_xlabel("x") + _ = ax.set_ylabel("CDF") + _ = ax.legend() + + +class TestCreateLowerboundDegenerateDistributionParams: + def test_simple_dist(self): + """Degenerate dist finishes adding mass before the single component starts.""" + comp_dist = Gumbel(loc=torch.tensor([0.0, 10.0]), scale=torch.tensor([1.0, 1.0])) + params = _create_lowerbound_degenerate_distribution_params(comp_dist) + dtype = params.dtype + finfo = torch.finfo(dtype) + # Every component's lower tail must start at or above where the degenerate dist finishes + component_lower_bounds = comp_dist.icdf(torch.tensor(finfo.eps)).min(dim=-1).values # noqa: PD011 + degenerate_dist_upper_bound = Gumbel(*torch.unbind(params, dim=-1)).icdf(torch.tensor(1 - finfo.eps)) + assert component_lower_bounds >= degenerate_dist_upper_bound + + def test_batched_dist_different_scales(self): + """Degenerate dist is placed before the lowest-starting component when locs and scales differ.""" + comp_dist = Gumbel(loc=torch.tensor([[0.0, 10.0], [1.0, 1.0]]), scale=torch.tensor([[0.5, 5.0], [1.0, 1.0]])) + params = _create_lowerbound_degenerate_distribution_params(comp_dist) + dtype = params.dtype + finfo = torch.finfo(dtype) + # The degenerate dist must finish before ALL components start adding mass + component_lower_bounds = comp_dist.icdf(torch.tensor(finfo.eps)).min(dim=-1).values # noqa: PD011 + degenerate_dist_upper_bound = Gumbel(*torch.unbind(params, dim=-1)).icdf(torch.tensor(1 - finfo.eps)) + assert (component_lower_bounds >= degenerate_dist_upper_bound).all() + + def test_lower_bound_too_high_raises(self): + """Passing a lower_bound above the component dist's lower tail raises ValueError.""" + comp_dist = Gumbel(loc=torch.tensor([0.0, 10.0]), scale=torch.tensor([1.0, 1.0])) + dtype = comp_dist.loc.dtype + finfo = torch.finfo(dtype) + actual_lower = comp_dist.icdf(torch.tensor(finfo.eps)).min().item() + too_high = actual_lower + 1.0 + with pytest.raises(ValueError, match="lower_bound provided"): + _ = _create_lowerbound_degenerate_distribution_params(comp_dist, lower_bound=too_high) + + def test_lower_bound_set_appropriately(self): + """When lower_bound is set below all components, degenerate dist finishes at or before lower_bound.""" + comp_dist = Gumbel(loc=torch.tensor([0.0, 10.0]), scale=torch.tensor([1.0, 1.0])) + lower_bound = -20.0 + params = _create_lowerbound_degenerate_distribution_params(comp_dist, lower_bound=lower_bound) + dtype = params.dtype + finfo = torch.finfo(dtype) + # The degenerate dist must have finished adding mass by lower_bound + assert Gumbel(*torch.unbind(params, dim=-1)).icdf(torch.tensor(1 - finfo.eps)).item() <= lower_bound + + # %% Can be used to get plots for test_system_marginal_cdf_with_importance_sampling if __name__ == "__main__": # %% MarginalCDF = TestMarginalCDFExtrapolation() - MarginalCDF.test_system_marginal_cdf_with_importance_sampling(1, visualise=True) + MarginalCDF.test_marginal_cdf_with_importance_sampling(1, visualise=True) diff --git a/tests/utils/test_distibution_helper.py b/tests/utils/test_distribution_helper.py similarity index 78% rename from tests/utils/test_distibution_helper.py rename to tests/utils/test_distribution_helper.py index 484cdb8d..78183f05 100644 --- a/tests/utils/test_distibution_helper.py +++ b/tests/utils/test_distribution_helper.py @@ -5,7 +5,7 @@ from scipy import stats from scipy.stats._distn_infrastructure import rv_continuous -from axtreme.utils import distibution_helpers +from axtreme.utils import distribution_helpers @pytest.mark.parametrize( @@ -17,11 +17,11 @@ ], ) def test_distribution_parameter_names_from_scipy(dist: rv_continuous, expected: list[str]): - result = distibution_helpers.distribution_parameter_names_from_scipy(dist) + result = distribution_helpers.distribution_parameter_names_from_scipy(dist) assert result == expected -# TODO(sw): How do we chance that the uncertainty (cov) we are getting is reasonable? +# TODO(sw): How do we check that the uncertainty (cov) we are getting is reasonable? @pytest.mark.parametrize( "dist, params", [ @@ -36,5 +36,5 @@ def test_distribution_parameter_names_from_scipy(dist: rv_continuous, expected: ) def test_fit_dist_with_uncertainty(dist: rv_continuous, params: dict[str, Any]): sample = dist.rvs(**params, size=10_000, random_state=7) - means, _ = distibution_helpers.fit_dist_with_uncertainty(sample, dist) + means, _ = distribution_helpers.fit_dist_with_uncertainty(sample, dist) np.testing.assert_allclose(means, list(params.values()), atol=1e-2)