Struct potpourri::backend::ndarray::gaussian::Gaussian

pub struct Gaussian {
    pub means: Array2<f64>,
    pub covariances: Array3<f64>,
    pub precisions: Array3<f64>,
    pub summands: Array1<f64>,
    /* private fields */
}

Represents a gaussian mixture model. The number of components is determined automatically from the responsibilities when first calling maximize method.

The sufficient statistics that can be extracted from the data to maximize the parameters. It is a triple of arrays (names as in Kimura et al.):

$$ \begin{aligned} a_j &= \sum_i^n r_{ij},&& (k) \\ b_j &= \sum_i^n r_{ij} \cdot x_i ,&& (k \times d) \\ c_j &= \sum_i^n r_{ij} \cdot x_i^T\cdot x_i, &&(k \times d \times d) \\ \end{aligned} $$

Fields

means: Array2<f64>

The mean values, $ k\times d $

covariances: Array3<f64>

The covariance matrices), $(k\times d\times d)$

precisions: Array3<f64>

The precision matrices (inverted coariances), $(k\times d\times d)$

summands: Array1<f64>

Implementations

impl Gaussian

pub fn new() -> Gaussian

Trait Implementations

impl Clone for Gaussian

fn clone(&self) -> Gaussian

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Gaussian

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

Formats the value using the given formatter.

impl Default for Gaussian

fn default() -> Gaussian

Returns the “default value” for a type.

impl Mixable<Gaussian> for Gaussian

fn predict( &self, _latent_likelihood: <Gaussian as Parametrizable>::Likelihood, _data: &<Gaussian as Parametrizable>::DataIn<'_> ) -> Result<<Gaussian as Parametrizable>::DataOut, Error>

impl Parametrizable for Gaussian

type SufficientStatistics = (ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, ArrayBase<OwnedRepr<f64>, Dim<[usize; 3]>>)

type Likelihood = ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>

type DataIn<'a> = ArrayBase<ViewRepr<&'a f64>, Dim<[usize; 2]>>

type DataOut = ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>

fn expect( &self, data: &Self::DataIn<'_> ) -> Result<(Self::Likelihood, AvgLLH), Error>

The E-Step. Computes the likelihood for each component in the mixture Note that for Mixables, this is the log-likelihood

fn compute( &self, data: &Self::DataIn<'_>, responsibilities: &Self::Likelihood ) -> Result<Self::SufficientStatistics, Error>

Computes the sufficient statistics from the responsibility matrix. The Optionally, stores the sufficient statistics (for incremental learning and store.restore functionality) can be disabled for performance (defaults to True)

fn maximize( &mut self, sufficient_statistics: &Self::SufficientStatistics ) -> Result<(), Error>

Maximize the model parameters from

fn update( &mut self, sufficient_statistics: &Self::SufficientStatistics, weight: f64 ) -> Result<(), Error>

Update the stored sufficient statistics (for incremental learning) Weights is a tuple (a float should suffice, if summing to one)

fn merge( sufficient_statistics: &[&Self::SufficientStatistics], weights: &[f64] ) -> Result<Self::SufficientStatistics, Error>

merge multiple sufficient statistics into one.

fn predict(&self, _data: &Self::DataIn<'_>) -> Result<Self::DataOut, Error>

fn expect_rand( &self, _data: &Self::DataIn<'_>, _k: usize ) -> Result<Self::Likelihood, Error>

Generate a random expectation. Used as an initalization. It is recommended to draw the expectations from a univorm Dirichlet distribution. Note: This works better than an initialization method, because the layers such as the Probabilistic trait don’t need to implement backend-specific random samplers.