fvgp 4.2.2__tar.gz → 4.2.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fvgp
-Version: 4.2.2
+Version: 4.2.4
 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.4}/fvgp/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-05-31T14:47:35-0700",
+ "date": "2024-06-07T11:34:45-0700",
  "dirty": false,
  "error": null,
- "full-revisionid": "c7d74e2e459b81c40049a2af64298d8d63111af3",
- "version": "4.2.2"
+ "full-revisionid": "c2a8c754f5e362fcd4d68857b83c2edf1bc1f5d0",
+ "version": "4.2.4"
 }
 '''  # END VERSION_JSON
 

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

@@ -1,9 +1,6 @@
 #!/usr/bin/env python
 import numpy as np
-import warnings
 from .gp import GP
-from .gp_kernels import get_distance_matrix
-from .gp_kernels import matern_kernel_diff1
 
 
 class fvGP(GP):
@@ -147,11 +144,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.
@@ -196,6 +188,74 @@ class fvGP(GP):
         logdet(K+V)
     likelihood.V : np.ndarray
         the noise covariance matrix
+
+
+    This class inherits all capabilities from :py:class:`fvgp.GP`.
+    Check there for a full list of capabilities. Here are the most important.
+
+    Base-GP Methods:
+
+    :py:meth:`fvgp.GP.train`
+
+    :py:meth:`fvgp.GP.train_async`
+
+    :py:meth:`fvgp.GP.stop_training`
+
+    :py:meth:`fvgp.GP.kill_training`
+
+    :py:meth:`fvgp.GP.update_hyperparameters`
+
+    :py:meth:`fvgp.GP.set_hyperparameters`
+
+    :py:meth:`fvgp.GP.get_hyperparameters`
+
+    Posterior Evaluations:
+
+    :py:meth:`fvgp.GP.posterior_mean`
+
+    :py:meth:`fvgp.GP.posterior_covariance`
+
+    :py:meth:`fvgp.GP.posterior_mean_grad`
+
+    :py:meth:`fvgp.GP.posterior_covariance_grad`
+
+    :py:meth:`fvgp.GP.joint_gp_prior`
+
+    :py:meth:`fvgp.GP.joint_gp_prior_grad`
+
+    :py:meth:`fvgp.GP.gp_entropy`
+
+    :py:meth:`fvgp.GP.gp_entropy_grad`
+
+    :py:meth:`fvgp.GP.gp_kl_div`
+
+    :py:meth:`fvgp.GP.gp_kl_div_grad`
+
+    :py:meth:`fvgp.GP.gp_mutual_information`
+
+    :py:meth:`fvgp.GP.gp_total_correlation`
+
+    :py:meth:`fvgp.GP.gp_relative_information_entropy`
+
+    :py:meth:`fvgp.GP.gp_relative_information_entropy_set`
+
+    :py:meth:`fvgp.GP.posterior_probability`
+
+    :py:meth:`fvgp.GP.posterior_probability_grad`
+
+    Validation Methods:
+
+    :py:meth:`fvgp.GP.crps`
+
+    :py:meth:`fvgp.GP.rmse`
+
+    :py:meth:`fvgp.GP.make_2d_x_pred`
+
+    :py:meth:`fvgp.GP.make_1d_x_pred`
+
+    :py:meth:`fvgp.GP.log_likelihood`
+
+    :py:meth:`fvgp.GP.test_log_likelihood_gradient`
     """
 
     def __init__(
@@ -216,13 +276,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 +323,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.4}/fvgp/gp.py

@@ -17,9 +17,7 @@ import sys
 # TODO: search below "TODO"
 #   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
+#   variational inference in fvgp
 
 
 class GP:
@@ -143,14 +141,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
@@ -169,7 +159,6 @@ class GP:
     info : bool, optional
         Provides a way how to see the progress of gp2Scale, Default is False
 
-
     Attributes
     ----------
     x_data : np.ndarray
@@ -210,7 +199,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 +210,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 +290,6 @@ class GP:
             self.data,
             self.prior,
             self.likelihood,
-            online=online,
             calc_inv=calc_inv,
             info=info,
             gp2Scale=gp2Scale,
@@ -369,7 +358,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 +760,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 +785,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 +809,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 +836,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 +859,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 +883,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 +943,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 +1001,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 +1028,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 +1073,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 +1100,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 +1125,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 +1152,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 +1179,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 +1207,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 +1218,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.4}/fvgp/gpMCMC.py

@@ -3,6 +3,7 @@ import time
 import warnings
 from loguru import logger
 
+
 ## --------------------------------------------------------------------- ##
 #  A generic Metropolis sampler.  You have to supply the log likelihood   #
 #  function, which need not really be a likelihood function at all.       #
@@ -43,18 +44,14 @@ class gpMCMC:
     Parameters
     ----------
     log_likelihood_function : Callable
-        The log of the likelihood to be sampled.
-    dim : int
-        The dimensionality of the space.
-    prior_function : Callable
+        The log of the likelihood to be sampled. Function of the form def likelihood(x,args) that return a scalar.
+    prior_function : callable
         Function to query for the prior probability of form: func(x, obj), where
         x is the current vector and obj is this gpMCMC object instance.
     proposal_distributions : iterable
         A list of object instances of ProposalDistribution.
     args : Any, optional
         Arguments that will be communicated to all Callables.
-    bounds : np.ndarray, optional
-        Bounds for MCMC. Not needed but encouraged. Default is [-1e6,1e6] in all directions.
 
 
     Attributes
@@ -66,28 +63,19 @@ class gpMCMC:
 
     def __init__(self,
                  log_likelihood_function,
-                 dim,
                  prior_function,
                  proposal_distributions,
-                 args=None,
-                 bounds=None,
+                 args=None
                  ):
         self.log_likelihood_function = log_likelihood_function
-        self.dim = dim
         self.prior_function = prior_function
         self.proposal_distributions = proposal_distributions
         self.args = args
         self.trace = None
         self.mcmc_info = None
-        if bounds is None:
-            self.bounds = np.zeros((dim, 2))
-            self.bounds[:] = np.array([-1e6, 1e6])
-        else: self.bounds = bounds
-        warnings.warn("Thank you for trying our new MCMC. While we tested it quite a lot it's still in\n \
-         its experimental stage. Use caution.")
-
-    def run_mcmc(self, n_updates=10000,
-                 x0=None,
+
+    def run_mcmc(self, *, x0,
+                 n_updates=10000,
                  info=False,
                  break_condition=None,
                  run_in_every_iteration=None):
@@ -97,12 +85,12 @@ class gpMCMC:
 
         Parameters
         ----------
-        n_updates: int, optional
-            The log of the likelihood to be sampled.
         x0 : np.ndarray
             Starting point of the mcmc.
+        n_updates: int, optional
+            The log of the likelihood to be sampled.
         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
@@ -116,11 +104,9 @@ class gpMCMC:
         trace information : dict
             Mean and variances are presented of the last 1% of x. All other returns consider all x.
             x here are all the accepted positions in the MCMC.
-
         """
         start_time = time.time()
         n_updates = max(n_updates, 2)
-        if x0 is None: x0 = np.ones(self.dim)
         if not isinstance(x0, np.ndarray): raise Exception("x0 is not a numpy array")
         if np.ndim(x0) != 1: raise Exception("x0 is not a vector in MCMC")
         if break_condition is None:
@@ -128,7 +114,8 @@ class gpMCMC:
                 return False
         elif break_condition == "default":
             break_condition = self._default_break_condition
-        else: raise Exception("No valid input for break condition provided!")
+        else:
+            raise Exception("No valid input for break condition provided!")
         if run_in_every_iteration is None: run_in_every_iteration = lambda a: False
 
         self.trace = {"f(x)": [], "x": [], "time stamp": []}
@@ -184,18 +171,20 @@ class gpMCMC:
             abs_diff = abs(latest_mean - earlier_mean)
             max_index = np.argmax(abs_diff)
             ratio = (abs_diff[max_index] / abs(latest_mean[max_index])) * 100.
-            if ratio < 0.1: return True
-            else: return False
-        else: return False
+            if ratio < 0.1:
+                return True
+            else:
+                return False
+        else:
+            return False
 
     ###############################################################
     def _jump(self, x_old, obj, prior_eval, likelihood):
         x_star = x_old.copy()
-        assert callable(obj.prop_dist)
+        assert callable(obj.proposal_dist)
 
         # get proposed x (x_star)
-        x_star[obj.indices] = obj.prop_dist(x_old[obj.indices].copy(), obj)
-
+        x_star[obj.indices] = obj.proposal_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 +196,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
@@ -219,19 +208,19 @@ class gpMCMC:
 
         return x, prior_eval, likelihood, jump_trace
 
-    ###############################################################
-
 
 ###############################################################
 class ProposalDistribution:
-    def __init__(self, prop_dist,
+    def __init__(self,
                  indices,
+                 proposal_dist="normal",
                  init_prop_Sigma=None,
-                 adapt_callable=None,
+                 adapt_callable="normal",
                  r_opt=.234,
                  c_0=10,
                  c_1=.8,
                  K=10,
+                 auto_accept=False,
                  adapt_cov=True,
                  prop_args=None):
         """
@@ -239,45 +228,48 @@ class ProposalDistribution:
 
         Parameters
         ----------
-        prop_dist : Callable
+        indices : iterable of int
+            The indices of the parameters that should be drawn from this proposal distribution.
+        proposal_dist : callable, optional
             A callable to calculate the proposal distribution evaluation.
-            It is defined as `def name(x, obj)`, where `obj` is a `proposal_distribution`
+            It is defined as `def name(x, para, obj)`, where `obj` is a `proposal_distribution`
             object instance. The function should return a new proposal for `x`.
-        indices : iterable of int
-            The indices that should be drawn from this proposal distribution.
+            para are all other parameters. Default is a normal distribution with the default
+            `init_prop_sigma`.
         init_prop_Sigma : np.ndarray, optional
             If the proposal distribution is normal this is the covariance of the initial proposal distribution.
             It will be updated if adapt_callable = `normal` or a callable.
             While it is optional to provide it, it is highly recommended to do so.
             A warning will be printed in that case. A good rule of thumb
-            is to orient yourself on the size of your domain.
+            is to orient yourself on the size of your domain. The default is the identity matrix.
         adapt_callable : Callable or None or string, optional
             A callable to adapt the distribution. The default is None which means
             the proposal distribution will not be adapted.
-            Use `normal` for the default adaption procedure for normal distributions.
+            Use `normal` (default) for the default adaption procedure for normal distributions.
             The callable should be defined as `def adapt(index, mcmc_obj)` and not return anything
-            but update the `mcmc_obj.prop_args`. Note, any adapt function will have to be well thought through.
+            but update the `ProposalDistribution.prop_args` attribute. Note, any
+            adapt function will have to be well thought through.
             Most adapt functions will not lead to a stationary final distributions. Use with caution.
         prop_args : Any, optional
-            Arguments that will be available as obj attribute in `prop_dist`and `adapt_callable`.
+            Arguments that will be available as obj attribute in `proposal_dist`and `adapt_callable`.
 
         """
-        # consider:
-        # axis_std = np.linalg.norm(hps_bounds, axis=1) / 10.
-        # init_s = np.diag(axis_std ** 2)
-
-        self.prop_dist = prop_dist
         self.indices = indices
         self.r_opt = r_opt
         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 = []
-        if adapt_callable == "normal" and init_prop_Sigma is None:
+        if proposal_dist == "normal": self.proposal_dist = self.normal_proposal_dist
+        elif callable(proposal_dist): self.proposal_dist = proposal_dist
+        else: raise Exception("No proposal distribution specified!")
+
+        if proposal_dist == "normal" and init_prop_Sigma is None:
             init_prop_Sigma = np.identity(dim)
-            warnings.warn("You are using the normal adaption mechanism for normal distributions\n \
+            warnings.warn("You are using the normal proposal distribution for normal distributions\n \
                            but did not provide `init_prop_sigma`. This can lead to slow convergence")
 
         if callable(adapt_callable):
@@ -296,7 +288,12 @@ class ProposalDistribution:
                 self.prop_args["prop_Sigma"] = init_prop_Sigma
                 self.prop_args["sigma_m"] = 2.4 ** 2 / dim
 
-            #########################################################
+    #########################################################
+    def normal_proposal_dist(self, x, hps, obj):
+        cov = obj.prop_args["prop_Sigma"]
+        proposal_hps = np.random.multivariate_normal(
+            mean=x, cov=cov, size=1).reshape(len(x))
+        return proposal_hps
 
     def _adapt(self, end, mcmc_obj):
         K = self.K
@@ -320,34 +317,3 @@ class ProposalDistribution:
 
     def _no_adapt(self, end, mcmc_obj):
         return
-
-
-###############################################################
-###############################################################
-###############################################################
-###############################################################
-def out_of_bounds(x, bounds):
-    for i in range(len(x)):
-        if x[i] < bounds[i, 0] or x[i] > bounds[i, 1]:
-            return True
-    return False
-
-
-def project_onto_bounds(x, bounds):  # pragma: no cover
-    for i in range(len(x)):
-        if x[i] < bounds[i, 0]: x[i] = bounds[i, 0]
-        if x[i] > bounds[i, 1]: x[i] = bounds[i, 1]
-    return x
-
-
-def in_bounds(v, bounds):  # pragma: no cover
-    for i in range(len(v)):
-        if v[i] < bounds[i, 0] or v[i] > bounds[i, 1]: return False
-    return True
-
-
-def prior_func(theta, bounds):  # pragma: no cover
-    if in_bounds(theta, bounds):
-        return 0.
-    else:
-        return -np.inf

{fvgp-4.2.2 → fvgp-4.2.4}/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.4}/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.4}/fvgp/mcmc.py

@@ -53,13 +53,13 @@ def prior_func(theta,bounds):
 #                                                                         #
 
 
-def mcmc(likelihood_fn, bounds, x0 = None, n_updates = 10000,
-                          prior_args = None,
-                          info = False, prior_fn = None,
-                          prop_Sigma = np.nan, adapt_cov = True,
-                          return_prop_Sigma_trace = False,
-                          r_opt = .234, c_0 = 10, c_1 = .8,
-                          K = 10):
+def mcmc(likelihood_fn, bounds, x0=None, n_updates=10000,
+         prior_args=None,
+         info=False, prior_fn=None,
+         prop_Sigma=np.nan, adapt_cov=True,
+         return_prop_Sigma_trace=False,
+         r_opt=.234, c_0=10, c_1=.8,
+         K=10):
 
     start_time = time.time()
     n_updates = max(n_updates,2)
@@ -113,10 +113,9 @@ def mcmc(likelihood_fn, bounds, x0 = None, n_updates = 10000,
         if prior_star != -np.inf:
             likelihood_star = likelihood_fn(hyperparameters = theta_star)
             if np.isnan(likelihood_star): likelihood_star = -np.inf
-            metr_ratio = np.exp(prior_star + likelihood_star -
-                                  prior - likelihood)
+            metr_ratio = np.exp(prior_star + likelihood_star - prior - 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):
                 theta = theta_star
                 prior = prior_star
                 likelihood = likelihood_star
@@ -132,7 +131,7 @@ def mcmc(likelihood_fn, bounds, x0 = None, n_updates = 10000,
             sigma_m = np.exp(np.log(sigma_m) + gamma1*(r_hat - r_opt))
 
             if adapt_cov:
-                prop_Sigma = prop_Sigma + gamma2*(np.cov(trace[:,(i - K + 1) : i]) - prop_Sigma)
+                prop_Sigma = prop_Sigma + gamma2*(np.cov(trace[:, (i - K + 1): i]) - prop_Sigma)
                 check_chol_cont = True
                 while check_chol_cont:
                     try:
@@ -148,8 +147,7 @@ def mcmc(likelihood_fn, bounds, x0 = None, n_updates = 10000,
         ctime.append(time.time() - start_time)
         sigma_m_trace[i] = sigma_m
         r_trace[i] = r_hat
-        if return_prop_Sigma_trace:
-            prop_Sigma_trace[i,:,:] = prop_Sigma
+        if return_prop_Sigma_trace: prop_Sigma_trace[i, :, :] = prop_Sigma
         # Echo every 100 iterations
         if info:
             if (i % 100) == 0: logger.info("Finished {} out of {} iterations. f(x)= {}", i, n_updates, likelihood)
@@ -159,10 +157,10 @@ def mcmc(likelihood_fn, bounds, x0 = None, n_updates = 10000,
     #########################################################
 
     # Collect trace objects to return
-    res = {'trace':trace,
-           'sigma_m_trace':sigma_m_trace,
-           'r_trace':r_trace,
-           'acc_prob':jump_trace.mean()}
+    res = {'trace': trace,
+           'sigma_m_trace': sigma_m_trace,
+           'r_trace': r_trace,
+           'acc_prob': jump_trace.mean()}
     arg_max = np.argmax(f)
     x = np.asarray(trace.T)
     if return_prop_Sigma_trace: res['prop_Sigma_trace'] = prop_Sigma_trace

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fvgp
-Version: 4.2.2
+Version: 4.2.4
 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.4}/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(
@@ -256,13 +271,13 @@ def test_gp2Scale(client):
             return 0. + np.sum(np.log(theta)/2.)
         else: 
             return -np.inf
-    pd = ProposalDistribution(proposal_distribution, [0,1], 
+    pd = ProposalDistribution([0,1] ,proposal_dist=proposal_distribution,
                             init_prop_Sigma = init_s, adapt_callable="normal")
 
 
 
 
-    my_mcmc = gpMCMC(obj_func, len(hps_bounds), prior_function, [pd], 
+    my_mcmc = gpMCMC(obj_func, prior_function, [pd],
                     args={"bounds":hps_bounds})
 
     hps = np.random.uniform(
@@ -270,7 +285,20 @@ def test_gp2Scale(client):
                             high = hps_bounds[:,1], 
                             size = len(hps_bounds))
     mcmc_result = my_mcmc.run_mcmc(x0=hps, info=True, n_updates=10, break_condition="default")
-
+    my_gp2S.set_hyperparameters(mcmc_result["x"][-1])
     x_pred = np.linspace(0,1,1000)
     mean1 = my_gp2S.posterior_mean(x_pred.reshape(-1,1))["f(x)"]
     var1 =  my_gp2S.posterior_covariance(x_pred.reshape(-1,1))["v(x)"]
+    
+    pd = ProposalDistribution([0,1], init_prop_Sigma = init_s)
+    my_mcmc = gpMCMC(obj_func, prior_function, [pd],
+                    args={"bounds":hps_bounds})
+
+    mcmc_result = my_mcmc.run_mcmc(x0=hps, info=True, n_updates=10, break_condition="default")
+    
+    pd = ProposalDistribution([0,1], init_prop_Sigma = init_s, adapt_callable = "normal")
+    my_mcmc = gpMCMC(obj_func, prior_function, [pd],
+                    args={"bounds":hps_bounds})
+
+    mcmc_result = my_mcmc.run_mcmc(x0=hps, info=True, n_updates=10, break_condition="default")
+