hmm.hpp

Go to the documentation of this file.

#ifndef MLPACK_METHODS_HMM_HMM_HPP
#define MLPACK_METHODS_HMM_HMM_HPP

#include <mlpack/prereqs.hpp>
#include <mlpack/core/dists/discrete_distribution.hpp>

namespace mlpack {
namespace hmm  {

template<typename Distribution = distribution::DiscreteDistribution>
class HMM
{
 public:
  HMM(const size_t states = 0,
      const Distribution emissions = Distribution(),
      const double tolerance = 1e-5);

  HMM(const arma::vec& initial,
      const arma::mat& transition,
      const std::vector<Distribution>& emission,
      const double tolerance = 1e-5);

  double Train(const std::vector<arma::mat>& dataSeq);

  void Train(const std::vector<arma::mat>& dataSeq,
             const std::vector<arma::Row<size_t> >& stateSeq);

  double LogEstimate(const arma::mat& dataSeq,
                     arma::mat& stateLogProb,
                     arma::mat& forwardLogProb,
                     arma::mat& backwardLogProb,
                     arma::vec& logScales) const;

  double Estimate(const arma::mat& dataSeq,
                  arma::mat& stateProb,
                  arma::mat& forwardProb,
                  arma::mat& backwardProb,
                  arma::vec& scales) const;

  double Estimate(const arma::mat& dataSeq,
                  arma::mat& stateProb) const;

  void Generate(const size_t length,
                arma::mat& dataSequence,
                arma::Row<size_t>& stateSequence,
                const size_t startState = 0) const;

  double Predict(const arma::mat& dataSeq,
                 arma::Row<size_t>& stateSeq) const;

  double LogLikelihood(const arma::mat& dataSeq) const;

  void Filter(const arma::mat& dataSeq,
              arma::mat& filterSeq,
              size_t ahead = 0) const;

  void Smooth(const arma::mat& dataSeq,
              arma::mat& smoothSeq) const;

  const arma::vec& Initial() const { return initialProxy; }
  arma::vec& Initial()
  {
    recalculateInitial = true;
    return initialProxy;
  }

  const arma::mat& Transition() const { return transitionProxy; }
  arma::mat& Transition()
  {
    recalculateTransition = true;
    return transitionProxy;
  }

  const std::vector<Distribution>& Emission() const { return emission; }
  std::vector<Distribution>& Emission() { return emission; }

  size_t Dimensionality() const { return dimensionality; }
  size_t& Dimensionality() { return dimensionality; }

  double Tolerance() const { return tolerance; }
  double& Tolerance() { return tolerance; }

  template<typename Archive>
  void load(Archive& ar, const unsigned int version);

  template<typename Archive>
  void save(Archive& ar, const unsigned int version) const;

  BOOST_SERIALIZATION_SPLIT_MEMBER();


 protected:
  // Helper functions.
  void Forward(const arma::mat& dataSeq,
               arma::vec& logScales,
               arma::mat& forwardLogProb) const;

  void Backward(const arma::mat& dataSeq,
                const arma::vec& logScales,
                arma::mat& backwardLogProb) const;

  std::vector<Distribution> emission;

  arma::mat transitionProxy;

  mutable arma::mat logTransition;

 private:
  void ConvertToLogSpace() const;

  arma::vec initialProxy;

  mutable arma::vec logInitial;

  size_t dimensionality;

  double tolerance;

  mutable bool recalculateInitial;

  mutable bool recalculateTransition;
};

} // namespace hmm
} // namespace mlpack

// Include implementation.
#include "hmm_impl.hpp"

#endif