Struct potpourri::backend::ndarray::finite::Finite

pub struct Finite {
    pub prior: Option<f64>,
    pub pmf: Array1<f64>,
    /* private fields */
}

Fields

prior: Option<f64>

pmf: Array1<f64>

Implementations

impl Finite

pub fn new(prior: Option<f64>) -> Finite

Trait Implementations

impl Clone for Finite

fn clone(&self) -> Finite

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Finite

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

Formats the value using the given formatter.

impl Latent<Finite> for Finite

FIXME compute the likelihood.. is it just the sum of all?

fn expect( &self, data: &<Finite as Parametrizable>::DataIn<'_>, likelihood_b: &<Finite as Parametrizable>::Likelihood ) -> Result<(<Finite as Parametrizable>::Likelihood, AvgLLH), Error>

impl Parametrizable for Finite

type SufficientStatistics = ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>

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 predict(&self, _data: &Self::DataIn<'_>) -> Result<Self::DataOut, Error>

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.