UQPyL 2.0.1__cp39-cp39-win_amd64.whl

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_sampler import FAST_Sampler
+
+__all__=['LHS', 'FFD', 'RANDOM','Sobol_Sequence', 'FAST_Sampler','Sampler']

UQPyL/DoE/_lhs.py

@@ -0,0 +1,90 @@
+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/DoE/fast_sampler.py

@@ -0,0 +1,77 @@
+import numpy as np
+
+from .sampler_ABC import Sampler
+
+class FAST_Sampler(Sampler):
+    '''
+    The sample technique for FAST(Fourier Amplitude Sensitivity Test) method
+    
+    Parameters:
+    M: int
+        The interference parameter, i.e., the number of harmonics to sum in the
+        Fourier series decomposition (defalut 4). 
+        But, the number of sample must be greater than 4*M**2!
+    
+    Methods:
+    __call__ or sample: Generate a sample for FAST method
+    
+    Examples:
+        >>> fast=FAST_Sampler()
+        >>> samples=fast(5, 4) or fast.sample(5,4)
+            
+    '''
+    def __init__(self, M: int=4):
+        
+        super().__init__()
+        self.M=M
+        
+    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 sample 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 nt<=4*self.M**2:
+            raise ValueError("the number of sample must be greater than 4*M**2!")
+        
+        w=np.zeros(nx)
+        w[0]=np.floor((nt-1)/(2*self.M))
+        max_wi=np.floor(w[0]/(2*self.M)) #Saltelli 
+        
+        if max_wi>=nx-1:
+            w[1:]=np.floor(np.linspace(1,max_wi, nx-1))
+        else:
+            w[1:]=np.arange(nx-1)%max_wi+1
+        
+        s=(2*np.pi/nt)*np.arange(nt)
+        
+        X_sa=np.zeros((nt*nx, nx))
+        w_tmp=np.zeros(nx)
+        
+        for i in range(nx):
+            w_tmp[i]=w[0]
+            idx=list(range(i))+list(range(i+1,nx))
+            w_tmp[idx]=w[1:]
+            idx=range(i*nt, (i+1)*nt)   
+            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()
+        
+        return X_sa
+    
+    def sample(self, nt: int, nx: int) -> np.ndarray:
+        
+        return self._generate(nt, nx)
+    
+    

UQPyL/DoE/full_fact.py

@@ -0,0 +1,57 @@
+import numpy as np
+from typing import Union
+from itertools import product
+
+from .sampler_ABC import Sampler
+
+class FFD(Sampler):
+    '''
+    Full Factorial Design
+    
+    Methods:
+    __call__ or sample: Generate a Latin-hypercube design
+    
+    Examples:
+        >>> ffd=FFD()
+        >>> samples=ffd(3, [2,3,4]) or samples=ffd.sample(3, [2,3,4])
+    '''
+    
+    def __call__(self, nx: int, levels: Union[np.ndarray, int, list]) -> np.ndarray:
+        
+        return self._generate(nx, levels)
+    
+    def _generate(self, nx: int, levels: Union[np.ndarray, int, list]) -> np.ndarray:
+
+        if isinstance(levels, int):
+            levels = [levels]*nx
+        elif isinstance(levels, np.ndarray):
+            levels = levels.ravel().tolist()
+        
+        if len(levels)!=nx:
+            raise ValueError('The length of levels should be equal to nx or 1')
+        
+        factor_levels = [np.linspace(0, 1, num=level + 1)[:level] for level in levels]
+               
+        factor_combinations = list(product(*factor_levels))
+       
+        H = np.array(factor_combinations)
+        
+        return H
+    
+    def sample(self, nx: int, levels: Union[np.ndarray, int, list]) -> np.ndarray:
+        '''
+        Parameters:
+        nx: int
+            The number of input dimensions
+        
+        levels: Union[np.ndarray, int, list]
+            The levels for each input dimension
+            
+        Returns:
+        H: 2d-array
+            An n-by-samples design matrix between zero and one.        
+        '''
+        
+        return self._generate(nx, levels)
+        
+        

UQPyL/DoE/lhs.py

@@ -0,0 +1,73 @@
+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)

UQPyL/DoE/random.py

@@ -0,0 +1,28 @@
+import numpy as np
+
+from .sampler_ABC import Sampler
+
+class RANDOM(Sampler):
+    '''
+    Random Design
+    
+    Method:
+    __call__ or sample: Generate a random design
+    
+    Examples:
+        >>> random=RANDOM()
+        >>> random(10,10) or random.sample(10,10)
+    '''
+    
+    def _generate(self,nt: int, nx: int) -> np.ndarray:
+        
+        H=np.random.random((nt,nx))
+        
+        return H
+    
+    def sample(self, nt: int, nx: int) -> np.ndarray:
+        '''
+        Generate a sample with random values between zero and one 
+        '''
+        
+        return self._generate(nt, nx)

UQPyL/DoE/sampler_ABC.py

@@ -0,0 +1,26 @@
+import abc
+import numpy as np
+
+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 _generate(self, nt: int, nx: int) -> np.ndarray:
+        '''
+        nt: the number of sampled points
+        nx: the dimensions of decision variables
+        
+        return:
+            ndarry[nt,nx]
+        
+        '''
+        pass
+    
+    

UQPyL/DoE/sobol_sequence.py

@@ -0,0 +1,47 @@
+import numpy as np
+from scipy.stats.qmc import Sobol
+
+from .sampler_ABC import Sampler
+
+class Sobol_Sequence(Sampler):
+    '''
+    Sobol Sequence
+    
+    Methods:
+    __call__ or sample: generate the shape of (nt*nx, nx) and numpy array Sobol sequence. 
+    
+    '''
+    def __init__(self):
+        
+        super().__init__()
+    
+    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)
+    
+    def sample(self, nt: int, nx: int) -> np.ndarray:
+        '''
+        generate the shape of (nt, nx) and numpy array Sobol sequence. 
+        
+        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)
+
+        
+        
+        
+        
+            
+        

UQPyL/__init__.py

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

UQPyL/optimization/__init__.py

@@ -0,0 +1,21 @@
+from .ga import GA
+from .boxmin import Boxmin
+from .adam import Adam
+from .sce_ua import SCE_UA
+from .asmo import ASMO
+from .nsga_ii import NSGAII
+from .mo_asmo import MOASMO
+from ._binary_ga import Binary_GA
+__all__=[
+    'GA',
+    'Boxmin',
+    'Adam',
+    'SCE_UA',
+    'ASMO',
+    'NSGAII',
+    'MOASMO',
+    'Binary_GA'
+         ]
+
+MP_List=['Boxmin']
+EA_List=['GA']

UQPyL/optimization/_binary_ga.py

@@ -0,0 +1,61 @@
+import numpy as np
+
+class Binary_GA():
+    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
+        self.crossover_rate = crossover_rate
+        self.mutation_rate = mutation_rate
+        self.n_features = n_features
+        self.evaluate = evaluate
+    def initialize_population(self):
+        return np.random.randint(2, size=(self.population_size, self.n_features))
+    
+    def select(self, fitnesses):
+        inverse_fitnesses = [1.0/f for f in fitnesses]
+        total_fitness = sum(inverse_fitnesses)
+        selection_probs = [f/total_fitness for f in inverse_fitnesses]
+        return np.random.choice(range(self.population_size), size=self.population_size, replace=True, p=selection_probs)
+
+    def crossover(self, parent1, parent2):
+        if np.random.rand() < self.crossover_rate:
+            point = np.random.randint(1, self.n_features)
+            child1 = np.concatenate([parent1[:point], parent2[point:]])
+            child2 = np.concatenate([parent2[:point], parent1[point:]])
+            return child1, child2
+        return parent1, parent2
+
+    def mutate(self, individual):
+        for i in range(self.n_features):
+            if np.random.rand() < self.mutation_rate:
+                individual[i] = 1 - individual[i]
+        return individual
+    
+    def run(self):
+        population = self.initialize_population()
+        best_individual = None
+        best_fitness = float('inf')
+        history_individuals = []
+        history_values=[]
+        for generation in range(self.n_generations):
+            fitnesses = [self.evaluate(individual) for individual in population]
+            if min(fitnesses) < best_fitness:
+                best_fitness = min(fitnesses)
+                best_individual = population[np.argmin(fitnesses)]
+                
+            history_individuals.append(best_individual)
+            history_values.append(best_fitness)
+                
+            selected_indices = self.select(fitnesses)
+            selected_population = population[selected_indices]
+            offspring_population = []
+            for i in range(0, self.population_size, 2):
+                parent1, parent2 = selected_population[i], selected_population[i+1]
+                child1, child2 = self.crossover(parent1, parent2)
+                offspring_population.append(self.mutate(child1))
+                offspring_population.append(self.mutate(child2))
+            population = np.array(offspring_population)
+            # 精英保留
+            if best_individual is not None:
+                population[0] = best_individual
+        return best_individual, best_fitness, history_individuals, history_values

UQPyL/optimization/_ga.py

@@ -0,0 +1,120 @@
+import numpy as np
+import warnings
+import math
+from typing import Callable
+
+class GA():
+    type="EA" #Evolutionary Algorithm
+    proC=None
+    disC=None
+    proM=None
+    disM=None
+    tolerate=1e-6
+    def __init__(self, dim: int, ub: np.ndarray, lb: np.ndarray, n_samples: int,
+                 proC: float=1, disC: float=20, proM: float=1, disM: float=20,
+                 tolerate_times: int=1000):
+        self.__check__(dim,ub,lb)
+        self.dim=dim;self.ub=ub.reshape(1,-1);self.lb=lb.reshape(1,-1)
+        
+        self.proC=proC;self.disC=disC
+        self.proM=proM;self.disM=disM
+        self.tolerate=1e-6; self.tolerate_times=tolerate_times
+        self.n_samples=n_samples
+        self.iterTimes=4000
+    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
+        '''
+        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((N,D))
+        mu=np.random.random((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*np.power(-1,np.random.randint(0,high=2,size=(N,D)))
+        beta[np.random.random((N,D))<0.5]=1
+        beta[np.repeat(np.random.random((N,1))>self.proC,D,axis=1)]=1
+        
+        off1=(Parent1+Parent2)/2+beta*(Parent1-Parent2)/2
+        off2=(Parent1+Parent2)/2-beta*(Parent1-Parent2)/2
+        Offspring=np.vstack((off1,off2))
+        
+        Lower=np.repeat(self.lb,2*N,axis=0)
+        Upper=np.repeat(self.ub,2*N,axis=0)
+        Site=np.random.random((2*N,D))<self.proM/D
+        mu=np.random.random((2*N,D)) 
+        temp=np.zeros((2*N,D),dtype=np.bool_)
+        temp[Site * mu<=0.5]=1
+        Offspring=np.minimum(np.maximum(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=np.zeros((2*N,D),dtype=np.bool_);temp[Site * mu>0.5]=1
+        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
+    
+    def run(self, func: Callable):
+        
+        best_objs=np.inf
+        best_decs=None
+        time=1
+        iter=0
+        
+        decs=np.random.random((self.n_samples,self.dim))*(self.ub-self.lb)+self.lb
+        objs=func(decs)
+        
+        while iter<self.iterTimes:
+            
+            matingPool=self._tournamentSelection(decs,objs,2)
+            matingDecs=self._operationGA(matingPool)
+            matingObjs=func(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
+            
+            if(time>self.tolerate_times):
+                break
+            
+            iter+=1
+            
+            return best_decs,best_objs
+            
+    def __check__(self,dim: int, ub: np.ndarray, lb: np.ndarray):
+        if(ub.size==lb.size and dim==ub.size):
+            pass
+        else:
+            raise ValueError("The dimensions should be consistent among dim, ub and lb")
+
+