diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 8c596635e..c5fca5261 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -21,3 +21,4 @@ repos: rev: 0.8.1 hooks: - id: nbstripout + exclude: ^case_studies/ diff --git a/autoemulate/calibration/history_matching.py b/autoemulate/calibration/history_matching.py index ede9abb9a..7cf6deca6 100644 --- a/autoemulate/calibration/history_matching.py +++ b/autoemulate/calibration/history_matching.py @@ -1,14 +1,23 @@ import logging import warnings +import matplotlib.pyplot as plt +import pandas as pd +import seaborn as sns import torch +from matplotlib.colors import Normalize +from matplotlib.figure import Figure +from torch.distributions.multivariate_normal import MultivariateNormal from autoemulate.core.device import TorchDeviceMixin -from autoemulate.core.types import DeviceLike, TensorLike +from autoemulate.core.plotting import display_figure +from autoemulate.core.results import Result +from autoemulate.core.types import DeviceLike, DistributionLike, TensorLike from autoemulate.data.utils import set_random_seed -from autoemulate.emulators.base import ProbabilisticEmulator +from autoemulate.emulators import TransformedEmulator, get_emulator_class from autoemulate.simulations.base import Simulator +logging.basicConfig(level=logging.INFO) logger = logging.getLogger("autoemulate") @@ -267,21 +276,22 @@ class HistoryMatchingWorkflow(HistoryMatching): Run history matching workflow: - sample parameter values to test from the current NROY parameter space - - use emulator to rule out implausible parameters and update NROY space - - make predictions for a subset the NROY parameters using the simulator + - use emulator to rule out implausible parameter samples + - run simulations for a subset of the NROY parameters - refit the emulator using the simulated data """ def __init__( self, simulator: Simulator, - emulator: ProbabilisticEmulator, + result: Result, observations: dict[str, tuple[float, float]] | dict[str, float], threshold: float = 3.0, model_discrepancy: float = 0.0, rank: int = 1, train_x: TensorLike | None = None, train_y: TensorLike | None = None, + calibration_params: list[str] | None = None, device: DeviceLike | None = None, random_seed: int | None = None, ): @@ -292,8 +302,8 @@ def __init__( ---------- simulator: Simulator A simulator. - emulator: ProbabilisticEmulator - A ProbabilisticEmulator pre-trained on `simulator` data. + result: Result + A Result object containing the pre-trained emulator and its hyperparameters. observations: dict[str, tuple[float, float] | dict[str, float] For each output variable, specifies observed [value, noise] (with noise specified as variances). In case of no uncertainty in observations, provides @@ -313,74 +323,240 @@ def __init__( Optional tensor of input data the emulator was trained on. train_y: TensorLike | None Optional tensor of output data the emulator was trained on. + calibration_params: list[str] | None + Optional subset of parameters to calibrate. These have to correspond to the + parameters that the emulator was trained on. If None, calibrate all + simulator parameters. device: DeviceLike | None The device to use. If None, the default torch device is returned. + random_seed: int | None + Optional random seed for reproducibility. If None, no seed is set. """ super().__init__(observations, threshold, model_discrepancy, rank, device) self.simulator = simulator if random_seed is not None: set_random_seed(seed=random_seed) - self.emulator = emulator + self.result = result + self.emulator = result.model + self.emulator.device = self.device - # These get updated when run() is called and used to refit the emulator + # New data is simulated in `run()` and appended here + # It can be used to refit the emulator if train_x is not None and train_y is not None: - self.train_x = train_x.to(self.device) - self.train_y = train_y.to(self.device) + self.train_x = train_x.float().to(self.device) + self.train_y = train_y.float().to(self.device) else: self.train_x = torch.empty((0, self.simulator.in_dim), device=self.device) self.train_y = torch.empty((0, self.simulator.out_dim), device=self.device) - def generate_samples(self, n: int) -> tuple[TensorLike, TensorLike]: + # New NROY samples are generated in `run()` and used in `cloud_sample()` + # We only ever use the most recent NROY samples + # This means `self.nroy_samples` gets overwritten each time `run()` is called + self.nroy_samples = None + + # If use `run_waves()`, results are stored here + self.wave_results = [] + + # Save names and indices of parameters to calibrate + self.calibration_params = calibration_params or list( + simulator.parameters_range.keys() + ) + self.parameter_idx = [ + self.simulator.get_parameter_idx(param) for param in self.calibration_params + ] + + def _is_within_bounds( + self, sample: TensorLike, bounds_dict: dict[str, tuple[float, float]] + ) -> bool: """ - Generate parameter samples and evaluate implausibility. + Check if `sample` is within the bounds defined in `bounds_dict`. - Draw `n` samples from the simulator min/max parameter bounds and - evaluate implausability given emulator predictions. + Parameters + ---------- + sample: torch.Tensor + A single sample of input parameters to check, shape [1, in_dim]. + bounds_dict: dict of {param_name: [lower, upper]} + A dictionary of parameter bounds for each parameter. + + Returns + ------- + bool + True if the sample is within the bounds, False otherwise. + """ + sample = sample.squeeze(0) # shape: [in_dim] + lowers = torch.tensor( + [bounds[0] for bounds in bounds_dict.values()], + dtype=sample.dtype, + device=sample.device, + ) + uppers = torch.tensor( + [bounds[1] for bounds in bounds_dict.values()], + dtype=sample.dtype, + device=sample.device, + ) + return bool(torch.all((sample >= lowers) & (sample <= uppers)).item()) + + def _sample_within_bounds( + self, + dist: DistributionLike, + bounds: dict[str, tuple[float, float]], + n: int, + constant_params: dict[int, float] | None = None, + sample_params_idx: list[int] | None = None, + ) -> list[TensorLike]: + """ + Sample from distribution until `n` valid samples within the bounds are obtained. + + Handles constant parameters by inserting their values at the correct indices. Parameters ---------- + dist: DistributionLike + A distribution to sample from, e.g., MultivariateNormal. + bounds: dict[str, tuple[float, float]] + A dictionary of [min, max] parameter bounds for each sampled parameter. n: int - The number of parameter samples to generate. + The number of samples to generate. + constant_params: dict[int, float] | None + A dictionary of constant parameter indices and their values. + sample_params_idx: list[int] + Indices of parameters that are not constant. Returns ------- - tuple[TensorLike, TensorLike] - A tensor of tested input parameters and their implausability scores. + list[TensorLike] + A list of valid samples that are within the bounds. """ - # Generate `n` parameter samples from within NROY bounds - test_x = self.simulator.sample_inputs(n).to(self.device) + param_dim = len(bounds) + if sample_params_idx is None: + sample_params_idx = list(range(len(bounds))) + + valid_samples = [] + while len(valid_samples) < n: + n_remaining = n - len(valid_samples) + samples = dist.sample((n_remaining,)) + full = torch.empty( + (n_remaining, param_dim), + dtype=samples.dtype, + device=samples.device, + ) + if constant_params: + const_idx = list(constant_params.keys()) + const_vals = torch.tensor( + list(constant_params.values()), + dtype=samples.dtype, + device=samples.device, + ) + full[:, const_idx] = const_vals + full[:, sample_params_idx] = samples + valid_samples.extend([s for s in full if self._is_within_bounds(s, bounds)]) + return valid_samples - # Rule out implausible parameters from samples using an emulator - pred = self.emulator.predict(test_x) - impl_scores = self.calculate_implausibility(pred.mean, pred.variance) + def cloud_sample(self, n: int, scaling_factor: float = 0.1) -> TensorLike: + """ + Generate `n` additional parameter samples using cloud sampling. - return test_x, impl_scores + Handles fixed parameters (min == max) by not sampling those. The constant + values are inserted at the correct indices in the sampled tensor. + + Parameters + ---------- + n: int + The number of samples to generate. + scaling_factor: float + The standard deviation of the Gaussian to sample from in cloud sampling is + set to: `parameter range * scaling_factor`. + + Returns + ------- + TensorLike + A tensor of sampled (and potentially constant) parameters [n, in_dim]. + """ + assert isinstance(self.nroy_samples, TensorLike) + + bounds = self.generate_param_bounds(self.nroy_samples, buffer_ratio=0.0) + assert bounds is not None + + # Identify constant parameters + min_vals = torch.tensor([b[0] for b in bounds.values()], device=self.device) + max_vals = torch.tensor([b[1] for b in bounds.values()], device=self.device) + is_constant = min_vals == max_vals + constant_params = { + i: min_vals[i].item() for i, fixed in enumerate(is_constant) if fixed + } + sample_params_idx = [i for i, fixed in enumerate(is_constant) if not fixed] + + # If all parameters are constant just return the constant sample n times + if len(sample_params_idx) == 0: + msg = "All parameters are constant, cannot sample from them." + raise ValueError(msg) + + # Only use non-constant parameters for mean and covariance to sample from + nroy_params_to_sample = self.nroy_samples[:, sample_params_idx] + stdev = ( + nroy_params_to_sample.max(dim=0).values + - nroy_params_to_sample.min(dim=0).values + ) * scaling_factor + covariance_matrix = torch.diag(stdev**2) + + # Shuffle the order of means to sample from + num_means = nroy_params_to_sample.shape[0] + perm = torch.randperm(num_means, device=nroy_params_to_sample.device) + + # Determine how many samples to draw for each mean, handle remainder + min_samples_per_mean = n // num_means + remainder_to_sample = n % num_means + + all_valid_samples = [] + for i, mean in enumerate(nroy_params_to_sample[perm]): + n_samples = min_samples_per_mean + (1 if i < remainder_to_sample else 0) + mvn = MultivariateNormal(mean, covariance_matrix) + all_valid_samples.extend( + self._sample_within_bounds( + mvn, bounds, n_samples, constant_params, sample_params_idx + ) + ) + + return torch.stack(all_valid_samples, dim=0) - def update_simulator_bounds(self, nroy_x: TensorLike, buffer_ratio: float = 0.05): + def generate_samples( + self, n: int, scaling_factor: float = 0.1 + ) -> tuple[TensorLike, TensorLike]: """ - Update simulator parameter bounds to min/max of NROY parameter samples. + Generate parameter samples and evaluate implausibility. + + Draw `n` samples either from the simulator min/max parameter bounds or + using cloud sampling centered at NROY samples. Evaluate sample + implausability using emulator predictions. Parameters ---------- - nroy_x: TensorLike - A tensor of NROY parameter samples [n_samples, n_inputs] - buffer_ratio: float - A scaling factor used to expand the bounds of the (NROY) parameter space. - It is applied as a ratio of the range (max_val - min_val) of each input - parameter to create a buffer around the NROY minimum and maximum values. + n: int + The number of parameter samples to generate. + scaling_factor: float + The standard deviation of the Gaussian used in cloud sampling is + set to: `parameter range * scaling_factor`. + + Returns + ------- + tuple[TensorLike, TensorLike] + A tensor of tested input parameters and their implausability scores. """ - # [n_outputs, 2] where second dim is [min, max] - param_bounds = self.generate_param_bounds(nroy_x, buffer_ratio) - if param_bounds is not None: - self.simulator._param_bounds = list(param_bounds.values()) + # Generate `n` parameter samples (use simulator if have no NROY samples) + if self.nroy_samples is None: + test_x = self.simulator.sample_inputs(n).to(self.device) else: - warnings.warn( - ( - f"Could not update simulator parameter bounds only " - f"{nroy_x.shape[0]} samples were provided." - ), - stacklevel=2, - ) + test_x = self.cloud_sample(n, scaling_factor).to(self.device) + + # Rule out implausible parameters from samples using an emulator, + # only use calibration parameter subset + mean, variance = self.emulator.predict_mean_and_variance( + test_x[:, self.parameter_idx] + ) + assert variance is not None + impl_scores = self.calculate_implausibility(mean, variance) + + return test_x, impl_scores def sample_tensor(self, n: int, x: TensorLike) -> TensorLike: """ @@ -430,12 +606,38 @@ def simulate(self, x: TensorLike) -> tuple[TensorLike, TensorLike]: return x, y + def refit_emulator(self, x: TensorLike, y: TensorLike) -> None: + """ + Refit the emulator on the provided data. + + Parameters + ---------- + x: TensorLike + Tensor of input data to refit the emulator on. + y: TensorLike + Tensor of output data to refit the emulator on. + """ + # Create a fresh model with the same configuration + self.emulator = TransformedEmulator( + x.float(), + y.float(), + model=get_emulator_class(self.result.model_name), + x_transforms=self.result.x_transforms, + y_transforms=self.result.y_transforms, + device=self.device, + **self.result.params, + ) + + self.emulator.fit(x, y) + def run( self, n_simulations: int = 100, n_test_samples: int = 10000, max_retries: int = 3, - buffer_ratio: float = 0.0, + scaling_factor: float = 0.1, + refit_emulator: bool = True, + refit_on_all_data: bool = True, ) -> tuple[TensorLike, TensorLike]: """ Run a wave of the history matching workflow. @@ -443,22 +645,25 @@ def run( Parameters ---------- n_simulations: int - The number of simulations to run. + Number of simulations to run. n_test_samples: int Number of input parameters to test for implausibility with the emulator. Parameters to simulate are sampled from this NROY subset. max_retries: int Maximum number of times to try to generate `n_simulations` NROY parameters. That is the maximum number of times to repeat the following steps: - - draw `n_test_samples` parameters - - use emulator to make predictions for those parameters - - score implausability of parameters given predictions - - identify NROY parameters within this set - buffer_ratio: float - A scaling factor used to expand the bounds of the (NROY) parameter space. - It is applied as a ratio of the range (max_val - min_val) of each input - parameter to create a buffer around the NROY minimum and maximum values - when updating the simulator parameter bounds. + - draw `n_test_samples` parameters (use cloud sampling if possible) + - use emulator to make predictions for those parameters + - score implausability of parameters given predictions + - identify NROY parameters within this set + scaling_factor: float + The standard deviation of the Gaussian to sample from in cloud sampling is + set to: `parameter range * scaling_factor`. + refit_emulator: bool + Whether to refit the emulator at the end of the run. Defaults to True. + refit_on_all_data: bool + Whether to refit the emulator on all available data or just the data + available from the most recent simulation run. Defaults to True. Returns ------- @@ -466,12 +671,11 @@ def run( A tensor of tested input parameters and their implausibility scores from which simulation samples were then selected. """ - logger.debug( - "Running history matching workflow with" - " %d simulations and %d test samples.", - n_simulations, - n_test_samples, + msg = ( + f"Running history matching wave with {n_simulations} simulations and " + f"{n_test_samples} test samples" ) + logger.debug(msg) test_parameters_list, impl_scores_list, nroy_parameters_list = ( [], @@ -484,12 +688,17 @@ def run( if retries == max_retries: msg = ( f"Could not generate n_simulations ({n_simulations}) samples " - f"that are NROY after {max_retries} retries." + f"that are NROY after {max_retries} retries. " + f"Only {torch.cat(nroy_parameters_list, 0).shape[0]} " + "samples generated." ) - raise RuntimeError(msg) + raise Warning(msg) + break # Generate `n_test_samples` with implausability scores, identify NROY - test_parameters, impl_scores = self.generate_samples(n_test_samples) + test_parameters, impl_scores = self.generate_samples( + n_test_samples, scaling_factor + ) nroy_parameters = self.get_nroy(impl_scores, test_parameters) # Store results @@ -497,22 +706,361 @@ def run( test_parameters_list.append(test_parameters) impl_scores_list.append(impl_scores) + msg = ( + f"Generated {nroy_parameters.shape[0]} NROY samples on try " + f"{retries + 1}, have {torch.cat(nroy_parameters_list, 0).shape[0]} " + f"total NROY samples so far." + ) + logger.debug(msg) + retries += 1 - # Update simulator parameter bounds to NROY region - # Next time that call run(), will sample from within this region - nroy_parameters_all = torch.cat(nroy_parameters_list, 0) - self.update_simulator_bounds(nroy_parameters_all, buffer_ratio) + # Next time that call run(), will sample using these NROY points + self.nroy_samples = torch.cat(nroy_parameters_list, 0) # Randomly pick at most `n_simulations` parameters from NROY to simulate - nroy_simulation_samples = self.sample_tensor(n_simulations, nroy_parameters_all) + nroy_simulation_samples = self.sample_tensor(n_simulations, self.nroy_samples) # Make predictions using simulator (this updates self.x_train and self.y_train) - _, _ = self.simulate(nroy_simulation_samples) - - # Refit emulator using all available data - assert self.emulator is not None - self.emulator.fit(self.train_x, self.train_y) + x, y = self.simulate(nroy_simulation_samples) + + # Optionally refit the emulator using the most recent simulations or all data + if refit_emulator: + data_msg = "all data" if refit_on_all_data else "most recent data" + msg = f"Refitting emulator on {data_msg}." + logger.info(msg) + if refit_on_all_data: + self.refit_emulator(self.train_x[:, self.parameter_idx], self.train_y) + else: + self.refit_emulator(x[:, self.parameter_idx], y) # Return test parameters and impl scores for this run/wave return torch.cat(test_parameters_list, 0), torch.cat(impl_scores_list, 0) + + def run_waves( + self, + n_waves: int = 5, + frac_nroy_stop: float = 0.9, + n_simulations: int = 100, + n_test_samples: int = 10000, + max_retries: int = 3, + scaling_factor: float = 0.1, + refit_emulator_on_last_wave: bool = True, + refit_on_all_data: bool = True, + ) -> list[tuple[TensorLike, TensorLike]]: + """ + Run multiple waves of the history matching workflow. + + Refits the emulator after each wave (except the last), using all available data. + + Parameters + ---------- + n_waves: int + The maximum number of waves to run. + frac_nroy_stop: float + Fraction of NROY samples to stop at. If less than this fraction of + NROY samples is reached, the workflow stops. + n_simulations: int + Number of simulations to run in each wave. + n_test_samples: int + Number of input parameters to test for implausibility with the emulator. + Parameters to simulate are sampled from this NROY subset. + max_retries: int + Maximum number of times to try to generate `n_simulations` NROY parameters. + That is the maximum number of times to repeat the following steps: + - draw `n_test_samples` parameters (use cloud sampling if possible) + - use emulator to make predictions for those parameters + - score implausibility of parameters given predictions + - identify NROY parameters within this set + scaling_factor: float + The standard deviation of the Gaussian to sample from in cloud sampling is + set to: `parameter range * scaling_factor`. + refit_emulator_on_last_wave: bool + Whether to refit the emulator after the last wave. Defaults to True. + refit_on_all_data: bool + Whether to refit the emulator on all available data after each wave + or just the data from the most recent simulation run. Defaults to True. + + Returns + ------- + tuple[TensorLike, TensorLike] + A tensor of tested input parameters and their implausibility scores. + """ + self.wave_results = [] + for i in range(n_waves): + logger.info("Running history matching wave %d/%d", i + 1, n_waves) + refit_emulator = i != n_waves - 1 or refit_emulator_on_last_wave + test_x, impl_scores = self.run( + n_simulations=n_simulations, + n_test_samples=n_test_samples, + max_retries=max_retries, + scaling_factor=scaling_factor, + refit_emulator=refit_emulator, + refit_on_all_data=refit_on_all_data, + ) + + if len(test_x) < n_simulations or len(impl_scores) < n_simulations: + msg = ( + f"Not enough parameters or impl scores generated in wave {i + 1}" + f"/{n_waves}. Stopping history matching workflow. Results are " + f"stored until wave {i}/{n_waves}." + ) + logger.warning(msg) + break + + self.wave_results.append((test_x, impl_scores)) + + # Get NROY points from impl scores and check fraction + nroy_x = self.get_nroy(impl_scores, test_x) + nroy_frac = nroy_x.shape[0] / test_x.shape[0] + logger.info( + "Wave %d/%d: NROY fraction is %.2f%%", + i + 1, + n_waves, + nroy_frac * 100, + ) + if nroy_frac > frac_nroy_stop: + logger.info( + "Stopping history matching workflow at wave %d/%d " + "with NROY fraction %.2f%% > %.2f%%", + i + 1, + n_waves, + nroy_frac * 100, + frac_nroy_stop * 100, + ) + break + + return self.wave_results + + def plot_run( + self, + test_parameters: TensorLike, + impl_scores: TensorLike, + set_simulator_axis_limits: bool = True, + ref_val: dict[str, float] | None = None, + title: str = "History Matching Results", + fname: str | None = None, + ) -> None | Figure: + """ + Plot results of a single history matching run. + + Parameters + ---------- + test_parameters: TensorLike + A tensor of tested input parameters [n_samples, n_inputs]. + impl_scores: TensorLike + A tensor of implausibility scores for the tested input parameters. + set_simulator_axis_limits: bool + Whether to keep the simulator parameter ranges as axis limits. + ref_val:dict[str, float] | None + Optional dictionary of true parameter values to mark on the plots. + title: str + Title for the plot. + fname: str | None + Optional filename to save the plot to. If None, the plot is displayed. + + Returns + ------- + None | Figure + If `fname` is provided, saves the plot to the file and returns None. + If `fname` is None, displays the plot and returns the plot figure. + """ + test_parameters_plausible = self.get_nroy(impl_scores, test_parameters) + impl_scores_plausible = self.get_nroy(impl_scores, impl_scores) + + df = pd.DataFrame( + test_parameters_plausible[:, self.parameter_idx], + columns=self.calibration_params, # pyright: ignore[reportArgumentType] + ) + df["Implausibility"] = impl_scores_plausible.cpu().numpy().mean(axis=1) + g = sns.PairGrid(df, vars=self.calibration_params, corner=True) + + norm = Normalize( + vmin=df["Implausibility"].min(), # pyright: ignore[reportArgumentType] + vmax=df["Implausibility"].max(), # pyright: ignore[reportArgumentType] + ) + cmap = plt.cm.get_cmap("viridis") + + def scatter_continuous(x, y, **kwargs): + ax = plt.gca() + sc = ax.scatter( + x, + y, + c=df.loc[x.index, "Implausibility"], + cmap=cmap, + norm=norm, + s=15, + alpha=0.7, + ) + # Set axis limits if available + if set_simulator_axis_limits: + ax.set_xlim(self.simulator.parameters_range[x.name]) + ax.set_ylim(self.simulator.parameters_range[y.name]) + return sc + + def diag_hist(x, **kwargs): + ax = plt.gca() + sns.histplot(x, kde=False, color="gray", ax=ax) + # Set axis limits if available + if set_simulator_axis_limits: + ax.set_xlim(self.simulator.parameters_range[x.name]) + + g.map_lower(scatter_continuous) + g.map_diag(diag_hist) + + # Add reference points + if ref_val is not None: + for i, parami in enumerate(self.calibration_params): + for j, paramj in enumerate(self.calibration_params): + if j < i: # lower triangle only + ax = g.axes[i, j] + ax.scatter( + ref_val[paramj], + ref_val[parami], + color="white", + s=60, + edgecolor="black", + marker="X", + zorder=5, + label=( + "True value" + if (i == len(self.calibration_params) - 1 and j == 0) + else None + ), + ) + + # Colorbar + sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm) + sm.set_array([]) + plt.colorbar(sm, ax=plt.gcf().axes, shrink=0.7, label="Implausibility") + + # Global legend (handles all subplots) + handles, labels = g.axes[-1, 0].get_legend_handles_labels() + g.fig.legend(handles, labels, loc="upper right", frameon=True) + g.fig.suptitle(title, fontsize=16) + + if fname is None: + return display_figure(g.fig) + g.savefig(fname, bbox_inches="tight") + return None + + def plot_wave( + self, + wave: int, + set_simulator_axis_limits: bool = True, + ref_val: dict[str, float] | None = None, + fname: str | None = None, + ) -> None | Figure: + """ + Plot results for a specific wave. + + Parameters + ---------- + wave: int + The wave number to plot (0-indexed). + set_simulator_axis_limits: bool + Whether to keep the simulator parameter ranges as axis limits. + ref_val: dict[str, float] | None + Optional dictionary of true parameter values to mark on the plots. + fname: str | None + Optional filename to save the plot to. If None, the plot is displayed. + + Returns + ------- + None | Figure + If `fname` is provided, saves the plot to the file and returns None. + If `fname` is None, displays the plot and returns the plot figure. + """ + test_parameters, impl_scores = self.get_wave_results(wave) + return self.plot_run( + test_parameters, + impl_scores, + set_simulator_axis_limits, + ref_val, + f"Results for Wave {wave}", + fname, + ) + + def get_wave_results(self, wave: int) -> tuple[TensorLike, TensorLike]: + """ + Get results for a specific wave. + + Parameters + ---------- + wave: int + The wave number to get results for (0-indexed). + + Returns + ------- + tuple[TensorLike, TensorLike] + A tensor of tested input parameters and their implausibility scores. + """ + assert self.wave_results, "No wave results, run `run_waves()` first." + assert 0 <= wave < len(self.wave_results), f"Wave {wave} not available." + + return self.wave_results[wave] + + def plot_wave_evolution( + self, param, ref_val: dict[str, float] | None = None, fname: str | None = None + ) -> None | Figure: + """ + Plot evolution of parameter distributions across all waves. + + Parameters + ---------- + param: str + The parameter to plot the evolution for. + ref_val: dict[str, float] | None + Optional dictionary of true parameter values to mark on the plots. + fname: str | None + Optional filename to save the plot to. If None, the plot is displayed. + + Returns + ------- + None | Figure + If `fname` is provided, saves the plot to the file and returns None. + If `fname` is None, displays the plot and returns the plot figure. + """ + all_df = [] + for wave_idx, (test_parameters, impl_scores) in enumerate(self.wave_results): + test_parameters_plausible = self.get_nroy(impl_scores, test_parameters) + impl_scores_plausible = self.get_nroy(impl_scores, impl_scores) + + # Create DataFrame + df = pd.DataFrame( + test_parameters_plausible[:, self.parameter_idx], + columns=self.calibration_params, # pyright: ignore[reportArgumentType] + ) + df["Implausibility"] = impl_scores_plausible.mean(axis=1) # pyright: ignore[reportCallIssue] + df["Wave"] = wave_idx + + all_df.append(df) + + # Concatenate all waves into a single DataFrame + result_df = pd.concat(all_df, ignore_index=True) + + fig = plt.figure(figsize=(8, 5)) + sns.boxplot(data=result_df, x="Wave", y=param) + + # Add horizontal line at true value + if ref_val is not None: + plt.axhline( + ref_val[param], + color="red", + linestyle="--", + linewidth=2, + label="True value", + ) + + plt.title(f"Distribution of {param} by Wave") + plt.xlabel("Wave") + plt.ylabel(param) + plt.tight_layout() + + # Add global legend only once (first plot) + plt.legend(loc="upper right", frameon=True) + + if fname is None: + return display_figure(fig) + plt.savefig(f"{param}_wave_evolution.png", dpi=300, bbox_inches="tight") + return None diff --git a/autoemulate/core/sensitivity_analysis.py b/autoemulate/core/sensitivity_analysis.py index d5ea28222..e08b43e8b 100644 --- a/autoemulate/core/sensitivity_analysis.py +++ b/autoemulate/core/sensitivity_analysis.py @@ -307,7 +307,7 @@ def plot_morris( @staticmethod def top_n_sobol_params( sa_results_df: pd.DataFrame, top_n: int, sa_index: str = "ST" - ) -> list: + ) -> list[str]: """ Return `top_n` most important parameters given Sobol sensitivity analysis. @@ -338,14 +338,63 @@ def top_n_sobol_params( st_results = sa_results_df[sa_results_df["index"] == sa_index] - return ( - st_results.groupby("parameter")["value"] # pyright: ignore[reportCallIssue] - # each parameter is evalued against each output - # to rank parameters, average over how sensitive all outputs are to it + # each parameter is evalued against each output + # to rank parameters, average over how sensitive all outputs are to it + top_n = ( + st_results.groupby("parameter")["value"] # pyright: ignore[reportCallIssue, reportAssignmentType] .mean() .nlargest(top_n) .index.tolist() ) + assert isinstance(top_n, list) + return top_n + + def plot_sa_heatmap( + self, + results: pd.DataFrame, + index: str = "ST", + top_n: int | None = None, + cmap: str = "coolwarm", + normalize: bool = True, + figsize: tuple | None = None, + fname: str | None = None, + ): + """ + Plot a normalized Sobol sensitivity analysis heatmap. + + Parameters + ---------- + results: pd.DataFrame + Sensitivity index dataframe with columns ['index', 'parameter', + 'output', 'value']. + index: str + The type of sensitivity index to plot (e.g., 'ST'). + top_n: int | None + Number of top parameters to include. If None, returns all. Defaults to + None. + cmap: str + Matplotlib colormap. Defaults to 'coolwarm'. + normalize: bool + Wheterto normalize values to [0, 1]. Defaults to True. + figsize: tuple | None + Figure size as (width, height) in inches. Defaults to None. + fname: str | None + If provided, saves the figure to this file path. Defaults to None. + """ + # Determine which parameters to include + parameter_list = self.top_n_sobol_params( + results, + top_n=len(results["parameter"].unique()) if top_n is None else top_n, + ) + + fig = _plot_sa_heatmap( + results, index, parameter_list, cmap, normalize, fig_size=figsize + ) + + if fname is None: + return display_figure(fig) + fig.savefig(fname, bbox_inches="tight") + return None def _sobol_results_to_df(results: dict[str, ResultDict]) -> pd.DataFrame: @@ -770,3 +819,87 @@ def _create_morris_plot( ax.set_ylabel("μ* (Modified Mean)") ax.set_title(f"Output: {output_name}") ax.grid(True, alpha=0.3) + + +def _plot_sa_heatmap( + si_df, index, parameters, cmap="coolwarm", normalize=True, fig_size=None +) -> matplotlib.figure.Figure: + """ + Plot a sensitivity analysis heatmap for a given index. + + Parameters + ---------- + results: pd.DataFrame + Sensitivity index dataframe with columns ['index', 'parameter', + 'output', 'value']. + index: str + The type of sensitivity index to plot (e.g., 'ST'). + top_n: int | None + Number of top parameters to include. If None, returns all. Defaults to + None. + cmap: str + Matplotlib colormap. Defaults to 'coolwarm'. + normalize: bool + Wheterto normalize values to [0, 1]. Defaults to True. + figsize: tuple | None + Figure size as (width, height) in inches. Defaults to None. + + Returns + ------- + matplotlib.figure.Figure + The matplotlib figure containing the SA heatmap. + """ + # Filter the dataframe for the specified index + df = si_df[si_df["index"] == index] + + # Pivot the dataframe to get a matrix: rows = outputs, cols = parameters + heatmap_df = ( + df[df["parameter"].isin(parameters)] + .pivot_table( + index="output", columns="parameter", values="value", fill_value=np.nan + ) + .reindex(columns=parameters) # Ensure column order + ) + + # Normalize if requested + if normalize: + min_value = heatmap_df.min().min() + max_value = heatmap_df.max().max() + value_range = max_value - min_value if max_value != min_value else 1 + heatmap_df = (heatmap_df - min_value) / value_range + + # Convert to NumPy array + data_np = heatmap_df.to_numpy() + + # layout - add space for legend + nrows, ncols = _calculate_layout(data_np.shape[1], data_np.shape[0]) + fig_size = fig_size or (4.5 * ncols, 4.5 * nrows + 2) # Extra width for legend + + # Plotting + fig, ax = plt.subplots(figsize=fig_size) + cax = ax.imshow(data_np, cmap=cmap, aspect="auto") + + # Colorbar + cbar = fig.colorbar(cax, ax=ax) + cbar_label = "Normalized Sensitivity" if normalize else "Sensitivity" + cbar.set_label(cbar_label, rotation=270, labelpad=15) + + # Labels and ticks + ax.set_title(f"{index} Sensitivity Analysis Heatmap", fontsize=14, pad=12) + ax.set_xlabel("Parameters", fontsize=12) + ax.set_ylabel("Outputs", fontsize=12) + + ax.set_xticks(np.arange(len(parameters))) + ax.set_xticklabels(parameters, rotation=45, ha="right") + ax.set_yticks(np.arange(len(heatmap_df.index))) + ax.set_yticklabels(heatmap_df.index) + + # Gridlines + ax.set_xticks(np.arange(-0.5, len(parameters), 1), minor=True) + ax.set_yticks(np.arange(-0.5, len(heatmap_df.index), 1), minor=True) + ax.grid(which="minor", color="w", linestyle="-", linewidth=2) + ax.tick_params(which="minor", bottom=False, left=False) + + plt.tight_layout() + + return fig diff --git a/case_studies/blood_pressure/ModularCirc.ipynb b/case_studies/blood_pressure/ModularCirc.ipynb deleted file mode 100644 index 0c02510bf..000000000 --- a/case_studies/blood_pressure/ModularCirc.ipynb +++ /dev/null @@ -1,630 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Integrating a user-provided simulator in an end-to-end AutoEmulate workflow \n", - "\n", - "## Overview\n", - "\n", - "In this workflow we demonstrate the integration of a Cardiovascular simulator, Naghavi Model from ModularCirc in an end-to-end AutoEmulate workflow. \n", - "\n", - "Naghavi model is a 0D (zero-dimensional) computational model of the cardiovascular system, which is used to simulate blood flow and pressure dynamics in the heart and blood vessels.\n", - "\n", - "This demo includes:\n", - "- Setting up parameter ranges \n", - "- Creating samples\n", - "- Running the simulator to generate training data for the emulator \n", - "- Using AutoEmulate to find the best pre-processing technique and model tailored to the simulation data \n", - "- Applying history matching to refine the model and enhance parameter ranges \n", - "- Sensitivity Analysis \n", - "\n", - "\n", - "\"Work\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Workflow" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 1 - Create a dictionary called `parameters_range` which contains the name of the simulator input parameters and their range." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from autoemulate.simulations.naghavi_cardiac_ModularCirc import extract_parameter_ranges\n", - "# Usage example:\n", - "parameters_range = extract_parameter_ranges('../data/naghavi_model_parameters.json')\n", - "parameters_range" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 2 - Use `LatinHypercube` method from AutoEmulate to generate initial samples using the parameters range." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "from autoemulate.experimental_design import LatinHypercube\n", - "\n", - "# Generate Latin Hypercube samples\n", - "N_samples = 100\n", - "lhd = LatinHypercube(list(parameters_range.values()))\n", - "sample_array = lhd.sample(N_samples)\n", - "sample_df = pd.DataFrame(sample_array, columns=parameters_range.keys())\n", - "\n", - "print(\"Number of parameters:\", sample_df.shape[1], \"Number of samples from each parameter:\", sample_df.shape[0])\n", - "sample_df.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 3 - Wrap your Simulator in the AutoEmulate Simulator Base Class.\n", - "\n", - "\"Work\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from autoemulate.simulations.naghavi_cardiac_ModularCirc import NaghaviSimulator\n", - "# Initialize simulator with specific outputs\n", - "simulator = NaghaviSimulator(\n", - " parameters_range=parameters_range, \n", - " output_variables=['lv.P_i', 'lv.P_o'], # Only the ones you're interested in\n", - " n_cycles=300, \n", - " dt=0.001,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 4 - Run the simulator using `run_batch_simulations` to obtain data for training AutoEmulate. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "results_df = None\n", - "run = True\n", - "save = False\n", - "read = False\n", - "if run:\n", - " # Run batch simulations with the samples generated in Cell 1\n", - " results = simulator.run_batch_simulations(sample_df)\n", - "\n", - " # Convert results to DataFrame for analysis\n", - " results_df = pd.DataFrame(results)\n", - "\n", - "if save and results_df is not None:\n", - " # Save the results to a CSV file\n", - " results_df.to_csv('../data/simulator_results.csv', index=False)\n", - "\n", - "if read:\n", - " # Read the results from the CSV file\n", - " results_df = pd.read_csv('../data/simulator_results.csv')\n", - " results = results_df.to_numpy()\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "results_df" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - " Note that the first 4 steps can be replaced by having stored the output of your simulation in a file and then reading them in to a dataframe. However the purpose of this article is to demonstrate the use of a User-provided simulator in an end-to-end workflow." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "simulator.output_names" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Test your simulator with our test function to make sure it is compatible with AutoEmulate pipeline (Feature not provided yet).\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# this should be replaced with a test written specically to test the simulator written by the user\n", - "# ! pytest ../../tests/test_base_simulator.py" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 5 - Setup AutoEmulate.\n", - "- User should choose from the available target `pre-processing` methods the methods they would like to investigate.\n", - "- User should choose from the available `models` the `models` they would like to investigate.\n", - "- Setup AutoEmulate " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from autoemulate.compare import AutoEmulate\n", - "from autoemulate.plotting import _predict_with_optional_std\n", - "\n", - "\n", - "preprocessing_methods = [{\"name\" : \"PCA\", \"params\" : {\"reduced_dim\": 2}}]\n", - "em = AutoEmulate()\n", - "em.setup(sample_df, results, models=[\"gp\"], scale_output = True, reduce_dim_output=True, preprocessing_methods=preprocessing_methods)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 6 - Run compare to train AutoEmulate and extract the best model." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "best_model = em.compare()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 7 - Examine the summary of cross-validation." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "em.summarise_cv()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "best_model" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 8 - Extract the desired model, run evaluation and refit using the whole dataset.\n", - "- You can use the `best_model` selected by AutoEmulate \n", - "- or you can extract the model and pre-processing technique displayed in `em.summarise_cv()`" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "gp = em.get_model('GaussianProcess')\n", - "em.evaluate(gp)\n", - "# for best model change the line above to:\n", - "# em.evaluate(best_model)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "gp_final = em.refit(gp)\n", - "gp_final" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "em.plot_eval(gp_final)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 9 - Sensitivity Analysis \n", - "Use AutoEmulate to perform sensitivity analysis. This will help identify the parameters that have higher impact on the outputs to narrow down the search space for performing model calibration. \n", - "\n", - "Sobol Interpretation:\n", - "\n", - "- $S_1$ values sum to ≤ 1.0 (exact fraction of variance explained)\n", - "- $S_t - S_1$ = interaction effects involving that parameter\n", - "- Large $S_t - S_1$ gap indicates strong interactions\n", - "\n", - "Morris Interpretation:\n", - "\n", - "- High $\\mu^*$, Low $\\sigma$: Important parameter with linear/monotonic effects\n", - "- High $\\mu^*$, High $\\sigma$: Important parameter with non-linear effects or interactions\n", - "- Low $\\mu^*$, High $\\sigma$: Parameter involved in interactions but not individually important\n", - "- Low $\\mu^*$, Low $\\sigma$: Unimportant parameter" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Extract parameter names and bounds from the dictionary\n", - "parameter_names = list(parameters_range.keys())\n", - "parameter_bounds = list(parameters_range.values())\n", - "\n", - "# Define the problem dictionary for Sobol sensitivity analysis\n", - "problem = {\n", - " 'num_vars': len(parameter_names),\n", - " 'names': parameter_names,\n", - " 'bounds': parameter_bounds\n", - "}\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "si = em.sensitivity_analysis(problem=problem, method='sobol')\n", - "si.head()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "em.plot_sensitivity_analysis(si)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Refining the Model with Real-World Observations\n", - "\n", - "To refine our emulator, we need real-world observations to compare against. These observations can come from:\n", - "- Experimental values from literature\n", - "- Simulation results from a known reliable parameter set\n", - "\n", - "In this example, we'll generate our observations by running the simulator at the midpoint of each parameter range, treating these as our \"ground truth\" values for calibration. Note that in a real world example one can have multiple observations." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\t\n", - "# An example of how to define observed data with means and variances from a hypothetical experiment\n", - "observations = {\n", - " 'lv.P_i_min': (5.0, 0.1), # Minimum of minimum LV pressure\n", - " 'lv.P_i_max': (20.0, 0.1), # Maximum of minimum LV pressure\n", - " 'lv.P_i_mean': (10.0, 0.1), # Mean of minimum LV pressure\n", - " 'lv.P_i_range': (15.0, 0.5), # Range of minimum LV pressure\n", - " 'lv.P_o_min': (1.0, 0.1), # Minimum of maximum LV pressure\n", - " 'lv.P_o_max': (13.0, 0.1), # Maximum of maximum LV pressure\n", - " 'lv.P_o_mean': (12.0, 0.1), # Mean of maximum LV pressure\n", - " 'lv.P_o_range': (20.0, 0.5) # Range of maximum LV pressure\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Otherwise, use one forward pass of your simualtion to get the observed data\n", - "# Calculate midpoint parameters\n", - "midpoint_params = {}\n", - "for param_name, (min_val, max_val) in parameters_range.items():\n", - " midpoint_params[param_name] = (min_val + max_val) / 2.0\n", - "# Run the simulator with midpoint parameters\n", - "midpoint_results = simulator.sample_forward(midpoint_params)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Create observations dictionary\n", - "observations = {}\n", - "output_names = simulator.output_names\n", - "observations = {name: (float(val), max(abs(val) * 0.01, 0.01)) for name, val in zip(output_names, midpoint_results)}\n", - "observations\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 10 - History Matching\n", - " \n", - "Once you have the final model, running history matching can improve your model. The Implausibility metric is calculated using the following relation for each set of parameter:\n", - "\n", - "$I_i(\\overline{x_0}) = \\frac{|z_i - \\mathbb{E}(f_i(\\overline{x_0}))|}{\\sqrt{\\text{Var}[z_i - \\mathbb{E}(f_i(\\overline{x_0}))]}}$\n", - "Where if implosibility ($I_i$) exceeds a threshhold value, the points will be rulled out. \n", - "The outcome of history matching are the NORY (Not Ruled Out Yet) and RO (Ruled Out) points.\n", - "\n", - "- create a dictionary of your observations, this should match the output names of your simulator \n", - "- create the history matching object \n", - "- run history matching \n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from autoemulate.history_matching import HistoryMatching\n", - "\n", - "# Create history matcher\n", - "hm = HistoryMatching(\n", - " simulator=simulator,\n", - " observations=observations,\n", - " threshold=1.0\n", - ")\n", - "\n", - "# Run history matching\n", - "all_samples, all_impl_scores, emulator = hm.run(\n", - " n_waves=50,\n", - " n_samples_per_wave=100,\n", - " emulator_predict=True,\n", - " initial_emulator=gp_final,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "# Simple NROY extraction - just check the threshold!\n", - "threshold = 1.0 # Same threshold used in history matching\n", - "\n", - "# Find samples where ALL outputs have implausibility <= threshold\n", - "nroy_mask = np.all(all_impl_scores <= threshold, axis=1)\n", - "nroy_indices = np.where(nroy_mask)[0]\n", - "nroy_samples = all_samples[nroy_indices]\n", - "\n", - "print(f\"Total samples: {len(all_samples)}\")\n", - "print(f\"NROY samples: {len(nroy_samples)}\")\n", - "print(f\"NROY percentage: {len(nroy_samples)/len(all_samples)*100:.1f}%\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from autoemulate.experimental.calibration.history_matching_dashboard import HistoryMatchingDashboard\n", - "dashboard = HistoryMatchingDashboard(\n", - " samples=all_samples,\n", - " impl_scores=all_impl_scores,\n", - " param_names=simulator.param_names, \n", - " output_names=simulator.output_names, \n", - " )\n", - "dashboard.display()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\"Work \"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 11 - MCMC\n", - "Once you have identified the important parameters through the Sensitivity analysis tool, the MCMC module can return the calibrated parameter values with uncertainty. \n", - "The MCMC algorithm tries to find parameter values that match the predictions by the emulator to your `observations` whilst staying within the `parameters_range` (priors)\n", - "and accounting for uncertainty.\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "- Takes a pre-trained emulator (surrogate model)\n", - "- Uses sensitivity analysis results to identify the most important parameters\n", - "- Accepts observations (real data) to calibrate against\n", - "- Optionally incorporates NROY (Not Ruled Out Yet) samples from prior history matching\n", - "- Sets up parameter bounds for calibration" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from autoemulate.mcmc import MCMCCalibrator\n", - "# Define your observations (what you want to match)\n", - "# Define observed data with means and variances\n", - "\n", - "\n", - "# Run calibration\n", - "calibrator = MCMCCalibrator(\n", - " emulator=gp_final,\n", - " sensitivity_results=si,\n", - " observations=observations,\n", - " parameter_bounds=parameters_range,\n", - " nroy_samples=nroy_samples,\n", - " nroy_indices=nroy_indices,\n", - " all_samples=all_samples,\n", - " top_n_params=3 # Calibrate top 5 most sensitive parameters\n", - ")\n", - "\n", - "results = calibrator.run_mcmc(num_samples=100, warmup_steps=10)\n", - "# Get calibrated parameter values\n", - "calibrated_params = calibrator.get_calibrated_parameters()\n", - "calibrated_params\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from autoemulate.mcmc_dashboard import MCMCVisualizationDashboard\n", - "dashboard = MCMCVisualizationDashboard(calibrator)\n", - "dashboard.display()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Footnote: Testing the dashboard\n", - "\n", - "Sometimes it is hard to know, if the results we are seeing is because the code is not working, or our simulation results are more interesting than we expected. Here is a little test dataset which tests the dashboard, so that you can see how the plots are supposed to look liek and what they shouldf show" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Create a test sample with KNOWN NROY regions\n", - "test_samples = np.array([[x, y] for x in np.linspace(0,1,100) \n", - " for y in np.linspace(0,1,100)])\n", - "test_scores = (abs(test_samples[:, 0]-0.5)+abs(test_samples[:, 1]-0.5)).reshape(-1, 1)\n", - "\n", - "# Should show a clear diagonal pattern\n", - "test_dash = HistoryMatchingDashboard(\n", - " samples=test_samples,\n", - " impl_scores=test_scores,\n", - " param_names=[\"p1\", \"p2\"],\n", - " output_names=[\"out1\"],\n", - " threshold=0.7 # ~50% of points should be NROY\n", - ")\n", - "#test_dash.display()" - ] - } - ], - "metadata": { - "jupyter": { - "tags": [ - "skip-execution" - ] - }, - "kernelspec": { - "display_name": ".venv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.7" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/case_studies/blood_pressure/README.md b/case_studies/blood_pressure/README.md deleted file mode 100644 index 28f41474c..000000000 --- a/case_studies/blood_pressure/README.md +++ /dev/null @@ -1,24 +0,0 @@ -# Blood pressure simulation - -In this case study we demonstrate the integration of a cardiovascular simulator, the Naghavi Model from the [ModularCirc](https://github.com/alan-turing-institute/ModularCirc) package, in an end-to-end `AutoEmulate` workflow. - -To run the notebook follow the steps below. - -1. Clone the repository: - -```bash -git clone https://github.com/alan-turing-institute/autoemulate.git -cd case_studies/blood_pressure -``` - -2. Install dependencies: - -```bash -pip install -e . -``` - -3. Run JupyterLab to view the notebook: - -```bash -jupyter lab -``` \ No newline at end of file diff --git a/case_studies/patient_calibration/README.md b/case_studies/patient_calibration/README.md new file mode 100644 index 000000000..5d05bea74 --- /dev/null +++ b/case_studies/patient_calibration/README.md @@ -0,0 +1,63 @@ +# Patient-Specific Calibration in Cardiovascular Modeling + +This case study demonstrates the integration of a cardiovascular simulator, the Naghavi Model from the [ModularCirc](https://github.com/alan-turing-institute/ModularCirc) package, into an end-to-end `AutoEmulate` workflow. The goal is to showcase how `AutoEmulate` can be used to calibrate and validate physiological models, specifically focusing on blood pressure dynamics measured in the left ventricle. + +The Naghavi Model is a modular cardiovascular simulator that provides a detailed representation of blood pressure regulation mechanisms. By using `AutoEmulate`, we can calibrate the model parameters against clinial petient data. + +## Workflow Overview + +The workflow includes the following steps: +1. **Sensitivity Analysis**: Sensitivity analysis is performed to identify the most influential parameters affecting the model outputs. +2. **History Matching**: History matching is conducted to rule out implausible regions of the parameter space given clinical patient data. +3. **Bayesian Calibration**: Bayesian calibration is performed within the bounds of the not ruled out region of the parameter space to estimate the model parameters which generated the observed patient data. +4. **Uncertainty Quantification**: The posterior distributions of the parameters are used to quantify uncertainties. + +This case study provides a practical example of how `AutoEmulate` can be applied to complex physiological models, enabling robust parameter estimation and model validation. + +The Naghavi simulator from ModularCirc has been wrapped in an `AutoEmulate` `Simulator` class to enable the above workflow (see implementation in [cardiac_simulator.py](cardiac_simulator.py)). The `AutoEmulate` documentation page contains a [tutorial](https://alan-turing-institute.github.io/autoemulate/tutorials/simulator/01_custom_simulations.html) on how to wrap custom simulators for use with `AutoEmulate`. + +## How to Run the Case Study + +Follow the steps below to run the case study: + +1. Clone the repository: + + ```bash + git clone https://github.com/alan-turing-institute/autoemulate.git + cd case_studies/patient_calibration + ``` + +2. Install dependencies: + + ```bash + pip install -e . + ``` + +3. Run the Jupyter Notebook to explore the case study interactively: + + ```bash + jupyter lab + ``` + +## Files in This Case Study + +- **`patient_calibration_case_study.ipynb`**: A Jupyter Notebook that provides an interactive walkthrough of the case study. +- **`cardiac_simulator.py`**: Contains the `NaghaviSimulator` class that wraps the Naghavi Model from ModularCirc for use with `AutoEmulate`. +- **`naghavi_model_parameters.json`**: A JSON file containing the default parameters range for the Naghavi Model. +- **`README.md`**: This file, which provides an overview of the case study and instructions for running it. + +## Dependencies + +This case study requires the following dependencies: +- Python 3.8+ +- `AutoEmulate` +- `ModularCirc` +- `JupyterLab` + +Ensure all dependencies are installed by running the command in Step 2 above. + +## Additional Information + +For more details about the `AutoEmulate` framework and its capabilities, visit the [official repository](https://github.com/alan-turing-institute/autoemulate). + +For more information about the Naghavi Model and the `ModularCirc` package, visit the [ModularCirc repository](https://github.com/alan-turing-institute/ModularCirc).s \ No newline at end of file diff --git a/case_studies/patient_calibration/cardiac_simulator.py b/case_studies/patient_calibration/cardiac_simulator.py new file mode 100644 index 000000000..40539e9fe --- /dev/null +++ b/case_studies/patient_calibration/cardiac_simulator.py @@ -0,0 +1,310 @@ +import concurrent.futures +import json +from concurrent.futures import ProcessPoolExecutor +from itertools import product + +import numpy as np +import torch +from ModularCirc.Models.NaghaviModel import NaghaviModel, NaghaviModelParameters +from ModularCirc.Solver import Solver +from tqdm import tqdm + +from autoemulate.core.types import NumpyLike, TensorLike +from autoemulate.simulations.base import Simulator + +# ================================== +# PARAMETER UTILS +# ================================== + + +def _condense_dict_parameters( + dict_param: dict, condensed_range: dict, condensed_single: dict, prev: str = "" +) -> None: + """ + Recursively condense a nested dictionary into two flat dictionaries: + - `condensed_range`: Stores keys with value ranges (tuples of two floats). + - `condensed_single`: Stores keys with single values (floats). + """ + for key, val in dict_param.items(): + if len(prev) > 0: + new_key = prev.split(".")[-1] + "." + key + else: + new_key = key + if isinstance(val, dict): + _condense_dict_parameters(val, condensed_range, condensed_single, new_key) + else: + if len(val) > 1: + value, r = val + condensed_range[new_key] = tuple(np.array(r) * value) + else: + condensed_single[new_key] = val[0] + return + + +def extract_parameter_ranges( + json_file_path: str, +) -> tuple[dict[str, tuple[float, float]], dict[str, float]]: + """ + Extract parameter values from a JSON file and return two dictionaries: + - `condensed_range`: Parameters with value ranges (tuples of two floats). + - `condensed_single`: Parameters with single values (floats). + + Parameters + ---------- + json_file_path: str + Path to the JSON file to extract parameter values from. + + Returns + ------- + tuple[dict, dict] + Dictionary of parameter ranges and dictionary of single values. + """ + with open(json_file_path) as file: + dict_parameters = json.load(file) + + condensed_single = {} + condensed_range = {} + _condense_dict_parameters(dict_parameters, condensed_range, condensed_single) + + return condensed_range, condensed_single + + +# ================================== +# SIMULATOR +# ================================== + + +class NaghaviSimulator(Simulator): + def __init__( + self, + parameters_range: dict[str, tuple[float, float]] | None = None, + output_variables: list[str] | None = None, + log_level: str = "progress_bar", + n_cycles: int = 40, + dt: float = 0.001, + ): + """ + Initialize the Naghavi simulator. + + Parameters + ---------- + parameters_range: dict[str, tuple[float, float]] + Dictionary mapping input parameter names to their (min, max) ranges. + output_variables: list[str] + Optional list of specific output variables to track. Defaults to None. + log_level: str + Logging level for the simulator. Can be one of: + - "progress_bar": shows a progress bar during batch simulations + - "debug": shows debug messages + - "info": shows informational messages + - "warning": shows warning messages + - "error": shows error messages + - "critical": shows critical messages + n_cycles: int + Number of simulation cycles. + dt: float + Time step size. + """ + # Initialize the base class + if output_variables is not None: + output_names = self._create_output_names(output_variables) + else: + # The Naghavi heart model is structured as components (e.g., lv is the + # left ventricle) with 4 variables simulated in each component + components = ["ao", "art", "ven", "av", "mv", "la", "lv"] + variables = ["P_i", "P_o", "Q_i", "Q_o"] + output_variables = [ + f"{component}.{variable}" + for component, variable in product(components, variables) + ] + output_names = self._create_output_names(output_variables) + if parameters_range is None: + parameters_range, _ = extract_parameter_ranges( + "naghavi_model_parameters.json" + ) + super().__init__(parameters_range, output_names, log_level) + assert output_variables is not None + self._output_variables = output_variables + + # Naghavi-specific attributes + self.n_cycles = n_cycles + self.dt = dt + self.time_setup = { + "name": "HistoryMatching", + "ncycles": n_cycles, + "tcycle": 1.0, + "dt": dt, + "export_min": 1, + } + + @property + def output_variables(self) -> list[str]: + """List of original output variables without statistic suffixes.""" + return self._output_variables + + def _forward(self, x: TensorLike) -> TensorLike: + # Set parameters of the simulation given input + parobj = NaghaviModelParameters() + for i, param_name in enumerate(self.param_names): + # Input param names are of the form {component}.{param} + component, param = param_name.split(".") + # Shape of input x is [1, n_input_params] + value = x[0, i].item() + # The second arg passed to `_set_comp` method is a set that has to + # contain the first argument (i.e., component) + parobj._set_comp(component, [component], **{param: value}) + + # Run simulation + try: + model = NaghaviModel( + time_setup_dict=self.time_setup, parobj=parobj, suppress_printing=True + ) + solver = Solver(model=model) + solver.setup( + suppress_output=True, optimize_secondary_sv=False, method="LSODA" + ) + solver.solve() + + if not solver.converged: + print("Solver did not converge.") + return None + except Exception as e: + print(f"Simulation error: {e}") + return None + + # Collect and process outputs + output_stats = [] + for output_var in self.output_variables: + component, variable = output_var.split(".") + values = np.array(getattr(model.components[component], variable).values) + stats = self._calculate_output_stats(values) + output_stats.extend(stats) + + # return shape [1, n_outputs] + return torch.tensor(output_stats, dtype=torch.float32).reshape(1, -1) + + def _simulate_single(self, idx, x_row): + parobj = NaghaviModelParameters() + for i, param_name in enumerate(self.param_names): + component, param = param_name.split(".") + value = x_row[i].item() + parobj._set_comp(component, [component], **{param: value}) + + try: + # Create a new model and solver instance for each simulation + model = NaghaviModel( + time_setup_dict=self.time_setup, parobj=parobj, suppress_printing=True + ) + solver = Solver(model=model) + solver.setup( + suppress_output=True, optimize_secondary_sv=False, method="LSODA" + ) + solver.solve() + + if not solver.converged: + return None + + output_stats = [] + for output_var in self.output_variables: + component, variable = output_var.split(".") + values = np.array(getattr(model.components[component], variable).values) + stats = self._calculate_output_stats(values) + output_stats.extend(stats) + + return idx, torch.tensor(output_stats, dtype=torch.float32).reshape(1, -1) + except Exception as e: + print(f"Simulation error: {e}") + return None + + def forward_batch(self, x: TensorLike) -> tuple[TensorLike, TensorLike]: + """Run multiple simulations in parallel, skipping any that fail.""" + self.logger.info("Running batch simulation for %d samples", len(x)) + + results = [] + valid_idx = [] + + with ProcessPoolExecutor() as executor: + futures = { + executor.submit(self._simulate_single, i, x[i]): i + for i in range(len(x)) + } + + for future in tqdm( + concurrent.futures.as_completed(futures), + desc="Running simulations", + total=len(x), + unit="sample", + unit_scale=True, + ): + result = future.result() + if result is not None: + idx, res = result + results.append(res) # Ensure result is a Tensor + valid_idx.append(idx) + + # Report results + successful = len(results) + self.logger.info( + "Successfully completed %d/%d simulations (%.1f%%)", + successful, + len(x), + (successful / len(x) * 100 if len(x) > 0 else 0.0), + ) + + # Stack results into a 2D array on the first dimension using torch + if results: + results_tensor = torch.cat(results, dim=0) + else: + results_tensor = torch.empty(0) + + return results_tensor, x[valid_idx] + + def _create_output_names(self, output_vars: list[str]) -> list[str]: + """ + Simulator returns summary statistics for each output variable, create + names that track which output value is which variable and which statistic. + + Parameters + ---------- + output_vars: list[str] + Name of output variables to track (e.g., ['lv.P_i', 'lv.P_o']) + + Returns + ------- + list[str] + Names of all simulator outputs identifying which param and summary + statistic is returned. + """ + output_names = [] + for base_name in output_vars: + stat_names = [ + f"{base_name}_min", + f"{base_name}_max", + f"{base_name}_mean", + f"{base_name}_range", + ] + output_names.extend(stat_names) + return output_names + + def _calculate_output_stats(self, output_values: NumpyLike) -> NumpyLike: + """ + Calculate summary statistics for an output time series. + + Parameters + ---------- + output_values: NumpyLike + Array of time series values. + + Returns + ------- + NumpyLike + Array of output statistics. + """ + return np.array( + [ + np.min(output_values), + np.max(output_values), + np.mean(output_values), + np.max(output_values) - np.min(output_values), + ] + ) diff --git a/docs/data/naghavi_model_parameters.json b/case_studies/patient_calibration/naghavi_model_parameters.json similarity index 100% rename from docs/data/naghavi_model_parameters.json rename to case_studies/patient_calibration/naghavi_model_parameters.json diff --git a/case_studies/patient_calibration/patient_calibration_case_study.ipynb b/case_studies/patient_calibration/patient_calibration_case_study.ipynb new file mode 100644 index 000000000..4537dbabc --- /dev/null +++ b/case_studies/patient_calibration/patient_calibration_case_study.ipynb @@ -0,0 +1,1089 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Patient calibration workflow using AutoEmulate\n", + "\n", + "## Introduction\n", + "\n", + "\n", + "## The Naghavi cardiovascular model\n", + "\n", + "The Naghavi lumped parameter model is a mathematical model of the human cardiovascular system, designed to simulate the dynamics of blood flow and pressure throughout the heart and circulatory system using lumped parameter modeling. \n", + "A **lumped parameter model** simplifies the cardiovascular system by dividing it into compartments (or \"lumps\") such as:\n", + "\n", + "- Heart chambers (left and right atria and ventricles)\n", + "- Major blood vessels (aorta, vena cava, pulmonary arteries and veins)\n", + "- Systemic and pulmonary circulations\n", + "\n", + "Each compartment is modeled using analogies to electrical circuits:\n", + "\n", + "- Pressure ↔ Voltage\n", + "- Flow ↔ Current\n", + "- Resistance ↔ Vascular resistance (R\\)\n", + "- Compliance ↔ Vessel elasticity or capacitance (C\\)\n", + "- Inertance ↔ Blood inertia (L)\n", + "\n", + "This approach allows simulation of the time-dependent relationships between pressure, volume, and flow rate across the entire cardiovascular system using ordinary differential equations (ODEs).\n", + "\n", + "The Naghavi lumped parameter model is a mathematical model of the human cardiovascular system, designed to simulate the dynamics of blood flow and pressure throughout the heart and circulatory system using lumped parameter modeling. \n", + "A **lumped parameter model** simplifies the cardiovascular system by dividing it into compartments (or \"lumps\") such as:\n", + "\n", + "## Patient calibration workflow\n", + "\n", + "In this tutorial, we present a three-stage workflow for calibrating the Naghavi model to patient-specific clinical data using AutoEmulate. The process has the following stages:\n", + "\n", + "- First we perform a global sensitivity analysis, which identifies the most influential parameters affecting model outputs and reduces the dimensionality of the calibration problem. \n", + "- Next, we apply history matching, a sequential uncertainty quantification technique that uses emulators to efficiently rule out implausible regions of the parameter space based on observed patient data. This results in a restricted, plausible region—known as the NROY (Not Ruled Out Yet) space—where parameters are consistent with the clinical measurements within acceptable uncertainty bounds. \n", + "- Finally, we perform Bayesian inference within this NROY region to estimate the full posterior distribution of the remaining parameters, capturing the most likely values and their associated uncertainty. \n", + "\n", + "### Global sensitivity analysis\n", + "\n", + "The Naghavi model has 16 parameters which makes individual patient calibration challenging. To address this we use a emulator-based global sensitivity analysis to quantify the influence each parameter on features derived from left ventricle artery pressure. This approach reduces the parameters that will be used in model personalization from 16 to 5." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import torch\n", + "\n", + "from autoemulate.data.utils import set_random_seed\n", + "seed = 42\n", + "set_random_seed(seed)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Set up simulator and generate data\n", + "\n", + "For this tutorial we use `ModularCirc` a package that providse a framework for building 0D models and simulating cardiovascular flow and mechanics. The `NaghaviSimulator` simulates pressure traces, we then choose to output summary statistics for each of the simulated traces." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from cardiac_simulator import NaghaviSimulator\n", + "\n", + "simulator = NaghaviSimulator(\n", + " output_variables=['lv.P'], # We simulate the left ventricle pressure\n", + " n_cycles=300, \n", + " dt=0.001,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The simulator comes with predefined input parameters ranges. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'ao.r': (np.float64(120.0), np.float64(360.0)),\n", + " 'ao.c': (np.float64(0.15), np.float64(0.44999999999999996)),\n", + " 'art.r': (np.float64(562.5), np.float64(1687.5)),\n", + " 'art.c': (np.float64(1.5), np.float64(4.5)),\n", + " 'ven.r': (np.float64(4.5), np.float64(13.5)),\n", + " 'ven.c': (np.float64(66.65), np.float64(199.95000000000002)),\n", + " 'av.r': (np.float64(3.0), np.float64(9.0)),\n", + " 'mv.r': (np.float64(2.05), np.float64(6.1499999999999995)),\n", + " 'la.E_pas': (np.float64(0.22), np.float64(0.66)),\n", + " 'la.E_act': (np.float64(0.225), np.float64(0.675)),\n", + " 'la.v_ref': (np.float64(5.0), np.float64(15.0)),\n", + " 'la.k_pas': (np.float64(0.01665), np.float64(0.07500000000000001)),\n", + " 'lv.E_pas': (np.float64(0.5), np.float64(1.5)),\n", + " 'lv.E_act': (np.float64(1.5), np.float64(4.5)),\n", + " 'lv.v_ref': (np.float64(5.0), np.float64(15.0)),\n", + " 'lv.k_pas': (np.float64(0.00999), np.float64(0.045))}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "simulator.parameters_range" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can sample from those to generate data to train the emulator with. By default, the `sample_inputs` method uses Latin Hypercube Sampling." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "N_samples = 1024\n", + "x = simulator.sample_inputs(N_samples,random_seed=42)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below we use the simulator to generate predictions for the sampled parameters. Alternatively, for convenience, we can load already simulated data saved to a file." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "save = True\n", + "\n", + "if not os.path.exists(f'simulator_results_{N_samples}.csv'):\n", + " # Run batch simulations with the samples generated in Cell 1\n", + " y, x = simulator.forward_batch(x)\n", + " \n", + " # Convert results to DataFrame for analysis\n", + " results_df = pd.DataFrame(y)\n", + " inputs_df = pd.DataFrame(x)\n", + " \n", + " if save:\n", + " # Save the results to a CSV file\n", + " results_df.to_csv(f'simulator_results_{N_samples}.csv', index=False)\n", + " inputs_df.to_csv(f'simulator_inputs_{N_samples}.csv', index=False)\n", + "\n", + "else:\n", + " # Read the results from the CSV file\n", + " results_df = pd.read_csv(f'simulator_results_{N_samples}.csv')\n", + " inputs_df = pd.read_csv(f'simulator_inputs_{N_samples}.csv')\n", + "\n", + " y = torch.tensor(results_df.to_numpy())\n", + " x = torch.tensor(inputs_df.to_numpy())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These are the output summary variables we've simulated." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['lv.P_min', 'lv.P_max', 'lv.P_mean', 'lv.P_range']" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "simulator.output_names" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Train emulator with AutoEmulate\n", + " \n", + "To perform sensitivity analysis efficiently, we first need to construct an emulator—a fast, surrogate model that approximates the output of the full simulator. The simulated inputs and outputs from the cell above are used to train the emulator, in this case we choose to use a neural network trained with default hyperparameters." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "is_executing": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Comparing models: 100%|██████████| 1.00/1.00 [00:03<00:00, 3.02s/model]\n" + ] + } + ], + "source": [ + "from autoemulate.core.compare import AutoEmulate\n", + "\n", + "from autoemulate.emulators.nn.mlp import MLP\n", + "\n", + "ae = AutoEmulate(\n", + " x, \n", + " y, \n", + " models=[MLP], \n", + " # use default MLP params\n", + " model_params={}\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "is_executing": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
model_namex_transformsy_transformsparamsrmse_testr2_testr2_test_stdr2_trainr2_train_std
0MLP[StandardizeTransform()][StandardizeTransform()]{}2.3920430.9207520.0142810.984380.000933
\n", + "
" + ], + "text/plain": [ + " model_name x_transforms y_transforms params \\\n", + "0 MLP [StandardizeTransform()] [StandardizeTransform()] {} \n", + "\n", + " rmse_test r2_test r2_test_std r2_train r2_train_std \n", + "0 2.392043 0.920752 0.014281 0.98438 0.000933 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ae.summarise()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Extract the best performing emulator." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "is_executing": true + }, + "outputs": [], + "source": [ + "model = ae.best_result().model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Run Sensitivity Analysis \n", + "\n", + "The emulator trained above can predict model outputs rapidly across the entire parameter space, allowing us to estimate global sensitivity measures like Sobol’ indices or Morris elementary effects without repeatedly calling the full simulator. This approach enables scalable and accurate sensitivity analysis, especially in high-dimensional or computationally intensive settings.\n", + "\n", + "Here we use AutoEmulate to perform sensitivity analysis and plot the results." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "is_executing": true + }, + "outputs": [], + "source": [ + "from autoemulate.core.sensitivity_analysis import SensitivityAnalysis\n", + "\n", + "# Define the problem dictionary for Sobol sensitivity analysis\n", + "problem = {\n", + " 'num_vars': simulator.in_dim,\n", + " 'names': simulator.param_names,\n", + " 'bounds': simulator.param_bounds\n", + "}\n", + "\n", + "si = SensitivityAnalysis(model, problem=problem)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "is_executing": true + }, + "outputs": [], + "source": [ + "si_df = si.run(method='sobol')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "is_executing": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "si.plot_sobol(si_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "is_executing": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "si.plot_sa_heatmap(si_df, index='ST', cmap='coolwarm', normalize=True, figsize=(10, 6))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can select the top 3 parameters that have the biggest influcence on the pressure wave summary statistics extracted from the Naghavi Model." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "is_executing": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['lv.k_pas', 'lv.E_pas', 'la.E_act']" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n_parameters = 3\n", + "top_parameters_sa = si.top_n_sobol_params(si_df, top_n=n_parameters)\n", + "top_parameters_sa" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The parameters that are found to be less influential are fixed to a mid point value within its range. This means that next time we sample from the parameter space we only sample from the top 3 parameters. When running the simulations we pass in the fixed values for the other parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "is_executing": true + }, + "outputs": [], + "source": [ + "updated_range = {}\n", + "for param_name, (min_val, max_val) in simulator.parameters_range.items():\n", + " if param_name not in top_parameters_sa:\n", + " midpoint_value = (max_val + min_val) / 2.0\n", + " updated_range[param_name] = (midpoint_value, midpoint_value)\n", + " else:\n", + " updated_range[param_name] = simulator.parameters_range[param_name]# Fix to a value\n", + " \n", + "simulator.parameters_range = updated_range" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "is_executing": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Updated simulator parameters range with fixed values for non-sensitive parameters:\n", + "ao.r fixed to: 240.0\n", + "ao.c fixed to: 0.3\n", + "art.r fixed to: 1125.0\n", + "art.c fixed to: 3.0\n", + "ven.r fixed to: 9.0\n", + "ven.c fixed to: 133.3\n", + "av.r fixed to: 6.0\n", + "mv.r fixed to: 4.1\n", + "la.E_pas fixed to: 0.44\n", + "la.E_act to sample from: 0.225 - 0.675\n", + "la.v_ref fixed to: 10.0\n", + "la.k_pas fixed to: 0.046\n", + "lv.E_pas to sample from: 0.5 - 1.5\n", + "lv.E_act fixed to: 3.0\n", + "lv.v_ref fixed to: 10.0\n", + "lv.k_pas to sample from: 0.01 - 0.045\n" + ] + } + ], + "source": [ + "print(\"Updated simulator parameters range with fixed values for non-sensitive parameters:\")\n", + "for param, (a, b) in simulator.parameters_range.items():\n", + " if a == b:\n", + " print(f\"{param} fixed to: {round(float(a), 3)}\")\n", + " else:\n", + " print(f\"{param} to sample from: {round(float(a), 3)} - {round(float(b), 3)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Patient level calibration\n", + "\n", + "To refine our emulator, we need real-world observations to compare against. These observations can come from experiments reported in the literature. \n", + "\n", + "In this example, we'll generate synthetic \"observations\" by running the simulator at the midpoint of each parameter range, treating these as our \"ground truth\" values for calibration. Note that in a real world example one can have multiple observations." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "is_executing": true + }, + "outputs": [], + "source": [ + "# Calculate midpoint parameters\n", + "patient_true_values = {}\n", + "for param_name in simulator.parameters_range:\n", + " # Calculate the midpoint of the parameter range\n", + " min_val, max_val = simulator.parameters_range[param_name]\n", + " patient_true_values[param_name] = (max_val + min_val) / 2.0\n", + "\n", + "# Run the simulator with midpoint parameters\n", + "midpoint_results = simulator.forward(\n", + " torch.tensor(list(patient_true_values.values())).reshape(1, -1)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "is_executing": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'lv.P_min': (12.257057189941406, 0.6128528594970704),\n", + " 'lv.P_max': (22.596208572387695, 1.1298104286193849),\n", + " 'lv.P_mean': (20.69025421142578, 1.034512710571289),\n", + " 'lv.P_range': (10.339152336120605, 0.5169576168060303)}" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create observations dictionary\n", + "observations = {\n", + " name: (val.item(), max(abs(val.item()) * 0.05, 0.05)) for\n", + " name, val in \n", + " zip(simulator.output_names, midpoint_results[0])}\n", + "observations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### History Matching\n", + "\n", + "Once the influential parameters have been selected with sensitivity analysis, we want to find which values of those parameters are consistent with the clinical data for a specific patient such as the observations generated above. Rather than directly estimating the parameters, history matching first focuses on excluding regions of the parameter space that are not plausible. \n", + "\n", + "Given emulator predictions for a number of possible parameter sets $f(θ)$ and observed data $y_{obs}$, history matching:\n", + "- Computes an implausibility measure for each parameter set: $I(\\theta) = \\frac{|y_{obs} - \\mathbb{E}[f(\\theta)]|}{\\sqrt{\\text{Var}[f(\\theta)]}}$\n", + "- Rule out all $θ$ such that $I(θ)>$ threshold (e.g., 3).\n", + "\n", + "The denominator in the implausability calculation can optionally include uncertainty in the observations or a model discrepancy term." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since history matching requires predictive variance, below we train a Gaussian Process emulator. The emulator is trained on to predict the outputs given only the most sensitive parameters as inputs." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "is_executing": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Running simulations: 100%|██████████| 500/500 [02:11<00:00, 3.80sample/s] \n" + ] + } + ], + "source": [ + "x = simulator.sample_inputs(500,random_seed=seed)\n", + "y, x = simulator.forward_batch(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "is_executing": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Comparing models: 100%|██████████| 1.00/1.00 [00:04<00:00, 4.67s/model]\n" + ] + } + ], + "source": [ + "from autoemulate.emulators.gaussian_process.kernel import matern_3_2_kernel\n", + "\n", + "sa_parameter_idx = [\n", + " simulator.get_parameter_idx(param) for param in top_parameters_sa\n", + "]\n", + "\n", + "ae_hm = AutoEmulate(\n", + " # only use sensitive parameters as inputs to emulator\n", + " x[:, sa_parameter_idx], \n", + " y, \n", + " models=[\"GaussianProcess\"], \n", + " model_params = {\n", + " 'covar_module': matern_3_2_kernel,\n", + " 'standardize_x': True,\n", + " 'standardize_y': True\n", + " \n", + " }\n", + ")\n", + "\n", + "res = ae_hm.best_result()\n", + "gp_matern = res.model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We could now use the emulator to make predictions and evaluate those predictions against observations as described above.\n", + "\n", + "However, we often want to run history matching iteratively and make use of the simulator to continually improve the emulator and the calibration results. \n", + "\n", + "To this end, AutoEmulate implements the `HistoryMatchingWorkflow`, which can run multiple \"waves\" of history matching. In each wave:\n", + "- new parameters are sampled from the not ruled out yet (NROY) space and evaluated on their plausability using an emulator\n", + "- new simulations are run for a subset of those parameters\n", + "- the emulator is retrained with the newly simulated data from the current wave and all previous waves\n", + "\n", + "The `HistoryMatchingWorkflow` object takes in the simulator, the trained emulator and observations. Since the emulator was trained on a subset of the simulation parameters, we need to specify which parameters those are. `HistoryMatchingWorkflow` can also optionally be passed the data the emulator was trained on to reuse when retraining the emulator." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "is_executing": true + }, + "outputs": [], + "source": [ + "from autoemulate.calibration.history_matching import HistoryMatchingWorkflow\n", + "\n", + "hmw = HistoryMatchingWorkflow(\n", + " simulator=simulator,\n", + " result=ae_hm.best_result(),\n", + " observations=observations,\n", + " threshold=3.0,\n", + " train_x=x.float(),\n", + " train_y=y.float(),\n", + " # specify subset of simulator parameters to calibrate\n", + " # these are the input parameters the emulator was trained on\n", + " calibration_params=top_parameters_sa,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The workflow is called with the `run_waves` method. The user can specify how many waves to run but when the NROY region changes little between waves (e.g., <10% of new points are excluded) then the workflow is stopped even if not all waves have been completed." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "is_executing": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:autoemulate:Running history matching wave 1/5\n", + "DEBUG:autoemulate:Running history matching wave with 100 simulations and 1000 test samples\n", + "DEBUG:autoemulate:Generated 404 NROY samples on try 1, have 404 total NROY samples so far.\n", + "INFO:autoemulate:Running batch simulation for 100 samples\n", + "Running simulations: 100%|██████████| 100/100 [00:36<00:00, 2.71sample/s] \n", + "INFO:autoemulate:Successfully completed 100/100 simulations (100.0%)\n", + "INFO:autoemulate:Refitting emulator on all data.\n", + "INFO:autoemulate:Wave 1/5: NROY fraction is 40.40%\n", + "INFO:autoemulate:Running history matching wave 2/5\n", + "DEBUG:autoemulate:Running history matching wave with 100 simulations and 1000 test samples\n", + "WARNING:py.warnings:/Users/rjersakova/Documents/Projects/autoemulate/.venv/lib/python3.12/site-packages/linear_operator/utils/linear_cg.py:338: NumericalWarning: CG terminated in 1000 iterations with average residual norm 0.13786154985427856 which is larger than the tolerance of 0.01 specified by linear_operator.settings.cg_tolerance. If performance is affected, consider raising the maximum number of CG iterations by running code in a linear_operator.settings.max_cg_iterations(value) context.\n", + " warnings.warn(\n", + "\n", + "DEBUG:autoemulate:Generated 96 NROY samples on try 1, have 96 total NROY samples so far.\n", + "DEBUG:autoemulate:Generated 124 NROY samples on try 2, have 220 total NROY samples so far.\n", + "INFO:autoemulate:Running batch simulation for 100 samples\n", + "Running simulations: 100%|██████████| 100/100 [00:44<00:00, 2.26sample/s] \n", + "INFO:autoemulate:Successfully completed 100/100 simulations (100.0%)\n", + "INFO:autoemulate:Refitting emulator on all data.\n", + "INFO:autoemulate:Wave 2/5: NROY fraction is 11.00%\n", + "INFO:autoemulate:Running history matching wave 3/5\n", + "DEBUG:autoemulate:Running history matching wave with 100 simulations and 1000 test samples\n", + "DEBUG:autoemulate:Generated 593 NROY samples on try 1, have 593 total NROY samples so far.\n", + "INFO:autoemulate:Running batch simulation for 100 samples\n", + "Running simulations: 100%|██████████| 100/100 [00:39<00:00, 2.50sample/s] \n", + "INFO:autoemulate:Successfully completed 100/100 simulations (100.0%)\n", + "INFO:autoemulate:Refitting emulator on all data.\n", + "INFO:autoemulate:Wave 3/5: NROY fraction is 59.30%\n", + "INFO:autoemulate:Running history matching wave 4/5\n", + "DEBUG:autoemulate:Running history matching wave with 100 simulations and 1000 test samples\n", + "WARNING:py.warnings:/Users/rjersakova/Documents/Projects/autoemulate/.venv/lib/python3.12/site-packages/linear_operator/utils/linear_cg.py:338: NumericalWarning: CG terminated in 1000 iterations with average residual norm 0.018177548423409462 which is larger than the tolerance of 0.01 specified by linear_operator.settings.cg_tolerance. If performance is affected, consider raising the maximum number of CG iterations by running code in a linear_operator.settings.max_cg_iterations(value) context.\n", + " warnings.warn(\n", + "\n", + "DEBUG:autoemulate:Generated 667 NROY samples on try 1, have 667 total NROY samples so far.\n", + "INFO:autoemulate:Running batch simulation for 100 samples\n", + "Running simulations: 100%|██████████| 100/100 [00:41<00:00, 2.40sample/s] \n", + "INFO:autoemulate:Successfully completed 100/100 simulations (100.0%)\n", + "INFO:autoemulate:Refitting emulator on all data.\n", + "INFO:autoemulate:Wave 4/5: NROY fraction is 66.70%\n", + "INFO:autoemulate:Running history matching wave 5/5\n", + "DEBUG:autoemulate:Running history matching wave with 100 simulations and 1000 test samples\n", + "DEBUG:autoemulate:Generated 687 NROY samples on try 1, have 687 total NROY samples so far.\n", + "INFO:autoemulate:Running batch simulation for 100 samples\n", + "Running simulations: 100%|██████████| 100/100 [00:41<00:00, 2.41sample/s] \n", + "INFO:autoemulate:Successfully completed 100/100 simulations (100.0%)\n", + "INFO:autoemulate:Refitting emulator on all data.\n", + "INFO:autoemulate:Wave 5/5: NROY fraction is 68.70%\n" + ] + } + ], + "source": [ + "n_waves=5\n", + "\n", + "history_matching_results = hmw.run_waves(\n", + " n_waves=n_waves, \n", + " # the number of simulations to run each wave\n", + " n_simulations=100, \n", + " # number of parameter samples to draw from which to select NROY samples to simulate\n", + " n_test_samples=1000\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The below figure shows the implausibility scores for each parameter combination, allowing us to visualize which regions of the parameter space are plausible (i.e., not ruled out yet) based on the observed data in a given wave. " + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# include the true value for reference\n", + "ref_val = {param: float(patient_true_values[param]) for param in top_parameters_sa}" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hmw.plot_wave(wave=0, ref_val=ref_val)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hmw.plot_wave(wave=4, ref_val=ref_val)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also plot the evolution of the NROY space over the waves of history matching for a given parameter." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:matplotlib.category:Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "INFO:matplotlib.category:Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hmw.plot_wave_evolution(top_parameters_sa[0], ref_val=ref_val)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Bayesian calibration\n", + "\n", + "We can now use the reduced parameter space from history matching to constrain Bayesian inference to estimate the posterior distribution of parameters given the observed patient data. We apply the following steps:\n", + "\n", + "- Define a prior over parameters using the NROY region from history matching.\n", + "\n", + "- Define a likelihood function that compares model predictions to patient data, including observation and model error.\n", + "\n", + "- Use a Bayesian method (MCMC) to sample from the posterior.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "# Get the last wave results\n", + "test_parameters, impl_scores = hmw.wave_results[-1]\n", + "nroy_points = hmw.get_nroy(impl_scores,test_parameters) # Implausibility < 3.0\n", + "\n", + "# Get exact min/max bounds for the parameters from the NROY points\n", + "params_post_hm = hmw.generate_param_bounds(\n", + " nroy_x=nroy_points,\n", + " param_names=simulator.param_names, \n", + " buffer_ratio=0.0\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "is_executing": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:arviz.preview:arviz_base not installed\n", + "INFO:arviz.preview:arviz_stats not installed\n", + "INFO:arviz.preview:arviz_plots not installed\n", + "INFO:autoemulate:Initializing BayesianCalibration with parameters: ['la.E_act', 'lv.E_pas', 'lv.k_pas']\n", + "DEBUG:autoemulate:Observation for output 'lv.P_min' converted from 0D to 1D.\n", + "DEBUG:autoemulate:Observation for output 'lv.P_max' converted from 0D to 1D.\n", + "DEBUG:autoemulate:Observation for output 'lv.P_mean' converted from 0D to 1D.\n", + "DEBUG:autoemulate:Observation for output 'lv.P_range' converted from 0D to 1D.\n", + "INFO:autoemulate:Processed observations for outputs: ['lv.P_min', 'lv.P_max', 'lv.P_mean', 'lv.P_range']\n", + "DEBUG:autoemulate:Observation noise (variance) set as dict: {'lv.P_min': 0.3755886273937359, 'lv.P_max': 1.276471604617118, 'lv.P_mean': 1.0702165483335555, 'lv.P_range': 0.2672451775737704}\n", + "DEBUG:autoemulate:Using NUTS kernel.\n", + "INFO:autoemulate:Starting MCMC run.\n", + "Warmup: 0%| | 0/1250 [00:00, ?it/s]WARNING:py.warnings:/Users/rjersakova/Documents/Projects/autoemulate/.venv/lib/python3.12/site-packages/linear_operator/utils/linear_cg.py:338: NumericalWarning: CG terminated in 1000 iterations with average residual norm 0.024188920855522156 which is larger than the tolerance of 0.01 specified by linear_operator.settings.cg_tolerance. If performance is affected, consider raising the maximum number of CG iterations by running code in a linear_operator.settings.max_cg_iterations(value) context.\n", + " warnings.warn(\n", + "\n", + "Sample: 100%|██████████| 1250/1250 [00:23, 52.55it/s, step size=7.58e-01, acc. prob=0.853]\n", + "INFO:autoemulate:MCMC run completed.\n" + ] + } + ], + "source": [ + "from autoemulate.calibration.bayes import BayesianCalibration\n", + "\n", + "model_post_hm = hmw.emulator # Use the emulator from history matching\n", + "\n", + "bc = BayesianCalibration(\n", + " emulator=model_post_hm,\n", + " parameter_range={k:v for k,v in params_post_hm.items() if k in top_parameters_sa},\n", + " observations = {k: torch.tensor(v[0]) for k,v in observations.items()},\n", + " # take account of the emulator uncertainty\n", + " model_uncertainty=True,\n", + " # specify observation noise as variance\n", + " observation_noise={k: v[1]**2 for k,v in observations.items()}\n", + ")\n", + "\n", + "mcmc = bc.run_mcmc(warmup_steps=250, num_samples=1000, sampler='nuts')" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "is_executing": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " mean std median 5.0% 95.0% n_eff r_hat\n", + " la.E_act 0.49 0.10 0.49 0.31 0.63 913.40 1.00\n", + " lv.E_pas 1.00 0.27 1.01 0.53 1.39 1036.36 1.00\n", + " lv.k_pas 0.03 0.00 0.03 0.02 0.03 703.18 1.01\n", + "\n", + "Number of divergences: 0\n" + ] + } + ], + "source": [ + "mcmc.summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can check if the posterior samples are consistent with the true values of the parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "is_executing": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG:autoemulate:Using az.from_pyro for conversion.\n", + "WARNING:py.warnings:/Users/rjersakova/Documents/Projects/autoemulate/.venv/lib/python3.12/site-packages/arviz/data/io_pyro.py:158: UserWarning: Could not get vectorized trace, log_likelihood group will be omitted. Check your model vectorization or set log_likelihood=False\n", + " warnings.warn(\n", + "\n", + "INFO:autoemulate:Arviz InferenceData conversion complete.\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA74AAAJOCAYAAACQm9usAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAhOpJREFUeJzt3QWYVNUbx/GX7u5GultEQUFEUAwwEQsTCzH/toKN3R2I3YIoNoiKiIiE0iDd3c38n98Z7u7M7Ozu7LK7M3v5fp5n2GHizp2ZO+ee98R78gQCgYABAAAAAOBTeeO9AwAAAAAAZCcCXwAAAACArxH4AgAAAAB8jcAXAAAAAOBrBL4AAAAAAF8j8AUAAAAA+BqBLwAAAADA1wh8AQAAAAC+RuALAAAAAPA1Al+fq127tuXJk8cWLlyY5dt+66233LYvuuiiLN82AOS2MvHnn392247lAgCHQrkYKtbyUWUpkB3yZ8tWAQA4hPXr1y/euwAACalHjx5WuXLlVO9P675EoAaCww47zGrVqpXtjQXIWgS+AABkw4gYAEBKt912m3Xp0iXeu4FDEEOdAQAAAAC+RuB7CNm3b59Vr17dzZ/4448/Un3czTff7B5zww03ZPq1/vvvP2vUqFHSdvbv35/hbQwePNg9X38XLVpkF154oVWpUsUKFy5sDRo0cLfv2LEjxfP27Nlj7777rp133nluH0qWLGlFihSxhg0b2sCBA2358uVRX2/Tpk121113WfPmza1YsWJWqFAhq1q1qnXs2NHuuecet10A/pGTZWJ25FZYt26dXXPNNVazZk1XXmnYnfZxw4YNUZ/7+eef22WXXWbNmjWzMmXKuLJUw/UuueQSmz17dtTn7Nq1yx577DFr27atlShRwgoWLOiGIR5++OF2yy232Pr167P5HQOIB9W7HnnkEevatWtSGVO6dGnr1KmTvfLKK5mq1+WEH3/80a699lpr1aqVlS9f3u23yvk+ffrYxIkT03zupEmT3DQVlYsqH8uWLWstW7a0//3vf+7zEJW9ul90G/kbcpkAfK1WrVoBfc0LFixw/7/99tvd/6+44oqoj9+zZ0+gUqVK7jHTpk1Lc9tDhw51j+vXr1/Y7ePHjw9UqFAhkDdv3sBzzz2X6X0fNGiQ2/6FF14YKFeunNuvs846K3DyyScHihUr5u7r2LFjYMeOHWHPW7JkibuvVKlSgQ4dOrjn9OzZM1C1alV3u/Zt7ty5Yc/Ztm1boFmzZkn3n3LKKYFzzjkn0KVLl0DlypXd7Rs2bMj0ewHg/zJxzJgx7nHZeWr1yt1TTz01ULdu3UDp0qUDvXv3Dpx22mmBMmXKuPsaNmwYWL16dYrn5suXL1C0aNFAu3btAqeffrrbRp06ddxzVKaOGzcu7PH79u0LHHfcce7+kiVLBk488cRA3759A926dUv6HCdPnpxt7xVAfMpFuf/++91thx12mCsHVCfq3LlzoGDBgu52lSH79+/P0Ot45aPKyuyiclH72Lp1a1fGaT+bNGniXjd//vyBTz/9NOrzHn30UVdv1eMaNGgQOPvss11dsHHjxu42lb3y2muvBc4444ykclN14NALEhuB7yFWmM2ZM8f9X5WlyIBRRowY4e5v27ZtutuOFviqQClSpIirXGlbB8MLfHXp1atXYPv27WHBrQom3XfbbbeFPW/z5s3utXft2hV2++7du5MquQqEQw0bNszdroqdHhdZ+fv5559TbA9A7pOdZWJOBr66qGFv3bp1Sfepce6oo45y96mSGunDDz8MbN26New2VVxfeOEF95ymTZuGVWTHjh3rblcFUuVqpIkTJwbWrl2b5e8RQPwD3z///DPwzz//pHjssmXLAi1btnSP//jjjxMu8P3iiy8C69evj3q7Al91pITWJ0PL+cKFCwc++uijFM+dPn16YMaMGUn/1+ekx+tzQ+7CUOdDTP369e3oo4+2jRs32hdffJHi/qFDh7q/F198cYa3/fjjj9tZZ53lhhaPHTvWTj311CzZZw1Tfvnll91fj4atPPHEE+76iy++aDt37ky6T8Px9NoakheqQIEC9tBDD7nhy99++61t2bIl6b5Vq1a5v8cff7x7XKi8efNa586dU2wPQO6XXWViWkt19O7dO0v2/aWXXnJD8TwahqiyUq/x8ccf29KlS8Mer6F+msYRuZ9XX321HXnkkTZ9+nSbOXNminJRn4/K1Ujt2rWzcuXKZcl7AZBYNJ1B0yIiqQ716KOPuuuffPJJprZ97LHHplo+qhw7GCpfNZUj2u2qo2qKyJgxY8LuGzRokPv74IMP2tlnn53iuU2aNLHGjRsf1H4hMZDV+RCkCtyvv/7q5or17ds36fY1a9bY119/7eZDnHvuuRmaJ6eKkyphKhhGjRrl1oTLKt27d4+a2v7kk092lS4VYn///bcdddRRYfdPnTrVfvrpJ1uwYIFt27YtaT7K3r173fV58+ZZ69atkwp4UWGubWrboRVKAP6V1WViessZtWnTxg6W5p1pDlsk5ShQuaYy8Zdffkmx3yr31PCnv2r8U/kdGuRqrq8qed5+5suXz958802XV+H00093eRYAHBo0x//77793c2NXr17t/q+OW6/jILXcAAeznFHRokXtYCmXi8ruWbNmufwtqveJGve8/e7Zs6e7vnLlSpsyZYrr5Lj00ksP+rWR2Ah8D0FqzVKSJyUAUI+Aek9FCaGUwEm9AtFay1Lz4YcfukKlYsWKNm7cuAw9NxZeEoFoFGAr8A3t2VCQe8EFF0TtvQm1efPmpOtKq3/rrbe6JC6qsKrVUT1BSmzVq1cvO+WUU1yhCMB/srpMzInljNIqF3WfAt/QclEB7oABA1xSmuCIw/TLxbp169pTTz3lErvouboogZZ6h9U4qN4TRsIA/qSEfyr7Fi9eHFN5kSjLGd17772u5zathKSh++29PzXqlSpVKlv2CYmDmvwhSEPdVNFTr+fbb7+doqKW0SF9GganipZaA1VBikemv9CK3O233+6CXmV0Hj58uC1btiyplVIXVdoinyNDhgyx+fPn27PPPusqdAqgNcxRw2M6dOjg/g/Af7K6TEwUoWXcM88844ZBV6pUyd5//31buHChy4rvlYteT3dkuajsqMpc+uqrr7rM+uoBVmPn+eef73qGV6xYkePvC0D22r59u6v7KChU+ffnn3+6DO7q5FAZ4fX0ptWIFg/KXK8VPzRKR418c+fOTRrxp31V/TAR9xs5h8D3EOVV5LyKnXoHpk2b5no6NM81I5Tm/rfffnPDnN944w03tM4bVpIVNFQ5Naq8iddDI5rbJh999JHrrdV8lNBeCRWEafUgq6Kn56q3RIW9hvhpmI83pwWA/2RlmZgTMlsuqjKoIFc9t1quI5ZyUcHy5ZdfbsOGDXONg5oHrAZEXVfPDQB/0TQJTX/QdAdNddB0MI16UcNXeuVFPHnlnHp8+/fvb/Xq1XNDp71lhqLtt+qwokY8DYuGvxH4HqK0DpsCOhUCGp7sJXDRMN/MDOlVcKmCUnPLFDRqLph6WbOC5peoNzmS5hJrmLOSrmiNSY+3rqQqdpG+++47W7t2bcyvrcJe85dFc0AA+FNWl4nZTUG5LpE0h01Bu/b5mGOOialc1HMyUr5pNI2mhgjlIuA/XnnhBYWRNA0kEaVVzqke+cMPP6S4XXONlTNBvcIK8mPhdaZkZScPckbinc2R4z0cGv6moW/ewtzRKjm6qPczLVooXJnyNC925MiRdtJJJ2XJ8GANx7vqqqvc39DEBTfddJO7fuWVV4b1XHiZ95577rmw7Whojh4bjYZGK3CPHKatOSJKBJNaQQrAP7K6TMxOGqqncnHDhg1Jt6m3QrfpvjPOOMNq1KiRolx84YUXwso59XJoCHO0Ctzo0aNdA2PkXDlt/6uvvnLXKRcB//HKCyUInTFjRth9mvagDo7UqDxR+fj8889bvPZb+7h79+6wslGNmKn16HpZne+880777LPPUtyvzyA0432FChVc8KvEWF6wjdyB5FaHMBVOd911V1LLnXoHNCwkkjeXQ3M+0qPEAOpV1dwQJYrREEFVnA4mPb32U5WsOnXquPnEWrpIFTIF1Rpup0QGkQXYmWeeaXfffbcb9tK0aVPX0qesrXq+eqd///33sOdo+SXNgVPwrl5rJepS1kIld9Bzq1WrZrfcckum3wOAQ6tMjBYwh7rvvvtS7U2JhZZs+/fff1256C0N8vPPP7tKmBLzRVY677jjDteI99prr7kGSg1hVIIXlX3axmmnnZYiIaB6lG+44Qa3RJ0er7JTDZDqUda8X5X3eh8A/EX1IE0VGzFihLuuRFRa6UIjPFT+qTzRcOJoNC9Yj0lrdJ1yqqSVAFBT5rSiR0Zdf/31Lk+D6p0q15SfRQ13Kuc05PmSSy6J2qur8k/vR+W/6o8K3NULrPJOGfAV+GoUkBdYa9lLlcGffvqpy66vEUNeNurXX389w/uNHBTvhYSR84uSh+rZs2fSguJDhw7N0ILjerxu79evX4rn7Ny5M9CrVy93f6tWrQKrV6/O8L4PGjTIPV9///vvv0Dfvn0DlSpVChQsWDBQr169wD333BPYtm1b1Of+8ssvgeOOOy5Qvnz5QNGiRQPNmjULPPjgg4Fdu3YFOnfunOL9TJ48OXDbbbcFOnXqFKhWrZp7jQoVKgTatm0beOihhwJr167N8P4DOLTKRP3fuy+9i8qczAgtd1WuXnHFFYHq1au7MqtGjRqBgQMHBtatWxf1udOmTQuceuqpgSpVqgQKFy4cqF+/fuCWW24JbN682W0v8j3PmzcvMHjwYFeW1qxZ0z2nTJkygRYtWrjycsmSJZl6DwASv1zcvXt34LHHHgs0b97c1aPKli0b6N69e+D77793j9Pj9bxIXh1LdbdIsZaPTz31VKbfi/btvPPOc2VWoUKF3D5eeeWVgZUrV4bVK6MZP368q2uqHligQAH3nlu2bOnKyUWLFoU9VuWsyl+9jh7r7TsSWx79k5OBNhArZeZTb656cHUdAA516iXRkGwN28vuJZMAAPAT5vgCAAAAAHyNwBcAAAAA4Gskt0KOUCKDWbNmxfRYJRVgbUgAfqckKFoDPRZKvPf4449n+z4BQCJQ2ZiRRFEqH1VOAmlhji9yhDICKqteLDp37uyykwKAnynz87Bhw2J6rJYNWrhwYbbvEwAkUj6DWC1YsMBq166drfuE3I/AFwAAAADga8zxBQAAAAD4GoEvAAAAAMDXCHwBAAAAAL5G4AsAAAAA8DUCXwAAAACArxH4AgAAAAB8jcAXAAAAAOBrBL4AAAAAAF8j8AUAAAAA+BqBLwAAAADA1wh8AQAAAAC+RuALAAAAAPA1Al8AAAAAgK8R+AIAAAAAfI3AFwAAAADgawS+AAAAAABfI/AFAAAAAPgagS8AAAAAwNcIfAEAAAAAvkbgCwAAAADwNQJfAAAAAICvEfgCAAAAAHyNwBcAAAAA4GsEvgAAAAAAXyPwBQAAAAD4GoEvAAAAAMDXCHwBAAAAAL6WP947AAAA0jdiyrIMP6dXq2rZsi8A/CmtcobyBLkdPb4AAAAAAF8j8AUAAAAA+BqBLwAAAADA1wh8AQAAAAC+RnIrAECOIklT5j4DAACQefT4AgAAAAB8jcAXAAAAAOBrBL4AAAAAAF8j8EXcMdcNAAAAQHYi8AUAAAAA+BqBLwAAAADA1wh8AQAAAAC+RuCLuGJ+LwAAAIDsRuALAAAAAPA1Al8AAAAAgK8R+AIAAAAAfI3AFwAAAADgawS+AAAAAABfI/AFAAAAAPgagS8AAAAAwNcIfAEAAAAAvkbgCwAAAADwNQJfAAAAAICvEfgCAAAAAHyNwBcAAAAA4GsEvgAAAAAAX8sf7x0AACA7jJiyLMPP6dWqWrbsCwAgd50nOB/4Dz2+AAAAAABfI/AFAAAAAPgaQ50BAAAA+E5mprzAv+jxBQAAAAD4Gj2+AAAcBHoUAABIfPT4AgAAAAB8jcAXAAAAAOBrBL4AAAAAAF8j8AUAAAAA+BqBLwAAAADA1wh8AQAAAAC+RuALAAAAAPA1Al8AAAAAgK8R+AIAAAAAfI3AFwAAAADgawS+AAAAAABfI/BFwhgxZVm8dwEAAACADxH4AgAAAAB8jcAXAAAAAOBrBL4AAAAAAF8j8AUAAAAA+BqBLwAAAADA1wh8AQAAAAC+RuALAAAAAPA1Al8AAAAAgK8R+AIAAAAAfI3AFwAAAADga/njvQMAACB7jJiyLMPP6dWqWrbsCwAA8USPLwAAAADA1wh8AQAAAAC+RuALAAAAAPA1Al8AAAAAgK8R+AIAAAAAfI3AFwAAAADgawS+AAAAAABfI/BFrjR9+nQ766yzrEKFClakSBFr3ry5Pf3007Z///5MbW/cuHHWs2dPK1u2rBUvXtzat29vb7/9dtTHrlq1yt544w077bTTrHr16lawYEErXbq0de7c2YYNG2aBQCDV15k4caKdffbZVrVqVStQoIB73tFHH21Dhw5N83kAkJP27dtnH3/8sd188812zDHHWLFixSxPnjx20UUXxXvXAOCgLJ4/2x793xV24bEt7OwOdW3gWcfZl++9nuk6ZKj777/flZW6vPvuu6k+7ptvvrHjjz/e1QOLFi3q6rGPPvqo7dmz56D3AanLn8Z9QEIaP368HXfccbZjxw4XoNauXdt++eUXu+GGG+z333+3jz76yBU4sfrss8+sT58+rsBTBa98+fL2008/Wb9+/WzatGn2+OOPhz3+pptusvfee8/y589v7dq1s06dOtmyZcvst99+c/vx1Vdf2Ycffmj58uWL+jqqULZp08YFvGvWrLFff/3VPffHH3902wWAeNuyZYsrrwAg0Y2Ysizmx86aOsnuubKP7d650+o3a2UVq9awGX9PsDcfH2yzpv5l/3vkpQzVIUPNnj3bHnzwQff8tDozHnnkEbvtttssb968dsQRR1jFihVd3fbWW2+1H374wUaNGuU6R5D16PFFrqKWsPPOO88FvU8++aRNmDDBBbpz5861I4880j755BPX6xqr9evX2yWXXOKC0U8//dR+/vln93fWrFlWr149e+KJJ9xtocqVK+cKtuXLl7uCSkGugtc//vjDSpYs6Z6vHuFQe/futauvvtq9joLbSZMmuf0ePXq0C67V0/z+++/bmDFjsuyzAoDMUqXrggsusGeeecY1KGpUCgDkZnv37LGn7rzWBb2X3DTIHnvnKxfovjjiV2vYoq39/sNXNnrkJ5natgLd/v37ux7cU089Nc2Rf7fffrsrYxXgqnwdPny4q8cee+yxrhMkssMFWYfAF7nKF198YQsWLLCWLVu6Hl6Phic///zz7rqC1Vi9/vrrtnnzZuvVq5edfvrpSbdXqlTJDTmJtj1VBO+44w43zDrU4Ycf7lrw5IMPPgi7T4H06tWrrWHDhnbuueeG3de4cWM7//zzkwpEAIg3DW3WdI+BAwe6RsXChQvHe5cA4KD8MeZbW7VssdVu0MROPf/ypNuLFC1m/W97wF0f8c4rmdq26pMa9ac6o4Lf1LzyyisuSNa0kR49eiTdro6Tl19+2fUWq2NHHSXIegS+cbZw4UJ3kHfp0sW2bdtmN954o9WoUcPNW9Vw2JEjRyY9Vr2ZGhKhCokCM1VI1PMZafv27fbwww9b69atXUCoS4cOHVLtCVVv5YABA6xFixZWpkwZ99qNGjVyQdzGjRtTPF49oN5cL/WYXnXVVValShUrVKiQNWvWzN58803LLl9//bX7e+aZZ6a4T59XnTp17N9//3Wf68Fu76STTnKVPbW+7dy5M6btKSAX9QaH0mcTC/UmA8h6q5Yvsd6tq9udl51pO3dstzcfv9cuPeFwN7/rxr4n2J9jf8h0WXvDOT3snKMauMstF55io7+M3mMw/e8J9uqQO+26s7vZecc0da99zWmd7e1nHrKtWzalePw/f/3u9vmZe26wLZs22MsP3m4XH9/GzmxfxwaeeZz9OPzDLP6UABzqdchdO3bYp288H3O5lpvqkJN+/cn9ParbSSnuq9u4uVWqXssWz5vtzhcZsXLlSrvlllvcNDyNSkxzHyZNcn/1nUVq0KCBywGzdu1al3sGWY/AN0Hs3r3b/WA0DFZBqi5Tp051CZQUeD311FOup7BEiRKuhUgtQc8995xddtllYdtRr6Ja59UjqR+iEi5p3qp6HFXIXHvttSle+3//+58bmqvCSvugi3pBNQdB81e3bt0adZ9VoOm1vvzySzdftWPHju51Lr30UtfylR30mYgK9Gi82zV8+GC3p6RVKoQV9M6ZMyem7f3333/ub+XKlcNuV0Bet25dN/9DQ5pDzZw50yVA0AlD3zeA7B3qds8VfWzsN19Yw+ZtrEHzNrZwzgwbctNlNvWPXzNV1m5ct8aatu1gTdocYUsXzLdnB91grw65K8VrD3v6AResFixU2Fq072gt2ney7Vu32udvvWh3XHy67di+Leo+b9uy2W7t18v+HPu9NW7d3hq3amdLF86z5++92X74PLw8AXDoyco65K39TrV3nx8StVzL7XXIBXNmuL91GjWLen/dA7cvmjMzQ9v1GhFeeumldB+rBgpRnS+tDhCvfoosFkBcLViwQLPf3aVr166BrVu3Jt03dOhQd3u9evUCZcqUCUycODHpvmXLlgUqVqzo7p8/f37S7T179nS3XXfddYGdO3cm3b5y5cpAu3bt3H3ffPNN2D6MGjUqsHHjxrDb9Nz+/fu7x997771h940ZMyZpn88555yw1/niiy/c7TVr1kzxXjt37pz0vFgv+gxC6XPQ7VOnTo36eV5//fXu/meffTaQnk2bNiW9jq5H07t3b3f/l19+me72du/eHWjcuLF7/BNPPJHi/t9++y1QunRpd3+bNm0Cffr0CRx77LGB/PnzB1q0aBH4+++/030NwA+GT16a4cvBvs4rX49P+r03b98x8OHvc5Luu/beJ93tVWrUzlRZ+8mE+UnbeuvHyYF6TVq6++55/p2wfbj7ubcD7/0yI+w2Pbf7Gee5x/e98qaw++5/7eOkfT66R6+w17ntydfd7RUqV0vxWTVt2yHDZa0+g7Q+6w8++MA9rl+/fpn6LgDknjrkyedemmq5lpvqkKHlmi7FS5Zytz/90fdRzzOnnHeZu/+yW+6L+bwzcuTIFO9T5aRue+edd1I8/qijjnL3vfTSSynu279/f6BUqeA+3nTTTTG9PjKGrM4JQpnd1FKkISieCy+80LWkzZs3z+666y6XQdijoRAaTqFWPM0pUI/ilClT3ER5zTXV/ABt06NhLa+++qrr2dTrnHDCCUn3nXjiiSn2R0NOtDyQhpyMGDHC7rnnnhSP0XwEzasNHcbbu3dv10vqDTdWxmWPXjP0/7J4/Xb3t2bZou66/oZSgqlQXsuhUr9H431+ykiantBWyKzY3t133+16bw877DC78sorU9yv1syxY8e6Fti///7bXbyeZaW013cIIHupXLzyjoetcJHk3/yxJ59pw556wFYsWZipsnbktBVJjy9droJdffcjbvj0t5+8Y206Hpt0X9tOXVPsT4GChezSmwfbTyM+sgljv7c+VyTnLvAULV7CLr/tAfdYT4djT7Ca9RomDcurVLVG0n1tjuriMpVmRJUa4WUzgEOzDlm/aUuX+Cm0DhlariVSHTKyLpleubZze/BxhQoXifp477yQ2uibaPVIJS7VEGVlZI6FRmEqoZWmH0bWFbX6x6ZNm2KudyLjCHwThH7M+uGEUqFTq1YtN9a/e/fuKZ7jBUorVgQrXd9//31SwRFaYHm8Ob9//vlnivu0HI/mgmiYiYaoeGuZKShTprlo2rZtG3VOqt6HCi3tV2gh5SV+ipaCvlerau66/uZGyuysZFiaE6yhzNECaSW8uvjii90QJF1v2rSpmwus7H1KhqCMzioMY50PDCDjKlStYdVqhTcyqbysUKW6bd64PkvKWg2jK1y0mM2dPiXFfetWr7CJY390Q5V3bNuaVNbmz1/AVixeEHWfNfesZOmUw+Kq1qzjAt8Na1aHBb5nXDIg3c8BgH9kZR2y/bEnpFquJVodMjPLGWUlTXVZsmSJWwIz1rqbAuUXXnjBrQSixgl1mihZqj5/zXfWUplaCSTad4CDR+CbIKpVix7wqZBJ7X7vvl27drm/XkKnO++8011SE5moST0WKlAyumh29erVo96uOSSh+5WV9J43bNjgksqkNXfC24f0tuXR9tT6mJntaUkizZ9WIaWAVoFtJBX8WhdYa7VpnV/vtevXr+8y/CkA1u1qHVXBByB7lKsQPv/eU/hAY1VWlrV7doeXgSPeedXeefZh27s3Y2VtuYpVot5epFhwv/bsyfqyFsChWYd87/lH3MWPdUiV81s3b7JdO1Mm9RIlPvSyPKdHDQAKYLXsW9euKUfzpEbJxz7//HM766yz7J133nEXj0YRqZNKIzRTmwOMg0PgmyDSa9mJpeXHa2FTMgElUoqFWpxuuukmK1WqlFumR1nmlJjJa7nScBivNTAz+xRqyJAhrjUw2vCULw4MddbfUEq8oPfjqVmzpgt8ly5d6jIIRtLtolbO9CjQ1fvWsBI9r0mTJhnenpYf0lJISiyh5A7qAUqtR1gnBQ3VCQ24PWeffbYLfDXkiMAXyD558ubJ8rI2tWF2oWZPm2RDn7zPihYvaVf/71Fr1u5IK1O+QtLw5YuPb2sb1q5KZZ8zVtZ+9ubztnTh/Aw95/jT+lqT1u0z9BwA/qtDKoFe5erR6zyR09HiXYf0pFYGR5Zr5StXc4Hv2lUr3JJGkdatCu5rxSrRg/JQGhauz+yff/5JkaHZ288HH3zQJepS3S+0x7pbt24uGarqhurdzpcvnx111FF2xhlnuJGBolGByHoEvj7itZ4p+FJBFOu6uN6PUz2SoZShTpmhs8q3337r5rhmhAqT0MBXywUp053mx/bs2TPF4715s9GC4mi0PQWbel5k4KtAVQWShi9HDiGSGTNmuLktmuOheTJeYRWNF0Dr5BCNd7uCegC5q6yNZZid1o+U8wfcYl1PPSvsPvU+bFy3Osv27+/ff7bpk/7I0HMUiBP4Aocur1w7oksP633hFVEfEzkdLdHrkJHl2mENmrgs/v/N+tfaHX1cisfPn/Wv+1urQeOYX0Nzo1OjAFiXaHOT1aMbraNj/PjxrlFAc4GR9RhA7iNKkBRaEMXCC7SiDTnRmm9aZDuraO02bS/0MnzyUnfxrkferyHEkWvryqeffppi+5MnT3YtaEqMkFoChEhpbU89sBrSo5Y5Bb+hNCRIc2bWrVtngwcPtuuvvz7N1/GWN/rrr79S7TmWWPcbQO4qa9XLkNqw5d9/+DpLy9oHX/80qWyN9XLcqWdn2esDyL3l2oQDjXS5oQ4ZWZdMr1xreyDY/f3Hr1NsX8HwqqWLXNLA0JwJqVHdL7X98RoBNIxZ/3/rrbdieo9ff/21q8eqh1hDopH1CHx9RAuTq+DSotfXXHONSzAQSb2lajXzeD2ZGqYbOj9DvZmxZqjLScqIrKzJeh/qZQ2di6v3LNF6u7WunBZUj0zKoKHUGvKsrIOacxG6lp0WI4+2Pd2noFfJHHTfoEGD0t1vDYcW9S5HrvOmoULeeznzzDNj+hwAJE5Zu31ryuybC2bPsL/HjUn6v5dQS+v4ai1hz5L5c+ztZx/KoT0HgLTLtZlTJtorD98ZtVzL7XVIZcOvVK2m6/X98t3Xwub26j1LrwuuiLkOmVmTJk1K0Sig5KYaOaiOFs2bRvZgqLPPvPvuu66l6MUXX3TZhVu1auXmWGge67Rp01z2ueuuuy4pFb1+ZMoorGx8DRs2dBPr169f74aTaBiffuSLFi2yRFGgQAH3HtULe+ONN9pHH33k5t/++uuvbh6JAsfI4TYyf/589z4ik2KVLVvWJZTSHFs9V0OrlWVQC75rcXW9RuTcjSuuuMIlq1LmZmVLjOyVlvLly7tszR4tI3XzzTe727yMfhparaRWGtaieSL9+/d37wtA7iprh73znh3WsImVrVDJVRYXzp1pa1cut5PPvTRpOaOup/Zxya0m/vKDXXNaZ6vXtKVt3bTRDUluf2wPm/vvFFuzIjglIlGorPKmj2h0i9cjEZrATw13APxTrh3Z+Tj75uNh9ss3w6OWa7m5Dpm/QAG74YFn7Z6rzrE3n7jXfvv+S5fRf8bff7ocC0d1O8m6nhI+FSWtOmRmaS7vvn373AhFDXlWnVLBsIJejUDUZ4nsQeDrM8oarFaj1157zU2a1/Bf/V/r+Cp1/cCBA+2cc85JeryCPA2zVcucCqovv/zS9ajef//9LlCLNUlWTlICAO2zelo19EUtkNpPrVenAjlPnrST10QrgNQT+8ADD7hKnBJVKSgdMGBA1CDaG9qjAlDrsEWjYDw08JXHHnvM7fvLL7/sCrjZs2e77IWdO3e2yy+/3Pr27Zuh/QaQGGXti2+8bf/Nmm6zpk6y0uXKux6Fk/teYp16nJr0eC1H9Ni7X9nbzzzkgt2JY7+3ilVr2rlX32y9LrzSrjyloyUa9dpMmDAh7DY19ukCwJ/l2pC3htv3n79vv333ZYpy7dabbsj1dchGrdrZ4+9+bR+89IT9O2m86/2tXL22ndbvStdYmdE6ZGZo/d7hw4e7hgHlialSpYqrB+pz9JaZQvbIE8jKAfhABvllHV8AscvMmouZKRsS+XUSGeUwcOhKqzxL1LIhu8rgRH2/yDzm+AIAAAAAfI3AFwAAAADgawS+AAAAAABfI/AFAAAAAPgagS8AAAAAwNcIfAEAAAAAvkbgCwAAAADwtfzx3gEAAAAAOBTWSkf80OMLAAAAAPA1Al8AAAAAgK8R+AIAAAAAfI05vgCAhJdTc7yYS5a5z6BXq2rZsi8AAGQVenwBAAAAAL5G4AsAAAAA8DUCXwAAAACArxH4AgAAAAB8jeRWAADgoJAQCwCQ6OjxBQAAAAD4GoEvEgJLiAAAAADILgS+AAAAAABfI/AFAAAAAPgagS8AAAAAwNcIfAEAAAAAvsZyRoivQMDy7t/jru7PWyDeewMAiVMe5skT7z0CgJwRCJjt2x28nq8g5R+yBYEv4kqVvNaT73TXJ7d+MN67AwAJUx7uV+UPAA4FCnqHXx283vtFs/yF4r1H8CGGOgMAAAAAfI3AFwAAAADgawS+AAAAAABfI/AFAAAAAPgagS8AAAAAwNfI6gwAAAAgTSOmLEvz/l6tquXYvgCZQY8vAAAAAMDXCHwBAAAAAL5G4AsAAAAA8DUCXwAAAACArxH4AgAAAAB8jcAXAAAAAOBrBL4AAAAAAF8j8AUAAAAA+BqBLwAAAADA1wh8AQAAAAC+lj/eOwAAAAAgdxsxZVmq9/VqVS1H9wWIhh5fAAAAAICvEfgCAAAAAHyNwBcAAAAA4GsEvgAAAAAAXyPwBQAAAAD4GoEvAAAAAMDXCHwBAAAAAL5G4AsAAAAA8DUCXwAAAACArxH4AgAAAAB8jcAXAAAAAOBrBL4AAAAAAF8j8AUAAAAA+BqBLwAAAADA1wh8AQAAAAC+RuALAAAAAPA1Al8AAAAAgK8R+AIAAAAAfI3AFwAAAADgawS+AAAAAABfI/AFAAAAAPgagS8AAAAAwNcIfAEAAAAAvkbgCwAAAADwNQJfAAAAAICvEfgCAAAAAHyNwBcAAAAA4GsEvgAAAAAAXyPwBQAAAAD4GoEvAAAAAMDX8sd7BwAAAAD414gpy9K8v1ez8jm2Lzh00eMLAAAAAPA1Al8AAAAAgK8R+AIAAAAAfI3AFwAAAADgawS+AAAAAABfI/AFAAAAAPgagS8AAAAAwNcIfAEAAAAAvkbgCwAAAADwNQJfAAAAAICv5Y/3DgAAAAA4dI2cutxab9zhrk+eutz25ysY712CD9HjCwAAAADwNQJfAAAAAICvHfxQ52mfmH1+WfhtvV40a31e+G0LfjUbdnL62ztygFmPBzO+H/v3m01+22zqR2ZrZprt3m5WorJZnS5mHa8zK1c35XNWTDUb/aDZ4j/M9u4wK1fPrP3lZu0uif4ab51stvBXs863mR17u8Xd9C/M/n7bbMU0s12bzYpVMKt1lFmHq82qtcn8dtfNNxv3jNl/P5ttWWlWsKhZhcZmLfuYtb7QLG9Ee8murWb/jTFb+JvZsr+Dz9m22ixPXrNS1c0OOya4T5HfwYZFdsrIVkn/rb70a7ORaexXtOMqM8eiZ/pws8nvmC2fbLZzs1mRMmY12psdfqlZ3a7Rn/PFVWZT37d0XTXerFITy1EH8xvL7velY0LH1NwfzDYtNdMQJh0PTU8zO+IKs/yFUj5n4utmE98wWzfPLH8Rs5odzLreZValRcrHrp1n9tKRyftYvl7G9xEZ+w3pd6/vaPY3ZmvnBMugvAXMSlQyq364WduLzGp3ytRuVFo51mou/sJKb/jXCu1aZ3kC+2xPgZK2uWQ9W1H1eFtU60zbny/8mCm/5g9rOOslK73xX8sT2G+bSzawufUvtRXVuqfYfp79u63r6N5WfOtC+7v1g7ak1mkWL6U2TreKq36zsuunWpkNU63Q7g1J5eHiGr1tctuH4rZvDWc+b41mv5ju4/7o8KKtqtwl7LZyaye67yT4vv6xAnu3JN03q+HVNrvxgMyd5xf9FjzX6LytsmTbGrO9O82KVTSr3i5YfuucE2nbWrMfB5vN/d5s+/pg/aBJL7Nj7wye4yKNedhs7BCz2kebXfRVxvcVOW/SW2YLx5mt+jd4XOzYEDzXFK8UrBO17GtW//jUn5+ZOkF27VMur59WXfat1Vr0mZXaONPy791iuwuVs7Xl2tp/dfvZxjLNDnr7efbvsS4/n2klN89Num17kar2Q48fUzy246/9rPy6ielu86uTJ9q+/MUsbub+aDblXbMlfwbLqwKFg+Va1dZmTU41a3xKyufs3WU24ZVgPKC6+77dwXq3jqmO1wfPxxkx+T2zEVfH/vjrppmVqZWrytiDC3z1xr69zeJu9zaz9/sEf/ShNi4y+3uY2dQPzc58I/ygWT3T7M0TzPZsN1MFqlBJs9UzzL66wWzrGrMut4Zv659Pg9svXdOs0w0WV/v3mX1+udm/n4XfvnmZ2T+fBG8/YUgwoMioGV+afXaZ2b5dybft2GW2+PfgRZ/DuR+ZFQwpHOb9aPZJv+jbU4VYl8nvmp3+avBHkB0ycizu22v26cVmM78Mv13B+qyvgpfMNsAgpcUTzN47y2zXpuTbdCJf/nfwMvUDswu/NCteIfn+MQ+ZjX0keL1oebNdW8zmfhes8PYfY1ahYfhrfHNLsMBXQU/Qm/2/oa2rg+Xn+vnht+/fa7ZhYfCisui4e8yOvilDu9F82oNW57/3UtxeaPd6q7D2T3epuegL++3oYUmVlAqrf7cjf+9veWy/7c1f1PblLWRlNv5j7Sdeb3/ve9iW1Awvd+rNe8sFvevLtrIlNXtbPClYr7JytPlN82kPWanNs7N2owoahkWp/MnmpWYzdBludtS1Zt0fSL5vzw6zoScGz0VqkFXQsWmJ2fjnzVZOM+sX0eKq43fc02Z585ud+GjWvgdkHwWKOo+nKJMWBC+qG7Xvb9bzsZyrE2Rmn3Jz/TSwz9r+datVXzYq7OYiO1ZajaVfW/Wl39g/zW+zBXXPP6iXqT/ntbCgN1fbs9Psi/5mM0aE3656+M5NZuvmmm1enjLw1Xn47V7BYyOUHq+LgtjzPjGreUQOvIcduaaMPbjA99vbzbavzfjzChQ1q9ct+n2VMtES9NWN4UFvhUZmpWoEK8mqYOvg+fQSsyvHmVVoEHzMb08FC5VCpcyuHm9WsqrZJxcFT5q676gBycGdeja+vzt4vcfDwVaYePp5SHjQW7pW8D0v+SP4IwnsDwYCuq1O59i3u2aO2WeXBgMIUS+bemzUqq5edNHnrM/79Feib0MtpFVaBbex9K/kAFot8l9cGewJ0mctBYvZ8irdXA+NbCzdzKqWDmkVmj/abPfW5P9XaZk1x+Lo+8JPcMUrm1VqGmxh9bahH2v5+sFeq9SUb5gyAPMULmlxdTC/sax8X2oB/KBPctCrQk7HlI5TtaqLCm399i7+OrkhS73D0qS32VlvBQv9F48MbufXJ8OPv5kjzeb/ZFaiqlnnWzK2f8jcb0hlUGjQW7BE8OS6dZXZyn+Sbx/9gFnzs4IVshiU3jAtRdC7vkwL21ughOtBzLc/WDaV3jTD6s5/x+Y0vNL9v+HsF13Qu7VYDRvb5VPbn7eQHTXuYiu3frI1mvlsWOBbeMdKazD7FQtYXpvW4i6zPHksUewuUNIK7tlsiUi9Kan11OwsHNJolVPvSwGBeswKFDFbPsVsx/rk+35/zqzGEckVRTXCqEIm53xg1vAEswmvmn3zP7MFv5j9Nzb8XKnfgs5ZR1yV8yN3cHB0jilb16xUtWBdyPXehjS6/vmqWfOzzWocnvV1gqzap1xcP20068WwoHdb0eq2pURdK7t+sisDVE63+Och21Kynq2t0CFTr1F8y3xrMOfVTD13Q+lmtqPogTpohECeOOX71Sgr1WNC62+qvxctF+zQ8squUIFA8JgIDXrVM1y4VDD2UeOK6kuqfw2YZFasXGz7UrqmWeNTo9+n3mV1QHgU3JaokuvK2Mx/ywpKpn0YvK4gU5F9rNSD0+cdyxIr/03ej9CKsiozKrRe6xo8ABSIqXDr827wcTpRymFHBwsjadEnWLAoWF4zy6xa2+DtvzxqtmW5Wd3jzBrHMJQ0K2hI18Jfgj+Gk54IDyTUSuLRyb3fV2b5C5ptWhYc7ukVqD/cbXbFL7G/5k/3Jge9Kqgv/S4YbHo/MH02os9bLeqVQypBFZuadbnNrNFJZnnzBW9bO9fszR5m29cF/6+C/N/Pg4W2FCtvk9o9bq0n3+n+O7n1g1a17WHB+9b/F14Q1OoU/nqZPRbVc6hhIZ6ydcz6jw0GdNvWmb14RHA4kvs87jNreW7ws41Gw3Sza0iRGg2mvG92/H1mhYpn/PkH8xvLyvelIFW9NJ4+7wULRPnuzmBlQjR8UUNmG55otnpWsED0fpP6Les3qt+qWt5XHPjteq2M390RvN79/vCRCMi+8nzx+OTrefKZXTE2eSrD8GuCw7VElbxlk2IOfMutnRT2/9AhseXW/mWdfrsw6b4y65OPg1Ibgyf/lZW7uiBZllc7wQW+RXessIK71tvuQmXd7c3+fdTy79thC2qfbZtK58wJV8PyKq36xcpsmGYzm4T3yCyv1sOWVj/JNpRpYXn377ZuP52Uo68fq7Xl22do2PXCw/rYzkLlbUPZllZ8ywLrNC4TAUNqZZtGEbS5wKxQ8Lt25zyN+go9LtXb4QW+3vm+cOnk8qflOcFKmahM8SplGm44e1Rw6lACDBlFBqiupIbVosHfelJD6rtnBkeseXSceEFmVtYJsmqfEr1+Gthv5ddOsKrLf7RpLe9Obv/ctd7qzX096f/ryra2cZ2GWiBvQdfgeOzo3kkNYE3/fdzGHvtpJl47YK2mDHKNoHvyF7dAnrwZalRbcFjf7JnaklqdPT0aohxa163f3azXC2bFKybfFtpR4FF9adG45P+HjkiY/W0w4BXVv357MvbRCocdHbxE8/c74YFv24uTfwu5qIzNXHIrzZ8deX1yb6Pm0MZLaNArCsi8FnwFbYeFtDDoYNixMXg9ait/IOR6nuTg7Y+XgnMyTjww9DI76fVUuD7dPDiEQXPuIn8kXnAqbn7kgQNPBWTT05PvU+CvICIW+lzmhBzQmhvt9bDqs9KPKtS0j5Kva3y+AmzNQfCCXlHraLtLw58XOTQyNX++Hv59HNE/a47FpROTgyrR5+X1YqpFTIG7RwG75irkFPWs//qE2XPtzF4/zuyvN4KNNrmVGkz++Tj5/+UbJBeIctTA8MdrSoKk2wEX8gC1fm9cHGwYaX5mFuz0ISgz5Xm+AsnX1cIcOn8/cmSGF5zEYL/mCIcI7WHcWLpx2H1784c2CKV30ATvL79mglVb9q3tLlDKZjY58J6zkQLyZtMesh7fdrEjJlxrlVambIhcWuMUW179RNtRrFpcXj+7LDzsHFtZtZvtSqc3OEN0LA2YaHbk1eHHlY7BLrenfq6J9Xy/d3dwtJR0GxzcLnIP1UFCA0xRY2jkFCuNEsipOkFm9ilB66dqwGo842k7/vtu1nHcpVZ9Sfi8TJWt+fbvSfr/f3XOd0Gv7CxS2ZZVSz7/a9ROic3zMrwPtRd+ZOXW/e2uz2h6Y8R5IA7Sq7OnZ/yL4T2oZ7weHvSKyiHVydOKfULP26pnlasf8tiPgvWxgzXxteTrOle3uzhXlrGZ6/Ed82Bw/qyc8rTZ5hUZe/7uLWbf3xV8Xv7CZuXqmNXvkXqPXlqWhE5Yz2NWOSLxTdVWwWGQoh+ka3VQUNcq2GqmhEDqKdVQkmkfJw/x1TCDsLmD1wUDueygFhn1hGquowrhUJETwjXpPZTeR+T7De00WfqnWcUD7yUtak0KKbBSbNclFMqTfCCH7mdaQygif8CaqxJLRdzrMZKS1c0anZw1x6JacEMVKR3+f7VWhdL7TK0VVS20Xw4MDsd2Q7xbBoeIRG4zvfeq1j4lltJwEPWQefTbCG1IyKnfWFa8L6/X3mspj3ZMlTgwTGbLivBjSr89/QbVsq0CW73Aeox+q95wHrf9BcEh0epx7Mk8vEzLTHle59hgw5poiOmfr5m1Oi/4PSk5TOiJvOaBpGMx0NA3DUHWcDg57L/3bVOpxq5yU3/uqyl6Sj0bSzex8usmWeWVo212o6ttX75CLrmKN0R3d6Eylmf/Xms+LTjvc2aT62xPwQwezzEqtHONVV8y0mouGZFiDprmH2e37Hr9klvmWoup91mB3ZttT4HitqVkA1te9fisDWzTo0be/BFBROixltq5xit7dm4MNoCrYqhEmB6vTPn92WDArCk5Op6R+7lzbMgwZp0vQpOfZWWdIKv2KYHqpwV2b7Jqy76xGotHWNkNB8r8A/ZqX0KEjsKRyBE1m0o3jXj8VDfkOVaFd6yyJtOfdNeVKGth7T5Wf05yD3MsKq/82cqt+8v1GO8qWMaNtFlRtZvtz1c4e+rsaW5nY/jzG/QIzu/WyDadh3Us6vypRpLQxubI2EfTvCLr2ooFNM9XVA/TfHKNZjiYXC3eOV+0T0pelQvL2IwHvgqQ1MIkGvKhTHcaUpQROmg0ByeUWkyanWF26nMZG64Y2qqrVrXIISiRJ0NliFXg2+n6YMGjMfDPtTErWDx5LsfRNwYPXiV60hBAHVTHZPHcQSVTUECu4awashCaTEqtd5qfqblxqvSn9n4l9MBL7f3GIr3tKuuufoTesNVYtzvvQKNDaO9wehTshM5/OfyS6AFgZo7FyNYlBWdp/V+FRWoWjA1eQmnegpJUtDo39eep5U1zMNTDqaFLofOYlRRAn1GLs4PBZgZ6y7LsN5bZ9xUp8rOMll1QhbUX+Goui4Yua986Dgwmt9Ln81i94GekVvkCxYK/3bA5IlcG52PBcqw811BTDWH2ciuMujl4CaUspGe+maHyXJWgf5vfas3+ecQFv5VW/2Y9vjs27DF78xVxwa2yO3vmNLzKyv3e34pvW+Ievz9P/qThbzMbB0cW1PnvXSu5Zb5tLNXYFtY+27JS3n27rPKK0VZzyXCXaCtvYF/Y/q6o0tWWVT/ZVlfsmKWvm5OvX3rjdHcJ1fTfR2x2owE2t8HlFndKshgqNKO4RoOowqU5aB/2DZ4nvXJHo8I0tM+NuHkyWAarrEugud/IoM/7B88lqoRrCKYyznu9VCcOCc9hkZV1gqzapzjXT9VIWHH1OKuxeLhVXjkmKbeC7MtbwFZX7GRLa5xsKyuHl83Ftx1oQE1l7r+mPoQ/fmGG9qvF1PutwN6tti9vQZva6r5M/UarrvghxW07/y1nk9s8ZKsrHZ31dfa0uHwYIb2ic74PrtQSSisnKKdG3w+TE3eq4UTD29OsW0XGAvMPLvD9M2JOdWTy3FxUxmYs8NUX/+W1LmubG5ud1VlvlbBJk6fPyUAgHRogRbQ+pRg+4h5/oLCp2Njs4m+CvR1KF69CqGKT5HTxbu7gnclzBzXPUq1vauHR0Er1hOkAb3FOyuV90jvQFfCo9S40058OhFodgwePWlK0/fTeb7T3nNr7TU+K7UZp/dKEey/wjWW7+j7nfBPe4lPvuPSfpx966H60uSjrjkUtd6FCyhsuru9BvclaKmf+mGCBlpnPz6MAbbiG4ZVM2SqsgkffvS6bFoffp89GyS0UmGY0/Xx2/8bSe1+pSe9Y9Y6psOdsDh7Dx94RDIqTljMqHGwR73p3sIKgZZF0bLk5IncE39OkYcEluNTbrUQiGoaTVkK0Q93BlOcaCnj+58HnRw65kiJlg8tqVGqe4d36r+4FtqNwJWvz922Wf1/IEMQDFtc63RZHZGJeU/Eo+73j60nLGeXbv8s2lG6etJyRekEbznrRApbnQEKrvFZ5+Y9Wbfl3VmjnWttVuLwtq9rDDc3NiDLrJrtgs9rSb8OW61HgrSBTc3dXVulq+7Kppzfer69hjU1mPGX78hV231vcaDkzzXX0qJwKrZipTLloVDCPhYaqqgdEI4ma9g4utSE63+/ZFkxepPJYAY9GMih5jM4ZOkccfnn8ExcifTO/Cn6XoXQOUfbY1hfkbJ0gM/sU5/pp978/sMK7knvCNQpnbfl2tqz6Sba8anfbUzD68NQCe5LLIFG5EPb/iHpl/ojHp6XKsu+Sst8rqeHWEgfywWQBvdf2EwbYb0e/YxvLtMjaOntaIpNJbl0Z/XHquX3vjOBSjWr08BpNMhT7RNTHMkLZo0NHKKh81DJfoXJRGZuxwFfRvJexU/MJIuctpPlKhYOT8xv2DGaV1XxUJWrSD/Xnh5OHeKqLX13qmUq/HWUMe1rj2jUUQKm+o1GrhIIT78D+42WzbyNSyOtAmPOt2VnDYmu5UIH0csS6lpWbBwMevYaX7ThDIt5fVozjj7bdjG5bhbyyOHu0Flksn5O33p2n2ZnRh1Jn9ljU41Qh8npDFdC9GzIvOlLk+rJK0nPM/4JDPdV6ptZiZbz+8d6QXtKA2Q/3pAwQ1XIb2SOmFkJdoq0znVEH8xs7mPeVXcfU4ZcFL5EU5HpzRI4bFHzfWuJkyYTkx2jYuJbQOmto9LXvcHDlucqy985Ozvau40XJVnS8aekCDX92mSpHmJ31duyVr8B+a/7Pw2GZndeXaemG6JZdP8UlpdJ9VZb/YOOPej1smJyGSaeWJbTp9CdcT8GSGqfahnKtrek/j1i9+cPCHqN1c+fVu8imN4ut90RZpjv9lryMm4Lq9eVa29LqJ7u5bNk1lDonX39XoXI2r24/1xOytXht21WorBXbtsQazH7Zqi9LDggazXzOFtY+K2PDBbMy6H371OSKnYaNaum8yPOplkvrdSCZXiRlHNXoEg1r7XpPcErRO6eFj8ZRZU69PZf+kLHfChKDRgeNHHigzvZW8rn9YOsE2bFPca6fer/ijaUaBcuT6ifZziKZaZAPP7/nyWT9NP/uzdZiWrBhdlPJhq5BMyO2lKxrqyt1cgn6thWrbvvzFnbrpyvRoeYae414jWc8a+M7Jne8FNm+zOzl47O4zh5iX8j0Qk+r84NJTRUgqg7tJbDS8j+aEhetTnSw9fX0/DU0PLdQ+1SWSs0lZWzeDK3xOPZAi2qDE4M9UxmhbHU6GSn6V3e9WgdK1wguP9IhYrFkb05uLELn8agVLFJo0gKJpSUhbO7gY8GlVDRf0nvvtywI9jyJ1t2KXHsrNZEHorLwnfxMcFhnrD+gyDmyke85M+836nZT9rS4OZexbFctY1rX1/uhqDfpwhHJi1xnaDhF/6w/Fo8bnPrcgsjhIUonH0oZ6LreZVa7o1nJKsHWN1X4NQylZLXwoeMqqFKj1q6TngwOUcqKoPdgf2NZ9b4ycqxGHlOxHq9ujsh/ZtXambU+32zCy8lB72mvmN08L/j5as76yOuiv+6h7mB/Q59dnhz0ap62lku44AuzK38Nrt3r0fz10ARn6ai16LOwoHdS2yH2a+cPbHzHN+znYz9zw3alyM7Vbr3fWJRd97fVWPKlywA6velNVnrDP0lB74LDzrFRPcfbgtp9ktb31f2ZKc9VQZzacpBL6pTdQW9Ovf7COn1tevNbXY+6lgBRYLulZH2b1O4xtyyIR40KZdeHz//LEVrVYegJwWkS3moEKgMzMtxQIx+8hjSVgWpo1UgGVcjUIHjdtOA646oPaPSJ1hhHYrtzudmgjcFzgZZWCU30o2yy6mXKqjpBdu1TnOunqyp2sqmtBtv8+pfEHPTuyR8+NStfxIgdTckI5WXgT0+Dua9Z4V1rbX+efDal9X0WiEiCmJ5pLe9x0zGUYX53oXK2t0AxW1ehvf1x5Mu2N6SxrvzaPy1PyLDuFPFkZursaYmcyqbv9ISHg2WQyp5u94bfrylyMdetImOBTCaR2rfXbNLQ8Kz6zU7P+DYSqIyNPfBVynevkqp5XY8clnzx3pBH/9ftv4Usu5OW0Lk4orUgY6VeM4+G4ao3KJQ3xjza41Pz7W3B8ftqWdHcQc0d8hI/aSketUQoe7TWEZTIoTCpUaXezXHNkxx8vN7V7NnWwUXOtY5ueiL3f8vKg3+/Ube7ImUg7GXETmu7f71p9sUVydmItTTKxd/GtE5XoZ0HFov31OgQfajqwR6L+fKb9X7R7LLRZp1uDPa4KoA65RmzXiEZ9iQyWVpqXKDYJuXwkFBKLqWKmTe3Ur0UTzUx+/YOs2XBLIXZJrO/sVjeV2oiA/rIYzXyNgXYkcNzIkWbI+L9/lSAKn2+Wh01XMbLwhmZEA4H9xtSz4DWDPdoLro+89AlDtKa55+Gaku/DqlEFbOlNZLXE9xWvLatCenRLb92YnglJZrAvqSEVpoXrERMlVeMSbpbPQcatje3/mVhyU9iocpgaPBXY+lI6zq6l3UZfZrVm/O6FdkeMgcrG8T19fPktXXlDiynckChXTGuAZ2VS769dVJyAj2dj89+O+PZ3Se8FEwkpJ4crUKgRjX9XxQMqcFWy3B4SdpiPd8jvnRuULnUqKfZ2eGjO1ygGSo76gQHu09xrp8qv0LnsefYcT+c4EZ0FN8SMdc5iq3Fwzs3Cu9cE/H/8LrD1mK1Y9q1QjvXJfUYdxh/hZ0w6qikS5EdyXUIXfduj4WmuGwtnjzvNW9grxXcnTwkeG+B4gdfZ09LmYj3X6x8eON/ZB3Kq4OrXqa53WnWrSJjgUx2sMz8MnxbGqac0VEPCVbGZi6rc2jXdFr3h7ZCKOJX4RLNxog1IzOS0Ee9XEmVsIDZimnhC5N7a0uJWokiM8tG0uRyDQ9Rq4bmDkYGCd5izfriVcDogIg1iNAcgIu+ClYc3VzPD4IHgC6an6SLClUVuuqB8dZvC3u/7cN7UJSl2pvwHvl+pXrEOPzUqIdMn49XgIZmb0v6f0jzlzKyRdJQIa/l0Vu+5oLh0d9HFLUXfhq+fE9qSxgd7LHoqd42eAmlHsIkeYIJC2I5hmM5js/7OBg0qkdc372GdOv4+eOF4EWNCRrare8/9DuNVWZ/Ywf7vlKjIdPq7fcqppHH1OaI3060YyqS1uzVetBt+iUH5N42vN+mqNc6o4H6oSqjv6FoJ9m0eOt4x0A9ucnSHp6n5FeqpKSVVfiwBR9Z6U2zbHOJum5pjcgAbWfhYCbMnUWSM2Jqzm8sthWvZb90+dgtyVFjyQiXSVn7X2rzbCs1Y7ab++oNPV5etYfLLJ2Vsv31XYKsvKkOk9T6yKFydFkRzWf84JzkY7NgCbO+74dnxo3FllVmPx9YBqbn48Eh+aHlRWiSR69MyUjDPBJD8YhknaGrDRxMnSAn9ikO9dOZ377qypTi2xa7S8PZL7mLEgMqb8Cy6j3d8kSRNpRtZTWWJndelN44wzVYhv4//PEZy8GhMr/Q7o0Zul+JugJeh0OkwD4rvHNVqpnv3Vzmg62zp0V1ZPXEetM0NH9cPe9emevl1AkNjD2Kc7zefM0N1nk5tLwKrW+pHlYmk3Oi/wxdwii/2eGX5voyNnPr+GaGhiONfyE4xC7UqhlmvzwWfluNiPm9Q08yG1wqeHkqIlmK5jRGDoP0hmwoCPSyjnqpwtNakkW9xd48iW6Dkh8bms7e2//9+5JbXzI6hEA9Uxp+OnCy2SXfBSvxhQ5sQ/Pjfrjb7KmmZkN7pszw1vS04CRwjxZe93q5FaBMH558n36QoUsZqbLgfY66hGZv1XvV55P02LHJQbQ+z/HPp/25j3k4POhVIK2e3lgLgsB+q7n48+T/qzWrccQ6d1k5J0wNJJGLjyu7rRIkhS4kHhqAapmft04OJlbS45P2PWD2+/PBRojQk4gKtUhK2KRW2avGmV35m1mHa4Lzn0VDPMYOMXu+rdkrnYPbVFCa3b+xg3lfGxaFH1M6DjwqvDUXJjRBQ2hLXmTW6chjKpISV6mg1+9Rc3s93u8v9H2HXmctzqwV2sDgDWfW3F5P6LAor7wL9VRz6zW8ibt0/DV5jqooqVXo8NnQHuBiWxdZhTXJPc0a9ry7YOrBXMFdG6zRzGfd9X9a3JFU+dkTMryu4IFKkvc38v5YaJ7xjKY32fc9frLfj3zVVQw1fC6PBdx6ky2n3mc9vu1sR4y/0qosj8g8nAWy6/WLbF9pnX8+06ou+yZFz3rVpd+EbUtDELUsSJZQGRJapqiMCaVy6r2zkoNeDT3t92XGg17RuVbJ8FT2KLFKZHkRVqYcaMChPElMf79j9s+nUaZ/7TIbExz1kUTrlWdFnSC9+unB7FMc66dzGl1lPx3/rf169Lu2sNZZSUOYS2+aac2mP27dvzvOOv56odVc+FnYU5VbQFmfPcqkn/fAlDeNQNE6vx4F0aE5Gsqt+dNOGdnK5VpwlyUxDtFOR/WlX9nhEwZa2XWTIgLiPdb038fDknhp/vC+/MWyts6eFq1WEjrNSKOwlIDUE7o0YOSqKEpcFiq0PjVrVPjKK6qHhTZgjkmnjA2dSrL49+T/K19KRod4J2AZG3uPr7qiB6eSFUwB1IiQOYQaGtL6vJRRv3prlBxHiXdUeVJUr1aJkKUXXOY6zVOIlbrO9YFqCRyvW/7FDsEhthoP7/UgKlgMnXsWzThv7mDb8Cx7SiDg0fqyammZ/kXyUMHIYaQZoQNBF2X20zBftSgpk6A+E01q14HX5sLwFh+t2eYFMlqn9/nDg+u6qedb6e89yvaXEfp8NLlcBZU+tzdPCL63TUuShyV4P7jQ9WBV8VXAFkoB0lcHlp0JpcqJMhNGKLJjhZvDkUSZC1PrhTzYY1HLsHzRP5hxruxhwcJn9azwjHr64Z30RMrtqyFFF51stLaxhhOtnR1sEQyl7yi9NXh17J7QPJjIQMOVlLhA659pGJOCTV003CrW9XMP5jeWle8rlJZe0PvyWi4/Oj94TKmFU8O9Q39jac3LUxKIURFzRDzanralwFrDmtVzrNZZ0ftQ1k5k3W9I88b1GXvrD2pZBSVu05xr9VqoIhBKreExUsWpwtrkJGVt/7rFzfndm0/JrSa75Fahj021JV/LDM540i1ptKxqd1tbIXkt4XXl21v9ecHgvObiL2xug/5Wc3Fyg+G68jGMPIgmTz5bU6mTu+Tfs9WtI6yMywo+NYSu8qpfrMiOVW7NyFANZr1klVYFE8jli5gDp9uPHptcwfm184dZ/vppUUX38Ik3uUYGrZW8N38JK7ZtkZXYGr6ky6JaZ6boUdaav6UO9PCoESNyLnfF1b+ZTSwYbPGPNcu8ego+6Bu+5rymSPz2VMrHqpfj5OCan1EtGh+sN6i3+PiQc6Ua9tQYqQyuWqtT+RF0blh0oAKoPAhIPKumB4dUKtmhhgBrbq6mdGhkVWTPWdt+WVcnyK59SoD66fpybdxFDYdVVvzkljeqsGa8Wy6t/Lq/rNSm2ba4dnLgtrtQWZtX71JrOOdl938lJOz608m2pURdV36HZp6f3ixi+bs0TG77kLtEc/x33azojuVJa7b/0COicS8QsKorfnSXnYXK2eaSDV0QWHLznBRDsec06J/1dfb0KKmoGke8TM1a9mrSW2a7t5ktD5kCV6pmeOeA6ks1j0oOTNU5pdfXcerNBfbq4qqHZcafETl3UktqlcvK2MwNdc4Mr7FBAZVXqY+kD0PJdNIadhnNyU8FF/ledODLVpAWGqip8nvG6+HrpEVSb+lvqawvpfmpWuNSFXgdkLO+Tu7hUMCZFYswFygcnJuki4Ys6GCZ8kEwcUEkLROipXGmH+gh3bgoePHoPZwwJLhecUbo8znjDbPPLg0Gvyo450WseVarU8rKRLT0/lpfLhqtRxdF8a0hCZPUSKF5BNlt89LgJZIqUjoOVcEPFXpMaC0+ZQ6ORnMYOkYJ+lOj412LfeviFkb/LPjdL/sr9m24/cvkbyy73pfXUKPXUwZgNcpo39RzG6pC42BGy7QyT6rlXYG4lsdRo0ioI68NLpSuQnToicHED8oqLJ1uIANrduj9UjCTtjf3Rw0Z0ZIS6qSegZPYotpnusDX6xlQr6UqT5GUbXR6s/+luh0lqKq56HMXsP3bLDzb6apKR9ua8ke412ky42mrM/+dpFZ/3b6qUiZ6DiNobtji2me6S9Fti63G4hFWY8nIqI9VluSyGyIaCw4otHuDu2Tn66cq5OeoBofyET0mnhVVjrN/m9+e4vYSm+en+r6K7FzlLrbhQIUuVuo5Cw16RQ0tkY0tls521SM26sDx0+XW8CXkFPSoR23ENWar/jF7okEwx4UaJbSOeJeU7xUJREl9FMhGo7qR6k+pZfrPaJ0gJ/YpAeqn+/MVcsObddHScEoWqDJFDWmRlEtBjWNe1vdi25e6S+jSSP80vy2sMTJbhXxWKucLrwnpwQzZp5mNr7Xl1U/Mnjp7WtSD2uddsw/PDY5iUQAdOlLVGwF57ofB1wx9X5onPuzU5ESToZ0Jol7pvh+FD5GOlUYM/PNJeEdNrQx8ZwlcxuZc4HvR18FhuGqJ0JeklltVgtXDpJawJqcG03iHfrGxKlgsONRJQwx08GlNKJ0g1ZKs4O+o69KfM5k0d/DCYItapFOfMytXJ9gbogQ7OpAanGDWbXBwonlW0n6rZ00XtRhGUtDiLdOi96wePbUiqoW71lFmR16TMiFRrPQ9VBxv9vszwQBFP2glHFIvoVqb9PlkpMcvBgV2bwqfl9H09PBkOVlNPYBquVLrknqrVGnXvNXyDc0anRRMGhHtO1XLar+vgsN11dOu1lc9V0N79J1p+LBabfUdZJZa57xlfNbODR7b2f0by+73pdbRayYEM1GqIUW/H21bv0kN3dd3kdbvXsegl4FYJ/3I408F6mU/mP04ONjyqt+CTvgaWRA19T8OWvn6we9Ua25r3pkaJdQApkYrd8y0DzZeZfSYyZPP/jr8SVtaracL1LQmb6Fd6yxPYL/tLljKtpSo59aRXFT7DAvkDZnyESoQsBZTH3BBszJ57iwaMTQ7T16b0OEFazTreRdga07vjiKV3Tq+sxoPjG3pjwzYXqymzW58rc1uNMBKbAkZfpZDMvv6O4pWs7GdP3I9PcqMrcZJDQkP5MnrljnaUKa5LanRy1ZVOdZyHa0PrgqXyvwjQpbd82ikjRppxz0dnCqi41qjlTQqSmusIvG0uSB4HtfUHXUEbFsXrEjrNs1vVFmkntLQ6V8HWyfIzn1K0PqpcirMq3+pu5TYlDK5k0bhTDr8CTeypNbCz6zUphlWYM9WV2asK9/O5tftZxvLhIwYzGaa+qEpMRo9U2bDP1Z02xLLv3eb7c9b0HYUqeLWJ1Ym/M2l0vkODqbOnh4ldkqqI/0YDJ6V4Vh5UpQITWVUtAZ8TZ3r/7PZn68Ee/k1ZF8Ng6Wqm9U73qzT9eFzaDNi8rvBYy6zvb0JXMbmCQSycrEnIGNGTlpgrScHF7ee3PpBO6Vt1i1KDiAxjZhyYPkZhNF8uNDycH9oPgcf6tUqg8lgAPi2fE7E8o8yyn9yLrkVAAAAAABxQOALAAAAAPA1Al8AAAAAgK8R+AIAAAAAfI3AFwAAAADgawS+AAAAAABfI/AFAAAAAPgagS8AAAAAwNcIfAEAAAAAvkbgCwAAAADwNQJfAAAAAICvEfgCAAAAAHyNwBcAAAAA4GsEvgAAAAAAXyPwBQAAAAD4GoEvAAAAAMDXCHwBAAAAAL5G4AsAAAAA8DUCXwAAAACArxH4AgAAAAB8jcAXAAAAAOBrBL4AAAAAAF8j8AUAAAAA+BqBLwAAAADA1wh8AQAAAAC+RuALAAAAAPA1Al8AAAAAgK8R+AIAAAAAfI3AFwAAAADgawS+AAAAAABfI/AFAAAAAPgagS8AAAAAwNcIfAEAAAAAvkbgCwAAAADwNQJfAAAAAICvEfgCAAAAAHyNwBcAAAAA4GsEvgAAAAAAXyPwBQAAAAD4GoEvAAAAAMDXCHwBAAAAAL5G4AsAAAAA8DUCXwAAAACArxH4AgAAAAB8jcAXAAAAAOBrBL4AAAAAAF8j8AUAAAAA+BqBLwAAAADA1wh8AQAAAAC+RuALAAAAAPA1Al8AAAAAgK8R+AIAAAAAfI3AFwAAAADgawS+AAAAAABfI/AFAAAAAPgagS8AAAAAwNcIfAEAAAAAvkbgCwAAAADwNQJfAAAAAICvEfgCAAAAAHyNwBcAAAAA4GsEvgAAAAAAXyPwBQAAAAD4GoEvAAAAAMDXCHwBAAAAAL5G4AsAAAAA8DUCXwAAAACArxH4AgAAAAB8jcAXAAAAAOBrBL4AAAAAAF8j8AUAAAAA+BqBLwAAAADA1wh8AQAAAAC+RuALAAAAAPA1Al8AAAAAgK8R+AIAAAAAfI3AFwAAAADgawS+AAAAAABfI/AFAAAAAPgagS8AAAAAwNcIfAEAAAAAvkbgCwAAAADwNQJfAAAAAICvEfgCAAAAAHyNwBcAAAAA4GsEvgAAAAAAXyPwBQAAAAD4GoEvAAAAAMDXCHwBAAAAAL5G4AsAAAAA8DUCXwAAAACArxH4AgAAAAB8jcAXAAAAAOBrBL4AAAAAAF8j8AUAAAAA+BqBLwAAAADA1wh8AQAAAAC+RuALAAAAAPA1Al8AAAAAgK8R+AIAAAAAfI3AFwAAAADgawS+AAAAAABfI/AFAAAAAPgagS8AAAAAwNcIfAEAAAAAvkbgCwAAAADwNQJfAAAAAICvEfgCAAAAAHyNwBcAAAAA4GsEvgAAAAAAXyPwBQAAAAD4GoEvAAAAAMDXCHwBAAAAAL5G4AsAAAAA8DUCXwAAAACArxH4AgAAAAB8jcAXAAAAAOBrBL4AAAAAAF8j8AUAAAAA+BqBLwAAAADA1wh8AQAAAAC+RuALAAAAAPA1Al8AAAAAgK8R+AIAAAAAfI3AFwAAAADgawS+AAAAAABfI/AFAAAAAPgagS8AAAAAwNcIfAEAAAAAvkbgCwAAAADwNQJfAAAAAICvEfgCAAAAAHyNwBcAAAAA4GsEvgAAAAAAXyPwBQAAAAD4GoEvAAAAAMDXCHwBAAAAAL5G4AsAAAAA8DUCXwAAAACArxH4+tzMmTPtvPPOsypVqlihQoWsdu3aNmDAAFu7dm3M27j00kstT5487vLbb7+luH///v12zz33WNWqVa1IkSLWpUsXmzZtWtRt7d2715o3b25HHXWUBQKBDL8fbz/S8tZbb7nHXHTRRVFvD70UK1bM7bf2+dZbb7Xp06dneLsAco8l/821J+8YYBcf38bObF/HLu/ZwV4dcqdt3rA+5m08N/gm6926urvMmPxn1DLx/Rcfs4uPb2tnd6hrd152pi2cMyPqtvbt3WsDzzrObu3XK1Nlorcfafnpy4/dY56554aot4de+hxZ3+239nnYMw/a4vmzM7xdALm3fhjPsrDb4FHWe8gPCVMWUj/0HwJfHxs9erS1a9fO3n//fStdurSdfPLJrnB74YUXrHXr1rZ06dJ0tzFmzBh788030ww2H3nkEbv//vutVKlSdvzxx9v48eOtW7dutmXLlhSPfe6552zGjBluH9ILYLNL3bp1rV+/fu7Sq1cva9asmSvQHn30UXf9/PPPt82bN8dl3wBkn2l/jrObz+tpv3wz3IqVKGntjj7OChQsaKM+GmY39O1ha1ctT3cb/0wcZz+N+CjN8uvzoS/ax689Y8VKlLCWRxxjs6f9bYOu7Gs7tm1N8divPxxqS/+ba1fc/mDcysTKNWrZsaec5S7tu3S3mvUa2pL5c+yLt16ygWceZ0/dea1t35qyPAfgv/phvMrCrz4aZnOXb7YHzm2bMGUh9UP/yR/vHUD22L59u5177rnur3pj7733Xne7WtFuueUWe/zxx11P7nfffZfqNnbu3GlXXHGFNW3a1AW1v//+e4rH7NmzxxUILVu2tAkTJriC87333nOFwyuvvGI333xz0mNXrVplgwcPdttU4B0vnTp1cq1zofS5fP3113bttde6/VejwA8//GAFChSI234CyDq7duxwPb27du6wPv2vt75X3Zz02x/29AM2/O1X7Pl7/2eDX3wv1W3s3rXTXnrgNqtZt6EVLV7CZk39K8Vj9u7ZY18Me8lqN2hij70z0goULGRjR31uT9050L777F3rfeGVSY/duG6NffjKk9b9jPOtTqNmZvt2Wzw0btXerrvvqbDb9Ln89etP9tojd9vYUV/Y2lUr7N6XPrD8lImA7+uH8SgLP3j1GTuvc11rVrOsTTZLiLKwV6tq1A99hh5fn/r8889doNmwYUMbNGhQ0u1qRXvooYfckJbvv//epk6dmuo21Is7b948e/nll1P9gS9cuNA2btxo55xzjgt6pW/fvla4cGGbMmVK2GNVoGo7DzzwgCUafS5q8VTwrqEtY8eOtZdeeineuwUgi4wfPcpVrqrVrmt9rrgx7Ld//oDbrGLVGjZl/FhbMDv6MDxRz8WKJQvtyjsftnz5o7cbr16+xLZt2WRH9zjVVfTk6BN6W8FChWzB7PChcsOeftBt57xr/meJRp/L4cd0s0ffGWllK1Sy6ZP+sG8/eTveuwUgm+uH8SsLC9j/erewREP90F8IfH1q0qRJ7u8xxxxjefOGf80KPjt27OiujxgxIurz//nnH3vsscfskksucT2kqdmwYYP7W6ZMmaTb9HrqIfbuE/UWv/POO/bwww9b2bJlLVFVrFjR7rvvPnf92WefjffuAMgi82f+4/42aXNEijJRvZiNW7Vz1//8OfoomIVzZ9rwYS/bcb36WJPW7VN9na1bNrm/xUuWTrpNr1e0eEnbujl4n8ya8pf9/PVndsG1t1mJUsnlZ6IpXbZ8Uu/4Vx++Ge/dAZDN9cN4lYUXDviflSkWDJATEfVDfyDw9alt27alCEhDlStXzv2N1uOrZAT9+/d38z40jDktNWvWdH/nzJmTdJsC3jVr1iTdp+0pYULbtm3d8OpEd/bZZ7vCef78+THNgwaQ+Hbu2O7+Fi9ZKur9XvC5IEriFZVhL91/q5sX3O/6O9N8nQqVq7m/yxb9l3Tb1s0bbfOGdUn3aXuvPnKX1W3cwrr17muJrlP3U1yZuHLJopjm/gHIvfXDeJWFx/c62xId9cPcj8DXpypUqOD+Llq0KOr9CxYsSPV+JTf4448/3DyP9HpnK1eubG3atLGhQ4e6jM8Kem+88UZXmJ100knuMRoqrWHP2m5k62IiKlGihNWpU8ddVyIuALlfqTLBxr41y5dFvX/VsiXB+1ekvH/UR2/Z7H/+totuuDvd3tky5StancbNbfSXH7ksp6rovfnEfa5MbHv0ce4x3376jhvq1//2B3JFmVikWHGrVK1mUlZsAP6tH1IWpo76Ye5Hciuf0hAWzdXQhHwtXVS+fPmk+5YtW+Ym5ktk5mW1YN15550uffuFF14Y02s98cQT1qNHDzv66KOTbuvZs6ebE7Fu3Tq7++673ZDp9u3bhyXOKliwYKbfX3Zn/NPnpfnNocO1AeReTdscYZ++8Zz99dtPbrmOkmWSG/XWrV5hUyf84q7v2B6ebVQ9nO+98Kg1a3ekHXvKmTG91sU33m33Xn2+3XHJ6Um3te3U1c2Z3bxxg33w4mNumGCDZq3DksUUPIh6X3rLeByskqXLujl920KGKALwX/0wbmXhgeR+O/fsc8Gx5UvMspD6Ye5G4OtT3bt3dz2xf//9t5144omut7VJkyZu7q6yKms9XYlsYbvmmmts165dGZq4ryBZr6M5vEp0dcQRR9gFF1zg7rv99ttdRrwhQ4a4///00082cOBA11KmNX+POaG3PX/8PitcIGMlnJYiSo0KpHHjxtnB8NaQi1dKfQBZq9WRnV3vw38z/7H7Blzgehhq1Glgi+bOspcevNX27dsXtUx89eG7bM/u3XblHQ/H/FrN2x1lT37wjf381We2bctma9C8tXU56Qx33zvPPezKlwsH3uH+P3XCb/b6o/fYkv/mWMFChe2sI6rZ4HPaZvj9afmN1KxcstBmTploByNgB9bVpEwEfF0/jFtZqOXm7v/a5qzYbAULfWldTj7DLvvfva5cTKiykPphrkbg61P6QSpzn4Yb//XXXy4Y9VSqVMktK3TXXXeFzfH47LPP7Msvv3Q9tI0aNcrQ62nJIy+49eh133jjDZcEQC1kakk85ZRT3Fpoei0Fv4MGD7ZHttSzQX3aZOj1IpcjirzvYANftYJKIifiApCxMvG2x1+zBwb2s3kzptotF5ySdF/pchXsnCtudL0ZxUokzwH+/cev7c+x39vZl19n1Q+rl6HX0zIfF14XrNB55k2faj8N/9Auu+U+1+OsnuYHr7/IatVtaLc+/qotnTfLPnz1KStSML+dmnrOmKgilyMK9dOXHx90ZW/zxvXub4mQRDUA/Fc/jFdZeP8Nl1vjKkXt1as62dhAe/vgtWescOGidsnNyZmnE6EspH6YuxH4+litWrXc3NovvvjCZVXesWOHC1DPO+88V+iJ/u8ZOXKk+6th0L/8Ehzq4vGWJtI6ZsrYfNFFF7lLWi1i6j1u0aKFXXllcK02tSpqiPPHH3/sllM6/fTTbcyEKfb2t1/YLQmUwl6Lk//3XzAZg1pBAfhDxarV7akPv7M/xnzr1p3cvXOn1ajbwDr3PM3++Okb95iadRskPX7iLz+6v1P/+NWm/z0hbFveUh9a51brWHY99Ww77tSz0ywTXxlyp9Wq39h6nBkcETPqo2G2Z9cuu/nRl61S1RqWt0s32zX1C3v757nWY+cOK1As89NBstL2rVts1dLF7nqNOvXjvTsAsrF+eM/Tb8SnLNy9y1664nirUb64VW49wJYvW2KjPh5m511zixUqUsQSAfXD3I/A1+fy589vZ511lruEUkHnDVOOpMRWqfEC4GjPC/Xmm2/axIkT7ddff7V8+YLDmGfNmuV6fhX0eho0bWGjv/rMFq4Jn2scTwrMVTA3aNDArdkGwD+05mTH4092l1CzpgWX+ND8tUhK5pIabz3KaM8L9ePwD10vx0Nvfp5UJi5bOM/NnVXQ62l1WDn7dPwCW75kodVq1NISwbjvR7oysWqtOla2YuV47w6AbKwfxrMsVNDrqd+slY0Z+YmtWLLAajdIjCCT+mHuR+B7CFq5cqV9+umnbkkj9bqGDhFObQixAl0t2q1ANq11fUXzfDW3V/N8vfWCPWpVDLXzwP8TZa7E6tWr7Z577nHXr7vuunjvDoAcsGHtajeUr0TpMtah64lhQ+ZSGzZ352Vn2vRJf7jKW1prWXrrWb773BA3t61xq8PD7tu1a2fY/3fsPpB/IU9iZDjduH6tvf/SE+76yecm/nJ0AA6ufhivslAJ/kLtOrAEXZ4EyfZM/dAfEuNoQrb4999/3dDiyKzNvXr1ctmclY1ZCaaymuYOK0FW5BrAGkazdetWGzFihPv/nj17bNyPo6xQ/rxWq0JyK188qAVv1KhRbq7LihUrrGvXrm4tYwD+sWjerBSVK2UqfeiGS2zHtq128Q33WKHCWV8mvv/Co7Znz+4U617WqNPQdm7fZhPGfOf+v3fvHvvqr8WuTKxcvZbFu0z869ef3FzoDWtXWfP2Ha3H6efFdZ8AZH/9MF5l4Y7t2+y7KUuTysLff/jKChQslBBlIfVD/6DH18e0Dq/mbyh7X5UqVVxrldbaVVCqBFZpZUbOrKlTp7p1e/XaSpIQSnN+n376aevTp49b/kjZl+fOmGHXnNjYJXPJKfoMvPnJu3fvdksuKbuhl7BAPdWaj6xhQAD8Y/jbr9iEMd9anUbN3BqTm9avc4lONLdMSVu6npp6NtDM0vy3bz991617qSRaoXr26Wcj33/dHr/tamt9ZGc3pG/JwvWuTCxUuLDtt5wxc8qf9sw9N7jre/fsti2bNrrs115CK/XOXHH7g26YOAB/1w/jVRZ+9f7rds0r4+yYplVs1paT3ZrhZ1x8TbYE4LGWhS/u30H90Gf45nysd+/ebtiKglFlOVYG5xNOOMGuv/76dOfoZpaSXzVu3NgGDBiQ4r7KlSvbd999ZzfffLN9++23Vrp0aTvtgsvtpqM2W06aP3++u4h6vLUfSlLQoUMHt3ZxaMIvAP5xxLE9bOO61bZwzkybNeUvK1aylLU+qoudct6lbtmN7KCEL8qCelKflMkAFXwPfuE9G/rU/fb37z9bsRIl7IrujeymU1vYv5ZzVi5Z5C5SsHBhK1a8lEti1aBFGzv25DNdVlYAh0b9cFPp+vEpC597yz5+6CobO32FFSlZxnpfeIX1vepmsziWheXKlKF+6DN5At6CVEAcjJy0wFpPDg55mdz6QTul7WHx3iUA2WzElGXx3oWElHff7rDycH++xMjqnF16taoW710AkCDlcyKWf5RR/sMcXwAAAACArxH4AgAAAAB8jcAXAAAAAOBrBL4AAAAAAF8j8AUAAAAA+BqBLwAAAADA1wh8AQAAAAC+RuALAAAAAPA1Al8AAAAAgK8R+AIAAAAAfI3AFwAAAADgawS+AAAAAABfI/AFAAAAAPgagS8AAAAAwNcIfAEAAAAAvkbgCwAAAADwNQJfAAAAAICvEfgCAAAAAHyNwBcAAAAA4GsEvgAAAAAAXyPwBQAAAAD4GoEvAAAAAMDXCHwBAAAAAL5G4AsAAAAA8DUCXwAAAACArxH4AgAAAAB8LX+8dwAAABx6RkxZluHn9GpVLVv2BQDgf/T4AgAAAAB8jcAXAAAAAOBrBL4AAAAAAF8j8AUAAAAA+BqBLwAAAADA1wh8AQAAAAC+RuALAAAAAPA1Al8AAAAAgK8R+AIAAAAAfI3AFwAAAADgawS+AAAAAABfI/AFAAAAAPgagS8AAAAAwNcIfAEAAAAAvkbgCwAAAADwNQJfAAAAAICvEfgCAAAAAHwtf7x3AAAAAAASyYgpy9K8v1erajm2L8ga9PgCAAAAAHyNwBcAAAAA4GsEvgAAAAAAXyPwBQAAAAD4GoEvAAAAAMDXCHwBAAAAAL5G4AsAAAAA8DUCXwAAAACArxH4AgAAAAB8jcAXAAAAAOBrBL4AAAAAAF8j8AUAAAAA+BqBLwAAAADA1wh8AQAAAAC+RuALAAAAAPA1Al8AAAAAgK8R+AIAAAAAfI3AFwAAAADgawS+AAAAAABfI/AFAAAAAPgagS8AAAAAwNcIfAEAAAAAvkbgCwAAAADwNQJfAAAAAICvEfgCAAAAAHyNwBcAAAAA4GsEvgAAAAAAXyPwBQAAAAD4GoEvAAAAAMDXCHwBAAAAAL5G4AsAAAAA8DUCXwAAAACArxH4AgAAAAB8jcAXAAAAAOBrBL4AAAAAAF8j8AUAAAAA+BqBLwAAAADA1wh8AQAAAAC+RuALAAAAAPA1Al8AAAAAgK8R+AIAAAAAfI3AFwAAAADgawS+AAAAAABfI/AFAAAAAPgagS8AAAAAwNcIfAEAAAAAvkbgCwAAAADwNQJfAAAAAICvEfgCAAAAAHyNwBcAAAAA4GsEvgAAAAAAXyPwBQAAAAD4GoEvAAAAAMDXCHwBAAAAAL5G4AsAAAAA8DUCXwAAAACArxH4AgAAAAB8jcA3AezYscPuuecea9CggRUuXNiqVq1ql1xyiS1btixT29uwYYNdd911VqtWLStUqJD7e/3119vGjRtTPHbPnj32/fff24ABA6xZs2ZWtGhRK1KkiDVu3NhuvvlmW7NmTdTXmDRpkg0ePNiOOuooK126tBUsWNBq1Khh559/vk2bNs2y2/Tp0+2ss86yChUquP1t3ry5Pf3007Z///5MbW/cuHHWs2dPK1u2rBUvXtzat29vb7/9dqqf7+23327dunVzn60+M12aNm1qt9xyi61duzam11y3bp1VrFjR8uTJY/Xq1cvUfgPZXabUrl3bHaOpXWbNmpXqc7du3Wr33nuvtWjRwv2uSpUq5cqZVx6+03Zs33aQ7xKHqn379tnHH3/szlHHHHOMFStWzB2LF110Uaa29/PPP6d5jHfo0CHL3wP8L6vK4b1797r61kknnWR16tSxEiVKuO3Vr1/frr76alu0aFHU582ePdueeuop69u3r9WtWzfpeF64cGEWvUNkd91Uhg8fbieccILbpr531bVPO+00++2339J97ty5c91+6HtXnRVm+eO9A4e6nTt3WteuXe2PP/6wKlWqWK9evVyhNHToUPvqq6/c7SroYqWg68gjj7R58+a55/Xu3dv9EJ955hn75ptvbPz48S6484wdO9Z69OiRVME98cQTXTCsxz3xxBP23nvvuUpBw4YNwwrhdu3auevaloJfVTwmT57sHv/JJ5+4v2eeeaZlB+3bcccd504qClC137/88ovdcMMN9vvvv9tHH33kfuSx+uyzz6xPnz6uYFIlqnz58vbTTz9Zv379XBD/+OOPhz1eJ60hQ4a4965gV5/3li1b7K+//rLHHnvMvXcVSIcddliar3vTTTfFHCQD8SpTPPo9RKNgNpoFCxa436n+6vVUtuzatctVxr75eJidcck1VqRosQzvB6DyVmV2VlNw0KlTp6i3A/Eqh7UtNSCq8VCNiG3btrXdu3fblClT7KWXXnJ1DtVZvHqZR/ep7oeckdV1U9VJL7/8cnvzzTddHVtlkzqaFi9ebKNGjXLHQbTyKlT//v3deRfJCHzj7IEHHnAFoIIn9byqYJMnn3zSBUZqHVTgGSv17CroPf30092PLH/+4Fc8cOBAe+655+zGG2+0t956K+nxefPmtbPPPtu9ln6onk2bNrmKxXfffWcXX3yx+9GGOvzww+3OO++0k08+2fLly5f0I1Xr5oMPPuj2u0uXLi6IzEoKys877zxXsOgzUoHi9Sx1797dBd3quY215X/9+vVuX9WDoABYn5usWrXKFSgK/vUe9V48am1TkNu6dWv3+YWenFTIvPPOO/a///3PPv3001RfVyepYcOGuce/+uqrB/GJANlbpnhCy4306ESrQFcn6JdfftmuuOKKsPuf/fQnK1GyTIb3AZACBQrYBRdc4Cr6OhepMUXnqYOlMj8jxzmQE+WwevnUmH7EEUck1elE9Za77rrLNcRfeeWVrl4SSr2Nt956q/uN6LeiTg79VpD1srpuKvfdd58Lek855RRXLoV2WmnkYXodJ2+88YY7xqhnhssTCAQCEbchh6jFTkNdFWT+/fffLpAK1bJlS9fjqMJMLTvpWbFihVWvXt0VjKpwVqpUKawiqoBNgd7y5cvd66ZHj6tWrZq7rpZKDetNjw4nDZNW4aofamq9RJ6RkxZY68l3uuuTWz9op7RNu5dUw9sUkOuzUWtnKH2G+pw0lPKff/6xWDz66KPuxKDWWA0nCfXFF1+4QFiB78iRI2Pa3tKlS93nXKZMGfdZR6OCUSckDUPXa2oYlHoU1GABJFKZImq11lC6jJwqvN+VGoB0PdKIKZmbxuF3efftDisP9+crGO9dSji9WgXPSaE+/PBDN5xT55vMBK6qHB577LGZfj6Q3eVwajQCT0Of1fCu6WypjcCRRo0aubqZRuGoXE9NvMrn3Fj+eeVRVtdNVZdUvbBy5cpuOpGGK2eEOm9UF1eDxx133OHKN/VG//jjj3aoY45vHGleqQpGHdyRBaN4Q4VjDbq+/fZb1+t69NFHhwW9oiBLrUZqIdQQiVhoPormFHhBcCw0jENDcTLynIz4+uuv3d9ow6jbtGnjhg79+++/Mc9hSWt7mk+jllYVFDqpxNoTIZrznBoNWfrvv/9cT5j3eCARy5TMeu2119zfa6+9NltfBwAO5XJYdS6NutPftOodyF5ZXTfViEA1oFx22WUZDnpFeX7UyfLiiy9m+Ll+x1DnOJo6dWrSjyIa7/ZYk0XFsj0Nm4h1e2o91HAKUatTrBTUZfQ5sYrlPer19R7TatGMZXs6iaiFTq2yc+bMSQro0xrqogQUXtAcjfZLw6c1LE8NFCSZQCKXKaE0f33+/PmuEU1z25Vcw2sYC7VkyRI3ekGjTzT6QZXAL7/80lUENe/9jDPOMLOMn8iB7KZEMEpcqMSDmqajoc9KKhM6pQWIZzkcSqNwHnnkEdu2bZubT5yZAAmJWTcdPXq0+6scOhrNqXncOq+qR1+9txq2ntp8YXVuaaqjhkorcap6j5GMwDeONBxZVEGMxrs9tYx92b29F154wQ2j0bDc9BI1eTQPRRmfFTSqwpDVsvI9bt682VXG09ueAl9tL1rge+mll7pedDUQ6H0r8VXHjh2jDu9Ub7xa75ScINr9wMHK6jIglDKWh9IcJuUN0Fy1UDNmzEgaMXLNNdekaHHWnLTzr73del8YPu8XiDflsojMZ6Hzn/I/KIMuEO9yWFNINIxV9RcFUWqM1JDW119//SD3Gon0nXvnUf1VY7FXVxXVH5V3RtPxVJ8MpUYQZfpWQlodK0iJZsw40qR30VI40SiLm5fBMqe3pwzNSs4galGMhQpirxKsSrEyGWa1rHyP3rYOZnsajqKLerQU9Kowevfdd61cuXIpHqsgYeLEia7nLNr9QKKVKXLqqafa559/7k7Y27dvd8O1lCRPeQPUkDNixIiwx3ujRDSvScP5NQpCvcBqtfbKkreeut/++vWnTL9PICupF0Xz0ZWMSL29uigBoZYx0pw8JacJrXgCOV0Oe9QIozqHgh4FvWqQV+9erJ0TyB3fuXce1blW37HOp6pja+qdvmvlJVDG50hqWNa5Wudehr5HR+CLFNSaqKROmteqLNHKzpoe9Xoqo52Giik7tIZYHArUI67hRprPrKx9GlKiHgJlw45sDVSB1Llz50yvNQnEw7PPPuuGNdesWdMNpdMwZw3X11IZOvYjW5W99Qr121A250GDBrnWbk19UK+xl+3y0zeei8v7ASJpHqZ6UZQ1V5lTddHQUY1g8qakMFcOiUDDXVXurlmzxuV1UZ4QJU5SMAz/8M6jSpSqpUhVRimJmRJUqaNFw5y1coim4Xk0OlHn6wsvvDBsJRKEI/CNIy+9vXpRotGQBdHBnlPbU2uUUq7rRK9FuFXBjcVVV13l1qbT8ApN8s+ulqas/My8bWXF9tS7raQGao1TgaTg1nuuaMinEhWoFQ7ILWVKWjTMX5lLlSU0dK566O8q2hIz3m1z/p1su3fFljQOiAclDfIadiIbM4F4lsOag655nhqZoEZF1cE0sgb+qs+rHu71FnuUe0ZLVInWCfYamtUDrKHPjz/++EG8E/8j8I0j9aBIahPPvdtjWUYoK7anHl4Na9SQCg3t0pDdWJJ63HbbbS6LqxLZ/PDDD1m+dm92fWYlS5ZMSv2fVd+BHqcegpUrV9qECROSblejgIbAaK09tcR5l3POOcfd7w2T1kXPBRKhTEmLygZlLRUNY/aEbjtaEg/vtv379tnWTRsPej+A7OTN7Q09xoFEKYdVh9GKHcrgq/oX/PGde49LLRGWd/vq1auTtq9llNTppGA5tJ6pkZuiPDRdDtx2KCO5VRxpvS9RoBmNd3t62YSzYntqLdIaZJo3oCxymtMXS6+thodp3p56flToKvjNTnqPyp6n96Ke6az4zNRipuc1adIkRZZmzWfUkkZaazdWXuCvoUiRWbLHjh2baqODd1+sSycB2V2mxDoPKbRFWmtF6jej41j3R2Z+Dl3funDR8JZsINFEO8aBRCqHU6tzIOdkdd1UQ5sVyHrlTyTvPBo6wkrUcZJa50laddBDCT2+caTsv2qtU4KCyAWvReP3Ra15sfCWXfj111+TWoE8SkSjNeM0dCvyR6n5Ihp+qHkDrVq1ckOVYznJq5dXw8A0tELDwDTMObt5ywR5n01kQi6li9cwkFjSxae3PfXSqvLerVs3V5GPheY6a16YeL1h3mcc7aKF5L3HerfFuu9AdpcpaZk+fbob5qyRDAp2PVruSEPwRA1pkbwTb6Xqtaxo8YMfcg1kJyUTSmuZEiCe5XBomRpa50DOyuq6qUZfSrRAVYm0vEDaWyda202tnjlmzBj3GM0PDhy47VBG4BtH6lEdMGBA0hzQ0DmhTz75pEtVr2RISlwQ6vnnn3cVTa03GDnPtG/fvm4uqdKZqxfXo6Qyag08//zzXe9sKA2D0LBmbfP7779PkR49Gv24NWxXrU1aM0wBc05Qkh1ltFPL2lNPPZV0uz47fYZy0003pXiefvB6f3/++WfY7cpKqyHPykyrXm6PGg685Vsit/fhhx+6TJ/RWuD69+/vCjgluIr83oDcVqbot+2tJxhK29FwKp1A9RuKHB3i/Xbuv//+sOQbaui5++673fUTzjw/S94zEKvUzgNPP/10ivmROrZfeeUVd55R3gbNoQTiUQ6rMyJymS1vPumdd97pgiPN882OJSQRn7qpGkW0TJW+99DEeupcUaZn1TcVSGutcWQMQ53jTJl+lRBJB7fmEml+qFKRa36ohgi++eabKZ6zdu1a19MSbc6RTuBakkGt1PoxtWvXzvXMaMiutq9CN5QCPmWBEw1T1pIOqc3j9Xp1FBQqg7OyzumHrsqBLpF69+7tLllJGQwVpKsXVj9+pfHXXAj1cuvzUIKpfv36pXieWl695VhCKXunPuOzzz7bPVdzH7TUkL4TDQvRa0TOh1AmRTUw1KlTxwW46vHSHF21wKklrlq1am6/UltcHMgtZYpOxvfee6/7jWkol451NezoWFfDmn4bQ4YMSbE9TZe45557XHZ3tUirB0SjTcaNG+cS6LXpeKyden7/bP0c4G9q3PV6PbT8kBcgaAkij86FsZwHdN68+eabXa+uzmka6aPGTTXUaBSVzpE0ZCJe5bCWQVQ5rLqFOhnUm6zhrOpNVgCk/3/88ccphr3q96HficdbQ1ZBmkbmiBoudUFi1U11vnz//fddA4kC51dffdXq1auX1Huseqrup56ZcQS+caYhtBqG8PDDD7uDePjw4S4YU1Zg9Zakthh2WnM9VFnV2pnaltZ6q1Spkg0cONAVnJG9uaHzB9JKjKD98QJf/UDVqyyqHETr/fSGXmR14OtVqnUi0DIpGkqpFjYN8VHQft1112W4INDi4Jrnq3WLVVHSe9N8X7XYRiuodJLQUHBV4nVRgKwTjlrf1EqnQspLmgXk5jJFQ5bVE6bfm451rWWqERJqZVbjl6ZI6AQdjcobBcteY5wCZU2H0G+qZqfTUn0eEIsZM2aEJRD0AgddMko9MRrtpEZibVf5HTSCSiOkdO70MqgC8SiHtbykGgwVRKksVrCrpeUUCGnJuGuvvdYdr5G07mvkb0RCh1/TS5y4dVM1cui7Un1e5ZPKJtXnVQdVw0pWJEc7FOUJHOqDvRFXIyctsNaT73TXJ7d+0E5pyyLsgN+NmLIs3ruQkPLu2x1WHu7Plz3LwuVmvVpVi/cuAL4Wr/I5N5Z/lEe5D3N8AQAAAAC+RuALAAAAAPA1Al8AAAAAgK8R+AIAAAAAfI3AFwAAAADgawS+AAAAAABfI/AFAAAAAPgagS8AAAAAwNcIfAEAAAAAvkbgCwAAAADwtfzx3gEc2vbnLWCTWz+YdB0ADlWUhwAOVZR/yAkEvoivPHlsf76C8d4LAIg/ykMAhyrKP+QAhjoDAAAAAHyNwBcAAAAA4GsEvgAAAAAAXyPwBQAAAAD4GoEvAAAAAMDXCHwBAAAAAL5G4AsAAAAA8DUCXwAAAACArxH4AgAAAAB8jcAXAAAAAOBr+eO9Azi0bVq/LuKWanHaEwCJXz7gUFCqbLl47wKAAyiHKZP8hMAXcdXvuJZh/78wEIjbvgBI7PIBh4bhk5fGexcAHEA5TJnkJwx1BgAAAAD4GoEvAAAAAMDXCHwBAAAAAL7GHF/E1bCfpsZ7FwAkKMoHAIgvymH4CYEv4opMeQBSQ/kAAPFFOQw/YagzAAAAAMDXCHwBAAAAAL5G4AsAAAAA8DUCXwAAAACArxH4AgAAAAB8LUeyOgcCAdu9e3dOvBRymX17wo+LXbt2xW1fkNgKFixoefLkMT841MvEyN89ECvOEckoE5EdKJ9jR3mU+8rFPAGVNjlwYAwZMiS7XwaAj912221WqFAh8wPKRAAHizIRADJWLuZI4EtL3qFt5cqV9tZbb9lFF11klStXjvfuIJceG/Ru+AvlQnR8LtHxuaREmZj9OO4SE99L4lmZIN9JeuVijgx11g74pVUSmTsIvb8cBwh1qB4blImH7nefHj6X6Phc/C1Ry0SOu8TE95J4CuaS74TkVgAAAAAAXyPwRbYrXry4de7c2f0FQnFsHLr47qPjc4mOzwXxwHGXmPheEk/xXPKd5MgcXwAAAAAA4oUeXwAAAACArxH4AgAAAAB8jcAXAAAAAOBrBL4AAAAAAF8j8EWmTJw40Xr27GmlS5e2YsWKWYcOHezjjz/O0DZ27dpl9913n9WvX98KFy5sVatWtf79+9vq1auzbb+R+MeGFkDXmo6pXX7++eds3X9kHt99Su+++65dccUV1q5dO7e2od6H3mdG7d+/35577jlr3ry5FSlSxCpUqGB9+/a1//77zw7Fz0THQlrHSmY+YxwaqL8kJs4fieVdn5678sflVZGrjRkzxnr06OEK+3POOcdKlChhn332mfXp08eWLFliN910U0w/hF69etl3333nCrczzjjD5s6da6+//rr99NNP9scff7gfBw69Y8Oj46NVq1Ypbq9du3YW7zWyAt99dHfddZctWrTIypcvb1WqVHHXM0MVEJWPTZs2tYEDB9ry5ctdpfD777935aUq4IfaZyJaPqNLly4pbo92/ADUXxIT54/Ec5dfz11azgiI1Z49ewJ169YNFCpUKDB58uSk2zdu3Bho0KBBoGDBgoGFCxemu50333xTy2gF+vbtG9i/f3/S7S+99JK7vX///tn2HpDYx8bQoUPdMaC/yB347lP3ww8/JL33hx9+OFPvb/To0e55xxxzTGDXrl1Jt48aNcrd3r1798Ch9pmMGTPGPW/QoEHZtJfwG+oviYnzR2L6wafnLoY6I0NGjx5t8+fPt3PPPTesRa1UqVJ2xx132O7du23YsGHpbue1115zfx9++GE3fCK0ZahOnTr23nvv2Y4dO7LpXSCRjw3kPnz3qevWrZvVqlXroLbhlZf333+/FSxYMOn2E0880fV2quV88eLFdih9JkBGUX9JTJw/ElM3n567GOqMDPHmSHTv3j3FfRqmImPHjk1zGzt37rQJEyZYw4YNU/yodBI5/vjj7ZVXXrG//vrLjj766CzdfyT2sRFq8uTJtm7dOtu7d68boqRCuFy5clm4x8gqfPfZ//lqzlvHjh2jfr66X5/vBRdcYIcaDTF9+umnXaBRvXp169q1q1WrVi3eu4UERP0lMXH+8K+fE/DcReCLDFcyJNqY/MqVK1vx4sWTHpMatexpjkxq4/q927UdThyH1rER6tlnnw37v5IiDBo0yG699dYs2FtkJb777LNt2zZbsWKFNWvWzPLly5dmeXkoev/9993Fkz9/frv22mvtsccei/p54dBF/SUxcf7wp20Jeu5iqDMyZNOmTUlDUKIpWbJk0mMOZhuhj8Ohc2zIYYcd5jIAzpkzx7Zv325Lly61t99+28qWLWu33Xabuw+Jhe8++1BeRqfkQUOGDLF///3Xtm7daqtWrbLhw4dbvXr17KmnnrJbbrkl3ruIBEP9JTFx/vCnTQn6WyHwBZBQlKV1wIABrjVQLbUatqhhMMqgqYyPgwcPdkOY4D9894iVMoSqB0d/NZSuYsWKLpurssMqKFavD0vLAIcOzh+IBYEvMsRruUmthWbz5s2ptu5kZBuhj8Ohc2ykRRXcTp062fr1623mzJmZ3g6yHt999qG8zBgNjVQArAqu5mICHuoviYnzhz+VStDfCoEvMiStMfkrV650Q87SW5NLWQ/z5s2b6rj+tOZ7wN/HRnq0npw3dwSJg+8++6g3U2soLliwwPbt25fifsrLlA7VYwVpo/6SmDh/+FOxBD13Efgiw0NJRCnII2k4SehjUqMhKO3bt7fZs2enWBA7EAjYDz/84H4w7dq1y9J9R+IfG2lRwalMmcJSKImF7z576bNThW3cuHGpfr7HHHNMHPYsMXk9vcroCniovyQmzh/+1TkRz105vnIwcv1C43Xq1ElzofEFCxYk3b58+fLAzJkz3f2hWADef7Lq2Pjrr79SbHvv3r2Bm2++2R0bxx57bDa/E2QU331sHn74Yfc+hg4dGvX+NWvWuM9Ff0ONHj3aPe+YY44J7Nq1K+n2UaNGudu7d+8eONQ+k2jHijz99NNue/Xr13fHDuCh/pKYOH8kvod9dO4i8EWG6UAuUKBAoESJEoHLL788cOONNwZq1arlDuLHH3887LH9+vWL+mPZt29foEePHu6+Dh06BG699dbAGWecEciTJ0/gsMMOC6xevTqH3xUS5djQbS1atAicf/757rjQdnTy0+3Vq1cPzJ8/P4ffFWLBdx/da6+95t6vLm3atHHvpWPHjkm36X7PoEGD3P36G+myyy5z9zVt2jRwyy23BC644AJXISxbtmxg9uzZgUPtM9GxVa9evcA555zjKrZXXXVVoHXr1u6xpUuXDkyYMCEO7wyJjvpLYuL8kXhe8+m5i8AXmaJKxQknnBAoWbJkoEiRIoH27dsHPvzwwxSPS62Akp07dwYGDx4cqFu3rvsRVK5c2f1AVq5cmUPvAol4bNx0002ucK1UqZI7ERYrVizQsmXLwF133RVYv359Dr4TZBTffSDV95raRffHUnlQZfuZZ55xlQf1jJQrVy7Qp0+fwLx58wKH4mcyZMgQ14NTtWpV93noeGvUqFHg+uuvDyxZsiQO7wq5BfWXxMT5I7H08+m5K4/+ydnB1QAAAAAA5BySWwEAAAAAfI3AFwAAAADgawS+AAAAAABfI/AFAAAAAPgagS8AAAAAwNcIfAEAAAAAvkbgCwAAAADwNQJfAAAAAICvEfgCAAAAAHyNwBcAAAAA4GsEvgAAAAAAXyPwBQAAAAD4GoEvAAAAAMD87P9FkPUWJTvc6wAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import arviz as az\n", + "import matplotlib.pyplot as plt\n", + "idata = bc.to_arviz(mcmc)\n", + "\n", + "az.plot_posterior(\n", + " idata, \n", + " var_names=top_parameters_sa, \n", + " kind='hist', \n", + " figsize=(10, 6), \n", + " ref_val=[ref_val[param] for param in top_parameters_sa]\n", + ")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "is_executing": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[NbConvertApp] Converting notebook patient_calibration_case_study.ipynb to html\n", + "[NbConvertApp] Writing 767712 bytes to results_waves_5_sa_params_3.html\n" + ] + } + ], + "source": [ + "output_name = f\"results_waves_{n_waves}_sa_params_{n_parameters}.html\"\n", + "\n", + "!jupyter nbconvert --to html patient_calibration_case_study.ipynb --output {output_name}" + ] + } + ], + "metadata": { + "jupyter": { + "tags": [ + "skip-execution" + ] + }, + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/case_studies/blood_pressure/pyproject.toml b/case_studies/patient_calibration/pyproject.toml similarity index 71% rename from case_studies/blood_pressure/pyproject.toml rename to case_studies/patient_calibration/pyproject.toml index 678f02898..79ee73fb4 100644 --- a/case_studies/blood_pressure/pyproject.toml +++ b/case_studies/patient_calibration/pyproject.toml @@ -1,7 +1,7 @@ [project] -name = "blood_pressure" +name = "patient_calibration" version = "0.1.0" -description = "Blood pressure AutoEmulate case study with ModularCirc" +description = "Patient-specific calibration in cardiovascular modeling with AutoEmulate" requires-python = ">=3.10,<3.13" dependencies = [ "autoemulate", diff --git a/docs/tutorials/index.md b/docs/tutorials/index.md index 20b3c2b9f..461bfcbf6 100644 --- a/docs/tutorials/index.md +++ b/docs/tutorials/index.md @@ -4,4 +4,4 @@ These are in-depth workflows which cover all aspects of `AutoEmulate`. These tutorials are all Jupyter notebooks which can be [run in a local interactive session](../getting-started/installation.md#interactive-tutorials). - \ No newline at end of file +We also have [case studies](https://github.com/alan-turing-institute/autoemulate/tree/main/case_studies) in the GitHub repository, which demonstrate `AutoEmulate` applied to complex simulations and real-world use cases. \ No newline at end of file diff --git a/docs/tutorials/simulator/03_history_matching.ipynb b/docs/tutorials/simulator/03_history_matching.ipynb index b48885334..7bb2e07e0 100644 --- a/docs/tutorials/simulator/03_history_matching.ipynb +++ b/docs/tutorials/simulator/03_history_matching.ipynb @@ -6,6 +6,8 @@ "metadata": {}, "outputs": [], "source": [ + "import matplotlib.pyplot as plt\n", + "\n", "from autoemulate.emulators import GaussianProcess\n", "from autoemulate.core.compare import AutoEmulate\n", "from autoemulate.simulations.epidemic import Epidemic\n", @@ -33,14 +35,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The `HistoryMatching` calibration method can be a useful way to iteratively decide which simulations to run to generate data refine the emulator on. The `HistoryMatchingWorkflow` implements this iterative sample-predict-refit workflow. Each time it is run:\n", + "The `HistoryMatching` calibration method can be a useful way to iteratively decide which simulations to run to generate data to refine the emulator on. The `HistoryMatchingWorkflow` implements this iterative sample-predict-refit workflow. Each time it is run:\n", "- parameters are sampled from the not ruled out yet (NROY) space\n", "- an emulator is used in combination with `HistoryMatching` to score the implausability of the samples\n", "- simulations are run for a subset of the NROY samples\n", - "- the emulator is refit given the newly simulated data\n", - "\n", + "- the emulator is refit given the newly and previously simulated data\n", "\n", - "In this tutorial, we demonstrate how to implement this simulator in the loop workflow.\n" + "In this tutorial, we demonstrate how to use this simulator in the loop workflow.\n" ] }, { @@ -58,11 +59,34 @@ "metadata": {}, "outputs": [], "source": [ - "simulator = Epidemic(log_level=\"error\")\n", - "x = simulator.sample_inputs(500, random_seed=random_seed)\n", + "simulator = Epidemic()\n", + "x = simulator.sample_inputs(100, random_seed=random_seed)\n", "y, _ = simulator.forward_batch(x)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below we plot the simulated data. The peak infection rate is higher when the transmission rate increases and the recovery rate decreases and the two parameters are correlated with each other." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "transmission_rate = x[:, 0]\n", + "recovery_rate = x[:, 1]\n", + "\n", + "plt.scatter(transmission_rate, recovery_rate, c=y, cmap='viridis')\n", + "plt.xlabel('Transmission rate (beta)')\n", + "plt.ylabel('Recovery rate (gamma)')\n", + "plt.colorbar(label=\"Peak infection rate\")\n", + "plt.show" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -108,7 +132,7 @@ "metadata": {}, "outputs": [], "source": [ - "model = ae.best_result().model" + "best_result = ae.best_result()" ] }, { @@ -126,14 +150,16 @@ "metadata": {}, "outputs": [], "source": [ - "observations = {\"infection_rate\": (0.3, 0.05)}" + "observations = {\"infection_rate\": (0.15, 0.05**2)}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We also pass the fitted emulator and the simulator to the `HistoryMatchingWorkflow`." + "In addition to the observations, we pass the fitted emulator and the simulator to the `HistoryMatchingWorkflow` object at initialisation. \n", + "\n", + "Other options inputs include the history matching parameters (e.g., implausability threshold) and the original training data used to fit the emulator, which can then be used in refitting the emulator in combination with the newly simulated data." ] }, { @@ -144,12 +170,13 @@ "source": [ "hmw = HistoryMatchingWorkflow(\n", " simulator=simulator,\n", - " emulator=model,\n", + " result=best_result,\n", " observations=observations,\n", + " # optional parameters\n", " threshold=3.0,\n", + " random_seed=random_seed,\n", " train_x=x,\n", - " train_y=y, \n", - " random_seed=random_seed\n", + " train_y=y\n", ")\n" ] }, @@ -157,13 +184,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The `run` method implements the iterative sample-predict-refit workflow:\n", + "The `run` method implements the sample-predict-refit workflow:\n", "- sample `n_test_samples` to test from the not ruled out yet (NROY) space\n", "- use emulator to filter out implausible samples and update the NROY space\n", "- run `n_simulations` predictions for the sampled parameters using the simulator\n", - "- refit the emulator using the simulated data\n", + "- refit the emulator using the newly simulated data (unless `refit_emulator` is set to False)\n", "\n", - "The `HistoryMatchingWorkflow` object maintains and updates the internal state each time `run()` is called so the full workflow can be run over a number of iterations." + "The `HistoryMatchingWorkflow` object maintains and updates the internal state each time `run()` is called, including saving the newly simulated data. This means the full workflow can be run over a number of iterations by calling `run` repeatedly. At the end of each run the emulator is refit on all data simulated so far (unless `refit_on_all_data` is set to False). \n", + "\n", + "Alternatively, one can use the `run_waves` method to run multiple waves of the history matching workflow in one go." ] }, { @@ -172,16 +201,39 @@ "metadata": {}, "outputs": [], "source": [ - "test_parameters, impl_scores = hmw.run(n_simulations=20, n_test_samples=100)" + "_ = hmw.run_waves(n_waves=1, n_simulations=50, n_test_samples=1000)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## 3. Visualise results\n", + "## 3. Visualise results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `plot_wave` method plots the NROY samples and their implausability scores. There is also an associated `plot_run` method which takes in as input the outputs of the `run` method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "hmw.plot_wave(0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Interactive dashboard\n", "\n", - "For visualising results, you can use the `HistoryMatchingDashboard` which implements a number of interactive plots. To initialize it just pass in outputs of the `run()` method and information about the simulation." + " `HistoryMatchingDashboard` implements a number of interactive plots for results exploration. To initialize it just pass in information about the simulation and results for the history matching wave to plot. These are either the outputs returned by the `run()` or `get_wave_results` method." ] }, { @@ -190,6 +242,8 @@ "metadata": {}, "outputs": [], "source": [ + "test_parameters, impl_scores = hmw.get_wave_results(0)\n", + "\n", "dashboard = HistoryMatchingDashboard(\n", " samples=test_parameters,\n", " impl_scores=impl_scores,\n", @@ -224,7 +278,7 @@ ], "metadata": { "kernelspec": { - "display_name": "autoemulate", + "display_name": ".venv", "language": "python", "name": "python3" }, diff --git a/docs/tutorials/tasks/02_history_matching.ipynb b/docs/tutorials/tasks/02_history_matching.ipynb index a1b6ea027..31c53d7e7 100644 --- a/docs/tutorials/tasks/02_history_matching.ipynb +++ b/docs/tutorials/tasks/02_history_matching.ipynb @@ -6,6 +6,10 @@ "metadata": {}, "outputs": [], "source": [ + "import torch\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", "from autoemulate.emulators import GaussianProcess\n", "from autoemulate.core.compare import AutoEmulate\n", "from autoemulate.simulations.projectile import Projectile\n", @@ -47,16 +51,29 @@ "metadata": {}, "outputs": [], "source": [ - "simulator = Projectile(log_level=\"error\")\n", + "simulator = Projectile(log_level=\"error\", parameters_range={'c': (-5.0, 1.0), 'v0': (0.0, 10)})\n", "x = simulator.sample_inputs(1000)\n", "y, _ = simulator.forward_batch(x)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.scatter(x[:, 0], x[:, 1], c=y, cmap='viridis')\n", + "plt.xlabel('Drag coefficient')\n", + "plt.ylabel('Initial velocity')\n", + "plt.colorbar(label=\"Distance\")\n", + "plt.show" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Since we need an uncertainty aware emulator, we restrict AutoEmulate to only train a Gaussian Process." + "Since we need an uncertainty aware emulator, we restrict AutoEmulate to only train a Gaussian Process. For the purposes of this tutorial, we use default parameters." ] }, { @@ -65,7 +82,7 @@ "metadata": {}, "outputs": [], "source": [ - "ae = AutoEmulate(x, y, models=[GaussianProcess], log_level=\"error\")" + "ae = AutoEmulate(x, y, models=[GaussianProcess], model_params={}, log_level=\"error\")" ] }, { @@ -102,6 +119,28 @@ "To instantiate the `HistoryMatching` object, we need an observed mean and, optionally, variance for each simulator output. " ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "true_drag = -2.0\n", + "true_velocity = 7.0\n", + "distance = simulator.forward(torch.tensor([[true_drag, true_velocity]]))\n", + "stdev = distance.item() * 0.05\n", + "observation = {\"distance\": (distance.item(), stdev**2)}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "distance" + ] + }, { "cell_type": "code", "execution_count": null, @@ -109,7 +148,7 @@ "outputs": [], "source": [ "# observed data: (mean, variance)\n", - "hm = HistoryMatching(observations={\"distance\": (2500, 100)})" + "hm = HistoryMatching(observations=observation)" ] }, { @@ -125,7 +164,7 @@ "metadata": {}, "outputs": [], "source": [ - "x_new = simulator.sample_inputs(10)\n", + "x_new = simulator.sample_inputs(1000)\n", "mean, variance = model.predict_mean_and_variance(x_new)" ] }, @@ -143,7 +182,9 @@ "outputs": [], "source": [ "implausability = hm.calculate_implausibility(mean, variance)\n", - "implausability" + "\n", + "# first 10 implausability scores\n", + "implausability[:10]" ] }, { @@ -159,7 +200,36 @@ "metadata": {}, "outputs": [], "source": [ - "hm.get_nroy(implausability, x_new)" + "nroy_params = hm.get_nroy(implausability, x_new)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below we plot the NROY parameters against the true parameters used to generate the observed data. History matching has successfully ruled out a portion of the input space." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(1, 2, figsize=(10, 4))\n", + "\n", + "ax[0].boxplot(nroy_params[:, 0], vert=True, patch_artist=True, boxprops=dict(facecolor='lightblue'))\n", + "ax[0].axhline(true_drag, color=\"k\", linestyle=\"--\", label=\"True drag\")\n", + "ax[0].set_ylabel(\"Drag coefficient\")\n", + "ax[0].legend()\n", + "\n", + "ax[1].boxplot(nroy_params[:, 1], vert=True, patch_artist=True, boxprops=dict(facecolor='lightgreen'))\n", + "ax[1].axhline(true_velocity, color=\"k\", linestyle=\"--\", label=\"True initial velocity\")\n", + "ax[1].legend()\n", + "ax[1].set_ylabel(\"Initial velocity\")\n", + "\n", + "plt.suptitle(\"Box plot of NROY parameters after history matching\")\n", + "plt.show()" ] } ], diff --git a/docs/tutorials/tasks/03_bayes_calibration.ipynb b/docs/tutorials/tasks/03_bayes_calibration.ipynb index 328947a55..21f5a87bc 100644 --- a/docs/tutorials/tasks/03_bayes_calibration.ipynb +++ b/docs/tutorials/tasks/03_bayes_calibration.ipynb @@ -123,6 +123,36 @@ "observations = {\"infection_rate\": observed_infection_rates}" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "true_infection_rate, 0.05**2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "metadata": {}, diff --git a/tests/calibration/test_history_matching.py b/tests/calibration/test_history_matching.py index f611ffe16..ccb744fab 100644 --- a/tests/calibration/test_history_matching.py +++ b/tests/calibration/test_history_matching.py @@ -4,9 +4,10 @@ HistoryMatching, HistoryMatchingWorkflow, ) +from autoemulate.core.compare import AutoEmulate from autoemulate.core.device import SUPPORTED_DEVICES, check_torch_device_is_available from autoemulate.core.types import TensorLike -from autoemulate.emulators.gaussian_process.exact import GaussianProcess +from autoemulate.emulators import TransformedEmulator from autoemulate.simulations.epidemic import Epidemic from tests.simulations.test_base_simulator import MockSimulator @@ -103,14 +104,14 @@ def test_run(device): assert isinstance(y, TensorLike) # Run history matching - gp = GaussianProcess(x, y, device=device) - gp.fit(x, y) + ae = AutoEmulate(x, y, models=["GaussianProcess"], model_params={}) + res = ae.best_result() observations = {"infection_rate": (0.3, 0.05)} hm = HistoryMatchingWorkflow( simulator=simulator, - emulator=gp, + result=res, observations=observations, threshold=3.0, model_discrepancy=0.1, @@ -118,15 +119,29 @@ def test_run(device): device=device, ) + # no NROY samples are stored before run() is called + assert hm.nroy_samples is None + # call run first time - hm.run(n_simulations=5) + hm.run(n_simulations=5, n_test_samples=1000) # Check basic structure of results assert isinstance(hm.train_x, TensorLike) - assert isinstance(hm.emulator, GaussianProcess) + assert isinstance(hm.emulator, TransformedEmulator) assert len(hm.train_x) == 5 + # should have access to NROY samples now that can sample from + # n can be less or more than number of NROY samples + assert hm.nroy_samples is not None + assert hm.nroy_samples.shape[0] == 1000 + + new_samples = hm.cloud_sample(482) + assert new_samples.shape[0] == 482 + + new_samples = hm.cloud_sample(10053) + assert new_samples.shape[0] == 10053 + # can run again hm.run(n_simulations=5) @@ -135,27 +150,27 @@ def test_run(device): def test_run_max_tries(): - """Run history matching with observations that return no NROY params.""" + """Run HM with observations that return no NROY params to trigger warning.""" simulator = Epidemic() x = simulator.sample_inputs(10) y, _ = simulator.forward_batch(x) assert isinstance(y, TensorLike) # Run history matching - gp = GaussianProcess(x, y) - gp.fit(x, y) + ae = AutoEmulate(x, y, models=["GaussianProcess"], model_params={}) + res = ae.best_result() # Extreme values outside the range of what the simulator returns observations = {"infection_rate": (100.0, 1.0)} hm = HistoryMatchingWorkflow( simulator=simulator, - emulator=gp, + result=res, observations=observations, threshold=3.0, model_discrepancy=0.1, rank=1, ) - with pytest.raises(RuntimeError): + with pytest.raises(Warning): hm.run(n_simulations=5)