mixgaussHMM.h

/* 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_MIXGAUSS_HMM_H
#define FASTLIB_MIXGAUSS_HMM_H

#include "fastlib/fastlib.h"
#include "mixtureDST.h"

class MixtureofGaussianHMM {
 private:
  Matrix transmission_;

  ArrayList<MixtureGauss> list_mixture_gauss_;

  OT_DEF(MixtureofGaussianHMM) {
    OT_MY_OBJECT(transmission_);
    OT_MY_OBJECT(list_mixture_gauss_);
  }
 public:
  const Matrix& transmission() const { return transmission_; }
  const ArrayList<MixtureGauss>& list_mixture_gauss() const { return list_mixture_gauss_; }

  void setModel(const Matrix& transmission,
                const ArrayList<MixtureGauss>& list_mixture_gauss);

  void Init(const Matrix& transmission, const ArrayList<MixtureGauss>& list_mixture_gauss);

  void InitFromFile(const char* profile);

  void Init() {
    transmission_.Init(0, 0);
    list_mixture_gauss_.Init();
  }

  void LoadProfile(const char* profile);

  void SaveProfile(const char* profile) const;

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

  void EstimateModel(int numcluster, const Matrix& data_seq, const Vector& state_seq);
  void EstimateModel(int numstate, int numcluster, 
                     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<MixtureGauss>* mixs);
  static success_t SaveProfile(const char* profile, const Matrix& trans, const ArrayList<MixtureGauss>& mixs);

  static void GenerateInit(int L, const Matrix& trans, const ArrayList<MixtureGauss>& mixs, Matrix* seq, Vector* states);

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

  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<MixtureGauss>& mixs, 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 Train(const ArrayList<Matrix>& seqs, Matrix* guessTR, 
                    ArrayList<MixtureGauss>* guessMG, int max_iter, double tol);
  static void TrainViterbi(const ArrayList<Matrix>& seqs, Matrix* guessTR, 
                           ArrayList<MixtureGauss>* guessMG, int max_iter, double tol);
};
#endif