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 self.setup()
def __init__(self, list_of_means): """ :param list list_of_means: A list of MeanFunction object. """ output_dim = 0 for m in list_of_means: output_dim += m.output_dim MeanFunction.__init__(self, output_dim) # MeanFunctions are stored as ParamList self.mean_list = ParamList(list_of_means)
def __init__(self, list_of_kerns): """ :param list list_of_kerns: A list of Kernel object. """ output_dim = 0 for k in list_of_kerns: # assert k is Kernel object assert (isinstance(k, Kern)) output_dim += k.output_dim Kern.__init__(self, output_dim) kernels.Kern.__init__(self, input_dim=None) # kernels are stored as ParamList self.kern_list = ParamList(list_of_kerns)
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._optimize_models()
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__() self._models = ParamList( [DataScaler(m) for m in np.atleast_1d(models).tolist()]) self._default_params = list( map(lambda m: m.get_free_state(), self._models)) assert (optimize_restarts >= 0) self.optimize_restarts = optimize_restarts self._optimize_models()
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)
def models(self): return ParamList([ model for acq in self.operands for model in acq.models.sorted_params ])