full-gmm.h

Go to the documentation of this file.

// gmm/full-gmm.h

// Copyright 2009-2011  Jan Silovsky;
//                      Saarland University (Author: Arnab Ghoshal);
//                      Microsoft Corporation
//           2012       Arnab Ghoshal
//           2013       Johns Hopkins University (author: Daniel Povey)

// See ../../COPYING for clarification regarding multiple authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//  http://www.apache.org/licenses/LICENSE-2.0
//
// THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
// WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
// MERCHANTABLITY OR NON-INFRINGEMENT.
// See the Apache 2 License for the specific language governing permissions and
// limitations under the License.

#ifndef KALDI_GMM_FULL_GMM_H_
#define KALDI_GMM_FULL_GMM_H_

#include <utility>
#include <vector>

#include "base/kaldi-common.h"
#include "gmm/model-common.h"
#include "matrix/matrix-lib.h"

namespace kaldi {

class DiagGmm;
class FullGmmNormal;  // a simplified representation, see full-gmm-normal.h

class FullGmm {
  friend class FullGmmNormal;

 public:
  FullGmm() : valid_gconsts_(false) {}

  explicit FullGmm(const FullGmm &gmm): valid_gconsts_(false) {
    CopyFromFullGmm(gmm);
  }

  FullGmm(int32 nMix, int32 dim): valid_gconsts_(false) { Resize(nMix, dim); }

  void Resize(int32 nMix, int32 dim);

  int32 NumGauss() const { return weights_.Dim(); }
  int32 Dim() const { return means_invcovars_.NumCols(); }

  void CopyFromFullGmm(const FullGmm &fullgmm);
  void CopyFromDiagGmm(const DiagGmm &diaggmm);

  BaseFloat LogLikelihood(const VectorBase<BaseFloat> &data) const;

  void LogLikelihoods(const VectorBase<BaseFloat> &data,
                      Vector<BaseFloat> *loglikes) const;

  void LogLikelihoodsPreselect(const VectorBase<BaseFloat> &data,
                               const std::vector<int32> &indices,
                               Vector<BaseFloat> *loglikes) const;

  BaseFloat GaussianSelection(const VectorBase<BaseFloat> &data,
                              int32 num_gselect,
                              std::vector<int32> *output) const;

  BaseFloat GaussianSelectionPreselect(const VectorBase<BaseFloat> &data,
                                       const std::vector<int32> &preselect,
                                       int32 num_gselect,
                                       std::vector<int32> *output) const;

  BaseFloat ComponentPosteriors(const VectorBase<BaseFloat> &data,
                                VectorBase<BaseFloat> *posterior) const;

  BaseFloat ComponentLogLikelihood(const VectorBase<BaseFloat> &data,
                                   int32 comp_id) const;

  int32 ComputeGconsts();

  void Split(int32 target_components, float perturb_factor,
             std::vector<int32> *history = NULL);

  void Perturb(float perturb_factor);

  void Merge(int32 target_components,
             std::vector<int32> *history = NULL);

  BaseFloat MergePreselect(int32 target_components,
                           const std::vector<std::pair<int32, int32> > &preselect_pairs);

  void Write(std::ostream &os, bool binary) const;
  void Read(std::istream &is, bool binary);

  void Interpolate(BaseFloat rho, const FullGmm &source,
                   GmmFlagsType flags = kGmmAll);

  const Vector<BaseFloat> &gconsts() const { return gconsts_; }
  const Vector<BaseFloat> &weights() const { return weights_; }
  const Matrix<BaseFloat> &means_invcovars() const { return means_invcovars_; }
  const std::vector<SpMatrix<BaseFloat> > &inv_covars() const {
    return inv_covars_; }

  Matrix<BaseFloat> &means_invcovars() { return means_invcovars_; }
  std::vector<SpMatrix<BaseFloat> > &inv_covars() { return inv_covars_; }

  template<class Real>
  void SetWeights(const Vector<Real> &w);    

  template<class Real>
  void SetMeans(const Matrix<Real> &m);

  template<class Real>
  void SetInvCovarsAndMeans(const std::vector<SpMatrix<Real> > &invcovars,
                            const Matrix<Real> &means);

  template<class Real>
  void SetInvCovarsAndMeansInvCovars(const std::vector<SpMatrix<Real> > &invcovars,
                                     const Matrix<Real> &means_invcovars);

  template<class Real>
  void SetInvCovars(const std::vector<SpMatrix<Real> > &v);

  template<class Real>
  void GetCovars(std::vector<SpMatrix<Real> > *v) const;
  template<class Real>
  void GetMeans(Matrix<Real> *m) const;
  template<class Real>
  void GetCovarsAndMeans(std::vector< SpMatrix<Real> > *covars,
                         Matrix<Real> *means) const;

  void RemoveComponent(int32 gauss, bool renorm_weights);

  void RemoveComponents(const std::vector<int32> &gauss, bool renorm_weights);

  template<class Real>
  void GetComponentMean(int32 gauss, VectorBase<Real> *out) const;

 private:
  Vector<BaseFloat> gconsts_;
  bool valid_gconsts_;  
  Vector<BaseFloat> weights_;  
  std::vector<SpMatrix<BaseFloat> > inv_covars_;  
  Matrix<BaseFloat> means_invcovars_;  

  void ResizeInvCovars(int32 nMix, int32 dim);

  // merged_components_logdet computes logdet for merged components
  // f1, f2 are first-order stats (normalized by zero-order stats)
  // s1, s2 are second-order stats (normalized by zero-order stats)
  BaseFloat MergedComponentsLogdet(BaseFloat w1, BaseFloat w2,
                                     const VectorBase<BaseFloat> &f1,
                                     const VectorBase<BaseFloat> &f2,
                                     const SpMatrix<BaseFloat> &s1,
                                     const SpMatrix<BaseFloat> &s2) const;

  const FullGmm &operator=(const FullGmm &other);  // Disallow assignment.
};

std::ostream &
operator << (std::ostream & rOut, const kaldi::FullGmm &gmm);
std::istream &
operator >> (std::istream & rIn, kaldi::FullGmm &gmm);

}  // End namespace kaldi

#include "gmm/full-gmm-inl.h"  // templated functions.

#endif  // KALDI_GMM_FULL_GMM_H_