Struct BetaVI 

pub struct BetaVI {
    pub dim: usize,
    pub log_alpha: Array1<f64>,
    pub log_beta: Array1<f64>,
}

Variational family using a Beta distribution for probability-valued variables in [0,1]

z_i ~ Beta(alpha_i, beta_i) independently.

Parameterization: we store log(alpha_i) and log(beta_i) so that alpha, beta > 0.

Note: The reparameterization trick for Beta is approximate; we use the Kumaraswamy distribution as a surrogate (which has a simple inverse CDF). The entropy and log_prob use the exact Beta formulas.

Parameters (stored in flat form): [log_alpha_0, …, log_alpha_{d-1}, log_beta_0, …, log_beta_{d-1}]

Fields

dim: usize

Dimension of the latent variable

log_alpha: Array1<f64>

Log concentration parameters: log_alpha_i (alpha_i = exp(log_alpha_i) > 0)

log_beta: Array1<f64>

Log concentration parameters: log_beta_i (beta_i = exp(log_beta_i) > 0)

Implementations

impl BetaVI

pub fn new(dim: usize) -> Result<Self>

Create a new Beta variational family

Initializes with alpha=1, beta=1 (uniform distribution).

pub fn from_alpha_beta(alpha: Array1<f64>, beta: Array1<f64>) -> Result<Self>

Create from explicit alpha and beta parameters (both must be > 0)

pub fn alphas(&self) -> Array1<f64>

Get alpha parameters

pub fn betas(&self) -> Array1<f64>

Get beta parameters

pub fn means(&self) -> Array1<f64>

Compute the mean E[z_i] = alpha_i / (alpha_i + beta_i)

pub fn variances(&self) -> Array1<f64>

Compute the variance Var[z_i] = alphabeta / ((alpha+beta)^2(alpha+beta+1))

pub fn kl_to_uniform(&self) -> f64

Compute KL divergence to the uniform prior Beta(1,1) analytically.

KL(Beta(a,b) || Uniform) = KL(Beta(a,b) || Beta(1,1)) = sum_i [(a_i-1)*psi(a_i) + (b_i-1)*psi(b_i) - (a_i+b_i-2)*psi(a_i+b_i) + log_B(1,1) - log_B(a_i, b_i)]

where log_B(a,b) = lgamma(a) + lgamma(b) - lgamma(a+b), and log_B(1,1) = 0.

pub fn kl_to_beta_prior( &self, alpha0: &Array1<f64>, beta0: &Array1<f64>, ) -> Result<f64>

Compute KL divergence to Beta(alpha0, beta0) prior analytically.

KL(Beta(a,b) || Beta(a0,b0)) = log_B(a0,b0) - log_B(a,b)

• (a-a0)*psi(a) + (b-b0)*psi(b) - (a+b-a0-b0)*psi(a+b)

Trait Implementations

impl Clone for BetaVI

fn clone(&self) -> BetaVI

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BetaVI

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl VariationalFamily for BetaVI

fn dim(&self) -> usize

Dimensionality of the latent variable z

fn n_params(&self) -> usize

Number of variational parameters

fn get_params(&self) -> Array1<f64>

Get current variational parameters as a flat vector

fn set_params(&mut self, params: &Array1<f64>) -> Result<()>

Set variational parameters from a flat vector

fn sample_reparam(&self, epsilon: &Array1<f64>) -> Result<(Array1<f64>, f64)>

Sample using the reparameterization trick: z = f(epsilon; phi), where epsilon ~ base_noise_distribution

fn entropy(&self) -> f64

Compute the differential entropy H[q] = -E_q[log q(z)]

fn log_prob(&self, z: &Array1<f64>) -> Result<f64>

Compute log q(z; phi) for a given sample z

fn reparam_gradient( &self, dlog_joint_dz: &Array1<f64>, epsilon: &Array1<f64>, ) -> Result<Array1<f64>>

Compute the gradient of the ELBO w.r.t. parameters using reparameterization.

fn kl_from_prior(&self) -> Option<f64>

Compute KL divergence KL(q || p) where p is a standard prior.