cleaned up many benchmark functions.

README.md

@@ -23,6 +23,7 @@ Optional dependencies include:
 * pytorch (NN surrogates)
 * QUiNN (Quantification of Uncertainties in Neural Networks)
 * pyswarms (Particle Swarm Optimization)
+* dill (for saving python objects)
 
 ## Installation
 
@@ -71,6 +72,13 @@ $ pip install 'pytuq[dev]'
     $ pip install .
 ```
 
+## Contributors
+Habib N. Najm (Sandia National Laboratories)
+Javier Murgoitio-Esandi (Google)
+Cosmin Safta (Sandia National Laboratories)
+Joy Bahr-Mueller (Sandia National Laboratories)
+Vahan Sargsyan (Stuyvesant High School)
+
 ## License
 Distributed under BSD 3-Clause License. See `LICENSE.txt` for more information.
 

apps/create_data.py

@@ -5,9 +5,16 @@
 import numpy as np
 import matplotlib.pyplot as plt
 
-from pytuq.func import toy, genz, chem, benchmark, poly, oper, func
+from pytuq.func import toy, genz, chem, bench, poly, oper, func
+from pytuq.utils.xutils import instantiate_classes_from_module
 
 
+fcn_dict = {}
+for submod in ['bench', 'bench1d', 'bench2d', 'benchNd', 'chem', 'genz', 'poly', 'toy']:
+    this_objects = instantiate_classes_from_module(f"pytuq.func.{submod}")
+    for j in this_objects:
+        if j.name not in ['GenzBase', 'Poly']:
+            fcn_dict[j.name] = j
 
 
 usage_str = 'Script to create input-output data for benchmark functions.'
@@ -16,29 +23,53 @@
 #                    help="indices of requested parameters (count from 0)")
 
 parser.add_argument("-n", "--npts", dest="npts", type=int, default=100, help="Number of points")
-parser.add_argument("-f", "--func", dest="func", type=str, default='lj', help="Function name", choices=['lj', 'mb'])
-
+parser.add_argument("-f", "--func", dest="func", type=str, default='Muller-Brown', help="Function name", choices=list(fcn_dict.keys()))
+parser.add_argument("-x", "--xtrain", dest="xtrain_file", type=str, default=None, help="Optionally, provide x-sample file")
+parser.add_argument("-s", "--sigma", dest="sig", type=float, default=0.0, help="Noise size")
+parser.add_argument('-g', dest="grad", action='store_true',
+                    help='Whether to compute gradients (default: False)')
 
 args = parser.parse_args()
 
 fname = args.func
 nsam = args.npts
+grad = args.grad
+sig = args.sig
+xtrain_file = args.xtrain_file
 
-if fname == 'lj':
-    fcn = chem.LennardJones()
-elif fname == 'mb':
-    fcn = chem.MullerBrown()
-else:
-    print(f'Function {fcn} is unknown. Please use -h to see the options. Exiting.')
+try:
+    fcn = fcn_dict[fname]
+    print(f"{nsam} samples of function {fname} requested.")
+except KeyError:
+    print(f'Function {fname} is unknown. Please use -h to see the options. Exiting.')
     sys.exit()
 
-xx = fcn.sample_uniform(nsam)
+if xtrain_file is None:
+    xx = fcn.sample_uniform(nsam)
+else:
+    xx = np.loadtxt(xtrain_file)
+    if len(xx.shape)==1:
+        xx = xx.reshape(-1, 1)
+    print(f"Input data file {xtrain_file} has {xx.shape[0]} samples, ignoring the -n flag.")
+
+nsam, ndim = xx.shape
+assert(ndim==fcn.dim)
 
 yy = fcn(xx)
-gg = fcn.grad(xx) #nsam, nout, ndim
-nsam_, nout, ndim = gg.shape
-gg = gg.reshape(nsam, nout*ndim)
+yy += sig * np.random.randn(*yy.shape)
+print("Data noise sigma =", sig)
+_, nout = yy.shape
+assert(nout==fcn.outdim)
+
 
 np.savetxt('xtrain.txt', xx)
 np.savetxt('ytrain.txt', yy)
-np.savetxt('gtrain.txt', gg)
+print("Input    data saved to xtrain.txt with shape ", xx.shape)
+print("Output   data saved to ytrain.txt with shape ", yy.shape)
+if grad:
+    gg = fcn.grad(xx) #nsam, nout, ndim
+    gg = gg.reshape(nsam, nout*ndim)
+    np.savetxt('gtrain.txt', gg)
+    print(f"Gradient data saved to gtrain.txt with shape ({nsam}, {nout}x{ndim})")
+
+

apps/uqpc/uq_pc.py

@@ -10,7 +10,7 @@
 import numpy as np
 
 from pytuq.rv.pcrv import PCRV
-from pytuq.func.benchmark import Ishigami
+from pytuq.func.bench import Ishigami
 from pytuq.utils.xutils import savepk
 from pytuq.utils.mindex import get_mi, get_npc
 from pytuq.workflows.fits import pc_fit

docs/misc/about.rst

@@ -12,7 +12,7 @@ The Python Toolkit for Uncertainty Quantification (PyTUQ) is a Python-only set o
 - Methods for Gaussian process regression
 - Global sensitivity analysis methods
 - SVD-based dimensionality reduction techniques
-- Karhunen-Loeve expansions
+- Karhunen-Loève expansions
 - Various methods for linear regression
 - Bayesian compressive sensing techniques
 - MCMC classes for calibration and parameter inference
@@ -22,9 +22,18 @@ The Python Toolkit for Uncertainty Quantification (PyTUQ) is a Python-only set o
 
 Authors
 --------
-- Khachik Sargsyan
-- Bert Debusschere
-- Emilie Grace Baillo
+- Khachik Sargsyan (Sandia National Laboratories)
+- Bert Debusschere (Sandia National Laboratories)
+- Emilie Grace Baillo (Sandia National Laboratories)
+
+Contributors
+-------------
+- Habib N. Najm (Sandia National Laboratories)
+- Javier Murgoitio-Esandi (Google)
+- Cosmin Safta (Sandia National Laboratories)
+- Joy Bahr-Mueller (Sandia National Laboratories)
+- Vahan Sargsyan (Stuyvesant High School)
+
 
 Acknowledgements
 -----------------

examples/ex_bcs.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python
+"""Example demonstrating Bayesian Compressive Sensing (BCS) for sparse polynomial chaos regression.
 
-"""[summary]
-
-[description]
+This script shows how to use BCS to construct a sparse polynomial chaos surrogate model
+with specified multiindex and model data, comparing predictions with true function values.
 """
 import numpy as np
 import matplotlib.pyplot as plt

examples/ex_bcs_mindex_growth.py

@@ -1,15 +1,18 @@
 #!/usr/bin/env python
-"""An example demonstrating bcs and multiindex growth.
+"""Example demonstrating adaptive multiindex growth with Bayesian Compressive Sensing.
+
+This script shows how to iteratively grow a polynomial chaos surrogate using
+adaptive multiindex selection and BCS regression for sparse approximation.
 """
 import numpy as np
 
 
 from pytuq.rv.pcrv import PCRV
 from pytuq.utils.mindex import get_mi
-from pytuq.utils.plotting import myrc, lighten_color, plot_dm, plot_jsens
+from pytuq.utils.plotting import myrc, plot_dm
 from pytuq.utils.maps import scale01ToDom
 from pytuq.lreg.bcs import bcs
-from pytuq.utils.mindex import mi_addfront_cons, mi_addfront
+from pytuq.utils.mindex import mi_addfront
 
 import pytuq.utils.funcbank as fcb
 

examples/ex_colors.py

@@ -1,5 +1,9 @@
 #!/usr/bin/env python
-"""Example that creates RGB triples."""
+"""Example demonstrating color palette generation and visualization.
+
+This script creates and displays a set of RGB color triples using PyTUQ's
+plotting utilities, useful for creating consistent color schemes in plots.
+"""
 
 from matplotlib import pyplot as plt
 

examples/ex_evidence.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python
+"""Example demonstrating model selection using Bayesian evidence computation.
 
-"""[summary]
-
-[description]
+This script compares different models using analytical linear regression (ANL) and 
+computes evidence values to determine which model best fits the data.
 """
 import numpy as np
 import matplotlib.pyplot as plt

examples/ex_func.py

@@ -1,25 +1,23 @@
 #!/usr/bin/env python
+"""Example demonstrating function composition and operations with PyTUQ function classes.
 
-"""[summary]
-
-[description]
+This script shows how to combine, transform, and manipulate various function objects
+including toy functions, Genz functions, chemistry functions, and benchmark functions.
 """
 
-import sys
 import numpy as np
 
 from pytuq.utils.mindex import get_mi, get_npc
-from pytuq.func import toy, genz, chem, benchmark, poly, oper, func
+from pytuq.func import toy, genz, chem, bench2d, bench, benchNd, poly, oper, func
 from pytuq.utils.plotting import myrc
 
 myrc()
 
-
 fcns = [
         func.ModelWrapperFcn(lambda x,p : x[:,0]**p[0]+np.sin(x[:,1]**p[0]), 3, modelpar=[3]), \
         oper.PickDim(2, 1, cf=100.)+chem.MullerBrown(),\
         oper.PickDim(2, 1, cf=1.)-chem.MullerBrown(),\
-        benchmark.Adjiman()*benchmark.Branin(), \
+        bench2d.Adjiman()*bench2d.Branin(), \
         oper.PickDim(2, 1, cf=1.) / (toy.Constant(2,np.ones(1,)) + oper.PickDim(2, 0, cf=1.)), \
         oper.PickDim(2, 1, cf=100.)**3, \
         toy.Quad(),\
@@ -33,15 +31,11 @@
         genz.GenzCornerPeak(weights=[7., 2.]),\
         chem.MullerBrown(),\
         chem.LennardJones(),\
-        benchmark.Sobol(dim=3),\
-        benchmark.Franke(),\
-        benchmark.Ishigami(),\
-        benchmark.NegAlpineN2(),\
-        benchmark.Adjiman(),\
-        benchmark.Branin(),\
-        benchmark.SumSquares(),\
-        benchmark.Quadratic([-1., 2.], [[2., -1.], [-1., 1.]]),\
-        benchmark.MVN([-1., 2.], [[2., -1.], [-1., 1.]]),\
+        benchNd.Sobol(dim=3),\
+        bench.Ishigami(),\
+        benchNd.NegAlpineN2(),\
+        benchNd.SumSquares(),\
+        benchNd.MVN([-1., 2.], [[2., -1.], [-1., 1.]]),\
         poly.Leg(get_mi(4,3), np.ones((get_npc(4, 3),))),\
         poly.Mon(get_mi(4,3), np.ones((get_npc(4, 3),))),\
         oper.CartesProdFcn(toy.Identity(1),toy.Identity(1)), \
@@ -50,8 +44,8 @@
         oper.SliceFcn(chem.MullerBrown(), ind=[0,1]),\
         oper.ComposeFcn(toy.Identity(2), genz.GenzOscillatory(weights=[-3., -1.])),\
         oper.ComposeFcn(toy.Exp(), genz.GenzOscillatory(), name='Composite1d'),\
-        oper.GradFcn(benchmark.Adjiman(), 1), \
-        oper.GradFcn(benchmark.Franke(), 1), \
+        oper.GradFcn(bench2d.Adjiman(), 1), \
+        oper.GradFcn(bench2d.Franke(), 1), \
         oper.PickDim(2, 1)
         ]
 

examples/ex_funcall.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+"""Example demonstrating automatic instantiation and testing of all PyTUQ function classes.
+
+This script automatically creates instances of all available function classes from
+PyTUQ's function modules and validates their gradient implementations.
+"""
+
+import numpy as np
+
+from pytuq.utils.plotting import myrc
+from pytuq.utils.xutils import instantiate_classes_from_module
+myrc()
+
+objects = []
+for submod in ['bench', 'bench1d', 'bench2d', 'benchNd', 'chem', 'genz', 'poly', 'toy']:
+    this_objects = instantiate_classes_from_module(f"pytuq.func.{submod}")
+    for j in this_objects:
+        if j.name not in ['GenzBase', 'Poly']:
+            objects.append(j)
+
+#print("Created instances:", objects)
+for fcn in objects:
+
+    print(f"========== Function {fcn.name} ==================")
+    print(fcn.name, "->", fcn)
+
+
+    print("Gradient check")
+    x = np.random.rand(111, fcn.dim)
+    assert(np.allclose(fcn.grad_(x, eps=1.e-8), fcn.grad(x), atol=1.e-5, rtol=1.e-3))
+
+    # print("Minimize")
+    # xmin = fcn.minimize()
+    # print(f"Minimum is at {xmin}")
+
+    print(f"Domain is {fcn.domain}")
+
+    nom = fcn.sample_uniform(1)[0]
+    print("Plotting 1d slice")
+    fcn.plot_1d(ngr=100, nom=nom)
+
+    if fcn.dim>1:
+        print("Plotting 2d slice")
+        fcn.plot_2d(ngr=52, nom=nom)

examples/ex_funcgrad.py

@@ -1,16 +1,14 @@
 #!/usr/bin/env python
+"""Example demonstrating gradient checking and evaluation for benchmark functions.
 
-"""[summary]
-
-[description]
+This script tests the analytical gradients of functions against numerical gradients,
+and visualizes function values and derivatives.
 """
 
-import sys
 import numpy as np
 from matplotlib import pyplot as plt
 
-from pytuq.utils.mindex import get_mi, get_npc
-from pytuq.func import toy, genz, chem, benchmark, poly, oper, func
+from pytuq.func import chem
 from pytuq.utils.plotting import myrc
 
 myrc()

examples/ex_genz1d.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python
+"""Example demonstrating 1D Genz test functions.
 
-"""[summary]
-
-[description]
+This script evaluates and plots various 1D Genz functions including oscillatory,
+corner peak, and sum functions across their domains.
 """
 import numpy as np
 from matplotlib import pyplot as plt

examples/ex_gmm.py

@@ -1,9 +1,12 @@
 #!/usr/bin/env python
-"""Test script for gmm."""
+"""Example demonstrating Gaussian Mixture Model (GMM) sampling and visualization.
+
+This script creates a GMM with multiple components, samples from it within
+a specified domain, and visualizes the samples and probability density.
+"""
 
 import numpy as np
 import matplotlib.pyplot as plt
-from scipy.stats import truncnorm, multivariate_normal
 
 from pytuq.rv.mrv import GMM
 from pytuq.utils.plotting import plot_pdfs, plot_xrv

examples/ex_gp.py

@@ -1,10 +1,13 @@
 #!/usr/bin/env python
-"""A Gaussian Process fit example."""
+"""Example demonstrating Gaussian Process regression for function approximation.
+
+This script builds a Gaussian Process surrogate model from training data,
+performs hyperparameter optimization, and evaluates prediction accuracy.
+"""
 
 import numpy as np
 import matplotlib.pyplot as plt
 
-from scipy.optimize import minimize
 
 from pytuq.fit.gp import gp
 from pytuq.rv.pcrv import PCRV

examples/ex_gsa.py

@@ -1,15 +1,18 @@
 #!/usr/bin/env python
+"""Example demonstrating global sensitivity analysis using Sobol indices.
 
+This script computes main and total Sobol sensitivity indices using either
+sampling-based (SamSobol) or PC-based (PCSobol) methods for a test function.
+"""
 
-import os, sys
+import sys
 import numpy as np
 try:
     import pprint
 except ModuleNotFoundError:
     print("Please pip install pprint for more readable printing.")
 
 
-from pytuq.func.benchmark import Ishigami
 from pytuq.gsa.gsa import SamSobol, PCSobol
 from pytuq.utils.plotting import plot_sens, plot_jsens, myrc