restructuring and new solves in gp2Scales

fvgp/data.py

@@ -0,0 +1,55 @@
+import numpy as np
+
+
+class Data:
+    def __init__(self, x_data, y_data, noise_variances=None):
+        # make sure the inputs are in the right format
+        assert isinstance(x_data, np.ndarray) or isinstance(x_data, list)
+        assert isinstance(y_data, np.ndarray) and np.ndim(y_data) == 1
+        assert ((isinstance(noise_variances, np.ndarray) and np.ndim(noise_variances) == 1)
+                or noise_variances is None)
+        assert len(x_data) == len(y_data)
+        if noise_variances is not None: assert len(x_data) == len(noise_variances)
+
+        # analyse data
+        if isinstance(x_data, np.ndarray):
+            assert np.ndim(x_data) == 2
+            self.input_space_dim = len(x_data[0])
+            self.Euclidean = True
+        if isinstance(x_data, list):
+            self.input_space_dim = 1
+            self.Euclidean = False
+
+        self.x_data = x_data
+        self.y_data = y_data
+        self.noise_variances = noise_variances
+        self.point_number = len(self.x_data)
+
+    def update_data(self, x_data_new, y_data_new, noise_variances_new=None, append=True):
+        assert isinstance(x_data_new, np.ndarray) or isinstance(x_data_new, list)
+        assert isinstance(y_data_new, np.ndarray) and np.ndim(y_data_new) == 1
+        assert ((isinstance(noise_variances_new, np.ndarray) and np.ndim(noise_variances_new) == 1)
+                or noise_variances_new is None)
+        if self.Euclidean:
+            assert isinstance(x_data_new, np.ndarray) and np.ndim(x_data_new) == 2
+        else:
+            assert isinstance(x_data_new, list)
+        if self.noise_variances and noise_variances_new is None:
+            raise Exception("Please provide noise_variances in the data update.")
+
+        if append is False:
+            self.x_data = x_data_new
+            self.y_data = y_data_new
+        else:
+            if self.Euclidean:
+                np.row_stack([self.x_data, x_data_new])
+            else:
+                self.x_data = self.x_data + x_data_new
+            self.y_data = np.append(self.y_data, y_data_new)
+            if noise_variances_new is not None:
+                self.noise_variances = np.append(self.noise_variances, noise_variances_new)
+        self.point_number = len(self.x_data)
+
+    def is_nan(self):
+        if np.sum(self.x_data) + np.sum(self.y_data) == np.nan: return True
+        else: return False

fvgp/gp2Scale.py

@@ -12,7 +12,6 @@
 class gp2Scale():
     def __init__(
         self,
-        #x_data,
         batch_size=10000,
         gp_kernel_function=None,
         covariance_dask_client=None,
@@ -27,14 +26,14 @@ def __init__(
         self.point_number = None
         self.num_batches = None
         self.info = info
-        #self.x_data = x_data
         self.kernel = gp_kernel_function
         self.number_of_workers = len(covariance_dask_client.scheduler_info()['workers'])
         self.cov_initialized = False
 
         worker_info = list(covariance_dask_client.scheduler_info()["workers"].keys())
         if not worker_info: raise Exception("No workers available")
         self.compute_workers = list(worker_info)
+        self.client = covariance_dask_client
 
         self.x_data_scatter_future = None
         self.x_new_scatter_future = None
@@ -67,8 +66,9 @@ def update_x_data(self, x_new):
             self.x_data = np.row_stack([self.x_data, x_new])
         else: raise Exception("x_data or x_new is not of a permissible format.")
 
-    def compute_covariance(self, x_data, hyperparameters, client):
+    def compute_covariance(self, x_data, hyperparameters):
         """computes the covariance matrix from the kernel on HPC in sparse format"""
+        client = self.client
         self.cov_initialized = True
         self.point_number = len(x_data)
         self.num_batches = self.point_number // self.batch_size
@@ -101,7 +101,8 @@ def compute_covariance(self, x_data, hyperparameters, client):
 
         return sparse.coo_matrix((data, (i_s, j_s)))
 
-    def update_covariance(self, x_new, hyperparameters, client, cov):
+    def update_covariance(self, x_new, hyperparameters, cov):
+        client = self.client
         """computes the covariance matrix from the kernel on HPC in sparse format"""
         if not self.cov_initialized:
             raise Exception("Before updating the covariance, you have to compute a covariance.")
@@ -163,7 +164,14 @@ def harvest_result(future_result):
         future.release()
         return result
 
-    def calculate_sparse_noise_covariance(self, vector):
+    def calculate_sparse_noise_covariance(self, x, hyperparameters, obj):
+        vector = obj.noise_variances
+        diag = sparse.eye(len(vector), format="coo")
+        diag.setdiag(vector)
+        return diag
+
+    def calculate_sparse_default_noise_covariance(self, x, hyperparameters, obj):
+        vector = np.ones((len(x))) * (np.mean(abs(obj.y_data)) / 100.0)
         diag = sparse.eye(len(vector), format="coo")
         diag.setdiag(vector)
         return diag