UQPyL 2.0.1__tar.gz

UQPyL-2.0.1/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2024] [wmtSky]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

UQPyL-2.0.1/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.1
+Name: UQPyL
+Version: 2.0.1
+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 a comprehensive workflow for parameter **uncertainty quantification** and **optimization** in computational numerical simulations. **UQPyL** offers an extensive suite of advanced methodologies(Sobol', Delta Test, EFAST, et al.) and algorithms (NSGA-II, ASMO, MO-ASMO, et al.). In summary, UQPyL consists of four core modules: 
+- Design of Experiments (DoE) 
+- Sensibility Analysis 
+- Optimization
+- Surrogate models
+
+The surrogate models Module can help to solve computational expensive problems caused by intensive numerical simulations.**
+
+Once you have clearly defined the problem you aim to address, you can employ all pre-prepared methods and algorithms to complete following task:
+* Uncertainty Quantification (UQ)
+* Parameter Optimization
+
+Moreover, the versatility of UQPyL allows researchers to craft their own methods or algorithms by incorporating its diverse range of surrogate models. Consequently, users can:
+- Evaluate the effectiveness of their custom-designed algorithms
+- Compare different methods and algorithms under specific problem scenarios
+
+  **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>
+
+# Installation
+
+` pip install UQPyL ` (Recommend)
+
+or
+
+` git clone https://github.com/smasky/UQPyL.git `
+
+` cd UQPyL` and ` 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.1/README.md

@@ -0,0 +1,46 @@
+# Uncertainty Quantification Python Laboratory <br> (UQPyL)
+
+**UQPyL:** The **Uncertainty Quantification Python Laboratory** provide a comprehensive workflow for parameter **uncertainty quantification** and **optimization** in computational numerical simulations. **UQPyL** offers an extensive suite of advanced methodologies(Sobol', Delta Test, EFAST, et al.) and algorithms (NSGA-II, ASMO, MO-ASMO, et al.). In summary, UQPyL consists of four core modules: 
+- Design of Experiments (DoE) 
+- Sensibility Analysis 
+- Optimization
+- Surrogate models
+
+The surrogate models Module can help to solve computational expensive problems caused by intensive numerical simulations.**
+
+Once you have clearly defined the problem you aim to address, you can employ all pre-prepared methods and algorithms to complete following task:
+* Uncertainty Quantification (UQ)
+* Parameter Optimization
+
+Moreover, the versatility of UQPyL allows researchers to craft their own methods or algorithms by incorporating its diverse range of surrogate models. Consequently, users can:
+- Evaluate the effectiveness of their custom-designed algorithms
+- Compare different methods and algorithms under specific problem scenarios
+
+  **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>
+
+# Installation
+
+` pip install UQPyL ` (Recommend)
+
+or
+
+` git clone https://github.com/smasky/UQPyL.git `
+
+` cd UQPyL` and ` 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.1/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-2.0.1/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-2.0.1/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-2.0.1/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-2.0.1/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-2.0.1/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-2.0.1/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-2.0.1/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-2.0.1/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-2.0.1/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-2.0.1/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