def __init__(self, input_dim, energy=np.asarray([1.]), frequency=np.asarray([2*np.pi]), variance=1.,
                 lengthscales=1., len_fixed=False):
        gpflow.kernels.Stationary.__init__(self, input_dim, variance=variance, lengthscales=lengthscales,
                                           active_dims=None, ARD=False)
        # self.variance = Param(variance, transforms.positive())
        # self.lengthscale = Param(lengthscale, transforms.positive())

        self.num_partials = len(frequency)

        energy_list = []
        frequency_list = []

        for i in range(self.num_partials):
            energy_list.append(Param(energy[i], transforms.positive))
            frequency_list.append(Param(frequency[i], transforms.positive))

        self.energy = ParamList(energy_list)
        self.frequency = ParamList(frequency_list)

        # self.energy.fixed = True
        # self.frequency.fixed = True

        # self.energy = energy
        # self.frequency = frequency

        if len_fixed:
            self.lengthscales.fixed = True
Esempio n. 2
0
    def __init__(self,
                 input_dim,
                 num_partials,
                 lengthscales=None,
                 variances=None,
                 frequencies=None):
        gpflow.kernels.Kern.__init__(self, input_dim, active_dims=None)
        len_l = []
        var_l = []
        freq_l = []
        self.ARD = False
        self.num_partials = num_partials

        if lengthscales.all() == None:
            lengthscales = 1. * np.ones((num_partials, 1))
            variances = 0.125 * np.ones((num_partials, 1))
            frequencies = 1. * (1. + np.arange(num_partials))

        for i in range(self.num_partials):
            len_l.append(Param(lengthscales[i], transforms.Logistic(0., 2.)))
            var_l.append(Param(variances[i], transforms.Logistic(0., 1.)))
            freq_l.append(Param(frequencies[i], transforms.positive))

        self.lengthscales = ParamList(len_l)
        self.variance = ParamList(var_l)
        self.frequency = ParamList(freq_l)
Esempio n. 3
0
    def __init__(self,
                 input_dim,
                 energy=np.asarray([1.]),
                 frequency=np.asarray([2 * np.pi]),
                 variance=1.0,
                 features_as_params=False):
        """
        - input_dim is the dimension of the input to the kernel
        - variance is the (initial) value for the variance parameter(s)
          if ARD=True, there is one variance per input
        - active_dims is a list of length input_dim which controls
          which columns of X are used.
        """
        gpflow.kernels.Kern.__init__(self, input_dim, active_dims=None)
        self.num_features = len(frequency)
        self.variance = Param(variance, transforms.Logistic(0., 0.25))

        if features_as_params:
            energy_list = []
            frequency_list = []
            for i in range(energy.size):
                energy_list.append(Param(energy[i], transforms.positive))
                frequency_list.append(Param(frequency[i], transforms.positive))

            self.energy = ParamList(energy_list)
            self.frequency = ParamList(frequency_list)
        else:
            self.energy = energy
            self.frequency = frequency
Esempio n. 4
0
    def __init__(self,
                 input_dim,
                 variance=1.,
                 lengthscales=None,
                 energy=None,
                 frequencies=None,
                 len_fixed=True):
        gpflow.kernels.Kern.__init__(self, input_dim, active_dims=None)
        energy_l = []
        freq_l = []
        self.ARD = False
        self.num_partials = len(energy)

        for i in range(self.num_partials):
            energy_l.append(Param(energy[i], transforms.positive))
            freq_l.append(Param(frequencies[i], transforms.positive))

        self.energy = ParamList(energy_l)
        self.frequency = ParamList(freq_l)
        self.variance = Param(variance, transforms.positive)
        self.lengthscales = Param(lengthscales, transforms.positive)

        self.vars_n_freqs_fixed(fix_energy=True, fix_freq=True)
        if len_fixed:
            self.lengthscales.fixed = True
Esempio n. 5
0
 def __init__(self, kern, q_mu, q_sqrt, Z, mean_function):
     Parameterized.__init__(self)
     nodes = []
     for n_kern, n_q_mu, n_q_s in zip(kern, q_mu, q_sqrt):
         nodes.append(Node(n_kern, n_q_mu, n_q_s, Z))
     self.nodes = ParamList(nodes)
     self.mean_function = mean_function
Esempio n. 6
0
 def __init__(self, operands, oper):
     """
     :param operands: list of acquisition objects
     :param oper: a tf.reduce operation (e.g., tf.reduce_sum) for aggregating the returned scores of each operand.
     """
     super(AcquisitionAggregation, self).__init__()
     assert (all([isinstance(x, Acquisition) for x in operands]))
     self.operands = ParamList(operands)
     self._oper = oper
Esempio n. 7
0
    def __init__(self,
                 X,
                 Y,
                 inducing_points,
                 final_inducing_points,
                 hidden_units,
                 units,
                 share_inducing_inputs=True):
        Model.__init__(self)

        assert X.shape[0] == Y.shape[0]

        self.num_data, D_X = X.shape
        self.D_Y = 1
        self.num_samples = 100

        kernels = []
        for l in range(hidden_units + 1):
            ks = []
            if (l > 0):
                D = units
            else:
                D = D_X
            if (l < hidden_units):
                for w in range(units):
                    ks.append(
                        RBF(D, lengthscales=1., variance=1.) +
                        White(D, variance=1e-5))
            else:
                ks.append(RBF(D, lengthscales=1., variance=1.))
            kernels.append(ks)

        self.dims_in = [D_X] + [units] * hidden_units
        self.dims_out = [units] * hidden_units + [1]
        q_mus, q_sqrts, Zs, mean_functions = init_layers(
            X, self.dims_in, self.dims_out, inducing_points,
            final_inducing_points, share_inducing_inputs)

        layers = []
        for q_mu, q_sqrt, Z, mean_function, kernel in zip(
                q_mus, q_sqrts, Zs, mean_functions, kernels):
            layers.append(Layer(kernel, q_mu, q_sqrt, Z, mean_function))
        self.layers = ParamList(layers)

        for layer in self.layers[:-1]:  # fix the inner layer mean functions
            layer.mean_function.fixed = True

        self.likelihood = Gaussian()

        minibatch_size = 10000 if X.shape[0] > 10000 else None
        if minibatch_size is not None:
            self.X = MinibatchData(X, minibatch_size)
            self.Y = MinibatchData(Y, minibatch_size)
        else:
            self.X = DataHolder(X)
            self.Y = DataHolder(Y)
Esempio n. 8
0
    def __init__(self, models=[], optimize_restarts=5):
        """
        :param models: list of GPflow models representing our beliefs about the problem
        :param optimize_restarts: number of optimization restarts to use when training the models
        """
        super(Acquisition, self).__init__()
        models = np.atleast_1d(models)
        assert all(isinstance(model, (Model, ModelWrapper)) for model in models)
        self._models = ParamList([DataScaler(m) for m in models])

        assert (optimize_restarts >= 0)
        self.optimize_restarts = optimize_restarts
        self._needs_setup = True
Esempio n. 9
0
    def _optimize_models(self):
        # Optimize model #1
        self.operands[0]._optimize_models()

        # Copy it again if needed due to changed free state
        if self._needs_new_copies:
            new_copies = [copy.deepcopy(self.operands[0]) for _ in range(len(self.operands) - 1)]
            for c in new_copies:
                c.optimize_restarts = 0
            self.operands = ParamList([self.operands[0]] + new_copies)
            self._needs_new_copies = False

        # Draw samples using HMC
        # Sample each model of the acquisition function - results in a list of 2D ndarrays.
        hypers = np.hstack([model.sample(len(self.operands), **self._sample_opt) for model in self.models])

        # Now visit all acquisition copies, and set state
        for idx, draw in enumerate(self.operands):
            draw.set_state(hypers[idx, :])
Esempio n. 10
0
    def __init__(self,
                 X,
                 Y,
                 Z,
                 kernels,
                 likelihood,
                 num_latent_Y=None,
                 minibatch_size=None,
                 num_samples=1,
                 mean_function=Zero()):
        Model.__init__(self)

        assert X.shape[0] == Y.shape[0]
        assert Z.shape[1] == X.shape[1]
        assert kernels[0].input_dim == X.shape[1]

        self.num_data, D_X = X.shape
        self.num_samples = num_samples
        self.D_Y = num_latent_Y or Y.shape[1]

        self.dims = [k.input_dim for k in kernels] + [
            self.D_Y,
        ]
        q_mus, q_sqrts, Zs, mean_functions = init_layers(
            X, Z, self.dims, mean_function)

        layers = []
        for q_mu, q_sqrt, Z, mean_function, kernel in zip(
                q_mus, q_sqrts, Zs, mean_functions, kernels):
            layers.append(Layer(kernel, q_mu, q_sqrt, Z, mean_function))
        self.layers = ParamList(layers)

        for layer in self.layers[:-1]:  # fix the inner layer mean functions
            layer.mean_function.fixed = True

        self.likelihood = likelihood

        if minibatch_size is not None:
            self.X = MinibatchData(X, minibatch_size)
            self.Y = MinibatchData(Y, minibatch_size)
        else:
            self.X = DataHolder(X)
            self.Y = DataHolder(Y)
Esempio n. 11
0
    def __init__(self, X_variational_mean, X_variational_var, Y, kern, t, kern_t, M , Z=None):
        """
        Initialization of Bayesian Gaussian Process Dynamics Model. This method only works with Gaussian likelihood.
        :param X_variational_mean: initial latent positions, size N (number of points) x Q (latent dimensions).
        :param X_variational_var: variance of latent positions (N x Q), for the initialisation of the latent space.
        :param Y: data matrix, size N (number of points) x D (dimensions).
        :param kern: kernel specification, by default RBF.
        :param t: time stamps.
        :param kern_t: dynamics kernel specification, by default RBF.
        :param M: number of inducing points.
        :param Z: matrix of inducing points, size M (inducing points) x Q (latent dimensions), By default
                  random permutation of X_mean.
        """
        super(BayesianDGPLVM, self).__init__(name='BayesianDGPLVM')
        self.kern = kern
        assert len(X_variational_mean) == len(X_variational_var), 'must be same amount of time series'
        self.likelihood = likelihoods.Gaussian()

        # multiple sequences
        series = []
        for i in range(len(X_variational_mean)):
            series.append(GPTimeSeries(X_variational_mean[i], X_variational_var[i], t[i]))
        self.series = ParamList(series)

        # inducing points
        if Z is None:
            # By default we initialize by permutation of initial
            Z = np.random.permutation(np.concatenate(X_variational_mean, axis=0).copy())[:M]
        else:
            assert Z.shape[0] == M
        self.Z = Param(Z)

        self.kern_t = kern_t
        self.Y = DataHolder(Y)
        self.M = M
        self.n_s = 0
Esempio n. 12
0
    def __init__(self,
                 prev_ind_list,
                 cur_ind_list,
                 X_grid,
                 kerns_list,
                 name='collaborative_pref_gps'):

        Model.__init__(self, name)

        total_shape = total_all_actions(prev_ind_list)

        Y = np.ones(total_shape)[:, None]
        self.Y = DataHolder(Y)

        # Introducing Paramlist to define kernels for latent GPs H
        self.kerns_list = ParamList(kerns_list)

        self.X_grid = DataHolder(X_grid[:, None])

        self.prev_ind_list = prev_ind_list
        self.cur_ind_list = cur_ind_list

        # define likelihood
        self.likelihood = gpflow.likelihoods.Bernoulli()