autoemulate 0.3.1__tar.gz → 0.3.3__tar.gz

{autoemulate-0.3.1 → autoemulate-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: autoemulate
-Version: 0.3.1
+Version: 0.3.3
 Summary: A python package for semi-automated emulation
 License: MIT
 Author: AutoEmulate contributors (see our GitHub page)
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: docs
 Requires-Dist: anytree (>=2.12.1,<3.0.0)
+Requires-Dist: corner (>=2.2.3,<3.0.0)
 Requires-Dist: gpytorch (>=1.12,<2.0)
 Requires-Dist: iprogress (>=0.4,<0.5)
 Requires-Dist: ipywidgets (>=8.1.2,<9.0.0)
@@ -21,6 +22,7 @@ Requires-Dist: matplotlib (>=3.7.2,<4.0.0)
 Requires-Dist: mogp-emulator (>=0.7.2,<0.8.0)
 Requires-Dist: numpy (>=1.24,<2.0)
 Requires-Dist: pandas (>=2.1,<3.0)
+Requires-Dist: pyro-ppl (>=1.9.1,<2.0.0)
 Requires-Dist: salib (>=1.5.1,<2.0.0)
 Requires-Dist: scikit-learn (>=1.3.0,<1.6.0)
 Requires-Dist: scipy (>=1.11.3,<2.0.0)

{autoemulate-0.3.1 → autoemulate-0.3.3}/autoemulate/experimental/emulators/base.py

@@ -1,7 +1,9 @@
+import random
 from abc import ABC, abstractmethod
 from typing import ClassVar
 
 import numpy as np
+import torch
 from sklearn.base import BaseEstimator
 from torch import nn, optim
 
@@ -88,6 +90,25 @@ class Emulator(ABC, ValidationMixin, ConversionMixin, TorchDeviceMixin):
         )
         raise NotImplementedError(msg)
 
+    @staticmethod
+    def set_random_seed(seed: int, deterministic: bool = False):
+        """Set random seed for Python, NumPy and PyTorch.
+
+        Parameters
+        ----------
+        seed : int
+            The random seed to use.
+        deterministic : bool
+            Use "deterministic" algorithms in PyTorch.
+        """
+        random.seed(seed)
+        np.random.seed(seed)
+        torch.manual_seed(seed)
+        torch.cuda.manual_seed(seed)
+        if deterministic:
+            torch.backends.cudnn.benchmark = False
+            torch.use_deterministic_algorithms(True)
+
 
 class PyTorchBackend(nn.Module, Emulator, Preprocessor):
     """

{autoemulate-0.3.1 → autoemulate-0.3.3}/autoemulate/experimental/emulators/gaussian_process/exact.py

@@ -31,7 +31,6 @@ from autoemulate.experimental.emulators.gaussian_process import (
     MeanModuleFn,
 )
 from autoemulate.experimental.types import DeviceLike, OutputLike, TensorLike
-from autoemulate.utils import set_random_seed
 
 
 class GaussianProcessExact(Emulator, gpytorch.models.ExactGP, Preprocessor):
@@ -53,16 +52,15 @@ class GaussianProcessExact(Emulator, gpytorch.models.ExactGP, Preprocessor):
         mean_module_fn: MeanModuleFn = constant_mean,
         covar_module_fn: CovarModuleFn = rbf,
         preprocessor_cls: type[Preprocessor] | None = None,
-        random_state: int | None = None,
+        random_seed: int | None = None,
         epochs: int = 50,
         batch_size: int = 16,
         activation: type[nn.Module] = nn.ReLU,
         lr: float = 2e-1,
         device: DeviceLike | None = None,
     ):
-        # Init random state
-        if random_state is not None:
-            set_random_seed(random_state)
+        if random_seed is not None:
+            self.set_random_seed(random_seed)
 
         # Init device
         TorchDeviceMixin.__init__(self, device=device)

{autoemulate-0.3.1 → autoemulate-0.3.3}/autoemulate/experimental/emulators/lightgbm.py

@@ -34,13 +34,15 @@ class LightGBM(Emulator):
         colsample_bytree: float = 1.0,
         reg_alpha: float = 0.0,
         reg_lambda: float = 0.0,
-        random_state: int | None = None,
+        random_seed: int | None = None,
         n_jobs: int | None = 1,
         importance_type: str = "split",
         verbose: int = -1,
         device: DeviceLike = "cpu",
     ):
         """Initializes a LightGBM object."""
+        if random_seed is not None:
+            self.set_random_seed(random_seed)
         _, _ = x, y  # ignore unused arguments
         TorchDeviceMixin.__init__(self, device=device)
         self.boosting_type = boosting_type
@@ -58,7 +60,7 @@ class LightGBM(Emulator):
         self.colsample_bytree = colsample_bytree
         self.reg_alpha = reg_alpha
         self.reg_lambda = reg_lambda
-        self.random_state = random_state
+        self.random_seed = random_seed
         self.n_jobs = n_jobs
         self.importance_type = importance_type
         self.verbose = verbose
@@ -78,7 +80,7 @@ class LightGBM(Emulator):
             colsample_bytree=self.colsample_bytree,
             reg_alpha=self.reg_alpha,
             reg_lambda=self.reg_lambda,
-            random_state=self.random_state,
+            random_state=self.random_seed,
             n_jobs=self.n_jobs,
             importance_type=self.importance_type,
             verbose=self.verbose,

{autoemulate-0.3.1 → autoemulate-0.3.3}/autoemulate/experimental/emulators/neural_processes/conditional_neural_process.py

@@ -58,12 +58,10 @@ class CNPDataset(Dataset, TorchDeviceMixin):
     def __getitem__(self, idx):
         return self.sample()
 
-    def sample(self, seed=None):
+    def sample(self):
         """
         From the full dataset, sample context and target points.
         """
-        if seed is not None:
-            np.random.seed(seed)
 
         x = self.x
         y = self.y
@@ -262,6 +260,7 @@ class CNPModule(PyTorchBackend):
         offset_context_points: int = 2,
         n_episodes: int = 12,
         batch_size: int = 4,
+        random_seed: int | None = None,
         device: DeviceLike | None = None,
     ):
         """
@@ -294,6 +293,8 @@ class CNPModule(PyTorchBackend):
         device: DeviceLike | None
             Device to use for training. If None, use the default device.
         """
+        if random_seed is not None:
+            self.set_random_seed(random_seed, deterministic=True)
         super().__init__()
         TorchDeviceMixin.__init__(self, device=device)
         x, y = self._move_tensors_to_device(x, y)

{autoemulate-0.3.1 → autoemulate-0.3.3}/autoemulate/experimental/emulators/random_forest.py

@@ -25,7 +25,7 @@ class RandomForest(SklearnBackend):
         bootstrap: bool = True,
         oob_score: bool = False,
         max_samples: int | None = None,
-        random_state: int | np.random.RandomState | None = None,
+        random_seed: int | None = None,
         device: DeviceLike = "cpu",
     ):
         """Initializes a RandomForest object."""
@@ -40,7 +40,7 @@ class RandomForest(SklearnBackend):
         self.bootstrap = bootstrap
         self.oob_score = oob_score
         self.max_samples = max_samples
-        self.random_state = random_state
+        self.random_seed = random_seed
         self.model = RandomForestRegressor(
             n_estimators=self.n_estimators,
             max_depth=self.max_depth,
@@ -48,7 +48,7 @@ class RandomForest(SklearnBackend):
             min_samples_leaf=self.min_samples_leaf,
             max_features=self.max_features,
             bootstrap=self.bootstrap,
-            random_state=self.random_state,
+            random_state=self.random_seed,
         )
 
     @staticmethod

{autoemulate-0.3.1 → autoemulate-0.3.3}/autoemulate/experimental/emulators/svm.py

@@ -29,9 +29,12 @@ class SupportVectorMachine(SklearnBackend):
         verbose: bool = False,
         max_iter: int = 100,
         normalise_y: bool = True,
+        random_seed: int | None = None,
         device: DeviceLike = "cpu",
     ):
         """Initializes a SupportVectorMachines object."""
+        if random_seed is not None:
+            self.set_random_seed(random_seed)
         _, _, _ = x, y, device  # ignore unused arguments
         TorchDeviceMixin.__init__(self, device=device, cpu_only=True)
         self.kernel = kernel

{autoemulate-0.3.1 → autoemulate-0.3.3}/autoemulate/experimental/model_selection.py

@@ -70,6 +70,7 @@ def cross_validate(
     dataset: Dataset,
     model: type[Emulator],
     device: DeviceLike = "cpu",
+    random_seed: int = np.random.randint(int(1e5)),
     **kwargs: Any,
 ):
     """
@@ -105,7 +106,7 @@ def cross_validate(
 
         # fit model
         x, y = next(iter(train_loader))
-        m = model(x, y, device=device, **best_model_config)
+        m = model(x, y, device=device, random_seed=random_seed, **best_model_config)
         m.fit(x, y)
 
         # evaluate on batches

{autoemulate-0.3.1 → autoemulate-0.3.3}/autoemulate/history_matching.py

@@ -169,23 +169,13 @@ class HistoryMatching:
 
         # Need to handle discontinuous NROY spaces
         # i.e., region within min/max bounds is RO
-        valid_samples = np.empty((0, nroy_samples.shape[1]))
-        while len(valid_samples) < n_samples:
-            # Generate candidates
-            candidate_samples = np.random.uniform(
-                min_bounds, max_bounds, size=(n_samples, nroy_samples.shape[1])
-            )
-
-            # Filter valid samples based on implausibility and concatenate
-            implausibility = self.calculate_implausibility(candidate_samples)
-            valid_candidates = candidate_samples[implausibility["NROY"]]
-            valid_samples = np.concatenate((valid_samples, valid_candidates), axis=0)
 
-            # Only return required number of samples
-            if len(valid_samples) > n_samples:
-                valid_samples = valid_samples[:n_samples]
+        # Generate candidates
+        candidate_samples = np.random.uniform(
+            min_bounds, max_bounds, size=(n_samples, nroy_samples.shape[1])
+        )
 
-        return valid_samples
+        return candidate_samples
 
     def predict(
         self,
@@ -298,13 +288,22 @@ class HistoryMatching:
 
         with tqdm(total=n_waves, desc="History Matching", unit="wave") as pbar:
             for wave in range(n_waves):
+                #  CHECK IF WE HAVE SAMPLES TO PROCESS
+                if len(current_samples) == 0:
+                    print(f"Wave {wave}: No valid samples found, skipping...")
+                    pbar.update(1)
+                    continue
+
                 # Run wave using batch processing
                 pred_means, pred_vars, successful_samples = self.predict(
                     x=current_samples,
                     # Emulate predictions unless emulator_predict=False
                     emulator=emulator if emulator_predict else None,
                 )
-
+                if len(successful_samples) == 0:
+                    print(f"Wave {wave}: All simulations failed, skipping...")
+                    pbar.update(1)
+                    continue
                 # Calculate implausibility in batch
                 implausibility = self.calculate_implausibility(pred_means, pred_vars)
 
@@ -328,18 +327,39 @@ class HistoryMatching:
                             emulator, successful_samples, pred_means
                         )
 
-                # Generate new samples for next wave
-                if wave < n_waves - 1:
-                    if nroy_samples.size > 0:
-                        current_samples = self.sample_nroy(
-                            nroy_samples, n_samples_per_wave
-                        )
-                    else:
-                        # If no NROY points, sample from full space
-                        current_samples = self.simulator.sample_inputs(
-                            n_samples_per_wave
-                        )
-
+                    # Generate new samples for next wave
+                    if wave < n_waves - 1:
+                        if nroy_samples.size > 0:
+                            # Sample candidates
+                            candidate_samples = self.sample_nroy(
+                                nroy_samples, n_samples_per_wave
+                            )
+
+                            # Filter candidates using emulator before simulation
+                            if not emulator_predict and emulator is not None:
+                                pred_means, pred_vars = emulator.predict(
+                                    candidate_samples, return_std=True
+                                )
+                                pred_vars = pred_vars**2
+
+                                # Ensure correct shape for single output case
+                                if len(pred_means.shape) == 1:
+                                    pred_means = pred_means.reshape(-1, 1)
+                                    pred_vars = pred_vars.reshape(-1, 1)
+
+                                implausibility = self.calculate_implausibility(
+                                    pred_means, pred_vars
+                                )
+                                current_samples = candidate_samples[
+                                    implausibility["NROY"]
+                                ]
+                            else:
+                                current_samples = candidate_samples
+                        else:
+                            # If no NROY points, sample from full space
+                            current_samples = self.simulator.sample_inputs(
+                                n_samples_per_wave
+                            )
                 pbar.update(1)
 
         # Concatenate all samples and implausibility scores

{autoemulate-0.3.1 → autoemulate-0.3.3}/autoemulate/history_matching_dashboard.py

@@ -401,6 +401,7 @@ class HistoryMatchingDashboard:
                     self._plot_bayesian_style_comparison(filtered_df, filtered_scores)
                 elif plot_type == "Wave Evolution":
                     self._plot_wave_evolution(filtered_df, filtered_scores)
+                plt.show()
 
             except Exception as e:
                 plt.figure(figsize=(10, 6))
@@ -1208,26 +1209,8 @@ class HistoryMatchingDashboard:
 
         heading = widgets.HTML(value="<h2>History Matching Dashboard</h2>")
 
-        instructions = widgets.HTML(
-            value="""
-            <div style="background-color: #f8f9fa; padding: 15px; border-radius: 5px; margin-bottom: 15px;">
-                <h3>Instructions:</h3>
-                <ul>
-                    <li><strong>Plot Type</strong>: Select the type of visualization from the dropdown.</li>
-                    <li><strong>Threshold</strong>: Adjust the implausibility threshold for NROY classification.</li>
-                    <li><strong>Parameters</strong>: Select parameters to visualize (availability depends on plot type).</li>
-                    <li><strong>Show only NROY points</strong>: When available, filters to show only viable parameter combinations.</li>
-                    <li><strong>Update Plot</strong>: Click to regenerate the visualization with current settings.</li>
-                </ul>
-                <p><em>Note: Some controls are only available for certain plot types.</em></p>
-            </div>
-            """
-        )
-
         # Display the heading and instructions first
         display(heading)
-        display(instructions)
-
         display(self.main_layout)
         # Initialize the first plot
         self._update_plot(None)