UQPyL 2.0.4__tar.gz → 2.0.6__tar.gz

{UQPyL-2.0.4 → UQPyL-2.0.6}/PKG-INFO

@@ -1,10 +1,9 @@
 Metadata-Version: 2.1
 Name: UQPyL
-Version: 2.0.4
+Version: 2.0.6
 Summary: A python package for parameter uncertainty quantification and optimization
 Author: wmtSky
 Author-email: wmtSky <wmtsky@hhu.edu.cn>
-Classifier: Programming Language :: Python :: 3.6
 Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
@@ -46,13 +45,10 @@ The **main characteristics** of UQPyL includes:
 - Regional Sensitivity Analysis (RSA)
 
 **Optimization Algorithms:** (* indicates the use of surrogate models)
-- SCE-UA
-- Genetic Algorithm (GA)
-- Non-dominated Sorting Genetic Algorithm-II (NSGA-II)
-- AMSMO*
-- MO_ASMO*
-- MASTO* #TODO
-- AMSMO* #TODO
+- Single Objective Optimization: SCE-UA, ML-SCE-UA, GA, CSA, PSO, DE, ABC, ASMO*, EGO*
+- Multi Objective Optimization: MOEA/D, NSGA-II, RVEA, MOASMO*
+
+Noted: It is still being updated, and if you need other algorithms, please contact me.
 
 **Surrogate Models:**
 - Full connect neural network (FNN)
@@ -81,6 +77,70 @@ git clone https://github.com/smasky/UQPyL.git
 pip install . 
 ```
 
+# Quick Start
+For users, we should define the problem you want to solved firstly. The problem usually contains three important properties:
+a. func (the mapping from X to Y); b. the dimensions of decisions and outputs; c. the bound of decisions (ub, lb).
+
+For benchmark problems, we can import them from **UQPyL.problems** and instantiation:
+
+```
+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)
+```
+
+For practical problems, we should define the evaluation function in addition, like:
+```
+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")
+```
+**Please noted that**, the func need receive the matrix of X and return the matrix of Y. And keep columns equal to dimensions and rows equal to samples.
+
+After defining problem you solved, you can use any methods in UQPyL.
+**Sensibility:**
+```
+from UQPyL.sensibility import Sobol
+
+sobol=Sobol() #instantiation and set hyper-parameters
+sobol.analyze(problem)
+```
+
+**Optimization:**
+```
+from UQPyL.optimization.single_objective import SCE_UA
+
+sce=SCE_UA()
+res=sce.run(problem)
+bestDec=res.bestDec; bestObj=res.bestObj
+```
+
+**Surrogate:**
+```
+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)
+```
+
+The above is a quick start. For more advanced usage, please refer to the documentation (#TODO).
 
 # Call for Contributions
 We appreciate and welcome contributions. Because, we only set up standard workflows here. More advanced quantification methods and optimization algorithms are waited for pulling to this project.

{UQPyL-2.0.4 → UQPyL-2.0.6}/README.md

@@ -28,13 +28,10 @@ The **main characteristics** of UQPyL includes:
 - Regional Sensitivity Analysis (RSA)
 
 **Optimization Algorithms:** (* indicates the use of surrogate models)
-- SCE-UA
-- Genetic Algorithm (GA)
-- Non-dominated Sorting Genetic Algorithm-II (NSGA-II)
-- AMSMO*
-- MO_ASMO*
-- MASTO* #TODO
-- AMSMO* #TODO
+- Single Objective Optimization: SCE-UA, ML-SCE-UA, GA, CSA, PSO, DE, ABC, ASMO*, EGO*
+- Multi Objective Optimization: MOEA/D, NSGA-II, RVEA, MOASMO*
+
+Noted: It is still being updated, and if you need other algorithms, please contact me.
 
 **Surrogate Models:**
 - Full connect neural network (FNN)
@@ -63,6 +60,70 @@ git clone https://github.com/smasky/UQPyL.git
 pip install . 
 ```
 
+# Quick Start
+For users, we should define the problem you want to solved firstly. The problem usually contains three important properties:
+a. func (the mapping from X to Y); b. the dimensions of decisions and outputs; c. the bound of decisions (ub, lb).
+
+For benchmark problems, we can import them from **UQPyL.problems** and instantiation:
+
+```
+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)
+```
+
+For practical problems, we should define the evaluation function in addition, like:
+```
+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")
+```
+**Please noted that**, the func need receive the matrix of X and return the matrix of Y. And keep columns equal to dimensions and rows equal to samples.
+
+After defining problem you solved, you can use any methods in UQPyL.
+**Sensibility:**
+```
+from UQPyL.sensibility import Sobol
+
+sobol=Sobol() #instantiation and set hyper-parameters
+sobol.analyze(problem)
+```
+
+**Optimization:**
+```
+from UQPyL.optimization.single_objective import SCE_UA
+
+sce=SCE_UA()
+res=sce.run(problem)
+bestDec=res.bestDec; bestObj=res.bestObj
+```
+
+**Surrogate:**
+```
+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)
+```
+
+The above is a quick start. For more advanced usage, please refer to the documentation (#TODO).
 
 # Call for Contributions
 We appreciate and welcome contributions. Because, we only set up standard workflows here. More advanced quantification methods and optimization algorithms are waited for pulling to this project.

{UQPyL-2.0.4 → UQPyL-2.0.6}/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.4 → UQPyL-2.0.6}/UQPyL/DoE/fast_sequence.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-from .sampler_ABC import Sampler
+from .samplerABC import Sampler
 
 class FAST_Sequence(Sampler):
     '''
@@ -24,7 +24,7 @@ class FAST_Sequence(Sampler):
         
         super().__init__()
         self.M=M
-        
+    
     def _generate(self, nt: int, nx: int) -> np.ndarray:
         '''
         Generate a shape of (nt*nx, nx) sample for FAST
@@ -55,7 +55,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,9 +66,9 @@ 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:
         

{UQPyL-2.0.4 → UQPyL-2.0.6}/UQPyL/DoE/full_fact.py

@@ -2,7 +2,7 @@ import numpy as np
 from typing import Union
 from itertools import product
 
-from .sampler_ABC import Sampler
+from .samplerABC import Sampler
 
 class FFD(Sampler):
     '''

UQPyL-2.0.6/UQPyL/DoE/lhs.py

@@ -0,0 +1,213 @@
+import numpy as np
+from typing import Literal, Optional
+from scipy.spatial.distance import pdist
+
+from ..problems import ProblemABC as Problem
+
+from .samplerABC import Sampler, decoratorRescale
+
+# from ._lhs import _lhs_classic, _lhs_centered, _lhs_correlate, _lhs_maximin, _lhs_centered_maximin
+
+
+
+def _lhs_classic(nt: int, nx: int, random_state=None) -> np.ndarray:
+    # Generate the intervals
+    if random_state is None:
+        random_state=np.random.RandomState()
+    cut = np.linspace(0, 1, nt + 1)    
+    
+    # Fill points uniformly in each interval
+    u = random_state.rand(nt, nx)
+    a = cut[:nt]
+    b = cut[1:nt + 1]
+    rdpoints = np.zeros_like(u)
+    for j in range(nx):
+        rdpoints[:, j] = u[:, j]*(b-a) + a
+    
+    # Make the random pairings
+    H = np.zeros_like(rdpoints)
+    for j in range(nx):
+        order = random_state.permutation(range(nt))
+        H[:, j] = rdpoints[order, j]
+    
+    return H
+    
+################################################################################
+
+def _lhs_centered(nt: int, nx: int, random_state=None) -> np.ndarray:
+    
+    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)
+    a = cut[:nt]
+    b = cut[1:nt + 1]
+    _center = (a + b)/2
+    
+    # Make the random pairings
+    H = np.zeros_like(u)
+    for j in range(nx):
+        H[:, j] = random_state.permutation(_center)
+    
+    return H
+    
+################################################################################
+
+def _lhs_maximin(nt: int, nx: int, iterations: int, random_state=None)-> np.ndarray:
+    
+    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)
+
+        d = pdist(H_candidate,'euclidean')
+        if maxdist<np.min(d):
+            maxdist = np.min(d)
+            H = H_candidate.copy()
+    
+    return H
+
+def _lhs_centered_maximin(nt: int, nx: int, iterations: int, random_state=None)-> np.ndarray:
+    
+    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)
+        d = pdist(H_candidate,'euclidean')
+        if maxdist<np.min(d):
+            maxdist = np.min(d)
+            H = H_candidate.copy()
+    
+    return H
+################################################################################
+
+def _lhs_correlate(nt: int, nx: int, iterations: int, random_state=None) -> np.ndarray:
+    
+    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)
+        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])))
+            print('new candidate solution found with max,abs corrcoef = {}'.format(mincorr))
+            H = H_candidate.copy()
+
+    return H
+
+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):
+    '''
+    Latin-hypercube design
+    
+    Parameters:
+    criterion : str
+        Allowable values are "classic", "center", "maximin", "center_maximin", 
+        and "correlation". (Default: classic)
+        
+    iterations : int
+        The number of iterations in the maximin, center_maximin and correlations methods
+        (Default: 5).
+    
+    problem : problem
+        if the problem is provided, the bounds of the problem will be used to generate the samples
+    
+    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):
+        
+        self.criterion=criterion
+        self.iterations=iterations
+        self.problem=problem
+        
+        #initial random state
+        self.random_state=np.random.RandomState()
+        
+        
+    def _generate(self, nt: int, nx: int) -> np.ndarray:
+        '''
+        Generate a Latin-hypercube design
+        
+        Parameters 
+        nt: int
+            the number of sampled points
+        nx: int
+            the input dimensions of sampled points
+            
+        Returns:
+        H: 2d-array
+            An n-by-samples design matrix that has been normalized so factor values
+            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()))
+        
+        Sampling_method=LHS_METHOD[self.criterion]
+        
+        if self.criterion in ['maximin', 'center_maximin', 'correlation']:
+            xInit=Sampling_method(nt, nx, self.iterations, self.random_state)
+        else:
+            xInit=Sampling_method(nt, nx, self.random_state)
+        
+        return xInit
+    
+    @decoratorRescale
+    def sample(self, nt: int, nx:int, random_seed: Optional[int]=None) -> np.ndarray:
+        '''
+        Generate a Latin-hypercube design
+        
+        Parameters 
+        nt: int
+            the number of sampled points
+            
+        nx: int
+            the input dimensions of sampled points
+            
+        random_seed: int
+            the random seed for the random number generator
+            
+        Returns:
+        H: 2d-array
+            An n-by-samples design matrix that has been normalized so factor values
+            are uniformly spaced 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()
+        
+        return self._generate(nt, nx)

{UQPyL-2.0.4 → UQPyL-2.0.6}/UQPyL/DoE/morris_sequence.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-from .sampler_ABC import Sampler
+from .samplerABC import Sampler
 
 class Morris_Sequence(Sampler):
     '''
@@ -24,7 +24,7 @@ class Morris_Sequence(Sampler):
         
         super().__init__()
         self.num_levels=num_levels
-    
+        
     def _generate(self, nt: int, nx: int) -> np.ndarray:
         '''
         Generate a shape of (nt*nx, nx) sample for FAST
@@ -40,12 +40,12 @@ 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:
         '''

{UQPyL-2.0.4 → UQPyL-2.0.6}/UQPyL/DoE/random.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-from .sampler_ABC import Sampler
+from .samplerABC import Sampler
 
 class Random(Sampler):
     '''
@@ -13,7 +13,6 @@ class Random(Sampler):
         >>> random=RANDOM()
         >>> random(10,10) or random.sample(10,10)
     '''
-    
     def _generate(self,nt: int, nx: int) -> np.ndarray:
         
         H=np.random.random((nt,nx))

UQPyL-2.0.4/UQPyL/DoE/sampler_ABC.py → UQPyL-2.0.6/UQPyL/DoE/samplerABC.py

@@ -1,17 +1,28 @@
 import abc
 import numpy as np
 
+def decoratorRescale(func):
+    def wrapper(self, *args, **kwargs):
+        result=func(self, *args, **kwargs)
+        if self.problem is not None:
+            return self.problem._unit_X_transform_to_bound(result)
+        else:
+            return result
+    return wrapper
 class Sampler(metaclass=abc.ABCMeta):
     def __init__(self):
         pass
-    
     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)
     
-    @abc.abstractmethod
+    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) -> np.ndarray:
         '''
         nt: the number of sampled points
@@ -22,5 +33,4 @@ class Sampler(metaclass=abc.ABCMeta):
         
         '''
         pass
-    
-    
+

{UQPyL-2.0.4 → UQPyL-2.0.6}/UQPyL/DoE/sobol_sequence.py

@@ -1,7 +1,7 @@
 import numpy as np
 from scipy.stats.qmc import Sobol
 
-from .sampler_ABC import Sampler
+from .samplerABC import Sampler
 
 class Sobol_Sequence(Sampler):
     '''
@@ -26,16 +26,16 @@ class Sobol_Sequence(Sampler):
         
         self.scramble=scramble
         self.skip_value=skip_value
-    
+        
     def _generate(self, nt: int, nx: int) -> np.ndarray:
         '''
         generate the shape of (nt*nx, nx) and numpy array Sobol sequence. 
         '''
         
         sampler=Sobol(d=nx, scramble=self.scramble)
-        X=sampler.random(nt+self.skip_value)
+        xInit=sampler.random(nt+self.skip_value)
         
-        return X[self.skip_value:, :]
+        return xInit[self.skip_value:, :]
     
     def sample(self, nt: int, nx: int) -> np.ndarray:
         '''
@@ -52,11 +52,4 @@ class Sobol_Sequence(Sampler):
             An n-by-samples design matrix that has been normalized so factor values
             are uniformly spaced between zero and one.  
         '''
-        return self._generate(nt, nx)
-
-        
-        
-        
-        
-            
-        
+        return self._generate(nt, nx)   

{UQPyL-2.0.4 → UQPyL-2.0.6}/UQPyL/__init__.py

@@ -1,6 +1,6 @@
 from . import problems, surrogates, optimization, sensibility, DoE, utility
 
-__version__ = "2.0.4"
+__version__ = "2.0.6"
 __author__ = "wmtSky"
 
 __all__=[

UQPyL-2.0.6/UQPyL/optimization/__init__.py

@@ -0,0 +1,4 @@
+from .single_objective import GA, PSO, CSA, DE, SCE_UA, ML_SCE_UA, ASMO, ABC, Binary_GA, EGO
+from .multi_objective import NSGAII, MOEAD, MOASMO, RVEA
+from .mathematics import Boxmin, Adam
+from .algorithmABC import Algorithm