Gaussian Process

Shipping

gaussian_process

Non-parametric Bayesian fit that produces a calibrated posterior mean and ±σ confidence band

Signature

Inputs

signalSignalrequired— Training data: timestamps are x, values are y (≥ 2 samples). Per-sample σ² is honoured as heteroscedastic observation noise.
querySignal— OPTIONAL prediction grid x* (its timestamps are used; values/unit ignored). Unfed ⟹ a dense uniform grid over the training range.

Outputs

meanSignal— Posterior mean over x*, CARRYING the predictive variance as its per-sample σ² — this is the confidence band the plot renders as ±kσ.
stdSignal— Posterior standard deviation $\sqrt{\sigma^2(x^*)}$ (y-unit).
log_likelihoodScalar— Log marginal likelihood (model-fit quality; higher is better). Dimensionless.
hyperparamsDataFrame— One-row table of the hyperparameters actually used (length_scale, signal/noise variance, α, period), the log marginal likelihood, and the training-point count.

Parameters

Key	Type	Default	Notes
`kernel`	enum	rbf	one of: rbf, matern32, matern52, rational_quadratic, periodic
`optimize`	enum	mle	one of: mle, manual
`length_scale`	float	1.0x-units	ℓ — how far in x the function stays correlated. Small = wiggly, large = smooth. Active only when optimize = manual.
`signal_variance`	float	1.0	σf² — the prior amplitude² (vertical scale of the function). Active only when optimize = manual.
`noise_variance`	float	0.000001	σn² — observation-noise variance added to the kernel diagonal. Larger = smoother, trusts data less. Per-sample input σ² is added on top. Active when optimize = manual.
`alpha`	float	1.0	Rational-Quadratic shape α: small α mixes many length-scales (heavy-tailed), large α → RBF. Shown for the rational_quadratic kernel; never auto-optimized.
`period`	float	1.0x-units	Periodic-kernel period p (repeat interval). Shown for the periodic kernel; always user-set (its likelihood is multimodal).
`n_predict`	int	300	Number of points in the generated prediction grid when no query input is wired.
`extrapolation`	float	0.0	Extend the prediction grid beyond the training range by this fraction of the span on each side (0 = stay within the data).
`include_observation_noise`	bool	false	OFF = band is the uncertainty of the smooth fitted curve (latent function). ON = the wider predictive interval for a NEW noisy observation (adds σn²).
`max_train_points`	int	600	Cap on training points the GP factorizes (cost is O(n³)); larger inputs are subsampled by uniform stride.
`max_iterations`	int	60	Hyperparameter-optimizer iteration budget per restart (active when optimize = mle).

Description

Gaussian Process performs non-parametric Gaussian Process Regression — a Bayesian fit that, unlike a parametric curve fit, returns not just a smooth mean but a calibrated predictive uncertainty band that widens where data is sparse or extrapolated. The training signal's timestamps are $x$ , its values $y$ , and its per-sample variances (if any) are honoured as heteroscedastic observation noise.

Five kernels shape the prior over functions: RBF (infinitely smooth), Matérn 3/2 and 5/2 (rougher, often more realistic for physical signals), Rational-Quadratic (a mixture of length-scales, tuned by $α$ ), and Periodic (repeats with period $p$ ). With optimize = mle the node learns the length-scale, signal variance, and noise variance by maximizing the log marginal likelihood; manual uses the values you set.

Prediction happens on an optional query grid, or — when unfed — a dense uniform grid over the training range, optionally extrapolated by a fraction of the span on each side (watch the band widen as the GP leaves the data). Crucially, the mean output carries the posterior variance as its own $\sigma^2$: this is the one node that legitimately produces a fresh uncertainty array, flowing straight into the plot's ±kσ band renderer. Toggle include_observation_noise to switch the band between the smooth latent function ( $σ_{f}$ only) and the predictive interval for a new observation ( $+ σ_{n}^{2}$ ).

The hyperparams table reports the values actually used (learned, when optimizing) plus the log marginal likelihood and training-point count. A GP costs $O (n^{3})$ in the number of training points, so max_train_points caps it by uniform-stride subsampling; the query grid is cheap. The node is stateless.

Mathematics

f \sim G P (0, k (x, x^{'})), k_{RBF} (x, x^{'}) = σ_{f}^{2} exp (- \frac{( x - x ^{'} ) ^{2}}{2 ℓ ^{2}})

μ_{*} = K_{*} (K + σ_{n}^{2} I)^{- 1} y, Σ_{*} = K_{**} - K_{*} (K + σ_{n}^{2} I)^{- 1} K_{*}^{⊤}

lo g p (y ∣ X) = - \frac{1}{2} y^{⊤} (K + σ_{n}^{2} I)^{- 1} y - \frac{1}{2} lo g ∣ K + σ_{n}^{2} I ∣ - \frac{n}{2} lo g 2 π

Examples

Smoothing a noisy sine with a band

Feed a noisy $sin (0.5 x)$ with kernel = rbf, optimize = mle, n_predict = 40. The mean output is the smooth posterior over 40 grid points, carrying a per-point $σ^{2}$ ; std is its square root. Wire mean into a plot to see the fit with a ±σ uncertainty band, and read the learned $ℓ$ , $σ_{f}^{2}$ , $σ_{n}^{2}$ from hyperparams.

Extrapolation widens the band

With extrapolation = 0.5 on training range $[0, 9]$ , the prediction grid spans $[- 4.5, 13.5]$ . The band stays tight inside the data and flares out beyond it — a visual honesty about how little the model knows where it hasn't seen data.

Custom query grid

Wire a query Signal at $x^{*} = {5, 1, 3}$ ; the node predicts at exactly those points (sorted ascending), overriding the generated grid.

Applications

Uncertainty-aware smoothing/interpolation of noisy sensor data with an honest confidence band.
Bayesian optimization surrogates and active learning where the predictive σ drives acquisition.
Modelling periodic or multi-scale signals via the periodic and rational-quadratic kernels.
Heteroscedastic fitting where per-sample measurement noise varies across the record.

Neat

The mean output is the rare node that PRODUCES a fresh uncertainty array — its per-sample σ² is the GP posterior variance, entering the DAG as its own independent uncertainty source (the 'produces' σ-class).

Auto-optimization maximizes the log marginal likelihood — a principled, built-in model-selection objective — to learn ℓ, σf², σn² without manual tuning.

include_observation_noise cleanly separates the two questions a GP answers: the uncertainty of the smooth latent function vs the predictive interval of a brand-new noisy observation.

Lineage is intentionally left empty so the executor re-keys the GP's predictive σ as a fresh provenance source downstream — a non-diagonal transform can't propagate input-σ element-wise, and this is the correct handling.

Known issues

Cost is O(n³) in training points; inputs above max_train_points are subsampled by uniform stride, which can miss fine structure.

The α (rational-quadratic) and period (periodic) hyperparameters are never auto-optimized — set them manually.

Extreme extrapolation reverts the mean toward the prior (zero) with a very wide band; the model states its ignorance rather than guessing.