Struct potpourri::mixture::Mixture

pub struct Mixture<T, L>where
    T: Parametrizable<Likelihood = L::Likelihood>,
    L: Parametrizable + Latent<L>,{
    pub mixables: T,
    pub latent: L,
}

This trait represents the traditional mixture models with an underlying probability density (as opposed to k-means or SOM). They have a soft assignment, that is, for each sample and each component the likelihood is computed that the sample belongs to the component. The alternative is that a sample can only belong to one of the compent alone.

Warning: we don’t enforce trait bounds here due to a possible compiler bug

Warning: Mixables have to compute the log-likelihood in the expectation step!

Fields

mixables: T

latent: L

Implementations

impl<T, L> Mixture<T, L>where T: Parametrizable<Likelihood = L::Likelihood>, L: Parametrizable + Latent<L>,

pub fn new(mixables: T, latent: L) -> Self

Trait Implementations

impl<T, L> Clone for Mixture<T, L>where T: Parametrizable<Likelihood = L::Likelihood> + Clone, L: Parametrizable + Latent<L> + Clone,

fn clone(&self) -> Mixture<T, L>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, L> Debug for Mixture<T, L>where T: Parametrizable<Likelihood = L::Likelihood> + Debug, L: Parametrizable + Latent<L> + Debug,

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

Formats the value using the given formatter.

impl<T, L> Parametrizable for Mixture<T, L>where T: for<'a> Parametrizable<Likelihood = L::Likelihood, DataIn<'a> = L::DataIn<'a>> + Mixable<T>, L: Parametrizable + Latent<L>,

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

Prediction can be classification or regression depending on the implementation.

type SufficientStatistics = (<L as Parametrizable>::SufficientStatistics, <T as Parametrizable>::SufficientStatistics)

type Likelihood = <T as Parametrizable>::Likelihood

type DataIn<'a> = <T as Parametrizable>::DataIn<'a>

type DataOut = <T as Parametrizable>::DataOut

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 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.