def setUpClass(cls):
super(TestMultiFull, cls).setUpClass()
likelihood = likelihoods.Softmax()
kernel = [
kernels.RadialBasis(input_dim=2,
lengthscale=1.0,
std_dev=1.0,
white=0.0) for i in range(2)
]
inducing_locations = np.array([[1.0, 2.0, 3.0, 4.0]])
cls.model = autogp.GaussianProcess(likelihood_func=likelihood,
kernel_funcs=kernel,
inducing_inputs=inducing_locations,
num_components=2,
diag_post=False,
num_samples=1)
cls.session.run(tf.global_variables_initializer())
def setUpClass(cls):
super(TestSimpleFull, cls).setUpClass()
likelihood = likelihoods.Gaussian(1.0)
kernel = [
kernels.RadialBasis(input_dim=1,
lengthscale=1.0,
std_dev=1.0,
white=0.0)
]
# In most of our unit test, we will replace this value with something else.
inducing_inputs = np.array([[1.0]])
cls.model = autogp.GaussianProcess(likelihood_func=likelihood,
kernel_funcs=kernel,
inducing_inputs=inducing_inputs,
num_components=1,
diag_post=False,
num_samples=10)
cls.session.run(tf.initialize_all_variables())
def setUpClass(cls):
super(TestSimpleFull, cls).setUpClass()
likelihood = lik.Gaussian(1.0)
kernel = cov.SquaredExponential(input_dim=1,
length_scale=[1.0],
std_dev=[1.0],
white=[0.0])
# In most of our unit test, we will replace this value with something else.
inducing_inputs = np.array([[1.0]])
cls.inf = inf.VariationalInference(num_samples=10,
lik_func=likelihood,
cov_func=kernel,
num_components=1)
cls.model = autogp.GaussianProcess(lik_func=likelihood,
cov_func=kernel,
inducing_inputs=inducing_inputs,
num_components=1,
diag_post=False,
inf_func=cls.inf)
cls.session.run(tf.global_variables_initializer())
def setUpClass(cls):
super(TestMultiFull, cls).setUpClass()
likelihood = lik.Softmax()
kernel = cov.SquaredExponential(input_dim=2,
output_dim=2,
length_scale=1.,
std_dev=1.,
white=0.)
inducing_inputs = np.array([[1.0, 2.0, 3.0, 4.0]])
cls.inf = inf.VariationalInference(num_samples=10,
lik_func=likelihood,
cov_func=kernel,
num_components=2)
cls.model = autogp.GaussianProcess(lik_func=likelihood,
cov_func=kernel,
inducing_inputs=inducing_inputs,
num_components=2,
diag_post=False,
inf_func=cls.inf)
cls.session.run(tf.global_variables_initializer())
data = datasets.DataSet(d['train_inputs'].astype(np.float32),
d['train_outputs'].astype(np.float32))
test = datasets.DataSet(d['test_inputs'].astype(np.float32),
d['test_outputs'].astype(np.float32))
# Setup initial values for the model.
likelihood = lik.RegressionNetwork(7, 0.1)
kern = [
cov.SquaredExponential(data.X.shape[1],
length_scale=8.0,
input_scaling=IS_ARD) for i in range(8)
]
# kern = [kernels.ArcCosine(data.X.shape[1], 1, 3, 5.0, 1.0, input_scaling=True) for i in range(10)]
Z = init_z(data.X, NUM_INDUCING)
m = autogp.GaussianProcess(likelihood, kern, Z, num_samples=NUM_SAMPLES)
# setting up loss to be reported during training
error_rate = None # losses.StandardizedMeanSqError(d['train_outputs'].astype(np.float32), data.Dout)
import time
o = tf.train.RMSPropOptimizer(LEARNING_RATE)
start = time.time()
m.fit(data,
o,
loo_steps=0,
var_steps=50,
epochs=EPOCHS,
batch_size=BATCH_SIZE,
display_step=DISPLAY_STEP,
test=test,
std_dev=sigma_initial)
]
#kernel = [autogp.kernels.Matern_3_2(1, lengthscale= lengthscale_initial, std_dev = sigma_initial)]
#kernel = [autogp.kernels.Matern_5_2(1, lengthscale= lengthscale_initial, std_dev = sigma_initial)]
# Define the sparse approximation
sparsity_factor = 1.
inducing_number = int(sparsity_factor * N)
id_sparse = np.arange(N)
np.random.shuffle(id_sparse)
inducing_inputs = xtrain[id_sparse[:inducing_number]]
# Define the model
model = autogp.GaussianProcess(likelihood,
kernel,
inducing_inputs,
num_components=1,
diag_post=False)
# Define the optimizer
optimizer = tf.train.RMSPropOptimizer(0.005)
# Train the model
start = time.time()
print("Start the training")
model.fit(data, optimizer, loo_steps=0, var_steps=60, epochs=300)
end = time.time()
time_elapsed = end - start
print("Execution time in seconds", time_elapsed)
# Predict new inputs.
lengthscale=LENGTHSCALE,
std_dev=1.0,
input_scaling=IS_ARD) for i in range(1)
]
else:
kern = [
cov.SquaredExponential(data.X.shape[1],
length_scale=LENGTHSCALE,
input_scaling=IS_ARD) for i in range(1)
]
print(f"Using Kernel {KERNEL}")
m = autogp.GaussianProcess(likelihood,
kern,
Z,
num_samples=NUM_SAMPLES,
num_components=NUM_COMPONENTS)
error_rate = losses.ZeroOneLoss(data.Dout)
o = tf.train.AdamOptimizer(LEARNING_RATE)
m.fit(data,
o,
loo_steps=LOOCV_STEPS,
var_steps=VAR_STEPS,
epochs=EPOCHS,
batch_size=BATCH_SIZE,
display_step=DISPLAY_STEP,
test=test,
loss=error_rate)
ypred = m.predict(test.X)[0]
data, test, _ = datasets.import_mnist()
# Setup initial values for the model.
likelihood = lik.Softmax()
kern = cov.SquaredExponential(data.X.shape[1],
output_dim=10,
length_scale=10,
std_dev=1,
white=.01,
input_scaling=IS_ARD)
# kern = [kernels.ArcCosine(X.shape[1], 2, 3, 5.0, 1.0, input_scaling=True) for i in range(10)]
# RadialBasis(X.shape[1], input_scaling=True) for i in xrange(10)]
Z = init_z(data.X, NUM_INDUCING)
inf = inf.VariationalInference(kern, likelihood, num_samples=NUM_SAMPLES)
m = autogp.GaussianProcess(Z, kern, inf, likelihood)
# setting up loss to be reported during training
error_rate = losses.ZeroOneLoss(data.Dout)
import time
otime = time.time()
o = tf.train.RMSPropOptimizer(LEARNING_RATE)
start = time.time()
m.fit(data,
o,
loo_steps=50,
var_steps=50,
epochs=EPOCHS,
batch_size=BATCH_SIZE,
display_step=DISPLAY_STEP,
np.random.shuffle(idx)
xtrain = inputs[idx[:N]]
ytrain = outputs[idx[:N]]
data = autogp.datasets.DataSet(xtrain, ytrain)
xtest = inputs[idx[N:]]
ytest = outputs[idx[N:]]
# Initialize the Gaussian process.
likelihood = autogp.lik.Gaussian(1.)
kernel = autogp.cov.SquaredExponential(1, white=1e-5)
# inference = autogp.inf.VariationalInference(kernel, likelihood)
inference = autogp.inf.Exact(kernel, likelihood)
inducing_inputs = xtrain
model = autogp.GaussianProcess(inducing_inputs,
kernel,
inference,
likelihood,
inducing_outputs=ytrain)
# Train the model.
optimizer = tf.train.RMSPropOptimizer(0.005)
# model.fit(data, optimizer, batch_size=1, loo_steps=10, var_steps=10, epochs=100, optimize_inducing=False)
model.fit(data,
optimizer,
batch_size=None,
loo_steps=0,
var_steps=1,
epochs=500,
optimize_inducing=False,
only_hyper=True)
inputs = 5 * np.linspace(0, 1, num=N_all)[:, np.newaxis] outputs = np.sin(inputs) # selects training and test idx = np.arange(N_all) np.random.shuffle(idx) xtrain = inputs[idx[:N]] ytrain = outputs[idx[:N]] data = autogp.datasets.DataSet(xtrain, ytrain) xtest = inputs[idx[N:]] ytest = outputs[idx[N:]] # Initialize the Gaussian process. likelihood = autogp.likelihoods.Gaussian() kernel = [autogp.kernels.RadialBasis(1)] inducing_inputs = xtrain model = autogp.GaussianProcess(likelihood, kernel, inducing_inputs) # Train the model. optimizer = tf.train.RMSPropOptimizer(0.005) model.fit(data, optimizer, loo_steps=50, var_steps=50, epochs=1000) # Predict new inputs. ypred, _ = model.predict(xtest) plt.plot(xtrain, ytrain, '.', mew=2) plt.plot(xtest, ytest, 'o', mew=2) plt.plot(xtest, ypred, 'x', mew=2) plt.show()
