def _optimise_model(self, model: gpflow.models.Model,
optimise_func: Callable[[gpflow.models.Model, Callable, tf.Variable], None],
use_global_step: Optional[bool]=False, optimiser=None) -> 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()
lml_before = model.compute_log_likelihood()
# Run optimisation
with mon.Monitor([monitor_task], session, global_step_tensor, optimiser=optimiser) \
as monitor:
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)
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 add_jitter_to_model(model: gpflow.models.Model, mean: float=0, sd: float=0.1) -> None:
"""Add randomness (jitter) to a models parameters.
Randomness is drawn from a normal distribution with mean `mean` and standard deviation `sd`.
This method works inplace on the model which is passed.
Parameters
----------
model: gpflow.models.Model
Model to jitter.
mean: float
Mean of normal distribution that randomness is drawn from.
sd: float
Standard deviation of normal distribution that randomness is drawn from.
"""
for param_pathname, param_value in model.read_values().items():
model.assign({
param_pathname: param_value + np.random.normal(loc=mean, scale=sd),
})
def __init__(self, model: gpflow.models.Model, optimiser: gpflow.training.optimizer.Optimizer,
global_step, session=None, var_list=None):
self.session = model.enquire_session(session)
self.var_list = var_list
# Setup timers
total_time = timer.Stopwatch()
optimisation_time = timer.Stopwatch()
iter_count = timer.ElapsedTracker()
self.timers = {Trigger.TOTAL_TIME: total_time,
Trigger.OPTIMISATION_TIME: optimisation_time,
Trigger.ITER: iter_count}
self.tasks = []
self.model = model
self.global_step = global_step
self.set_optimiser(optimiser)
def negative_log_likelihood(model: gpflow.models.Model) -> float:
r"""Calculate the negative logarithmic likelihood of a model.
Uses gpflow method `compute_log_likelihood`, which returns:
```
LL = \log p(Y | model, theta)
```
With `theta` being the models parameters and `model` usually being a GP regression model,
`LL` being the *non-negative* log likelihood.
We then negate `LL` in order to obtain the negative log likelihood.
Parameters
----------
model: gpflow.models.Model
Model to be scored.
Returns
-------
score: float
Negative logarithmic likelihood score of the passed model.
"""
return -model.compute_log_likelihood()