estimate-am-sgmm2-ebw.h

Go to the documentation of this file.

// sgmm2/estimate-am-sgmm2-ebw.h

// Copyright 2012  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_SGMM2_ESTIMATE_AM_SGMM2_EBW_H_
#define KALDI_SGMM2_ESTIMATE_AM_SGMM2_EBW_H_ 1

#include <string>
#include <vector>

#include "gmm/model-common.h"
#include "itf/options-itf.h"
#include "sgmm2/estimate-am-sgmm2.h"

namespace kaldi {

struct EbwAmSgmm2Options {
  BaseFloat tau_v; 
  BaseFloat lrate_v; 
  BaseFloat tau_M; 
  BaseFloat lrate_M; 
  BaseFloat tau_N; 
  BaseFloat lrate_N; 
  BaseFloat tau_c;  
  BaseFloat tau_w;  
  BaseFloat lrate_w; 
  BaseFloat tau_u;  
  BaseFloat lrate_u; 
  BaseFloat max_impr_u; 
  BaseFloat tau_Sigma; 
  BaseFloat lrate_Sigma; 
  BaseFloat min_substate_weight; 
  
  BaseFloat cov_min_value; 
  
  BaseFloat max_cond; 
  BaseFloat epsilon;  
  
  EbwAmSgmm2Options() {
    tau_v = 50.0;
    lrate_v = 0.5;
    tau_M = 500.0;
    lrate_M = 0.5;
    tau_N = 500.0;
    lrate_N = 0.5;
    tau_c = 10.0;
    tau_w = 50.0;
    lrate_w = 1.0;
    tau_u = 50.0;
    lrate_u = 1.0;
    max_impr_u = 0.25;
    tau_Sigma = 500.0;
    lrate_Sigma = 0.5;

    min_substate_weight = 1.0e-05;
    cov_min_value = 0.5;
    
    max_cond = 1.0e+05;
    epsilon = 1.0e-40;
  }

  void Register(OptionsItf *opts) {
    std::string module = "EbwAmSgmm2Options: ";
    opts->Register("tau-v", &tau_v, module+
                   "Smoothing constant for phone vector estimation.");
    opts->Register("lrate-v", &lrate_v, module+
                   "Learning rate constant for phone vector estimation.");
    opts->Register("tau-m", &tau_M, module+
                   "Smoothing constant for estimation of phonetic-subspace projections (M).");
    opts->Register("lrate-m", &lrate_M, module+
                   "Learning rate constant for phonetic-subspace projections.");
    opts->Register("tau-n", &tau_N, module+
                   "Smoothing constant for estimation of speaker-subspace projections (N).");
    opts->Register("lrate-n", &lrate_N, module+
                   "Learning rate constant for speaker-subspace projections.");
    opts->Register("tau-c", &tau_c, module+
                   "Smoothing constant for estimation of substate weights (c)");
    opts->Register("tau-w", &tau_w, module+
                   "Smoothing constant for estimation of phonetic-space weight projections (w)");
    opts->Register("lrate-w", &lrate_w, module+
                   "Learning rate constant for phonetic-space weight-projections (w)");
    opts->Register("tau-u", &tau_u, module+
                   "Smoothing constant for estimation of speaker-space weight projections (u)");
    opts->Register("lrate-u", &lrate_u, module+
                   "Learning rate constant for speaker-space weight-projections (u)");
    opts->Register("tau-sigma", &tau_Sigma, module+
                   "Smoothing constant for estimation of within-class covariances (Sigma)");
    opts->Register("lrate-sigma", &lrate_Sigma, module+
                   "Constant that controls speed of learning for variances (larger->slower)");
    opts->Register("cov-min-value", &cov_min_value, module+
                   "Minimum value that an eigenvalue of the updated covariance matrix can take, "
                   "relative to its old value (maximum is inverse of this.)");
    opts->Register("min-substate-weight", &min_substate_weight, module+
                   "Floor for weights of sub-states.");
    opts->Register("max-cond", &max_cond, module+
                   "Value used in handling singular matrices during update.");
    opts->Register("epsilon", &max_cond, module+
                   "Value used in handling singular matrices during update.");
  }
};


class EbwAmSgmm2Updater {
 public:
  explicit EbwAmSgmm2Updater(const EbwAmSgmm2Options &options):
      options_(options) {}
  
  void Update(const MleAmSgmm2Accs &num_accs,
              const MleAmSgmm2Accs &den_accs,
              AmSgmm2 *model,
              SgmmUpdateFlagsType flags,
              BaseFloat *auxf_change_out,
              BaseFloat *count_out);
    
 protected:
  // The following two classes relate to multi-core parallelization of some
  // phases of the update.
  friend class EbwUpdateWClass;
  friend class EbwUpdatePhoneVectorsClass;
 private:
  EbwAmSgmm2Options options_;

  Vector<double> gamma_j_;  

  double UpdatePhoneVectors(const MleAmSgmm2Accs &num_accs,
                            const MleAmSgmm2Accs &den_accs,
                            const std::vector< SpMatrix<double> > &H,
                            AmSgmm2 *model) const;
  
  // Called from UpdatePhoneVectors; updates a subset of states
  // (relates to multi-threading).
  void UpdatePhoneVectorsInternal(const MleAmSgmm2Accs &num_accs,
                                  const MleAmSgmm2Accs &den_accs,
                                  const std::vector<SpMatrix<double> > &H,
                                  AmSgmm2 *model,
                                  double *auxf_impr,
                                  int32 num_threads,
                                  int32 thread_id) const;
  // Called from UpdatePhoneVectorsInternal
  static void ComputePhoneVecStats(const MleAmSgmm2Accs &accs,
                                   const AmSgmm2 &model,
                                   const std::vector<SpMatrix<double> > &H,
                                   int32 j1,
                                   int32 m,
                                   const Vector<double> &w_jm,
                                   double gamma_jm,
                                   Vector<double> *g_jm,
                                   SpMatrix<double> *H_jm);
                                    
  double UpdateM(const MleAmSgmm2Accs &num_accs,
                 const MleAmSgmm2Accs &den_accs,
                 const std::vector< SpMatrix<double> > &Q_num,
                 const std::vector< SpMatrix<double> > &Q_den,
                 const Vector<double> &gamma_num,
                 const Vector<double> &gamma_den,
                 AmSgmm2 *model) const;
  
  double UpdateN(const MleAmSgmm2Accs &num_accs,
                 const MleAmSgmm2Accs &den_accs,
                 const Vector<double> &gamma_num,
                 const Vector<double> &gamma_den,
                 AmSgmm2 *model) const;
  
  double UpdateVars(const MleAmSgmm2Accs &num_accs,
                    const MleAmSgmm2Accs &den_accs,
                    const Vector<double> &gamma_num,
                    const Vector<double> &gamma_den,
                    const std::vector< SpMatrix<double> > &S_means,
                    AmSgmm2 *model) const;

  double UpdateW(const MleAmSgmm2Accs &num_accs,
                 const MleAmSgmm2Accs &den_accs,
                 const Vector<double> &gamma_num,
                 const Vector<double> &gamma_den,
                 AmSgmm2 *model);


  double UpdateU(const MleAmSgmm2Accs &num_accs,
                 const MleAmSgmm2Accs &den_accs,
                 const Vector<double> &gamma_num,
                 const Vector<double> &gamma_den,
                 AmSgmm2 *model);
  
  double UpdateSubstateWeights(const MleAmSgmm2Accs &num_accs,
                               const MleAmSgmm2Accs &den_accs,
                               AmSgmm2 *model);

  KALDI_DISALLOW_COPY_AND_ASSIGN(EbwAmSgmm2Updater);
  EbwAmSgmm2Updater() {}  // Prevent unconfigured updater.
};


}  // namespace kaldi


#endif  // KALDI_SGMM2_ESTIMATE_AM_SGMM2_EBW_H_