basis-fmllr-diag-gmm.h

Go to the documentation of this file.

// transform/basis-fmllr-diag-gmm.h

// Copyright 2012  Carnegie Mellon University (author: Yajie Miao)
//           2014  Johns Hopkins University (author: Daniel Povey)
//           2014  IMSL, PKU-HKUST (Author: Wei Shi)

// 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_BASIS_FMLLR_DIAG_GMM_H_
#define KALDI_TRANSFORM_BASIS_FMLLR_DIAG_GMM_H_

#include <vector>
#include <string>

#include "base/kaldi-common.h"
#include "gmm/am-diag-gmm.h"
#include "gmm/mle-full-gmm.h"
#include "gmm/mle-am-diag-gmm.h"
#include "transform/transform-common.h"
#include "util/kaldi-table.h"
#include "util/kaldi-holder.h"

namespace kaldi {

/* This header contains routines for performing subspace CMLLR
   (without a regression tree) for diagonal GMM acoustic model.

   Refer to Dan Povey's paper for derivations:
   Daniel Povey, Kaisheng Yao. A basis representation of constrained
   MLLR transforms for robust adaptation. Computer Speech and Language,
   volume 26:35–51, 2012.
*/

struct BasisFmllrOptions {
  int32 num_iters;
  BaseFloat size_scale; // how many basis elements we add for each new frame.
  BaseFloat min_count;
  int32 step_size_iters;
  BasisFmllrOptions(): num_iters(10), size_scale(0.2), min_count(50.0), step_size_iters(3) { }
  void Register(OptionsItf *opts) {
    opts->Register("num-iters", &num_iters,
                   "Number of iterations in basis fMLLR update during testing");
    opts->Register("size-scale", &size_scale,
                   "Scale (< 1.0) on speaker occupancy that gives number of "
                   "basis elements.");
    opts->Register("fmllr-min-count", &min_count,
                   "Minimum count required to update fMLLR");
    opts->Register("step-size-iters", &step_size_iters,
                   "Number of iterations in computing step size");
  }
};

class BasisFmllrAccus {

 public:
  BasisFmllrAccus() { }
  explicit BasisFmllrAccus(int32 dim) {
      dim_ = dim;
      beta_ = 0;
      ResizeAccus(dim);
  }

  void ResizeAccus(int32 dim);

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

  void AccuGradientScatter(const AffineXformStats &spk_stats);

  SpMatrix<BaseFloat> grad_scatter_;
  int32 dim_;
  double beta_;
};

class BasisFmllrEstimate {

 public:
  BasisFmllrEstimate(): dim_(0), basis_size_(0) { }
  explicit BasisFmllrEstimate(int32 dim) {
      dim_ = dim; basis_size_ = dim * (dim + 1);
  }

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


  void EstimateFmllrBasis(const AmDiagGmm &am_gmm,
                          const BasisFmllrAccus &basis_accus);

  void ComputeAmDiagPrecond(const AmDiagGmm &am_gmm,
                            SpMatrix<double> *pre_cond);

  int32 Dim() const { return dim_; }

  int32 BasisSize() const { return basis_size_; }

  double ComputeTransform(const AffineXformStats &spk_stats,
                          Matrix<BaseFloat> *out_xform,
                          Vector<BaseFloat> *coefficients,
                          BasisFmllrOptions options) const;

 private:

  std::vector< Matrix<BaseFloat> > fmllr_basis_;
  int32 dim_;
  int32 basis_size_;
};


} // namespace kaldi

#endif  // KALDI_TRANSFORM_BASIS_FMLLR_DIAG_GMM_H_