diag-gmm.h

Go to the documentation of this file.

// gmm/diag-gmm.h

// Copyright 2009-2011  Microsoft Corporation;
//                      Saarland University (Author: Arnab Ghoshal);
//                      Georg Stemmer;  Jan Silovsky
//           2012       Arnab Ghoshal
//           2013-2014  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_DIAG_GMM_H_
#define KALDI_GMM_DIAG_GMM_H_ 1

#include <utility>
#include <vector>

#include "base/kaldi-common.h"
#include "gmm/model-common.h"
#include "matrix/matrix-lib.h"
#include "tree/cluster-utils.h"
#include "tree/clusterable-classes.h"

namespace kaldi {

class FullGmm;
class DiagGmmNormal;

class DiagGmm {
  friend class DiagGmmNormal;

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

  explicit DiagGmm(const DiagGmm &gmm): valid_gconsts_(false) {
    CopyFromDiagGmm(gmm);
  }

  DiagGmm(const GaussClusterable &gc, BaseFloat var_floor);

  void CopyFromNormal(const DiagGmmNormal &diag_gmm_normal);

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

  explicit DiagGmm(const std::vector<std::pair<BaseFloat, const DiagGmm*> > &gmms);

  void Resize(int32 nMix, int32 dim);

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

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

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

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

  void LogLikelihoods(const MatrixBase<BaseFloat> &data,
                      Matrix<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 GaussianSelection(const MatrixBase<BaseFloat> &data,
                              int32 num_gselect,
                              std::vector<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,
                                Vector<BaseFloat> *posteriors) const;

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

  int32 ComputeGconsts();

  void Generate(VectorBase<BaseFloat> *output);

  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);

  // Merge the components to a specified target #components: this
  // version uses a different approach based on K-means.
  void MergeKmeans(int32 target_components,
                   ClusterKMeansOptions cfg = ClusterKMeansOptions());

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

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

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

  const Vector<BaseFloat> &gconsts() const {
    KALDI_ASSERT(valid_gconsts_);
    return gconsts_;
  }
  const Vector<BaseFloat> &weights() const { return weights_; }
  const Matrix<BaseFloat> &means_invvars() const { return means_invvars_; }
  const Matrix<BaseFloat> &inv_vars() const { return inv_vars_; }
  bool valid_gconsts() const { return valid_gconsts_; }

  void RemoveComponent(int32 gauss, bool renorm_weights);

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

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

  template<class Real>
  void SetMeans(const MatrixBase<Real> &m);
  template<class Real>
  void SetInvVarsAndMeans(const MatrixBase<Real> &invvars,
                          const MatrixBase<Real> &means);
  template<class Real>
  void SetInvVars(const MatrixBase<Real> &v);

  template<class Real>
  void GetVars(Matrix<Real> *v) const;
  template<class Real>
  void GetMeans(Matrix<Real> *m) const;

  template<class Real>
  void SetComponentMean(int32 gauss, const VectorBase<Real> &in);
  template<class Real>
  void SetComponentInvVar(int32 gauss, const VectorBase<Real> &in);
  inline void SetComponentWeight(int32 gauss, BaseFloat weight);

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

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

 private:
  Vector<BaseFloat> gconsts_;
  bool valid_gconsts_;   
  Vector<BaseFloat> weights_;        
  Matrix<BaseFloat> inv_vars_;       
  Matrix<BaseFloat> means_invvars_;  

  // 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 merged_components_logdet(BaseFloat w1, BaseFloat w2,
                                     const VectorBase<BaseFloat> &f1,
                                     const VectorBase<BaseFloat> &f2,
                                     const VectorBase<BaseFloat> &s1,
                                     const VectorBase<BaseFloat> &s2) const;

 private:
  const DiagGmm &operator=(const DiagGmm &other);  // Disallow assignment
};

std::ostream &
operator << (std::ostream &os, const kaldi::DiagGmm &gmm);
std::istream &
operator >> (std::istream &is, kaldi::DiagGmm &gmm);

}  // End namespace kaldi

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

#endif  // KALDI_GMM_DIAG_GMM_H_