gpmp 0.9.15__py3-none-any.whl

examples/__init__.py

@@ -0,0 +1,4 @@
+from . import gpmp_example01_materncov
+from . import gpmp_example02_1d_interpolation
+from . import gpmp_example03_2d
+from . import gpmp_example04_nd

examples/gpmp_example01_materncov.py

@@ -0,0 +1,27 @@
+""" Plot the Matern nu = p + 1/2 kernel/covariance functions
+
+Author: Emmanuel Vazquez <emmanuel.vazquez@centralesupelec.fr>
+Copyright (c) 2022, CentraleSupelec
+License: GPLv3 (see LICENSE)
+"""
+import gpmp.num as gnp
+import gpmp as gp
+
+def main():
+    h = gnp.linspace(-2.0, 2.0, 500)
+
+    fig = gp.misc.plotutils.Figure()
+
+    for p in [0, 1, 4]:
+        r = gp.kernel.maternp_kernel(p, gnp.abs(h))
+        fig.plot(h, r, label='p={} / nu={}/2'.format(p, 2*p+1))
+
+    fig.title('Matern covariances')
+    fig.xlabel('h')
+    fig.ylabel('$k_{p+1/2}(h)$')
+    fig.legend()
+    fig.show(grid=True)
+
+
+if __name__ == '__main__':
+    main()

examples/gpmp_example02_1d_interpolation.py

@@ -0,0 +1,99 @@
+"""
+Plot and optimize the restricted negative log-likelihood
+
+Author: Emmanuel Vazquez <emmanuel.vazquez@centralesupelec.fr>
+Copyright (c) 2022-2023, CentraleSupelec
+License: GPLv3 (see LICENSE)
+"""
+
+import gpmp.num as gnp
+import gpmp as gp
+import matplotlib.pyplot as plt
+
+
+def generate_data():
+    """
+    Data generation.
+    
+    Returns
+    -------
+    tuple
+        (xt, zt): target data
+        (xi, zi): input dataset
+    """
+    dim = 1
+    nt = 200
+    box = [[-1], [1]]
+    xt = gp.misc.designs.regulargrid(dim, nt, box)
+    zt = gp.misc.testfunctions.twobumps(xt)
+
+    ni = 6
+    xi = gp.misc.designs.ldrandunif(dim, ni, box)
+    zi = gp.misc.testfunctions.twobumps(xi)
+   
+    return xt, zt, xi, zi
+
+
+def constant_mean(x, param):
+    return gnp.ones((x.shape[0], 1))
+
+
+def kernel(x, y, covparam, pairwise=False):
+    p = 3
+    return gp.kernel.maternp_covariance(x, y, p, covparam, pairwise)
+
+
+def visualize_results(xt, zt, xi, zi, zpm, zpv):
+    """
+    Visualize the results using gp.misc.plotutils (a matplotlib wrapper).
+    
+    Parameters
+    ----------
+    xt : numpy.ndarray
+        Target x values
+    zt : numpy.ndarray
+        Target z values
+    xi : numpy.ndarray
+        Input x values
+    zi : numpy.ndarray
+        Input z values
+    zpm : numpy.ndarray
+        Posterior mean
+    zpv : numpy.ndarray
+        Posterior variance
+    """
+    fig = gp.misc.plotutils.Figure(isinteractive=True)
+    fig.plot(xt, zt, 'k', linewidth=1, linestyle=(0, (5, 5)))
+    fig.plotdata(xi, zi)
+    fig.plotgp(xt, zpm, zpv, colorscheme='simple')
+    fig.xylabels('$x$', '$z$')
+    fig.title('Posterior GP with parameters selected by ReML')
+    fig.show(grid=True, xlim=[-1.0, 1.0], legend=True, legend_fontsize=9)
+
+
+def main():
+    xt, zt, xi, zi = generate_data()
+
+    meanparam = None
+    covparam0 = None
+    model = gp.core.Model(constant_mean, kernel, meanparam, covparam0)
+
+    # Automatic selection of parameters using REML
+    model, info = gp.kernel.select_parameters_with_reml(model, xi, zi, info=True)
+    gp.misc.modeldiagnosis.diag(model, info, xi, zi)
+
+    # Prediction
+    zpm, zpv = model.predict(xi, zi, xt)
+
+    # Visualization
+    print('\nVisualization')
+    print('-------------')
+    plot_likelihood = True
+    if plot_likelihood:
+        gp.misc.modeldiagnosis.plot_likelihood_sigma_rho(model, info)
+        
+    visualize_results(xt, zt, xi, zi, zpm, zpv)
+
+
+if __name__ == '__main__':
+    main()

examples/gpmp_example02_1d_interpolation_peaks.py

@@ -0,0 +1,145 @@
+"""
+Plot and optimize the restricted negative log-likelihood
+
+Author: Emmanuel Vazquez <emmanuel.vazquez@centralesupelec.fr>
+Copyright (c) 2022-2023, CentraleSupelec
+License: GPLv3 (see LICENSE)
+"""
+
+import gpmp.num as gnp
+import gpmp as gp
+import matplotlib.pyplot as plt
+
+
+def f_matern(x):
+    l = 0.1  # length scale
+    x1, x2, x3, x4 = -0.5, -0.2, 0.3, 0.5  # translation points
+    x = gnp.asarray(x)
+    return gnp.exp(-1.0 + 0.2 * x**2 - 
+        0.1 * gp.kernel.matern32_kernel(gnp.abs(x - x1) / 0.01)
+        - 0.2 * gp.kernel.matern32_kernel(gnp.abs(x - x2) / 0.02)
+        - 0.1 * gp.kernel.matern32_kernel(gnp.abs(x - x3) / 0.04)
+        - 0.2 * gp.kernel.matern32_kernel(gnp.abs(x - x4) / 0.04)
+    )
+
+
+def generate_data():
+    """
+    Data generation.
+
+    Returns
+    -------
+    tuple
+        (xt, zt): target data
+        (xi, zi): input dataset
+    """
+    dim = 1
+    nt = 1000
+    box = [[-1], [1]]
+    xt = gp.misc.designs.regulargrid(dim, nt, box)
+    zt = f_matern(xt)
+
+    ni = 40
+    xi = gp.misc.designs.ldrandunif(dim, ni, box)
+    zi = f_matern(xi)
+
+    return xt, zt, xi, zi
+
+
+def constant_mean(x, param):
+    return gnp.ones((x.shape[0], 1))
+
+
+def kernel(x, y, covparam, pairwise=False):
+    p = 1
+    return gp.kernel.maternp_covariance(x, y, p, covparam, pairwise)
+
+
+def visualize_results(xt, zt, xi, zi, zpm, zpv):
+    """
+    Visualize the results using gp.misc.plotutils (a matplotlib wrapper).
+
+    Parameters
+    ----------
+    xt : numpy.ndarray
+        Target x values
+    zt : numpy.ndarray
+        Target z values
+    xi : numpy.ndarray
+        Input x values
+    zi : numpy.ndarray
+        Input z values
+    zpm : numpy.ndarray
+        Posterior mean
+    zpv : numpy.ndarray
+        Posterior variance
+    """
+    fig = gp.misc.plotutils.Figure(isinteractive=True)
+    fig.plot(xt, zt, "k", linewidth=1, linestyle=(0, (5, 5)))
+    fig.plotdata(xi, zi)
+    fig.plotgp(xt, zpm, zpv, colorscheme="simple")
+    fig.xylabels("$x$", "$z$")
+    fig.title("Posterior GP with parameters selected by ReML")
+    fig.show(grid=True, xlim=[-1.0, 1.0], legend=True, legend_fontsize=9)
+
+
+def main():
+    xt, zt, xi, zi = generate_data()
+
+    meanparam = None
+    covparam0 = None
+    model = gp.core.Model(constant_mean, kernel, meanparam, covparam0)
+
+    # Automatic selection of parameters using REML
+    model, info = gp.kernel.select_parameters_with_reml(model, xi, zi, info=True)
+    gp.misc.modeldiagnosis.diag(model, info, xi, zi)
+
+    # Prediction
+    zpm, zpv = model.predict(xi, zi, xt)
+
+    # Visualization
+    print("\nVisualization")
+    print("-------------")
+    plot_likelihood = False
+    if plot_likelihood:
+        gp.misc.modeldiagnosis.plot_likelihood_sigma_rho(model, info)
+
+    visualize_results(xt, zt, xi, zi, zpm, zpv)
+
+    zloo, sigma2loo, eloo = model.loo(xi, zi)
+
+    plt.figure()
+    plt.plot(zi, eloo / sigma2loo, 'o')
+    plt.show()
+
+    r = gnp.to_np(eloo / sigma2loo)
+    
+    from scipy.stats import gennorm
+    import numpy as np
+    
+    shape, loc, scale = gennorm.fit(r)
+    print(f"Shape (beta): {shape}")
+    print(f"Location (mu): {loc}")
+    print(f"Scale (alpha): {scale}")
+
+    # Plot the histogram of the data
+    plt.figure()
+    plt.hist(r, bins=30, density=True, alpha=0.6, color='g')
+
+    # Create a range of values for the PDF
+    xmin, xmax = plt.xlim()
+    x_range = np.linspace(xmin, xmax, 100)
+
+    # Plot the fitted PDF
+    pdf_fitted = gennorm.pdf(x_range, shape, loc, scale)
+    plt.plot(x_range, pdf_fitted, 'k', linewidth=2)
+
+    # Display the plot
+    plt.title('Fit of Generalized Gaussian Distribution')
+    plt.xlabel('Data')
+    plt.ylabel('Density')
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

examples/gpmp_example03_2d.py

@@ -0,0 +1,143 @@
+"""
+Gaussian processes in 2D
+
+An anisotropic Matern covariance function is used for the Gaussian
+Process (GP) prior. The parameters of this covariance function
+(variance and ranges) are estimated using the Restricted Maximum
+Likelihood (ReML) method.
+
+The mean function of the GP prior is assumed to be constant and
+unknown.
+
+The function is sampled on a space-filling Latin Hypercube design, and
+the data is assumed to be noiseless.
+
+----
+Author: Emmanuel Vazquez <emmanuel.vazquez@centralesupelec.fr>
+Copyright (c) 2022-2023, CentraleSupelec
+License: GPLv3 (see LICENSE)
+----
+This example is based on the file stk_example_kb03.m from the STK at
+https://github.com/stk-kriging/stk/ 
+by Julien Bect and Emmanuel Vazquez, released under the GPLv3 license.
+
+Original copyright notice:
+
+   Copyright (c) 2015, 2016, 2018 CentraleSupelec
+   Copyright (c) 2011-2014 SUPELEC
+----
+"""
+
+import numpy as np
+import gpmp.num as gnp
+import gpmp as gp
+import matplotlib.pyplot as plt
+
+
+# Test function selection
+def select_test_function(case_num):
+    if case_num == 1:
+        f = gp.misc.testfunctions.braninhoo
+        dim = 2
+        box = [[-5, 0], [10, 15]]
+        ni = 20
+    elif case_num == 2:
+        f = gp.misc.testfunctions.wave
+        dim = 2
+        box = [[-1, -1], [1, 1]]
+        ni = 40
+    return f, dim, box, ni
+
+
+def create_model():
+    def constant_mean(x, param):
+        return gnp.ones((x.shape[0], 1))
+
+    def kernel(x, y, covparam, pairwise=False):
+        p = 6
+        return gp.kernel.maternp_covariance(x, y, p, covparam, pairwise)
+
+    meanparam = None
+    covparam = None
+
+    return gp.core.Model(constant_mean, kernel, meanparam, covparam)
+
+
+def main():
+    case_num = 2
+    f, dim, box, ni = select_test_function(case_num)
+
+    # Compute the function on a 80 x 80 regular grid
+    nt = [80, 80]
+    xt = gp.misc.designs.regulargrid(dim, nt, box)
+    zt = f(xt)
+
+    design_type = 'ld'
+    if design_type == 'lhs':
+        xi = gp.misc.designs.maximinlhs(dim, ni, box)
+    elif design_type == 'ld':
+        xi = gp.misc.designs.ldrandunif(dim, ni, box)
+    zi = f(xi)
+
+    model = create_model()
+
+    # Parameter selection
+    covparam0 = gp.kernel.anisotropic_parameters_initial_guess(model, xi, zi)
+    nlrl, dnlrl = gp.kernel.make_selection_criterion_with_gradient(
+        model.negative_log_restricted_likelihood,
+        xi,
+        zi)
+    covparam_reml, info = gp.kernel.autoselect_parameters(covparam0, nlrl, dnlrl, info=True)
+    model.covparam = gnp.asarray(covparam_reml)
+    gp.misc.modeldiagnosis.diag(model, info, xi, zi)
+
+    # Prediction
+    (zpm, zpv) = model.predict(xi, zi, xt)
+
+    # Visualization
+    cmap = plt.get_cmap('PiYG')
+    contour_lines = 30
+
+    fig, axes = plt.subplots(nrows=2, ncols=2)
+    data = [zt, zpm, np.abs(zpm - zt), np.sqrt(zpv)]
+    titles = [
+        'function to be approximated',
+        f'approximation from {ni} points',
+        'true approx error',
+        'posterior std'
+    ]
+
+    for ax, z, title in zip(axes.flat, data, titles):
+        cs = ax.contourf(xt[:, 0].reshape(nt),
+                         xt[:, 1].reshape(nt),
+                         z.reshape(nt),
+                         levels=contour_lines,
+                         cmap=cmap)
+        ax.plot(xi[:, 0], xi[:, 1], 'ro', label='data')
+        ax.set_title(title)
+        ax.set_xlabel('$x_1$')
+        ax.set_ylabel('$x_2$')
+        ax.legend()
+        fig.colorbar(cs, ax=ax, shrink=0.9)
+
+    plt.show()
+
+    # Predictions vs truth
+    plt.figure()
+    plt.plot(zt, zpm, 'ko')
+    (xmin, xmax), (ymin, ymax) = plt.xlim(), plt.ylim()
+    xmin = min(xmin, ymin)
+    xmax = max(xmax, ymax)
+    plt.plot([xmin, xmax], [xmin, xmax], '--')
+    plt.xlabel('true values')
+    plt.ylabel('predictions')
+    plt.show()
+
+    # LOO predictions
+    zloom, zloov, eloo = model.loo(xi, zi)
+    gp.misc.plotutils.plot_loo(zi, zloom, zloov)
+
+    gp.misc.plotutils.crosssections(model, xi, zi, box, [0, 20], [0, 1])
+
+if __name__ == '__main__':
+    main()

examples/gpmp_example04_nd.py

@@ -0,0 +1,114 @@
+"""Prediction of some classical test functions in dimension > 2
+
+An anisotropic Matern covariance function is used for the Gaussian
+Process (GP) prior. The parameters of this covariance function
+(variance and ranges) are estimated using the Restricted Maximum
+Likelihood (ReML).
+
+The mean function of the GP prior is assumed to be constant and
+unknown.
+
+The function is sampled on a space-filling Latin Hypercube design, and
+the data is assumed to be noiseless.
+
+----
+Author: Emmanuel Vazquez <emmanuel.vazquez@centralesupelec.fr>
+Copyright (c) 2022-2023, CentraleSupelec
+License: GPLv3 (see LICENSE)
+"""
+import gpmp.num as gnp
+import gpmp as gp
+import matplotlib.pyplot as plt
+
+
+def choose_test_case(problem):
+    if problem == 1:
+        problem_name = "Hartmann4"
+        f = gp.misc.testfunctions.hartmann4
+        dim = 4
+        box = [[0.0] * 4, [1.0] * 4]
+        ni = 40
+        xi = gp.misc.designs.ldrandunif(dim, ni, box)
+        nt = 1000
+        xt = gp.misc.designs.ldrandunif(dim, nt, box)
+
+    elif problem == 2:
+        problem_name = "Hartmann6"
+        f = gp.misc.testfunctions.hartmann6
+        dim = 6
+        box = [[0.0] * 6, [1.0] * 6]
+        ni = 500
+        xi = gp.misc.designs.ldrandunif(dim, ni, box)
+        nt = 1000
+        xt = gp.misc.designs.ldrandunif(dim, nt, box)
+
+    elif problem == 3:
+        problem_name = "Borehole"
+        f = gp.misc.testfunctions.borehole
+        dim = 8
+        box = [
+            [0.05, 100., 63070., 990., 63.1, 700., 1120., 9855.],
+            [0.15, 50000., 115600., 1110., 116., 820., 1680., 12045.],
+        ]
+        ni = 30
+        xi = gp.misc.designs.maximinldlhs(dim, ni, box)
+        nt = 1000
+        xt = gp.misc.designs.ldrandunif(dim, nt, box)
+
+    elif problem == 4:
+        problem_name = "detpep8d"
+        f = gp.misc.testfunctions.detpep8d
+        dim = 8
+        box = [[0.0] * 8, [1.0] * 8]
+        ni = 60
+        xi = gp.misc.designs.maximinldlhs(dim, ni, box)
+        nt = 1000
+        xt = gp.misc.designs.ldrandunif(dim, nt, box)
+
+    return problem_name, f, dim, box, ni, xi, nt, xt
+
+
+def constant_mean(x, param):
+    return gnp.ones((x.shape[0], 1))
+
+
+def kernel(x, y, covparam, pairwise=False):
+    p = 10
+    return gp.kernel.maternp_covariance(x, y, p, covparam, pairwise)
+
+
+def visualize_predictions(problem_name, zt, zpm):
+    plt.figure()
+    plt.plot(zt, zpm, "ko")
+    (xmin, xmax), (ymin, ymax) = plt.xlim(), plt.ylim()
+    xmin = min(xmin, ymin)
+    xmax = max(xmax, ymax)
+    plt.plot([xmin, xmax], [xmin, xmax], "--")
+    plt.title(problem_name)
+    plt.show()
+
+
+def main():
+    problem = 1
+    problem_name, f, dim, box, ni, xi, nt, xt = choose_test_case(problem)
+
+    zi = f(xi)
+    zt = f(xt)
+
+    model = gp.core.Model(constant_mean, kernel)
+
+    model, info = gp.kernel.select_parameters_with_reml(model, xi, zi, info=True)
+    gp.misc.modeldiagnosis.diag(model, info, xi, zi)
+
+    (zpm, zpv) = model.predict(xi, zi, xt)
+
+    visualize_predictions(problem_name, zt, zpm)
+
+    zloom, zloov, eloo = model.loo(xi, zi)
+    gp.misc.plotutils.plot_loo(zi, zloom, zloov)
+
+    gp.misc.plotutils.crosssections(model, xi, zi, box, [0, 1], list(range(dim)))
+
+
+if __name__ == "__main__":
+    main()

examples/gpmp_example05_1d_custom_kernel.py

@@ -0,0 +1,133 @@
+"""
+GP interpolation in 1D, with noiseless data
+
+This example demonstrates how to compute GP interpolation with unknown mean
+(aka ordinary / intrinsic kriging) on a one-dimensional noiseless dataset.
+
+A Mat'ern covariance function is used for the Gaussian Process (GP) prior.
+The parameters of this covariance function are assumed to be known
+(i.e., no parameter estimation is performed here).
+
+The kriging predictor / posterior mean of the GP, interpolates the data.
+
+----
+Author: Emmanuel Vazquez <emmanuel.vazquez@centralesupelec.fr>
+Copyright (c) 2022-2023, CentraleSupelec
+License: GPLv3 (see LICENSE)
+----
+This example is based on the file stk_example_kb01.m from the STK at
+https://github.com/stk-kriging/stk/
+by Julien Bect and Emmanuel Vazquez, released under the GPLv3 license.
+
+Original copyright notice:
+
+   Copyright (c) 2015, 2016, 2018 CentraleSupelec
+   Copyright (c) 2011-2014 SUPELEC
+"""
+
+import math
+import numpy as np
+import gpmp.num as gnp
+import gpmp as gp
+
+
+def generate_data():
+    """
+    Data generation
+    (xt, zt): target
+    (xi, zi): input dataset
+    """
+    # Build (xt, zt)
+    dim = 1
+    nt = 200
+    box = [[-1], [1]]
+    xt = gp.misc.designs.regulargrid(dim, nt, box)
+    zt = gp.misc.testfunctions.twobumps(xt)
+
+    shuffle = True
+    if shuffle:
+        ni = 5
+        ind = np.random.choice(nt, ni, replace=False)
+    else:
+        ind = [10, 45, 100, 130, 160]
+    xi = xt[ind]
+    zi = zt[ind]
+
+    return xt, zt, xi, zi
+
+
+def zero_mean(x, param):
+    return None
+
+
+def constant_mean(x, param):
+    return gnp.ones((x.shape[0], 1))
+
+
+def kernel_ii_or_tt(x, param, pairwise=False):
+    """Covariance between observations or predictands at x."""
+    p = 2
+    sigma2 = gnp.exp(param[0])
+    loginvrho = param[1]
+    nugget = 100 * gnp.eps
+
+    if pairwise:
+        # return a vector of covariances
+        K = sigma2 * gnp.ones((x.shape[0], ))  # nx x 0
+    else:
+        # return a covariance matrix
+        K = gnp.scaled_distance(loginvrho, x, x)  # nx x nx
+        K = sigma2 * gp.kernel.maternp_kernel(p, K) + nugget * gnp.eye(K.shape[0])
+
+    return K
+
+
+def kernel_it(x, y, param, pairwise=False):
+    """Covariance between observations and prediction points."""
+    p = 2
+    sigma2 = gnp.exp(param[0])
+    loginvrho = param[1]
+
+    if pairwise:
+        # return a vector of covariances
+        K = gnp.scaled_distance_elementwise(loginvrho, x, y)  # nx x 0
+    else:
+        # return a covariance matrix
+        K = gnp.scaled_distance(loginvrho, x, y)  # nx x ny
+
+    K = sigma2 * gp.kernel.maternp_kernel(p, K)
+    return K
+
+
+def kernel(x, y, param, pairwise=False):
+    if y is x or y is None:
+        return kernel_ii_or_tt(x, param, pairwise)
+    else:
+        return kernel_it(x, y, param, pairwise)
+
+
+def visualize(xt, zt, xi, zi, zpm, zpv):
+    fig = gp.misc.plotutils.Figure(isinteractive=True)
+    fig.plot(xt, zt, 'C0', linestyle=(0, (5, 5)), linewidth=1.0)
+    fig.plotdata(xi, zi)
+    fig.plotgp(xt, zpm, zpv)
+    fig.xylabels('x', 'z')
+    fig.show(grid=True, legend=True, legend_fontsize=9)
+
+
+def main():
+    xt, zt, xi, zi = generate_data()
+    mean = constant_mean
+    meanparam = None
+
+    covparam = gnp.array([math.log(0.5**2),    # log(sigma2)
+                          math.log(1 / .7)])   # log(1/rho)
+
+    model = gp.core.Model(mean, kernel, meanparam, covparam)
+
+    zpm, zpv = model.predict(xi, zi, xt)
+    visualize(xt, zt, xi, zi, zpm, zpv)
+
+
+if __name__ == "__main__":
+    main()