sgptools 1.2.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

sgptools/models/bo.py

@@ -1,118 +0,0 @@
-# Copyright 2024 The SGP-Tools Contributors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import numpy as np
-from ..utils.metrics import get_mi
-from ..utils.data import get_inducing_pts
-from bayes_opt import BayesianOptimization
-
-
-class BayesianOpt:
-    """Class for optimizing sensor placements using Bayesian Optimization
-
-    Refer to the following papers for more details:
-        - UAV route planning for active disease classification [Vivaldini et al., 2019]
-        - Occupancy map building through Bayesian exploration [Francis et al., 2019]
-
-    Args:
-        X_train (ndarray): (n, d); Locations in the environment used to approximate the monitoring regions
-        noise_variance (float): data variance
-        kernel (gpflow.kernels.Kernel): gpflow kernel function
-        transform (Transform): Transform object
-    """
-    def __init__(self, X_train, noise_variance, kernel,
-                 transform=None):
-        self.X_train = X_train
-        self.noise_variance = noise_variance
-        self.kernel = kernel
-        self.num_dim = X_train.shape[-1]
-        self.transform = transform
-
-        # use the boundaries of the region as the search space
-        self.pbounds_dim = []
-        for i in range(self.num_dim):
-            self.pbounds_dim.append((np.min(X_train[:, i]), np.max(X_train[:, i])))
-  
-    def objective(self, **kwargs):
-        """Objective function (GP-based Mutual Information)
-
-        Args:
-            x<i> (ndarray): (1, d); Current solution sensor placement location i
-        """
-        # MI does not depend on waypoint order (reshape to -1, num_dim)
-        X = []
-        for i in range(len(kwargs)):
-            X.append(kwargs['x{}'.format(i)])
-        X = np.array(X).reshape(-1, self.num_dim)
-        if self.transform is not None:
-            X = self.transform.expand(X)
-            constraints_loss = self.transform.constraints(X)
-
-        try:
-            mi = get_mi(X, self.X_train, self.noise_variance, self.kernel)
-            mi += constraints_loss
-            mi = mi.numpy()
-        except:
-            mi = -1e4 # if the cholskey decomposition fails
-        return mi
-
-    def optimize(self, 
-                 num_sensors=10, 
-                 max_steps=100,  
-                 X_init=None,
-                 init_points=10,
-                 verbose=0, 
-                 seed=1234):
-        """Optimizes the sensor placements using Bayesian Optimization without any constraints
-
-        Args:
-            num_sensors (int): Number of sensor locations to optimize.
-            max_steps (int): Maximum number of optimization steps. 
-            X_init (ndarray): (m, d); Initial inducing points.
-            init_points (int): Number of random solutions used for initial exploration. 
-                               Random exploration can help by diversifying the exploration space. 
-            verbose (int): The level of verbosity.
-            seed (int): The algorithm will use it to seed the randomnumber generator, ensuring replicability.
-
-        Returns:
-            Xu (ndarray): (m, d); Solution sensor placement locations
-        """
-        if X_init is None:
-            X_init = get_inducing_pts(self.X_train, num_sensors, random=True)
-        else:
-            num_sensors = len(X_init.reshape(-1, self.num_dim))
-        X_init = X_init.reshape(-1)
-
-        pbounds = {}
-        for i in range(self.num_dim*num_sensors):
-            pbounds['x{}'.format(i)] = self.pbounds_dim[i%self.num_dim]
-
-        optimizer = BayesianOptimization(f=self.objective,
-                                         pbounds=pbounds,
-                                         verbose=verbose,
-                                         random_state=seed,
-                                         allow_duplicate_points=True)
-        optimizer.maximize(init_points=init_points,
-                           n_iter=max_steps)
-
-        sol = []
-        for i in range(self.num_dim*num_sensors):
-            sol.append(optimizer.max['params']['x{}'.format(i)])
-        sol = np.array(sol).reshape(-1, self.num_dim)
-        if self.transform is not None:
-            sol = self.transform.expand(sol,
-                                        expand_sensor_model=False)
-            if not isinstance(sol, np.ndarray):
-                sol = sol.numpy()
-        return sol.reshape(-1, self.num_dim)

sgptools/models/cma_es.py

@@ -1,121 +0,0 @@
-# Copyright 2024 The SGP-Tools Contributors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import cma
-import numpy as np
-from shapely import geometry
-from ..utils.metrics import get_mi
-from ..utils.data import get_inducing_pts
-
-
-class CMA_ES:
-    """Class for optimizing sensor placements using CMA-ES (a genetic algorithm)
-
-    Refer to the following paper for more details:
-        - Adaptive Continuous-Space Informative Path Planning for Online Environmental Monitoring [Hitz et al., 2017]
-
-    Args:
-        X_train (ndarray): (n, d); Locations in the environment used to approximate the monitoring regions
-        noise_variance (float): data variance
-        kernel (gpflow.kernels.Kernel): gpflow kernel function
-        distance_budget (float): Distance budget for when treating the inducing points 
-                                 as waypoints of a path
-        num_robots (int): Number of robots, used when modeling 
-                          multi-robot IPP with a distance budget
-        transform (Transform): Transform object
-    """
-    def __init__(self, X_train, noise_variance, kernel,
-                 distance_budget=None,
-                 num_robots=1,
-                 transform=None):
-        self.boundaries = geometry.MultiPoint([[p[0], p[1]] for p in X_train]).convex_hull
-        self.X_train = X_train
-        self.noise_variance = noise_variance
-        self.kernel = kernel
-        self.num_dim = X_train.shape[-1]
-        self.distance_budget = distance_budget
-        self.num_robots = num_robots
-        self.transform = transform
-
-    def update(self, noise_variance, kernel):
-        """Update GP noise variance and kernel function parameters
-
-        Args:
-            noise_variance (float): data variance
-            kernel (gpflow.kernels.Kernel): gpflow kernel function
-        """
-        self.noise_variance = noise_variance
-        self.kernel = kernel
-    
-    def objective(self, X):
-        """Objective function (GP-based Mutual Information)
-
-        Args:
-            X (ndarray): (n, d); Current solution sensor placement locations
-        """
-        # MI does not depend on waypoint order (reshape to -1, num_dim)
-        X = np.array(X).reshape(-1, self.num_dim)
-        constraints_loss = 0.0
-        if self.transform is not None:
-            X = self.transform.expand(X)
-            constraints_loss = self.transform.constraints(X)
-
-        try:
-            mi = -get_mi(X, self.X_train, self.noise_variance, self.kernel)
-            mi -= constraints_loss
-            mi = mi.numpy()
-        except:
-            mi = 0.0 # if the cholskey decomposition fails
-        return mi
-    
-    def optimize(self, 
-                 num_sensors=10, 
-                 max_steps=5000, 
-                 tol=1e-6, 
-                 X_init=None,
-                 verbose=0,
-                 seed=1234):
-        """Optimizes the sensor placements using CMA-ES without any constraints
-
-        Args:
-            num_sensors (int): Number of sensor locations to optimize
-            max_steps (int): Maximum number of optimization steps
-            tol (float): Convergence tolerance to decide when to stop optimization
-            X_init (ndarray): (m, d); Initial inducing points
-            verbose (int): The level of verbosity.
-            seed (int): The algorithm will use it to seed the randomnumber generator, ensuring replicability.
-            
-        Returns:
-            Xu (ndarray): (m, d); Solution sensor placement locations
-        """
-        sigma0 = 1.0
-        
-        if X_init is None:
-            X_init = get_inducing_pts(self.X_train, num_sensors, random=True)
-        X_init = X_init.reshape(-1)
-
-        xopt, _ = cma.fmin2(self.objective, X_init, sigma0, 
-                            options={'maxfevals': max_steps,
-                                     'verb_disp': verbose,
-                                     'tolfun': tol,
-                                     'seed': seed},
-                            restarts=5)
-        
-        xopt = np.array(xopt).reshape(-1, self.num_dim)
-        if self.transform is not None:
-            xopt = self.transform.expand(xopt, 
-                                         expand_sensor_model=False)
-            if not isinstance(xopt, np.ndarray):
-                xopt = xopt.numpy()
-        return xopt.reshape(-1, self.num_dim)

sgptools/models/continuous_sgp.py

@@ -1,68 +0,0 @@
-# Copyright 2024 The SGP-Tools Contributors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import numpy as np
-
-from ..utils.data import get_inducing_pts
-from ..utils.gpflow import optimize_model
-
-from .core.augmented_sgpr import AugmentedSGPR
-
-
-def continuous_sgp(num_inducing, X_train, noise_variance, kernel, 
-                   transform=None,
-                   Xu_init=None, 
-                   Xu_time=None, 
-                   orientation=False,
-                   **kwargs):
-    """Get sensor placement solutions using the Continuous-SGP method
-
-    Refer to the following papers for more details:
-        - Efficient Sensor Placement from Regression with Sparse Gaussian Processes in Continuous and Discrete Spaces [[Jakkala and Akella, 2023](https://www.itskalvik.com/publication/sgp-sp/)]
-        - Multi-Robot Informative Path Planning from Regression with Sparse Gaussian Processes [[Jakkala and Akella, 2024](https://www.itskalvik.com/publication/sgp-ipp/)]
-
-    Args:
-        num_inducing (int): Number of inducing points
-        X_train (ndarray): (n, d); Unlabeled random sampled training points
-        noise_variance (float): data variance
-        kernel (gpflow.kernels.Kernel): gpflow kernel function
-        transform (Transform): Transform object
-        Xu_init (ndarray): (m, d); Initial inducing points
-        Xu_time (ndarray): (t, d); Temporal inducing points used in spatio-temporal models
-        orientation (bool): If True, a additionl dimension is added to the 
-                            inducing points to represent the FoV orientation
-
-    Returns:
-        sgpr (AugmentedSGPR): Optimized sparse Gaussian process model
-        loss (ndarray): Loss values computed during training
-    """
-    # Generate init inducing points
-    if Xu_init is None:
-        Xu_init = get_inducing_pts(X_train, num_inducing, 
-                                   orientation=orientation)
-
-    # Fit spare GP
-    sgpr = AugmentedSGPR((X_train, np.zeros((len(X_train), 1)).astype(X_train.dtype)),
-                         noise_variance=noise_variance,
-                         kernel=kernel, 
-                         inducing_variable=Xu_init,
-                         inducing_variable_time=Xu_time,
-                         transform=transform)
-
-    # Train the mode
-    loss = optimize_model(sgpr,
-                          kernel_grad=False, 
-                          **kwargs)
-
-    return sgpr, loss

sgptools/models/core/__init__.py

@@ -1,9 +0,0 @@
-# sgptools/models/core/__init__.py
-
-"""Core modules in this package:
-
-- `augmented_gpr`: Provides a Gaussian process model with expand and aggregate functions
-- `augmented_sgpr`: Provides a sparse Gaussian process model with update, expand, and aggregate functions
-- `osgpr`: Provides a streaming sparse Gaussian process model along with initialization function
-- `transformations`: Provides transforms to model complex sensor field of views and handle informative path planning
-"""

sgptools/models/core/osgpr.py

@@ -1,291 +0,0 @@
-# Copyright 2024 The streaming_sparse_gp Contributors. All Rights Reserved.
-# https://github.com/thangbui/streaming_sparse_gp/tree/master
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Provides a streaming sparse Gaussian process model along with initialization function
-"""
-
-import tensorflow as tf
-import numpy as np
-
-import gpflow
-from gpflow.inducing_variables import InducingPoints
-from gpflow.models import GPModel, InternalDataTrainingLossMixin
-from gpflow import covariances
-from ...utils.data import get_inducing_pts
-
-
-class OSGPR_VFE(GPModel, InternalDataTrainingLossMixin):
-    """Online Sparse Variational GP regression model from [streaming_sparse_gp](https://github.com/thangbui/streaming_sparse_gp/tree/master)
-
-    Refer to the following paper for more details:
-        - Streaming Gaussian process approximations [Bui et al., 2017]
-
-    Args:
-        data (tuple): (X, y) ndarrays with inputs (n, d) and labels (n, 1)
-        kernel (gpflow.kernels.Kernel): gpflow kernel function
-        mu_old (ndarray): mean of old `q(u)`; here `u` are the latents corresponding to the inducing points `Z_old`
-        Su_old (ndarray): posterior covariance of old `q(u)`
-        Kaa_old (ndarray): prior covariance of old `q(u)`
-        Z_old (ndarray): (m_old, d): Old initial inducing points
-        Z (ndarray): (m_new, d): New initial inducing points
-        mean_function (function): GP mean function
-    """
-    def __init__(self, data, kernel, mu_old, Su_old, Kaa_old, Z_old, Z, mean_function=None):
-        self.X, self.Y = self.data = gpflow.models.util.data_input_to_tensor(data)
-        likelihood = gpflow.likelihoods.Gaussian()
-        num_latent_gps = GPModel.calc_num_latent_gps_from_data(data, kernel, likelihood)
-        super().__init__(kernel, likelihood, mean_function, num_latent_gps)
-
-        self.inducing_variable = InducingPoints(Z)
-        self.num_data = self.X.shape[0]
-
-        self.mu_old = tf.Variable(mu_old, shape=tf.TensorShape(None), trainable=False)
-        self.M_old = Z_old.shape[0]
-        self.Su_old = tf.Variable(Su_old, shape=tf.TensorShape(None), trainable=False)
-        self.Kaa_old = tf.Variable(Kaa_old, shape=tf.TensorShape(None), trainable=False)
-        self.Z_old = tf.Variable(Z_old, shape=tf.TensorShape(None), trainable=False)
-
-    def init_Z(self):
-        M = self.inducing_variable.Z.shape[0]
-        M_old = int(0.7 * M)
-        M_new = M - M_old
-        old_Z = self.Z_old.numpy()[np.random.permutation(M)[0:M_old], :]
-        new_Z = self.X.numpy()[np.random.permutation(self.X.shape[0])[0:M_new], :]
-        Z = np.vstack((old_Z, new_Z))
-        return Z
-
-    def update(self, data, inducing_variable=None, update_inducing=True):
-        """Configure the OSGPR to adapt to a new batch of data. 
-        Note: The OSGPR needs to be trained using gradient-based approaches after update.
-
-        Args:
-            data (tuple): (X, y) ndarrays with new batch of inputs (n, d) and labels (n, ndim)
-            inducing_variable (ndarray): (m_new, d): New initial inducing points
-            update_inducing (bool): Whether to update the inducing points
-        """
-        self.X, self.Y = self.data = gpflow.models.util.data_input_to_tensor(data)
-        self.num_data = self.X.shape[0]
-
-        # Update the inducing points        
-        self.Z_old.assign(self.inducing_variable.Z.numpy())
-        if inducing_variable is None and update_inducing:
-            inducing_variable = self.init_Z()
-        if inducing_variable is not None:
-            self.inducing_variable.Z.assign(inducing_variable)
-
-        # Get posterior mean and covariance for the old inducing points
-        mu_old, Su_old = self.predict_f(self.Z_old, full_cov=True)
-        self.mu_old.assign(mu_old.numpy())
-        self.Su_old.assign(Su_old.numpy())
-
-        # Get the prior covariance matrix for the old inducing points
-        Kaa_old = self.kernel(self.Z_old)
-        self.Kaa_old.assign(Kaa_old.numpy())
-
-    def _common_terms(self):
-        Mb = self.inducing_variable.num_inducing
-        Ma = self.M_old
-        # jitter = gpflow.default_jitter()
-        jitter = gpflow.utilities.to_default_float(1e-4)
-        sigma2 = self.likelihood.variance
-        sigma = tf.sqrt(sigma2)
-
-        Saa = self.Su_old
-        ma = self.mu_old
-
-        # a is old inducing points, b is new
-        # f is training points
-        # s is test points
-        Kbf = covariances.Kuf(self.inducing_variable, self.kernel, self.X)
-        Kbb = covariances.Kuu(self.inducing_variable, self.kernel, jitter=jitter)
-        Kba = covariances.Kuf(self.inducing_variable, self.kernel, self.Z_old)
-        Kaa_cur = gpflow.utilities.add_noise_cov(self.kernel(self.Z_old), jitter)
-        Kaa = gpflow.utilities.add_noise_cov(self.Kaa_old, jitter)
-
-        err = self.Y - self.mean_function(self.X)
-
-        Sainv_ma = tf.linalg.solve(Saa, ma)
-        Sinv_y = self.Y / sigma2
-        c1 = tf.matmul(Kbf, Sinv_y)
-        c2 = tf.matmul(Kba, Sainv_ma)
-        c = c1 + c2
-
-        Lb = tf.linalg.cholesky(Kbb)
-        Lbinv_c = tf.linalg.triangular_solve(Lb, c, lower=True)
-        Lbinv_Kba = tf.linalg.triangular_solve(Lb, Kba, lower=True)
-        Lbinv_Kbf = tf.linalg.triangular_solve(Lb, Kbf, lower=True) / sigma
-        d1 = tf.matmul(Lbinv_Kbf, Lbinv_Kbf, transpose_b=True)
-
-        LSa = tf.linalg.cholesky(Saa)
-        Kab_Lbinv = tf.linalg.matrix_transpose(Lbinv_Kba)
-        LSainv_Kab_Lbinv = tf.linalg.triangular_solve(
-            LSa, Kab_Lbinv, lower=True)
-        d2 = tf.matmul(LSainv_Kab_Lbinv, LSainv_Kab_Lbinv, transpose_a=True)
-
-        La = tf.linalg.cholesky(Kaa)
-        Lainv_Kab_Lbinv = tf.linalg.triangular_solve(
-            La, Kab_Lbinv, lower=True)
-        d3 = tf.matmul(Lainv_Kab_Lbinv, Lainv_Kab_Lbinv, transpose_a=True)
-
-        D = tf.eye(Mb, dtype=gpflow.default_float()) + d1 + d2 - d3
-        D = gpflow.utilities.add_noise_cov(D, jitter)
-        LD = tf.linalg.cholesky(D)
-
-        LDinv_Lbinv_c = tf.linalg.triangular_solve(LD, Lbinv_c, lower=True)
-
-        return (Kbf, Kba, Kaa, Kaa_cur, La, Kbb, Lb, D, LD,
-                Lbinv_Kba, LDinv_Lbinv_c, err, d1)
-
-    def maximum_log_likelihood_objective(self):
-        """
-        Construct a tensorflow function to compute the bound on the marginal
-        likelihood. 
-        """
-
-        Mb = self.inducing_variable.num_inducing
-        Ma = self.M_old
-        jitter = gpflow.default_jitter()
-        # jitter = gpflow.utilities.to_default_float(1e-4)
-        sigma2 = self.likelihood.variance
-        sigma = tf.sqrt(sigma2)
-        N = self.num_data
-
-        Saa = self.Su_old
-        ma = self.mu_old
-
-        # a is old inducing points, b is new
-        # f is training points
-        Kfdiag = self.kernel(self.X, full_cov=False)
-        (Kbf, Kba, Kaa, Kaa_cur, La, Kbb, Lb, D, LD,
-            Lbinv_Kba, LDinv_Lbinv_c, err, Qff) = self._common_terms()
-
-        LSa = tf.linalg.cholesky(Saa)
-        Lainv_ma = tf.linalg.triangular_solve(LSa, ma, lower=True)
-
-        # constant term
-        bound = -0.5 * N * np.log(2 * np.pi)
-        # quadratic term
-        bound += -0.5 * tf.reduce_sum(tf.square(err)) / sigma2
-        # bound += -0.5 * tf.reduce_sum(ma * Sainv_ma)
-        bound += -0.5 * tf.reduce_sum(tf.square(Lainv_ma))
-        bound += 0.5 * tf.reduce_sum(tf.square(LDinv_Lbinv_c))
-        # log det term
-        bound += -0.5 * N * tf.reduce_sum(tf.math.log(sigma2))
-        bound += - tf.reduce_sum(tf.math.log(tf.linalg.diag_part(LD)))
-
-        # delta 1: trace term
-        bound += -0.5 * tf.reduce_sum(Kfdiag) / sigma2
-        bound += 0.5 * tf.reduce_sum(tf.linalg.diag_part(Qff))
-
-        # delta 2: a and b difference
-        bound += tf.reduce_sum(tf.math.log(tf.linalg.diag_part(La)))
-        bound += - tf.reduce_sum(tf.math.log(tf.linalg.diag_part(LSa)))
-
-        Kaadiff = Kaa_cur - tf.matmul(Lbinv_Kba, Lbinv_Kba, transpose_a=True)
-        Sainv_Kaadiff = tf.linalg.solve(Saa, Kaadiff)
-        Kainv_Kaadiff = tf.linalg.solve(Kaa, Kaadiff)
-
-        bound += -0.5 * tf.reduce_sum(
-            tf.linalg.diag_part(Sainv_Kaadiff) - tf.linalg.diag_part(Kainv_Kaadiff))
-
-        return bound
-
-    def predict_f(self, Xnew, full_cov=False):
-        """
-        Compute the mean and variance of the latent function at some new points
-        Xnew. 
-        """
-
-        # jitter = gpflow.default_jitter()
-        jitter = gpflow.utilities.to_default_float(1e-4)
-
-        # a is old inducing points, b is new
-        # f is training points
-        # s is test points
-        Kbs = covariances.Kuf(self.inducing_variable, self.kernel, Xnew)
-        (Kbf, Kba, Kaa, Kaa_cur, La, Kbb, Lb, D, LD,
-            Lbinv_Kba, LDinv_Lbinv_c, err, Qff) = self._common_terms()
-
-        Lbinv_Kbs = tf.linalg.triangular_solve(Lb, Kbs, lower=True)
-        LDinv_Lbinv_Kbs = tf.linalg.triangular_solve(LD, Lbinv_Kbs, lower=True)
-        mean = tf.matmul(LDinv_Lbinv_Kbs, LDinv_Lbinv_c, transpose_a=True)
-
-        if full_cov:
-            Kss = self.kernel(Xnew) + jitter * tf.eye(tf.shape(Xnew)[0], dtype=gpflow.default_float())
-            var1 = Kss
-            var2 = - tf.matmul(Lbinv_Kbs, Lbinv_Kbs, transpose_a=True)
-            var3 = tf.matmul(LDinv_Lbinv_Kbs, LDinv_Lbinv_Kbs, transpose_a=True)
-            var = var1 + var2 + var3
-        else:
-            var1 = self.kernel(Xnew, full_cov=False)
-            var2 = -tf.reduce_sum(tf.square(Lbinv_Kbs), axis=0)
-            var3 = tf.reduce_sum(tf.square(LDinv_Lbinv_Kbs), axis=0)
-            var = var1 + var2 + var3
-
-        return mean + self.mean_function(Xnew), var
-
-
-def init_osgpr(X_train, 
-               num_inducing=10, 
-               lengthscales=1.0, 
-               variance=1.0,
-               noise_variance=0.001,
-               kernel=None,
-               ndim=1):
-    """Initialize a VFE OSGPR model with an RBF kernel with 
-    unit variance and lengthcales, and 0.001 noise variance.
-    Used in the Online Continuous SGP approach. 
-
-    Args:
-        X_train (ndarray): (n, d); Unlabeled random sampled training points. 
-                        They only effect the initial inducing point locations, 
-                        i.e., limits them to the bounds of the data
-        num_inducing (int): Number of inducing points
-        lengthscales (float or list): Kernel lengthscale(s), if passed as a list, 
-                                each element corresponds to each data dimension
-        variance (float): Kernel variance
-        noise_variance (float): Data noise variance
-        kernel (gpflow.kernels.Kernel): gpflow kernel function
-        ndim (int): Number of output dimensions
-
-    Returns:
-        online_param (OSGPR_VFE): Initialized online sparse Gaussian process model
-    """
-
-    if kernel is None:
-        kernel = gpflow.kernels.SquaredExponential(lengthscales=lengthscales, 
-                                                   variance=variance)
-        
-    y_train = np.zeros((len(X_train), ndim), dtype=X_train.dtype)
-    Z_init = get_inducing_pts(X_train, num_inducing)
-    init_param = gpflow.models.SGPR((X_train, y_train),
-                                    kernel, 
-                                    inducing_variable=Z_init, 
-                                    noise_variance=noise_variance)
-    
-    # Initialize the OSGPR model using the parameters from the SGPR model
-    # The X_train and y_train here will be overwritten in the online phase 
-    X_train = np.zeros([2, X_train.shape[-1]], dtype=X_train.dtype)
-    y_train =  np.zeros([2, ndim], dtype=X_train.dtype)
-    Zopt = init_param.inducing_variable.Z.numpy()
-    mu, Su = init_param.predict_f(Zopt, full_cov=True)
-    Kaa = init_param.kernel(Zopt)
-    online_param = OSGPR_VFE((X_train[:2], y_train[:2]),
-                             init_param.kernel,
-                             mu, Su[0], Kaa,
-                             Zopt, Zopt)
-    online_param.likelihood.variance.assign(init_param.likelihood.variance)
-
-    return online_param