Model syntax
Build a regression with several predictors, shared group effects and reusable components from one @brm declaration. The examples use named tuples; a data frame works too. Columns may have different lengths when they describe different observation or group axes.
Formulas and links
This model predicts both the mean and the standard deviation. The subject's intercept and slope are correlated, and the scale stays positive through its explicit log link.
Mean and scale regression
panes: brm|stanblocks|rkppl|stan|jax:3using BayesianRegressionModels
builder = @brm begin
mu ~ 1 + x + (1 + x | person | subject)
log(sigma) ~ 1 + x
y ~ Normal(mu, sigma)
effect(mu, :) ~ Normal(0, 1)
effect(sigma, Intercept) ~ Normal(-1, 0.5)
effect(sigma, x) ~ Normal(0, 0.2)
sd(:, person) ~ Exponential(0.5)
cor(:, person) ~ LKJCholesky(2, 2)
end
data = (; subject=["a", "a", "b", "b", "c", "c"],
x=[-1., 1., -1., 1., -1., 1.],
y=[-0.6, 0.9, -0.2, 1.4, -0.8, 0.5])
model = builder(data)SBBRMI with data keys = [:b_person_subject_lkj_eta, :col_idx_mu_person_subject, :n_subject, :n_terms_person_subject, :subject_idx, :x, :y]
configured submodels:
ranef_correlated_draws_generic_configured_1 = Base.merge(BayesianRegressionModels.ranef_correlated_draws_generic, quote
tau ~ (StanBlocks.builtin.restricted)(exponential, 1.0 ./ 0.5; n = n_terms, lower = 0.0)
end)
emitted @slic body:
begin
b_person_subject ~ ranef_correlated_draws_generic_configured_1(; group_idx = subject_idx, n_groups = n_subject, n_terms = n_terms_person_subject, lkj_eta = b_person_subject_lkj_eta)
X_mu = hcat(rep_vector(1.0, num_elements(x)), x)
pop_mu ~ _popefs_normal(; X = X_mu, beta_loc = [0, 0], beta_scale = [1, 1])
Z_mu_person_subject = hcat(rep_vector(1.0, num_elements(x)), x)
r_mu_person_subject = rows_dot_product(Z_mu_person_subject, b_person_subject[subject_idx, col_idx_mu_person_subject])
mu = pop_mu + r_mu_person_subject
X_log_sigma = hcat(rep_vector(1.0, num_elements(x)), x)
pop_log_sigma ~ _popefs_normal(; X = X_log_sigma, beta_loc = [-1, 0], beta_scale = [0.5, 0.2])
log_sigma = pop_log_sigma
sigma = exp(log_sigma)
y ~ normal(mu, sigma)
end"""
Group-level (varying) effects of grouping `g`, `K` correlated margins per level.
Non-centered, from the scales `tau[1:K]` (drawn from their priors), the Cholesky factor of the margins' correlation `L ~ LKJCholesky(K, eta)` and standardized effects
`z[1:length(levels(g)), 1:K] ~ Normal(0, 1)`. Returns the
level-by-margin matrix `z * transpose(tau .* L)`, one row per level of `g` in order.
"""
brm_correlated_group_effects(g, K, eta) = begin
tau[1:K] .~ Exponential.(0.5)
L ~ LKJCholesky(K, eta)
z[1:length(levels(g)), 1:K] .~ Normal.(0, 1)
return z * transpose(tau .* L)
end
"""
Population-level effects: one coefficient per column of the design matrix `X`.
Draws `beta_pop[1:ncoef] ~ Normal(loc, scale)` and returns the linear predictor
`X * beta_pop`. `ncoef` is the number of columns of `X`. Each prior argument (`loc`, `scale`) is one value for all coefficients or a vector with one per coefficient.
"""
brm_population_effects(X, ncoef, loc, scale) = begin
beta_pop[1:ncoef] .~ Normal.(loc, scale)
return X * beta_pop
end
begin
subject_fit_levels = brm_fit_levels(subject_fit)
b_person_subject ~ brm_correlated_group_effects(subject_fit_levels, 2, bucket_person_subject_lkj_eta)
subject_level = brm_level_indices(subject, subject_fit_levels)
ranef_mu_person_subject = b_person_subject[subject_level, 1] .+ b_person_subject[subject_level, 2] .* x
X_mu = hcat(ones(length(subject)), x)
pop_mu ~ brm_population_effects(X_mu, 2, 0.0, 1.0)
mu = pop_mu .+ ranef_mu_person_subject
X_log_sigma = hcat(ones(length(x)), x)
pop_log_sigma ~ brm_population_effects(X_log_sigma, 2, [-1.0, 0.0], [0.5, 0.2])
log_sigma = pop_log_sigma
sigma = exp.(log_sigma)
y .~ Normal.(mu, exp.(log_sigma))
endfunctions {
matrix hcat(
vector x,
vector y
) {
int n = dims(x)[1];
if (dims(y)[1] != n) reject("hcat: dim mismatch — `y` dim 1 (= ", dims(y)[1], ") does not match `n` (= ", n, "), inferred from `x` dim 1. `n` sizes: `x` dim 1 (= ", dims(x)[1], "), `y` dim 1 (= ", dims(y)[1], ").");
return append_col(x, y);
}
vector normal_lpdfs(
vector obs,
vector loc,
vector scale
) {
return jbroadcasted_normal_lpdfs(obs, loc, scale);
}
vector jbroadcasted_normal_lpdfs(
vector x1,
vector x2,
vector x3
) {
int n = dims(x1)[1];
vector[n] rv;
for(i in 1:n) {
rv[i] = normal_lpdfs(broadcasted_getindex(x1, i), broadcasted_getindex(x2, i), broadcasted_getindex(x3, i));
}
return rv;
}
real normal_lpdfs(
real args1,
real args2,
real args3
) {
return normal_lpdf(args1 | args2, args3);
}
real broadcasted_getindex(vector x, int i) {
return x[i];
}
vector normal_vector_rng(
int anontok__1,
vector a,
vector b
) {
int n = anontok__1;
if((n == 0)) {
vector[n] rv;
return rv;
} else {
return to_vector(normal_rng(a, b));
}
}
}
data {
int n_terms_person_subject;
real b_person_subject_lkj_eta;
int n_subject;
int x_n;
vector[x_n] x;
int subject_idx_n;
int col_idx_mu_person_subject_n;
array[subject_idx_n] int subject_idx;
array[col_idx_mu_person_subject_n] int col_idx_mu_person_subject;
int y_n;
vector[y_n] y;
}
transformed data {
matrix[x_n, 2] X_mu = hcat(rep_vector(1.0, num_elements(x)), x);
int pop_mu_n_covariates = 2;
matrix[x_n, 2] Z_mu_person_subject = hcat(rep_vector(1.0, num_elements(x)), x);
matrix[x_n, 2] X_log_sigma = hcat(rep_vector(1.0, num_elements(x)), x);
int pop_log_sigma_n_covariates = 2;
}
parameters {
cholesky_factor_corr[n_terms_person_subject] b_person_subject_L;
vector<lower=0.0>[n_terms_person_subject] b_person_subject_tau;
vector[(n_terms_person_subject * n_subject)] b_person_subject_z_flat;
vector[pop_mu_n_covariates] pop_mu_beta_pop;
vector[pop_log_sigma_n_covariates] pop_log_sigma_beta_pop;
}
transformed parameters {
matrix[n_terms_person_subject, n_subject] b_person_subject_z = to_matrix(b_person_subject_z_flat, n_terms_person_subject, n_subject);
matrix[n_subject, n_terms_person_subject] b_person_subject = ((diag_pre_multiply(b_person_subject_tau, b_person_subject_L) * b_person_subject_z)');
vector[x_n] pop_mu = (X_mu * pop_mu_beta_pop);
vector[subject_idx_n] r_mu_person_subject = rows_dot_product(Z_mu_person_subject, b_person_subject[subject_idx, col_idx_mu_person_subject]);
vector[x_n] mu = (pop_mu + r_mu_person_subject);
vector[x_n] pop_log_sigma = (X_log_sigma * pop_log_sigma_beta_pop);
vector[x_n] log_sigma = pop_log_sigma;
vector[x_n] sigma = exp(log_sigma);
}
model {
b_person_subject_L ~ lkj_corr_cholesky(b_person_subject_lkj_eta);
b_person_subject_tau ~ exponential((1.0 ./ 0.5));
b_person_subject_z_flat ~ std_normal();
pop_mu_beta_pop ~ normal([0, 0]', [1, 1]');
pop_log_sigma_beta_pop ~ normal([-1, 0]', [0.5, 0.2]');
y ~ normal(mu, sigma);
}
generated quantities {
vector[y_n] y_likelihood = normal_lpdfs(y, mu, sigma);
vector[y_n] y_gen = normal_vector_rng(y_n, mu, sigma);
}using ReactiveKernels, ReactiveKernelsPPL
rk = RKBRMI(model)
source = jax_source(rk.model, rk_bound_plan(rk))
write("model.py", source)
inputs = rk_bound_data(rk, source) # exactly the inputs prepare_data readsimport jax
import model as m
prepared = m.prepare_data(**inputs)
lp = m.log_density(u, **prepared) # u: unconstrained, length m.dimension(prepared)
lp = jax.jit(m.log_density)(u, **prepared) # one compiled function for every dataset of these shapes"""Generated by ReactiveKernelsPPL.jax_source from a built @rkppl program; do not edit.
Data: X_log_sigma, bucket_person_subject_lkj_eta, subject, subject_fit, x, y.
Model documentation:
- `b_person_subject`: Group-level (varying) effects of grouping `g`, `K` correlated margins per level.
Non-centered, from the scales `tau[1:K]` (drawn from their priors), the Cholesky factor of the margins' correlation `L ~ LKJCholesky(K, eta)` and standardized effects
`z[1:length(levels(g)), 1:K] ~ Normal(0, 1)`. Returns the
level-by-margin matrix `z * transpose(tau .* L)`, one row per level of `g` in order.
- `pop_mu`: Population-level effects: one coefficient per column of the design matrix `X`.
Draws `beta_pop[1:ncoef] ~ Normal(loc, scale)` and returns the linear predictor
`X * beta_pop`. `ncoef` is the number of columns of `X`. Each prior argument (`loc`, `scale`) is one value for all coefficients or a vector with one per coefficient.
- `pop_log_sigma`: Population-level effects: one coefficient per column of the design matrix `X`.
Draws `beta_pop[1:ncoef] ~ Normal(loc, scale)` and returns the linear predictor
`X * beta_pop`. `ncoef` is the number of columns of `X`. Each prior argument (`loc`, `scale`) is one value for all coefficients or a vector with one per coefficient.
"""
import numpy as np
import scipy.special as ssp
from typing import Any
import jax
import jax.numpy as jnp
import jax.scipy.linalg
import jax.scipy.special as jsp
from jax.typing import ArrayLike
jax.config.update("jax_enable_x64", True)
DATA = {"X_log_sigma": {"dtype": "float64", "ndim": 2, "ragged": False}, "bucket_person_subject_lkj_eta": {"dtype": "float64", "ndim": 0, "ragged": False}, "subject": {"dtype": "object", "ndim": 1, "ragged": False}, "subject_fit": {"dtype": "object", "ndim": 1, "ragged": False}, "x": {"dtype": "float64", "ndim": 1, "ragged": False}, "y": {"dtype": "float64", "ndim": 1, "ragged": False}}
INPUTS = ("unconstrained", "ppl_last_b_person_subject_z", "ppl_axis1_b_person_subject_z", "ppl_first_pop_mu_beta_pop", "ppl_last_pop_mu_beta_pop", "ppl_first_pop_log_sigma_beta_pop", "ppl_last_pop_log_sigma_beta_pop", "subject_level", "x", "X_mu", "X_log_sigma", "y", "bucket_person_subject_lkj_eta", "ppl_prior_b_person_subject_L_normalizer")
PREPARED = {"ppl_last_b_person_subject_z": {"dtype": "int64", "ndim": 0, "ragged": False}, "ppl_axis1_b_person_subject_z": {"dtype": "int64", "ndim": 0, "ragged": False}, "ppl_first_pop_mu_beta_pop": {"dtype": "int64", "ndim": 0, "ragged": False}, "ppl_last_pop_mu_beta_pop": {"dtype": "int64", "ndim": 0, "ragged": False}, "ppl_first_pop_log_sigma_beta_pop": {"dtype": "int64", "ndim": 0, "ragged": False}, "ppl_last_pop_log_sigma_beta_pop": {"dtype": "int64", "ndim": 0, "ragged": False}, "subject_level": {"dtype": "int64", "ndim": 1, "ragged": False}, "x": {"dtype": "float64", "ndim": 1, "ragged": False}, "X_mu": {"dtype": "float64", "ndim": 2, "ragged": False}, "X_log_sigma": {"dtype": "float64", "ndim": 2, "ragged": False}, "y": {"dtype": "float64", "ndim": 1, "ragged": False}, "bucket_person_subject_lkj_eta": {"dtype": "float64", "ndim": 0, "ragged": False}, "ppl_prior_b_person_subject_L_normalizer": {"dtype": "float64", "ndim": 0, "ragged": False}}
UNTRANSLATED = {}
def _rk_order_key_np(x):
# Julia's isless order of an array as sortable keys: a float is an integer
# key, -0.0 before 0.0 and every NaN last, equal for values isequal treats
# as equal. Integer and string arrays are their own keys.
x = np.asarray(x)
if x.dtype.kind != "f":
return x
bits = np.where(np.isnan(x), np.nan, x).astype(np.float64).view(np.int64)
return np.where(bits < 0, bits ^ np.int64(0x7FFFFFFFFFFFFFFF), bits)
def _rk_unique_np(x):
# Julia's unique of a vector: the first value of each isequal class, in
# order.
x = np.asarray(x)
_, first = np.unique(_rk_order_key_np(x), return_index=True)
return x[np.sort(first)]
def _rk_sort_np(x):
# Julia's sort of a vector: ascending in isless order, equal values in
# their order.
x = np.asarray(x)
return x[np.argsort(_rk_order_key_np(x), kind="stable")]
def _brm_sorted_labels_np(source):
labels = _rk_unique_np(source)
sorted_ = _rk_sort_np(labels)
return sorted_
def _brm_fit_levels_np(source):
value = _brm_sorted_labels_np(source)
levels = value
return levels
def _rk_dict_key(x):
if isinstance(x, tuple):
return (1, tuple(map(_rk_dict_key, x)))
if isinstance(x, np.ndarray):
return (2, x.shape, tuple(map(_rk_dict_key, x.ravel(order="F"))))
if isinstance(x, (complex, np.complexfloating)):
if x.imag == 0 and not np.signbit(x.imag):
return _rk_dict_key(x.real)
return (3, _rk_dict_key(x.real), _rk_dict_key(x.imag))
if isinstance(x, (float, np.floating)):
if np.isnan(x):
return (4,)
if x == 0 and np.signbit(x):
return (5,)
return (0, x)
class _RKDict:
def __init__(self, pairs=()):
self.data = {}
for key, value in pairs:
self[key] = value
def __len__(self):
return len(self.data)
def __contains__(self, key):
return _rk_dict_key(key) in self.data
def __getitem__(self, key):
return self.data[_rk_dict_key(key)][1]
def __setitem__(self, key, value):
self.data[_rk_dict_key(key)] = (key, value)
def get(self, key, default):
item = self.data.get(_rk_dict_key(key))
return default if item is None else item[1]
def setdefault(self, key, default):
return self.data.setdefault(_rk_dict_key(key), (key, default))[1]
def pop(self, key, default):
item = self.data.pop(_rk_dict_key(key), None)
return default if item is None else item[1]
def items(self):
return self.data.values()
def keys(self):
return (item[0] for item in self.items())
def values(self):
return (item[1] for item in self.items())
def copy(self):
return _RKDict(self.items())
def _brm_level_indices_np(labels, source):
value = _brm_fit_levels_np(source)
levels = value
lookup = _RKDict()
for k in range(1, len(levels) + 1):
lookup[levels[k - 1]] = k
indices = np.zeros((len(labels),), dtype=np.int64)
for r in range(1, len(labels) + 1):
position = lookup.get(labels[r - 1], 0)
if position == 0:
raise ValueError("".join([str("RK backend: group label `"), str(labels[r - 1]), str("` is not one of the "), str(len(levels)), str(" fitted levels. A replay keeps the fitted levels of every grouping it does not resample; name the grouping in `resample_groups` to take the new data's own levels.")]))
indices[r - 1] = position
return indices
def _rk_levels_np(x):
arr = np.asarray(x)
values = sorted(set(v for v in arr.tolist() if v is not None))
return np.array(values, dtype=object if arr.dtype == object else arr.dtype)
class StaticInt(int):
"""An integer of the prepared data that sets a shape.
It is an `int` everywhere, and `jax.jit` treats it as static, so the
functions jit with the prepared data as arguments; a new value traces
them again.
"""
def __repr__(self):
return "StaticInt(%d)" % int(self)
jax.tree_util.register_pytree_node(StaticInt, lambda s: ((), int(s)), lambda v, _: StaticInt(v))
def brm_population_effects(X: ArrayLike, beta_pop: ArrayLike, *, outputs: tuple[str, ...]) -> dict:
"""Population-level effects: one coefficient per column of the design matrix `X`.
Draws `beta_pop[1:ncoef] ~ Normal(loc, scale)` and returns the linear predictor
`X * beta_pop`. `ncoef` is the number of columns of `X`. Each prior argument (`loc`, `scale`) is one value for all coefficients or a vector with one per coefficient.
"""
results = {}
if any(name in outputs for name in ("value",)):
value = X @ beta_pop
if any(name in outputs for name in ("ppl_prior_beta_pop", "ppl_pw_prior_beta_pop")):
def ppl_pw_prior_beta_pop_cell(beta_pop_2):
log_scale = np.log(1.0)
standardized = (beta_pop_2 - 0.0) / jnp.where((beta_pop_2 == 0.0 if 1.0 == 0 else False), 1.0, 1.0)
standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
logpdf = standard_logpdf - jnp.where((beta_pop_2 != 0.0 if 1.0 == 0 else False), 0.0, log_scale)
return logpdf
ppl_pw_prior_beta_pop = (jnp.zeros(beta_pop.shape[:1], dtype=jnp.float64) if 0 in beta_pop.shape[:1] else jax.vmap(ppl_pw_prior_beta_pop_cell, in_axes=(0,))(beta_pop))
if any(name in outputs for name in ("ppl_prior_beta_pop",)):
ppl_prior_beta_pop = jnp.sum(ppl_pw_prior_beta_pop)
if "ppl_prior_beta_pop" in outputs:
results["ppl_prior_beta_pop"] = ppl_prior_beta_pop
if "ppl_pw_prior_beta_pop" in outputs:
results["ppl_pw_prior_beta_pop"] = ppl_pw_prior_beta_pop
if "value" in outputs:
results["value"] = value
return results
def brm_population_effects_2(
X: ArrayLike,
beta_pop: ArrayLike,
*,
outputs: tuple[str, ...],
) -> dict:
"""Population-level effects: one coefficient per column of the design matrix `X`.
Draws `beta_pop[1:ncoef] ~ Normal(loc, scale)` and returns the linear predictor
`X * beta_pop`. `ncoef` is the number of columns of `X`. Each prior argument (`loc`, `scale`) is one value for all coefficients or a vector with one per coefficient.
"""
results = {}
if any(name in outputs for name in ("value",)):
value = X @ beta_pop
if any(name in outputs for name in ("ppl_prior_beta_pop", "ppl_pw_prior_beta_pop")):
ppl_parg_beta_pop_1 = jnp.asarray([-1.0, 0.0], dtype=jnp.float64)
ppl_parg_beta_pop_2 = jnp.asarray([0.5, 0.2], dtype=jnp.float64)
def ppl_pw_prior_beta_pop_cell(beta_pop_2, location, scale):
log_scale = jnp.log(scale)
standardized = (beta_pop_2 - location) / jnp.where(jnp.logical_and(scale == 0, beta_pop_2 == location), 1.0, scale)
standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
logpdf = standard_logpdf - jnp.where(jnp.logical_and(scale == 0, beta_pop_2 != location), 0.0, log_scale)
return logpdf
ppl_pw_prior_beta_pop = (jnp.zeros(beta_pop.shape[:1], dtype=jnp.float64) if 0 in beta_pop.shape[:1] and ppl_parg_beta_pop_1.shape[:1] == beta_pop.shape[:1] and ppl_parg_beta_pop_2.shape[:1] == beta_pop.shape[:1] else jax.vmap(ppl_pw_prior_beta_pop_cell, in_axes=(0, 0, 0))(beta_pop, ppl_parg_beta_pop_1, ppl_parg_beta_pop_2))
if any(name in outputs for name in ("ppl_prior_beta_pop",)):
ppl_prior_beta_pop = jnp.sum(ppl_pw_prior_beta_pop)
if "ppl_prior_beta_pop" in outputs:
results["ppl_prior_beta_pop"] = ppl_prior_beta_pop
if "ppl_pw_prior_beta_pop" in outputs:
results["ppl_pw_prior_beta_pop"] = ppl_pw_prior_beta_pop
if "value" in outputs:
results["value"] = value
return results
def brm_correlated_group_effects_density(
ppl_last_z: ArrayLike,
ppl_prior_L_normalizer: ArrayLike,
eta: ArrayLike,
tau: ArrayLike,
unconstrained: ArrayLike,
*,
outputs: tuple[str, ...],
) -> dict:
"""Group-level (varying) effects of grouping `g`, `K` correlated margins per level.
Non-centered, from the scales `tau[1:K]` (drawn from their priors), the Cholesky factor of the margins' correlation `L ~ LKJCholesky(K, eta)` and standardized effects
`z[1:length(levels(g)), 1:K] ~ Normal(0, 1)`. Returns the
level-by-margin matrix `z * transpose(tau .* L)`, one row per level of `g` in order.
"""
results = {}
if any(name in outputs for name in ("ppl_lkj_diagonal_L", "ppl_lkj_partials_L", "ppl_lkj_raw_L", "ppl_prior_L", "ppl_prior_L_diagonal")):
ppl_lkj_raw_L = unconstrained[2:3]
if any(name in outputs for name in ("ppl_lkj_diagonal_L", "ppl_lkj_partials_L", "ppl_prior_L", "ppl_prior_L_diagonal")):
ppl_lkj_partials_L = jnp.tanh(ppl_lkj_raw_L)
if any(name in outputs for name in ("ppl_lkj_diagonal_L", "ppl_prior_L", "ppl_prior_L_diagonal")):
out = jnp.ones((2,), dtype=jnp.float64)
tuple_ = (1, 2, 1.0)
i = tuple_[0]
j = tuple_[1]
d = tuple_[2]
def loop_body(p, carry):
(d_2, i_2, j_2, out_2) = carry
d_3 = d_2 * jnp.sqrt(1 - ppl_lkj_partials_L[p - 1] ** 2)
def then_arm():
i_3 = i_2 + 1
return (None, jnp.asarray(d_3, dtype=jnp.float64), jnp.asarray(i_3, dtype=jnp.int64), jnp.asarray(j_2, dtype=jnp.int64), out_2)
def else_arm():
out_3 = out_2.at[j_2 - 1].set(d_3)
tuple__2 = (1, j_2 + 1, 1.0)
i_4 = tuple__2[0]
j_3 = tuple__2[1]
d_4 = tuple__2[2]
return (None, jnp.asarray(d_4, dtype=jnp.float64), jnp.asarray(i_4, dtype=jnp.int64), jnp.asarray(j_3, dtype=jnp.int64), out_3)
branch = jax.lax.cond(i_2 + 1 < j_2, then_arm, else_arm)
return (branch[1], branch[2], branch[3], branch[4])
loop_carry = jax.lax.fori_loop(1, 2, loop_body, (jnp.asarray(d, dtype=jnp.float64), jnp.asarray(i, dtype=jnp.int64), jnp.asarray(j, dtype=jnp.int64), out))
ppl_lkj_diagonal_L = loop_carry[3]
if any(name in outputs for name in ("ppl_arrflat_z", "ppl_prior_z", "ppl_pw_prior_z")):
ppl_arrflat_z = unconstrained[3:ppl_last_z]
if any(name in outputs for name in ("ppl_prior_tau", "ppl_pw_prior_tau")):
def ppl_pw_prior_tau_cell(tau_2):
log_scale = np.log(0.5)
logpdf = jax.lax.cond(tau_2 < 0, lambda: -jnp.inf, lambda: -log_scale - tau_2 / 0.5)
return logpdf
ppl_pw_prior_tau = (jnp.zeros(tau.shape[:1], dtype=jnp.float64) if 0 in tau.shape[:1] else jax.vmap(ppl_pw_prior_tau_cell, in_axes=(0,))(tau))
if any(name in outputs for name in ("ppl_prior_tau",)):
ppl_prior_tau = jnp.sum(ppl_pw_prior_tau)
if any(name in outputs for name in ("ppl_prior_L", "ppl_prior_L_diagonal")):
ppl_prior_L_diagonal = jax.lax.cond(jnp.logical_and(jnp.isfinite(eta), eta > 0), lambda: (2 * eta - 2) * jnp.log(ppl_lkj_diagonal_L[1]), lambda: 0.0)
if any(name in outputs for name in ("ppl_prior_L",)):
ppl_prior_L = ppl_prior_L_normalizer + ppl_prior_L_diagonal
if any(name in outputs for name in ("ppl_prior_z", "ppl_pw_prior_z")):
def ppl_pw_prior_z_cell(z):
log_scale = np.log(1.0)
standardized = (z - 0.0) / jnp.where((z == 0.0 if 1.0 == 0 else False), 1.0, 1.0)
standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
logpdf = standard_logpdf - jnp.where((z != 0.0 if 1.0 == 0 else False), 0.0, log_scale)
return logpdf
ppl_pw_prior_z = (jnp.zeros(ppl_arrflat_z.shape[:1], dtype=jnp.float64) if 0 in ppl_arrflat_z.shape[:1] else jax.vmap(ppl_pw_prior_z_cell, in_axes=(0,))(ppl_arrflat_z))
if any(name in outputs for name in ("ppl_prior_z",)):
ppl_prior_z = jnp.sum(ppl_pw_prior_z)
if "ppl_arrflat_z" in outputs:
results["ppl_arrflat_z"] = ppl_arrflat_z
if "ppl_lkj_diagonal_L" in outputs:
results["ppl_lkj_diagonal_L"] = ppl_lkj_diagonal_L
if "ppl_lkj_partials_L" in outputs:
results["ppl_lkj_partials_L"] = ppl_lkj_partials_L
if "ppl_lkj_raw_L" in outputs:
results["ppl_lkj_raw_L"] = ppl_lkj_raw_L
if "ppl_prior_L" in outputs:
results["ppl_prior_L"] = ppl_prior_L
if "ppl_prior_L_diagonal" in outputs:
results["ppl_prior_L_diagonal"] = ppl_prior_L_diagonal
if "ppl_prior_tau" in outputs:
results["ppl_prior_tau"] = ppl_prior_tau
if "ppl_prior_z" in outputs:
results["ppl_prior_z"] = ppl_prior_z
if "ppl_pw_prior_tau" in outputs:
results["ppl_pw_prior_tau"] = ppl_pw_prior_tau
if "ppl_pw_prior_z" in outputs:
results["ppl_pw_prior_z"] = ppl_pw_prior_z
return results
def _ppl_lkj_lower(z: ArrayLike, diagonal: ArrayLike, K: ArrayLike, P: ArrayLike) -> jax.Array:
"""Compute `_ppl_lkj_lower` from its authored source."""
out = jnp.zeros((K, K), dtype=jnp.float64)
out_2 = out.at[0, 0].set(1.0)
tuple_ = (1, 2, 1.0)
i = tuple_[0]
j = tuple_[1]
w = tuple_[2]
def loop_body(p, carry):
(i_2, j_2, out_3, w_2) = carry
out_4 = out_3.at[j_2 - 1, i_2 - 1].set(z[p - 1] * w_2)
w_3 = w_2 * jnp.sqrt(1 - z[p - 1] ** 2)
def then_arm():
i_3 = i_2 + 1
return (None, jnp.asarray(i_3, dtype=jnp.int64), jnp.asarray(j_2, dtype=jnp.int64), out_4, jnp.asarray(w_3, dtype=jnp.float64))
def else_arm():
out_5 = out_4.at[j_2 - 1, j_2 - 1].set(diagonal[j_2 - 1])
tuple__2 = (1, j_2 + 1, 1.0)
i_4 = tuple__2[0]
j_3 = tuple__2[1]
w_4 = tuple__2[2]
return (None, jnp.asarray(i_4, dtype=jnp.int64), jnp.asarray(j_3, dtype=jnp.int64), out_5, jnp.asarray(w_4, dtype=jnp.float64))
branch = jax.lax.cond(i_2 + 1 < j_2, then_arm, else_arm)
return (branch[1], branch[2], branch[3], branch[4])
carry_init = (jnp.asarray(i, dtype=jnp.int64), jnp.asarray(j, dtype=jnp.int64), out_2, jnp.asarray(w, dtype=jnp.float64))
loop_carry = jax.lax.fori_loop(1, P + 1, loop_body, carry_init) if 1 <= P else carry_init
return loop_carry[2]
def brm_correlated_group_effects(
L: ArrayLike,
tau: ArrayLike,
z: ArrayLike,
*,
outputs: tuple[str, ...],
) -> dict:
"""Group-level (varying) effects of grouping `g`, `K` correlated margins per level.
Non-centered, from the scales `tau[1:K]` (drawn from their priors), the Cholesky factor of the margins' correlation `L ~ LKJCholesky(K, eta)` and standardized effects
`z[1:length(levels(g)), 1:K] ~ Normal(0, 1)`. Returns the
level-by-margin matrix `z * transpose(tau .* L)`, one row per level of `g` in order.
"""
results = {}
if any(name in outputs for name in ("value",)):
value = z @ jnp.transpose(tau[..., None] * L)
if "value" in outputs:
results["value"] = value
return results
def prepare_data(X_log_sigma: ArrayLike, bucket_person_subject_lkj_eta: ArrayLike, subject: Any, subject_fit: Any, x: ArrayLike, y: ArrayLike) -> dict:
"""The functions' data inputs, computed from the raw data once per dataset.
Pass the data by the names the model reads them; a list of arrays is a ragged
column. Call the other functions with the result: `f(u, **prepared)`.
"""
X_log_sigma = np.asarray(X_log_sigma, dtype=np.float64)
subject = np.asarray(subject, dtype=object)
subject_fit = np.asarray(subject_fit, dtype=object)
x = np.asarray(x, dtype=np.float64)
y = np.asarray(y, dtype=np.float64)
X_mu = np.asarray(np.concatenate([np.ones((len(subject),), dtype=np.float64)[:, None], x[:, None]], axis=1), dtype=np.float64)
rkppl_value_bucket_person_subject_lkj_eta = bucket_person_subject_lkj_eta
value = _brm_fit_levels_np(subject_fit)
subject_fit_levels = value
value_2 = _brm_level_indices_np(subject, subject_fit_levels)
subject_level = np.asarray(value_2, dtype=np.int64)
ppl_axis1_b_person_subject_z = len(_rk_levels_np(subject_fit_levels))
ppl_last_b_person_subject_z = 3 + 2 * ppl_axis1_b_person_subject_z
ppl_first_pop_mu_beta_pop = ppl_last_b_person_subject_z + 1
ppl_last_pop_mu_beta_pop = ppl_first_pop_mu_beta_pop + 1
ppl_first_pop_log_sigma_beta_pop = ppl_last_pop_mu_beta_pop + 1
ppl_last_pop_log_sigma_beta_pop = ppl_first_pop_log_sigma_beta_pop + 1
if np.isfinite(bucket_person_subject_lkj_eta) and bucket_person_subject_lkj_eta > 0:
value_4 = ssp.gammaln(bucket_person_subject_lkj_eta + 0.5)
total = 1 * value_4
for k in range(1, 2):
value_5 = ssp.gammaln(bucket_person_subject_lkj_eta + 0.5 * (1 - k))
total = total - 0.5 * k * 1.1447298858494002 - value_5
value_3 = total
else:
value_3 = -np.inf
ppl_prior_b_person_subject_L_normalizer = value_3
return {"ppl_last_b_person_subject_z": StaticInt(ppl_last_b_person_subject_z), "ppl_axis1_b_person_subject_z": StaticInt(ppl_axis1_b_person_subject_z), "ppl_first_pop_mu_beta_pop": StaticInt(ppl_first_pop_mu_beta_pop), "ppl_last_pop_mu_beta_pop": StaticInt(ppl_last_pop_mu_beta_pop), "ppl_first_pop_log_sigma_beta_pop": StaticInt(ppl_first_pop_log_sigma_beta_pop), "ppl_last_pop_log_sigma_beta_pop": StaticInt(ppl_last_pop_log_sigma_beta_pop), "subject_level": np.asarray(subject_level, dtype=np.int64), "x": np.asarray(x, dtype=np.float64), "X_mu": np.asarray(X_mu, dtype=np.float64), "X_log_sigma": np.asarray(X_log_sigma, dtype=np.float64), "y": np.asarray(y, dtype=np.float64), "bucket_person_subject_lkj_eta": bucket_person_subject_lkj_eta, "ppl_prior_b_person_subject_L_normalizer": ppl_prior_b_person_subject_L_normalizer}
def model(_entry: str, unconstrained: ArrayLike, **prepared: ArrayLike) -> Any:
"""Shared model computation. The generated entry wrappers select a static output."""
ppl_last_b_person_subject_z = prepared["ppl_last_b_person_subject_z"]
ppl_axis1_b_person_subject_z = prepared["ppl_axis1_b_person_subject_z"]
ppl_first_pop_mu_beta_pop = prepared["ppl_first_pop_mu_beta_pop"]
ppl_last_pop_mu_beta_pop = prepared["ppl_last_pop_mu_beta_pop"]
ppl_first_pop_log_sigma_beta_pop = prepared["ppl_first_pop_log_sigma_beta_pop"]
ppl_last_pop_log_sigma_beta_pop = prepared["ppl_last_pop_log_sigma_beta_pop"]
subject_level = prepared["subject_level"]
x = prepared["x"]
X_mu = prepared["X_mu"]
X_log_sigma = prepared["X_log_sigma"]
y = prepared["y"]
bucket_person_subject_lkj_eta = prepared["bucket_person_subject_lkj_eta"]
ppl_prior_b_person_subject_L_normalizer = prepared["ppl_prior_b_person_subject_L_normalizer"]
unconstrained = jnp.asarray(unconstrained)
subject_level = jnp.asarray(subject_level)
x = jnp.asarray(x)
X_mu = jnp.asarray(X_mu)
X_log_sigma = jnp.asarray(X_log_sigma)
y = jnp.asarray(y)
if _entry in ("log_density", "log_prior", "log_likelihood", "constrain"):
prefix_stop = 2
if not (prefix_stop <= unconstrained.size):
raise ValueError("BoundsError: prefix exceeds array length")
plate_argument = unconstrained[:max(prefix_stop, 0)]
def b_person_subject_tau_cell(ppl_cell_b_person_subject_tau):
constrain_2 = jnp.exp(ppl_cell_b_person_subject_tau)
return constrain_2
b_person_subject_tau = (jnp.zeros(plate_argument.shape[:1], dtype=jnp.float64) if 0 in plate_argument.shape[:1] else jax.vmap(b_person_subject_tau_cell, in_axes=(0,))(plate_argument))
if _entry in ("log_density", "log_jacobian"):
prefix_stop_2 = 2
if not (prefix_stop_2 <= unconstrained.size):
raise ValueError("BoundsError: prefix exceeds array length")
plate_argument_2 = unconstrained[:max(prefix_stop_2, 0)]
def ppl_ljcells_b_person_subject_tau_cell(ppl_cell_b_person_subject_tau):
return ppl_cell_b_person_subject_tau
ppl_ljcells_b_person_subject_tau = (jnp.zeros(plate_argument_2.shape[:1], dtype=jnp.float64) if 0 in plate_argument_2.shape[:1] else jax.vmap(ppl_ljcells_b_person_subject_tau_cell, in_axes=(0,))(plate_argument_2))
if _entry in ("log_density", "log_prior", "log_likelihood", "constrain"):
pop_mu_beta_pop = unconstrained[ppl_first_pop_mu_beta_pop - 1:ppl_last_pop_mu_beta_pop]
if _entry in ("log_density", "log_prior", "log_likelihood"):
pop_mu = brm_population_effects(
X=(X_mu if _entry in ("log_density", "log_likelihood") else None),
beta_pop=(pop_mu_beta_pop if _entry in ("log_density", "log_prior", "log_likelihood") else None),
outputs=tuple(
name for name, needed in (
("ppl_prior_beta_pop", ("log_density", "log_prior")),
("ppl_pw_prior_beta_pop", ("log_density", "log_prior")),
("value", ("log_density", "log_likelihood")),
)
if _entry in needed
),
)
if _entry in ("log_density", "log_prior", "log_likelihood", "constrain"):
pop_log_sigma_beta_pop = unconstrained[ppl_first_pop_log_sigma_beta_pop - 1:ppl_last_pop_log_sigma_beta_pop]
if _entry in ("log_density", "log_prior", "log_likelihood"):
pop_log_sigma = brm_population_effects_2(
X=(X_log_sigma if _entry in ("log_density", "log_likelihood") else None),
beta_pop=(pop_log_sigma_beta_pop if _entry in ("log_density", "log_prior", "log_likelihood") else None),
outputs=tuple(
name for name, needed in (
("ppl_prior_beta_pop", ("log_density", "log_prior")),
("ppl_pw_prior_beta_pop", ("log_density", "log_prior")),
("value", ("log_density", "log_likelihood")),
)
if _entry in needed
),
)
if _entry in ("log_density", "log_likelihood"):
rkppl_synth_1 = jnp.exp(pop_log_sigma["value"])
if _entry in ("log_density", "log_jacobian"):
plate_fold = jnp.sum(ppl_ljcells_b_person_subject_tau)
b_person_subject = brm_correlated_group_effects_density(
ppl_last_z=(ppl_last_b_person_subject_z if _entry in ("log_density", "log_prior", "log_likelihood", "constrain") else None),
ppl_prior_L_normalizer=(ppl_prior_b_person_subject_L_normalizer if _entry in ("log_density", "log_prior") else None),
eta=(bucket_person_subject_lkj_eta if _entry in ("log_density", "log_prior") else None),
tau=(b_person_subject_tau if _entry in ("log_density", "log_prior") else None),
unconstrained=unconstrained,
outputs=tuple(
name for name, needed in (
("ppl_arrflat_z", ("log_density", "log_prior", "log_likelihood", "constrain")),
("ppl_lkj_diagonal_L", ("log_density", "log_prior", "log_likelihood", "constrain")),
("ppl_lkj_partials_L", ("log_density", "log_prior", "log_likelihood", "log_jacobian", "constrain")),
("ppl_lkj_raw_L", ("log_density", "log_prior", "log_likelihood", "log_jacobian", "constrain")),
("ppl_prior_L", ("log_density", "log_prior")),
("ppl_prior_L_diagonal", ("log_density", "log_prior")),
("ppl_prior_tau", ("log_density", "log_prior")),
("ppl_prior_z", ("log_density", "log_prior")),
("ppl_pw_prior_tau", ("log_density", "log_prior")),
("ppl_pw_prior_z", ("log_density", "log_prior")),
)
if _entry in needed
),
)
if _entry in ("log_density", "log_likelihood", "constrain"):
ppl_lkj_lower = _ppl_lkj_lower(b_person_subject["ppl_lkj_partials_L"], b_person_subject["ppl_lkj_diagonal_L"], 2, 1)
b_person_subject_L = ppl_lkj_lower
if _entry in ("log_density", "log_jacobian"):
total = 0.0
tuple_ = (1, 2)
i = tuple_[0]
j = tuple_[1]
def loop_body(p, carry):
(i_2, j_2, total_2) = carry
total_3 = total_2 + (j_2 - i_2 + 1) / 2 * jnp.log(1 - b_person_subject["ppl_lkj_partials_L"][p - 1] ** 2)
tuple__2 = jax.lax.cond(i_2 + 1 < j_2, lambda: (i_2 + 1, j_2), lambda: (1, j_2 + 1))
i_3 = tuple__2[0]
j_3 = tuple__2[1]
return (i_3, j_3, total_3)
loop_carry = jax.lax.fori_loop(1, 2, loop_body, (jnp.asarray(i, dtype=jnp.int64), jnp.asarray(j, dtype=jnp.int64), jnp.asarray(total, dtype=jnp.float64)))
ppl_lkj_logjac_b_person_subject_L = loop_carry[2]
if _entry in ("log_density", "log_likelihood", "constrain"):
b_person_subject_z = jnp.reshape(b_person_subject["ppl_arrflat_z"], (ppl_axis1_b_person_subject_z, 2), order="F")
if _entry in ("log_density", "log_prior"):
prior = b_person_subject["ppl_prior_tau"] + b_person_subject["ppl_prior_L"] + b_person_subject["ppl_prior_z"] + pop_mu["ppl_prior_beta_pop"] + pop_log_sigma["ppl_prior_beta_pop"]
if _entry in ("log_density", "log_jacobian"):
log_jacobian_2 = plate_fold + ppl_lkj_logjac_b_person_subject_L
if _entry in ("log_density", "log_likelihood"):
b_person_subject_2 = brm_correlated_group_effects(
L=(b_person_subject_L if _entry in ("log_density", "log_likelihood") else None),
tau=(b_person_subject_tau if _entry in ("log_density", "log_likelihood") else None),
z=(b_person_subject_z if _entry in ("log_density", "log_likelihood") else None),
outputs=tuple(
name for name, needed in (
("value", ("log_density", "log_likelihood")),
)
if _entry in needed
),
)
ranef_mu_person_subject = b_person_subject_2["value"][subject_level - 1, 0] + b_person_subject_2["value"][subject_level - 1, 1] * x
ppl_offset_mu = pop_mu["value"] + ranef_mu_person_subject
def ppl_pw_y_resp_cell(y_2, mu, rkppl_synth_1_2):
def then_arm():
log_scale = jnp.log(rkppl_synth_1_2)
standardized = (y_2 - mu) / jnp.where(jnp.logical_and(rkppl_synth_1_2 == 0, y_2 == mu), 1.0, rkppl_synth_1_2)
standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
return standard_logpdf - jnp.where(jnp.logical_and(rkppl_synth_1_2 == 0, y_2 != mu), 0.0, log_scale)
ppl_density = jax.lax.cond(rkppl_synth_1_2 > 0, then_arm, lambda: -jnp.inf)
return ppl_density
ppl_pw_y_resp = (jnp.zeros(y.shape[:1], dtype=jnp.float64) if 0 in y.shape[:1] and ppl_offset_mu.shape[:1] == y.shape[:1] and rkppl_synth_1.shape[:1] == y.shape[:1] else jax.vmap(ppl_pw_y_resp_cell, in_axes=(0, 0, 0))(y, ppl_offset_mu, rkppl_synth_1))
ppl_lik_y_resp = jnp.sum(ppl_pw_y_resp)
if _entry in ("log_density",):
posterior = prior + ppl_lik_y_resp + log_jacobian_2
if not (unconstrained.size == ppl_last_pop_log_sigma_beta_pop):
raise ValueError("[layout] packed length ≠ layout total: a packed point holds the coordinates of the binding whose layout packed it")
if _entry == "log_density":
return jnp.asarray(posterior, dtype=jnp.float64)
if _entry == "log_prior":
return jnp.asarray(prior, dtype=jnp.float64)
if _entry == "log_likelihood":
return jnp.asarray(ppl_lik_y_resp, dtype=jnp.float64)
if _entry == "log_jacobian":
return jnp.asarray(log_jacobian_2, dtype=jnp.float64)
if _entry == "constrain":
return {"b_person_subject": {"tau": jnp.asarray(b_person_subject_tau), "L": jnp.asarray(b_person_subject_L), "z": jnp.asarray(b_person_subject_z)}, "pop_mu": {"beta_pop": jnp.asarray(pop_mu_beta_pop)}, "pop_log_sigma": {"beta_pop": jnp.asarray(pop_log_sigma_beta_pop)}}
def log_density(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
"""The log density a sampler targets at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`.
The sum of `log_prior`, `log_likelihood` and `log_jacobian`.
"""
return model("log_density", unconstrained, **prepared)
def log_prior(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
"""The log prior density of the constrained parameters at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
return model("log_prior", unconstrained, **prepared)
def log_likelihood(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
"""The log likelihood of the observations at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
return model("log_likelihood", unconstrained, **prepared)
def log_jacobian(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
"""The log Jacobian of the constraining transforms at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
return model("log_jacobian", unconstrained, **prepared)
def constrain(unconstrained: ArrayLike, **prepared: ArrayLike) -> dict:
"""The constrained value of each parameter, and of each requested value, at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`. Returns a dict, a submodel's values nested under its name:
- `b_person_subject.tau`
- `b_person_subject.L`
- `b_person_subject.z`
- `pop_mu.beta_pop`
- `pop_log_sigma.beta_pop`
"""
return model("constrain", unconstrained, **prepared)
def dimension(prepared: dict) -> int:
"""The length of `unconstrained` for the data `prepared` (what `prepare_data` returned)."""
return int(prepared["ppl_last_pop_log_sigma_beta_pop"])
def parameters(prepared: dict) -> dict:
"""Each parameter's 0-based `start`/`stop` in `unconstrained`, its transform and dimensions,
for the data `prepared` (what `prepare_data` returned)."""
return {"b_person_subject.tau": {"start": 0, "stop": 2, "transform": "exp", "dims": (2,)}, "b_person_subject.L": {"start": 2, "stop": 3, "transform": "lkj", "dims": (2, 2)}, "b_person_subject.z": {"start": 3, "stop": int(prepared["ppl_last_b_person_subject_z"]), "transform": "identity", "dims": (int(prepared["ppl_axis1_b_person_subject_z"]), 2)}, "pop_mu.beta_pop": {"start": int(prepared["ppl_first_pop_mu_beta_pop"]) - 1, "stop": int(prepared["ppl_last_pop_mu_beta_pop"]), "transform": "identity", "dims": (2,)}, "pop_log_sigma.beta_pop": {"start": int(prepared["ppl_first_pop_log_sigma_beta_pop"]) - 1, "stop": int(prepared["ppl_last_pop_log_sigma_beta_pop"]), "transform": "identity", "dims": (2,)}}~ introduces a formula or a probability law; = computes a value. A formula allocates coefficients for its terms. Write 1 for an intercept: BRM does not insert one. The name sigma above holds the response-scale value exp(linear predictor). Its prior address is effect(sigma, ...); applying exp to sigma again would apply the link twice.
The BRM, intermediate-representation, StanBlocks and Stan panes all come from the same bound model. The following inspection checks the authored inputs and keeps the prior declarations visible.
using BayesianRegressionModels
model = Main.BRMDocsComparisons.example_module(:SyntaxGuide).model
(inputs=data_columns(model), priors=string(priors_of(model)))(inputs = [:x, :subject], priors = "effect(mu, 😃 ~ Normal(0, 1)\neffect(sigma, Intercept) ~ Normal(-1, 0.5)\neffect(sigma, x) ~ Normal(0, 0.2)\nsd(:, person) ~ Exponential(0.5)\ncor(:, person) ~ LKJCholesky(2, 2)")
| Familiar formula | BRM meaning |
|---|---|
1 + x + z | An intercept and two population effects |
x * z / x & z | Main effects plus interaction / interaction alone |
(1 + x | subject) | Correlated subject intercepts and slopes |
(1 + x || subject) | Independent subject intercepts and slopes |
(1 | p | subject) in two predictors | One correlation block spanning both predictors |
(1 | gr(subject; by=arm)) | Separate group-effect distributions by stratum |
| Two response statements | A joint model; shared names share parameters |
y ~ Normal(@brm(1 + x), exp(@brm(1))) | Nested mean and log-scale formulas |
Integer, string and categorical columns are factors; use floating-point values for a numeric trend. With an intercept, factors use treatment contrasts. Without one, the first eligible factor uses one coefficient per level. factor(g; cmc=false) keeps treatment coding; factor(g; ref=k) chooses a reference level. The reference gives the interaction and ordinal exceptions.
Nonlinear models and plates
Ordinary assignments combine sampled values without adding coefficients. This exponential-decay model has one rate per unit and several observations per unit. A groups binding connects the two axes.
Two axes connected by a plate
panes: brm|stanblocks|rkppl|stan|jax:3decay = @brm begin
log(rate) ~ 1 + (1 | unit)
rows = groups(observation_unit => unit)
@plate for i in eachindex(rate)
mean_y = amplitude * exp.(-rate[i] .* time[rows[i]])
y[rows[i]] ~ Normal(mean_y, noise)
end
amplitude ~ LogNormal(0, 0.5)
noise ~ Exponential(0.2)
effect(rate, Intercept) ~ Normal(-1, 0.5)
sd(rate, unit) ~ Exponential(0.3)
end
model = decay((; unit=["a", "b"],
observation_unit=["a", "b", "a", "b", "b"],
time=[0., 0., 1., 1., 2.], y=[1.1, 0.9, 0.7, 0.6, 0.4]))SBBRMI with data keys = [:kernel_nsub_y_cell, :kernel_y_cell_time_ragged, :kernel_y_cell_y_ragged, :n_rows_time_observation_unit, :n_rows_y_observation_unit, :n_terms_rate__unit_unit, :n_unit, :time, :unit_idx, :y]
configured submodels:
ranef_correlated_draws_single_margin_1 = Base.merge(BayesianRegressionModels._sb_single_margin_ranef(BayesianRegressionModels.ranef_correlated_draws), quote
tau ~ (StanBlocks.builtin.restricted)(exponential, 1.0 ./ 0.3; n = n_terms, lower = 0.0)
end)
emitted @slic body:
begin
b_rate__unit_unit ~ ranef_correlated_draws_single_margin_1(; group_idx = unit_idx, n_groups = n_unit, n_terms = n_terms_rate__unit_unit)
X_log_rate = hcat(rep_vector(1.0, num_elements(unit_idx)))
pop_log_rate ~ _popefs_normal(; X = X_log_rate, beta_loc = [-1], beta_scale = [0.5])
r_log_rate_rate__unit_unit = b_rate__unit_unit[unit_idx, 1]
log_rate = pop_log_rate + r_log_rate_rate__unit_unit
rate = exp(log_rate)
amplitude ~ lognormal(0, 0.5)
noise ~ exponential(1.0 ./ 0.2)
y_cell ~ plate(rate, kernel_y_cell_time_ragged, kernel_y_cell_y_ragged; outer = (kernel_nsub_y_cell,)) do rate, time, y
#= brm-docs-example.jl:5 =#
mean_y = amplitude * exp.(-rate .* time)
#= brm-docs-example.jl:6 =#
y ~ normal(mean_y, noise)
#= brm-docs-example.jl:7 =#
nothing
end
end"""
Group-level (varying) effects of grouping `g`.
Non-centered, from the scale `tau[1]` (drawn from its prior) and standardized effects
`z[1:length(levels(g)), 1:1] ~ Normal(0, 1)`. Returns the
level-by-margin matrix `z .* tau[1]`, one row per level of `g` in order.
"""
brm_group_effects(g) = begin
tau[1:1] .~ Exponential.(0.3)
z[1:length(levels(g)), 1:1] .~ Normal.(0, 1)
return z .* tau[1]
end
begin
unit_fit_levels = brm_fit_levels(unit_fit)
b_rate__unit_unit ~ brm_group_effects(unit_fit_levels)
unit_level = brm_level_indices(unit, unit_fit_levels)
ranef_rate_rate__unit_unit = b_rate__unit_unit[unit_level, 1]
rate_Intercept ~ Normal(-1.0, 0.5)
log_rate = rate_Intercept .+ ranef_rate_rate__unit_unit
rate = exp.(log_rate)
amplitude ~ LogNormal(0.0, 0.5)
noise ~ Exponential(0.2)
y_cell_rows_2 = brm_ragged_rows([:time, :observation_unit, :unit, :time], observation_unit, unit, (time,))
@plate for i = eachindex(unit)
mean_y = amplitude * exp.(-(rate[i]) .* time[y_cell_rows_2[i]])
y_cell_argument_y_1[i] = mean_y
end
@plate for i = eachindex(y)
y[i] .~ Normal.(y_cell_argument_y_1[i], noise)
end
endfunctions {
matrix hcat(vector x) {
int n = dims(x)[1];
return to_matrix(x, n, 1);
}
int ragged_end(array[] int ends, int i) {
return ends[i];
}
int ragged_start(
array[] int ends,
int i
) {
if((i == 1)) {
return 1;
} else {
return (1 + ends[(i - 1)]);
}
}
vector jbroadcasted_exp(
vector x1
) {
int n = dims(x1)[1];
vector[n] rv;
for(i in 1:n) {
rv[i] = exp(broadcasted_getindex(x1, i));
}
return rv;
}
real broadcasted_getindex(vector x, int i) {
return x[i];
}
vector normal_lpdfs(
vector obs,
vector loc,
real scale
) {
return jbroadcasted_normal_lpdfs(obs, loc, scale);
}
vector jbroadcasted_normal_lpdfs(
vector x1,
vector x2,
real x3
) {
int n = dims(x1)[1];
vector[n] rv;
for(i in 1:n) {
rv[i] = normal_lpdfs(broadcasted_getindex(x1, i), broadcasted_getindex(x2, i), x3);
}
return rv;
}
real normal_lpdfs(
real args1,
real args2,
real args3
) {
return normal_lpdf(args1 | args2, args3);
}
vector normal_vector_rng(
int anontok__1,
vector a,
real b
) {
int n = anontok__1;
if((n == 0)) {
vector[n] rv;
return rv;
} else {
return to_vector(normal_rng(a, b));
}
}
}
data {
int n_terms_rate__unit_unit;
int n_unit;
int unit_idx_n;
array[unit_idx_n] int unit_idx;
int kernel_nsub_y_cell;
int kernel_y_cell_time_ragged_ends_n;
int kernel_y_cell_time_ragged_mem_n;
tuple(vector[kernel_y_cell_time_ragged_mem_n], array[kernel_y_cell_time_ragged_ends_n] int) kernel_y_cell_time_ragged;
int kernel_y_cell_y_ragged_mem_n;
int kernel_y_cell_y_ragged_ends_n;
tuple(vector[kernel_y_cell_y_ragged_mem_n], array[kernel_y_cell_y_ragged_ends_n] int) kernel_y_cell_y_ragged;
}
transformed data {
matrix[num_elements(unit_idx), 1] X_log_rate = hcat(rep_vector(1.0, num_elements(unit_idx)));
int pop_log_rate_n_covariates = 1;
array[kernel_nsub_y_cell] int y_cell_mean_y__pl_len;
for(plate_i__pl_1 in 1:kernel_nsub_y_cell) {
y_cell_mean_y__pl_len[plate_i__pl_1] = (
1 +
(
ragged_end(kernel_y_cell_time_ragged.2, plate_i__pl_1) -
ragged_start(kernel_y_cell_time_ragged.2, plate_i__pl_1)
)
);
}
array[kernel_nsub_y_cell] int y_cell_mean_y__pl_end = cumulative_sum(y_cell_mean_y__pl_len);
}
parameters {
vector<lower=0.0>[n_terms_rate__unit_unit] b_rate__unit_unit_tau;
vector[(n_terms_rate__unit_unit * n_unit)] b_rate__unit_unit_z_flat;
vector[pop_log_rate_n_covariates] pop_log_rate_beta_pop;
real<lower=0.0> amplitude;
real<lower=0.0> noise;
}
transformed parameters {
matrix[n_terms_rate__unit_unit, n_unit] b_rate__unit_unit_z = to_matrix(b_rate__unit_unit_z_flat, n_terms_rate__unit_unit, n_unit);
matrix[n_unit, n_terms_rate__unit_unit] b_rate__unit_unit = ((diag_matrix(b_rate__unit_unit_tau) * b_rate__unit_unit_z)');
vector[num_elements(unit_idx)] pop_log_rate = (X_log_rate * pop_log_rate_beta_pop);
vector[unit_idx_n] r_log_rate_rate__unit_unit = b_rate__unit_unit[unit_idx, 1];
vector[num_elements(unit_idx)] log_rate = (pop_log_rate + r_log_rate_rate__unit_unit);
vector[num_elements(unit_idx)] rate = exp(log_rate);
vector[sum(y_cell_mean_y__pl_len)] y_cell_mean_y;
for(plate_i__pl_1 in 1:kernel_nsub_y_cell) {
y_cell_mean_y[
ragged_start(y_cell_mean_y__pl_end, plate_i__pl_1):ragged_end(y_cell_mean_y__pl_end, plate_i__pl_1)
] = (
amplitude *
jbroadcasted_exp(
(
(-rate[plate_i__pl_1]) .*
kernel_y_cell_time_ragged.1[
ragged_start(kernel_y_cell_time_ragged.2, plate_i__pl_1):ragged_end(kernel_y_cell_time_ragged.2, plate_i__pl_1)
]
)
)
);
}
}
model {
b_rate__unit_unit_tau ~ exponential((1.0 ./ 0.3));
b_rate__unit_unit_z_flat ~ std_normal();
pop_log_rate_beta_pop ~ normal([-1]', [0.5]');
amplitude ~ lognormal(0, 0.5);
noise ~ exponential((1.0 ./ 0.2));
for(plate_i__pl_1 in 1:kernel_nsub_y_cell) {
kernel_y_cell_y_ragged.1[
ragged_start(kernel_y_cell_y_ragged.2, plate_i__pl_1):ragged_end(kernel_y_cell_y_ragged.2, plate_i__pl_1)
] ~ normal(
y_cell_mean_y[
ragged_start(y_cell_mean_y__pl_end, plate_i__pl_1):ragged_end(y_cell_mean_y__pl_end, plate_i__pl_1)
],
noise
);
}
}
generated quantities {
vector[num_elements(kernel_y_cell_y_ragged.1)] kernel_y_cell_y_ragged_gen;
vector[num_elements(kernel_y_cell_y_ragged.2)] kernel_y_cell_y_ragged_likelihood;
for(plate_i__pl_1 in 1:kernel_nsub_y_cell) {
kernel_y_cell_y_ragged_gen[
ragged_start(kernel_y_cell_y_ragged.2, plate_i__pl_1):ragged_end(kernel_y_cell_y_ragged.2, plate_i__pl_1)
] = normal_vector_rng(
(1 + (ragged_end(kernel_y_cell_y_ragged.2, plate_i__pl_1) - ragged_start(kernel_y_cell_y_ragged.2, plate_i__pl_1))),
y_cell_mean_y[
ragged_start(y_cell_mean_y__pl_end, plate_i__pl_1):ragged_end(y_cell_mean_y__pl_end, plate_i__pl_1)
],
noise
);
kernel_y_cell_y_ragged_likelihood[plate_i__pl_1] = normal_lpdf(kernel_y_cell_y_ragged.1[
ragged_start(kernel_y_cell_y_ragged.2, plate_i__pl_1):ragged_end(kernel_y_cell_y_ragged.2, plate_i__pl_1)
] |
y_cell_mean_y[
ragged_start(y_cell_mean_y__pl_end, plate_i__pl_1):ragged_end(y_cell_mean_y__pl_end, plate_i__pl_1)
],
noise
);
}
}using ReactiveKernels, ReactiveKernelsPPL
rk = RKBRMI(model)
source = jax_source(rk.model, rk_bound_plan(rk))
write("model.py", source)
inputs = rk_bound_data(rk, source) # exactly the inputs prepare_data readsimport jax
import model as m
prepared = m.prepare_data(**inputs)
lp = m.log_density(u, **prepared) # u: unconstrained, length m.dimension(prepared)
lp = jax.jit(m.log_density)(u, **prepared) # one compiled function for every dataset of these shapes"""Generated by ReactiveKernelsPPL.jax_source from a built @rkppl program; do not edit.
Data: observation_unit, time, unit, unit_fit, y.
Model documentation:
- `b_rate__unit_unit`: Group-level (varying) effects of grouping `g`.
Non-centered, from the scale `tau[1]` (drawn from its prior) and standardized effects
`z[1:length(levels(g)), 1:1] ~ Normal(0, 1)`. Returns the
level-by-margin matrix `z .* tau[1]`, one row per level of `g` in order.
"""
import numpy as np
import scipy.special as ssp
from typing import Any
import jax
import jax.numpy as jnp
import jax.scipy.linalg
import jax.scipy.special as jsp
from jax.typing import ArrayLike
jax.config.update("jax_enable_x64", True)
DATA = {"observation_unit": {"dtype": "object", "ndim": 1, "ragged": False}, "time": {"dtype": "float64", "ndim": 1, "ragged": False}, "unit": {"dtype": "object", "ndim": 1, "ragged": False}, "unit_fit": {"dtype": "object", "ndim": 1, "ragged": False}, "y": {"dtype": "float64", "ndim": 1, "ragged": True}}
INPUTS = ("unconstrained", "ppl_last_b_rate_unit_unit_z", "ppl_axis1_b_rate_unit_unit_z", "unit_level", "plate_argument", "time", "y_cell_rows_2", "y_cell_rows_2_lengths", "y_cell_rows_2_flat", "y", "y_lengths", "y_flat")
PREPARED = {"ppl_last_b_rate_unit_unit_z": {"dtype": "int64", "ndim": 0, "ragged": False}, "ppl_axis1_b_rate_unit_unit_z": {"dtype": "int64", "ndim": 0, "ragged": False}, "unit_level": {"dtype": "int64", "ndim": 1, "ragged": False}, "plate_argument": {"dtype": "int64", "ndim": 1, "ragged": False}, "time": {"dtype": "float64", "ndim": 1, "ragged": False}, "y_cell_rows_2": {"dtype": "int64", "ndim": 1, "ragged": True}, "y": {"dtype": "float64", "ndim": 1, "ragged": True}}
UNTRANSLATED = {}
def _rk_order_key_np(x):
# Julia's isless order of an array as sortable keys: a float is an integer
# key, -0.0 before 0.0 and every NaN last, equal for values isequal treats
# as equal. Integer and string arrays are their own keys.
x = np.asarray(x)
if x.dtype.kind != "f":
return x
bits = np.where(np.isnan(x), np.nan, x).astype(np.float64).view(np.int64)
return np.where(bits < 0, bits ^ np.int64(0x7FFFFFFFFFFFFFFF), bits)
def _rk_unique_np(x):
# Julia's unique of a vector: the first value of each isequal class, in
# order.
x = np.asarray(x)
_, first = np.unique(_rk_order_key_np(x), return_index=True)
return x[np.sort(first)]
def _rk_sort_np(x):
# Julia's sort of a vector: ascending in isless order, equal values in
# their order.
x = np.asarray(x)
return x[np.argsort(_rk_order_key_np(x), kind="stable")]
def _brm_sorted_labels_np(source):
labels = _rk_unique_np(source)
sorted_ = _rk_sort_np(labels)
return sorted_
def _brm_fit_levels_np(source):
value = _brm_sorted_labels_np(source)
levels = value
return levels
def _rk_dict_key(x):
if isinstance(x, tuple):
return (1, tuple(map(_rk_dict_key, x)))
if isinstance(x, np.ndarray):
return (2, x.shape, tuple(map(_rk_dict_key, x.ravel(order="F"))))
if isinstance(x, (complex, np.complexfloating)):
if x.imag == 0 and not np.signbit(x.imag):
return _rk_dict_key(x.real)
return (3, _rk_dict_key(x.real), _rk_dict_key(x.imag))
if isinstance(x, (float, np.floating)):
if np.isnan(x):
return (4,)
if x == 0 and np.signbit(x):
return (5,)
return (0, x)
class _RKDict:
def __init__(self, pairs=()):
self.data = {}
for key, value in pairs:
self[key] = value
def __len__(self):
return len(self.data)
def __contains__(self, key):
return _rk_dict_key(key) in self.data
def __getitem__(self, key):
return self.data[_rk_dict_key(key)][1]
def __setitem__(self, key, value):
self.data[_rk_dict_key(key)] = (key, value)
def get(self, key, default):
item = self.data.get(_rk_dict_key(key))
return default if item is None else item[1]
def setdefault(self, key, default):
return self.data.setdefault(_rk_dict_key(key), (key, default))[1]
def pop(self, key, default):
item = self.data.pop(_rk_dict_key(key), None)
return default if item is None else item[1]
def items(self):
return self.data.values()
def keys(self):
return (item[0] for item in self.items())
def values(self):
return (item[1] for item in self.items())
def copy(self):
return _RKDict(self.items())
def _brm_level_indices_np(labels, source):
value = _brm_fit_levels_np(source)
levels = value
lookup = _RKDict()
for k in range(1, len(levels) + 1):
lookup[levels[k - 1]] = k
indices = np.zeros((len(labels),), dtype=np.int64)
for r in range(1, len(labels) + 1):
position = lookup.get(labels[r - 1], 0)
if position == 0:
raise ValueError("".join([str("RK backend: group label `"), str(labels[r - 1]), str("` is not one of the "), str(len(levels)), str(" fitted levels. A replay keeps the fitted levels of every grouping it does not resample; name the grouping in `resample_groups` to take the new data's own levels.")]))
indices[r - 1] = position
return indices
def _rk_levels_np(x):
arr = np.asarray(x)
values = sorted(set(v for v in arr.tolist() if v is not None))
return np.array(values, dtype=object if arr.dtype == object else arr.dtype)
def _brm_group_values_np(raw):
return raw
def _brm_cell_labels_np(raw, group, prefix):
if np.logical_not(True):
raise ValueError("_brm_not_a_label_vector threw")
value = _brm_group_values_np(raw)
values = value
unique_labels = True
seen = _RKDict()
for k in range(1, len(values) + 1):
if (values[k - 1] is None) or (values[k - 1] in seen):
unique_labels = False
seen[values[k - 1]] = k
if np.logical_not(unique_labels):
raise ValueError("".join([str(prefix), str(": kernel(...) needs pre-grouped per-subject data — `"), str(group), str("` must list one non-missing unique subject per row. Repeated levels indicate long-format data. Got "), str(values), str(".")]))
return values
def _brm_check_ragged_axis_np(x, group, column, len_, n, prefix):
if len_ != n:
raise ValueError("".join([str(prefix), str(": `"), str(x), str("` read through `"), str(group), str("`: `"), str(x), str("` has "), str(len_), str(" entries (data vector `"), str(column), str("`) but `"), str(group), str("` has "), str(n), str(". The grouping column must label EVERY entry of `"), str(x), str("`; an entry whose label names no cell is read by no cell.")]))
return None
def _brm_check_ragged_axes_np(names, offset, axes, n, prefix):
k = offset
for axis in axes:
k = k + 1
value = _brm_check_ragged_axis_np(names[0], names[1], names[k - 1], len(axis), n, prefix)
return None
def _brm_check_missing_labels_np(x, group, values, prefix):
return None
def _brm_hashed_label_table_np(labels):
table = _RKDict()
for k in range(1, len(labels) + 1):
table[labels[k - 1]] = k
return table
def _brm_label_position_np(table, lo, hi, v):
return table.get(v, 0)
def _rk_isequal_np(a, b):
# Julia's isequal on scalars: NaN equals NaN, -0.0 differs from 0.0, and
# missing (None) equals only missing.
if a is None or b is None:
return a is b
if a != a and b != b:
return True
if not bool(a == b):
return False
if isinstance(a, (int, float, np.number)) and isinstance(b, (int, float, np.number)) and a == 0:
return bool(np.signbit(a) == np.signbit(b))
return True
def _brm_partition_rows_np(values, ncells, table, lo, hi):
counts = np.zeros((ncells,), dtype=np.int64)
if np.logical_not((len(values) == 0)):
previous = values[0]
value = _brm_label_position_np(table, lo, hi, previous)
at = value
for r_2 in range(1, len(values) + 1):
if np.logical_not(_rk_isequal_np(values[r_2 - 1], previous)):
previous = values[r_2 - 1]
value_2 = _brm_label_position_np(table, lo, hi, previous)
at = value_2
if at != 0:
counts[at - 1] = counts[at - 1] + 1
rows = [np.zeros((counts[k - 1],), dtype=np.int64) for k in range(1, ncells + 1)]
for k_2 in range(1, ncells + 1):
counts[k_2 - 1] = 0
if np.logical_not((len(values) == 0)):
previous = values[0]
value_3 = _brm_label_position_np(table, lo, hi, previous)
at = value_3
for r_3 in range(1, len(values) + 1):
if np.logical_not(_rk_isequal_np(values[r_3 - 1], previous)):
previous = values[r_3 - 1]
value_4 = _brm_label_position_np(table, lo, hi, previous)
at = value_4
if at != 0:
counts[at - 1] = counts[at - 1] + 1
rows[at - 1][counts[at - 1] - 1] = r_3
return rows
def _brm_ragged_partition_np(x, group, values, labels, prefix):
value = _brm_check_missing_labels_np(x, group, values, prefix)
value_2 = _brm_hashed_label_table_np(labels)
value_3 = _brm_partition_rows_np(values, len(labels), value_2, None, None)
rows = value_3
return rows
def _brm_ragged_rows_np(names, groups, cells, axes):
value = _brm_cell_labels_np(cells, names[2], "RK backend")
labels = value
value_2 = _brm_group_values_np(groups)
values = value_2
value_3 = _brm_check_ragged_axes_np(names, 3, axes, len(values), "RK backend")
value_4 = _brm_ragged_partition_np(names[0], names[1], values, labels, "RK backend")
return value_4
class StaticInt(int):
"""An integer of the prepared data that sets a shape.
It is an `int` everywhere, and `jax.jit` treats it as static, so the
functions jit with the prepared data as arguments; a new value traces
them again.
"""
def __repr__(self):
return "StaticInt(%d)" % int(self)
jax.tree_util.register_pytree_node(StaticInt, lambda s: ((), int(s)), lambda v, _: StaticInt(v))
def _rk_pad_rows(rows, dtype, rank=1):
# A ragged value as the functions take it: the padded array (each row
# repeats its last entry; an empty row is zeros), the lengths, and the
# positions of the valid entries in the flattened padded array, whose
# length is the total. `dtype` is the element type the program declares,
# so an empty row (`[]`) keeps an integer column integer.
rows = [np.asarray(r, dtype=dtype) for r in rows]
# One length per cell describes its first axis. Other axes retain a
# common shape; independently ragged axes need separate extents.
tail = rows[0].shape[1:] if rows else (1,) * (rank - 1)
if any(r.ndim != rank or r.shape[1:] != tail for r in rows):
raise ValueError("ragged cells need their declared rank and common trailing dimensions")
lengths = np.asarray([r.shape[0] for r in rows], dtype=np.int64)
width = max([1 if rank > 1 and not rows else 0] + [int(n) for n in lengths])
padded = np.stack([np.pad(r, ((0, width - r.shape[0]),) + ((0, 0),) * (rank - 1),
mode="edge") if r.shape[0] > 0
else np.zeros((width,) + tail, dtype=dtype) for r in rows]) if rows else np.zeros((0, width) + tail, dtype=dtype)
flat = np.flatnonzero(np.arange(width)[None, :] < lengths[:, None])
return padded, lengths, flat
def _log_of(x: ArrayLike, active: ArrayLike) -> jax.Array:
"""Compute `_rk_log_of` from its authored source."""
return jnp.asarray(x, dtype=jnp.float64)
def brm_group_effects_density(
ppl_last_z: ArrayLike,
tau: ArrayLike,
unconstrained: ArrayLike,
*,
outputs: tuple[str, ...],
) -> dict:
"""Group-level (varying) effects of grouping `g`.
Non-centered, from the scale `tau[1]` (drawn from its prior) and standardized effects
`z[1:length(levels(g)), 1:1] ~ Normal(0, 1)`. Returns the
level-by-margin matrix `z .* tau[1]`, one row per level of `g` in order.
"""
results = {}
if any(name in outputs for name in ("ppl_arrflat_z", "ppl_prior_z", "ppl_pw_prior_z")):
ppl_arrflat_z = unconstrained[4:ppl_last_z]
if any(name in outputs for name in ("ppl_prior_tau", "ppl_pw_prior_tau")):
def ppl_pw_prior_tau_cell(tau_2):
log_scale = np.log(0.3)
logpdf = jax.lax.cond(tau_2 < 0, lambda: -jnp.inf, lambda: -log_scale - tau_2 / 0.3)
return logpdf
ppl_pw_prior_tau = (jnp.zeros(tau.shape[:1], dtype=jnp.float64) if 0 in tau.shape[:1] else jax.vmap(ppl_pw_prior_tau_cell, in_axes=(0,))(tau))
if any(name in outputs for name in ("ppl_prior_tau",)):
ppl_prior_tau = jnp.sum(ppl_pw_prior_tau)
if any(name in outputs for name in ("ppl_prior_z", "ppl_pw_prior_z")):
def ppl_pw_prior_z_cell(z):
log_scale = np.log(1.0)
standardized = (z - 0.0) / jnp.where((z == 0.0 if 1.0 == 0 else False), 1.0, 1.0)
standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
logpdf = standard_logpdf - jnp.where((z != 0.0 if 1.0 == 0 else False), 0.0, log_scale)
return logpdf
ppl_pw_prior_z = (jnp.zeros(ppl_arrflat_z.shape[:1], dtype=jnp.float64) if 0 in ppl_arrflat_z.shape[:1] else jax.vmap(ppl_pw_prior_z_cell, in_axes=(0,))(ppl_arrflat_z))
if any(name in outputs for name in ("ppl_prior_z",)):
ppl_prior_z = jnp.sum(ppl_pw_prior_z)
if "ppl_arrflat_z" in outputs:
results["ppl_arrflat_z"] = ppl_arrflat_z
if "ppl_prior_tau" in outputs:
results["ppl_prior_tau"] = ppl_prior_tau
if "ppl_prior_z" in outputs:
results["ppl_prior_z"] = ppl_prior_z
if "ppl_pw_prior_tau" in outputs:
results["ppl_pw_prior_tau"] = ppl_pw_prior_tau
if "ppl_pw_prior_z" in outputs:
results["ppl_pw_prior_z"] = ppl_pw_prior_z
return results
def brm_group_effects(tau: ArrayLike, z: ArrayLike, *, outputs: tuple[str, ...]) -> dict:
"""Group-level (varying) effects of grouping `g`.
Non-centered, from the scale `tau[1]` (drawn from its prior) and standardized effects
`z[1:length(levels(g)), 1:1] ~ Normal(0, 1)`. Returns the
level-by-margin matrix `z .* tau[1]`, one row per level of `g` in order.
"""
results = {}
if any(name in outputs for name in ("value",)):
value = z * tau[0]
if "value" in outputs:
results["value"] = value
return results
def prepare_data(observation_unit: Any, time: ArrayLike, unit: Any, unit_fit: Any, y: list) -> dict:
"""The functions' data inputs, computed from the raw data once per dataset.
Pass the data by the names the model reads them; a list of arrays is a ragged
column. Call the other functions with the result: `f(u, **prepared)`.
"""
observation_unit = np.asarray(observation_unit, dtype=object)
time = np.asarray(time, dtype=np.float64)
unit = np.asarray(unit, dtype=object)
unit_fit = np.asarray(unit_fit, dtype=object)
y = [np.asarray(a, dtype=np.float64) for a in y]
value = _brm_fit_levels_np(unit_fit)
unit_fit_levels = value
value_2 = _brm_level_indices_np(unit, unit_fit_levels)
unit_level = np.asarray(value_2, dtype=np.int64)
ppl_axis1_b_rate_unit_unit_z = len(_rk_levels_np(unit_fit_levels))
ppl_last_b_rate_unit_unit_z = 4 + ppl_axis1_b_rate_unit_unit_z
value_3 = _brm_ragged_rows_np(np.stack(["time", "observation_unit", "unit", "time"]), observation_unit, unit, (time,))
y_cell_rows_2 = value_3
plate_argument = np.arange(1, len(unit) + 1)
y_cell_rows_2_padded, y_cell_rows_2_lengths, y_cell_rows_2_flat = _rk_pad_rows(y_cell_rows_2, np.int64, 1)
y_padded, y_lengths, y_flat = _rk_pad_rows(y, np.float64, 1)
return {"ppl_last_b_rate_unit_unit_z": StaticInt(ppl_last_b_rate_unit_unit_z), "ppl_axis1_b_rate_unit_unit_z": StaticInt(ppl_axis1_b_rate_unit_unit_z), "unit_level": np.asarray(unit_level, dtype=np.int64), "plate_argument": np.asarray(plate_argument, dtype=np.int64), "time": np.asarray(time, dtype=np.float64), "y_cell_rows_2": y_cell_rows_2_padded, "y_cell_rows_2_lengths": y_cell_rows_2_lengths, "y_cell_rows_2_flat": y_cell_rows_2_flat, "y": y_padded, "y_lengths": y_lengths, "y_flat": y_flat}
def model(_entry: str, unconstrained: ArrayLike, **prepared: ArrayLike) -> Any:
"""Shared model computation. The generated entry wrappers select a static output."""
ppl_last_b_rate_unit_unit_z = prepared["ppl_last_b_rate_unit_unit_z"]
ppl_axis1_b_rate_unit_unit_z = prepared["ppl_axis1_b_rate_unit_unit_z"]
unit_level = prepared["unit_level"]
plate_argument = prepared["plate_argument"]
time = prepared["time"]
y_cell_rows_2 = prepared["y_cell_rows_2"]
y_cell_rows_2_lengths = prepared["y_cell_rows_2_lengths"]
y_cell_rows_2_flat = prepared["y_cell_rows_2_flat"]
y = prepared["y"]
y_lengths = prepared["y_lengths"]
y_flat = prepared["y_flat"]
unconstrained = jnp.asarray(unconstrained)
unit_level = jnp.asarray(unit_level)
plate_argument = jnp.asarray(plate_argument)
time = jnp.asarray(time)
y_cell_rows_2 = jnp.asarray(y_cell_rows_2)
y_cell_rows_2_lengths = jnp.asarray(y_cell_rows_2_lengths)
y_cell_rows_2_flat = jnp.asarray(y_cell_rows_2_flat)
y = jnp.asarray(y)
y_lengths = jnp.asarray(y_lengths)
y_flat = jnp.asarray(y_flat)
if _entry in ("log_density", "log_prior", "log_likelihood", "constrain"):
rate_Intercept = unconstrained[0]
u_argument = unconstrained[1]
constrain_2 = jnp.exp(u_argument)
u_argument_2 = unconstrained[2]
constrain_3 = jnp.exp(u_argument_2)
plate_argument_2 = unconstrained[3:4]
def b_rate_unit_unit_tau_cell(ppl_cell_b_rate_unit_unit_tau):
constrain_4 = jnp.exp(ppl_cell_b_rate_unit_unit_tau)
return constrain_4
b_rate_unit_unit_tau = (jnp.zeros(plate_argument_2.shape[:1], dtype=jnp.float64) if 0 in plate_argument_2.shape[:1] else jax.vmap(b_rate_unit_unit_tau_cell, in_axes=(0,))(plate_argument_2))
if _entry in ("log_density", "log_jacobian"):
plate_argument_3 = unconstrained[3:4]
def ppl_ljcells_b_rate_unit_unit_tau_cell(ppl_cell_b_rate_unit_unit_tau):
return ppl_cell_b_rate_unit_unit_tau
ppl_ljcells_b_rate_unit_unit_tau = (jnp.zeros(plate_argument_3.shape[:1], dtype=jnp.float64) if 0 in plate_argument_3.shape[:1] else jax.vmap(ppl_ljcells_b_rate_unit_unit_tau_cell, in_axes=(0,))(plate_argument_3))
if _entry in ("log_density", "log_prior"):
ppl_prior_rate_Intercept_log_scale = np.log(0.5)
ppl_prior_rate_Intercept_standardized = (rate_Intercept - -1.0) / jnp.where((rate_Intercept == -1.0 if 0.5 == 0 else False), 1.0, 0.5)
ppl_prior_rate_Intercept_standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * ppl_prior_rate_Intercept_standardized ** 2
logpdf = ppl_prior_rate_Intercept_standard_logpdf - jnp.where((rate_Intercept != -1.0 if 0.5 == 0 else False), 0.0, ppl_prior_rate_Intercept_log_scale)
ppl_prior_amplitude_log_scale = np.log(0.5)
def else_arm():
log_of = _log_of(u_argument, jnp.logical_not(constrain_2 <= 0))
return log_of
ppl_prior_amplitude_logpdf_log_x = jax.lax.cond(constrain_2 <= 0, lambda: -jnp.inf, else_arm)
ppl_prior_amplitude_logpdf_jacobian = jnp.where(constrain_2 <= 0, 0.0, ppl_prior_amplitude_logpdf_log_x)
ppl_prior_amplitude_logpdf_logpdf_standardized = (ppl_prior_amplitude_logpdf_log_x - 0.0) / jnp.where((ppl_prior_amplitude_logpdf_log_x == 0.0 if 0.5 == 0 else False), 1.0, 0.5)
ppl_prior_amplitude_logpdf_logpdf_standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * ppl_prior_amplitude_logpdf_logpdf_standardized ** 2
ppl_prior_amplitude_logpdf = ppl_prior_amplitude_logpdf_logpdf_standard_logpdf - jnp.where((ppl_prior_amplitude_logpdf_log_x != 0.0 if 0.5 == 0 else False), 0.0, ppl_prior_amplitude_log_scale)
logpdf_2 = ppl_prior_amplitude_logpdf - ppl_prior_amplitude_logpdf_jacobian
ppl_prior_noise_log_scale = np.log(0.2)
logpdf_3 = jax.lax.cond(constrain_3 < 0, lambda: -jnp.inf, lambda: -ppl_prior_noise_log_scale - constrain_3 / 0.2)
if _entry in ("log_density", "log_jacobian"):
u_argument_3 = unconstrained[1]
u_argument_4 = unconstrained[2]
plate_fold = jnp.sum(ppl_ljcells_b_rate_unit_unit_tau)
log_jacobian_2 = u_argument_3 + u_argument_4 + plate_fold
if _entry in ("log_density", "log_prior", "log_likelihood", "constrain"):
b_rate_unit_unit = brm_group_effects_density(
ppl_last_z=(ppl_last_b_rate_unit_unit_z if _entry in ("log_density", "log_prior", "log_likelihood", "constrain") else None),
tau=(b_rate_unit_unit_tau if _entry in ("log_density", "log_prior") else None),
unconstrained=(unconstrained if _entry in ("log_density", "log_prior", "log_likelihood", "constrain") else None),
outputs=tuple(
name for name, needed in (
("ppl_arrflat_z", ("log_density", "log_prior", "log_likelihood", "constrain")),
("ppl_prior_tau", ("log_density", "log_prior")),
("ppl_prior_z", ("log_density", "log_prior")),
("ppl_pw_prior_tau", ("log_density", "log_prior")),
("ppl_pw_prior_z", ("log_density", "log_prior")),
)
if _entry in needed
),
)
if _entry in ("log_density", "log_likelihood", "constrain"):
b_rate_unit_unit_z = jnp.reshape(b_rate_unit_unit["ppl_arrflat_z"], (ppl_axis1_b_rate_unit_unit_z, 1), order="F")
if _entry in ("log_density", "log_prior"):
prior = logpdf + logpdf_2 + logpdf_3 + b_rate_unit_unit["ppl_prior_tau"] + b_rate_unit_unit["ppl_prior_z"]
if _entry in ("log_density", "log_likelihood"):
b_rate_unit_unit_2 = brm_group_effects(
tau=(b_rate_unit_unit_tau if _entry in ("log_density", "log_likelihood") else None),
z=(b_rate_unit_unit_z if _entry in ("log_density", "log_likelihood") else None),
outputs=tuple(
name for name, needed in (
("value", ("log_density", "log_likelihood")),
)
if _entry in needed
),
)
ppl_column_b_rate_unit_unit_1 = b_rate_unit_unit_2["value"][:, 0]
plate_argument_4 = ppl_column_b_rate_unit_unit_1[unit_level - 1]
def log_rate_cell(rate_Intercept_2, value):
plate_value = rate_Intercept_2 + value
return plate_value
log_rate = (jnp.zeros(plate_argument_4.shape[:1], dtype=jnp.float64) if 0 in plate_argument_4.shape[:1] else jax.vmap(log_rate_cell, in_axes=(None, 0))(rate_Intercept, plate_argument_4))
rate = jnp.exp(log_rate)
def y_cell_argument_y_1_cell(ppl_pi_y_cell_argument_y_1, time_2, amplitude, rate_2, y_cell_rows_2_2, y_cell_rows_2_n):
ppl_linear_time = time_2
mean_y = amplitude * jnp.exp(-rate_2[ppl_pi_y_cell_argument_y_1 - 1] * ppl_linear_time[y_cell_rows_2_2[ppl_pi_y_cell_argument_y_1 - 1] - 1])
return (mean_y, y_cell_rows_2_n[ppl_pi_y_cell_argument_y_1 - 1])
plate_value, plate_lengths = ((jnp.zeros((0, 0), dtype=jnp.float64), jnp.zeros((0,), dtype=jnp.int64)) if 0 in plate_argument.shape[:1] else jax.vmap(y_cell_argument_y_1_cell, in_axes=(0, None, None, None, None, None))(plate_argument, time, constrain_2, rate, y_cell_rows_2, y_cell_rows_2_lengths))
y_cell_argument_y_1 = plate_value
def ppl_pw_y_resp_totals_cell(ppl_group_y, ppl_group_y_n, ppl_group_y_cell_argument_y_1, ppl_group_y_cell_argument_y_1_n, noise):
def ppl_pw_y_resp_group_cell(ppl_group_y_2, ppl_group_y_cell_argument_y_1_2, noise_2, active_cell):
def then_arm():
log_scale = jnp.log(noise_2)
standardized = (ppl_group_y_2 - ppl_group_y_cell_argument_y_1_2) / jnp.where(jnp.logical_and(noise_2 == 0, ppl_group_y_2 == ppl_group_y_cell_argument_y_1_2), 1.0, noise_2)
standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
return standard_logpdf - jnp.where(jnp.logical_and(noise_2 == 0, ppl_group_y_2 != ppl_group_y_cell_argument_y_1_2), 0.0, log_scale)
ppl_density = jax.lax.cond(noise_2 > 0, then_arm, lambda: -jnp.inf)
return ppl_density
ppl_pw_y_resp_group = (jnp.zeros(ppl_group_y.shape[:1], dtype=jnp.float64) if 0 in ppl_group_y.shape[:1] and ppl_group_y_cell_argument_y_1.shape[:1] == ppl_group_y.shape[:1] else jax.vmap(ppl_pw_y_resp_group_cell, in_axes=(0, 0, None, 0))(ppl_group_y, ppl_group_y_cell_argument_y_1, noise, jnp.logical_and(jnp.broadcast_to((jnp.arange(ppl_group_y.shape[0]) < ppl_group_y_n), ppl_group_y.shape[:1]), jnp.broadcast_to((jnp.arange(ppl_group_y_cell_argument_y_1.shape[0]) < ppl_group_y_cell_argument_y_1_n), ppl_group_y_cell_argument_y_1.shape[:1]))))
ppl_group_total = jnp.sum(jnp.where((jnp.arange(ppl_pw_y_resp_group.shape[0]) < ppl_group_y_n), ppl_pw_y_resp_group, 0.0))
return ppl_group_total
ppl_pw_y_resp_totals = (jnp.zeros(y.shape[:1], dtype=jnp.float64) if 0 in y.shape[:1] and y_cell_argument_y_1.shape[:1] == y.shape[:1] else jax.vmap(ppl_pw_y_resp_totals_cell, in_axes=(0, 0, 0, 0, None))(y, y_lengths, y_cell_argument_y_1, y_cell_rows_2_lengths[plate_argument - 1], constrain_3))
ppl_lik_y_resp = jnp.sum(ppl_pw_y_resp_totals)
if _entry in ("log_density",):
posterior = prior + ppl_lik_y_resp + log_jacobian_2
if not (unconstrained.size == ppl_last_b_rate_unit_unit_z):
raise ValueError("[layout] packed length ≠ layout total: a packed point holds the coordinates of the binding whose layout packed it")
if _entry == "log_density":
return jnp.asarray(posterior, dtype=jnp.float64)
if _entry == "log_prior":
return jnp.asarray(prior, dtype=jnp.float64)
if _entry == "log_likelihood":
return jnp.asarray(ppl_lik_y_resp, dtype=jnp.float64)
if _entry == "log_jacobian":
return jnp.asarray(log_jacobian_2, dtype=jnp.float64)
if _entry == "constrain":
return {"rate_Intercept": jnp.asarray(rate_Intercept, dtype=jnp.float64), "amplitude": jnp.asarray(constrain_2, dtype=jnp.float64), "noise": jnp.asarray(constrain_3, dtype=jnp.float64), "b_rate__unit_unit": {"tau": jnp.asarray(b_rate_unit_unit_tau), "z": jnp.asarray(b_rate_unit_unit_z)}}
def log_density(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
"""The log density a sampler targets at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`.
The sum of `log_prior`, `log_likelihood` and `log_jacobian`.
"""
return model("log_density", unconstrained, **prepared)
def log_prior(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
"""The log prior density of the constrained parameters at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
return model("log_prior", unconstrained, **prepared)
def log_likelihood(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
"""The log likelihood of the observations at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
return model("log_likelihood", unconstrained, **prepared)
def log_jacobian(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
"""The log Jacobian of the constraining transforms at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
return model("log_jacobian", unconstrained, **prepared)
def constrain(unconstrained: ArrayLike, **prepared: ArrayLike) -> dict:
"""The constrained value of each parameter, and of each requested value, at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`. Returns a dict, a submodel's values nested under its name:
- `rate_Intercept`
- `amplitude`
- `noise`
- `b_rate__unit_unit.tau`
- `b_rate__unit_unit.z`
"""
return model("constrain", unconstrained, **prepared)
def dimension(prepared: dict) -> int:
"""The length of `unconstrained` for the data `prepared` (what `prepare_data` returned)."""
return int(prepared["ppl_last_b_rate_unit_unit_z"])
def parameters(prepared: dict) -> dict:
"""Each parameter's 0-based `start`/`stop` in `unconstrained`, its transform and dimensions,
for the data `prepared` (what `prepare_data` returned)."""
return {"rate_Intercept": {"start": 0, "stop": 1, "transform": "identity", "dims": ()}, "amplitude": {"start": 1, "stop": 2, "transform": "exp", "dims": ()}, "noise": {"start": 2, "stop": 3, "transform": "exp", "dims": ()}, "b_rate__unit_unit.tau": {"start": 3, "stop": 4, "transform": "exp", "dims": (1,)}, "b_rate__unit_unit.z": {"start": 4, "stop": int(prepared["ppl_last_b_rate_unit_unit_z"]), "transform": "identity", "dims": (int(prepared["ppl_axis1_b_rate_unit_unit_z"]), 1)}}The loop follows the unit-level rate vector. Inside the cell, rate[i] is a unit's value, time[rows[i]] its observations, and bare amplitude is shared. Cell code uses Julia broadcasting explicitly. A bare left-hand name is local; an indexed left-hand name exposes a model output. Observe the response slice directly: an assignment that aliases it does not become a new observation.
For long-format series, @plate for p in groups(unit; order=time) iterates each unit's ordered row indices. An @scan within the cell states a recurrence; AR1Normal(mu[p], sigma, phi; time=time[p]) supplies an AR(1) residual law that accounts for gaps. Response families distinguishes residual dependence from a latent rw, dar or cdar term.
Reusable components
A function-style component gives each call its own parameters. Shared values are explicit arguments. This calibration is used twice with separate local intercepts and slopes.
Independent calls with a shared prior scale
panes: brm|stanblocks|rkppl|stan|jax:3"A calibration curve; every call owns its intercept and slope."
@brm function calibration(x, shared_scale)
value = a + b * x
a ~ Normal(0, shared_scale)
b ~ Normal(1, 0.2)
return value
end
joint = @brm begin
left ~ calibration(x_left, shared_scale)
right ~ calibration(x_right, shared_scale)
y_left ~ Normal(left, noise)
y_right ~ Normal(right, noise)
shared_scale ~ Exponential(1)
noise ~ Exponential(0.5)
end
model = joint((; x_left=[-0.4, 0.2, 0.7], x_right=[0.3, -0.2],
y_left=[0.1, 0.4, 0.8], y_right=[0.3, -0.1]))SBBRMI with data keys = [:x_left, :x_right, :y_left, :y_right]
emitted @slic body:
begin
shared_scale ~ exponential(1.0 ./ 1)
left ~ (SlicModel(untraced; inputs=0, statements=5))(; x = x_left, shared_scale = shared_scale)
right ~ (SlicModel(untraced; inputs=0, statements=5))(; x = x_right, shared_scale = shared_scale)
noise ~ exponential(1.0 ./ 0.5)
y_left ~ normal(left, noise)
y_right ~ normal(right, noise)
end"""
A calibration curve; every call owns its intercept and slope.
"""
left_component(x, shared_scale) = begin
b ~ Normal(1.0, 0.2)
a ~ Normal(0.0, shared_scale)
value = a .+ b .* x
component_result = value
return component_result
end
"""
A calibration curve; every call owns its intercept and slope.
"""
right_component(x, shared_scale) = begin
b ~ Normal(1.0, 0.2)
a ~ Normal(0.0, shared_scale)
value = a .+ b .* x
component_result = value
return component_result
end
begin
shared_scale ~ Exponential(1.0)
noise ~ Exponential(0.5)
Core.@doc "A calibration curve; every call owns its intercept and slope." left ~ left_component(x_left, shared_scale)
Core.@doc "A calibration curve; every call owns its intercept and slope." right ~ right_component(x_right, shared_scale)
y_left .~ Normal.(left, noise)
y_right .~ Normal.(right, noise)
endfunctions {
vector normal_lpdfs(
vector obs,
vector loc,
real scale
) {
return jbroadcasted_normal_lpdfs(obs, loc, scale);
}
vector jbroadcasted_normal_lpdfs(
vector x1,
vector x2,
real x3
) {
int n = dims(x1)[1];
vector[n] rv;
for(i in 1:n) {
rv[i] = normal_lpdfs(broadcasted_getindex(x1, i), broadcasted_getindex(x2, i), x3);
}
return rv;
}
real normal_lpdfs(
real args1,
real args2,
real args3
) {
return normal_lpdf(args1 | args2, args3);
}
real broadcasted_getindex(vector x, int i) {
return x[i];
}
vector normal_vector_rng(
int anontok__1,
vector a,
real b
) {
int n = anontok__1;
if((n == 0)) {
vector[n] rv;
return rv;
} else {
return to_vector(normal_rng(a, b));
}
}
}
data {
int x_left_n;
vector[x_left_n] x_left;
int x_right_n;
vector[x_right_n] x_right;
int y_left_n;
vector[y_left_n] y_left;
int y_right_n;
vector[y_right_n] y_right;
}
transformed data {
}
parameters {
real<lower=0.0> shared_scale;
real left_b;
real left_a;
real right_b;
real right_a;
real<lower=0.0> noise;
}
transformed parameters {
vector[x_left_n] left_value = (left_a + (left_b .* x_left));
vector[x_left_n] left_component_result = left_value;
vector[x_left_n] left = left_component_result;
vector[x_right_n] right_value = (right_a + (right_b .* x_right));
vector[x_right_n] right_component_result = right_value;
vector[x_right_n] right = right_component_result;
}
model {
shared_scale ~ exponential((1.0 ./ 1));
left_b ~ normal(1, 0.2);
left_a ~ normal(0, shared_scale);
right_b ~ normal(1, 0.2);
right_a ~ normal(0, shared_scale);
noise ~ exponential((1.0 ./ 0.5));
y_left ~ normal(left, noise);
y_right ~ normal(right, noise);
}
generated quantities {
vector[y_left_n] y_left_likelihood = normal_lpdfs(y_left, left, noise);
vector[y_left_n] y_left_gen = normal_vector_rng(y_left_n, left, noise);
vector[y_right_n] y_right_likelihood = normal_lpdfs(y_right, right, noise);
vector[y_right_n] y_right_gen = normal_vector_rng(y_right_n, right, noise);
}using ReactiveKernels, ReactiveKernelsPPL
rk = RKBRMI(model)
source = jax_source(rk.model, rk_bound_plan(rk))
write("model.py", source)
inputs = rk_bound_data(rk, source) # exactly the inputs prepare_data readsimport jax
import model as m
prepared = m.prepare_data(**inputs)
lp = m.log_density(u, **prepared) # u: unconstrained, length m.dimension(prepared)
lp = jax.jit(m.log_density)(u, **prepared) # one compiled function for every dataset of these shapes"""Generated by ReactiveKernelsPPL.jax_source from a built @rkppl program; do not edit.
Data: x_left, x_right, y_left, y_right.
Model documentation:
- `left`: A calibration curve; every call owns its intercept and slope.
- `right`: A calibration curve; every call owns its intercept and slope.
- `left`: A calibration curve; every call owns its intercept and slope.
- `right`: A calibration curve; every call owns its intercept and slope.
"""
import numpy as np
import scipy.special as ssp
from typing import Any
import jax
import jax.numpy as jnp
import jax.scipy.linalg
import jax.scipy.special as jsp
from jax.typing import ArrayLike
jax.config.update("jax_enable_x64", True)
DIMENSION = 6
PARAMETERS = {"shared_scale": {"start": 0, "stop": 1, "transform": "exp", "dims": ()}, "noise": {"start": 1, "stop": 2, "transform": "exp", "dims": ()}, "left.b": {"start": 2, "stop": 3, "transform": "identity", "dims": ()}, "left.a": {"start": 3, "stop": 4, "transform": "identity", "dims": ()}, "right.b": {"start": 4, "stop": 5, "transform": "identity", "dims": ()}, "right.a": {"start": 5, "stop": 6, "transform": "identity", "dims": ()}}
DATA = {"x_left": {"dtype": "float64", "ndim": 1, "ragged": False}, "x_right": {"dtype": "float64", "ndim": 1, "ragged": False}, "y_left": {"dtype": "float64", "ndim": 1, "ragged": False}, "y_right": {"dtype": "float64", "ndim": 1, "ragged": False}}
INPUTS = ("unconstrained", "x_left", "x_right", "y_left", "y_right")
PREPARED = {"x_left": {"dtype": "float64", "ndim": 1, "ragged": False}, "x_right": {"dtype": "float64", "ndim": 1, "ragged": False}, "y_left": {"dtype": "float64", "ndim": 1, "ragged": False}, "y_right": {"dtype": "float64", "ndim": 1, "ragged": False}}
UNTRANSLATED = {}
def _log_of(x: ArrayLike) -> jax.Array:
"""Compute `_rk_log_of` from its authored source."""
return jnp.asarray(x, dtype=jnp.float64)
def left_component(
a: ArrayLike,
b: ArrayLike,
shared_scale: ArrayLike,
u_argument: ArrayLike,
x: ArrayLike,
*,
outputs: tuple[str, ...],
) -> dict:
"""A calibration curve; every call owns its intercept and slope."""
results = {}
if any(name in outputs for name in ("value",)):
def value_cell(a_2, b_2, x_2):
plate_value = a_2 + b_2 * x_2
return plate_value
value = (jnp.zeros(x.shape[:1], dtype=jnp.float64) if 0 in x.shape[:1] else jax.vmap(value_cell, in_axes=(None, None, 0))(a, b, x))
if any(name in outputs for name in ("ppl_prior_a", "ppl_prior_a_location", "ppl_prior_a_standard_logpdf")):
ppl_prior_a_location = 0.0
if any(name in outputs for name in ("ppl_prior_a", "ppl_prior_a_log_scale")):
log_of = _log_of(u_argument)
ppl_prior_a_log_scale = log_of
if any(name in outputs for name in ("ppl_prior_a", "ppl_prior_a_standard_logpdf")):
ppl_prior_a_logpdf_z = (a - ppl_prior_a_location) / jnp.where(jnp.logical_and(shared_scale == 0, a == ppl_prior_a_location), 1.0, shared_scale)
ppl_prior_a_standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * ppl_prior_a_logpdf_z ** 2
if any(name in outputs for name in ("ppl_prior_a",)):
ppl_prior_a = ppl_prior_a_standard_logpdf - jnp.where(jnp.logical_and(shared_scale == 0, a != ppl_prior_a_location), 0.0, ppl_prior_a_log_scale)
if "ppl_prior_a" in outputs:
results["ppl_prior_a"] = ppl_prior_a
if "ppl_prior_a_location" in outputs:
results["ppl_prior_a_location"] = ppl_prior_a_location
if "ppl_prior_a_log_scale" in outputs:
results["ppl_prior_a_log_scale"] = ppl_prior_a_log_scale
if "ppl_prior_a_standard_logpdf" in outputs:
results["ppl_prior_a_standard_logpdf"] = ppl_prior_a_standard_logpdf
if "value" in outputs:
results["value"] = value
return results
def prepare_data(x_left: ArrayLike, x_right: ArrayLike, y_left: ArrayLike, y_right: ArrayLike) -> dict:
"""The functions' data inputs, computed from the raw data once per dataset.
Pass the data by the names the model reads them; a list of arrays is a ragged
column. Call the other functions with the result: `f(u, **prepared)`.
"""
x_left = np.asarray(x_left, dtype=np.float64)
x_right = np.asarray(x_right, dtype=np.float64)
y_left = np.asarray(y_left, dtype=np.float64)
y_right = np.asarray(y_right, dtype=np.float64)
return {"x_left": np.asarray(x_left, dtype=np.float64), "x_right": np.asarray(x_right, dtype=np.float64), "y_left": np.asarray(y_left, dtype=np.float64), "y_right": np.asarray(y_right, dtype=np.float64)}
def model(_entry: str, unconstrained: ArrayLike, **prepared: ArrayLike) -> Any:
"""Shared model computation. The generated entry wrappers select a static output."""
x_left = prepared["x_left"]
x_right = prepared["x_right"]
y_left = prepared["y_left"]
y_right = prepared["y_right"]
unconstrained = jnp.asarray(unconstrained)
x_left = jnp.asarray(x_left)
x_right = jnp.asarray(x_right)
y_left = jnp.asarray(y_left)
y_right = jnp.asarray(y_right)
if _entry in ("log_density", "log_prior", "constrain"):
u_argument = unconstrained[0]
constrain_2 = jnp.exp(u_argument)
if _entry in ("log_density", "log_prior", "log_likelihood", "constrain"):
u_argument_2 = unconstrained[1]
constrain_3 = jnp.exp(u_argument_2)
left_b = unconstrained[2]
left_a = unconstrained[3]
if _entry in ("log_density", "log_prior", "log_likelihood"):
left = left_component(
a=(left_a if _entry in ("log_density", "log_prior", "log_likelihood") else None),
b=(left_b if _entry in ("log_density", "log_likelihood") else None),
shared_scale=(constrain_2 if _entry in ("log_density", "log_prior") else None),
u_argument=(u_argument if _entry in ("log_density", "log_prior") else None),
x=(x_left if _entry in ("log_density", "log_likelihood") else None),
outputs=tuple(
name for name, needed in (
("ppl_prior_a", ("log_density", "log_prior")),
("ppl_prior_a_location", ("log_density", "log_prior")),
("ppl_prior_a_log_scale", ("log_density", "log_prior")),
("ppl_prior_a_standard_logpdf", ("log_density", "log_prior")),
("value", ("log_density", "log_likelihood")),
)
if _entry in needed
),
)
if _entry in ("log_density", "log_prior", "log_likelihood", "constrain"):
right_b = unconstrained[4]
right_a = unconstrained[5]
if _entry in ("log_density", "log_likelihood"):
def right_value_cell(right_a_2, right_b_2, x_right_2):
plate_value = right_a_2 + right_b_2 * x_right_2
return plate_value
right_value = (jnp.zeros(x_right.shape[:1], dtype=jnp.float64) if 0 in x_right.shape[:1] else jax.vmap(right_value_cell, in_axes=(None, None, 0))(right_a, right_b, x_right))
def ppl_pw_y_left_resp_cell(y_left_2, left_2, noise):
def then_arm():
log_scale = jnp.log(noise)
standardized = (y_left_2 - left_2) / jnp.where(jnp.logical_and(noise == 0, y_left_2 == left_2), 1.0, noise)
standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
return standard_logpdf - jnp.where(jnp.logical_and(noise == 0, y_left_2 != left_2), 0.0, log_scale)
ppl_density = jax.lax.cond(noise > 0, then_arm, lambda: -jnp.inf)
return ppl_density
ppl_pw_y_left_resp = (jnp.zeros(y_left.shape[:1], dtype=jnp.float64) if 0 in y_left.shape[:1] and left["value"].shape[:1] == y_left.shape[:1] else jax.vmap(ppl_pw_y_left_resp_cell, in_axes=(0, 0, None))(y_left, left["value"], constrain_3))
ppl_lik_y_left_resp = jnp.sum(ppl_pw_y_left_resp)
def ppl_pw_y_right_resp_cell(y_right_2, right, noise):
def then_arm():
log_scale = jnp.log(noise)
standardized = (y_right_2 - right) / jnp.where(jnp.logical_and(noise == 0, y_right_2 == right), 1.0, noise)
standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
return standard_logpdf - jnp.where(jnp.logical_and(noise == 0, y_right_2 != right), 0.0, log_scale)
ppl_density = jax.lax.cond(noise > 0, then_arm, lambda: -jnp.inf)
return ppl_density
ppl_pw_y_right_resp = (jnp.zeros(y_right.shape[:1], dtype=jnp.float64) if 0 in y_right.shape[:1] and right_value.shape[:1] == y_right.shape[:1] else jax.vmap(ppl_pw_y_right_resp_cell, in_axes=(0, 0, None))(y_right, right_value, constrain_3))
ppl_lik_y_right_resp = jnp.sum(ppl_pw_y_right_resp)
likelihood = ppl_lik_y_left_resp + ppl_lik_y_right_resp
if _entry in ("log_density", "log_prior"):
ppl_prior_parameters_normal_mu = jnp.asarray([1.0, 1.0], dtype=jnp.float64)
ppl_prior_parameters_normal_sd = jnp.asarray([0.2, 0.2], dtype=jnp.float64)
plate_argument = (left_b, right_b)
def ppl_prior_parameters_normal_pw_cell(value, location, scale):
log_scale = jnp.log(scale)
standardized = (value - location) / jnp.where(jnp.logical_and(scale == 0, value == location), 1.0, scale)
standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
logpdf = standard_logpdf - jnp.where(jnp.logical_and(scale == 0, value != location), 0.0, log_scale)
return logpdf
ppl_prior_parameters_normal_pw = (jnp.zeros(jnp.stack(plate_argument).shape[:1], dtype=jnp.float64) if 0 in jnp.stack(plate_argument).shape[:1] and ppl_prior_parameters_normal_mu.shape[:1] == jnp.stack(plate_argument).shape[:1] and ppl_prior_parameters_normal_sd.shape[:1] == jnp.stack(plate_argument).shape[:1] else jax.vmap(ppl_prior_parameters_normal_pw_cell, in_axes=(0, 0, 0))(jnp.stack(plate_argument), ppl_prior_parameters_normal_mu, ppl_prior_parameters_normal_sd))
ppl_prior_parameters_normal = jnp.sum(ppl_prior_parameters_normal_pw)
ppl_prior_shared_scale_log_scale = np.log(1.0)
logpdf = jax.lax.cond(constrain_2 < 0, lambda: -jnp.inf, lambda: -ppl_prior_shared_scale_log_scale - constrain_2 / 1.0)
ppl_prior_noise_log_scale = np.log(0.5)
logpdf_2 = jax.lax.cond(constrain_3 < 0, lambda: -jnp.inf, lambda: -ppl_prior_noise_log_scale - constrain_3 / 0.5)
ppl_prior_right_a_standardized = (right_a - 0.0) / jnp.where(jnp.logical_and(constrain_2 == 0, right_a == 0.0), 1.0, constrain_2)
ppl_prior_right_a_standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * ppl_prior_right_a_standardized ** 2
logpdf_3 = ppl_prior_right_a_standard_logpdf - jax.lax.cond(jnp.logical_and(constrain_2 == 0, right_a != 0.0), lambda: 0.0, lambda: left["ppl_prior_a_log_scale"])
prior = ppl_prior_parameters_normal + logpdf + logpdf_2 + left["ppl_prior_a"] + logpdf_3
if _entry in ("log_density", "log_jacobian"):
u_argument_3 = unconstrained[0]
u_argument_4 = unconstrained[1]
log_jacobian_2 = u_argument_3 + u_argument_4
if _entry in ("log_density",):
posterior = prior + likelihood + log_jacobian_2
if not (unconstrained.size == 6):
raise ValueError("[layout] packed length ≠ layout total: a packed point holds the coordinates of the binding whose layout packed it")
if _entry == "log_density":
return jnp.asarray(posterior, dtype=jnp.float64)
if _entry == "log_prior":
return jnp.asarray(prior, dtype=jnp.float64)
if _entry == "log_likelihood":
return jnp.asarray(likelihood, dtype=jnp.float64)
if _entry == "log_jacobian":
return jnp.asarray(log_jacobian_2, dtype=jnp.float64)
if _entry == "constrain":
return {"shared_scale": jnp.asarray(constrain_2, dtype=jnp.float64), "noise": jnp.asarray(constrain_3, dtype=jnp.float64), "left": {"b": jnp.asarray(left_b, dtype=jnp.float64), "a": jnp.asarray(left_a, dtype=jnp.float64)}, "right": {"b": jnp.asarray(right_b, dtype=jnp.float64), "a": jnp.asarray(right_a, dtype=jnp.float64)}}
def log_density(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
"""The log density a sampler targets at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`.
The sum of `log_prior`, `log_likelihood` and `log_jacobian`.
"""
return model("log_density", unconstrained, **prepared)
def log_prior(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
"""The log prior density of the constrained parameters at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
return model("log_prior", unconstrained, **prepared)
def log_likelihood(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
"""The log likelihood of the observations at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
return model("log_likelihood", unconstrained, **prepared)
def log_jacobian(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
"""The log Jacobian of the constraining transforms at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
return model("log_jacobian", unconstrained, **prepared)
def constrain(unconstrained: ArrayLike, **prepared: ArrayLike) -> dict:
"""The constrained value of each parameter, and of each requested value, at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`. Returns a dict, a submodel's values nested under its name:
- `shared_scale`
- `noise`
- `left.b`
- `left.a`
- `right.b`
- `right.a`
"""
return model("constrain", unconstrained, **prepared)
def dimension(prepared: dict) -> int:
"""The length of `unconstrained` for the data `prepared` (what `prepare_data` returned)."""
return 6
def parameters(prepared: dict) -> dict:
"""Each parameter's 0-based `start`/`stop` in `unconstrained`, its transform and dimensions,
for the data `prepared` (what `prepare_data` returned)."""
return {"shared_scale": {"start": 0, "stop": 1, "transform": "exp", "dims": ()}, "noise": {"start": 1, "stop": 2, "transform": "exp", "dims": ()}, "left.b": {"start": 2, "stop": 3, "transform": "identity", "dims": ()}, "left.a": {"start": 3, "stop": 4, "transform": "identity", "dims": ()}, "right.b": {"start": 4, "stop": 5, "transform": "identity", "dims": ()}, "right.a": {"start": 5, "stop": 6, "transform": "identity", "dims": ()}}using BayesianRegressionModels
model = Main.BRMDocsComparisons.example_module(:ComponentGuide).model
calls = brm_components(model)
@assert length(calls) == 2
[call.path for call in calls](:left,)(:right,)
Components accept positional and keyword inputs, including defaults, and resolve functions in their defining module. A named return such as return (; recovery, decay) exposes kin.recovery and kin.decay after kin ~ kinetics(...). Before indexing a returned field in a plate, bind it at model scope, recovery = kin.recovery, then read recovery[i]. brm_components discovers the definitions and call paths; descriptor queries use submodel=:left rather than generated names.
Use merge(structure_a, structure_b, priors_a, priors_b) for fragments that share one namespace. Put structure first and priors last within each scope; moving a cell-local prior outside the plate changes the model. A retained builder can bind new data; reprocess(backend, new_data) instead preserves the fit's preprocessing. These are different operations.
The Warfarin example combines group predictors, nonlinear time courses and observations on several axes.