fvgp 4.2.2__tar.gz → 4.2.3__tar.gz

{fvgp-4.2.2/fvgp.egg-info → fvgp-4.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fvgp
-Version: 4.2.2
+Version: 4.2.3
 Summary: Python package for highly flexible function-valued Gaussian processes (fvGP)
 Home-page: https://github.com/MarcusMichaelNoack/fvgp
 Author: Marcus Michael Noack

{fvgp-4.2.2 → fvgp-4.2.3}/fvgp/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-05-31T14:47:35-0700",
+ "date": "2024-06-04T16:02:02-0700",
  "dirty": false,
  "error": null,
- "full-revisionid": "c7d74e2e459b81c40049a2af64298d8d63111af3",
- "version": "4.2.2"
+ "full-revisionid": "ecd6703d29e227a0204fc15bb6f03aef33fc31ff",
+ "version": "4.2.3"
 }
 '''  # END VERSION_JSON
 

{fvgp-4.2.2 → fvgp-4.2.3}/fvgp/fvgp.py

@@ -147,11 +147,6 @@ class fvGP(GP):
         False. Note, the training will always use Cholesky or LU decomposition instead of the
         inverse for stability reasons. Storing the inverse is
         a good option when the dataset is not too large and the posterior covariance is heavily used.
-    online : bool, optional
-        A new setting that allows optimization for online applications. Default=False. If True,
-        calc_inv will be set to true, and the inverse and the logdet() of full dataset will only be computed
-        once in the beginning and after that only updated. This leads to a significant speedup because
-        the most costly aspects of a GP are entirely avoided.
     ram_economy : bool, optional
         Only of interest if the gradient and/or Hessian of the marginal log_likelihood
         is/are used for the training.
@@ -216,13 +211,14 @@ class fvGP(GP):
         gp2Scale_dask_client=None,
         gp2Scale_batch_size=10000,
         calc_inv=False,
-        online=False,
         ram_economy=False,
         args=None,
         info=False,
     ):
 
-        if isinstance(x_data, np.ndarray): self.orig_input_space_dim = x_data.shape[1]
+        if isinstance(x_data, np.ndarray):
+            assert np.ndim(x_data) == 2
+            self.orig_input_space_dim = x_data.shape[1]
         else: self.orig_input_space_dim = 1
 
         self.output_num = y_data.shape[1]
@@ -262,7 +258,6 @@ class fvGP(GP):
             gp2Scale_dask_client=gp2Scale_dask_client,
             gp2Scale_batch_size=gp2Scale_batch_size,
             calc_inv=calc_inv,
-            online=online,
             ram_economy=ram_economy,
             args=args,
             info=info)

{fvgp-4.2.2 → fvgp-4.2.3}/fvgp/gp.py

@@ -18,8 +18,8 @@ import sys
 #   neither minres nor random logdet are doing a good job in gp2Scale,
 #                                            cg is better but we might need a preconditioner , maybe a large LU?
 #   the mcmc in default mode should not need proposal distributions explicitly
-#   reshape posteriors if x_out
-#   when are we really using gpu vs cpu as compute_device
+#   reshape posteriors if x_out is given
+#   variational inference in fvgp
 
 
 class GP:
@@ -143,14 +143,6 @@ class GP:
         False. Note, the training will always use Cholesky or LU decomposition instead of the
         inverse for stability reasons. Storing the inverse is
         a good option when the dataset is not too large and the posterior covariance is heavily used.
-    online : bool, optional
-        A new setting that allows optimization for online applications. Default=False. If True,
-        the inverse (if calc_inv is True), or the Cholesky factors (if calc_inv is False) and the logdet()
-        will only be computed
-        once in the beginning and after that only updated. This leads to a significant speedup because
-        the most costly aspects of a GP are entirely avoided. A good indicator whether `online` is a good choice is
-        the `append` option in the gp update. You always append data, never overwrite, online should be True
-        to save some time.
     ram_economy : bool, optional
         Only of interest if the gradient and/or Hessian of the marginal log_likelihood is/are used for the training.
         If True, components of the derivative of the marginal log-likelihood are
@@ -210,7 +202,6 @@ class GP:
         gp2Scale_dask_client=None,
         gp2Scale_batch_size=10000,
         calc_inv=False,
-        online=False,
         ram_economy=False,
         args=None,
         info=False
@@ -222,6 +213,8 @@ class GP:
             logger.remove()
             logger.enable("fvgp")
             logger.add(sys.stdout, filter="fvgp", level="INFO")
+        else:
+            logger.disable("fvgp")
         self.calc_inv = calc_inv
         self.gp2Scale = gp2Scale
         self.gp2Scale_dask_client = gp2Scale_dask_client
@@ -300,7 +293,6 @@ class GP:
             self.data,
             self.prior,
             self.likelihood,
-            online=online,
             calc_inv=calc_inv,
             info=info,
             gp2Scale=gp2Scale,
@@ -369,7 +361,7 @@ class GP:
                                self.prior.hyperparameters)
 
         # update marginal density
-        self.marginal_density.update_data()
+        self.marginal_density.update_data(append)
         ##########################################
         self.x_data = self.data.x_data
         self.y_data = self.data.y_data
@@ -771,9 +763,9 @@ class GP:
             a constraint during training. The default is None which means the initialized or trained hyperparameters
             are used.
         x_out : np.ndarray, optional
-            Output coordinates in case of multitask GP use; a numpy array of size (N x L),
-            where N is the number of output points,
-            and L is the dimensionality of the output space (most often 1).
+            Output coordinates in case of multitask GP use; a numpy array of size (N),
+            where N is the number evaluation points in the output direction.
+            Usually this is np.ndarray([0,1,2,...]).
 
         Return
         ------
@@ -796,9 +788,9 @@ class GP:
             a constraint during training. The default is None which means the initialized or trained hyperparameters
             are used.
         x_out : np.ndarray, optional
-            Output coordinates in case of multitask GP use; a numpy array of size (N x L),
-            where N is the number of output points,
-            and L is the dimensionality of the output space.
+            Output coordinates in case of multitask GP use; a numpy array of size (N),
+            where N is the number evaluation points in the output direction.
+            Usually this is np.ndarray([0,1,2,...]).
         direction : int, optional
             Direction of derivative, If None (default) the whole gradient will be computed.
 
@@ -820,9 +812,9 @@ class GP:
             A numpy array of shape (V x D), interpreted as  an array of input point positions or a list for
             GPs on non-Euclidean input spaces.
         x_out : np.ndarray, optional
-            Output coordinates in case of multitask GP use; a numpy array of size (N x L),
-            where N is the number of output points,
-            and L is the dimensionality of the output space.
+            Output coordinates in case of multitask GP use; a numpy array of size (N),
+            where N is the number evaluation points in the output direction.
+            Usually this is np.ndarray([0,1,2,...]).
         variance_only : bool, optional
             If True the computation of the posterior covariance matrix is avoided which can save compute time.
             In that case the return will only provide the variance at the input points.
@@ -847,9 +839,9 @@ class GP:
             A numpy array of shape (V x D), interpreted as  an array of input point positions or a list for
             GPs on non-Euclidean input spaces.
         x_out : np.ndarray, optional
-            Output coordinates in case of multitask GP use; a numpy array of size (N x L),
-            where N is the number of output points,
-            and L is the dimensionality of the output space.
+            Output coordinates in case of multitask GP use; a numpy array of size (N),
+            where N is the number evaluation points in the output direction.
+            Usually this is np.ndarray([0,1,2,...]).
         direction : int, optional
             Direction of derivative, If None (default) the whole gradient will be computed.
 
@@ -870,9 +862,9 @@ class GP:
             A numpy array of shape (V x D), interpreted as  an array of input point positions or a list for
             GPs on non-Euclidean input spaces.
         x_out : np.ndarray, optional
-            Output coordinates in case of multitask GP use; a numpy array of size (N x L),
-            where N is the number of output points,
-            and L is the dimensionality of the output space.
+            Output coordinates in case of multitask GP use; a numpy array of size (N),
+            where N is the number evaluation points in the output direction.
+            Usually this is np.ndarray([0,1,2,...]).
 
         Return
         ------
@@ -894,9 +886,9 @@ class GP:
         direction : int
             Direction of derivative.
         x_out : np.ndarray, optional
-            Output coordinates in case of multitask GP use; a numpy array of size (N x L),
-            where N is the number of output points,
-            and L is the dimensionality of the output space.
+            Output coordinates in case of multitask GP use; a numpy array of size (N),
+            where N is the number evaluation points in the output direction.
+            Usually this is np.ndarray([0,1,2,...]).
 
         Return
         ------
@@ -954,9 +946,9 @@ class GP:
         direction : int
             Direction of derivative.
         x_out : np.ndarray, optional
-            Output coordinates in case of multitask GP use; a numpy array of size (N x L),
-            where N is the number of output points,
-            and L is the dimensionality of the output space.
+            Output coordinates in case of multitask GP use; a numpy array of size (N),
+            where N is the number evaluation points in the output direction.
+            Usually this is np.ndarray([0,1,2,...]).
 
         Return
         ------
@@ -1012,9 +1004,9 @@ class GP:
         comp_cov : np.ndarray
             Comparison covariance matrix for KL divergence. shape(comp_cov) = (len(x_pred),len(x_pred))
         x_out : np.ndarray, optional
-            Output coordinates in case of multitask GP use; a numpy array of size (N x L),
-            where N is the number of output points,
-            and L is the dimensionality of the output space.
+            Output coordinates in case of multitask GP use; a numpy array of size (N),
+            where N is the number evaluation points in the output direction.
+            Usually this is np.ndarray([0,1,2,...]).
 
         Return
         -------
@@ -1039,9 +1031,9 @@ class GP:
         direction: int
             The direction in which the gradient will be computed.
         x_out : np.ndarray, optional
-            Output coordinates in case of multitask GP use; a numpy array of size (N x L),
-            where N is the number of output points,
-            and L is the dimensionality of the output space.
+            Output coordinates in case of multitask GP use; a numpy array of size (N),
+            where N is the number evaluation points in the output direction.
+            Usually this is np.ndarray([0,1,2,...]).
 
         Return
         ------
@@ -1084,9 +1076,9 @@ class GP:
             A numpy array of shape (V x D), interpreted as  an array of input point positions or a list for
             GPs on non-Euclidean input spaces.
         x_out : np.ndarray, optional
-            Output coordinates in case of multitask GP use; a numpy array of size (N x L),
-            where N is the number of output points,
-            and L is the dimensionality of the output space.
+            Output coordinates in case of multitask GP use; a numpy array of size (N),
+            where N is the number evaluation points in the output direction.
+            Usually this is np.ndarray([0,1,2,...]).
 
         Return
         -------
@@ -1111,9 +1103,9 @@ class GP:
             A numpy array of shape (V x D), interpreted as  an array of input point positions or a list for
             GPs on non-Euclidean input spaces.
         x_out : np.ndarray, optional
-            Output coordinates in case of multitask GP use; a numpy array of size (N x L),
-            where N is the number of output points,
-            and L is the dimensionality of the output space.
+            Output coordinates in case of multitask GP use; a numpy array of size (N),
+            where N is the number evaluation points in the output direction.
+            Usually this is np.ndarray([0,1,2,...]).
 
         Return
         -------
@@ -1136,9 +1128,9 @@ class GP:
             A numpy array of shape (V x D), interpreted as  an array of input point positions or a list for
             GPs on non-Euclidean input spaces.
         x_out : np.ndarray, optional
-            Output coordinates in case of multitask GP use; a numpy array of size (N x L),
-            where N is the number of output points,
-            and L is the dimensionality of the output space.
+            Output coordinates in case of multitask GP use; a numpy array of size (N),
+            where N is the number evaluation points in the output direction.
+            Usually this is np.ndarray([0,1,2,...]).
 
         Return
         -------
@@ -1163,9 +1155,9 @@ class GP:
             A numpy array of shape (V x D), interpreted as  an array of input point positions or a list for
             GPs on non-Euclidean input spaces.
         x_out : np.ndarray, optional
-            Output coordinates in case of multitask GP use; a numpy array of size (N x L),
-            where N is the number of output points,
-            and L is the dimensionality of the output space.
+            Output coordinates in case of multitask GP use; a numpy array of size (N),
+            where N is the number evaluation points in the output direction.
+            Usually this is np.ndarray([0,1,2,...]).
 
         Return
         -------
@@ -1190,9 +1182,9 @@ class GP:
         comp_cov: np.nparray
             Covariance matrix, in R^{len(x_pred) times len(x_pred)}
         x_out : np.ndarray, optional
-            Output coordinates in case of multitask GP use; a numpy array of size (N x L),
-            where N is the number of output points,
-            and L is the dimensionality of the output space.
+            Output coordinates in case of multitask GP use; a numpy array of size (N),
+            where N is the number evaluation points in the output direction.
+            Usually this is np.ndarray([0,1,2,...]).
 
         Return
         -------
@@ -1218,9 +1210,9 @@ class GP:
         direction : int
             The direction to compute the gradient in.
         x_out : np.ndarray, optional
-            Output coordinates in case of multitask GP use; a numpy array of size (N x L),
-            where N is the number of output points,
-            and L is the dimensionality of the output space.
+            Output coordinates in case of multitask GP use; a numpy array of size (N),
+            where N is the number evaluation points in the output direction.
+            Usually this is np.ndarray([0,1,2,...]).
 
         Return
         -------
@@ -1229,58 +1221,6 @@ class GP:
             given the GP posterior at a given point.
         """
         return self.posterior.posterior_probability_grad(x_pred, comp_mean, comp_cov, direction, x_out=x_out)
-
-    ##################################################################################
-    ##################################################################################
-    ##################################################################################
-    ##################################################################################
-    ######################Compute#Covariance#Matrix###################################
-    ##################################################################################
-    ##################################################################################
-    def _normalize(self, data):
-        min_d = np.min(data)
-        max_d = np.max(data)
-        data = (data - min_d) / (max_d - min_d)
-        return data, min_d, max_d
-
-    def normalize_y_data(self, y_data):
-        """
-        Function to normalize the y_data.
-        The user is responsible to normalize the noise accordingly.
-        This function will not update the object instance.
-
-        Parameters
-        ----------
-        y_data : np.ndarray
-            Numpy array of shape (U).
-        """
-        return self._normalize(y_data)
-
-    def _normalize_x_data(self, x_data):
-        n_x = np.empty(x_data.shape)
-        x_min = np.empty((len(x_data)))
-        x_max = np.empty((len(x_data)))
-        for i in range(len(self.x_data[0])):
-            n_x[:, i], x_min[i], x_max[i] = self._normalize(x_data[:, i])
-        return n_x, x_min, x_max
-
-    def _normalize_x_pred(self, x_pred, x_min, x_max):
-        new_x_pred = np.empty(x_pred.shape)
-        for i in range(len(x_pred[0])):
-            new_x_pred[:, i] = (x_pred[:, i] - x_min[i]) / (x_max[i] - x_min[i])
-        return new_x_pred
-
-    def _cartesian_product_noneuclid(self, x, y):
-        """
-        Input x,y have to be 2d numpy arrays
-        The return is the cartesian product of the two sets
-        """
-        res = []
-        for i in range(len(y)):
-            for j in range(len(x)):
-                res.append([x[j], y[i]])
-        return res
-
     ####################################################################################
     ####################################################################################
     #######################VALIDATION###################################################

{fvgp-4.2.2 → fvgp-4.2.3}/fvgp/gpMCMC.py

@@ -102,7 +102,7 @@ class gpMCMC:
         x0 : np.ndarray
             Starting point of the mcmc.
         info : bool
-            Whether to print information is the mcmc runs (use logger).
+            Whether to print information about the mcmc iterations (using logger).
         break_condition : callable or string or None
             A break condition that specified when the mcmc is terminated. If None,
             mcmc will run until `n_updates` is reached. If callable will get the mcmc object instance as
@@ -194,8 +194,7 @@ class gpMCMC:
         assert callable(obj.prop_dist)
 
         # get proposed x (x_star)
-        x_star[obj.indices] = obj.prop_dist(x_old[obj.indices].copy(), obj)
-
+        x_star[obj.indices] = obj.prop_dist(x_old[obj.indices].copy(), x_old, obj)
         # evaluate prior(x_star)
         prior_evaluation_x_star = self.prior_function(x_star, self.args)
         jump_trace = 0.
@@ -207,7 +206,7 @@ class gpMCMC:
             metr_ratio = np.exp(prior_evaluation_x_star + likelihood_star -
                                 prior_eval - likelihood)
             if np.isnan(metr_ratio):  metr_ratio = 0.
-            if metr_ratio > np.random.uniform(0, 1, 1):
+            if metr_ratio > np.random.uniform(0, 1, 1) or obj.auto_accept:
                 x = x_star
                 prior_eval = prior_evaluation_x_star
                 likelihood = likelihood_star
@@ -224,7 +223,8 @@ class gpMCMC:
 
 ###############################################################
 class ProposalDistribution:
-    def __init__(self, prop_dist,
+    def __init__(self,
+                 prop_dist,
                  indices,
                  init_prop_Sigma=None,
                  adapt_callable=None,
@@ -232,6 +232,7 @@ class ProposalDistribution:
                  c_0=10,
                  c_1=.8,
                  K=10,
+                 auto_accept=False,
                  adapt_cov=True,
                  prop_args=None):
         """
@@ -272,6 +273,7 @@ class ProposalDistribution:
         self.c_0 = c_0
         self.c_1 = c_1
         self.K = K
+        self.auto_accept = auto_accept
         self.adapt_cov = adapt_cov
         dim = len(indices)
         self.jump_trace = []
@@ -296,8 +298,7 @@ class ProposalDistribution:
                 self.prop_args["prop_Sigma"] = init_prop_Sigma
                 self.prop_args["sigma_m"] = 2.4 ** 2 / dim
 
-            #########################################################
-
+    #########################################################
     def _adapt(self, end, mcmc_obj):
         K = self.K
         if (end % K) == 0:

{fvgp-4.2.2 → fvgp-4.2.3}/fvgp/gp_marginal_density.py

@@ -11,7 +11,6 @@ class GPMarginalDensity:
                  data_obj,
                  prior_obj,
                  likelihood_obj,
-                 online=False,
                  calc_inv=False,
                  info=False,
                  gp2Scale=False,
@@ -21,15 +20,13 @@ class GPMarginalDensity:
         self.prior_obj = prior_obj
         self.likelihood_obj = likelihood_obj
         self.calc_inv = calc_inv
-        self.online = online
         self.info = info
         self.y_data = data_obj.y_data
         self.gp2Scale = gp2Scale
         self.compute_device = compute_device
         if self.gp2Scale:
-            self.online = False
             self.calc_inv = False
-            warnings.warn("gp2Scale use forbids calc_inv=True or online=True. Both have been set to False")
+            warnings.warn("gp2Scale use forbids calc_inv=True; it has been set to False")
         self.KVlinalg = KVlinalg(info, compute_device)
         K, V, m = self._get_KVm()
         if self.gp2Scale: mode = self._set_gp2Scale_mode(K)
@@ -39,11 +36,12 @@ class GPMarginalDensity:
         self.KVinvY = self._set_KVinvY(K, V, m, mode)
 
     ##################################################################
-    def update_data(self):
+    def update_data(self, append):
         """Update the marginal PDF when the data has changed in data likelihood or prior objects"""
         self.y_data = self.data_obj.y_data
         K, V, m = self._get_KVm()
-        self.KVinvY = self._update_KVinvY(K, V, m)
+        if append: self.KVinvY = self._update_KVinvY(K, V, m)
+        else: self.KVinvY = self._set_KVinvY(K, V, m, self.KVlinalg.mode)
 
     def update_hyperparameters(self):
         """Update the marginal PDF when if hyperparameters have changed"""

{fvgp-4.2.2 → fvgp-4.2.3}/fvgp/gp_posterior.py

@@ -1,31 +1,9 @@
 import numpy as np
-from .gp_lin_alg import solve
 from loguru import logger
-import warnings
 from scipy.sparse import issparse
 from .gp_lin_alg import *
 
 
-def cartesian_product(x, y):
-    """
-    Input x,y have to be 2d numpy arrays
-    The return is the cartesian product of the two sets
-    """
-    res = []
-    if isinstance(x, list) or isinstance(y, list):
-        for i in range(len(y)):
-            for j in range(len(x)):
-                res.append((y[i], x[j]))
-        return res
-    elif isinstance(x, np.ndarray) and isinstance(y, np.ndarray):
-        for i in range(len(y)):
-            for j in range(len(x)):
-                res.append(np.append(x[j], y[i]))
-        return np.array(res)
-    else:
-        raise Exception("Cartesian product out of options")
-
-
 class GPposterior:
     def __init__(self,
                  data_obj,
@@ -53,13 +31,15 @@ class GPposterior:
             hyperparameters = self.prior_obj.hyperparameters
 
         self._perform_input_checks(x_pred, x_out)
+        x_orig = x_pred.copy()
         if x_out is not None: x_pred = self.cartesian_product(x_pred, x_out)
 
         k = self.kernel(x_data, x_pred, hyperparameters, self)
         A = k.T @ KVinvY
         posterior_mean = self.mean_function(x_pred, hyperparameters, self) + A
+        if x_out is not None: posterior_mean = posterior_mean.reshape(len(x_orig), len(x_out), order='F')
 
-        return {"x": x_pred,
+        return {"x": x_orig,
                 "f(x)": posterior_mean}
 
     def posterior_mean_grad(self, x_pred, hyperparameters=None, x_out=None, direction=None):
@@ -75,6 +55,7 @@ class GPposterior:
             hyperparameters = self.prior_obj.hyperparameters
 
         self._perform_input_checks(x_pred, x_out)
+        x_orig = x_pred.copy()
         if x_out is not None: x_pred = self.cartesian_product(x_pred, x_out)
 
         f = self.mean_function(x_pred, hyperparameters, self)
@@ -83,20 +64,23 @@ class GPposterior:
             x1 = np.array(x_pred)
             x1[:, direction] = x1[:, direction] + eps
             mean_der = (self.mean_function(x1, hyperparameters, self) - f) / eps
-            k = self.kernel(x_data, x_pred, hyperparameters, self)
+            #k = self.kernel(x_data, x_pred, hyperparameters, self)
             k_g = self.d_kernel_dx(x_pred, x_data, direction, hyperparameters)
             posterior_mean_grad = mean_der + (k_g @ KVinvY)
+            if x_out is not None: posterior_mean_grad = posterior_mean_grad.reshape(len(x_orig), len(x_out), order='F')
         else:
-            posterior_mean_grad = np.zeros(x_pred.shape)
-            for direction in range(len(x_pred[0])):
+            posterior_mean_grad = np.zeros((len(x_pred), x_orig.shape[1]))
+            for direction in range(len(x_orig[0])):
                 x1 = np.array(x_pred)
                 x1[:, direction] = x1[:, direction] + eps
                 mean_der = (self.mean_function(x1, hyperparameters, self) - f) / eps
                 k_g = self.d_kernel_dx(x_pred, x_data, direction, hyperparameters)
                 posterior_mean_grad[:, direction] = mean_der + (k_g @ KVinvY)
             direction = "ALL"
+            if x_out is not None:
+                posterior_mean_grad = posterior_mean_grad.reshape(len(x_orig), len(x_orig[0]), len(x_out), order='F')
 
-        return {"x": x_pred,
+        return {"x": x_orig,
                 "direction": direction,
                 "df/dx": posterior_mean_grad}
 
@@ -105,6 +89,7 @@ class GPposterior:
         x_data = self.data_obj.x_data.copy()
 
         self._perform_input_checks(x_pred, x_out)
+        x_orig = x_pred.copy()
         if x_out is not None: x_pred = self.cartesian_product(x_pred, x_out)
 
         k = self.kernel(x_data, x_pred, self.prior_obj.hyperparameters, self)
@@ -140,35 +125,45 @@ class GPposterior:
             else:
                 warnings.warn("Noise could not be added, you did not provide a noise callable at initialization")
 
-        return {"x": x_pred,
+        if x_out is not None:
+            v = v.reshape(len(x_orig), len(x_out), order='F')
+            if S is not None: S = S.reshape(len(x_orig), len(x_orig), len(x_out), len(x_out), order='F')
+
+        return {"x": x_orig,
                 "v(x)": v,
                 "S": S}
 
     def posterior_covariance_grad(self, x_pred, x_out=None, direction=None):
         x_data = self.data_obj.x_data.copy()
         self._perform_input_checks(x_pred, x_out)
+        x_orig = x_pred.copy()
         if x_out is not None: x_pred = self.cartesian_product(x_pred, x_out)
 
         k = self.kernel(x_data, x_pred, self.prior_obj.hyperparameters, self)
         k_covariance_prod = self.marginal_density_obj.KVlinalg.solve(k)
         if direction is not None:
             k_g = self.d_kernel_dx(x_pred, x_data, direction, self.prior_obj.hyperparameters).T
-            kk = self.kernel(x_pred, x_pred, self.prior_obj.hyperparameters, self)
+            #kk = self.kernel(x_pred, x_pred, self.prior_obj.hyperparameters, self)
             x1 = np.array(x_pred)
             x2 = np.array(x_pred)
             eps = 1e-6
             x1[:, direction] = x1[:, direction] + eps
             kk_g = (self.kernel(x1, x1, self.prior_obj.hyperparameters, self) -
                     self.kernel(x2, x2, self.prior_obj.hyperparameters, self)) / eps
-            a = kk_g - (2.0 * k_g.T @ k_covariance_prod)
-            return {"x": x_pred,
-                    "dv/dx": np.diag(a),
-                    "dS/dx": a}
+            dSdx = kk_g - (2.0 * k_g.T @ k_covariance_prod)
+            #print(dSdx.shape)
+            a = np.diag(dSdx)
+            if x_out is not None:
+                a = a.reshape(len(x_orig), len(x_out), order='F')
+                dSdx = dSdx.reshape(len(x_orig), len(x_orig), len(x_out), len(x_out),  order='F')
+            return {"x": x_orig,
+                    "dv/dx": a,
+                    "dS/dx": dSdx}
         else:
-            grad_v = np.zeros((len(x_pred), len(x_pred[0])))
-            for direction in range(len(x_pred[0])):
+            grad_v = np.zeros((len(x_pred), len(x_orig[0])))
+            for direction in range(len(x_orig[0])):
                 k_g = self.d_kernel_dx(x_pred, x_data, direction, self.prior_obj.hyperparameters).T
-                kk = self.kernel(x_pred, x_pred, self.prior_obj.hyperparameters, self)
+                #kk = self.kernel(x_pred, x_pred, self.prior_obj.hyperparameters, self)
                 x1 = np.array(x_pred)
                 x2 = np.array(x_pred)
                 eps = 1e-6
@@ -176,7 +171,10 @@ class GPposterior:
                 kk_g = (self.kernel(x1, x1, self.prior_obj.hyperparameters, self) -
                         self.kernel(x2, x2, self.prior_obj.hyperparameters, self)) / eps
                 grad_v[:, direction] = np.diag(kk_g - (2.0 * k_g.T @ k_covariance_prod))
-            return {"x": x_pred,
+
+            if x_out is not None: grad_v = grad_v.reshape(len(x_orig), len(x_orig[0]), len(x_out), order='F')
+
+            return {"x": x_orig,
                     "dv/dx": grad_v}
 
     ###########################################################################
@@ -192,6 +190,7 @@ class GPposterior:
         post_mean = self.mean_function(x_pred, self.prior_obj.hyperparameters, self)
         joint_gp_prior_mean = np.append(prior_mean_vec, post_mean)
         joint_gp_prior_cov = np.block([[K, k], [k.T, kk]])
+
         return {"x": x_pred,
                 "K": K + np.identity(len(K)) * 1e-9,
                 "k": k,
@@ -219,10 +218,9 @@ class GPposterior:
                                                                                         self.prior_obj.hyperparameters,
                                                                                         self)) / (2.0 * eps)
         # post_mean = self.mean_function(x_pred, self.prior_obj.hyperparameters, self)
-        mean_der = (self.mean_function(x1, self.prior_obj.hyperparameters, self) - self.mean_function(x2,
-                                                                                                      self.prior_obj.hyperparameters,
-                                                                                                      self)) / (
-                           2.0 * eps)
+        mean_der = ((self.mean_function(x1, self.prior_obj.hyperparameters, self) -
+                    self.mean_function(x2, self.prior_obj.hyperparameters,self)) /
+                    (2.0 * eps))
         full_gp_prior_mean_grad = np.append(np.zeros(prior_mean_vec.shape), mean_der)
         prior_cov_grad = np.zeros(K.shape)
         return {"x": x_pred,
@@ -345,53 +343,53 @@ class GPposterior:
     def gp_mutual_information(self, x_pred, x_out=None):
         x_data, K = self.data_obj.x_data.copy(), self.prior_obj.K.copy() + (np.identity(len(self.prior_obj.K)) * 1e-9)
         self._perform_input_checks(x_pred, x_out)
+        x_orig = x_pred.copy()
         if x_out is not None: x_pred = self.cartesian_product(x_pred, x_out)
 
         k = self.kernel(x_data, x_pred, self.prior_obj.hyperparameters, self)
         kk = self.kernel(x_pred, x_pred, self.prior_obj.hyperparameters, self) + (np.identity(len(x_pred)) * 1e-9)
 
-        joint_covariance = \
-            np.asarray(np.block([[K, k],
-                                 [k.T, kk]]))
-        return {"x": x_pred,
+        joint_covariance = np.block([[K, k],[k.T, kk]])
+        return {"x": x_orig,
                 "mutual information": self.mutual_information(joint_covariance, kk, K)}
 
     ###########################################################################
     def gp_total_correlation(self, x_pred, x_out=None):
         x_data, K = self.data_obj.x_data.copy(), self.prior_obj.K.copy() + (np.identity(len(self.prior_obj.K)) * 1e-9)
         self._perform_input_checks(x_pred, x_out)
+        x_orig = x_pred.copy()
         if x_out is not None: x_pred = self.cartesian_product(x_pred, x_out)
 
         k = self.kernel(x_data, x_pred, self.prior_obj.hyperparameters, self)
         kk = self.kernel(x_pred, x_pred, self.prior_obj.hyperparameters, self) + (np.identity(len(x_pred)) * 1e-9)
-        joint_covariance = np.asarray(np.block([[K, k],
-                                                [k.T, kk]]))
+        joint_covariance = np.block([[K, k],[k.T, kk]])
 
-        prod_covariance = np.asarray(np.block([[K, k * 0.],
-                                               [k.T * 0., kk * np.identity(len(kk))]]))
+        prod_covariance = np.block([[K, k * 0.],[k.T * 0., kk * np.identity(len(kk))]])
 
-        return {"x": x_pred,
+        return {"x": x_orig,
                 "total correlation": self.kl_div(np.zeros((len(joint_covariance))), np.zeros((len(joint_covariance))),
                                                  joint_covariance, prod_covariance)}
 
     ###########################################################################
     def gp_relative_information_entropy(self, x_pred, x_out=None):
         self._perform_input_checks(x_pred, x_out)
+        x_orig = x_pred.copy()
         if x_out is not None: x_pred = self.cartesian_product(x_pred, x_out)
         kk = self.kernel(x_pred, x_pred, self.prior_obj.hyperparameters, self) + (np.identity(len(x_pred)) * 1e-9)
         post_cov = self.posterior_covariance(x_pred, x_out=None)["S"] + (np.identity(len(x_pred)) * 1e-9)
-        return {"x": x_pred,
+        return {"x": x_orig,
                 "RIE": self.kl_div(np.zeros((len(x_pred))), np.zeros((len(x_pred))), kk, post_cov)}
 
     ###########################################################################
     def gp_relative_information_entropy_set(self, x_pred, x_out=None):
         self._perform_input_checks(x_pred, x_out)
+        x_orig = x_pred.copy()
         if x_out is not None: x_pred = self.cartesian_product(x_pred, x_out)
         RIE = np.zeros((len(x_pred)))
         for i in range(len(x_pred)):
             RIE[i] = self.gp_relative_information_entropy(x_pred[i].reshape(1, len(x_pred[i])), x_out=None)["RIE"]
 
-        return {"x": x_pred,
+        return {"x": x_orig,
                 "RIE": RIE}
 
     ###########################################################################

{fvgp-4.2.2 → fvgp-4.2.3/fvgp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fvgp
-Version: 4.2.2
+Version: 4.2.3
 Summary: Python package for highly flexible function-valued Gaussian processes (fvGP)
 Home-page: https://github.com/MarcusMichaelNoack/fvgp
 Author: Marcus Michael Noack

{fvgp-4.2.2 → fvgp-4.2.3}/tests/test_fvgp.py

@@ -22,7 +22,7 @@ from distributed.utils_test import gen_cluster, client, loop, cluster_fixture, l
 from fvgp.gp_kernels import *
 from fvgp.gp_lin_alg import *
 from scipy import sparse
-
+from fvgp.gp_kernels import *
 
 
 
@@ -69,13 +69,25 @@ def test_lin_alg():
 
 
 def test_single_task_init_basic():
+    def kernel(x1,x2,hps,obj):
+        d = get_distance_matrix(x1,x2)
+        return hps[0] * matern_kernel_diff1(d,3.)
+    def noise(x,hps,obj):
+        return np.identity(len(x))
     my_gp1 = GP(x_data, y_data, init_hyperparameters = np.array([1, 1, 1, 1, 1, 1]), compute_device = 'cpu', info = True)
+    my_gp1 = GP(x_data, y_data, init_hyperparameters = np.array([1, 1, 1, 1, 1, 1]), gp_kernel_function = kernel,
+            gp_noise_function=noise, compute_device = 'cpu', info = True, ram_economy=True)
+    my_gp1.marginal_density.neg_log_likelihood_hessian(hyperparameters=my_gp1.get_hyperparameters())
+    my_gp1 = GP(x_data, y_data, init_hyperparameters = np.array([1, 1, 1, 1, 1, 1]), gp_kernel_function = kernel,
+            gp_noise_function=noise, compute_device = 'cpu', info = True, ram_economy=False)
+    my_gp1.marginal_density.neg_log_likelihood_hessian(hyperparameters=my_gp1.get_hyperparameters())
     my_gp1 = GP(x_data, y_data, info = True)
     my_gp1 = GP(x_data, y_data, init_hyperparameters = np.array([1, 1, 1, 1, 1, 1]))
     my_gp1 = GP(x_data, y_data, init_hyperparameters = np.array([1, 1, 1, 1, 1, 1]), calc_inv = False, info = True)
     my_gp1 = GP(x_data, y_data, init_hyperparameters = np.array([1, 1, 1, 1, 1, 1]), args = {'a':2.})
     my_gp1.update_gp_data(x_data, y_data, append = True)
     my_gp1.update_gp_data(x_data, y_data, append = False)
+
     
     my_gp1 = GP(x_data, y_data, noise_variances = np.zeros(y_data.shape) + 0.01,init_hyperparameters = np.array([1, 1, 1, 1, 1, 1]), args = {'a':2.})
     my_gp1.update_gp_data(x_data, y_data, noise_variances_new = np.zeros(y_data.shape) + 0.01, append = True)
@@ -102,6 +114,7 @@ def test_single_task_init_basic():
     my_gp1.rmse(x_data[0:2] + 1., np.array([1.,2.]))
     my_gp1.make_2d_x_pred(np.array([1.,2.]),np.array([3.,4]))
     my_gp1.make_1d_x_pred(np.array([1.,2.]))
+    my_gp1._get_default_hyperparameter_bounds()
 
 
 def test_single_task_init_advanced():
@@ -205,7 +218,9 @@ def test_multi_task():
     my_fvgp.update_gp_data(x_data, y_data, append = False)
     my_fvgp.train(hyperparameter_bounds=np.array([[0.01,1],[0.01,10]]),
             method = "global", pop_size = 10, tolerance = 0.001, max_iter = 2)
-    my_fvgp.posterior_mean(np.random.rand(10,5), x_out = np.zeros((1)))["f(x)"]
+    my_fvgp.posterior_mean(np.random.rand(10,5), x_out = np.array([0,1]))["f(x)"]
+    my_fvgp.posterior_mean_grad(np.random.rand(10,5), x_out = np.array([0,1]))["df/dx"]
+    my_fvgp.posterior_covariance(np.random.rand(10,5), x_out = np.array([0,1]))["v(x)"]
     
 
 
@@ -240,7 +255,7 @@ def test_gp2Scale(client):
     init_s = (np.diag(hps_bounds[:,1]-hps_bounds[:,0])/100.)**2
 
     from fvgp import gpMCMC
-    def proposal_distribution(x0, obj):
+    def proposal_distribution(x0, hps, obj):
         cov = obj.prop_args["prop_Sigma"]
         proposal_hps = np.zeros((len(x0)))
         proposal_hps = np.random.multivariate_normal(