discreteHMM.h

Go to the documentation of this file.

/* MLPACK 0.2
 *
 * Copyright (c) 2008, 2009 Alexander Gray,
 *                          Garry Boyer,
 *                          Ryan Riegel,
 *                          Nikolaos Vasiloglou,
 *                          Dongryeol Lee,
 *                          Chip Mappus, 
 *                          Nishant Mehta,
 *                          Hua Ouyang,
 *                          Parikshit Ram,
 *                          Long Tran,
 *                          Wee Chin Wong
 *
 * Copyright (c) 2008, 2009 Georgia Institute of Technology
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */
#ifndef FASTLIB_DISCRETE_HMM_H
#define FASTLIB_DISCRETE_HMM_H

#include "fastlib/fastlib.h"

class DiscreteHMM {
 private:
  Matrix transmission_;

  Matrix emission_;

  OT_DEF(DiscreteHMM) {
    OT_MY_OBJECT(transmission_);
    OT_MY_OBJECT(emission_);
  }

 public:
  const Matrix& transmission() const { return transmission_; }
  const Matrix& emission() const { return emission_; }

  void setModel(const Matrix& transmission, const Matrix& emission);

  void Init(const Matrix& transmission, const Matrix& emission);

  void InitFromFile(const char* profile);

  void InitFromData(const ArrayList<Vector>& list_data_seq, int numstate);

  void LoadProfile(const char* profile);

  void SaveProfile(const char* profile) const;

  void GenerateSequence(int length, Vector* data_seq, Vector* state_seq) const;

  void EstimateModel(const Vector& data_seq, const Vector& state_seq);
  void EstimateModel(int numstate, int numsymbol, const Vector& data_seq, const Vector& state_seq);

  void DecodeOverwrite(const Vector& data_seq, Matrix* state_prob_mat, Matrix* forward_prob_mat, Matrix* backward_prob_mat, Vector* scale_vec) const;

  void DecodeInit(const Vector& data_seq, Matrix* state_prob_mat, Matrix* forward_prob_mat, Matrix* backward_prob_mat, Vector* scale_vec) const;

  double ComputeLogLikelihood(const Vector& data_seq) const;

  void ComputeLogLikelihood(const ArrayList<Vector>& list_data_seq, ArrayList<double>* list_likelihood) const;

  void ComputeViterbiStateSequence(const Vector& data_seq, Vector* state_seq) const;

  void TrainBaumWelch(const ArrayList<Vector>& list_data_seq, int max_iteration, double tolerance);

  void TrainViterbi(const ArrayList<Vector>& list_data_seq, int max_iteration, double tolerance);



  static void GenerateInit(int L, const Matrix& trans, const Matrix& emis, Vector* seq, Vector * states);

  static void EstimateInit(const Vector& seq, const Vector& states, Matrix* trans, Matrix* emis);
  static void EstimateInit(int numSymbols, int numStates, const Vector& seq, const Vector& states, Matrix* trans, Matrix* emis);

  static void ForwardProcedure(const Vector& seq, const Matrix& trans, const Matrix& emis, Vector *scales, Matrix* fs);
  static void BackwardProcedure(const Vector& seq, const Matrix& trans, const Matrix& emis, const Vector& scales, Matrix* bs);
  static double Decode(const Vector& seq, const Matrix& trans, const Matrix& emis, Matrix* pstates, Matrix* fs, Matrix* bs, Vector* scales);

  static double ViterbiInit(const Vector& seq, const Matrix& trans, const Matrix& emis, Vector* states);
  static double ViterbiInit(int L, const Vector& seq, const Matrix& trans, const Matrix& emis, Vector* states);

  static void Train(const ArrayList<Vector>& seqs, Matrix* guessTR, Matrix* guessEM, int max_iter, double tol);

  static void TrainViterbi(const ArrayList<Vector>& seqs, Matrix* guessTR, Matrix* guessEM, int max_iter, double tol);

};
#endif