UQPyL 2.1.3__tar.gz → 2.1.4__tar.gz

{UQPyL-2.1.3 → uqpyl-2.1.4}/PKG-INFO

@@ -1,18 +1,23 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: UQPyL
-Version: 2.1.3
+Version: 2.1.4
 Summary: A python package for parameter uncertainty quantification and optimization
 Author: wmtSky
 Author-email: wmtSky <wmtsky@hhu.edu.cn>
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: prettytable
+Requires-Dist: h5py
+Dynamic: author
 
 # UQPyL:  Uncertainty Quantification Python Lab
 
@@ -20,11 +25,18 @@ Description-Content-Type: text/markdown
 
 [![PyPI version](https://badge.fury.io/py/UQPyL.svg?icon=si%3Apython&icon_color=%2331aadd)](https://badge.fury.io/py/UQPyL) ![PyPI - Downloads](https://img.shields.io/pypi/dm/UQPyL) ![PyPI - License](https://img.shields.io/pypi/l/UQPyL) ![GitHub last commit](https://img.shields.io/github/last-commit/smasky/UQPyL) ![Static Badge](https://img.shields.io/badge/Author-wmtSky-orange) ![Static Badge](https://img.shields.io/badge/Contact-wmtsmasky%40gmail.com-blue)
 
-**UQPyL** is a Python package for **Uncertainty Quantification** and **Optimization** of computational models and their associated problems (e.g., model calibration, resource scheduling, product design). It includes a wide range of methods and algorithms for Design of Experiments, Sensitivity Analysis, Optimization (Single- and Multi-objective). Additionally, **Surrogate Models** are built-in for solving computationally expensive problems. 
+**UQPyL** is a Python package for **Uncertainty Quantification** and **Optimization** of computational models and their associated problems (e.g., model calibration, resource scheduling, product design). It includes a wide range of methods and algorithms for Design of Experiments, Sensitivity Analysis, Bayesian Inference, Optimization (Single- and Multi-objective). Additionally, **Surrogate Models** are built-in for solving computationally expensive problems. 
 
 👉[中文简介](https://github.com/smasky/UQPyL/blob/dev/README_CN.md)
 
-👉[Documentation](https://uqpyl.readthedocs.io/en/latest/)
+👉[中文文档](https://swat-uq.readthedocs.io/en/latest/zh/index.html)
+
+👉[Documentation](https://uqpyl.readthedocs.io)
+
+## Changelog
+
+- 2025.12.14:  Added the **inference** module. And results are now saved in **NetCDF** format, replacing the previous HDF output.
+
 
 ## Contents
 

{UQPyL-2.1.3 → uqpyl-2.1.4}/README.md

@@ -4,11 +4,18 @@
 
 [![PyPI version](https://badge.fury.io/py/UQPyL.svg?icon=si%3Apython&icon_color=%2331aadd)](https://badge.fury.io/py/UQPyL) ![PyPI - Downloads](https://img.shields.io/pypi/dm/UQPyL) ![PyPI - License](https://img.shields.io/pypi/l/UQPyL) ![GitHub last commit](https://img.shields.io/github/last-commit/smasky/UQPyL) ![Static Badge](https://img.shields.io/badge/Author-wmtSky-orange) ![Static Badge](https://img.shields.io/badge/Contact-wmtsmasky%40gmail.com-blue)
 
-**UQPyL** is a Python package for **Uncertainty Quantification** and **Optimization** of computational models and their associated problems (e.g., model calibration, resource scheduling, product design). It includes a wide range of methods and algorithms for Design of Experiments, Sensitivity Analysis, Optimization (Single- and Multi-objective). Additionally, **Surrogate Models** are built-in for solving computationally expensive problems. 
+**UQPyL** is a Python package for **Uncertainty Quantification** and **Optimization** of computational models and their associated problems (e.g., model calibration, resource scheduling, product design). It includes a wide range of methods and algorithms for Design of Experiments, Sensitivity Analysis, Bayesian Inference, Optimization (Single- and Multi-objective). Additionally, **Surrogate Models** are built-in for solving computationally expensive problems. 
 
 👉[中文简介](https://github.com/smasky/UQPyL/blob/dev/README_CN.md)
 
-👉[Documentation](https://uqpyl.readthedocs.io/en/latest/)
+👉[中文文档](https://swat-uq.readthedocs.io/en/latest/zh/index.html)
+
+👉[Documentation](https://uqpyl.readthedocs.io)
+
+## Changelog
+
+- 2025.12.14:  Added the **inference** module. And results are now saved in **NetCDF** format, replacing the previous HDF output.
+
 
 ## Contents
 

uqpyl-2.1.4/UQPyL/DoE/__init__.py

@@ -0,0 +1,12 @@
+from .lhs import LHS
+from .full_fact import FFD
+from .random import Random
+from .base import Sampler
+from .sobol import SobolSequence
+from .fast import FASTSequence
+from .morris import MorrisSequence
+from .saltelli import SaltelliSequence
+
+__all__ = ['LHS', 'FFD', 'Random', 'SaltelliSequence','SobolSequence', 
+                'MorrisSequence', 'FASTSequence', 'Sampler']
+

uqpyl-2.1.4/UQPyL/DoE/base.py

@@ -0,0 +1,22 @@
+import abc
+import numpy as np
+
+from ..problem import ProblemABC as Problem
+
+class Sampler(metaclass = abc.ABCMeta):
+    
+    def __init__(self):
+        
+        pass
+    
+    def _generate(self, nt: int, nx: int, seed = None):
+        '''
+        nt: the number of sampled points
+        nx: the dimensions of decision variables
+        
+        return:
+            ndarry[nt,nx]
+        '''
+        
+        pass
+

UQPyL-2.1.3/UQPyL/DoE/fast_sequence.py → uqpyl-2.1.4/UQPyL/DoE/fast.py

@@ -1,12 +1,12 @@
 import numpy as np
 from typing import Union, Optional
 
-from .samplerABC import Sampler, decoratorRescale
-from ..problems import ProblemABC as Problem
+from .base import Sampler
+from ..problem import ProblemABC as Problem
 
-class FAST_Sequence(Sampler):
+class FASTSequence(Sampler):
     """
-    The sample technique for FAST (Fourier Amplitude Sensitivity Test) method.
+    The sample method for FAST (Fourier Amplitude Sensitivity Test) method.
     
     This class generates samples for the FAST method, which is used for sensitivity analysis
     by decomposing the output variance into contributions from each input variable.
@@ -31,8 +31,10 @@ class FAST_Sequence(Sampler):
         
         :param nt: Number of sample points.
         :param nx: Input dimensions of sampled points.
+        
         :return: A 2D array of samples, normalized so factor values are uniformly spaced between zero and one.
         """
+        
         if nt <= 4 * self.M**2:
             raise ValueError("The number of samples must be greater than 4 * M^2!")
         
@@ -55,37 +57,29 @@ class FAST_Sequence(Sampler):
             idx = list(range(i)) + list(range(i + 1, nx))
             w_tmp[idx] = w[1:]
             idx = range(i * nt, (i + 1) * nt)
-            phi = 2 * np.pi * np.random.rand()
+            phi = 2 * np.pi * self.rng.random()
             sin_result = np.sin(w_tmp[:, None] * s + phi)
             arsin_result = (1 / np.pi) * np.arcsin(sin_result)  # Saltelli's formula
             xInit[idx, :] = 0.5 + arsin_result.transpose()
         
         return xInit
     
-    @decoratorRescale
-    def sample(self, nt: int, nx: Optional[int] = None, problem: Optional[Problem] = None, random_seed: Optional[int] = None):
+    def sample(self, problem: Problem, nt: int, seed: int = None):
         """
         Generate a sample for the FAST method.
         
+        :param problem: Problem instance to use bounds for sampling.
         :param nt: Number of sample points.
         :param nx: Input dimensions of sampled points.
-        :param problem: Problem instance to use bounds for sampling.
         :param random_seed: Random seed for reproducibility.
+        
         :return: A 2D array of FAST samples.
         """
-        if random_seed is not None:
-            self.random_state = np.random.RandomState(random_seed)
-        else:
-            self.random_state = np.random.RandomState()
         
-        if problem is not None and nx is not None:
-            if problem.nInput != nx:
-                raise ValueError('The input dimensions of the problem and the samples must be the same')
-        elif problem is None and nx is None:
-            raise ValueError('Either the problem or the input dimensions must be provided')
+        self.rng = np.random.default_rng(seed) if seed is not None else np.random.default_rng()
         
-        nx = problem.nInput if problem is not None else nx
+        nx = problem.nInput
         
-        return self._generate(nt, nx)
+        return problem._transform_unit_X(self._generate(nt, nx))
     
     

{UQPyL-2.1.3 → uqpyl-2.1.4}/UQPyL/DoE/full_fact.py

@@ -2,8 +2,8 @@ import numpy as np
 from typing import Union, Optional
 from itertools import product
 
-from .samplerABC import Sampler, decoratorRescale
-from ..problems import ProblemABC as Problem
+from .base import Sampler
+from ..problem import ProblemABC as Problem
 
 class FFD(Sampler):
     """
@@ -39,28 +39,19 @@ class FFD(Sampler):
         
         return H
     
-    @decoratorRescale
-    def sample(self, levels: Union[np.ndarray, int, list], nx: Optional[int] = None, problem: Optional[Problem] = None, random_seed: Optional[int] = None):
+    def sample(self, problem: Problem, levels: Union[np.ndarray, int, list], seed: Optional[int] = None):
         """
         Generate a full factorial design sample.
         
-        :param levels: Levels for each input dimension. Can be an integer, list, or ndarray.
-        :param nx: Number of input dimensions.
         :param problem: Problem instance to use bounds for sampling.
+        :param levels: Levels for each input dimension. Can be an integer, list, or ndarray.
         :param random_seed: Random seed for reproducibility.
+        
         :return: A 2D array of full factorial design samples.
         """
-        if random_seed is not None:
-            self.random_state = np.random.RandomState(random_seed)
-        else:
-            self.random_state = np.random.RandomState()
-        
-        if problem is not None and nx is not None:
-            if problem.nInput != nx:
-                raise ValueError('The input dimensions of the problem and the samples must be the same')
-        elif problem is None and nx is None:
-            raise ValueError('Either the problem or the input dimensions must be provided')
         
-        nx = problem.nInput if problem is not None else nx
+        self.rng = np.random.default_rng(seed) if seed is not None else np.random.default_rng()
+                
+        nx = problem.nInput
 
-        return self._generate(levels, nx)
+        return problem._transform_unit_X(self._generate(levels, nx))

{UQPyL-2.1.3 → uqpyl-2.1.4}/UQPyL/DoE/lhs.py

@@ -2,26 +2,24 @@ from typing import Literal, Optional
 import numpy as np
 from scipy.spatial.distance import pdist
 
-from .samplerABC import Sampler, decoratorRescale
-from ..problems import ProblemABC as Problem
+from .base import Sampler
+from ..problem import ProblemABC as Problem
 
-def _lhs_classic(nt: int, nx: int, random_state=None) -> np.ndarray:
+def _lhs_classic(nt: int, nx: int, rng):
     """
     Generate a classic Latin Hypercube Sampling (LHS) design.
     
     :param nt: Number of samples.
     :param nx: Number of dimensions.
-    :param random_state: Random state for reproducibility.
+    :param rng: Random state for reproducibility.
     :return: A 2D array of LHS samples.
     """
-    if random_state is None:
-        random_state = np.random.RandomState()
-    
+
     # Generate the intervals
     cut = np.linspace(0, 1, nt + 1)
     
     # Fill points uniformly in each interval
-    u = random_state.rand(nt, nx)
+    u = rng.random((nt, nx))
     a = cut[:nt]
     b = cut[1:nt + 1]
     rdpoints = np.zeros_like(u)
@@ -31,30 +29,26 @@ def _lhs_classic(nt: int, nx: int, random_state=None) -> np.ndarray:
     # Make the random pairings
     H = np.zeros_like(rdpoints)
     for j in range(nx):
-        order = random_state.permutation(range(nt))
+        order = rng.permutation(range(nt))
         H[:, j] = rdpoints[order, j]
     
     return H
     
-################################################################################
-
-def _lhs_centered(nt: int, nx: int, random_state=None) -> np.ndarray:
+def _lhs_centered(nt: int, nx: int, rng):
     """
     Generate a centered Latin Hypercube Sampling (LHS) design.
     
     :param nt: Number of samples.
     :param nx: Number of dimensions.
-    :param random_state: Random state for reproducibility.
+    :param rng: Random state for reproducibility.
     :return: A 2D array of centered LHS samples.
     """
-    if random_state is None:
-        random_state = np.random.RandomState()
-    
+
     # Generate the intervals
     cut = np.linspace(0, 1, nt + 1)    
     
     # Fill points uniformly in each interval
-    u = random_state.rand(nt, nx)
+    u = rng.random(nt, nx)
     a = cut[:nt]
     b = cut[1:nt + 1]
     _center = (a + b)/2
@@ -62,31 +56,27 @@ def _lhs_centered(nt: int, nx: int, random_state=None) -> np.ndarray:
     # Make the random pairings
     H = np.zeros_like(u)
     for j in range(nx):
-        H[:, j] = random_state.permutation(_center)
+        H[:, j] = rng.permutation(_center)
     
     return H
     
-################################################################################
-
-def _lhs_maximin(nt: int, nx: int, iterations: int, random_state=None)-> np.ndarray:
+def _lhs_maximin(nt: int, nx: int, iterations: int, rng):
     """
     Generate a maximin Latin Hypercube Sampling (LHS) design.
     
     :param nt: Number of samples.
     :param nx: Number of dimensions.
     :param iterations: Number of iterations to maximize the minimum distance.
-    :param random_state: Random state for reproducibility.
+    :param rng: Random state for reproducibility.
     :return: A 2D array of maximin LHS samples.
     """
-    if random_state is None:
-        random_state=np.random.RandomState()
-        
+     
     maxdist = 0
     
     # Maximize the minimum distance between points
     for i in range(iterations):
 
-        H_candidate = _lhs_classic(nt, nx, random_state)
+        H_candidate = _lhs_classic(nt, nx, rng)
 
         d = pdist(H_candidate,'euclidean')
         if maxdist<np.min(d):
@@ -95,25 +85,23 @@ def _lhs_maximin(nt: int, nx: int, iterations: int, random_state=None)-> np.ndar
     
     return H
 
-def _lhs_centered_maximin(nt: int, nx: int, iterations: int, random_state=None)-> np.ndarray:
+def _lhs_centered_maximin(nt: int, nx: int, iterations: int, rng):
     """
     Generate a centered maximin Latin Hypercube Sampling (LHS) design.
     
     :param nt: Number of samples.
     :param nx: Number of dimensions.
     :param iterations: Number of iterations to maximize the minimum distance.
-    :param random_state: Random state for reproducibility.
+    :param rng: Random state for reproducibility.
     :return: A 2D array of centered maximin LHS samples.
     """
-    if random_state is None:
-        random_state=np.random.RandomState()
-    
+
     maxdist = 0
     
     # Maximize the minimum distance between points
     for i in range(iterations):
 
-        H_candidate = _lhs_centered(nt, nx, random_state)
+        H_candidate = _lhs_centered(nt, nx, rng)
         d = pdist(H_candidate,'euclidean')
         if maxdist<np.min(d):
             maxdist = np.min(d)
@@ -122,25 +110,23 @@ def _lhs_centered_maximin(nt: int, nx: int, iterations: int, random_state=None)-
     return H
 ################################################################################
 
-def _lhs_correlate(nt: int, nx: int, iterations: int, random_state=None) -> np.ndarray:
+def _lhs_correlate(nt: int, nx: int, iterations: int, rng = None):
     """
     Generate a correlation-optimized Latin Hypercube Sampling (LHS) design.
     
     :param nt: Number of samples.
     :param nx: Number of dimensions.
     :param iterations: Number of iterations to minimize correlation.
-    :param random_state: Random state for reproducibility.
+    :param rng: Random state for reproducibility.
     :return: A 2D array of correlation-optimized LHS samples.
     """
-    if random_state is None:
-        random_state=np.random.RandomState()
     
     mincorr = np.inf
     
     # Minimize the components correlation coefficients
     for _ in range(iterations):
         # Generate a random LHS
-        H_candidate = _lhs_classic(nt, nx, random_state)
+        H_candidate = _lhs_classic(nt, nx, rng)
         R = np.corrcoef(H_candidate)
         if np.max(np.abs(R[R!=1]))<mincorr:
             mincorr = np.max(np.abs(R-np.eye(R.shape[0])))
@@ -149,8 +135,8 @@ def _lhs_correlate(nt: int, nx: int, iterations: int, random_state=None) -> np.n
 
     return H
 
-Criterion=Literal['classic','center','maximin','center_maximin','correlation']
-LHS_METHOD={'classic': _lhs_classic, 'center': _lhs_centered, 'maximin': _lhs_maximin,
+Criterion = Literal['classic','center','maximin','center_maximin','correlation']
+LHS_METHOD = {'classic': _lhs_classic, 'center': _lhs_centered, 'maximin': _lhs_maximin,
              'center_maximin': _lhs_centered_maximin, 'correlation': _lhs_correlate}
 
 class LHS(Sampler):
@@ -162,16 +148,16 @@ class LHS(Sampler):
     
             
     """
-    def __init__(self, criterion: Criterion ='classic', iterations: int=5):
+    def __init__(self, criterion: Criterion ='classic', iterations = 5):
         """
         Initialize the LHS sampler with a specified criterion and number of iterations.
         
         :param criterion: The LHS criterion to use.
         :param iterations: Number of iterations for optimization methods.
         """
-        self.criterion=criterion
-        self.iterations=iterations
-        
+
+        self.criterion = criterion
+        self.iterations = iterations
         #initial random state
         super().__init__()
         
@@ -190,35 +176,25 @@ class LHS(Sampler):
         Sampling_method = LHS_METHOD[self.criterion]
         
         if self.criterion in ['maximin', 'center_maximin', 'correlation']:
-            xInit = Sampling_method(nt, nx, self.iterations, self.random_state)
+            xInit = Sampling_method(nt, nx, self.iterations, self.rng)
         else:
-            xInit = Sampling_method(nt, nx, self.random_state)
+            xInit = Sampling_method(nt, nx, self.rng)
         
         return xInit
     
-    @decoratorRescale
-    def sample(self, nt: int, nx: int = None, problem: Problem = None, random_seed: Optional[int] = None) -> np.ndarray:
+    def sample(self, problem: Problem, nt: int, seed: Optional[int] = None):
         """
         Generate a Latin-hypercube design.
         
         :param nt: Number of sampled points.
         :param nx: Input dimensions of sampled points.
         :param problem: Problem instance to use bounds for sampling.
-        :param random_seed: Random seed for reproducibility.
+        :param seed: Random seed for reproducibility.
         :return: A 2D array of LHS samples.
         """
         
-        if random_seed is not None:
-            self.random_state = np.random.RandomState(random_seed)
-        else:
-            self.random_state = np.random.RandomState()
-        
-        if problem is not None and nx is not None:
-            if problem.nInput != nx:
-                raise ValueError('The input dimensions of the problem and the samples must be the same')
-        elif problem is None and nx is None:
-            raise ValueError('Either the problem or the input dimensions must be provided')
+        self.rng = np.random.default_rng(seed) if seed is not None else np.random.default_rng()
         
-        nx = problem.nInput if problem is not None else nx
+        nx = problem.nInput
         
-        return self._generate(nt, nx)
+        return problem._transform_unit_X(self._generate(nt, nx))

UQPyL-2.1.3/UQPyL/DoE/morris_sequence.py → uqpyl-2.1.4/UQPyL/DoE/morris.py

@@ -1,10 +1,10 @@
 import numpy as np
 from typing import Optional
 
-from .samplerABC import Sampler, decoratorRescale
-from ..problems import ProblemABC as Problem
+from .base import Sampler
+from ..problem import ProblemABC as Problem
 
-class Morris_Sequence(Sampler):
+class MorrisSequence(Sampler):
     """
     The sample technique for Morris analysis.
     
@@ -18,6 +18,7 @@ class Morris_Sequence(Sampler):
     Reference:
         [1] Max D. Morris (1991) Factorial Sampling Plans for Preliminary Computational Experiments, Technometrics, 33:2, 161-174
     """
+    
     def __init__(self, numLevels: int = 4):
         """
         Initialize the Morris Sequence sampler with a specified number of levels.
@@ -25,6 +26,7 @@ class Morris_Sequence(Sampler):
         :param numLevels: Number of levels for the Morris method.
         """
         super().__init__()
+        
         self.numLevels = numLevels
         
     def _generate(self, nt: int, nx: int):
@@ -38,35 +40,27 @@ class Morris_Sequence(Sampler):
         xInit = np.zeros((nt * (nx + 1), nx))
         
         for i in range(nt):
+            
             xInit[i * (nx + 1):(i + 1) * (nx + 1), :] = self._generate_trajectory(nx)
         
         return xInit
     
-    @decoratorRescale
-    def sample(self, nt: int, nx: Optional[int] = None, problem: Optional[Problem] = None, random_seed: Optional[int] = None):
+    def sample(self, problem: Problem, nt: int, seed: Optional[int] = None):
         """
         Generate a sample for the Morris method.
         
-        :param nt: Number of trajectories.
-        :param nx: Input dimensions of sampled points.
         :param problem: Problem instance to use bounds for sampling.
+        :param nt: Number of trajectories.
         :param random_seed: Random seed for reproducibility.
+        
         :return: A 2D array of samples.
         """
-        if random_seed is not None:
-            self.random_state = np.random.RandomState(random_seed)
-        else:
-            self.random_state = np.random.RandomState()
         
-        if problem is not None and nx is not None:
-            if problem.nInput != nx:
-                raise ValueError('The input dimensions of the problem and the samples must be the same')
-        elif problem is None and nx is None:
-            raise ValueError('Either the problem or the input dimensions must be provided')
+        self.rng = np.random.default_rng(seed) if seed is not None else np.random.default_rng()
         
-        nx = problem.nInput if problem is not None else nx
+        nx = problem.nInput
         
-        return self._generate(nt, nx)
+        return problem._transform_unit_X(self._generate(nt, nx))
         
     def _generate_trajectory(self, nx: int):
         """
@@ -80,14 +74,14 @@ class Morris_Sequence(Sampler):
         B = np.tril(np.ones([nx + 1, nx], dtype=int), -1)
         
         # From paper[1] page 164
-        D_star = np.diag(np.random.choice([-1, 1], nx))  # Step 1
+        D_star = np.diag(self.rng.choice([-1, 1], nx))  # Step 1
         J = np.ones((nx + 1, nx))
         
         levels_grids = np.linspace(0, 1 - delta, int(self.numLevels / 2))
-        x_star = np.random.choice(levels_grids, nx).reshape(1, -1)  # Step 2
+        x_star = self.rng.choice(levels_grids, nx).reshape(1, -1)  # Step 2
         
         P_star = np.zeros((nx, nx))
-        cols = np.random.choice(nx, nx, replace=False)
+        cols = self.rng.choice(nx, nx, replace=False)
         P_star[np.arange(nx), cols] = 1  # Step 3
         
         element_a = J[0, :] * x_star

uqpyl-2.1.4/UQPyL/DoE/random.py

@@ -0,0 +1,45 @@
+import numpy as np
+from typing import Optional
+
+from .base import Sampler
+from ..problem import ProblemABC as Problem
+
+class Random(Sampler):
+    """
+    Random Design
+    
+    Methods:
+        sample: Generate a random design.
+    
+    Examples:
+        >>> random = Random()
+        >>> random.sample(10, 10) or random(10, 10)
+    """
+    
+    def _generate(self, nt: int, nx: int):
+        """
+        Generate a random sample.
+        
+        :param nt: Number of sampled points.
+        :param nx: Input dimensions of sampled points.
+        :return: A 2D array of random samples.
+        """
+        H = self.rng.random((nt, nx))
+        
+        return H
+    
+    def sample(self, problem: Problem, nt: int, seed: Optional[int] = None):
+        """
+        Generate a sample with random values between zero and one.
+        
+        :param problem: Problem instance to use bounds for sampling.
+        :param nt: Number of sampled points.
+        :param random_seed: Random seed for reproducibility.
+        :return: A 2D array of random samples.
+        """
+        
+        self.rng = np.random.default_rng(seed) if seed is not None else np.random.default_rng()
+        
+        nx = problem.nInput
+        
+        return problem._transform_unit_X(self._generate(nt, nx))