UQPyL 2.0.5__tar.gz → 2.0.6__tar.gz

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

@@ -1,10 +1,9 @@
 Metadata-Version: 2.1
 Name: UQPyL
-Version: 2.0.5
+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.5 → 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.5 → 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.5 → 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.5 → 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.5 → UQPyL-2.0.6}/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
 
@@ -151,6 +151,7 @@ class LHS(Sampler):
         #initial random state
         self.random_state=np.random.RandomState()
         
+        
     def _generate(self, nt: int, nx: int) -> np.ndarray:
         '''
         Generate a Latin-hypercube design
@@ -168,7 +169,7 @@ class LHS(Sampler):
         '''
         
         if self.problem is not None:
-            if(self.problem.n_input!=nx):
+            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:
@@ -177,16 +178,13 @@ class LHS(Sampler):
         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
     
+    @decoratorRescale
     def sample(self, nt: int, nx:int, random_seed: Optional[int]=None) -> np.ndarray:
         '''
         Generate a Latin-hypercube design

{UQPyL-2.0.5 → 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.5 → 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.5/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.5 → 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.5 → UQPyL-2.0.6}/UQPyL/__init__.py

@@ -1,6 +1,6 @@
 from . import problems, surrogates, optimization, sensibility, DoE, utility
 
-__version__ = "2.0.5"
+__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

UQPyL-2.0.6/UQPyL/optimization/algorithmABC.py

@@ -0,0 +1,119 @@
+import numpy as np
+import abc
+import functools
+
+from .population import Population
+from .result import Result
+from ..DoE import LHS
+from ..utility import Verbose
+
+class Algorithm(metaclass=abc.ABCMeta):
+    """
+    This is a baseclass for algorithms
+    """
+    def __init__(self, maxFEs=None, maxIterTimes=None, maxTolerateTimes=None, tolerate=1e-6, 
+                 verbose=True, verboseFreq=10, logFlag=True, saveFlag=False):
+        
+        self.setting=Setting()
+        self.result=Result(self)
+        
+        self.problem=None
+        self.maxFEs=maxFEs
+        self.maxIter=maxIterTimes
+        self.maxTolerateTimes=maxTolerateTimes
+        self.tolerate=tolerate
+        
+        self.verbose=verbose
+        self.verboseFreq=verboseFreq
+        self.logFlag=logFlag
+        self.saveFlag=saveFlag
+        
+    def initialize(self, nInit):
+        
+        lhs=LHS('classic', problem=self.problem)
+        xInit=lhs.sample(nInit, self.problem.nInput)
+        pop=Population(xInit)
+        self.evaluate(pop); 
+            
+        return pop
+    
+    @staticmethod
+    def initializeRun(func):
+        
+        @functools.wraps(func)
+        def wrapper(obj, *args, **kwargs):
+            obj.result=Result(obj)
+            res=func(obj, *args, **kwargs)
+            return res
+        return wrapper
+ 
+    @abc.abstractmethod
+    def run(self, problem, xInit=None, yInit=None):
+        pass
+    
+    def evaluate(self, pop):
+        
+        pop.evaluate(self.problem)
+        self.FEs+=pop.nPop
+    
+    def checkTermination(self):
+        
+        if self.FEs<=self.maxFEs:
+            if self.maxIter is None or self.iters<=self.maxIter:
+                if self.maxTolerateTimes is None or self.tolerateTimes<=self.maxTolerateTimes:
+                    self.iters+=1
+                    return True
+                
+        return False
+    
+    def setProblem(self, problem):
+        self.problem=problem
+    
+    def saveResult(self):
+        if self.problem.nOutput>1:
+            self.result.save(type=1)
+        else:
+            self.result.save()
+    
+    @Verbose.decoratorRecord
+    def record(self, pop):
+        
+        if self.problem.nOutput==1:
+            self.result.update(pop, self.FEs, self.iters)
+        else:
+            self.result.update(pop, self.FEs, self.iters, 1)
+            
+    def setParameters(self, key, value):
+        
+        self.setting.setParameter(key, value)
+    
+    def getParaValue(self, *args):
+        
+        return self.setting.getParaValue(*args)
+    
+class Setting():
+    """
+    Save the parameter setting of the algorithm
+    """
+    
+    def __init__(self):
+        self.keys=[]
+        self.values=[]
+        self.dicts={}
+    
+    def setParameter(self, key, value):
+        
+        self.dicts[key]=value
+        self.keys.append(key)
+        self.values.append(value)
+    
+    def getParaValue(self, *args):
+        
+        values=[]
+        for arg in args:
+            values.append(self.dicts[arg])
+        
+        if len(args)>1:
+            return tuple(values)
+        else:
+            return values[0]

UQPyL-2.0.6/UQPyL/optimization/mathematics/__init__.py

@@ -0,0 +1,2 @@
+from .adam import Adam
+from .boxmin import Boxmin

{UQPyL-2.0.5/UQPyL/optimization → UQPyL-2.0.6/UQPyL/optimization/mathematics}/boxmin.py

@@ -1,26 +1,39 @@
 import numpy as np
 from typing import Callable
 
-class Boxmin():
+from ..algorithmABC import Algorithm
+from ...problems import ProblemABC as Problem
+class Boxmin(Algorithm):
     type='MP' #mathematical programming
-    def __init__(self, initialPos: np.ndarray, ub: np.ndarray, lb: np.ndarray) -> None:
-        self.initalPos=initialPos
-        self.ub=ub
-        self.lb=lb
-        self.nv=0
+    def __init__(self) -> None:
+        
+        super().__init__()
+        
     ###################################Interface Function#################################
-    def run(self, func: Callable):
-        self.func=func
+    def run(self, problem: Problem, xInit=None):
+        self.ub=problem.ub.ravel()
+        self.lb=problem.lb.ravel()
+        if xInit is None:
+            xInit=np.random.uniform(problem.lb.ravel(), problem.ub.ravel(), problem.nInput)
+            
+        
+        self.func=problem.evaluate
+        self.nv=0; 
+        
+        self._start(xInit)
         
-        self._start()
         p=self.initalPos.size
+        kmax = 2 if p <= 2 else min(p, 4)
         
-        for _ in range(np.minimum(p,4)):
+        for _ in range(kmax):
             pos_copy=self.pos.copy()
             self._explore()
             self._move(pos_copy)
-            
-        return self.pos, self.f
+        
+        self.result.bestDec=self.pos
+        self.result.bestObj=self.f
+        
+        return self.result
     #######################################Private Function################################
     def _move(self, pos_old: np.ndarray):
         
@@ -82,14 +95,14 @@ class Boxmin():
         self.pos=pos
         self.f=f
         
-    def _start(self):
+    def _start(self, xInit):
         
-        p = self.initalPos.size
-        D = 2 ** (np.arange(1, p + 1).reshape(-1, 1) / (p + 2))
+        self.initalPos=xInit
         
-        f = self.func(self.initalPos)
+        p = xInit.size
+        D = 2 ** (np.arange(1, p + 1).reshape(-1, 1) / (p + 2))
         
         self.nv=1
         self.D=D
-        self.f=f
+        self.f=self.func(xInit)
         self.pos=self.initalPos

UQPyL-2.0.6/UQPyL/optimization/metric/__init__.py

@@ -0,0 +1,3 @@
+from .hv import HV
+from .igd import IGD
+from .gd import GD

UQPyL-2.0.6/UQPyL/optimization/metric/gd.py

@@ -0,0 +1,12 @@
+import numpy as np
+from scipy.spatial.distance import cdist
+
+def GD(pop, optimum):
+    
+    distances = cdist(pop, optimum, metric='euclidean')
+    
+    minDist=np.min(distances, axis=1)
+    
+    gd=np.mean(minDist)
+    
+    return gd