refactored for compatibility with new gpflow!

Author: aboustati

.travis.yml

@@ -11,7 +11,7 @@ before_install:
 
 install:
         - pip install numpy scipy pandas pytest pytest-cov codecov
-        - pip install https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.5.1-cp36-cp36m-linux_x86_64.whl
+        - pip install https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.8.0-cp36-cp36m-linux_x86_64.whl
         - pip install git+https://github.com/GPflow/GPflow
         - python setup.py install
 

dgplib/__init__.py

@@ -1,7 +1,7 @@
 from __future__ import absolute_import
 
 from . import layers
-from . import models
+from . import cascade
 from . import multikernel_layers
 from . import utils
 from . import specialized_kernels

dgplib/models.py renamed to dgplib/cascade.py

@@ -1,4 +1,3 @@
-import numpy as np
 import tensorflow as tf
 
 from gpflow import settings
@@ -31,7 +30,7 @@ class DSDGP(Model):
     """
     @defer_build()
     def __init__(self, X, Y, Z, layers, likelihood,
-                 num_latent_Y=None,
+                 num_latent=None,
                  minibatch_size=None,
                  num_samples=1,
                  mean_function=Zero(),
@@ -58,7 +57,9 @@ def __init__(self, X, Y, Z, layers, likelihood,
 
         self.num_data, D_X = X.shape
         self.num_samples = num_samples
-        self.D_Y = num_latent_Y or Y.shape[1]
+        self.D_Y = num_latent or Y.shape[1]
+
+        self.mean_function = mean_function
 
         layers.initialize_params(X, Z)#Maybe add initialization method for model
         if layers._initialized == True:

dgplib/dsdgp.py

@@ -10,8 +10,8 @@
 from gpflow.kullback_leiblers import gauss_kl
 from gpflow.mean_functions import Linear, Zero
 from gpflow.params import Parameter, Parameterized, ParamList
+from gpflow.features import inducingpoint_wrapper
 
-from .utils import shape_as_list
 
 class Layer(Parameterized):
     """
@@ -34,18 +34,18 @@ def __init__(self, input_dim, output_dim, num_inducing, kernel,
         self.output_dim = output_dim
         self.num_inducing = num_inducing
         if multitask:
-            self.Z = Parameter(np.zeros((self.num_inducing, self.input_dim+1)),
-                               fix_shape=True)
+            Z = np.zeros((self.num_inducing, self.input_dim + 1))
         else:
-            self.Z = Parameter(np.zeros((self.num_inducing, self.input_dim)),
-                               fix_shape=True)
+            Z = np.zeros((self.num_inducing, self.input_dim))
+
+        self.feature = inducingpoint_wrapper(None, Z)
 
         if isinstance(kernel, list):
             self.kernel = ParamList(kernel)
         else:
             self.kernel = kernel
 
-        self.mean_function = mean_function or Zero()
+        self.mean_function = mean_function or Zero(output_dim=self.output_dim)
 
         shape = (self.num_inducing, self.output_dim)
 
@@ -63,10 +63,7 @@ def build_prior_KL(self, K):
     def _build_predict(self, Xnew, full_cov=False, stochastic=True):
         # Credits to High Salimbeni for this (@hughsalimbeni)
         def f_conditional(Xnew, full_cov=False):
-            mean, var = conditional(Xnew=Xnew,
-                                    X=self.Z,
-                                    kern=self.kernel,
-                                    f=self.q_mu,
+            mean, var = conditional(Xnew, self.feature, self.kernel, self.q_mu,
                                     q_sqrt=self.q_sqrt,
                                     full_cov=full_cov,
                                     white=True)
@@ -75,14 +72,17 @@ def f_conditional(Xnew, full_cov=False):
 
         def multisample_conditional(Xnew, full_cov=False):
             if full_cov:
-                f = lambda a: f_conditional(a, full_cov=full_cov)
+                def f(a):
+                    m, v = f_conditional(a, full_cov=full_cov)
+                    return  m, tf.transpose(v)
+                #f = lambda a: f_conditional(a, full_cov=full_cov)
                 mean, var = tf.map_fn(f, Xnew, dtype=(settings.tf_float,
-                                                  settings.tf_float))
+                                                      settings.tf_float))
                 return tf.stack(mean), tf.stack(var)
             else:
-                #S, N, D = shape_as_list(Xnew)
+                # S, N, D = shape_as_list(Xnew)
                 s = tf.shape(Xnew)
-                X_flat = tf.reshape(Xnew, [s[0]*s[1], s[2]])
+                X_flat = tf.reshape(Xnew, [s[0] * s[1], s[2]])
                 mean, var = f_conditional(X_flat)
                 return [tf.reshape(m, [s[0], s[1], -1]) for m in [mean, var]]
 
@@ -93,6 +93,7 @@ def multisample_conditional(Xnew, full_cov=False):
 
         return mean, var
 
+
 def find_weights(input_dim, output_dim, X, multitask=False):
     """
     Find the initial weights of the Linear mean function based on
@@ -104,7 +105,7 @@ def find_weights(input_dim, output_dim, X, multitask=False):
 
     elif input_dim > output_dim:
         if multitask:
-            _, _, V = np.linalg.svd(X[:,:-1], full_matrices=False)
+            _, _, V = np.linalg.svd(X[:, :-1], full_matrices=False)
         else:
             _, _, V = np.linalg.svd(X, full_matrices=False)
         W = V[:output_dim, :].T
@@ -115,15 +116,17 @@ def find_weights(input_dim, output_dim, X, multitask=False):
         W = np.concatenate([I, zeros], 1)
 
     if multitask:
-        W = np.concatenate([W, np.zeros((1,W.shape[1]))], axis=0)
+        W = np.concatenate([W, np.zeros((1, W.shape[1]))], axis=0)
 
     return W
 
+
 class InputMixin(object):
     """
     Mixin class for input layers. Implements a single method to compute the
     value of the inputs and inducing inputs for the next layer.
     """
+
     def compute_inputs(self, X, Z, multitask=False):
         W = find_weights(self.input_dim, self.output_dim, X, multitask)
 
@@ -132,44 +135,49 @@ def compute_inputs(self, X, Z, multitask=False):
 
         return X_running, Z_running, W
 
+
 class HiddenMixin(object):
     """
     Mixin class for hidden layers. Implements a single method to compute the
     value of the inputs and inducing inputs for the next layer.
     """
+
     def compute_inputs(self, X, Z, multitask=False):
         W = find_weights(self.input_dim, self.output_dim, X, multitask)
 
-        if isinstance(self.Z, ParamList):
-            Z_running = self.Z[0].value.copy().dot(W)
+        if isinstance(self.feature, ParamList):
+            Z_running = self.feature[0].Z.value.copy().dot(W)
         else:
-            Z_running = self.Z.value.copy().dot(W)
+            Z_running = self.feature.Z.value.copy().dot(W)
 
         X_running = X.copy().dot(W)
 
         return X_running, Z_running, W
 
+
 class OutputMixin(object):
     """
     Mixin class for output layers. Does not implement any methods. Only used
     for type checking.
     """
+
     def compute_inputs(self, X, Z, multitask=False):
         W = find_weights(self.input_dim, self.output_dim, X, multitask)
 
-        Z_running = self.Z.value.copy().dot(W)
+        Z_running = self.feature.Z.value.copy().dot(W)
         X_running = X.copy().dot(W)
 
         return X_running, Z_running, W
 
+
 class InputLayer(Layer, InputMixin):
     @defer_build()
     def initialize_forward(self, X, Z, multitask=False):
         """
         Initialize Layer and Propagate values of inputs and inducing inputs
         forward
         """
-        self.Z.assign(Z)
+        self.feature.Z.assign(Z)
 
         X_running, Z_running, W = self.compute_inputs(X, Z, multitask)
 
@@ -187,7 +195,7 @@ def initialize_forward(self, X, Z, multitask=False):
         Initialize Layer and Propagate values of inputs and inducing inputs
         forward
         """
-        self.Z.assign(Z)
+        self.feature.Z.assign(Z)
 
         X_running, Z_running, W = self.compute_inputs(X, Z, multitask)
 
@@ -197,6 +205,7 @@ def initialize_forward(self, X, Z, multitask=False):
 
         return X_running, Z_running
 
+
 class OutputLayer(Layer, OutputMixin):
     @defer_build()
     def initialize_forward(self, X, Z, multitask=False):
@@ -205,5 +214,5 @@ def initialize_forward(self, X, Z, multitask=False):
         forward
         """
 
-        self.Z.assign(Z)
+        self.feature.Z.assign(Z)
         return (None, None)

dgplib/layers.py

@@ -7,13 +7,13 @@
 
 from gpflow.conditionals import conditional
 from gpflow.decors import params_as_tensors, autoflow, defer_build
+from gpflow.features import inducingpoint_wrapper
 from gpflow.kullback_leiblers import gauss_kl
 from gpflow.mean_functions import Linear, Zero
 from gpflow.params import Parameter, Parameterized, ParamList
 
-from .layers import Layer, find_weights
+from .layers import Layer
 from .layers import InputMixin, HiddenMixin, OutputMixin
-from .utils import shape_as_list
 
 class MultikernelLayer(Layer):
     """
@@ -40,12 +40,13 @@ def __init__(self, input_dim, output_dim, num_inducing, kernel_list,
         self.offset = int(self.output_dim/self.num_kernels)
 
         if not self._shared_Z:
-            del self.Z
+            del self.feature
             if multitask:
                 Z = np.zeros((self.num_inducing, self.input_dim+1))
             else:
                 Z = np.zeros((self.num_inducing, self.input_dim))
-            self.Z = ParamList([Parameter(Z.copy()) for _ in range(self.num_kernels)])
+
+            self.feature = ParamList([inducingpoint_wrapper(None, Z.copy()) for _ in range(self.num_kernels)])
 
 
     @params_as_tensors
@@ -67,19 +68,21 @@ def f_conditional(Xnew, full_cov=False):
             mean = []
             var = []
             if self._shared_Z:
-                Zs = [self.Z for _ in range(self.num_kernels)]
+                feats = [self.feature for _ in range(self.num_kernels)]
             else:
-                Zs = self.Z
-            for i, (k, Z) in enumerate(zip(self.kernel, Zs)):
-                m, v = conditional(Xnew=Xnew,
-                                   X=Z,
-                                   kern=k,
-                                   f=self.q_mu[:,(i*self.offset):((i+1)*self.offset)],
+                feats = [feat for feat in self.feature]
+            for i, (k, feat) in enumerate(zip(self.kernel, feats)):
+                m, v = conditional(Xnew, feat, k, self.q_mu[:,(i*self.offset):((i+1)*self.offset)],
                                    q_sqrt=self.q_sqrt[(i*self.offset):((i+1)*self.offset),:,:,],
                                    full_cov=full_cov,
                                    white=True)
                 mean.append(m)
-                var.append(v)
+
+                #temporary fix
+                if full_cov:
+                    var.append(tf.transpose(v))
+                else:
+                    var.append(v)
 
             mean = tf.concat(mean, axis=-1) #NxK
             var = tf.concat(var, axis=-1) #NxK or NxNxK
@@ -114,10 +117,10 @@ def initialize_forward(self, X, Z, multitask=False):
         forward
         """
         if self._shared_Z:
-            self.Z.assign(Z)
+            self.feature.Z.assign(Z)
         else:
-            for Z_current in self.Z:
-                Z_current.assign(Z)
+            for feat in self.feature:
+                feat.Z.assign(Z)
 
         X_running, Z_running, W = self.compute_inputs(X, Z, multitask)
 
@@ -136,10 +139,10 @@ def initialize_forward(self, X, Z, multitask=False):
         forward
         """
         if self._shared_Z:
-            self.Z.assign(Z)
+            self.feature.Z.assign(Z)
         else:
-            for Z_current in self.Z:
-                Z_current.assign(Z)
+            for feat in self.feature:
+                feat.Z.assign(Z)
 
         X_running, Z_running, W = self.compute_inputs(X, Z, multitask)
 
@@ -158,9 +161,9 @@ def initialize_forward(self, X, Z, multitask=False):
         """
 
         if self._shared_Z:
-            self.Z.assign(Z)
+            self.feature.Z.assign(Z)
         else:
-            for Z_current in self.Z:
-                Z_current.assign(Z)
+            for feat in self.feature:
+                feat.Z.assign(Z)
 
         return (None, None)

dgplib/multikernel_layers.py

@@ -1,12 +1,6 @@
-import numpy as np
 import tensorflow as tf
 
-from gpflow import settings
-
 from gpflow.decors import autoflow, defer_build, params_as_tensors
-from gpflow.mean_functions import Zero
-from gpflow.models import Model
-from gpflow.params import DataHolder, Minibatch
 
 from .dsdgp import DSDGP
 from .utils import normal_sample, tile_over_samples
@@ -30,4 +24,3 @@ def _propagate(self, Xnew, full_cov=False, num_samples=1):
             Fvars.append(var)
 
         return Fs[1:], Fmeans, Fvars
-