def build_deep_gp(input_dim, num_data): layers = [input_dim, 2, 2, 1] # Below are different ways to build layers # 1. Pass in Lists: kernel_list = [RBF(), Matern12()] num_inducing = [25, 25] l1_kernel = construct_basic_kernel(kernels=kernel_list) l1_inducing = construct_basic_inducing_variables(num_inducing=num_inducing, input_dim=layers[0]) # 2. Pass in kernels, specificy output dims (shared hyperparams/variables) l2_kernel = construct_basic_kernel(kernels=RBF(), output_dim=layers[2], share_hyperparams=True) l2_inducing = construct_basic_inducing_variables( num_inducing=25, input_dim=layers[1], share_variables=True ) # 3. Pass in kernels, specificy output dims (independent hyperparams/vars) # By default and the constructor will make indep. copies l3_kernel = construct_basic_kernel(kernels=RBF(), output_dim=layers[3]) l3_inducing = construct_basic_inducing_variables( num_inducing=25, input_dim=layers[2], output_dim=layers[3] ) # Assemble at the end gp_layers = [ GPLayer(l1_kernel, l1_inducing, num_data), GPLayer(l2_kernel, l2_inducing, num_data), GPLayer(l3_kernel, l3_inducing, num_data, mean_function=Zero()), ] return DeepGP(gp_layers, Gaussian(0.1))
def build_gp_layers(layer_sizes, num_data): gp_layers = [] for input_dim, output_dim in zip(layer_sizes[:-1], layer_sizes[1:]): kernel = construct_basic_kernel(kernels=RBF(), output_dim=output_dim) inducing_vars = construct_basic_inducing_variables( num_inducing=25, input_dim=input_dim, output_dim=output_dim) layer = GPLayer(kernel, inducing_vars, num_data) gp_layers.append(layer) gp_layers[-1].mean_function = Zero() return gp_layers
def setup_gp_layer_and_data(num_inducing: int, **gp_layer_kwargs): input_dim = 30 output_dim = 5 num_data = 100 data = make_data(input_dim, output_dim, num_data=num_data) kernel = construct_basic_kernel(RBF(), output_dim) inducing_vars = construct_basic_inducing_variables(num_inducing, input_dim, output_dim) mean_function = Zero(output_dim) gp_layer = GPLayer(kernel, inducing_vars, num_data, mean_function=mean_function, **gp_layer_kwargs) return gp_layer, data
def __init__( self, likelihood: gpflow.likelihoods.Likelihood = gpflow.likelihoods. Gaussian(0.01) ) -> None: kernel = construct_basic_kernel(gpflow.kernels.SquaredExponential(), output_dim=1, share_hyperparams=True) inducing_var = construct_basic_inducing_variables( num_inducing=5, input_dim=1, share_variables=True, z_init=tf.random.normal([5, 1], dtype=gpflow.default_float()), ) gp_layer = GPLayer(kernel, inducing_var, 10) super().__init__( [gp_layer], # not actually used likelihood, )
M = Z.shape[0] # Layer 1 inducing_var1 = construct_basic_inducing_variables(M, D, D, share_variables=True, z_init=Z.copy()) kernel1 = construct_basic_kernel( gpflow.kernels.SquaredExponential(lengthscales=0.15), output_dim=D, share_hyperparams=True, ) layer1 = GPLayer(kernel1, inducing_var1, num_data, full_cov=True, num_samples=num_samples) # Layer 2 inducing_var2 = construct_basic_inducing_variables(M, D, D, share_variables=True, z_init=Z.copy()) kernel2 = construct_basic_kernel( gpflow.kernels.SquaredExponential(lengthscales=0.8, variance=0.1), output_dim=D, share_hyperparams=True, ) layer2 = GPLayer(kernel2,
# -0.47, -2.55, 1.81, 1.10, -0.57, # -2.60, 1.56, -0.62, 1.86, 0.80 # ]).astype(default_float()) # Z_aug = np.random.rand(3 * 5,).astype(default_float()) # num_inducing_points = Z.shape[0] # axs[0].plot(Z, q, 'o', color='black') # Shallow sparse GP Z1 = np.linspace(min(X), max(X), num=num_inducing_points)[..., None].astype(default_float()) # Z1 = Z[..., None] feat1 = SharedIndependentInducingVariables(InducingPoints(Z1)) kern1 = SharedIndependent(Kernel(lengthscales=lengthscale, variance=outer_variance), output_dim=1) layer1 = GPLayer(kern1, feat1, X.shape[0], mean_function=Zero(), white=False) # layer1.q_mu.assign(value=q[..., None]) lik_layer = LikelihoodLayer(Gaussian(variance=likelihood_variance)) model = DeepGP([layer1], lik_layer, input_dim=1, output_dim=1) model.compile(tf.optimizers.Adam(learning_rate=learning_rate)) callbacks = [ tf.keras.callbacks.ReduceLROnPlateau( monitor="loss", patience=patience, factor=factor, verbose=verbose, min_lr=min_learning_rate, ) ]
# %% Z = X.copy() M = Z.shape[0] # Layer 1 inducing_var1 = construct_basic_inducing_variables(M, D, D, share_variables=True, z_init=Z.copy()) kernel1 = construct_basic_kernel( gpflow.kernels.SquaredExponential(lengthscales=0.15), output_dim=D, share_hyperparams=True, ) layer1 = GPLayer(kernel1, inducing_var1, Ns) # Layer 2 inducing_var2 = construct_basic_inducing_variables(M, D, D, share_variables=True, z_init=Z.copy()) kernel2 = construct_basic_kernel( gpflow.kernels.SquaredExponential(lengthscales=0.8, variance=0.1), output_dim=D, share_hyperparams=True, ) layer2 = GPLayer(kernel2, inducing_var2, Ns) # Layer 3