fvgp 4.2.0__tar.gz → 4.2.2__tar.gz

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

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

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

{fvgp-4.2 → fvgp-4.2.2}/fvgp/deep_kernel_network.py

@@ -1,12 +1,15 @@
 import torch
 from torch import nn
-class Network(nn.Module): # pragma: no cover
+
+
+class Network(nn.Module):  # pragma: no cover
     def __init__(self, dim, layer_width):
         super().__init__()
         # Inputs to hidden layer linear transformation
         self.layer1 = nn.Linear(dim, layer_width)
         self.layer2 = nn.Linear(layer_width, layer_width)
         self.layer3 = nn.Linear(layer_width, dim)
+        self.number_of_hps = int(2. * dim * layer_width + layer_width ** 2 + 2. * layer_width + dim)
 
     def forward(self, x):
         x = torch.Tensor(x)
@@ -15,16 +18,18 @@ class Network(nn.Module): # pragma: no cover
         x = torch.nn.functional.relu(self.layer3(x))
         return x.detach().numpy()
 
-    def set_weights(self,w1,w2,w3):
+    def set_weights(self, w1, w2, w3):
         with torch.no_grad(): self.layer1.weight = nn.Parameter(torch.from_numpy(w1).float())
         with torch.no_grad(): self.layer2.weight = nn.Parameter(torch.from_numpy(w2).float())
         with torch.no_grad(): self.layer3.weight = nn.Parameter(torch.from_numpy(w3).float())
-    def set_biases(self,b1,b2,b3):
+
+    def set_biases(self, b1, b2, b3):
         with torch.no_grad(): self.layer1.bias = nn.Parameter(torch.from_numpy(b1).float())
         with torch.no_grad(): self.layer2.bias = nn.Parameter(torch.from_numpy(b2).float())
         with torch.no_grad(): self.layer3.bias = nn.Parameter(torch.from_numpy(b3).float())
 
     def get_weights(self):
         return self.layer1.weight, self.layer2.weight, self.layer3.weight
+
     def get_biases(self):
         return self.layer1.bias, self.layer2.bias, self.layer3.bias

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

@@ -56,10 +56,6 @@ class fvGP(GP):
         fvgp.fvGP.gp_deep_kernel_layer_width. If you specify
         another kernel, please provide
         init_hyperparameters.
-    hyperparameter_bounds : np.ndarray, optional
-        A 2d numpy array of shape (N x 2), where N is the number of needed hyperparameters.
-        The default is None, in that case hyperparameter_bounds have to be specified
-        in the train calls or default bounds are used. Those only work for the default kernel.
     output_positions : np.ndarray, optional
         A 2-D numpy array of shape (U x output_number), so that for each measurement position, the outputs
         are clearly defined by their positions in the output space. The default is
@@ -87,9 +83,6 @@ class fvGP(GP):
         is a 1d array of length N depending on how many hyperparameters are initialized, and
         obj is an `fvgp.GP` instance. The default is a deep kernel with 2 hidden layers and
         a width of fvgp.fvGP.gp_deep_kernel_layer_width.
-    gp_deep_kernel_layer_width : int, optional
-        If no kernel is provided, fvGP will use a deep kernel of depth 2 and width gp_deep_kernel_layer_width.
-        If a user defined kernel is provided this parameter is irrelevant. The default is 5.
     gp_kernel_function_grad : Callable, optional
         A function that calculates the derivative of the `gp_kernel_function` with respect to the hyperparameters.
         If provided, it will be used for local training (optimization) and can speed up the calculations.
@@ -210,12 +203,10 @@ class fvGP(GP):
         x_data,
         y_data,
         init_hyperparameters=None,
-        hyperparameter_bounds=None,
         output_positions=None,
         noise_variances=None,
         compute_device="cpu",
         gp_kernel_function=None,
-        gp_deep_kernel_layer_width=5,
         gp_kernel_function_grad=None,
         gp_noise_function=None,
         gp_noise_function_grad=None,
@@ -238,8 +229,6 @@ class fvGP(GP):
         output_space_dim = 1
         ###check the output dims
 
-
-
         if np.ndim(y_data) == 1:
             raise ValueError("The output number is 1, you can use GP for single-task GPs")
         if output_space_dim == 1 and isinstance(output_positions, np.ndarray) is False:
@@ -255,39 +244,12 @@ class fvGP(GP):
         self.fvgp_noise_variances = noise_variances
         x_data, y_data, noise_variances = self._transform_index_set(x_data, y_data, noise_variances,
                                                                     self.output_positions)
-        init_hps = init_hyperparameters
-
-        if gp_kernel_function is None and isinstance(x_data, np.ndarray):
-            gp_kernel_function = self._default_multi_task_kernel
-            try:
-                from .deep_kernel_network import Network
-            except:
-                raise Exception("You have not specified a kernel and the default kernel will be used. \n \
-                    The default kernel needs pytorch to be installed manually.")
-            self.gp_deep_kernel_layer_width = gp_deep_kernel_layer_width
-            self.n = Network(self.iset_dim, gp_deep_kernel_layer_width)
-            number_of_hps = int(2. * self.iset_dim * gp_deep_kernel_layer_width +
-                                gp_deep_kernel_layer_width ** 2 + 2. * gp_deep_kernel_layer_width + self.iset_dim + 2.)
-            self.hps_bounds = np.zeros((number_of_hps, 2))
-            self.hps_bounds[0] = np.array([np.var(y_data) / 10., np.var(y_data) * 10.])
-            self.hps_bounds[1] = np.array([(np.max(x_data) - np.min(x_data)) / 100., (np.max(x_data) -
-                                                                                      np.min(x_data)) * 100.])
-            self.hps_bounds[2:] = np.array([-1., 1.])
-            init_hps = np.random.uniform(low=self.hps_bounds[:, 0],
-                                         high=self.hps_bounds[:, 1], size=len(self.hps_bounds))
-            warnings.warn("Hyperparameter bounds have been initialized automatically \
-                    \n for the default kernel in fvgp. They will automatically used for the training.\
-                    \n However, you can also define and provide new bounds.")
-            hyperparameter_bounds = self.hps_bounds
-        else:
-            warnings.warn("Default kernel could not be defined.")
 
         ####init GP
         super().__init__(
             x_data,
             y_data,
-            init_hyperparameters=init_hps,
-            hyperparameter_bounds=hyperparameter_bounds,
+            init_hyperparameters=init_hyperparameters,
             noise_variances=noise_variances,
             compute_device=compute_device,
             gp_kernel_function=gp_kernel_function,
@@ -300,7 +262,7 @@ class fvGP(GP):
             gp2Scale_dask_client=gp2Scale_dask_client,
             gp2Scale_batch_size=gp2Scale_batch_size,
             calc_inv=calc_inv,
-            online = online,
+            online=online,
             ram_economy=ram_economy,
             args=args,
             info=info)
@@ -352,7 +314,7 @@ class fvGP(GP):
         ######################################
         x_data, y_data, noise_variances = self._transform_index_set(x_new, y_new, noise_variances_new,
                                                                     output_positions_new)
-        super().update_gp_data(self.x_data, self.y_data, noise_variances, append=append)
+        super().update_gp_data(x_data, y_data, noise_variances, append=append)
         self.output_positions = np.row_stack([self.output_positions, output_positions_new])
 
     ################################################################################################
@@ -362,24 +324,25 @@ class fvGP(GP):
             value_pos[:, j] = j
         return value_pos
 
-    def get_fvgp_data(self, labels):
-        for i in range(len(self.output_num)):
-            pass
     ################################################################################################
     def _transform_index_set(self, x_data, y_data, noise_variances, output_positions):
         point_number = len(x_data)
         assert isinstance(x_data, np.ndarray) or isinstance(x_data, list)
-        if isinstance(x_data, np.ndarray): new_points = np.zeros((point_number * self.output_num, self.iset_dim))
-        else: new_points = [0.] * point_number * self.output_num
+        if isinstance(x_data, np.ndarray):
+            new_points = np.zeros((point_number * self.output_num, self.iset_dim))
+        else:
+            new_points = [0.] * point_number * self.output_num
         new_values = np.zeros((point_number * self.output_num))
-        if noise_variances is not None: new_variances = np.zeros((point_number * self.output_num))
-        else: new_variances = None
+        if noise_variances is not None:
+            new_variances = np.zeros((point_number * self.output_num))
+        else:
+            new_variances = None
         for i in range(self.output_num):
             if isinstance(x_data, np.ndarray):
                 new_points[i * point_number: (i + 1) * point_number] = np.column_stack([x_data, output_positions[:, i]])
             if isinstance(x_data, list):
                 for j in range(len(x_data)):
-                    new_points[i*point_number+j] = [x_data[j], output_positions[j, i]]
+                    new_points[i * point_number + j] = [x_data[j], output_positions[j, i]]
             new_values[i * point_number: (i + 1) * point_number] = y_data[:, i]
             if noise_variances is not None:
                 new_variances[i * point_number: (i + 1) * point_number] = noise_variances[:, i]
@@ -387,30 +350,4 @@ class fvGP(GP):
         return new_points, new_values, new_variances
 
     ################################################################################################
-    def _default_multi_task_kernel(self, x1, x2, hps, obj):  # pragma: no cover
-        signal_var = hps[0]
-        length_scale = hps[1]
-        hps_nn = hps[2:]
-        w1_indices = np.arange(0, self.gp_deep_kernel_layer_width * self.iset_dim)
-        last = self.gp_deep_kernel_layer_width * self.iset_dim
-        w2_indices = np.arange(last, last + self.gp_deep_kernel_layer_width ** 2)
-        last = last + self.gp_deep_kernel_layer_width ** 2
-        w3_indices = np.arange(last, last + self.gp_deep_kernel_layer_width * self.iset_dim)
-        last = last + self.gp_deep_kernel_layer_width * self.iset_dim
-        b1_indices = np.arange(last, last + self.gp_deep_kernel_layer_width)
-        last = last + self.gp_deep_kernel_layer_width
-        b2_indices = np.arange(last, last + self.gp_deep_kernel_layer_width)
-        last = last + self.gp_deep_kernel_layer_width
-        b3_indices = np.arange(last, last + self.iset_dim)
 
-        self.n.set_weights(hps_nn[w1_indices].reshape(self.gp_deep_kernel_layer_width, self.iset_dim),
-                           hps_nn[w2_indices].reshape(self.gp_deep_kernel_layer_width, self.gp_deep_kernel_layer_width),
-                           hps_nn[w3_indices].reshape(self.iset_dim, self.gp_deep_kernel_layer_width))
-        self.n.set_biases(hps_nn[b1_indices].reshape(self.gp_deep_kernel_layer_width),
-                          hps_nn[b2_indices].reshape(self.gp_deep_kernel_layer_width),
-                          hps_nn[b3_indices].reshape(self.iset_dim))
-        x1_nn = self.n.forward(x1)
-        x2_nn = self.n.forward(x2)
-        d = get_distance_matrix(x1_nn, x2_nn)
-        k = signal_var * matern_kernel_diff1(d, length_scale)
-        return k

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

@@ -1,7 +1,6 @@
 #!/usr/bin/env python
 
 import warnings
-import dask.distributed as distributed
 import numpy as np
 from loguru import logger
 from dask.distributed import Client
@@ -12,17 +11,17 @@ from .gp_marginal_density import GPMarginalDensity
 from .gp_likelihood import GPlikelihood
 from .gp_training import GPtraining
 from .gp_posterior import GPposterior
+import sys
 
 
 # TODO: search below "TODO"
-#   neither minres nor random logdet are doing a good job, cg is better but we might need a preconditioner , maybe a large LU?
-#   for Ron's situation, make x_data, x_data optional and None by default, if not communicated, they will be asssigned simple dummy_data (with given dimensionality)
-#                and self.dummy_data = True. This should be overwritten in the update_data and used for warning in train and posteriors.
-#                the noise will have to be either given as a function or itialized randomly too with a warning that noise will have to be communited in the update.
+#   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
 
+
 class GP:
     """
     This class provides all the tools for a single-task Gaussian Process (GP).
@@ -47,17 +46,9 @@ class GP:
     init_hyperparameters : np.ndarray, optional
         Vector of hyperparameters used by the GP initially.
         This class provides methods to train hyperparameters.
-        The default is a random draw from a uniform distribution
-        within hyperparameter_bounds, with a shape appropriate
-        for the default kernel (D + 1), which is an anisotropic Matern
+        The default is an array of ones with the right length for the anisotropic Matern
         kernel with automatic relevance determination (ARD). If sparse_node or gp2Scale is
         enabled, the default kernel changes to the anisotropic Wendland kernel.
-    hyperparameter_bounds : np.ndarray, optional
-        A 2d numpy array of shape (N x 2), where N is the number of needed hyperparameters.
-        The default is None, in which case the hyperparameter_bounds are estimated from the domain size
-        and the initial y_data. If the data set changes significantly,
-        the hyperparameters and the bounds should be changed/retrained. Initial hyperparameters and bounds
-        can also be set in the train calls. The default only works for the default kernels.
     noise_variances : np.ndarray, optional
         An numpy array defining the uncertainties/noise in the data
         `y_data` in form of a point-wise variance. Shape (len(y_data), 1) or (len(y_data)).
@@ -154,9 +145,12 @@ class GP:
         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
+        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.
+        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
@@ -204,7 +198,6 @@ class GP:
         x_data,
         y_data,
         init_hyperparameters=None,
-        hyperparameter_bounds=None,
         noise_variances=None,
         compute_device="cpu",
         gp_kernel_function=None,
@@ -225,6 +218,10 @@ class GP:
         self.compute_device = compute_device
         self.args = args
         self.info = info
+        if info:
+            logger.remove()
+            logger.enable("fvgp")
+            logger.add(sys.stdout, filter="fvgp", level="INFO")
         self.calc_inv = calc_inv
         self.gp2Scale = gp2Scale
         self.gp2Scale_dask_client = gp2Scale_dask_client
@@ -238,30 +235,18 @@ class GP:
         # prepare initial hyperparameters and bounds
         if self.data.Euclidean:
             if callable(gp_kernel_function) or callable(gp_mean_function) or callable(gp_noise_function):
-                if hyperparameter_bounds is None and init_hyperparameters is None:
-                    raise Exception(
-                        "You have provided callables for kernel, mean, or noise functions but no"
-                        "initial hyperparameters or hyperparameter bounds. Please provide"
-                        "at least one of them at initialization.")
-                else:
-                    if init_hyperparameters is None:
-                        hyperparameters, hyperparameter_bounds = self._get_default_hyperparameters(
-                            hyperparameter_bounds)
+                if init_hyperparameters is None: raise Exception(
+                    "You have provided callables for kernel, mean, or noise functions but no"
+                    "initial hyperparameters.")
             else:
-                if init_hyperparameters is None: hyperparameters, hyperparameter_bounds = \
-                    self._get_default_hyperparameters(hyperparameter_bounds)
+                if init_hyperparameters is None: hyperparameters = np.ones((self.data.input_space_dim + 1))
         else:
-            hyperparameters, hyperparameter_bounds = init_hyperparameters, hyperparameter_bounds
+            hyperparameters = init_hyperparameters
 
         # warn if they could not be prepared
         if hyperparameters is None:
             raise Exception("'init_hyperparameters' not provided and could not be calculated. Please provide them ")
 
-        if hyperparameter_bounds is None:
-            warnings.warn("hyperparameter_bounds not provided. "
-                          "They will have to be provided in the training call.")
-        self.hyperparameter_bounds = hyperparameter_bounds
-
         if gp2Scale:
             try:
                 import imate
@@ -282,19 +267,19 @@ class GP:
         ###init prior instance##################
         ########################################
         self.prior = GPprior(self.data.input_space_dim,
-                            self.data.x_data,
-                            self.data.Euclidean,
-                            hyperparameters=hyperparameters,
-                            gp_kernel_function=gp_kernel_function,
-                            gp_mean_function=gp_mean_function,
-                            gp_kernel_function_grad=gp_kernel_function_grad,
-                            gp_mean_function_grad=gp_mean_function_grad,
-                            constant_mean=np.mean(y_data),
-                            gp2Scale=gp2Scale,
-                            gp2Scale_dask_client=gp2Scale_dask_client,
-                            gp2Scale_batch_size=gp2Scale_batch_size,
-                            ram_economy=ram_economy
-                            )
+                             self.data.x_data,
+                             self.data.Euclidean,
+                             hyperparameters=hyperparameters,
+                             gp_kernel_function=gp_kernel_function,
+                             gp_mean_function=gp_mean_function,
+                             gp_kernel_function_grad=gp_kernel_function_grad,
+                             gp_mean_function_grad=gp_mean_function_grad,
+                             constant_mean=np.mean(y_data),
+                             gp2Scale=gp2Scale,
+                             gp2Scale_dask_client=gp2Scale_dask_client,
+                             gp2Scale_batch_size=gp2Scale_batch_size,
+                             ram_economy=ram_economy
+                             )
         ########################################
         ###init likelihood instance#############
         ########################################
@@ -389,22 +374,26 @@ class GP:
         self.x_data = self.data.x_data
         self.y_data = self.data.y_data
 
-    def _get_default_hyperparameters(self, hyperparameter_bounds):
+    def _get_default_hyperparameter_bounds(self):
         """
-        This function will create hyperparameter bounds and init hyperparameters
-        for the default kernel.
-        """
-        if hyperparameter_bounds is None:
-            hyperparameter_bounds = np.zeros((self.data.input_space_dim + 1, 2))
-            hyperparameter_bounds[0] = np.array([np.var(self.data.y_data) / 100., np.var(self.data.y_data) * 10.])
-            for i in range(self.data.input_space_dim):
-                range_xi = np.max(self.data.x_data[:, i]) - np.min(self.data.x_data[:, i])
-                hyperparameter_bounds[i + 1] = np.array([range_xi / 100., range_xi * 10.])
+        This function will create hyperparameter bounds for the default kernel based
+        on the data only.
 
-        init_hyperparameters = np.random.uniform(low=hyperparameter_bounds[:, 0],
-                                                 high=hyperparameter_bounds[:, 1],
-                                                 size=len(hyperparameter_bounds))
-        return init_hyperparameters, hyperparameter_bounds
+        Return:
+        --------
+        hyperparameter bounds for the default kernel : np.ndarray
+        """
+        if not self.data.Euclidean: raise Exception("Please provide custom hyperparameter bounds to "
+                                                    "the training in the non-Euclidean setting")
+        if len(self.prior.hyperparameters) != self.data.input_space_dim + 1:
+            raise Exception("Please provide custom hyperparameter_bounds when kernel, mean or noise"
+                            " functions are customized")
+        hyperparameter_bounds = np.zeros((self.data.input_space_dim + 1, 2))
+        hyperparameter_bounds[0] = np.array([np.var(self.data.y_data) / 100., np.var(self.data.y_data) * 10.])
+        for i in range(self.data.input_space_dim):
+            range_xi = np.max(self.data.x_data[:, i]) - np.min(self.data.x_data[:, i])
+            hyperparameter_bounds[i + 1] = np.array([range_xi / 100., range_xi * 10.])
+        return hyperparameter_bounds
 
     ###################################################################################
     ###################################################################################
@@ -412,10 +401,10 @@ class GP:
     #################TRAINING##########################################################
     ###################################################################################
     def train(self,
+              hyperparameter_bounds=None,
               objective_function=None,
               objective_function_gradient=None,
               objective_function_hessian=None,
-              hyperparameter_bounds=None,
               init_hyperparameters=None,
               method="global",
               pop_size=20,
@@ -434,6 +423,11 @@ class GP:
 
         Parameters
         ----------
+        hyperparameter_bounds : np.ndarray
+            A numpy array of shape (D x 2), defining the bounds for the optimization.
+            A 2d numpy array of shape (N x 2), where N is the number of hyperparameters.
+            If the data set changes significantly,
+            the hyperparameters and the bounds should be changed/retrained.
         objective_function : callable, optional
             The function that will be MINIMIZED for training the GP. The form of the function is f(hyperparameters=hps)
             and returns a scalar. This function can be used to train via non-standard user-defined objectives.
@@ -450,13 +444,6 @@ class GP:
             and returns a matrix of shape(len(hps),len(hps)). This function can be used to train
             via non-standard user-defined objectives.
             The default is the hessian of the negative log marginal likelihood.
-        hyperparameter_bounds : np.ndarray, optional
-            A numpy array of shape (D x 2), defining the bounds for the optimization.
-            A 2d numpy array of shape (N x 2), where N is the number of hyperparameters.
-            The default is None, in which case the hyperparameter_bounds are estimated from the domain size
-            and the y_data. If the data set changes significantly,
-            the hyperparameters and the bounds should be changed/retrained.
-            The default only works for the default kernels.
         init_hyperparameters : np.ndarray, optional
             Initial hyperparameters used as starting location for all optimizers with local component.
             The default is a random draw from a uniform distribution within the bounds.
@@ -485,23 +472,29 @@ class GP:
             A Dask Distributed Client instance for distributed training if HGDL is used. If None is provided, a new
             `dask.distributed.Client` instance is constructed.
         """
+        if self.gp2Scale: method = 'mcmc'
         if hyperparameter_bounds is None:
-            if self.hyperparameter_bounds is None: raise Exception("Please provide hyperparameter_bounds")
-            hyperparameter_bounds = self.hyperparameter_bounds
-        if init_hyperparameters is None: init_hyperparameters = self.prior.hyperparameters
-        if init_hyperparameters is None: init_hyperparameters = np.random.uniform(low=hyperparameter_bounds[:, 0],
-                                                                                  high=hyperparameter_bounds[:, 1],
-                                                                                  size=len(hyperparameter_bounds))
+            hyperparameter_bounds = self._get_default_hyperparameter_bounds()
+            warnings.warn("Default hyperparameter_bounds initialized because none were provided. "
+                          "This will fail for custom kernel,"
+                          " mean, or noise functions")
+        if init_hyperparameters is None:
+            init_hyperparameters = np.random.uniform(low=hyperparameter_bounds[:, 0],
+                                                     high=hyperparameter_bounds[:, 1],
+                                                     size=len(hyperparameter_bounds))
         if objective_function is not None and method == 'mcmc':
             warnings.warn("MCMC will ignore the user-defined objective function")
         if objective_function is not None and objective_function_gradient is None and (method == 'local' or 'hgdl'):
             raise Exception("For user-defined objective functions and local or hybrid optimization, a gradient and\
                              Hessian function of the objective function have to be defined.")
+        if method == 'mcmc': objective_function = self.marginal_density.log_likelihood
         if objective_function is None: objective_function = self.marginal_density.neg_log_likelihood
-        if objective_function is None and method == 'mcmc': objective_function = self.marginal_density.log_likelihood
         if objective_function_gradient is None: objective_function_gradient = self.marginal_density.neg_log_likelihood_gradient
         if objective_function_hessian is None: objective_function_hessian = self.marginal_density.neg_log_likelihood_hessian
 
+        logger.info("objective function: {}", objective_function)
+        logger.info("method: {}", method)
+
         hyperparameters = self.trainer.train(
             objective_function=objective_function,
             objective_function_gradient=objective_function_gradient,
@@ -525,10 +518,10 @@ class GP:
 
     ##################################################################################
     def train_async(self,
+                    hyperparameter_bounds=None,
                     objective_function=None,
                     objective_function_gradient=None,
                     objective_function_hessian=None,
-                    hyperparameter_bounds=None,
                     init_hyperparameters=None,
                     max_iter=10000,
                     local_optimizer="L-BFGS-B",
@@ -544,6 +537,11 @@ class GP:
 
         Parameters
         ----------
+        hyperparameter_bounds : np.ndarray
+            A numpy array of shape (D x 2), defining the bounds for the optimization.
+            A 2d numpy array of shape (N x 2), where N is the number of hyperparameters.
+            If the data set changes significantly,
+            the hyperparameters and the bounds should be changed/retrained.
         objective_function : callable, optional
             The function that will be MINIMIZED for training the GP. The form of the function is f(hyperparameters=hps)
             and returns a scalar. This function can be used to train via non-standard user-defined objectives.
@@ -560,13 +558,6 @@ class GP:
             and returns a matrix of shape(len(hps),len(hps)). This function can be used to train
             via non-standard user-defined objectives.
             The default is the hessian of the negative log marginal likelihood.
-        hyperparameter_bounds : np.ndarray, optional
-            A numpy array of shape (D x 2), defining the bounds for the optimization.
-            A 2d numpy array of shape (N x 2), where N is the number of hyperparameters.
-            The default is None, in which case the hyperparameter_bounds are estimated from the domain size
-            and the y_data. If the data set changes significantly,
-            the hyperparameters and the bounds should be changed/retrained.
-            The default only works for the default kernels.
         init_hyperparameters : np.ndarray, optional
             Initial hyperparameters used as starting location for all optimizers with local component.
             The default is a random draw from a uniform distribution within the bounds.
@@ -589,14 +580,15 @@ class GP:
         to update the prior GP : object instance
         """
         if self.gp2Scale: raise Exception("gp2Scale does not allow asynchronous training!")
-        if dask_client is None: dask_client = distributed.Client()
         if hyperparameter_bounds is None:
-            if self.hyperparameter_bounds is None: raise Exception("Please provide hyperparameter_bounds")
-            hyperparameter_bounds = self.hyperparameter_bounds
-        if init_hyperparameters is None: init_hyperparameters = self.prior.hyperparameters
-        if init_hyperparameters is None: init_hyperparameters = np.random.uniform(low=hyperparameter_bounds[:, 0],
-                                                                                  high=hyperparameter_bounds[:, 1],
-                                                                                  size=len(hyperparameter_bounds))
+            hyperparameter_bounds = self._get_default_hyperparameter_bounds()
+            warnings.warn("Default hyperparameter_bounds initialized because none were provided. "
+                          "This will fail for custom kernel,"
+                          " mean, or noise functions")
+        if init_hyperparameters is None:
+            init_hyperparameters = np.random.uniform(low=hyperparameter_bounds[:, 0],
+                                                     high=hyperparameter_bounds[:, 1],
+                                                     size=len(hyperparameter_bounds))
         if objective_function is None: objective_function = self.marginal_density.neg_log_likelihood
         if objective_function_gradient is None: objective_function_gradient = self.marginal_density.neg_log_likelihood_gradient
         if objective_function_hessian is None: objective_function_hessian = self.marginal_density.neg_log_likelihood_hessian
@@ -725,8 +717,7 @@ class GP:
         A dictionary containing information about the GP prior distribution : dict
         """
 
-        return {"prior covariance (K)": self.prior.K, "log(|KV|)": self.marginal_density.KVlogdet,
-                "inv(KV)": self.marginal_density.KVinv,
+        return {"prior covariance (K)": self.prior.K,
                 "prior mean": self.prior.m}
 
     def log_likelihood(self, hyperparameters=None):
@@ -1296,8 +1287,8 @@ class GP:
     ####################################################################################
     def _crps_s(self, x, mu, sigma):
         res = abs(sigma * ((1. / np.sqrt(np.pi))
-                                    - 2. * norm.pdf((x - mu) / sigma)
-                                    - (((x - mu) / sigma) * (2. * norm.cdf((x - mu) / sigma) - 1.))))
+                           - 2. * norm.pdf((x - mu) / sigma)
+                           - (((x - mu) / sigma) * (2. * norm.cdf((x - mu) / sigma) - 1.))))
         return np.mean(res), np.sqrt(np.var(res))
 
     def crps(self, x_test, y_test):
@@ -1341,8 +1332,8 @@ class GP:
         RMSE : float
         """
 
-        v1 = y_test
-        v2 = self.posterior_mean(x_test)["f(x)"]
+        v1 = y_test.reshape(len(y_test))
+        v2 = self.posterior_mean(x_test)["f(x)"].reshape(len(v1))
         return np.sqrt(np.sum((v1 - v2) ** 2) / len(v1))
 
     def make_2d_x_pred(self, bx, by, resx=100, resy=100):  # pragma: no cover