def model(vs,
a_scale: Positive = 0.1,
b_scale: Positive = 0.1,
noise: Positive = 0.01):
# Construct an RNN.
f_rnn = rnn_constructor(output_size=1,
widths=(10, ),
nonlinearity=B.tanh,
final_dense=True)
# Set the weights for the RNN.
num_weights = f_rnn.num_weights(input_size=1)
weights = Vars(tf.float32,
source=vs.get(shape=(num_weights, ), name="rnn"))
f_rnn.initialise(input_size=1, vs=weights)
with Measure():
# Construct GPs that modulate the RNN.
a = GP(1e-2 * EQ().stretch(a_scale))
b = GP(1e-2 * EQ().stretch(b_scale))
# GP-RNN model:
f_gp_rnn = (1 + a) * (lambda x: f_rnn(x)) + b
return f_rnn, f_gp_rnn, noise, a, b
def model(vs):
g = Graph()
# Construct an RNN.
f_rnn = rnn_constructor(output_size=1,
widths=(10, ),
nonlinearity=B.tanh,
final_dense=True)
# Set the weights for the RNN.
num_weights = f_rnn.num_weights(input_size=1)
weights = Vars(tf.float32,
source=vs.get(shape=(num_weights, ), name='rnn'))
f_rnn.initialise(input_size=1, vs=weights)
# Construct GPs that modulate the RNN.
a = GP(1e-2 * EQ().stretch(vs.pos(0.1, name='a/scale')), graph=g)
b = GP(1e-2 * EQ().stretch(vs.pos(0.1, name='b/scale')), graph=g)
e = GP(vs.pos(1e-2, name='e/var') * Delta(), graph=g)
# GP-RNN model:
f_gp_rnn = (1 + a) * (lambda x: f_rnn(x)) + b
y_gp_rnn = f_gp_rnn + e
return f_rnn, f_gp_rnn, y_gp_rnn, a, b
def model(
vs,
var1: Positive = 1,
scale1: Positive = 1,
noise1: Positive = 0.1,
var2: Positive = 1,
scale2: Positive = 1,
noise2: Positive = 0.1,
):
# Build layers:
f1 = GP(var1 * EQ().stretch(scale1))
f2 = GP(var2 * EQ().stretch(scale2))
return (f1, noise1), (f2, noise2)
def model(vs):
g = Graph()
# Construct model for first layer:
f1 = GP(vs.pos(1., name='f1/var') *
EQ().stretch(vs.pos(1., name='f1/scale')),
graph=g)
e1 = GP(vs.pos(0.1, name='e1/var') * Delta(), graph=g)
y1 = f1 + e1
# Construct model for second layer:
f2 = GP(vs.pos(1., name='f2/var') *
EQ().stretch(vs.pos(np.array([1., .5]), name='f2/scale')),
graph=g)
e2 = GP(vs.pos(0.1, name='e2/var') * Delta(), graph=g)
y2 = f2 + e2
return f1, y1, f2, y2
def model(
vs,
var1: Positive = 1,
scale1: Positive = 1,
noise1: Positive = 0.1,
var2: Positive = 1,
scale2: Positive = 1,
noise2: Positive = 0.1,
):
# Construct model for first layer:
prior1 = Measure()
f1 = GP(var1 * EQ() > scale1, measure=prior1)
e1 = GP(noise1 * Delta(), measure=prior1)
y1 = f1 + e1
# Construct model for second layer:
prior2 = Measure()
f2 = GP(var2 * EQ() > scale2, measure=prior2)
e2 = GP(noise2 * Delta(), measure=prior2)
y2 = f2 + e2
return f1, y1, f2, y2
def model(
vs,
u_var: Positive = 0.5,
u_scale: Positive = 0.5,
noise: Positive = 0.5,
alpha: Positive = 1.2,
):
with Measure():
# Random fluctuation:
u = GP(u_var * EQ().stretch(u_scale))
# Construct model.
f = u + (lambda x: x**alpha)
return f, noise
def model(vs):
g = Graph()
# Random fluctuation:
u = GP(vs.pos(.5, name='u/var') *
EQ().stretch(vs.pos(0.5, name='u/scale')), graph=g)
# Noise:
e = GP(vs.pos(0.5, name='e/var') * Delta(), graph=g)
# Construct model:
alpha = vs.pos(1.2, name='alpha')
f = u + (lambda x: x ** alpha)
y = f + e
return f, y
def model(
vs,
u_var: Positive = 0.5,
u_scale: Positive = 0.5,
e_var: Positive = 0.5,
alpha: Positive = 1.2,
):
prior = Measure()
# Random fluctuation:
u = GP(u_var * EQ() > u_scale, measure=prior)
# Noise:
e = GP(e_var * Delta(), measure=prior)
# Construct model:
f = u + (lambda x: x**alpha)
y = f + e
return f, y
import matplotlib.pyplot as plt import numpy as np import tensorflow as tf from tensorflow.contrib.opt import ScipyOptimizerInterface as SOI from wbml import vars64 as vs from stheno.tensorflow import GP, EQ, Delta s = tf.Session() # Define points to predict at. x = np.linspace(0, 5, 100) x_obs = np.linspace(0, 3, 20) # Construct the model. u = GP(vs.pos(.5) * EQ().stretch(vs.pos(1.))) e = GP(vs.pos(.5) * Delta()) alpha = vs.pos(1.2) vs.init(s) f = u + (lambda x: x**alpha) y = f + e # Sample a true, underlying function and observations. f_true = x**1.8 y_obs = s.run((y | (f(x), f_true))(x_obs).sample()) # Learn. lml = y(x_obs).logpdf(y_obs) SOI(-lml).minimize(s)
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
import wbml.plot
from stheno.tensorflow import B, GP, EQ, Delta, Obs
# Define points to predict at.
x = B.linspace(tf.float64, 0, 10, 200)
x_obs = B.linspace(tf.float64, 0, 10, 10)
# Construct the model.
f = 0.7 * GP(EQ()).stretch(1.5)
e = 0.2 * GP(Delta())
# Construct derivatives.
df = f.diff()
ddf = df.diff()
dddf = ddf.diff() + e
# Fix the integration constants.
zero = tf.constant(0, dtype=tf.float64)
one = tf.constant(1, dtype=tf.float64)
f, df, ddf, dddf = (f, df, ddf, dddf) | Obs((f(zero), one), (df(zero), zero),
(ddf(zero), -one))
# Sample observations.
y_obs = B.sin(x_obs) + 0.2 * B.randn(*x_obs.shape)
# Condition on the observations to make predictions.
f, df, ddf, dddf = (f, df, ddf, dddf) | Obs(dddf(x_obs), y_obs)
from varz.tensorflow import Vars, minimise_adam
from wbml.net import rnn as rnn_constructor
from stheno.tensorflow import B, Graph, GP, Delta, EQ, Obs
# Increase regularisation because we are dealing with float32.
B.epsilon = 1e-6
# Construct points which to predict at.
x = B.linspace(tf.float32, 0, 1, 100)[:, None]
inds_obs = np.arange(0, int(0.75 * len(x))) # Train on the first 75% only.
x_obs = B.take(x, inds_obs)
# Construct function and observations.
# Draw random modulation functions.
a_true = GP(1e-2 * EQ().stretch(0.1))(x).sample()
b_true = GP(1e-2 * EQ().stretch(0.1))(x).sample()
# Construct the true, underlying function.
f_true = (1 + a_true) * B.sin(2 * np.pi * 7 * x) + b_true
# Add noise.
y_true = f_true + 0.1 * B.randn(*f_true.shape)
# Normalise and split.
f_true = (f_true - B.mean(y_true)) / B.std(y_true)
y_true = (y_true - B.mean(y_true)) / B.std(y_true)
y_obs = B.take(y_true, inds_obs)
def model(vs):
g = Graph()
s = tf.Session() # Define points to predict at. x = np.linspace(0, 10, 200) x_obs1 = np.linspace(0, 10, 30) inds2 = np.random.permutation(len(x_obs1))[:10] x_obs2 = x_obs1[inds2] # Construct variable storages. vs1 = Vars(np.float64) vs2 = Vars(np.float64) # Construct a model for each output. m1 = Graph() m2 = Graph() f1 = vs1.pos(1.) * GP(EQ(), graph=m1).stretch(vs1.pos(1.)) f2 = vs2.pos(1.) * GP(EQ(), graph=m2).stretch(vs2.pos([1., .5])) sig1 = vs1.pos(0.1) sig2 = vs2.pos(0.1) # Initialise variables. vs1.init(s) vs2.init(s) # Noise models: e1 = sig1 * GP(Delta(), graph=m1) e2 = sig2 * GP(Delta(), graph=m2) # Observation models: y1 = f1 + e1 y2 = f2 + e2
# Construct function and observations. # Draw a random fluctuation. k_u = .2 * RQ(1e-1).stretch(0.05) u = s.run(GP(k_u)(np.array(x, dtype=np.float64)).sample()).squeeze() # Construct the true, underlying function. f_true = np.sin(2 * np.pi * 7 * x) + np.array(u, dtype=np.float32) # Add noise. y_true = f_true + 0.2 * np.array(np.random.randn(*x.shape), dtype=np.float32) # Normalise and split. f_true = (f_true - np.mean(y_true)) / np.std(y_true) y_true = (y_true - np.mean(y_true)) / np.std(y_true) y_obs = y_true[inds_obs] # Construct the model. a = 0.1 * GP(EQ()).stretch(vs_gp.pos(0.1)) b = 0.1 * GP(EQ()).stretch(vs_gp.pos(0.1)) e = vs_gp.pos(0.1) * GP(Delta()) # RNN-only model: y_rnn = rnn + e # GP-RNN model: f_gp_rnn = (1 + a) * rnn + b y_gp_rnn = f_gp_rnn + e # Construct evidences. lml_rnn = y_rnn(x_obs).logpdf(y_obs) lml_gp_rnn = y_gp_rnn(x_obs).logpdf(y_obs) # Construct optimisers and initialise.
import matplotlib.pyplot as plt import numpy as np import tensorflow as tf import wbml.plot from stheno.tensorflow import B, Measure, GP, EQ, Delta # Define points to predict at. x = B.linspace(tf.float64, 0, 10, 200) x_obs = B.linspace(tf.float64, 0, 10, 10) # Construct the model. prior = Measure() f = 0.7 * GP(EQ(), measure=prior).stretch(1.5) e = 0.2 * GP(Delta(), measure=prior) # Construct derivatives. df = f.diff() ddf = df.diff() dddf = ddf.diff() + e # Fix the integration constants. zero = B.cast(tf.float64, 0) one = B.cast(tf.float64, 1) prior = prior | ((f(zero), one), (df(zero), zero), (ddf(zero), -one)) # Sample observations. y_obs = B.sin(x_obs) + 0.2 * B.randn(*x_obs.shape) # Condition on the observations to make predictions. post = prior | (dddf(x_obs), y_obs)