UQPyL 2.0.3__tar.gz → 2.0.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: UQPyL
-Version: 2.0.3
+Version: 2.0.5
 Summary: A python package for parameter uncertainty quantification and optimization
 Author: wmtSky
 Author-email: wmtSky <wmtsky@hhu.edu.cn>

UQPyL-2.0.5/UQPyL/DoE/lhs.py

@@ -0,0 +1,215 @@
+import numpy as np
+from typing import Literal, Optional
+from scipy.spatial.distance import pdist
+
+from ..problems import Problem
+
+from .sampler_ABC import Sampler
+
+# 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.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)
+        else:
+            X=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
+    
+    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.3 → UQPyL-2.0.5}/UQPyL/__init__.py

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

{UQPyL-2.0.3 → UQPyL-2.0.5}/UQPyL/optimization/asmo.py

@@ -3,6 +3,7 @@ from tqdm import tqdm
 from typing import Optional
 
 from .sce_ua import SCE_UA
+from .pso import PSO
 from ..DoE import LHS
 from ..problems import Problem
 from ..surrogates import Surrogate
@@ -46,11 +47,11 @@ class ASMO():
         #construct optimization problem to combine surrogate and algorithm
         self.subProblem=Problem(self.surrogate.predict, self.n_input, 1, self.ub, self.lb)
         
-    def run(self,maxFE=1000, Tolerate=0.001, maxTolerateTime=50, oneStep=False):
+    def run(self, oneStep=False):
         '''
         main procedure
         ''' 
-        show_process=tqdm(total=maxFE)
+        show_process=tqdm(total=self.maxFE)
         FE=0
         TT=0
         n_input=self.n_input
@@ -65,8 +66,8 @@ class ASMO():
         XPop=self.x_init
         YPop=self.y_init
         
-        fe=YPop.shape[0]
-        show_process.update(fe)
+        FE=YPop.shape[0]
+        show_process.update(FE)
         ###
         idx=np.argsort(YPop, axis=0)
         BestY=YPop[idx[0,0],0]
@@ -78,11 +79,11 @@ class ASMO():
         # history_BestY.append(BestY)
         
         if (oneStep==False):
-            while fe<self.maxFE and TT<self.maxTolerateTime:
+            while FE<self.maxFE and TT<self.maxTolerateTime:
                 show_process.update(1)
                 # Build surrogate model
                 self.surrogate.fit(XPop, YPop)
-                res=SCE_UA(self.subProblem).run()
+                res=PSO(self.subProblem).run()
                 BestX_SM=res['best_dec']
                 
                 TempY=self.evaluate(BestX_SM)
@@ -91,8 +92,10 @@ class ASMO():
                 YPop=np.vstack((YPop,TempY))
                 
                 if TempY[0,0]<BestY:
-                    BestY=np.copy(TempY)
+                    BestY=np.copy(TempY[0,0])
                     BestX=np.copy(BestX_SM)
+                    history_best_decs[FE]=BestX
+                    history_best_objs[FE]=BestY
         else:
             self.surrogate.fit(XPop, YPop)
             res=SCE_UA(self.subProblem).run()
@@ -100,17 +103,17 @@ class ASMO():
             
             TempY=self.evaluate(BestX_SM)
             
-            fe+=1
+            FE+=1
             XPop=np.vstack((XPop,BestX_SM))
             YPop=np.vstack((YPop,TempY))
             
             if TempY[0,0]<BestY:
                 BestY=np.copy(TempY)
                 BestX=np.copy(BestX_SM)
-                history_best_decs[fe]=BestX
-                history_best_objs[fe]=BestY
+                history_best_decs[FE]=BestX
+                history_best_objs[FE]=BestY
         
-        Result={'best_dec':BestX, 'best_obj':BestY, 'history_best_decs': history_best_decs, 'history_best_objs':history_best_objs ,'FE':fe}
+        Result={'best_dec':BestX, 'best_obj':BestY, 'history_best_decs': history_best_decs, 'history_best_objs':history_best_objs ,'FEs':FE}
         
         return Result
             

{UQPyL-2.0.3 → UQPyL-2.0.5}/UQPyL/problems/single_Benchmarks.py

@@ -59,9 +59,11 @@ class Schwefel_2_22(ProblemABC):
         
         super().__init__(n_input,1,ub,lb,disc_var,cont_var)
         
-    def evaluate(self, X: np.ndarray) -> np.ndarray:
+    def evaluate(self, X: np.ndarray, unit: bool=False) -> np.ndarray:
         
-        X=self._unit_X_transform_to_bound(np.atleast_2d(X))
+        X=self._check_2d(X)
+        if unit:
+            X=self._unit_X_transform_to_bound(np.atleast_2d(X))
         F=np.sum(np.abs(X),axis=1).reshape(-1,1)+np.prod(np.abs(X),axis=1).reshape(-1,1)
         return F
 
@@ -85,10 +87,12 @@ class Schwefel_1_22(ProblemABC):
         
         super().__init__(n_input,1,ub,lb,disc_var,cont_var)
         
-    def evaluate(self, X: np.ndarray) -> np.ndarray:
+    def evaluate(self, X: np.ndarray, unit: bool=False) -> np.ndarray:
         
         F=0
-        X=self._unit_X_transform_to_bound(np.atleast_2d(X))
+        X=self._check_2d(X)
+        if unit:
+            X=self._unit_X_transform_to_bound(np.atleast_2d(X))
         X=X**2
         for d in range(self.n_input):
             F+=np.sum(X[:,:d],axis=1).reshape(-1,1)
@@ -113,9 +117,11 @@ class Schwefel_2_21(ProblemABC):
         
         super().__init__(n_input,1,ub,lb,disc_var,cont_var)
         
-    def evaluate(self, X: np.ndarray) -> np.ndarray:
+    def evaluate(self, X: np.ndarray, unit: bool=False) -> np.ndarray:
         
-        X=self._unit_X_transform_to_bound(np.atleast_2d(X))
+        X=self._check_2d(X)
+        if unit:
+            X=self._unit_X_transform_to_bound(np.atleast_2d(X))
         X=np.abs(X)
         F=np.max(X,axis=1).reshape(-1,1)
         return F
@@ -139,9 +145,11 @@ class Rosenbrock(ProblemABC):
         
         super().__init__(n_input,1,ub,lb,disc_var,cont_var)
         
-    def evaluate(self, X: np.ndarray) -> np.ndarray:
+    def evaluate(self, X: np.ndarray, unit: bool=False) -> np.ndarray:
         
-        X=self._unit_X_transform_to_bound(np.atleast_2d(X))    
+        X=self._check_2d(X)
+        if unit:
+            X=self._unit_X_transform_to_bound(np.atleast_2d(X))    
         Temp1=100*np.square(X[:,1:]-np.square(X[:,:-1]))
         Temp2=np.square(X[:,:-1]-1)
         F=np.sum(Temp1+Temp2,axis=1).reshape(-1,1)
@@ -166,9 +174,11 @@ class Step(ProblemABC):
         
         super().__init__(n_input,1,ub,lb,disc_var,cont_var)
         
-    def evaluate(self, X: np.ndarray) -> np.ndarray:
+    def evaluate(self, X: np.ndarray, unit: bool=False) -> np.ndarray:
         
-        X=self._unit_X_transform_to_bound(np.atleast_2d(X))     
+        X=self._check_2d(X)
+        if unit:
+            X=self._unit_X_transform_to_bound(np.atleast_2d(X))     
         F=np.sum(np.square(np.floor(X)+0.5),axis=1).reshape(-1,1)
         
         return F
@@ -192,9 +202,11 @@ class Quartic(ProblemABC):
         
         super().__init__(n_input,1,ub,lb,disc_var,cont_var)
         
-    def evaluate(self, X: np.ndarray) -> np.ndarray:
+    def evaluate(self, X: np.ndarray, unit: bool=False) -> np.ndarray:
         
-        X=self._unit_X_transform_to_bound(np.atleast_2d(X))  
+        X=self._check_2d(X)
+        if unit:
+            X=self._unit_X_transform_to_bound(np.atleast_2d(X))  
         Temp=np.linspace(1,self.n_input,self.n_input)*np.power(X,4)
         F=np.sum(Temp,axis=1).reshape(-1,1)+np.random.random((Temp.shape[0],1))          
         return F
@@ -218,9 +230,11 @@ class Schwefel_2_26(ProblemABC):
         
         super().__init__(n_input,1,ub,lb,disc_var,cont_var)
         
-    def evaluate(self, X: np.ndarray) -> np.ndarray:
+    def evaluate(self, X: np.ndarray, unit: bool=False) -> np.ndarray:
         
-        X=self._unit_X_transform_to_bound(np.atleast_2d(X)) 
+        X=self._check_2d(X)
+        if unit:
+            X=self._unit_X_transform_to_bound(np.atleast_2d(X)) 
         Temp=np.sin(np.sqrt(np.abs(X)))*X
         F=np.sum(Temp,axis=1).reshape(-1,1)*-1         
         return F
@@ -244,9 +258,11 @@ class Rastrigin(ProblemABC):
         
         super().__init__(n_input,1,ub,lb,disc_var,cont_var)
         
-    def evaluate(self, X: np.ndarray) -> np.ndarray:
+    def evaluate(self, X: np.ndarray, unit: bool=False) -> np.ndarray:
         
-        X=self._unit_X_transform_to_bound(np.atleast_2d(X)) 
+        X=self._check_2d(X)
+        if unit:
+            X=self._unit_X_transform_to_bound(np.atleast_2d(X))
         F=np.sum(np.square(X)-10*np.cos(2*np.pi*X)+10,axis=1).reshape(-1,1)
         return F
 
@@ -270,9 +286,11 @@ class Ackley(ProblemABC):
         
         super().__init__(n_input,1,ub,lb,disc_var,cont_var)
     
-    def evaluate(self, X: np.ndarray) -> np.ndarray:
+    def evaluate(self, X: np.ndarray, unit: bool=False) -> np.ndarray:
         
-        X=self._unit_X_transform_to_bound(np.atleast_2d(X)) 
+        X=self._check_2d(X)
+        if unit:
+            X=self._unit_X_transform_to_bound(np.atleast_2d(X)) 
         Temp1=np.exp(np.sqrt(np.sum(np.square(X),axis=1)/self.n_input)*-0.2)*-20
         Temp2=np.exp(np.sum(np.cos(2*np.pi*X),axis=1)/self.n_input)*-1+20+np.e  
         F=(Temp1+Temp2).reshape(-1,1)
@@ -297,9 +315,11 @@ class Griewank(ProblemABC):
         
         super().__init__(n_input,1,ub,lb,disc_var,cont_var)
     
-    def evaluate(self, X: np.ndarray) -> np.ndarray:
+    def evaluate(self, X: np.ndarray, unit: bool=False) -> np.ndarray:
         
-        X=self._unit_X_transform_to_bound(np.atleast_2d(X)) 
+        X=self._check_2d(X)
+        if unit:
+            X=self._unit_X_transform_to_bound(np.atleast_2d(X)) 
         I=np.sqrt(np.atleast_2d(np.linspace(1,self.n_input,self.n_input)))
         F=np.sum(np.square(X), axis=1).reshape(-1,1)/4000-np.prod(np.cos(X/I),axis=1).reshape(-1,1)+1     
         return F
@@ -327,9 +347,11 @@ class Trid(ProblemABC):
         
         super().__init__(n_input,1,ub,lb,disc_var,cont_var)
     
-    def evaluate(self, X: np.ndarray) -> np.ndarray:
+    def evaluate(self, X: np.ndarray, unit: bool=False) -> np.ndarray:
         
-        X=self._unit_X_transform_to_bound(np.atleast_2d(X))
+        X=self._check_2d(X)
+        if unit:
+            X=self._unit_X_transform_to_bound(np.atleast_2d(X))
         F=np.sum(np.square(X-1),axis=1).reshape(-1,1)-np.sum(X[:,1:]*X[:,:-1],axis=1).reshape(-1,1)
         return F
 
@@ -352,9 +374,11 @@ class Bent_Cigar(ProblemABC):
         
         super().__init__(n_input,1,ub,lb,disc_var,cont_var)
     
-    def evaluate(self, X: np.ndarray) -> np.ndarray:
+    def evaluate(self, X: np.ndarray, unit: bool=False) -> np.ndarray:
         
-        X=self._unit_X_transform_to_bound(np.atleast_2d(X))
+        X=self._check_2d(X)
+        if unit:
+            X=self._unit_X_transform_to_bound(np.atleast_2d(X))
         F=((X[:,0]**2)+np.sum(np.square(X[:,1:]),axis=1)*(10**6)).reshape(-1,1)
         return F
     
@@ -377,9 +401,11 @@ class Discus(ProblemABC):
         
         super().__init__(n_input,1,ub,lb,disc_var,cont_var)
     
-    def evaluate(self, X: np.ndarray) -> np.ndarray:
+    def evaluate(self, X: np.ndarray, unit: bool=False) -> np.ndarray:
         
-        X=self._unit_X_transform_to_bound(np.atleast_2d(X))
+        X=self._check_2d(X)
+        if unit:
+            X=self._unit_X_transform_to_bound(np.atleast_2d(X))
         F=(X[:,0]**2*(10**6)+np.sum(np.square(X[:,1:]),axis=1)).reshape(-1,1)
         return F
     
@@ -406,9 +432,11 @@ class Weierstrass(ProblemABC):
         
         super().__init__(n_input,1,ub,lb,disc_var,cont_var)
         
-    def evaluate(self, X: np.ndarray) -> np.ndarray:
+    def evaluate(self, X: np.ndarray, unit: bool=False) -> np.ndarray:
         
-        X=self._unit_X_transform_to_bound(np.atleast_2d(X))
+        X=self._check_2d(X)
+        if unit:
+            X=self._unit_X_transform_to_bound(np.atleast_2d(X))
         K=np.atleast_2d(np.linspace(1,self.kMax,self.kMax))
         aK=np.power(self.a,K)
         bK=np.power(self.b,K)

{UQPyL-2.0.3 → UQPyL-2.0.5}/UQPyL/sensibility/fast.py

@@ -79,7 +79,7 @@ class FAST(SA):
         '''
         n_input=self.n_input; M=self.M
         
-        if N<=4*M**2:
+        if N<4*M**2:
             raise ValueError("the number of sample must be greater than 4*M**2!")
         
         w=np.zeros(n_input)

{UQPyL-2.0.3 → UQPyL-2.0.5}/UQPyL/sensibility/morris.py

@@ -94,7 +94,7 @@ class Morris(SA):
         
         N=int(X.shape[0]/self.num_levels)
         
-        for i in range(N):
+        for i in range(num_trajectory):
             X_sub=X[i*(n_input+1):(i+1)*(n_input+1), :]
             Y_sub=Y[i*(n_input+1):(i+1)*(n_input+1), :]
 

{UQPyL-2.0.3 → UQPyL-2.0.5}/UQPyL/surrogates/gaussian_process.py

@@ -6,7 +6,7 @@ from .surrogate_ABC import Surrogate
 from .gp_kernels import RBF, Matern, Gp_Kernel
 from ..optimization import GA, Boxmin, MP_List, EA_List
 from ..utility.model_selections import RandSelect
-from ..utility.metrics import r2_score
+from ..utility.metrics import r_square
 from ..utility.scalers import Scaler
 from ..utility.polynomial_features import PolynomialFeatures
 
@@ -88,7 +88,7 @@ class GPR(Surrogate):
                 self.trainY=trainY
                 self._objfunc(theta, record=True)
                 predictY=self.predict(self.X_scaler.inverse_transform(testX))
-                return -1*r2_score(self.Y_scaler.inverse_transform(testY), predictY)
+                return -1*r_square(self.Y_scaler.inverse_transform(testY), predictY)
             bestTheta, bestObj=self.OPModel.run(objFunc)
             
         elif self.optimizer in EA_List:
@@ -103,7 +103,7 @@ class GPR(Surrogate):
                 for i, theta in enumerate(thetas):
                     self._objfunc(np.power(np.e,theta),record=True)
                     predictY=self.predict(self.X_scaler.inverse_transform(testX))
-                    objs[i]=-1*r2_score(self.Y_scaler.inverse_transform(testY), predictY)
+                    objs[i]=-1*r_square(self.Y_scaler.inverse_transform(testY), predictY)
                 return objs.reshape(-1,1)
             
             self.OPFunc=objFunc

{UQPyL-2.0.3 → UQPyL-2.0.5}/UQPyL/surrogates/kriging.py

@@ -6,7 +6,7 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 
 from .surrogate_ABC import Surrogate, Scale_T
 from .krg_kernels import Krg_Kernel
-from ..utility.metrics import r2_score
+from ..utility.metrics import r_square
 from ..optimization import Boxmin, GA, MP_List, EA_List
 from ..utility.model_selections import RandSelect
 from ..utility.scalers import Scaler
@@ -199,7 +199,7 @@ class KRG(Surrogate):
                     self._objFunc(theta,record=True)
                     self.kernel.theta=theta
                     predictY=self.predict(self.__X_inverse_transform__(testX))
-                    obj=-1*r2_score(self.__Y_inverse_transform__(testY),predictY)
+                    obj=-1*r_square(self.__Y_inverse_transform__(testY),predictY)
                     return obj
                 
                 self.OPFunc=objFunc
@@ -218,7 +218,7 @@ class KRG(Surrogate):
                         self.kernel.theta=np.power(np.e,theta).ravel()
                         #TODO
                         predictY=self.predict(self.__X_inverse_transform__(testX))
-                        objs[i]=-1*r2_score(self.__Y_inverse_transform__(testY),predictY)
+                        objs[i]=-1*r_square(self.__Y_inverse_transform__(testY),predictY)
                     return objs.reshape(-1,1)
                 self.OPFunc=objFunc
                 

{UQPyL-2.0.3 → UQPyL-2.0.5}/UQPyL/utility/__init__.py

@@ -2,7 +2,7 @@ from .scalers import MinMaxScaler, StandardScaler, Scaler
 from .model_selections import KFold, RandSelect
 from .polynomial_features import PolynomialFeatures
 from .grid_search import GridSearch
-from .metrics import r2_score, rank_score, sort_score
+from .metrics import r_square, rank_score, sort_score
 
 __all__=[
     'Scaler',
@@ -11,7 +11,7 @@ __all__=[
     'KFold',
     'RandSelect',
     'PolynomialFeatures',
-    'r2_score',
+    'r_square',
     'rank_score',
     'GridSearch'
 ]

{UQPyL-2.0.3 → UQPyL-2.0.5}/UQPyL/utility/grid_search.py

@@ -1,4 +1,4 @@
-from .metrics import r2_score, mse, rank_score
+from .metrics import r_square, mse, rank_score
 from .model_selections import KFold
 from typing import Dict, Literal
 import numpy as np
@@ -23,7 +23,7 @@ def fit_predict(evaluator, dataX, dataY, train_sets, test_sets, metric):
 
 class GridSearch():
     def __init__(self, para_grid: Dict, Evaluator, 
-                 CV: int=5, Metric: Literal["r2_score", "mse", "rank_score"]="r2_score",
+                 CV: int=5, Metric: Literal["r_square", "mse", "rank_score"]="r_square",
                  workers: int=8):
         
         self.Evaluator=Evaluator
@@ -49,7 +49,7 @@ class GridSearch():
             for para in combinations:
                 tempEvaluator=copy.deepcopy(self.Evaluator)
                 tempEvaluator.set_Paras(para)
-                future=exe.submit(fit_predict, tempEvaluator,dataX, dataY, train_sets, test_sets, "r2_score")
+                future=exe.submit(fit_predict, tempEvaluator,dataX, dataY, train_sets, test_sets, "r_square")
                 futures[future]=para
 
             bestValue=-np.inf

{UQPyL-2.0.3 → UQPyL-2.0.5}/UQPyL/utility/metrics.py

@@ -1,7 +1,6 @@
 import numpy as np
-import math
-from typing import Tuple
-def r2_score(true_Y: np.ndarray, pre_Y: np.ndarray) -> np.ndarray:
+
+def r_square(true_Y: np.ndarray, pre_Y: np.ndarray) -> np.ndarray:
     """
     R2-score
     """

{UQPyL-2.0.3 → UQPyL-2.0.5}/UQPyL.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: UQPyL
-Version: 2.0.3
+Version: 2.0.5
 Summary: A python package for parameter uncertainty quantification and optimization
 Author: wmtSky
 Author-email: wmtSky <wmtsky@hhu.edu.cn>

{UQPyL-2.0.3 → UQPyL-2.0.5}/UQPyL.egg-info/SOURCES.txt

@@ -9,7 +9,6 @@ UQPyL.egg-info/dependency_links.txt
 UQPyL.egg-info/requires.txt
 UQPyL.egg-info/top_level.txt
 UQPyL/DoE/__init__.py
-UQPyL/DoE/_lhs.py
 UQPyL/DoE/fast_sequence.py
 UQPyL/DoE/full_fact.py
 UQPyL/DoE/lhs.py

{UQPyL-2.0.3 → UQPyL-2.0.5}/pyproject.toml

@@ -12,7 +12,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "UQPyL"
-version = "2.0.3"
+version = "2.0.5"
 authors = [
     {name = "wmtSky", email = "wmtsky@hhu.edu.cn"}
 ]

{UQPyL-2.0.3 → UQPyL-2.0.5}/setup.py

@@ -41,7 +41,7 @@ extensions=cythonize(cython_extensions, compiler_directives={'cdivision': True,
 setup(
     name="UQPyL",
     author="wmtSky",
-    version="2.0.3",
+    version="2.0.5",
     author_email="wmtsky@hhu.edu.cn",
     # ... 其他常规setup参数 ...
     ext_modules=extensions,  # 如果有自定义的编译行为

UQPyL-2.0.3/UQPyL/DoE/_lhs.py

@@ -1,90 +0,0 @@
-import numpy as np
-from scipy.spatial.distance import pdist,squareform
-
-
-def _lhs_classic(nt: int, nx: int) -> np.ndarray:
-    # Generate the intervals
-    cut = np.linspace(0, 1, nt + 1)    
-    
-    # Fill points uniformly in each interval
-    u = np.random.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 = np.random.permutation(range(nt))
-        H[:, j] = rdpoints[order, j]
-    
-    return H
-    
-################################################################################
-
-def _lhs_centered(nt: int, nx: int) -> np.ndarray:
-    # Generate the intervals
-    cut = np.linspace(0, 1, nt + 1)    
-    
-    # Fill points uniformly in each interval
-    u = np.random.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] = np.random.permutation(_center)
-    
-    return H
-    
-################################################################################
-
-def _lhs_maximin(nt: int, nx: int, iterations: int)-> np.ndarray:
-    
-    maxdist = 0
-    
-    # Maximize the minimum distance between points
-    for i in range(iterations):
-
-        H_candidate = _lhs_classic(nt, nx)
-
-        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)-> np.ndarray:
-    maxdist = 0
-    
-    # Maximize the minimum distance between points
-    for i in range(iterations):
-
-        H_candidate = _lhs_centered(nt, nx)
-        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) -> np.ndarray:
-    mincorr = np.inf
-    
-    # Minimize the components correlation coefficients
-    for i in range(iterations):
-        # Generate a random LHS
-        H_candidate = _lhs_classic(nt, nx)
-        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

UQPyL-2.0.3/UQPyL/DoE/lhs.py

@@ -1,73 +0,0 @@
-import numpy as np
-from typing import Literal
-
-from .sampler_ABC import Sampler
-from ._lhs import _lhs_classic, _lhs_centered, _lhs_correlate, _lhs_maximin, _lhs_centered_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):
-    '''
-    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).
-    
-    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)-> None:
-        self.criterion=criterion
-        self.iterations=iterations
-        
-    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.
-        '''
-        Sampling_method=LHS_METHOD[self.criterion]
-        if self.criterion in ['maximin', 'center_maximin', 'correlation']:
-            return Sampling_method(nt, nx, self.iterations)
-        else:
-            return Sampling_method(nt, nx)
-    
-    def sample(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.
-        '''
-        
-        return self._generate(nt, nx)