gaussianHMM.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_GAUSSIAN_HMM_H
#define FASTLIB_GAUSSIAN_HMM_H

#include "fastlib/fastlib.h"

class GaussianHMM {
 private:
  Matrix transmission_;

  ArrayList<Vector> list_mean_vec_;

  ArrayList<Matrix> list_covariance_mat_;
  
  ArrayList<Matrix> list_inverse_cov_mat_;

  Vector gauss_const_vec_;

  OT_DEF(GaussianHMM) {
    OT_MY_OBJECT(transmission_);
    OT_MY_OBJECT(list_mean_vec_);
    OT_MY_OBJECT(list_covariance_mat_);
    OT_MY_OBJECT(list_inverse_cov_mat_);
  }

  void CalculateInverse();
 public:
  const Matrix& transmission() const { return transmission_; }
  const ArrayList<Vector>& list_mean_vec() const { return list_mean_vec_; }
  const ArrayList<Matrix>& list_covariance_mat() const { return list_covariance_mat_; }

  void setModel(const Matrix& transmission,  const ArrayList<Vector>& list_mean_vec,
                const ArrayList<Matrix>& list_covariance_mat);

  void Init(const Matrix& transmission,  const ArrayList<Vector>& list_mean_vec,
            const ArrayList<Matrix>& list_covariance_mat);
  
  void InitFromFile(const char* profile);

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

  void InitFromData(const Matrix& data_seq, const Vector& state_seq);

  void LoadProfile(const char* profile);

  void SaveProfile(const char* profile) const;

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

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

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

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

  double ComputeLogLikelihood(const Matrix& data_seq) const;

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

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

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



  static success_t LoadProfile(const char* profile, Matrix* trans, 
                               ArrayList<Vector>* means, ArrayList<Matrix>* covs);
  static success_t SaveProfile(const char* profile, const Matrix& trans, 
                               const ArrayList<Vector>& means, 
                               const ArrayList<Matrix>& covs);
  static void GenerateInit(int L, const Matrix& trans, const ArrayList<Vector>& means, 
                           const ArrayList<Matrix>& covs, Matrix* seq, Vector* states);

  static void EstimateInit(const Matrix& seq, const Vector& states, Matrix* trans, 
                           ArrayList<Vector>* means, ArrayList<Matrix>* covs);
  static void EstimateInit(int numStates, const Matrix& seq, const Vector& states, 
                           Matrix* trans, ArrayList<Vector>* means, 
                           ArrayList<Matrix>* covs);

  static void ForwardProcedure(int L, const Matrix& trans, const Matrix& emis_prob, 
                               Vector *scales, Matrix* fs);
  static void BackwardProcedure(int L, const Matrix& trans, const Matrix& emis_prob, 
                                const Vector& scales, Matrix* bs);
  static double Decode(const Matrix& trans, const Matrix& emis_prob, Matrix* pstates, 
                       Matrix* fs, Matrix* bs, Vector* scales);
  static double Decode(int L, const Matrix& trans, const Matrix& emis_prob, 
                       Matrix* pstates, Matrix* fs, Matrix* bs, Vector* scales);
  static void CalculateEmissionProb(const Matrix& seq, const ArrayList<Vector>& means, 
                                    const ArrayList<Matrix>& inv_covs, const Vector& det,
                                    Matrix* emis_prob);

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

  static void InitGaussParameter(int M, const ArrayList<Matrix>& seqs, 
                                 Matrix* guessTR, ArrayList<Vector>* guessME, ArrayList<Matrix>* guessCO);

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

  static void TrainViterbi(const ArrayList<Matrix>& seqs, Matrix* guessTR, 
                           ArrayList<Vector>* guessME, ArrayList<Matrix>* guessCO, 
                           int max_iter, double tol);
};
#endif