UQPyL 2.0.5__tar.gz → 2.0.7__tar.gz

UQPyL-2.0.7/PKG-INFO

@@ -0,0 +1,196 @@
+Metadata-Version: 2.1
+Name: UQPyL
+Version: 2.0.7
+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: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+
+
+# Uncertainty Quantification Python Laboratory (UQPyL)
+
+**UQPyL:** The **Uncertainty Quantification Python Laboratory** provides comprehensive workflows tailored for **Uncertainty Quantification** and **Optimization** of computational models and their associated applications (e.g., model calibration, resource scheduling, product design). 
+
+## Main Characteristics
+
+1. **Comprehensive Sensitivity Analysis and Optimization Algorithm**: Implements widely used sensitivity analysis methodologies and optimization algorithms.
+2. **Advanced Surrogate Modeling**: Integrates diverse surrogate models equipped to solve computationally expensive problems.
+3. **Rich Application Resources**: Provides a comprehensive suite of benchmark problems and practical case studies, enabling users to get started quickly.
+4. **Modular and Extensible Architecture**: Encourages and facilitates the development of novel methods or algorithms by users, aligning with our commitment to openness and collaboration. (**We appreciate and welcome contributions**)
+
+## Quick Links
+
+- **Website**: [UQPyL Official Site](http://www.uq-pyl.com) (**#TODO**: Needs update)
+- **Source Code**: [GitHub Repository](https://github.com/smasky/UQPyL/)
+- **Documentation**: [ReadTheDocs](https://uqpyl.readthedocs.io/en/latest/)(**#TODO**: Being updating )
+- **Citation Info**: [UQPyL 2.0](**#TODO**: Needs update), [UQPyL 1.0](https://www.sciencedirect.com/science/article/pii/S1364815215300955)
+
+---
+
+## Included Methods and Algorithms
+
+### Sensitivity Analysis
+
+(All methods support surrogate models)
+- Sobol'
+- Delta Test (DT)
+- Extended Fourier Amplitude Sensitivity Test (eFAST)
+- Random Balance Designs - Fourier Amplitude Sensitivity Test (RBD-FAST)
+- Multivariate Adaptive Regression Splines-Sensitivity Analysis (MARS-SA)
+- Morris
+- Regional Sensitivity Analysis (RSA)
+
+### Optimization Algorithms
+
+(* indicates solving computational expensive optimization problem)
+- **Single Objective Optimization**: SCE-UA, ML-SCE-UA, GA, CSA, PSO, DE, ABC, ASMO*, EGO*
+- **Multi-Objective Optimization**: MOEA/D, NSGA-II, RVEA, MOASMO*
+
+*Note: The library is still being updated. If you need other algorithms, please contact us.*
+
+### Surrogate Models
+
+- Fully Connected Neural Network (FCNN)
+- Kriging (KRG)
+- Gaussian Process (GP)
+- Linear Regression (LR)
+- Polynomial Regression (PR)
+- Radial Basis Function (RBF)
+- Support Vector Machine (SVM)
+- Multivariate Adaptive Regression Splines (MARS)
+
+---
+
+## Installation
+
+Recommended (PyPi or Conda):
+
+```bash
+pip install UQPyL
+```
+
+```bash
+conda install UQPyL
+```
+
+Alternatively:
+
+```bash
+git clone https://github.com/smasky/UQPyL.git 
+cd UQPyL
+pip install .
+```
+
+---
+
+## Quick Start
+
+To use UQPyL, define the problem you want to solve. The problem usually contains three important properties:
+1. `func` (the mapping from X to Y)
+2. The dimensions of decisions and outputs
+3. The bounds of decisions (ub, lb)
+
+### Benchmark Problems
+
+```python
+from UQPyL.problems.single_objective import Sphere
+
+problem = Sphere(nInput=10, ub=100, lb=-100)
+problem = Sphere(nInput=10, ub=np.ones(10)*100, lb=np.ones(10)*-100)
+```
+
+### Practical Problems
+
+Define the evaluation function:
+
+```python
+from UQPyL.problems import PracticalProblem
+
+def func(X):
+    Y = np.sum(X, axis=1).reshape(-1, 1)
+    return Y
+
+problem = PracticalProblem(func=func, nInput=10, nOutput=1, ub=100, lb=-100, name="Sphere")
+```
+
+**Note:** The `func` needs to accept a matrix of X and return a matrix of Y, with columns equal to dimensions and rows equal to samples. X and Y should be np.ndarray.
+
+After defining the problem, you can use any methods in UQPyL.
+
+### Sensitivity Analysis
+
+```python
+from UQPyL.sensibility import Sobol
+
+sobol = Sobol()  # Instantiate and set hyper-parameters
+sobol.analyze(problem)
+```
+
+### Optimization
+
+```python
+from UQPyL.optimization.single_objective import SCE_UA
+
+sce = SCE_UA()
+res = sce.run(problem)
+bestDec = res.bestDec
+bestObj = res.bestObj
+```
+
+### Surrogate Modeling
+
+```python
+from UQPyL.DoE import LHS
+
+lhs = LHS(problem)
+xTrain = lhs.sample(200, problem.nInput)
+yTrain = problem.evaluate(xTrain)
+
+xTest = lhs.sample(50, problem.nInput)
+yTest = problem.evaluate(xTest)
+
+from UQPyL.surrogate.rbf import RBF
+
+rbf = RBF()
+rbf.fit(xTrain, yTrain)
+yPred = rbf.predict(xTest)
+
+from UQPyL.utility.metric import r_square
+r2 = r_square(yTest, yPred)
+```
+
+For more advanced usage, please refer to the documentation (**#TODO**).
+
+---
+
+## Call for Contributions
+
+We welcome contributions to expand our library with more sophisticated UQ methods, optimization algorithms and engineering problems.
+
+---
+
+## Contact
+
+For any inquiries or contributions, please contact:
+
+**wmtSky**  
+Email: [wmtsky@hhu.edu.cn](mailto:wmtsky@hhu.edu.cn), [wmtsmasky@gmail.com](mailto:wmtsmasky@gmail.com)
+
+---
+
+*This project is licensed under the MIT License - see the [LICENSE](https://github.com/smasky/UQPyL/LICENSE) file for details.*
+
+![GitHub Stars](https://img.shields.io/github/stars/smasky/UQPyL?style=social)
+![GitHub Forks](https://img.shields.io/github/forks/smasky/UQPyL?style=social)
+
+
+

UQPyL-2.0.7/README.md

@@ -0,0 +1,179 @@
+
+# Uncertainty Quantification Python Laboratory (UQPyL)
+
+**UQPyL:** The **Uncertainty Quantification Python Laboratory** provides comprehensive workflows tailored for **Uncertainty Quantification** and **Optimization** of computational models and their associated applications (e.g., model calibration, resource scheduling, product design). 
+
+## Main Characteristics
+
+1. **Comprehensive Sensitivity Analysis and Optimization Algorithm**: Implements widely used sensitivity analysis methodologies and optimization algorithms.
+2. **Advanced Surrogate Modeling**: Integrates diverse surrogate models equipped to solve computationally expensive problems.
+3. **Rich Application Resources**: Provides a comprehensive suite of benchmark problems and practical case studies, enabling users to get started quickly.
+4. **Modular and Extensible Architecture**: Encourages and facilitates the development of novel methods or algorithms by users, aligning with our commitment to openness and collaboration. (**We appreciate and welcome contributions**)
+
+## Quick Links
+
+- **Website**: [UQPyL Official Site](http://www.uq-pyl.com) (**#TODO**: Needs update)
+- **Source Code**: [GitHub Repository](https://github.com/smasky/UQPyL/)
+- **Documentation**: [ReadTheDocs](https://uqpyl.readthedocs.io/en/latest/)(**#TODO**: Being updating )
+- **Citation Info**: [UQPyL 2.0](**#TODO**: Needs update), [UQPyL 1.0](https://www.sciencedirect.com/science/article/pii/S1364815215300955)
+
+---
+
+## Included Methods and Algorithms
+
+### Sensitivity Analysis
+
+(All methods support surrogate models)
+- Sobol'
+- Delta Test (DT)
+- Extended Fourier Amplitude Sensitivity Test (eFAST)
+- Random Balance Designs - Fourier Amplitude Sensitivity Test (RBD-FAST)
+- Multivariate Adaptive Regression Splines-Sensitivity Analysis (MARS-SA)
+- Morris
+- Regional Sensitivity Analysis (RSA)
+
+### Optimization Algorithms
+
+(* indicates solving computational expensive optimization problem)
+- **Single Objective Optimization**: SCE-UA, ML-SCE-UA, GA, CSA, PSO, DE, ABC, ASMO*, EGO*
+- **Multi-Objective Optimization**: MOEA/D, NSGA-II, RVEA, MOASMO*
+
+*Note: The library is still being updated. If you need other algorithms, please contact us.*
+
+### Surrogate Models
+
+- Fully Connected Neural Network (FCNN)
+- Kriging (KRG)
+- Gaussian Process (GP)
+- Linear Regression (LR)
+- Polynomial Regression (PR)
+- Radial Basis Function (RBF)
+- Support Vector Machine (SVM)
+- Multivariate Adaptive Regression Splines (MARS)
+
+---
+
+## Installation
+
+Recommended (PyPi or Conda):
+
+```bash
+pip install UQPyL
+```
+
+```bash
+conda install UQPyL
+```
+
+Alternatively:
+
+```bash
+git clone https://github.com/smasky/UQPyL.git 
+cd UQPyL
+pip install .
+```
+
+---
+
+## Quick Start
+
+To use UQPyL, define the problem you want to solve. The problem usually contains three important properties:
+1. `func` (the mapping from X to Y)
+2. The dimensions of decisions and outputs
+3. The bounds of decisions (ub, lb)
+
+### Benchmark Problems
+
+```python
+from UQPyL.problems.single_objective import Sphere
+
+problem = Sphere(nInput=10, ub=100, lb=-100)
+problem = Sphere(nInput=10, ub=np.ones(10)*100, lb=np.ones(10)*-100)
+```
+
+### Practical Problems
+
+Define the evaluation function:
+
+```python
+from UQPyL.problems import PracticalProblem
+
+def func(X):
+    Y = np.sum(X, axis=1).reshape(-1, 1)
+    return Y
+
+problem = PracticalProblem(func=func, nInput=10, nOutput=1, ub=100, lb=-100, name="Sphere")
+```
+
+**Note:** The `func` needs to accept a matrix of X and return a matrix of Y, with columns equal to dimensions and rows equal to samples. X and Y should be np.ndarray.
+
+After defining the problem, you can use any methods in UQPyL.
+
+### Sensitivity Analysis
+
+```python
+from UQPyL.sensibility import Sobol
+
+sobol = Sobol()  # Instantiate and set hyper-parameters
+sobol.analyze(problem)
+```
+
+### Optimization
+
+```python
+from UQPyL.optimization.single_objective import SCE_UA
+
+sce = SCE_UA()
+res = sce.run(problem)
+bestDec = res.bestDec
+bestObj = res.bestObj
+```
+
+### Surrogate Modeling
+
+```python
+from UQPyL.DoE import LHS
+
+lhs = LHS(problem)
+xTrain = lhs.sample(200, problem.nInput)
+yTrain = problem.evaluate(xTrain)
+
+xTest = lhs.sample(50, problem.nInput)
+yTest = problem.evaluate(xTest)
+
+from UQPyL.surrogate.rbf import RBF
+
+rbf = RBF()
+rbf.fit(xTrain, yTrain)
+yPred = rbf.predict(xTest)
+
+from UQPyL.utility.metric import r_square
+r2 = r_square(yTest, yPred)
+```
+
+For more advanced usage, please refer to the documentation (**#TODO**).
+
+---
+
+## Call for Contributions
+
+We welcome contributions to expand our library with more sophisticated UQ methods, optimization algorithms and engineering problems.
+
+---
+
+## Contact
+
+For any inquiries or contributions, please contact:
+
+**wmtSky**  
+Email: [wmtsky@hhu.edu.cn](mailto:wmtsky@hhu.edu.cn), [wmtsmasky@gmail.com](mailto:wmtsmasky@gmail.com)
+
+---
+
+*This project is licensed under the MIT License - see the [LICENSE](https://github.com/smasky/UQPyL/LICENSE) file for details.*
+
+![GitHub Stars](https://img.shields.io/github/stars/smasky/UQPyL?style=social)
+![GitHub Forks](https://img.shields.io/github/forks/smasky/UQPyL?style=social)
+
+
+

{UQPyL-2.0.5 → UQPyL-2.0.7}/UQPyL/DoE/__init__.py

@@ -1,7 +1,7 @@
 from .lhs import LHS
 from .full_fact import FFD
 from .random import Random
-from .sampler_ABC import Sampler
+from .samplerABC import Sampler
 from .sobol_sequence import Sobol_Sequence
 from .fast_sequence import FAST_Sequence
 from .morris_sequence import Morris_Sequence

{UQPyL-2.0.5 → UQPyL-2.0.7}/UQPyL/DoE/fast_sequence.py

@@ -1,7 +1,8 @@
 import numpy as np
+from typing import Union, Optional
 
-from .sampler_ABC import Sampler
-
+from .samplerABC import Sampler, decoratorRescale
+from ..problems import ProblemABC as Problem
 class FAST_Sequence(Sampler):
     '''
     The sample technique for FAST(Fourier Amplitude Sensitivity Test) method
@@ -15,17 +16,14 @@ class FAST_Sequence(Sampler):
     Methods:
     __call__ or sample: Generate a sample for FAST method
     
-    Examples:
-        >>> fast_seq=FAST_Sequence()
-        >>> samples=fast_seq(5, 4) or fast_seq.sample(5,4)
-    
     '''
     def __init__(self, M: int=4):
         
         super().__init__()
-        self.M=M
         
-    def _generate(self, nt: int, nx: int) -> np.ndarray:
+        self.M=M
+    
+    def _generate(self, nt: int, nx: int):
         '''
         Generate a shape of (nt*nx, nx) sample for FAST
         
@@ -55,7 +53,7 @@ class FAST_Sequence(Sampler):
         
         s=(2*np.pi/nt)*np.arange(nt)
         
-        X_sa=np.zeros((nt*nx, nx))
+        xInit=np.zeros((nt*nx, nx))
         w_tmp=np.zeros(nx)
         
         for i in range(nx):
@@ -66,11 +64,25 @@ class FAST_Sequence(Sampler):
             phi=2*np.pi*np.random.rand()    
             sin_result=np.sin(w_tmp[:,None]*s+phi)
             arsin_result=(1/np.pi)*np.arcsin(sin_result) #saltelli formula
-            X_sa[idx, :]=0.5+arsin_result.transpose()
+            xInit[idx, :]=0.5+arsin_result.transpose()
         
-        return X_sa
+        return xInit
     
-    def sample(self, nt: int, nx: int) -> np.ndarray:
+    @decoratorRescale
+    def sample(self, nt: int, nx: Optional[int] = None, problem: Optional[Problem] = None, random_seed: Optional[int] = None):
+        
+        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
         
         return self._generate(nt, nx)
     

UQPyL-2.0.7/UQPyL/DoE/full_fact.py

@@ -0,0 +1,68 @@
+import numpy as np
+from typing import Union, Optional
+from itertools import product
+
+from .samplerABC import Sampler, decoratorRescale
+from ..problems import ProblemABC as Problem
+
+class FFD(Sampler):
+    '''
+    Full Factorial Design
+    
+    Methods:
+    __call__ or sample: Generate a Latin-hypercube design
+
+    '''
+    
+    #Abandon
+    # def __call__(self, nx: int, levels: Union[np.ndarray, int, list]) -> np.ndarray:
+        
+    #     return self._generate(nx, levels)
+    
+    def _generate(self, levels: Union[np.ndarray, int, list], nx: int):
+
+        if isinstance(levels, int):
+            levels = [levels]*nx
+        elif isinstance(levels, np.ndarray):
+            levels = levels.ravel().tolist()
+        
+        if len(levels)!=nx:
+            raise ValueError('The length of levels should be equal to nx or 1')
+        
+        factor_levels = [np.linspace(0, 1, num=level)[:level] for level in levels]
+               
+        factor_combinations = list(product(*factor_levels))
+       
+        H = np.array(factor_combinations)
+        
+        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):
+        '''
+        Parameters:
+        nx: int
+            The number of input dimensions
+        
+        levels: Union[np.ndarray, int, list]
+            The levels for each input dimension
+            
+        Returns:
+        H: 2d-array
+            An n-by-samples design matrix between zero and one.        
+        '''
+        
+        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
+
+        return self._generate(levels, nx)

{UQPyL-2.0.5 → UQPyL-2.0.7}/UQPyL/DoE/lhs.py

@@ -2,9 +2,9 @@ import numpy as np
 from typing import Literal, Optional
 from scipy.spatial.distance import pdist
 
-from ..problems import Problem
+from ..problems import ProblemABC as Problem
 
-from .sampler_ABC import Sampler
+from .samplerABC import Sampler, decoratorRescale
 
 # from ._lhs import _lhs_classic, _lhs_centered, _lhs_correlate, _lhs_maximin, _lhs_centered_maximin
 
@@ -136,22 +136,17 @@ class LHS(Sampler):
     
     Methods:
     __call__ or sample: Generate a Latin-hypercube design
-        
-    Examples:
-        >>>lhs=LHS('classic')
-        >>>samples=lhs(5,10) or samples=lhs.sample(5,10)
-    
+            
     '''
-    def __init__(self, criterion: Criterion ='classic', iterations: int=5, problem: Optional[Problem]=None):
+    def __init__(self, criterion: Criterion ='classic', iterations: int=5):
         
         self.criterion=criterion
         self.iterations=iterations
-        self.problem=problem
         
         #initial random state
-        self.random_state=np.random.RandomState()
+        super().__init__()
         
-    def _generate(self, nt: int, nx: int) -> np.ndarray:
+    def _generate(self, nt: int, nx:int=None):
         '''
         Generate a Latin-hypercube design
         
@@ -167,27 +162,20 @@ class LHS(Sampler):
             are uniformly spaced between zero and one.
         '''
         
-        if self.problem is not None:
-            if(self.problem.n_input!=nx):
-                raise ValueError('The input dimensions of the problem and the samples must be the same')
-        
         if self.criterion not in LHS_METHOD:
             raise ValueError('The criterion must be one of {}'.format(LHS_METHOD.keys()))
         
         Sampling_method=LHS_METHOD[self.criterion]
         
         if self.criterion in ['maximin', 'center_maximin', 'correlation']:
-            X=Sampling_method(nt, nx, self.iterations, self.random_state)
+            xInit=Sampling_method(nt, nx, self.iterations, self.random_state)
         else:
-            X=Sampling_method(nt, nx, self.random_state)
+            xInit=Sampling_method(nt, nx, self.random_state)
         
-        #rescale the samples
-        if self.problem is not None:
-            X=X*(self.problem.ub-self.problem.lb)+self.problem.lb
-            
-        return X
+        return xInit
     
-    def sample(self, nt: int, nx:int, random_seed: Optional[int]=None) -> np.ndarray:
+    @decoratorRescale
+    def sample(self, nt: int, nx:int = None, problem: Problem = None, random_seed: Optional[int] = None) -> np.ndarray:
         '''
         Generate a Latin-hypercube design
         
@@ -212,4 +200,12 @@ class LHS(Sampler):
         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
+        
         return self._generate(nt, nx)

{UQPyL-2.0.5 → UQPyL-2.0.7}/UQPyL/DoE/morris_sequence.py

@@ -1,6 +1,8 @@
 import numpy as np
+from typing import Optional
 
-from .sampler_ABC import Sampler
+from .samplerABC import Sampler, decoratorRescale
+from ..problems import ProblemABC as Problem
 
 class Morris_Sequence(Sampler):
     '''
@@ -24,8 +26,8 @@ class Morris_Sequence(Sampler):
         
         super().__init__()
         self.num_levels=num_levels
-    
-    def _generate(self, nt: int, nx: int) -> np.ndarray:
+        
+    def _generate(self, nt: int, nx: int):
         '''
         Generate a shape of (nt*nx, nx) sample for FAST
         
@@ -40,17 +42,33 @@ class Morris_Sequence(Sampler):
             An n-by-samples design matrix that has been normalized so factor values
             are uniformly spaced between zero and one.
         '''      
-        X=np.zeros((nt*(nx+1), nx))
+        xInit=np.zeros((nt*(nx+1), nx))
         
         for i in range(nt):
-            X[i*(nx+1):(i+1)*(nx+1), :]=self._generate_trajectory(nx)
+            xInit[i*(nx+1):(i+1)*(nx+1), :]=self._generate_trajectory(nx)
         
-        return X
+        return xInit
     
-    def _generate_trajectory(self, nx: int) -> np.ndarray:
-        '''
+    @decoratorRescale
+    def sample(self, nt: int, nx: Optional[int]=None, problem: Optional[Problem]=None, random_seed: Optional[int] = None):
+        
+        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._generate(nt, nx)
+        
+    def _generate_trajectory(self, nx: int):
         
-        '''
         delta=self.num_levels/(2*(self.num_levels-1))
         
         B=np.tril(np.ones([nx + 1, nx], dtype=int), -1)