UQPyL 2.0.1__tar.gz → 2.0.2__tar.gz

UQPyL-2.0.2/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.1
+Name: UQPyL
+Version: 2.0.2
+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
+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 <br> (UQPyL)
+
+**UQPyL:** The **Uncertainty Quantification Python Laboratory** provide comprehensive workflows tailored to the **Uncertainty Quantification** and **Optimization** for computational models and their associated applications (e.g. model calibration, resource scheduling, product design). 
+
+The **main characteristics** of UQPyL includes:
+
+1. Implementation of widely used sensitivity analysis methodologies and optimization algorithms.
+
+2. Integration of diverse surrogate models equipped with tunable to solving computational expensive problems.
+
+3. Provision of a comprehensive suite of benchmark problems and practical case studies, enabling users to quick start.
+
+4. A modular and extensible architecture that 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**)
+
+ **Website:** http://www.uq-pyl.com/ (**#TODO** it need to update now.) <br>
+  **Source Code:** https://github.com/smasky/UQPyL/ <br> 
+  **Documentation:** **#TODO** <br>
+  **Citing in your work:** **#TODO** <br>
+
+# Included Methods and Algorithms
+**Sensibility Analysis:** (all methods support for surrogate models)
+- Sobol'
+- Delta_test (DT)
+- extended Fourier Amplitude Sensitivity Test (eFAST)
+- Random Balance Designs - Fourier Amplitude Sensitivity Test
+- Multivariate Adaptive Regression Splines-Sensibility Analysis (MARS-SA)
+- Morris
+- 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
+
+**Surrogate Models:**
+- Full connect neural network (FNN)
+- 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
+
+Recommend (PyPi or Conda):
+
+```
+pip install UQPyL
+
+conda install UQPyL
+```
+
+And also:
+
+```
+git clone https://github.com/smasky/UQPyL.git 
+pip install . 
+```
+
+
+# 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.
+
+---
+# Contact:
+
+wmtSky, <wmtsky@hhu.edu.cn> 
+
+
+
+
+

UQPyL-2.0.2/README.md

@@ -0,0 +1,78 @@
+# Uncertainty Quantification Python Laboratory <br> (UQPyL)
+
+**UQPyL:** The **Uncertainty Quantification Python Laboratory** provide comprehensive workflows tailored to the **Uncertainty Quantification** and **Optimization** for computational models and their associated applications (e.g. model calibration, resource scheduling, product design). 
+
+The **main characteristics** of UQPyL includes:
+
+1. Implementation of widely used sensitivity analysis methodologies and optimization algorithms.
+
+2. Integration of diverse surrogate models equipped with tunable to solving computational expensive problems.
+
+3. Provision of a comprehensive suite of benchmark problems and practical case studies, enabling users to quick start.
+
+4. A modular and extensible architecture that 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**)
+
+ **Website:** http://www.uq-pyl.com/ (**#TODO** it need to update now.) <br>
+  **Source Code:** https://github.com/smasky/UQPyL/ <br> 
+  **Documentation:** **#TODO** <br>
+  **Citing in your work:** **#TODO** <br>
+
+# Included Methods and Algorithms
+**Sensibility Analysis:** (all methods support for surrogate models)
+- Sobol'
+- Delta_test (DT)
+- extended Fourier Amplitude Sensitivity Test (eFAST)
+- Random Balance Designs - Fourier Amplitude Sensitivity Test
+- Multivariate Adaptive Regression Splines-Sensibility Analysis (MARS-SA)
+- Morris
+- 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
+
+**Surrogate Models:**
+- Full connect neural network (FNN)
+- 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
+
+Recommend (PyPi or Conda):
+
+```
+pip install UQPyL
+
+conda install UQPyL
+```
+
+And also:
+
+```
+git clone https://github.com/smasky/UQPyL.git 
+pip install . 
+```
+
+
+# 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.
+
+---
+# Contact:
+
+wmtSky, <wmtsky@hhu.edu.cn> 
+
+
+
+
+

UQPyL-2.0.2/UQPyL/DoE/__init__.py

@@ -0,0 +1,8 @@
+from .lhs import LHS
+from .full_fact import FFD
+from .random import Random
+from .sampler_ABC import Sampler
+from .sobol_sequence import Sobol_Sequence
+from .fast_sequence import FAST_Sequence
+from .morris_sequence import Morris_Sequence
+__all__=['LHS', 'FFD', 'Random', 'Sobol_Sequence', 'Morris_Sequence','FAST_Sequence','Sampler']

UQPyL-2.0.1/UQPyL/DoE/fast_sampler.py → UQPyL-2.0.2/UQPyL/DoE/fast_sequence.py

@@ -2,7 +2,7 @@ import numpy as np
 
 from .sampler_ABC import Sampler
 
-class FAST_Sampler(Sampler):
+class FAST_Sequence(Sampler):
     '''
     The sample technique for FAST(Fourier Amplitude Sensitivity Test) method
     
@@ -16,9 +16,9 @@ class FAST_Sampler(Sampler):
     __call__ or sample: Generate a sample for FAST method
     
     Examples:
-        >>> fast=FAST_Sampler()
-        >>> samples=fast(5, 4) or fast.sample(5,4)
-            
+        >>> fast_seq=FAST_Sequence()
+        >>> samples=fast_seq(5, 4) or fast_seq.sample(5,4)
+    
     '''
     def __init__(self, M: int=4):
         

{UQPyL-2.0.1 → UQPyL-2.0.2}/UQPyL/DoE/full_fact.py

@@ -30,7 +30,7 @@ class FFD(Sampler):
         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 + 1)[:level] for level in levels]
+        factor_levels = [np.linspace(0, 1, num=level)[:level] for level in levels]
                
         factor_combinations = list(product(*factor_levels))
        

UQPyL-2.0.2/UQPyL/DoE/morris_sequence.py

@@ -0,0 +1,81 @@
+import numpy as np
+
+from .sampler_ABC import Sampler
+
+class Morris_Sequence(Sampler):
+    '''
+    The sample technique for Morris analysis
+    
+    Parameters:
+        num_levels (p): each x_i would take value on {0, 1/(p-1), 2/(p-1), ..., 1}. 
+                        Morris et al[1]. recommend the num_levels to be even and range from 4 and 10.
+    
+    Methods:
+        __call__ or sample: Generate a sample for FAST method
+    
+    Examples:
+        >>> mor_seq=Morris_Sequence(num_levels=4)
+        >>> mor_seq.sample(100, 4) or mor_seq(100, 4)
+    
+    Reference:
+        [1] Max D. Morris (1991) Factorial Sampling Plans for Preliminary Computational Experiments, Technometrics, 33:2, 161-174
+    '''
+    def __init__(self, num_levels: int=4):
+        
+        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
+        
+        parameters:
+        nt: int
+            the number of trajectory
+        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.
+        '''      
+        X=np.zeros((nt*(nx+1), nx))
+        
+        for i in range(nt):
+            X[i*(nx+1):(i+1)*(nx+1), :]=self._generate_trajectory(nx)
+        
+        return X
+    
+    def _generate_trajectory(self, nx: int) -> np.ndarray:
+        '''
+        
+        '''
+        delta=self.num_levels/(2*(self.num_levels-1))
+        
+        B=np.tril(np.ones([nx + 1, nx], dtype=int), -1)
+        
+        # from paper[1] page 164
+        D_star = np.diag(np.random.choice([-1, 1], nx)) #step1
+        J=np.ones((nx+1, nx))
+        
+        levels_grids=np.linspace(0, 1-delta, int(self.num_levels / 2))
+        x_star=np.random.choice(levels_grids, nx).reshape(1,-1) #step2
+        
+        P_star=np.zeros((nx,nx))
+        cols = np.random.choice(nx, nx, replace=False)
+        P_star[np.arange(nx), cols]=1 #step3
+        
+        element_a = J[0, :] * x_star
+        element_b = P_star.T
+        element_c = np.matmul(2.0 * B, element_b)
+        element_d = np.matmul((element_c - J), D_star)
+
+        B_star = element_a + (delta / 2.0) * (element_d + J)
+    
+        return B_star
+        
+        
+        
+        
+    

{UQPyL-2.0.1 → UQPyL-2.0.2}/UQPyL/DoE/random.py

@@ -2,7 +2,7 @@ import numpy as np
 
 from .sampler_ABC import Sampler
 
-class RANDOM(Sampler):
+class Random(Sampler):
     '''
     Random Design
     

{UQPyL-2.0.1 → UQPyL-2.0.2}/UQPyL/DoE/sobol_sequence.py

@@ -6,21 +6,36 @@ from .sampler_ABC import Sampler
 class Sobol_Sequence(Sampler):
     '''
     Sobol Sequence
+    ------------------------------------------------
+    Parameters:
+    scramble: bool default=True
+        the switch to scramble the sequence or not
+    skip_value: int default=0
+        the number of skipped points for Sobol sequence
     
     Methods:
     __call__ or sample: generate the shape of (nt*nx, nx) and numpy array Sobol sequence. 
     
+    Examples:
+        >>> sobol_seq=Sobol_Sequence(skip_value=128)
+        >>> sobol_seq.sample(64, 4)
     '''
-    def __init__(self):
+    def __init__(self, scramble: bool=True, skip_value: int=0):
         
         super().__init__()
+        
+        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. 
         '''
         
-        return Sobol(d=nx).random(nt)
+        sampler=Sobol(d=nx, scramble=self.scramble)
+        X=sampler.random(nt+self.skip_value)
+        
+        return X[self.skip_value:, :]
     
     def sample(self, nt: int, nx: int) -> np.ndarray:
         '''

{UQPyL-2.0.1 → UQPyL-2.0.2}/UQPyL/optimization/__init__.py

@@ -4,8 +4,10 @@ from .adam import Adam
 from .sce_ua import SCE_UA
 from .asmo import ASMO
 from .nsga_ii import NSGAII
+from .moea_d import MOEA_D  
 from .mo_asmo import MOASMO
 from ._binary_ga import Binary_GA
+from .pso import PSO
 __all__=[
     'GA',
     'Boxmin',
@@ -14,7 +16,9 @@ __all__=[
     'ASMO',
     'NSGAII',
     'MOASMO',
-    'Binary_GA'
+    'MOEA_D',
+    'Binary_GA',
+    'PSO'
          ]
 
 MP_List=['Boxmin']

{UQPyL-2.0.1 → UQPyL-2.0.2}/UQPyL/optimization/_binary_ga.py

@@ -1,6 +1,9 @@
 import numpy as np
 
 class Binary_GA():
+    '''
+        Binary_GA for Delta Test
+    '''
     def __init__(self, evaluate, n_features, population_size=50, n_generations=100, crossover_rate=0.7, mutation_rate=0.01):
         self.population_size = population_size
         self.n_generations = n_generations

UQPyL-2.0.2/UQPyL/optimization/asmo.py

@@ -0,0 +1,116 @@
+import numpy as np
+from tqdm import tqdm
+from typing import Optional
+
+from .sce_ua import SCE_UA
+from ..DoE import LHS
+from ..problems import Problem
+from ..surrogates import Surrogate
+
+lhs=LHS('classic')
+class ASMO():
+    '''
+        Adaptive Surrogate Modelling-based Optimization <Single> <Surrogate>
+        ----------------------------------------------
+        Attributes:
+            problem: Problem
+                the problem you want to solve, including the following attributes:
+                n_input: int
+                    the input number of the problem
+                ub: 1d-np.ndarray or float
+                    the upper bound of the problem
+                lb: 1d-np.ndarray or float
+                    the lower bound of the problem
+                evaluate: Callable
+                    the function to evaluate the input
+            surrogate: Surrogate
+                the surrogate model you want to use
+            n_init: int, default=50
+                Number of initial samples for surrogate modelling
+    '''
+    def __init__(self, problem: Problem, surrogate: Surrogate, 
+                    n_init: int=50, x_init: Optional[np.ndarray]=None, y_init: Optional[np.ndarray]=None,
+                    maxFE: int=500, maxTolerateTime=50):
+        #base setting
+        self.evaluate=problem.evaluate
+        self.lb=problem.lb; self.ub=problem.ub
+        self.n_input=problem.n_input
+        self.maxFE=maxFE; self.maxTolerateTime=maxTolerateTime
+        
+        #surrogate setting
+        self.surrogate=surrogate
+        self.n_init=n_init
+        self.x_init=x_init
+        self.y_init=y_init
+        
+        #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):
+        '''
+        main procedure
+        ''' 
+        show_process=tqdm(total=maxFE)
+        FE=0
+        TT=0
+        n_input=self.n_input
+        lb=self.lb
+        ub=self.ub
+            
+        if self.x_init is None:
+            self.x_init=(ub-lb)*lhs(self.n_init, n_input)+lb
+        if self.y_init is None:
+            self.y_init=self.evaluate(self.x_init)
+           
+        XPop=self.x_init
+        YPop=self.y_init
+        
+        fe=YPop.shape[0]
+        show_process.update(fe)
+        ###
+        idx=np.argsort(YPop, axis=0)
+        BestY=YPop[idx[0,0],0]
+        BestX=XPop[idx[0,0],:]
+        # history_BestY=[]; history_BestX=[]
+        # history_BestX.append(BestX)
+        # history_BestY.append(BestY)
+        
+        if (oneStep==False):
+            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()
+                BestX_SM=res['best_dec']
+                
+                TempY=self.evaluate(BestX_SM)
+                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)
+        else:
+            self.surrogate.fit(XPop, YPop)
+            res=SCE_UA(self.subProblem).run()
+            BestX_SM=res['best_decs']
+            
+            TempY=self.evaluate(BestX_SM)
+            
+            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)
+        
+        Result={'best_dec':BestX, 'best_obj':BestY, 'FE':fe}
+        
+        return Result
+            
+            
+        
+            
+            

UQPyL-2.0.2/UQPyL/optimization/ga.py

@@ -0,0 +1,190 @@
+import numpy as np
+import math
+
+from ..problems import Problem
+from ..DoE import LHS
+class GA():
+    '''
+        Genetic Algorithm <Single>
+        -------------------------------
+        Attributes:
+            problem: Problem
+                the problem you want to solve, including the following attributes:
+                n_input: int
+                    the input number of the problem
+                ub: 1d-np.ndarray or float
+                    the upper bound of the problem
+                lb: 1d-np.ndarray or float
+                    the lower bound of the problem
+                evaluate: Callable
+                    the function to evaluate the input
+            n_samples: int, default=50
+                the number of samples as the population
+            proC: float, default=1
+                the probability of crossover
+            disC: float, default=20
+                the distribution index of crossover
+            proM: float, default=1
+                the probability of mutation
+            disM: float, default=20
+                the distribution index of mutation
+            maxIterTimes: int, default=10000
+                the maximum iteration times
+            maxFEs: int, default=2000000
+                the maximum function evaluations
+            maxTolerateTimes: int, default=1000
+                the maximum tolerate times which the best objective value does not change
+            tolerate: float, default=1e-6
+                the tolerate value which the best objective value does not change
+        
+        Methods:
+            run: run the Genetic Algorithm
+        
+        References:
+            [1] D. E. Goldberg, Genetic Algorithms in Search, Optimization, and Machine Learning, 1989.
+            [2] M. Mitchell, An Introduction to Genetic Algorithms, 1998.
+            [3] D. Simon, Evolutionary Optimization Algorithms, 2013.
+            [4] J. H. Holland, Adaptation in Natural and Artificial Systems, MIT Press, 1992.
+    '''
+    type="EA" #Evolutionary Algorithm
+    def __init__(self, problem, n_samples: int=50,
+                 proC: float=1, disC: float=20, proM: float=1, disM: float=20,
+                 maxIterTimes: int=1000,
+                 maxFEs: int=50000,
+                 maxTolerateTimes: int=1000,
+                 tolerate=1e-6):
+        #problem setting
+        self.evaluate=problem.evaluate
+        self.n_input=problem.n_input
+        self.ub=problem.ub.reshape(1,-1);self.lb=problem.lb.reshape(1,-1)
+        
+        #algorithm setting
+        self.proC=proC;self.disC=disC
+        self.proM=proM;self.disM=disM
+        self.tolerate=tolerate
+        self.n_samples=n_samples
+        
+        #termination setting
+        self.maxTolerateTimes=maxTolerateTimes
+        self.maxIterTimes=maxIterTimes
+        self.maxFEs=maxFEs
+        
+    #--------------------------Public Functions--------------------------#
+    def run(self) -> dict:
+        '''
+            Run the Genetic Algorithm
+            -------------------------------
+            Returns:
+                Result: dict
+                    the result of the Genetic Algorithm, including the following keys:
+                    best_decs: 2d-np.ndarray
+                        the decision variables of the best solution
+                    best_objs: 2d-np.ndarray
+                        the objective values of the best solution
+                    history_best_decs: 2d-np.ndarray
+                        the best decision variables of each iteration
+                    history_best_objs: 2d-np.ndarray
+                        the best objective values of each iteration
+                    iters: int
+                        the iteration times of the Genetic Algorithm
+                    FEs: int
+                        the function evaluations of the Genetic Algorithm
+        '''
+        best_objs=np.inf
+        best_decs=None
+        time=1
+        iter=0
+        FEs=0
+        
+        lhs=LHS('classic')
+        decs=(lhs(self.n_samples,self.n_input))*(self.ub-self.lb)+self.lb
+        objs=self.evaluate(decs)
+        FEs+=objs.shape[0]
+        
+        history_decs={}
+        history_objs={}
+        Result={}
+        while iter<self.maxIterTimes and FEs<self.maxFEs and time<=self.maxTolerateTimes:
+            
+            matingPool=self._tournamentSelection(decs,objs,2)
+            matingDecs=self._operationGA(matingPool)
+            matingObjs=self.evaluate(matingDecs)
+            
+            
+            tempObjs=np.vstack((objs,matingObjs))
+            tempDecs=np.vstack((decs,matingDecs))
+            rank=np.argsort(tempObjs,axis=0)
+            decs=tempDecs[rank[:self.n_samples,0],:]
+            objs=tempObjs[rank[:self.n_samples,0],:]
+            
+            if(abs(best_objs-np.min(objs))>self.tolerate):
+                best_objs=np.min(objs)
+                best_decs=decs[np.argmin(objs,axis=0),:]
+                time=0
+            else:
+                time+=1
+            
+            iter+=1
+            FEs+=matingObjs.shape[0]
+            
+            history_decs[FEs]=best_decs
+            history_objs[FEs]=best_objs
+                  
+        Result['best_dec']=best_decs
+        Result['best_obj']=best_objs
+        Result['history_best_decs']=history_decs
+        Result['history_best_objs']=history_objs
+        Result['iters']=iter
+        Result['FEs']=FEs
+        
+        return Result
+    #--------------------Private Functions--------------------# 
+    def _tournamentSelection(self,decs: np.ndarray, objs: np.ndarray, K: int=2):
+        '''
+            K-tournament selection
+        '''
+        rankIndex=np.argsort(objs,axis=0)
+        rank=np.argsort(rankIndex,axis=0)
+        
+        tourSelection=np.random.randint(0,high=objs.shape[0],size=(objs.shape[0],K))
+        winner=np.min(rank[tourSelection,:].ravel().reshape(objs.shape[0],2),axis=1)
+        winIndex=rankIndex[winner]
+        
+        return decs[winIndex.ravel(),:]
+        
+    def _operationGA(self,decs: np.ndarray):
+        '''
+            GA Operation: crossover and mutation
+        '''
+        n_samples=decs.shape[0]
+        parent1=decs[:math.floor(n_samples/2),:]
+        parent2=decs[math.floor(n_samples/2):math.floor(n_samples/2)*2,:]
+        
+        n, d = parent1.shape
+        beta = np.zeros_like(parent1)
+        mu = np.random.rand(n, d)
+
+        beta[mu <= 0.5] = np.power(2 * mu[mu <= 0.5], 1 / (self.disC + 1))
+        beta[mu > 0.5] = np.power(2 - 2 * mu[mu > 0.5], -1 / (self.disC + 1))
+        beta = beta * (-1) ** np.random.randint(0, 2, size=(n, d))
+        beta[np.random.rand(n, d) < 0.5] = 1
+        beta[np.repeat(np.random.rand(n, 1) > self.proC, d, axis=1)] = 1
+
+        offspring = np.concatenate(( (parent1 + parent2) / 2 + beta * (parent1 - parent2) / 2,
+                              (parent1 + parent2) / 2 - beta * (parent1 - parent2) / 2 ), axis=0)
+
+        lower = np.repeat(self.lb, 2 * n, axis=0)
+        upper = np.repeat(self.ub, 2 * n, axis=0)
+        site = np.random.rand(2 * n, d) < self.proM / d
+        mu = np.random.rand(2 * n, d)
+        
+        temp = site & (mu <= 0.5)
+        offspring = np.clip(offspring, lower, upper)
+        t1 = (1 - 2 * mu[temp]) * np.power(1 - (offspring[temp] - lower[temp]) / (upper[temp] - lower[temp]), self.disM + 1)
+        offspring[temp] = offspring[temp] + (upper[temp] - lower[temp]) * (np.power(2 * mu[temp] + t1, 1 / (self.disM + 1)) - 1)
+        
+        temp = site & (mu > 0.5)
+        t2 = 2 * (mu[temp] - 0.5) * np.power(1 - (upper[temp] - offspring[temp]) / (upper[temp] - lower[temp]), self.disM + 1)
+        offspring[temp] = offspring[temp] + (upper[temp] - lower[temp]) * (1 - np.power(2 * (1 - mu[temp]) + t2, 1 / (self.disM + 1)))
+        
+        return offspring