UQPyL 2.0.6__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.6 → UQPyL-2.0.7}/UQPyL/DoE/fast_sequence.py

@@ -1,7 +1,8 @@
 import numpy as np
+from typing import Union, Optional
 
-from .samplerABC 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:
+    def _generate(self, nt: int, nx: int):
         '''
         Generate a shape of (nt*nx, nx) sample for FAST
         
@@ -70,7 +68,21 @@ class FAST_Sequence(Sampler):
         
         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.6 → UQPyL-2.0.7}/UQPyL/DoE/lhs.py

@@ -136,23 +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
         
@@ -168,10 +162,6 @@ class LHS(Sampler):
             are uniformly spaced between zero and one.
         '''
         
-        if self.problem is not None:
-            if(self.problem.nInput!=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()))
         
@@ -185,7 +175,7 @@ class LHS(Sampler):
         return xInit
     
     @decoratorRescale
-    def sample(self, nt: int, nx:int, random_seed: Optional[int]=None) -> np.ndarray:
+    def sample(self, nt: int, nx:int = None, problem: Problem = None, random_seed: Optional[int] = None) -> np.ndarray:
         '''
         Generate a Latin-hypercube design
         
@@ -210,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.6 → UQPyL-2.0.7}/UQPyL/DoE/morris_sequence.py

@@ -1,6 +1,8 @@
 import numpy as np
+from typing import Optional
 
-from .samplerABC import Sampler
+from .samplerABC import Sampler, decoratorRescale
+from ..problems import ProblemABC as Problem
 
 class Morris_Sequence(Sampler):
     '''
@@ -25,7 +27,7 @@ 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
         
@@ -47,10 +49,26 @@ class Morris_Sequence(Sampler):
         
         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)

UQPyL-2.0.7/UQPyL/DoE/random.py

@@ -0,0 +1,43 @@
+import numpy as np
+from typing import Optional
+
+from .samplerABC import Sampler, decoratorRescale
+from ..problems import ProblemABC as Problem
+
+class Random(Sampler):
+    '''
+    Random Design
+    
+    Method:
+    __call__ or sample: Generate a random design
+    
+    Examples:
+        >>> random=RANDOM()
+        >>> random(10,10) or random.sample(10,10)
+    '''
+    def _generate(self,nt: int, nx: int):
+        
+        H=np.random.random((nt,nx))
+        
+        return H
+    
+    @decoratorRescale
+    def sample(self, nt: int, nx: Optional[int] = None, problem: Optional[Problem] = None, random_seed: Optional[int] = None):
+        '''
+        Generate a sample with random values 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(nt, nx)

UQPyL-2.0.7/UQPyL/DoE/samplerABC.py

@@ -0,0 +1,50 @@
+import abc
+import numpy as np
+
+from ..problems import ProblemABC as Problem
+
+def decoratorRescale(func):
+    def wrapper(self, *args, **kwargs):
+        result=func(self, *args, **kwargs)
+        
+        for arg in args:
+            if isinstance(arg, Problem):
+                return arg._unit_X_transform_to_bound(result)
+        
+        for key, value in kwargs.items():
+            if isinstance(value, Problem):
+                return value._unit_X_transform_to_bound(result)
+
+        return result
+    return wrapper
+class Sampler(metaclass=abc.ABCMeta):
+    
+    def __init__(self):
+        
+        self.random_state=np.random.RandomState()
+    
+    #Abandon
+    # def __call__(self, nt:int, nx: int) -> np.ndarray:
+    #     return self._generate(nt, nx)
+    
+    # def sample(self, nt:int, nx:int) -> np.ndarray:
+    #     return self._generate(nt, nx)
+    
+    # def rescale_to_problem(self, xInit:np.ndarray):
+        
+    #     if self.problem is not None:
+    #         xInit=self.problem._unit_xInit_transform_to_bound(xInit)
+            
+    #     return xInit
+    
+    def _generate(self, nt: int, nx: int):
+        '''
+        nt: the number of sampled points
+        nx: the dimensions of decision variables
+        
+        return:
+            ndarry[nt,nx]
+        
+        '''
+        pass
+