def _optimise_model(self, model: gpflow.models.Model,
optimise_func: Callable[[gpflow.models.Model, Callable, tf.Variable], None],
use_global_step: Optional[bool]=False) -> None:
"""
Runs optimisation test with given model and optimisation function.
:param model: Model derived from `gpflow.models.Model`
:param optimise_func: Function that performs the optimisation. The function should take
the model, step callback and the `global_step` tensor as the arguments
:param use_global_step: flag indicating the the `global_step` variable should be used
"""
session = model.enquire_session()
global_step_tensor = mon.create_global_step(session) if use_global_step else None
monitor_task = _DummyMonitorTask()
monitor = mon.Monitor([monitor_task], session, global_step_tensor)
monitor.start_monitoring()
# Calculate LML before the optimisation, run optimisation and calculate LML after that.
lml_before = model.compute_log_likelihood()
optimise_func(model, monitor, global_step_tensor)
lml_after = model.compute_log_likelihood()
if use_global_step:
# Check that the 'global_step' has the actual number of iterations
global_step = session.run(global_step_tensor)
self.assertEqual(global_step, monitor_task.call_count)
else:
# Just check that there were some iterations
self.assertGreater(monitor_task.call_count, 0)
# Check that the optimiser has done something
self.assertGreater(lml_after, lml_before)
def test_on_iteration_timing(self, mock_timer):
"""
Tests how the Monitor keeps track of the total running time and total optimisation time.
"""
mock_timer.side_effect = [1.0, 3.5, 4.0, 6.0, 7.0]
monitor = mon.Monitor([])
# In each call to the _on_iteration the timer is called twice - at the beginning and at
# the end of the call.
monitor._on_iteration()
self.assertEqual(monitor._context.total_time, 2.5)
self.assertEqual(monitor._context.optimisation_time, 2.5)
monitor._on_iteration()
self.assertEqual(monitor._context.total_time, 5.0)
self.assertEqual(monitor._context.optimisation_time, 4.5)
# build model
gpflow.reset_default_graph_and_session()
with gpflow.defer_build():
kernel = gpflow.kernels.RBF(1, active_dims=[0]) + gpflow.kernels.RBF(1, active_dims=[1])
feature = gpflow.features.InducingPoints(Z)
model = gpflow.models.SVGP(
X_aug, Y, kernel, NegativeBinomial(),
feat=feature, minibatch_size=500, name=name)
model.compile()
# restore/create monitor session
lr = 0.01
monitor_tasks, session, global_step, file_writer = build_monitor(model, path)
optimiser = gpflow.train.AdamOptimizer(lr)
if os.path.isdir('./monitor-saves/' + path + model.name):
try:
mon.restore_session(session, './monitor-saves/' + path + model.name)
except:
pass
else:
os.makedirs('./monitor-saves/' + path + model.name)
model.anchor(session)
# optimize
with mon.Monitor(monitor_tasks, session, global_step, print_summary=True) as monitor:
optimiser.minimize(model, step_callback=monitor, maxiter=1000, global_step=global_step)
file_writer.close()
def run_experiment(_seed, D, T, n_seq, batch_size, model_class,
optimizer, learning_rate, momentum, use_nesterov, maxiter, parallel_iterations,
process_noise_var, emission_noise_var,
Q_init_scale, R_init_scale, Ucov_chol_init_scale, X_chol_init_scale, kern_var_init, init_at_gp_on_Y,
train_Q, train_kern_var, train_Z, train_As, train_bs, train_Ss,
n_samples, n_ind_pts, base_save_path, init_from_disk,
test, filter_length, test_length, test_seq, test_samples, args):
tf.set_random_seed(_seed)
np.random.seed(_seed)
#tr = KinkTransitions(dim=D, Q=np.ones(D) * process_noise_var, name='KinkTransitions_datagen')
#SSM_datagen = SSM(X_init=np.zeros((T, D)), Y=np.zeros((T, D)), transitions=tr, emissions=em, name='SSM_datagen')
if args["emission_model"] == "gaussian":
em = GaussianEmissions(obs_dim=D, R=np.eye(D) * emission_noise_var, name='GaussianEmissions_datagen')
elif args["emission_model"] == "narendrali":
em = NarendraLiEmission(noise_var = emission_noise_var, name='NarendraLiEmission')
Y, U_0 = np.load(args["data"] + "Y_" +args["name"] +".npz"), np.load(args["data"] + "U_" +args["name"] +".npz")
Y, U = [np.transpose(Y[:,:,i]) for i in range(Y.shape[2])], None if U_0.shape[0] == 0 else [ np.transpose(U_0[:,:,i]) for i in range(U_0.shape[2])]
Xtest, Ytest, Utest = np.load(args["data"] + "Xtest_" +args["name"] +".npz"), np.load(args["data"] + "Ytest_" +args["name"] +".npz"), np.load(args["data"] + "Utest_" +args["name"] +".npz")
Xtest,Ytest, Utest = None if Xtest.shape[0]== 0 else [np.transpose(Xtest[:,:,i]) for i in range(Xtest.shape[2])], [np.transpose(Ytest[:,:,i]) for i in range(Ytest.shape[2])], None if U_0.shape[0] == 0 else [ np.transpose(Utest[:,:,i]) for i in range(Utest.shape[2])]
Xplot, Uplot = np.transpose(np.load(args["data"] + "Xplot_" +args["name"] +".npz")), np.transpose(np.load(args["data"] + "Uplot_" +args["name"] +".npz"))
Uplot = None if U_0.shape[0] == 0 else Uplot
Xplot = None if Xplot.shape[1]== 0 else Xplot # WE have already taken the transpose
Ypred, Upred = np.load(args["data"] + "Ypred_" +args["name"] +".npz"), np.load(args["data"] + "Upred_" +args["name"] +".npz")
Ypred, Upred = None if Ypred.shape[0]== 0 else [np.transpose(Ypred[:,:,i]) for i in range(Ypred.shape[2])], None if U_0.shape[0] == 0 else [ np.transpose(Upred[:,:,i]) for i in range(Upred.shape[2])]
Ypredseqahead, Upredseqahead = np.load(args["data"] + "Ypredseqahead_" +args["name"] +".npz"), np.load(args["data"] + "Upredseqahead_" +args["name"] +".npz")
Ypredseqahead, Upredseqahead = None if Ypredseqahead.shape[0]== 0 else [np.transpose(Ypredseqahead[:,:,i]) for i in range(Ypredseqahead.shape[2])], [None if U_0.shape[0] == 0 else np.transpose(Upredseqahead[:,:,i]) for i in range(Upredseqahead.shape[2])]
gaussian_GPSSM_name = 'SSM_SG_MultipleSequences'
model_classes = [gaussian_GPSSM_name, 'PRSSM_MS_MF', 'PRSSM_MS', 'GPSSM_MS_MF', 'GPSSM_MS_SPURIOUS',
'GPSSM_MS_FITC', 'GPSSM_MS_CUBIC', 'GPSSM_MS_VCDT', 'GPSSM_MS_FITC_SAMPLE_F', 'GPSSM_MS_FactorizedLinear', 'GPSSM_MS_FactorizedNonLinear']
if model_class in model_classes:
model_class_python = eval(model_class)
else:
raise ValueError('Unknown model class')
#kern = gp.kernels.Matern32(D, variance=kern_var_init, ARD=True, name='GPSSM_kern')
#Z = np.linspace(-8., 3., n_ind_pts)[:, None]
#mean_fn = mean_fns.Zero(D, name='GPSSM_mean_fn')
#Q_diag = np.ones(D) * Q_init_scale
#Ucov_chol = np.tile(np.eye(n_ind_pts)[None, ...], [D, 1, 1]) * Ucov_chol_init_scale
if init_from_disk is not None and init_from_disk[-4:] == '.npy':
GPSSM_params = np.load(init_from_disk).ravel()[0]
if 'GPSSM/Q_sqrt' in GPSSM_params.keys():
Q_diag = GPSSM_params['GPSSM/Q_sqrt'] ** 2.
if R_init_scale is not None:
em.Rchol = np.eye(D) * (R_init_scale ** 0.5)
em.compile()
extra_kwargs = {'batch_size': batch_size}
model = model_class_python(D,
Y,
inputs=U,
emissions=em,
n_ind_pts = n_ind_pts,
n_samples=n_samples,
seed=None,
name='GPSSM',
**extra_kwargs)
if args["emission_model"] == "gaussian":
if args["train_emission"]:
model.emissions.Rchol.trainable = False
model.emissions.C.trainable = False
model.emissions.bias.trainable = False
else:
model.emissions.Rchol.trainable = False
model.emissions.C.trainable = False
model.emissions.bias.trainable = False
elif args["emission_model"] == "narendrali":
model.emissions.trainable= args["train_emission"]
model.emissions.Rchol.trainable = False
model.emissions.C.trainable = False
model.emissions.bias.trainable = False
transitions = model
if train_As is not None: model.As.trainable = train_As
if train_bs is not None: model.bs.trainable = train_bs
if train_Ss is not None: model.S_chols.trainable = train_Ss
if model_class != 'GPSSM_MS_FactorizedLinear':
transitions.Q_sqrt.trainable = train_Q
transitions.Z.trainable = train_Z
try:
transitions.kern.kern.variance.trainable = train_kern_var
except:
warnings.warn('Could not set trainable status of the kernel\'s variance: default is trainable')
session = model.enquire_session()
if init_from_disk is not None:
if init_from_disk[-4:] != '.npy':
matching_dirs = glob(init_from_disk)
assert len(matching_dirs) == 1, 'More/Less than one matching run found'
matching_dir = matching_dirs[0]
checkpoint_loc = tf.train.latest_checkpoint(matching_dir + '/checkpoints')
tf.train.Saver().restore(session, checkpoint_loc)
GPSSM_params = model.read_values(session)
if 'PRSSM' in model_class:
offending_keys = [k for k in GPSSM_params.keys() if ('/As' in k or '/bs' in k or '/S_chols' in k)]
for k in offending_keys: GPSSM_params.pop(k)
model.assign(GPSSM_params)
model.compile()
print('================== Successfully initialised GPSSM params from: ' + init_from_disk + ' ==================')
print('Likelihood at initialisation loaded from disk:', model.compute_log_likelihood())
experiment_id = args["name"]
save_path = os.path.join(args["largestorage"], experiment_id)
if optimizer == 'adam':
optimizer = gp.train.AdamOptimizer(learning_rate=learning_rate)
elif optimizer == 'momentum':
optimizer = gp.train.MomentumOptimizer(learning_rate=learning_rate,
momentum=momentum, use_nesterov=use_nesterov)
else:
raise ValueError('Unknown optimizer')
global_step = mon.create_global_step(session)
print_task = mon.PrintTimingsTask() \
.with_name('print') \
.with_condition(mon.PeriodicIterationCondition(100))
checkpoint_task = mon.CheckpointTask(checkpoint_dir=save_path + '/checkpoints',
saver=tf.train.Saver(max_to_keep=100, save_relative_paths=True)) \
.with_name('checkpoint') \
.with_condition(mon.PeriodicIterationCondition(10000)) \
.with_exit_condition(True)
with mon.LogdirWriter(save_path + '/tensorboard') as writer:
tensorboard_task = mon.ModelToTensorBoardTask(writer, model, only_scalars=False) \
.with_name('tensorboard') \
.with_condition(mon.PeriodicIterationCondition(50)) \
.with_exit_condition(True)
monitor_tasks = [print_task, tensorboard_task, checkpoint_task]
with mon.Monitor(monitor_tasks, session, global_step, print_summary=True) as monitor:
optimizer.minimize(model, step_callback=monitor, global_step=global_step, maxiter=maxiter)
finallog = model.compute_log_likelihood()
if model_class in ['GPSSM_MS_FactorizedLinear', gaussian_GPSSM_name]:
#Z_Inds = model.transitions.Z.feat.Z.value
#Mu_Inds = model.transitions.Umu.value
#Sigma_Inds = model.transitions.Ucov_chol.value
X_samples = session.run(model._build_sample_qx())
else:
X_samples = session.run(model._build_sample()[0])
#Z_Inds = vcdt.Z.feat.Z.value
#Mu_Inds = model.Umu.value
#Sigma_Inds = model.Ucov_chol.value
#np.savez(os.path.join(save_path, 'LastState.npz'),
# Z_Inds=Z_Inds, Mu_Inds=Mu_Inds, Sigma_Inds=Sigma_Inds,log= finallog, X_Samples = X_samples)
np.savez(os.path.join(save_path, 'LastState.npz'),log= finallog, X_Samples = X_samples)
if Ypredseqahead is not None:
if model_class in ['GPSSM_MS_FactorizedLinear', gaussian_GPSSM_name]:
X_samples_filter = [np.transpose(xf, [1, 0, 2]) for xf in session.run(model._build_sample_qx())]
else:
X_samples_filter = session.run(model._build_sample()[0])
model_to_sample = model
X_samples, Y_samples, SE, RMSE, logp, NLPP, NLPP_mean, model_params = [], [], [], [], [], [], [], []
for i in range(len(Ypredseqahead)):
if model_class in ['GPSSM_MS_FactorizedLinear', gaussian_GPSSM_name]:
model_to_sample = GPSSM_Cubic(D, Ypredseqahead[i], emissions=model.emissions,inputs=Upredseqahead[i],
px1_mu=None, px1_cov=None,
kern=model.transitions.kern.kern,
Z=model.transitions.Z.feat.Z.value,
mean_fn=model.transitions.mean_fn,
Q_diag=model.transitions.Q_sqrt.value.copy() ** 2.,
Umu=model.transitions.Umu.value.copy(),
Ucov_chol=model.transitions.Ucov_chol.value.copy(),
qx1_mu=None, qx1_cov=None, As=None, bs=None, Ss=None,
n_samples=n_samples, seed=None,
name='GPSSM_posterior_sampling')
X_samples_i, Y_samples_i = model_to_sample.sample(T=test_length,
x0_samples=X_samples_filter[i][-1],
inputs=Upredseqahead[i],
cubic=False)
Ypred_i = Ypredseqahead[i]
SE_i = np.square(Y_samples_i.mean(1)[1:,:] - Ypred_i)
RMSE_i = np.sqrt(np.mean(np.sum(SE_i, -1)))
logp_i = session.run(
model_to_sample.emissions.logp(tf.constant(X_samples_i[1:,:]), tf.constant(Ypred_i[:, None, :])))
NLPP_i = - np.log(np.mean(np.exp(logp_i), axis=-1)) # We do not simply average over the logs, but ove the real
NLPP_mean_i = NLPP_i.mean()
print(RMSE_i, NLPP_mean_i)
X_samples.append(X_samples_i)
Y_samples.append(Y_samples_i)
SE.append(SE_i)
RMSE.append(RMSE_i)
logp.append(logp_i)
NLPP.append(NLPP_i)
NLPP_mean.append(NLPP_mean_i)
model_params.append(model.read_values(session=session))
np.savez(os.path.join(save_path, 'test_results2.npz'),
X_samples=X_samples, Y_samples=Y_samples, Ypred=Ypredseqahead,
SE=SE, RMSE=RMSE, logp=logp, NLPP=NLPP, NLPP_mean=NLPP_mean,
model_params=model_params, Upred = Upredseqahead)
pred_session = em.enquire_session()
pred_mu = []
pred_var = []
if Xtest is not None:
for i in range(len(Xtest)):
if Utest is not None:
Xin = np.concatenate([Xtest[i], Utest[i]], axis=1 )
else:
Xin = Xtest[i]
Xin = tf.constant(Xin)
if model_class == "GPSSM_MS_FactorizedLinear":
F_mu, F_var = pred_session.run(
model.transitions.conditional(Xin, add_noise=False))
else:
F_mu, F_var = session.run(model._build_predict_f(Xin))
pred_mu.extend(F_mu)
pred_var.extend(F_var)
np.save(args["dir"] + args["name"]+ "_pred", np.stack(np.stack(pred_mu), np.stack(pred_var)))
if Xplot is not None :
if Uplot is not None:
Xin = np.concatenate([Xplot, Uplot], axis=1 )
else:
Xin = Xplot
Xin = tf.constant(Xin)
if model_class == "GPSSM_MS_FactorizedLinear":
F_mu_plot, F_var_plot = pred_session.run(
model.transitions.conditional(Xin, add_noise=False))
else:
F_mu_plot, F_var_plot = session.run(model._build_predict_f(Xin))
np.save(args["dir"] + args["name"]+ "_plot", np.stack([F_mu_plot,F_var_plot]))
if Ypred is not None:
batch_size = None
Y_test_filter = [Ypred[i][:filter_length, :] for i in range(len(Ypred))]
U_test_filter = [Upred[i][:filter_length+1, :] for i in range(len(Ypred))]
modeltest = model_class_python(D, Y_test_filter, emissions=model.emissions, inputs= U_test_filter,
px1_mu=None, px1_cov=None,
kern=model.kern.kern,
Z=model.Z.feat.Z.value,
mean_fn=model.mean_fn,
Q_diag=model.Q_sqrt.value.copy() ** 2.,
Umu=model.Umu.value.copy(),
Ucov_chol=model.Ucov_chol.value.copy(),
qx1_mu=None, qx1_cov=None, As=None, bs=None, Ss=None,
n_samples=n_samples, batch_size=batch_size,
seed=None,
name='GPSSM_posterior')
modeltest.trainable = False
modeltest.qx1_mu.trainable = True
modeltest.qx1_cov_chol.trainable = True
if 'PRSSM' not in model_class:
modeltest.As.trainable = True
modeltest.bs.trainable = True
modeltest.S_chols.trainable = True
print('Likelihood at initialisation on filtering test sequences:', modeltest.compute_log_likelihood())
# We use the same optimizer again
global_step = mon.create_global_step(session)
print_task = mon.PrintTimingsTask() \
.with_name('print') \
.with_condition(mon.PeriodicIterationCondition(100))
checkpoint_task = mon.CheckpointTask(checkpoint_dir=save_path + '/checkpoints',
saver=tf.train.Saver(max_to_keep=100, save_relative_paths=True)) \
.with_name('checkpoint') \
.with_condition(mon.PeriodicIterationCondition(10000)) \
.with_exit_condition(True)
with mon.LogdirWriter(save_path + '/tensorboard') as writer:
tensorboard_task = mon.ModelToTensorBoardTask(writer, model, only_scalars=False) \
.with_name('tensorboard') \
.with_condition(mon.PeriodicIterationCondition(50)) \
.with_exit_condition(True)
monitor_tasks = [print_task, tensorboard_task, checkpoint_task]
with mon.Monitor(monitor_tasks, session, global_step, print_summary=True) as monitor:
optimizer.minimize(modeltest, step_callback=monitor, global_step=global_step, maxiter=maxiter)
if test_samples is not None:
modeltest.n_samples = test_samples
modeltest.compile()
if model_class in ['GPSSM_MS_FactorizedLinear', gaussian_GPSSM_name]:
X_samples_filter = [np.transpose(xf, [1, 0, 2]) for xf in session.run(modeltest._build_sample_qx())]
model_to_sample = GPSSM_Cubic(D, Y_test_filter, emissions=modeltest.emissions, inputs =U_test_filter,
px1_mu=None, px1_cov=None,
kern=modeltest.transitions.kern.kern,
Z=modeltest.transitions.Z.feat.Z.value,
mean_fn=modeltest.transitions.mean_fn,
Q_diag=modeltest.transitions.Q_sqrt.value.copy() ** 2.,
Umu=modeltest.transitions.Umu.value.copy(),
Ucov_chol=modeltest.transitions.Ucov_chol.value.copy(),
qx1_mu=None, qx1_cov=None, As=None, bs=None, Ss=None,
n_samples=n_samples, seed=None,
name='GPSSM_posterior_sampling')
else:
X_samples_filter = session.run(modeltest._build_sample()[0])
model_to_sample = modeltest
Y_samples_filter = [modeltest.emissions.sample_conditional(xf[1:,:]) for xf in X_samples_filter]
X_samples, Y_samples, SE, RMSE, logp, NLPP, NLPP_mean, model_params = [], [], [], [], [], [], [], []
for i in range(len(Ypred)):
X_samples_i, Y_samples_i = model_to_sample.sample(T=test_length,
x0_samples=X_samples_filter[i][-1],
inputs=Upred[filter_length:test_length+1, :],
cubic=False)
Ypred_i = Ypred[i][:(filter_length + test_length), :]
X_samples_i = np.concatenate([X_samples_filter[i], X_samples_i[1:]], 0)
Y_samples_i = np.concatenate([Y_samples_filter[i], Y_samples_i[1:]], 0)
SE_i = np.square(Y_samples_i.mean(1) - Ypred_i)
RMSE_i = np.sqrt(np.mean(np.sum(SE_i, -1)))
logp_i = session.run(
model_to_sample.emissions.logp(tf.constant(X_samples_i), tf.constant(Ypred_i[:, None, :])))
NLPP_i = - np.log(np.mean(np.exp(logp_i), axis=-1)) # We do not simply average over the logs, but ove the real
NLPP_mean_i = NLPP_i.mean()
print(RMSE_i, NLPP_mean_i)
X_samples.append(X_samples_i)
Y_samples.append(Y_samples_i)
SE.append(SE_i)
RMSE.append(RMSE_i)
logp.append(logp_i)
NLPP.append(NLPP_i)
NLPP_mean.append(NLPP_mean_i)
model_params.append(modeltest.read_values(session=session))
np.savez(os.path.join(save_path, 'test_results.npz'),
X_samples=X_samples, Y_samples=Y_samples, Ypred=Ypred, Upred= Upred,
SE=SE, RMSE=RMSE, logp=logp, NLPP=NLPP, NLPP_mean=NLPP_mean, filter_length=filter_length,
model_params=model_params)
def run_experiment(_seed, D, T, n_seq, batch_size, model_class, optimizer,
learning_rate, momentum, use_nesterov, maxiter,
parallel_iterations, process_noise_var, emission_noise_var,
Q_init_scale, R_init_scale, Ucov_chol_init_scale,
X_chol_init_scale, kern_var_init, init_at_gp_on_Y, train_R,
train_C, train_b, train_Q, train_kern_var, train_Z,
train_As, train_bs, train_Ss, n_samples, n_ind_pts,
base_save_path, init_from_disk, test, filter_length,
test_length, test_seq, test_samples):
tf.set_random_seed(_seed)
np.random.seed(_seed)
tr = KinkTransitions(dim=D,
Q=np.ones(D) * process_noise_var,
name='KinkTransitions_datagen')
em = GaussianEmissions(obs_dim=D,
R=np.eye(D) * emission_noise_var,
name='GaussianEmissions_datagen')
SSM_datagen = SSM(X_init=np.zeros((T, D)),
Y=np.zeros((T, D)),
transitions=tr,
emissions=em,
name='SSM_datagen')
X, Y = SSM_datagen.sample(T, N=n_seq)
X, Y = list(X), list(Y)
if test:
X_test, Y_test = SSM_datagen.sample(filter_length + test_length,
N=test_seq)
Y_test_filter = list(Y_test[:, :filter_length])
gaussian_GPSSM_name = 'SSM_nf_MULTISEQ'
model_classes = [
gaussian_GPSSM_name, 'PRSSM_MS_MF', 'PRSSM_MS', 'GPSSM_MS_MF',
'GPSSM_MS_SPURIOUS', 'GPSSM_MS_FITC', 'GPSSM_MS_CUBIC',
'GPSSM_MS_VCDT', 'GPSSM_MS_FITC_SAMPLE_F', 'GPSSM_VCDT_Stick_Land'
]
if model_class in model_classes:
model_class_python = eval(model_class)
else:
raise ValueError('Unknown model class')
kern = gp.kernels.RBF(D,
variance=kern_var_init,
ARD=True,
name='GPSSM_kern')
Z = np.linspace(-8., 3., n_ind_pts)[:, None]
mean_fn = mean_fns.Zero(D, name='GPSSM_mean_fn')
Q_diag = np.ones(D) * Q_init_scale
Ucov_chol = np.tile(np.eye(n_ind_pts)[None, ...],
[D, 1, 1]) * Ucov_chol_init_scale
if init_from_disk is not None and init_from_disk[-4:] == '.npy':
GPSSM_params = np.load(init_from_disk).ravel()[0]
if 'GPSSM/Q_sqrt' in GPSSM_params.keys():
Q_diag = GPSSM_params['GPSSM/Q_sqrt']**2.
elif init_at_gp_on_Y:
X_gp = np.concatenate([y[:-1] for y in Y])
Y_gp = np.concatenate([y[1:] for y in Y])
gpr = gp.models.SVGP(X_gp,
Y_gp,
kern,
gp.likelihoods.Gaussian(variance=Q_diag,
name='GPR_likelihood'),
Z=Z,
mean_function=mean_fn)
gpr.likelihood.trainable = train_Q
gpr.kern.variance.trainable = train_kern_var
gpr.feature.trainable = train_Z
opt = gp.train.ScipyOptimizer()
opt.minimize(gpr)
if R_init_scale is not None:
em.Rchol = np.eye(D) * (R_init_scale**0.5)
em.compile()
if model_class == 'GPSSM_VCDT_Stick_Land':
assert n_seq == 1
Y = Y[0]
extra_kwargs = {}
else:
extra_kwargs = {'batch_size': batch_size}
model = model_class_python(D,
Y,
emissions=em,
kern=kern,
Z=Z,
mean_fn=mean_fn,
Q_diag=Q_diag,
Ucov_chol=Ucov_chol,
n_samples=n_samples,
parallel_iterations=parallel_iterations,
seed=None,
name='GPSSM',
**extra_kwargs)
transitions = model
if train_As is not None: model.As.trainable = train_As
if train_bs is not None: model.bs.trainable = train_bs
if train_Ss is not None: model.S_chols.trainable = train_Ss
transitions.Q_sqrt.trainable = train_Q
try:
transitions.kern.kern.variance.trainable = train_kern_var
except:
warnings.warn(
'Could not set trainable status of the kernel\'s variance: default is trainable'
)
transitions.Z.trainable = train_Z
model.emissions.Rchol.trainable = train_R
model.emissions.C.trainable = train_C
model.emissions.bias.trainable = train_b
session_conf = tf.ConfigProto(intra_op_parallelism_threads=4,
inter_op_parallelism_threads=4)
session = model.enquire_session()
if test:
assert init_from_disk is not None, 'Have to initialise before testing'
if init_from_disk is not None:
if init_from_disk[-4:] != '.npy':
matching_dirs = glob(init_from_disk)
assert len(
matching_dirs) == 1, 'More/Less than one matching run found'
matching_dir = matching_dirs[0]
checkpoint_loc = tf.train.latest_checkpoint(matching_dir +
'/checkpoints')
tf.train.Saver().restore(session, checkpoint_loc)
GPSSM_params = model.read_values(session)
if 'PRSSM' in model_class:
offending_keys = [
k for k in GPSSM_params.keys()
if ('/As' in k or '/bs' in k or '/S_chols' in k)
]
for k in offending_keys:
GPSSM_params.pop(k)
model.assign(GPSSM_params)
model.compile()
print(
'================== Successfully initialised GPSSM params from: ' +
init_from_disk + ' ==================')
print('Likelihood at initialisation loaded from disk:',
model.compute_log_likelihood())
elif init_at_gp_on_Y:
transitions.Q_sqrt = gpr.likelihood.variance.value**0.5
if model_class != gaussian_GPSSM_name:
model.S_chols = model.S_chols.value * 0. + gpr.likelihood.variance.value**0.5
transitions.Umu = gpr.q_mu.value.T
transitions.Ucov_chol = gpr.q_sqrt.value
transitions.kern.kern.variance = gpr.kern.variance.value
transitions.kern.kern.lengthscales = gpr.kern.lengthscales.value
transitions.Z.feat.Z = gpr.feature.Z.value
transitions.mean_fn.assign(gpr.mean_function.read_values())
model.compile()
print(
'================== Successfully initialised using a GP fit on the observations =================='
)
print('Likelihood at initialisation from GP fit on the observations:',
model.compute_log_likelihood())
if test:
batch_size = None
model = model_class_python(D,
Y_test_filter,
emissions=model.emissions,
px1_mu=None,
px1_cov=None,
kern=model.kern.kern,
Z=model.Z.feat.Z.value,
mean_fn=model.mean_fn,
Q_diag=model.Q_sqrt.value.copy()**2.,
Umu=model.Umu.value.copy(),
Ucov_chol=model.Ucov_chol.value.copy(),
qx1_mu=None,
qx1_cov=None,
As=None,
bs=None,
Ss=None,
n_samples=n_samples,
batch_size=batch_size,
seed=None,
parallel_iterations=parallel_iterations,
name='GPSSM_posterior')
model.trainable = False
model.qx1_mu.trainable = True
model.qx1_cov_chol.trainable = True
if 'PRSSM' not in model_class:
model.As.trainable = True
model.bs.trainable = True
model.S_chols.trainable = True
print('Likelihood at initialisation on filtering test sequences:',
model.compute_log_likelihood())
# Monitoring:
experiment_id = model_class \
+ '__T_' + str(T) + '__n_seq_' + str(n_seq) \
+ '__Q_' + str(process_noise_var) + '__R_' + str(emission_noise_var) \
+ '__n_samples_' + str(n_samples) + '__M_' + str(n_ind_pts)
if test:
experiment_id += '__test'
if init_from_disk is not None:
experiment_id += '__initialised'
save_path = os.path.join(base_save_path,
experiment_id + '__' + str(datetime.now()))
if optimizer == 'adam':
optimizer = gp.train.AdamOptimizer(learning_rate=learning_rate)
elif optimizer == 'momentum':
optimizer = gp.train.MomentumOptimizer(learning_rate=learning_rate,
momentum=momentum,
use_nesterov=use_nesterov)
else:
raise ValueError('Unknown optimizer')
global_step = mon.create_global_step(session)
print_task = mon.PrintTimingsTask() \
.with_name('print') \
.with_condition(mon.PeriodicIterationCondition(100))
checkpoint_task = mon.CheckpointTask(checkpoint_dir=save_path + '/checkpoints',
saver=tf.train.Saver(max_to_keep=100, save_relative_paths=True)) \
.with_name('checkpoint') \
.with_condition(mon.PeriodicIterationCondition(10000)) \
.with_exit_condition(True)
with mon.LogdirWriter(save_path + '/tensorboard') as writer:
tensorboard_task = mon.ModelToTensorBoardTask(writer, model, only_scalars=False) \
.with_name('tensorboard') \
.with_condition(mon.PeriodicIterationCondition(50)) \
.with_exit_condition(True)
monitor_tasks = [print_task, tensorboard_task, checkpoint_task]
with mon.Monitor(monitor_tasks,
session,
global_step,
print_summary=True) as monitor:
optimizer.minimize(model,
step_callback=monitor,
global_step=global_step,
maxiter=maxiter)
if test:
if test_samples is not None:
model.n_samples = test_samples
model.compile()
if model_class == gaussian_GPSSM_name:
X_samples_filter = [
np.transpose(xf, [1, 0, 2])
for xf in session.run(model._build_sample_qx())
]
model_to_sample = GPSSM_CUBIC(
D,
Y_test[0],
emissions=model.emissions,
px1_mu=None,
px1_cov=None,
kern=model.transitions.kern.kern,
Z=model.transitions.Z.feat.Z.value,
mean_fn=model.transitions.mean_fn,
Q_diag=model.transitions.Q_sqrt.value.copy()**2.,
Umu=model.transitions.Umu.value.copy(),
Ucov_chol=model.transitions.Ucov_chol.value.copy(),
qx1_mu=None,
qx1_cov=None,
As=None,
bs=None,
Ss=None,
n_samples=n_samples,
seed=None,
parallel_iterations=parallel_iterations,
name='GPSSM_posterior_sampling')
else:
X_samples_filter = session.run(model._build_sample()[0])
model_to_sample = model
Y_samples_filter = [
model.emissions.sample_conditional(xf) for xf in X_samples_filter
]
X_samples, Y_samples, SE, RMSE, logp, NLPP, NLPP_mean, model_params = [], [], [], [], [], [], [], []
for i in range(len(Y_test)):
X_samples_i, Y_samples_i = model_to_sample.sample(
T=len(Y_test[i]) - filter_length,
x0_samples=X_samples_filter[i][-1],
inputs=None,
cubic=False)
X_samples_i = np.concatenate(
[X_samples_filter[i], X_samples_i[1:]], 0)
Y_samples_i = np.concatenate(
[Y_samples_filter[i], Y_samples_i[1:]], 0)
SE_i = np.square(Y_samples_i.mean(1) - Y_test[i])
RMSE_i = np.sqrt(np.mean(np.sum(SE_i, -1)))
logp_i = session.run(
model_to_sample.emissions.logp(
tf.constant(X_samples_i), tf.constant(Y_test[i][:,
None, :])))
NLPP_i = -log(
mean(exp(logp_i), axis=-1)
) # We do not simply average over the logs, but ove the real
NLPP_mean_i = NLPP_i.mean()
print(RMSE_i, NLPP_mean_i)
X_samples.append(X_samples_i)
Y_samples.append(Y_samples_i)
SE.append(SE_i)
RMSE.append(RMSE_i)
logp.append(logp_i)
NLPP.append(NLPP_i)
NLPP_mean.append(NLPP_mean_i)
model_params.append(model.read_values(session=session))
np.savez(os.path.join(matching_dir, 'test_results.npz'),
X_samples=X_samples,
Y_samples=Y_samples,
X_test=X_test,
Y_test=Y_test,
SE=SE,
RMSE=RMSE,
logp=logp,
NLPP=NLPP,
NLPP_mean=NLPP_mean,
filter_length=filter_length,
model_params=model_params)
nw = np.zeros((trX.shape[0] - 1, nodes, nodes))
nw[0, :, :] = model.layers[0].kern.lengthscales.value
for cur_n in range(0, trX.shape[0] - 2):
# for cur_n in range(1, trX.shape[0]):
model.X.update_cur_n(cur_n, cc=cc, loc=loc)
model.Y.update_cur_n(cur_n, cc=cc, loc=loc)
with mon.LogdirWriter(exp_path) as writer:
tensorboard_task = mon.ModelToTensorBoardTask(writer, model)\
.with_name('tensorboard')\
.with_condition(mon.PeriodicIterationCondition(100))\
.with_exit_condition(True)
monitor_tasks = [] # [print_task, tensorboard_task]
with mon.Monitor(monitor_tasks, session) as monitor:
#optimiser.minimize(model, step_callback=monitor, global_step=global_step, maxiter=maxiter)
model.layers[0].feature.Z.assign(Zcp.copy())
model.layers[0].kern.lengthscales.assign(np.ones((nodes, nodes)))
optimiser.minimize(model, step_callback=monitor, maxiter=maxiter)
nw[cur_n, :, :] = model.layers[0].kern.lengthscales.value
teX = trX[cur_n + 1].reshape(1, nodes)
S = 100
m, v = model.predict_y(teX, S)
pred = np.mean(m, axis=0)
var = np.mean(v, axis=0)
if inc:
pred += teX
tensorboard_task = mon.ModelToTensorBoardTask(writer, model, only_scalars=False)\
.with_name('tensorboard')\
.with_condition(mon.PeriodicIterationCondition(100))\
.with_exit_condition(True)
print_task = mon.PrintTimingsTask() \
.with_name('print') \
.with_condition(mon.PeriodicIterationCondition(500))
# Create optimizer
epoch_steps = len(data['X']) // int(args.bs)
learning_rate = tf.train.exponential_decay(float(args.lr), global_step, decay_steps=epoch_steps, decay_rate=0.99)
optimizer = gpflow.train.AdamOptimizer(learning_rate)
maxiter = epoch_steps * EPOCHS
print('Optimizing model (running {} iterations)...'.format(maxiter))
with mon.Monitor([tensorboard_task, print_task], session, global_step, print_summary=True) as monitor:
optimizer.minimize(model, maxiter=maxiter, step_callback=monitor, global_step=global_step)
# Save model
print('Saving model...')
fname = 'models/{model_name}.gpflow'.format(model_name=model_name)
if os.path.exists(fname):
os.remove(fname)
try:
Saver().save(fname, model)
except ValueError as e:
print('Failed to save model:', e)
# Evaluate model
print('Evaluating model...')
metrics = []
def ex1():
fX_dim = 1
M = 100
X, Y, Xt, Yt = LoadData.load_ocean()
# annoyingly only float32 and lower is supported by the conv layers
f = lambda x: tf.cast(NN.cnn_fn(tf.cast(x, tf.float32), fX_dim), float_type)
kern = NNComposedKernel(gpflow.kernels.Matern32(fX_dim), f)
# build the model
lik = gpflow.likelihoods.Gaussian()
Z = kmeans2(X, M, minit='points')[0]
model = NN_SVGP(X, Y, kern, lik, Z=Z, minibatch_size=200)
session = model.enquire_session()
global_step = mon.create_global_step(session)
# print
print_task = mon.PrintTimingsTask().with_name('print') \
.with_condition(mon.PeriodicIterationCondition(10)) \
.with_exit_condition(True)
sleep_task = mon.SleepTask(0.01).with_name('sleep').with_name('sleep')
saver_task = mon.CheckpointTask('./monitor-saves').with_name('saver') \
.with_condition(mon.PeriodicIterationCondition(10)) \
.with_exit_condition(True)
file_writer = mon.LogdirWriter('./model-tensorboard')
model_tboard_task = mon.ModelToTensorBoardTask(file_writer, model).with_name('model_tboard') \
.with_condition(mon.PeriodicIterationCondition(10)) \
.with_exit_condition(True)
lml_tboard_task = mon.LmlToTensorBoardTask(file_writer, model).with_name('lml_tboard') \
.with_condition(mon.PeriodicIterationCondition(100)) \
.with_exit_condition(True)
custom_tboard_task = CustomTensorBoardTask(file_writer, model, Xt, Yt).with_name('custom_tboard') \
.with_condition(mon.PeriodicIterationCondition(100)) \
.with_exit_condition(True)
monitor_tasks = [print_task, model_tboard_task, lml_tboard_task, custom_tboard_task, saver_task, sleep_task]
monitor = mon.Monitor(monitor_tasks, session, global_step)
if os.path.isdir('./monitor-saves'):
mon.restore_session(session, './monitor-saves')
# use gpflow wrappers to train. NB all session handling is done for us
optimiser = gpflow.training.AdamOptimizer(0.001)
with mon.Monitor(monitor_tasks, session, global_step, print_summary=True) as monitor:
optimiser.minimize(model, step_callback=monitor, maxiter=30000, global_step=global_step)
file_writer.close()
print('LML after the optimisation: %f' % m.compute_log_likelihood())
# # predictions
pY, pYv = model.predict_y(Xt)
rmse = np.mean((pY - Yt) ** 2.0) ** 0.5
nlpp = -np.mean(-0.5 * np.log(2 * np.pi * pYv) - 0.5 * (Yt - pY) ** 2.0 / pYv)
print('rmse is {:.4f}%, nlpp is {:.f}%'.format(rmse, nlpp))
