GPflow2.0 port

.gitignore

@@ -111,4 +111,4 @@ ENV/
 .idea/
 
 # pytest
-./pytest_cache
+.pytest_cache

TODO.md

@@ -0,0 +1,3 @@
+# TODO
+* Create utilities for dealing with features and kernels
+* Multikernel layers: additive and concatenated

dgplib/__init__.py

@@ -1,10 +1,9 @@
-from __future__ import absolute_import
-
+from . import utilities
 from . import layers
+from . import multiprocess_layers
+from . import weighted_layers
 from . import cascade
-from . import multikernel_layers
-from . import utils
 from . import specialized_kernels
+from . import training_utilities
 
 from .dsdgp import DSDGP
-from .multitask_dsdgp import MultitaskDSDGP

dgplib/cascade.py

@@ -1,83 +1,86 @@
-import numpy as np
-import tensorflow as tf
+from gpflow.base import Module
+from .layers import Layer
+from .multiprocess_layers import MultiprocessLayer
 
-from gpflow.params import Parameterized, ParamList
-from .layers import InputMixin, HiddenMixin, OutputMixin
-from .layers import Layer, InputLayer, OutputLayer, HiddenLayer
-from .multikernel_layers import MultikernelLayer, MultikernelInputLayer, MultikernelOutputLayer, MultikernelHiddenLayer
 
-class Sequential(Parameterized):
+class Sequential(Module):
     """
     Linear Stack of layers
     """
 
     def __init__(self, layers=None, name=None):
         """
-        - layers is a list of layer objects.
+        :param layers: list of Layer objects
         """
 
-        super(Sequential, self).__init__(name=name)
+        super().__init__(name=name)
 
-        self._initialized = False #Change into property later
-        self.layers = ParamList([])
+        self._initialized = False
+        self.constituents = []
 
         if layers:
             for layer in layers:
                 self.add(layer)
 
+    @property
+    def initialized(self):
+        return self._initialized
+
+    @initialized.setter
+    def initialized(self, value):
+        if not self.initialized:
+            if value:
+                raise ValueError("Cannot overwrite initialization for uninitialized models")
+        self._initialized = value
+
     def _valid_input(self, layer):
-        assert isinstance(layer, Layer)
+        """
+        Checks if input to the cascade object is valid
+        """
+        assert isinstance(layer, (Layer, MultiprocessLayer))
 
-        if self._initialized:
+        if self.initialized:
             raise ValueError('Cannot add more layers to initialized model')
 
-        if not self.layers:
-            #Temporary Hack
-            assert isinstance(layer, InputMixin), "First layer must be an Input Layer"
-        else:
-            #Temporary Hack
-            if isinstance(self.layers[-1], OutputMixin):
-                raise ValueError('Cannot add layers after an Output Layer')
-
-            assert self.layers[-1].output_dim == layer.input_dim, """Input
+        if self.constituents:  # if list is not empty
+            assert self.constituents[-1].output_dim == layer.input_dim, """Input
             dimensions of layer must be equal to the output dimensions of the
             preceding layer"""
 
     def add(self, layer):
         """
         Adds a layer instance on top of the layer stack.
 
-        - layer is an instance of an object that inherits from Layer
+        :param layer: Layer object
         """
         self._valid_input(layer)
-        self.layers.append(layer)
+        self.constituents.append(layer)
 
     def get_dims(self):
         """
         Get a list of the dimensions of the constituent layers.
         """
-        dims = [(l.input_dim, l.output_dim) for l in self.layers]
+        dims = [(l.input_dim, l.output_dim) for l in self.constituents]
 
         return dims
 
     def initialize_params(self, X, Z):
-        X_running, Z_running = self.layers[0].initialize_forward(X, Z)
-        for layer in self.layers[1:]:
-            X_running, Z_running = layer.initialize_forward(X_running, Z_running)
+        """
+        Handles the initialization of inducing inputs in the Sequential cascade
+        """
+        Z_current = Z.copy()
+        X_next, Z_next, W = self.constituents[0].propagate_inputs_and_features(X, Z)
+        self.constituents[0].initialize_features(Z_current)
+        if self.constituents[0].fixed_linear_mean_function:
+            self.constituents[0].initialize_linear_mean_function_weights(W)
+        for layer in self.constituents[1:]:
+            Z_current = Z_next
+            X_next, Z_next, W = layer.propagate_inputs_and_features(X_next, Z_current)
+            layer.initialize_features(Z_current)
+            if layer.fixed_linear_mean_function:
+                layer.initialize_linear_mean_function_weights(W)
 
         print('Model Parameters Initialized')
         self._initialized = True
 
-class MultitaskSequential(Sequential):
-    def initialize_params(self, X, Z):
-        X_ind = X[:, -1:]
-        Z_ind = Z[:, -1:]
-        X_running, Z_running = self.layers[0].initialize_forward(X, Z, multitask=True)
-        for layer in self.layers[1:]:
-            X_running = np.hstack([X_running, X_ind])
-            Z_running = np.hstack([Z_running, Z_ind])
-            X_running, Z_running = layer.initialize_forward(X_running,
-                                                            Z_running,
-                                                            multitask=True)
-        print('Model Parameters Initialized')
-        self._initialized = True
+