noise = 0.1 t = B.linspace(-44, 44, n) t_plot = B.linspace(44, 44, 500) # Setup true model and GPCM models. kernel = EQ() window = 2 scale = 1 n_u = 40 n_z = 88 # Sample data. m = Measure() gp_f = GP(kernel, measure=m) gp_y = gp_f + GP(noise * Delta(), measure=m) truth, y = map(B.flatten, m.sample(gp_f(t_plot), gp_y(t))) # Remove region [-8.8, 8.8]. inds = ~((t >= -8.8) & (t <= 8.8)) t = t[inds] y = y[inds] def comparative_kernel(vs_): return vs_.pos(1) * kernel.stretch(vs_.pos(1.0)) + vs_.pos(noise) * Delta() run( args=args, wd=wd, noise=noise,
e_exp = GP(Exp(), measure=prior) e = e_indep + 0.3 * e_exp # Sum the latent function and observation noise to get a model for the observations. y = f + 0.5 * e # Sample a true, underlying function and observations. ( f_true_smooth, f_true_wiggly, f_true_periodic, f_true_linear, f_true, y_obs, ) = prior.sample(f_smooth(x), f_wiggly(x), f_periodic(x), f_linear(x), f(x), y(x_obs)) # Now condition on the observations and make predictions for the latent function and # its various components. post = prior | (y(x_obs), y_obs) pred_smooth = post(f_smooth(x)).marginals() pred_wiggly = post(f_wiggly(x)).marginals() pred_periodic = post(f_periodic(x)).marginals() pred_linear = post(f_linear(x)).marginals() pred_f = post(f(x)).marginals() # Plot results. def plot_prediction(x, f, pred, x_obs=None, y_obs=None): plt.plot(x, f, label="True", style="test")
# Define points to predict at. x = B.linspace(0, 10, 100) x_obs = B.linspace(0, 10, 20) # Constuct a prior: prior = Measure() w = lambda x: B.exp(-(x**2) / 0.5) # Window b = [(w * GP(EQ(), measure=prior)).shift(xi) for xi in x_obs] # Weighted basis funs f = sum(b) # Latent function e = GP(Delta(), measure=prior) # Noise y = f + 0.2 * e # Observation model # Sample a true, underlying function and observations. f_true, y_obs = prior.sample(f(x), y(x_obs)) # Condition on the observations to make predictions. post = prior | (y(x_obs), y_obs) # Plot result. for i, bi in enumerate(b): mean, lower, upper = post(bi(x)).marginals() kw_args = {"label": "Basis functions"} if i == 0 else {} plt.plot(x, mean, style="pred2", **kw_args) plt.plot(x, f_true, label="True", style="test") plt.scatter(x_obs, y_obs, label="Observations", style="train", s=20) mean, lower, upper = post(f(x)).marginals() plt.plot(x, mean, label="Prediction", style="pred") plt.fill_between(x, lower, upper, style="pred") tweak()
p = 4 H = B.randn(p, m) # Construct latent functions. prior = Measure() us = VGP([GP(EQ(), measure=prior) for _ in range(m)]) fs = us.lmatmul(H) # Construct noise. e = VGP([GP(0.5 * Delta(), measure=prior) for _ in range(p)]) # Construct observation model. ys = e + fs # Sample a true, underlying function and observations. samples = prior.sample(*(p(x) for p in fs.ps), *(p(x_obs) for p in ys.ps)) fs_true, ys_obs = samples[:p], samples[p:] # Compute the posterior and make predictions. post = prior | (*((p(x_obs), y_obs) for p, y_obs in zip(ys.ps, ys_obs)), ) preds = [post(p(x)).marginals() for p in fs.ps] # Plot results. def plot_prediction(x, f, pred, x_obs=None, y_obs=None): plt.plot(x, f, label="True", style="test") if x_obs is not None: plt.scatter(x_obs, y_obs, label="Observations", style="train", s=20) mean, lower, upper = pred plt.plot(x, mean, label="Prediction", style="pred") plt.fill_between(x, lower, upper, style="pred")
from stheno import B, Measure, GP, EQ # Define points to predict at. x = B.linspace(0, 10, 100) # Construct a prior. prior = Measure() f1 = GP(3, EQ(), measure=prior) f2 = GP(3, EQ(), measure=prior) # Compute the approximate product. f_prod = f1 * f2 # Sample two functions. s1, s2 = prior.sample(f1(x), f2(x)) # Predict. post = prior | ((f1(x), s1), (f2(x), s2)) mean, lower, upper = post(f_prod(x)).marginals() # Plot result. plt.plot(x, s1, label="Sample 1", style="train") plt.plot(x, s2, label="Sample 2", style="train", ls="--") plt.plot(x, s1 * s2, label="True product", style="test") plt.plot(x, mean, label="Approximate posterior", style="pred") plt.fill_between(x, lower, upper, style="pred") tweak() plt.savefig("readme_example9_product.png") plt.show()
# Define points to predict at. x = B.linspace(0, 10, 200) x_obs = B.linspace(0, 10, 10) # Construct the model. prior = Measure() slope = GP(1, measure=prior) intercept = GP(5, measure=prior) f = slope * (lambda x: x) + intercept e = 0.2 * GP(Delta(), measure=prior) # Noise model y = f + e # Observation model # Sample a slope, intercept, underlying function, and observations. true_slope, true_intercept, f_true, y_obs = prior.sample( slope(0), intercept(0), f(x), y(x_obs)) # Condition on the observations to make predictions. post = prior | (y(x_obs), y_obs) mean, lower, upper = post(f(x)).marginals() out.kv("True slope", true_slope[0, 0]) out.kv("Predicted slope", post(slope(0)).mean[0, 0]) out.kv("True intercept", true_intercept[0, 0]) out.kv("Predicted intercept", post(intercept(0)).mean[0, 0]) # Plot result. plt.plot(x, f_true, label="True", style="test") plt.scatter(x_obs, y_obs, label="Observations", style="train", s=20) plt.plot(x, mean, label="Prediction", style="pred") plt.fill_between(x, lower, upper, style="pred")