regtree-mllr-diag-gmm.h

Go to the documentation of this file.

// transform/regtree-mllr-diag-gmm.h

// Copyright 2009-2011  Saarland University;  Jan Silovsky

// 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_TRANSFORM_REGTREE_MLLR_DIAG_GMM_H_
#define KALDI_TRANSFORM_REGTREE_MLLR_DIAG_GMM_H_

#include <vector>

#include "base/kaldi-common.h"
#include "gmm/am-diag-gmm.h"
#include "transform/transform-common.h"
#include "transform/regression-tree.h"
#include "util/common-utils.h"

namespace kaldi {


struct RegtreeMllrOptions {
  BaseFloat min_count;  

  bool use_regtree;

  RegtreeMllrOptions(): min_count(1000.0), use_regtree(true) { }

  void Register(OptionsItf *opts) {
    opts->Register("mllr-min-count", &min_count,
                   "Minimum count to estimate an MLLR transform.");
    opts->Register("mllr-use-regtree", &use_regtree,
                   "Use a regression-class tree for MLLR.");
  }
};

class RegtreeMllrDiagGmm {
 public:
  RegtreeMllrDiagGmm() {}

  void Init(int32 num_xforms, int32 dim);

  void SetUnit();

  void TransformModel(const RegressionTree &regtree, AmDiagGmm *am);

  void GetTransformedMeans(const RegressionTree &regtree, const AmDiagGmm &am,
                           int32 pdf_index, MatrixBase<BaseFloat> *out) const;

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

  void SetParameters(const MatrixBase<BaseFloat> &mat, int32 regclass);
  void set_bclass2xforms(const std::vector<int32> &in) { bclass2xforms_ = in; }

  const std::vector< Matrix<BaseFloat> > xform_matrices() const {
    return xform_matrices_;
  }

 private:
  std::vector< Matrix<BaseFloat> > xform_matrices_;
  int32 num_xforms_;  
  std::vector<int32> bclass2xforms_;
  int32 dim_;  

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

inline void RegtreeMllrDiagGmm::SetParameters(const MatrixBase<BaseFloat> &mat,
                                              int32 regclass) {
  xform_matrices_[regclass].CopyFromMat(mat, kNoTrans);
}

class RegtreeMllrDiagGmmAccs {
 public:
  RegtreeMllrDiagGmmAccs() {}
  ~RegtreeMllrDiagGmmAccs() { DeletePointers(&baseclass_stats_); }

  void Init(int32 num_bclass, int32 dim);
  void SetZero();

  BaseFloat AccumulateForGmm(const RegressionTree &regtree,
                             const AmDiagGmm &am,
                             const VectorBase<BaseFloat> &data,
                             int32 pdf_index, BaseFloat weight);

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

  void Update(const RegressionTree &regtree, const RegtreeMllrOptions &opts,
              RegtreeMllrDiagGmm *out_mllr, BaseFloat *auxf_impr,
              BaseFloat *t) const;

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

  int32 Dim() const { return dim_; }
  int32 NumBaseClasses() const { return num_baseclasses_; }
  const std::vector<AffineXformStats*> &baseclass_stats() const {
    return baseclass_stats_;
  }

 private:
  std::vector<AffineXformStats*> baseclass_stats_;
  int32 num_baseclasses_;    
  int32 dim_;    

  BaseFloat MllrObjFunction(const Matrix<BaseFloat> &xform,
                            int32 bclass_id) const;

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

typedef TableWriter< KaldiObjectHolder<RegtreeMllrDiagGmm> >
            RegtreeMllrDiagGmmWriter;
typedef RandomAccessTableReader< KaldiObjectHolder<RegtreeMllrDiagGmm> >
            RandomAccessRegtreeMllrDiagGmmReader;
typedef RandomAccessTableReaderMapped< KaldiObjectHolder<RegtreeMllrDiagGmm> >
            RandomAccessRegtreeMllrDiagGmmReaderMapped;
typedef SequentialTableReader< KaldiObjectHolder<RegtreeMllrDiagGmm> >
            RegtreeMllrDiagGmmSeqReader;

}  // namespace kaldi

#endif  // KALDI_TRANSFORM_REGTREE_MLLR_DIAG_GMM_H_