mle-am-diag-gmm.h

Go to the documentation of this file.

// gmm/mle-am-diag-gmm.h

// Copyright 2009-2012  Saarland University (author: Arnab Ghoshal);
//                      Yanmin Qian; Johns Hopkins University (author: Daniel Povey)
//                      Cisco Systems (author: Neha Agrawal)

// 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_MLE_AM_DIAG_GMM_H_
#define KALDI_GMM_MLE_AM_DIAG_GMM_H_ 1

#include <vector>

#include "gmm/am-diag-gmm.h"
#include "gmm/mle-diag-gmm.h"
#include "util/common-utils.h"

namespace kaldi {

class AccumAmDiagGmm {
 public:
  AccumAmDiagGmm() : total_frames_(0.0), total_log_like_(0.0) {}
  ~AccumAmDiagGmm();

  void Read(std::istream &in_stream, bool binary, bool add = false);
  void Write(std::ostream &out_stream, bool binary) const;

  void Init(const AmDiagGmm &model, GmmFlagsType flags);
  void Init(const AmDiagGmm &model, int32 dim, GmmFlagsType flags);
  void SetZero(GmmFlagsType flags);

  BaseFloat AccumulateForGmm(const AmDiagGmm &model,
                             const VectorBase<BaseFloat> &data,
                             int32 gmm_index, BaseFloat weight);

  BaseFloat AccumulateForGmmTwofeats(const AmDiagGmm &model,
                                     const VectorBase<BaseFloat> &data1,
                                     const VectorBase<BaseFloat> &data2,
                                     int32 gmm_index, BaseFloat weight);

  void AccumulateFromPosteriors(const AmDiagGmm &model,
                                const VectorBase<BaseFloat> &data,
                                int32 gmm_index,
                                const VectorBase<BaseFloat> &posteriors);

  void AccumulateForGaussian(const AmDiagGmm &am,
                             const VectorBase<BaseFloat> &data,
                             int32 gmm_index, int32 gauss_index,
                             BaseFloat weight);

  int32 NumAccs() { return gmm_accumulators_.size(); }

  int32 NumAccs() const { return gmm_accumulators_.size(); }

  BaseFloat TotStatsCount() const; // returns the total count got by summing the count
  // of the actual stats, may differ from TotCount() if e.g. you did I-smoothing.
  
  // Be careful since total_frames_ is not updated in AccumulateForGaussian
  BaseFloat TotCount() const { return total_frames_; }
  BaseFloat TotLogLike() const { return total_log_like_; }

  const AccumDiagGmm& GetAcc(int32 index) const;

  AccumDiagGmm& GetAcc(int32 index);

  void Add(BaseFloat scale, const AccumAmDiagGmm &other);

  void Scale(BaseFloat scale);

  int32 Dim() const {
    return (gmm_accumulators_.empty() || !gmm_accumulators_[0] ?
            0 : gmm_accumulators_[0]->Dim());
  }

 private:
  std::vector<AccumDiagGmm*> gmm_accumulators_;

  double total_frames_, total_log_like_;

  // Cannot have copy constructor and assigment operator
  KALDI_DISALLOW_COPY_AND_ASSIGN(AccumAmDiagGmm);
};

void MleAmDiagGmmUpdate(const MleDiagGmmOptions &config,
                        const AccumAmDiagGmm &amdiaggmm_acc,
                        GmmFlagsType flags,
                        AmDiagGmm *am_gmm,
                        BaseFloat *obj_change_out,
                        BaseFloat *count_out);

void MapAmDiagGmmUpdate(const MapDiagGmmOptions &config,
                        const AccumAmDiagGmm &diag_gmm_acc,
                        GmmFlagsType flags,
                        AmDiagGmm *gmm,
                        BaseFloat *obj_change_out,
                        BaseFloat *count_out);

// These typedefs are needed to write GMMs to and from pipes, for MAP
// adaptation and decoding.  Note: this doesn't handle the transition
// model, you have to read that in separately.
typedef TableWriter< KaldiObjectHolder<AmDiagGmm> >  MapAmDiagGmmWriter;
typedef RandomAccessTableReader< KaldiObjectHolder<AmDiagGmm> > RandomAccessMapAmDiagGmmReader;
typedef RandomAccessTableReaderMapped< KaldiObjectHolder<AmDiagGmm> > RandomAccessMapAmDiagGmmReaderMapped;
typedef SequentialTableReader< KaldiObjectHolder<AmDiagGmm> > MapAmDiagGmmSeqReader;

}  // End namespace kaldi


#endif  // KALDI_GMM_MLE_AM_DIAG_GMM_H_