Struct GammaVI 

pub struct GammaVI {
    pub dim: usize,
    pub log_shape: Array1<f64>,
    pub log_rate: Array1<f64>,
}

Variational family using a Gamma distribution for positive-valued variables

z_i ~ Gamma(shape_i, rate_i), i.e., with mean shape_i/rate_i.

Parameters stored as [log_shape_0, …, log_shape_{d-1}, log_rate_0, …, log_rate_{d-1}]

Reparameterization: uses the Marsaglia-Tsang approach.

Fields

dim: usize

Dimension of the latent variable

log_shape: Array1<f64>

Log shape parameters: log_shape_i (shape_i = exp(log_shape_i) > 0)

log_rate: Array1<f64>

Log rate parameters: log_rate_i (rate_i = exp(log_rate_i) > 0)

Implementations

impl GammaVI

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

Create a new Gamma variational family

Initializes with shape=1, rate=1 (standard exponential).

pub fn from_shape_rate(shape: Array1<f64>, rate: Array1<f64>) -> Result<Self>

Create from explicit shape and rate parameters (both must be > 0)

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

Get shape parameters

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

Get rate parameters

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

Compute the mean E[z_i] = shape_i / rate_i

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

Compute the variance Var[z_i] = shape_i / rate_i^2

pub fn kl_to_gamma_prior( &self, shape0: &Array1<f64>, rate0: &Array1<f64>, ) -> Result<f64>

Compute KL(Gamma(a,b) || Gamma(a0, b0)) analytically.

KL = (a-a0)psi(a) - lgamma(a) + lgamma(a0) + a0(ln(b) - ln(b0)) + a*(b0/b - 1)

Trait Implementations

impl Clone for GammaVI

fn clone(&self) -> GammaVI

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GammaVI

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

Formats the value using the given formatter.

impl VariationalFamily for GammaVI

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.