#include <train-nnet-ensemble.h>

Collaboration diagram for NnetEnsembleTrainer:

Public Member Functions
	NnetEnsembleTrainer (const NnetEnsembleTrainerConfig &config, std::vector< Nnet *> nnet_ensemble)

void	TrainOnExample (const NnetExample &value)
	TrainOnExample will take the example and add it to a buffer; if we've reached the minibatch size it will do the training. More...

	~NnetEnsembleTrainer ()

Private Member Functions
	KALDI_DISALLOW_COPY_AND_ASSIGN (NnetEnsembleTrainer)

void	TrainOneMinibatch ()

void	BeginNewPhase (bool first_time)

Private Attributes
NnetEnsembleTrainerConfig	config_

std::vector< Nnet * >	nnet_ensemble_

std::vector< NnetUpdater * >	updater_ensemble_

int32	num_phases_

int32	minibatches_seen_this_phase_

std::vector< NnetExample >	buffer_

double	beta_

double	avg_logprob_this_phase_

double	count_this_phase_

Detailed Description

Definition at line 64 of file train-nnet-ensemble.h.

Constructor & Destructor Documentation

◆ NnetEnsembleTrainer()

NnetEnsembleTrainer	(	const NnetEnsembleTrainerConfig &	config,
		std::vector< Nnet *>	nnet_ensemble
	)

Definition at line 34 of file train-nnet-ensemble.cc.

References NnetEnsembleTrainer::BeginNewPhase(), NnetEnsembleTrainerConfig::beta, NnetEnsembleTrainer::beta_, NnetEnsembleTrainer::config_, and NnetEnsembleTrainer::num_phases_.

                                    :
     config_(config), nnet_ensemble_(nnet_ensemble) {
   beta_ = config_.beta;
   num_phases_ = 0;
   bool first_time = true;
   BeginNewPhase(first_time);
 }

◆ ~NnetEnsembleTrainer()

~NnetEnsembleTrainer ( )

Definition at line 127 of file train-nnet-ensemble.cc.

References NnetEnsembleTrainer::BeginNewPhase(), NnetEnsembleTrainer::buffer_, KALDI_LOG, NnetEnsembleTrainer::minibatches_seen_this_phase_, and NnetEnsembleTrainer::TrainOneMinibatch().

                                           {
   if (!buffer_.empty()) {
     KALDI_LOG << "Doing partial minibatch of size "
               << buffer_.size();
     TrainOneMinibatch();
     if (minibatches_seen_this_phase_ != 0) {
       bool first_time = false;
       BeginNewPhase(first_time);
     }
   }
 }

Member Function Documentation

◆ BeginNewPhase()

void BeginNewPhase ( bool first_time )

private

Definition at line 115 of file train-nnet-ensemble.cc.

References NnetEnsembleTrainer::avg_logprob_this_phase_, NnetEnsembleTrainer::count_this_phase_, KALDI_LOG, NnetEnsembleTrainer::minibatches_seen_this_phase_, and NnetEnsembleTrainer::num_phases_.

Referenced by NnetEnsembleTrainer::NnetEnsembleTrainer(), NnetEnsembleTrainer::TrainOneMinibatch(), and NnetEnsembleTrainer::~NnetEnsembleTrainer().

                                                        {
   if (!first_time)
     KALDI_LOG << "Averaged cross-entropy between the supervision labels and the output is "
               << (avg_logprob_this_phase_/count_this_phase_) << " over "
               << count_this_phase_ << " frames, during this phase";
   avg_logprob_this_phase_ = 0.0;
   count_this_phase_ = 0.0;
   minibatches_seen_this_phase_ = 0;
   num_phases_++;
 }

◆ KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( NnetEnsembleTrainer )

private

◆ TrainOneMinibatch()

void TrainOneMinibatch ( )

private

Definition at line 50 of file train-nnet-ensemble.cc.

References NnetEnsembleTrainer::avg_logprob_this_phase_, NnetEnsembleTrainer::BeginNewPhase(), NnetEnsembleTrainer::beta_, NnetEnsembleTrainer::buffer_, NnetEnsembleTrainer::config_, NnetEnsembleTrainer::count_this_phase_, rnnlm::i, CuMatrixBase< Real >::InvertElements(), KALDI_ASSERT, kaldi::nnet2::MakePair(), NnetEnsembleTrainerConfig::minibatches_per_phase, NnetEnsembleTrainer::minibatches_seen_this_phase_, CuMatrixBase< Real >::MulElements(), NnetEnsembleTrainer::nnet_ensemble_, and NnetEnsembleTrainer::updater_ensemble_.

Referenced by NnetEnsembleTrainer::TrainOnExample(), and NnetEnsembleTrainer::~NnetEnsembleTrainer().

                                             {
   KALDI_ASSERT(!buffer_.empty());
   
   int32 num_states = nnet_ensemble_[0]->GetComponent(nnet_ensemble_[0]->NumComponents() - 1).OutputDim();
   // average of posteriors matrix, storing averaged outputs of net ensemble.
   CuMatrix<BaseFloat> post_avg(buffer_.size(), num_states);
   updater_ensemble_.reserve(nnet_ensemble_.size());
   std::vector<CuMatrix<BaseFloat> > post_mat;
   post_mat.resize(nnet_ensemble_.size());
   for (int32 i = 0; i < nnet_ensemble_.size(); i++) {
     updater_ensemble_.push_back(new NnetUpdater(*(nnet_ensemble_[i]), nnet_ensemble_[i]));
     updater_ensemble_[i]->FormatInput(buffer_);
     updater_ensemble_[i]->Propagate();
     // posterior matrix, storing output of one net.
     updater_ensemble_[i]->GetOutput(&post_mat[i]);
     CuVector<BaseFloat> row_sum(post_mat[i].NumRows());
     post_avg.AddMat(1.0, post_mat[i]);
   }
 
   // calculate the interpolated posterios as new supervision labels, and also 
   // collect the indices of the original supervision labels for later use (calc. objf.).
   std::vector<MatrixElement<BaseFloat> > sv_labels;
   std::vector<Int32Pair > sv_labels_ind;
   sv_labels.reserve(buffer_.size()); // We must have at least this many labels.
   sv_labels_ind.reserve(buffer_.size()); // We must have at least this many labels.
   for (int32 m = 0; m < buffer_.size(); m++) {
     KALDI_ASSERT(buffer_[m].labels.size() == 1 &&
                  "Currently this code only supports single-frame egs.");
     const std::vector<std::pair<int32,BaseFloat> > &labels = buffer_[m].labels[0];
     for (size_t i = 0; i < labels.size(); i++) {
       MatrixElement<BaseFloat> 
           tmp = {m, labels[i].first, labels[i].second};
       sv_labels.push_back(tmp);
       sv_labels_ind.push_back(MakePair(m, labels[i].first));
     }
   }
   post_avg.Scale(1.0 / nnet_ensemble_.size());
   post_avg.Scale(beta_);
   post_avg.AddElements(1.0, sv_labels);
 
   // calculate the deriv, do backprop, and calculate the objf.
   for (int32 i = 0; i < nnet_ensemble_.size(); i++) {  
     CuMatrix<BaseFloat> tmp_deriv(post_mat[i]);
     post_mat[i].ApplyLog();
     std::vector<BaseFloat> log_post_correct;
     log_post_correct.resize(sv_labels_ind.size());
     post_mat[i].Lookup(sv_labels_ind, &(log_post_correct[0]));
     BaseFloat log_prob_this_net = std::accumulate(log_post_correct.begin(),
                                                   log_post_correct.end(),
                                                   static_cast<BaseFloat>(0));
     avg_logprob_this_phase_ += log_prob_this_net;
     tmp_deriv.InvertElements();
     tmp_deriv.MulElements(post_avg);
     updater_ensemble_[i]->Backprop(&tmp_deriv);
   }
   count_this_phase_ += buffer_.size();
   buffer_.clear();
   minibatches_seen_this_phase_++;
   if (minibatches_seen_this_phase_ == config_.minibatches_per_phase) {
     avg_logprob_this_phase_ /= static_cast<BaseFloat>(nnet_ensemble_.size());
     bool first_time = false;
     BeginNewPhase(first_time);
   }
 }

◆ TrainOnExample()

void TrainOnExample ( const NnetExample & value )

TrainOnExample will take the example and add it to a buffer; if we've reached the minibatch size it will do the training.

Definition at line 44 of file train-nnet-ensemble.cc.

References NnetEnsembleTrainer::buffer_, NnetEnsembleTrainer::config_, NnetEnsembleTrainerConfig::minibatch_size, and NnetEnsembleTrainer::TrainOneMinibatch().

Referenced by main().

                                                                  {
   buffer_.push_back(value);
   if (static_cast<int32>(buffer_.size()) == config_.minibatch_size)
     TrainOneMinibatch();
 }