Struct HiddenMarkovModel 

pub struct HiddenMarkovModel<S> { /* private fields */ }

A finite hidden Markov model with inspectable transition and emission rows.

Implementations

impl<S: Eq + Clone> HiddenMarkovModel<S>

pub fn discrete( states: Vec<S>, initial: Vec<f64>, transitions: Vec<Vec<f64>>, emissions: Vec<Vec<f64>>, ) -> Result<Self, HmmError>

Builds a model with categorical observations indexed from zero.

Examples found in repository

examples/bounded_sequence_inference.rs (lines 24-29)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let policy = QuantilePolicy::new(0.02, 8, 256)?;
    let mut left = QuantileSketch::new(policy.clone())?;
    let mut right = QuantileSketch::new(policy)?;
    for value in 0..100 {
        if value % 2 == 0 {
            left.insert(value as f64)?;
        } else {
            right.insert(value as f64)?;
        }
    }
    left.merge(&right)?;
    let median = left.estimate(0.5)?;
    println!(
        "quantile value={} rank=[{:.3},{:.3}] retained={} exact={}",
        median.value, median.rank_lower, median.rank_upper, median.retained_entries, median.exact
    );

    let model = HiddenMarkovModel::discrete(
        vec!["quiet", "active"],
        vec![0.6, 0.4],
        vec![vec![0.8, 0.2], vec![0.3, 0.7]],
        vec![vec![0.9, 0.1], vec![0.2, 0.8]],
    )?;
    let observations = [0, 0, 1, 1];
    let inference = forward_backward(&model, &observations)?;
    let path = viterbi(&model, &observations)?;
    println!(
        "inference log-likelihood={:.6} path={:?} repairs={}",
        inference.evidence.log_likelihood, path.states, inference.evidence.numerical_repairs
    );

    let data = [
        Sequence::Discrete(vec![0, 0, 1, 1, 1, 0]),
        Sequence::Discrete(vec![0, 1, 1, 0, 0, 0]),
    ];
    let report = fit_hmm(
        &data,
        HmmSpec::Discrete {
            states: 2,
            symbols: 2,
            additive_smoothing: 1.0e-6,
        },
        HmmFitControl::new(23, 6, 1.0e-7, 10_000, 1.0e-12)?,
    )?;
    println!(
        "fit likelihood={:.6} iterations={} converged={} repairs={} work={} termination={:?} seed={}",
        report.evidence.log_likelihood,
        report.evidence.iterations,
        report.evidence.converged,
        report.evidence.numerical_repairs,
        report.evidence.work,
        report.evidence.termination,
        report.evidence.seed
    );
    Ok(())
}

pub fn gaussian( states: Vec<S>, initial: Vec<f64>, transitions: Vec<Vec<f64>>, means: Vec<f64>, variances: Vec<f64>, variance_floor: f64, ) -> Result<Self, HmmError>

Builds a model with scalar Gaussian observations.

pub fn from_transition_matrix( initial: Vec<f64>, transitions: FiniteTransitionMatrix<S>, emissions: EmissionModel, ) -> Result<Self, HmmError>

Builds a model from the same finite transition representation exposed by crate::MarkovModel::transition_matrix.

pub fn states(&self) -> &[S]

Returns the ordered hidden-state vocabulary.

pub fn initial_probabilities(&self) -> &[f64]

Returns the normalized initial-state probabilities.

pub fn transitions(&self) -> &FiniteTransitionMatrix<S>

Returns the shared finite transition representation.

pub fn emissions(&self) -> &EmissionModel

Returns the categorical or Gaussian emission representation.

Trait Implementations

impl<S: Clone> Clone for HiddenMarkovModel<S>

fn clone(&self) -> HiddenMarkovModel<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for HiddenMarkovModel<S>

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

Formats the value using the given formatter.

impl<S: PartialEq> PartialEq for HiddenMarkovModel<S>

fn eq(&self, other: &HiddenMarkovModel<S>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<S: PartialEq> StructuralPartialEq for HiddenMarkovModel<S>