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()
# 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):
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,
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
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
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
def rnn(x):
return f_rnn(x[:, :, None])[:, :, 0]
# Construct session.
s = tf.Session()
# Construct points which to predict at.
x = np.linspace(0, 1, 100, dtype=np.float32)
inds_obs = np.arange(0, int(0.75 * len(x))) # Train on the first 75% only.
x_obs = x[inds_obs]
# 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())
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)