This class is for computing objective-function values in a nnet3+chain setup, for diagnostics. More...

#include <nnet-chain-diagnostics.h>

Collaboration diagram for NnetChainComputeProb:

[legend]

Public Member Functions
	NnetChainComputeProb (const NnetComputeProbOptions &nnet_config, const chain::ChainTrainingOptions &chain_config, const fst::StdVectorFst &den_fst, const Nnet &nnet)

	NnetChainComputeProb (const NnetComputeProbOptions &nnet_config, const chain::ChainTrainingOptions &chain_config, const fst::StdVectorFst &den_fst, Nnet *nnet)

void	Reset ()

void	Compute (const NnetChainExample &chain_eg)

bool	PrintTotalStats () const

const ChainObjectiveInfo *	GetObjective (const std::string &output_name) const

double	GetTotalObjective (double *tot_weight) const

const Nnet &	GetDeriv () const

	~NnetChainComputeProb ()

Private Member Functions
void	ProcessOutputs (const NnetChainExample &chain_eg, NnetComputer *computer)

Private Attributes
NnetComputeProbOptions	nnet_config_

chain::ChainTrainingOptions	chain_config_

chain::DenominatorGraph	den_graph_

const Nnet &	nnet_

CachingOptimizingCompiler	compiler_

bool	deriv_nnet_owned_

Nnet *	deriv_nnet_

int32	num_minibatches_processed_

unordered_map< std::string, ChainObjectiveInfo, StringHasher >	objf_info_

Detailed Description

This class is for computing objective-function values in a nnet3+chain setup, for diagnostics.

It also supports computing model derivatives. Note: if the –xent-regularization option is nonzero, the cross-entropy objective will be computed, and displayed when you call PrintTotalStats(), but it will not contribute to model derivatives (there is no code to compute the regularized objective function, and anyway it's not clear that we really need this regularization in the combination phase).

Definition at line 54 of file nnet-chain-diagnostics.h.

Constructor & Destructor Documentation

◆ NnetChainComputeProb() [1/2]

NnetChainComputeProb	(	const NnetComputeProbOptions &	nnet_config,
		const chain::ChainTrainingOptions &	chain_config,
		const fst::StdVectorFst &	den_fst,
		const Nnet &	nnet
	)

Definition at line 26 of file nnet-chain-diagnostics.cc.

References NnetComputeProbOptions::compute_deriv, NnetChainComputeProb::deriv_nnet_, KALDI_ERR, NnetChainComputeProb::nnet_, NnetChainComputeProb::nnet_config_, kaldi::nnet3::ScaleNnet(), kaldi::nnet3::SetNnetAsGradient(), and NnetComputeProbOptions::store_component_stats.

                      :
     nnet_config_(nnet_config),
     chain_config_(chain_config),
     den_graph_(den_fst, nnet.OutputDim("output")),
     nnet_(nnet),
     compiler_(nnet, nnet_config_.optimize_config, nnet_config_.compiler_config),
     deriv_nnet_owned_(true),
     deriv_nnet_(NULL),
     num_minibatches_processed_(0) {
   if (nnet_config_.compute_deriv) {
     deriv_nnet_ = new Nnet(nnet_);
     ScaleNnet(0.0, deriv_nnet_);
     SetNnetAsGradient(deriv_nnet_); // force simple update
   } else if (nnet_config_.store_component_stats) {
     KALDI_ERR << "If you set store_component_stats == true and "
               << "compute_deriv == false, use the other constructor.";
   }
 }

◆ NnetChainComputeProb() [2/2]

NnetChainComputeProb	(	const NnetComputeProbOptions &	nnet_config,
		const chain::ChainTrainingOptions &	chain_config,
		const fst::StdVectorFst &	den_fst,
		Nnet *	nnet
	)

Definition at line 50 of file nnet-chain-diagnostics.cc.

References NnetComputeProbOptions::compute_deriv, NnetChainComputeProb::den_graph_, KALDI_ASSERT, and NnetComputeProbOptions::store_component_stats.

                :
     nnet_config_(nnet_config),
     chain_config_(chain_config),
     den_graph_(den_fst, nnet->OutputDim("output")),
     nnet_(*nnet),
     compiler_(*nnet, nnet_config_.optimize_config, nnet_config_.compiler_config),
     deriv_nnet_owned_(false),
     deriv_nnet_(nnet),
     num_minibatches_processed_(0) {
   KALDI_ASSERT(den_graph_.NumPdfs() > 0);
   KALDI_ASSERT(nnet_config.store_component_stats && !nnet_config.compute_deriv);
 }

◆ ~NnetChainComputeProb()

~NnetChainComputeProb ( )

Definition at line 74 of file nnet-chain-diagnostics.cc.

References NnetChainComputeProb::deriv_nnet_, and NnetChainComputeProb::deriv_nnet_owned_.

                                             {
   if (deriv_nnet_owned_)
     delete deriv_nnet_;  // delete does nothing if pointer is NULL.
 }

Member Function Documentation

◆ Compute()

void Compute ( const NnetChainExample & chain_eg )

Definition at line 88 of file nnet-chain-diagnostics.cc.

References NnetComputer::AcceptInputs(), NnetChainComputeProb::chain_config_, CachingOptimizingCompiler::Compile(), NnetChainComputeProb::compiler_, NnetComputeProbOptions::compute_config, NnetComputeProbOptions::compute_deriv, NnetChainComputeProb::deriv_nnet_, kaldi::nnet3::GetChainComputationRequest(), NnetChainExample::inputs, NnetChainComputeProb::nnet_, NnetChainComputeProb::nnet_config_, NnetChainComputeProb::ProcessOutputs(), NnetComputer::Run(), and NnetComputeProbOptions::store_component_stats.

Referenced by kaldi::nnet3::RecomputeStats().

                                                                    {
   bool need_model_derivative = nnet_config_.compute_deriv,
       store_component_stats = nnet_config_.store_component_stats;
   ComputationRequest request;
   // if the options specify cross-entropy regularization, we'll be computing
   // this objective (not interpolated with the regular objective-- we give it a
   // separate name), but currently we won't make it contribute to the
   // derivative-- we just compute the derivative of the regular output.
   // This is because in the place where we use the derivative (the
   // model-combination code) we decided to keep it simple and just use the
   // regular objective.
   bool use_xent_regularization = (chain_config_.xent_regularize != 0.0),
       use_xent_derivative = false;
   GetChainComputationRequest(nnet_, chain_eg, need_model_derivative,
                              store_component_stats, use_xent_regularization,
                              use_xent_derivative, &request);
   std::shared_ptr<const NnetComputation> computation = compiler_.Compile(request);
   NnetComputer computer(nnet_config_.compute_config, *computation,
                         nnet_, deriv_nnet_);
   // give the inputs to the computer object.
   computer.AcceptInputs(nnet_, chain_eg.inputs);
   computer.Run();
   this->ProcessOutputs(chain_eg, &computer);
   if (nnet_config_.compute_deriv)
     computer.Run();
 }

◆ GetDeriv()

const Nnet & GetDeriv ( ) const

Definition at line 68 of file nnet-chain-diagnostics.cc.

References NnetComputeProbOptions::compute_deriv, NnetChainComputeProb::deriv_nnet_, KALDI_ERR, and NnetChainComputeProb::nnet_config_.

                                                  {
   if (!nnet_config_.compute_deriv)
     KALDI_ERR << "GetDeriv() called when no derivatives were requested.";
   return *deriv_nnet_;
 }

◆ GetObjective()

const ChainObjectiveInfo * GetObjective ( const std::string & output_name ) const

Definition at line 211 of file nnet-chain-diagnostics.cc.

References NnetChainComputeProb::objf_info_.

                                         {
   unordered_map<std::string, ChainObjectiveInfo, StringHasher>::const_iterator
       iter = objf_info_.find(output_name);
   if (iter != objf_info_.end())
     return &(iter->second);
   else
     return NULL;
 }

◆ GetTotalObjective()

double GetTotalObjective ( double * tot_weight ) const

Definition at line 221 of file nnet-chain-diagnostics.cc.

References NnetChainComputeProb::objf_info_.

                                                                          {
   double tot_objectives = 0.0;
   double tot_weight = 0.0;
   unordered_map<std::string, ChainObjectiveInfo, StringHasher>::const_iterator
     iter = objf_info_.begin(), end = objf_info_.end();
   for (; iter != end; ++iter) {
     tot_objectives += iter->second.tot_like + iter->second.tot_l2_term;
     tot_weight += iter->second.tot_weight;
   }
 
   if (total_weight) *total_weight = tot_weight;
   return tot_objectives;
 }

◆ PrintTotalStats()

bool PrintTotalStats ( ) const

Definition at line 179 of file nnet-chain-diagnostics.cc.

References Nnet::GetNodeIndex(), KALDI_ASSERT, KALDI_LOG, NnetChainComputeProb::nnet_, NnetChainComputeProb::objf_info_, ChainObjectiveInfo::tot_l2_term, ChainObjectiveInfo::tot_like, and ChainObjectiveInfo::tot_weight.

Referenced by kaldi::nnet3::RecomputeStats().

                                                  {
   bool ans = false;
   unordered_map<std::string, ChainObjectiveInfo, StringHasher>::const_iterator
       iter, end;
   iter = objf_info_.begin();
   end = objf_info_.end();
   for (; iter != end; ++iter) {
     const std::string &name = iter->first;
     int32 node_index = nnet_.GetNodeIndex(name);
     KALDI_ASSERT(node_index >= 0);
     const ChainObjectiveInfo &info = iter->second;
     BaseFloat like = (info.tot_like / info.tot_weight),
         l2_term = (info.tot_l2_term / info.tot_weight),
         tot_objf = like + l2_term;
     if (info.tot_l2_term == 0.0) {
       KALDI_LOG << "Overall log-probability for '"
                 << name << "' is "
                 << like << " per frame"
                 << ", over " << info.tot_weight << " frames.";
     } else {
       KALDI_LOG << "Overall log-probability for '"
                 << name << "' is "
                 << like << " + " << l2_term << " = " << tot_objf << " per frame"
                 << ", over " << info.tot_weight << " frames.";
     }
     if (info.tot_weight > 0)
       ans = true;
   }
   return ans;
 }

◆ ProcessOutputs()

void ProcessOutputs	(	const NnetChainExample &	chain_eg,
		NnetComputer *	computer
	)

private

Definition at line 115 of file nnet-chain-diagnostics.cc.

References NnetComputer::AcceptInput(), NnetChainComputeProb::chain_config_, NnetComputeProbOptions::compute_deriv, NnetChainComputeProb::den_graph_, Nnet::GetNodeIndex(), NnetComputer::GetOutput(), Nnet::IsOutputNode(), KALDI_ERR, kaldi::kTrans, kaldi::kUndefined, NnetChainSupervision::name, NnetChainComputeProb::nnet_, NnetChainComputeProb::nnet_config_, NnetChainComputeProb::num_minibatches_processed_, NnetChainComputeProb::objf_info_, NnetChainExample::outputs, CuMatrix< Real >::Resize(), NnetChainSupervision::supervision, ChainObjectiveInfo::tot_l2_term, ChainObjectiveInfo::tot_like, ChainObjectiveInfo::tot_weight, and kaldi::TraceMatMat().

Referenced by NnetChainComputeProb::Compute().

                                                                  {
   // There will normally be just one output here, named 'output',
   // but the code is more general than this.
   std::vector<NnetChainSupervision>::const_iterator iter = eg.outputs.begin(),
       end = eg.outputs.end();
   for (; iter != end; ++iter) {
     const NnetChainSupervision &sup = *iter;
     int32 node_index = nnet_.GetNodeIndex(sup.name);
     if (node_index < 0 ||
         !nnet_.IsOutputNode(node_index))
       KALDI_ERR << "Network has no output named " << sup.name;
 
     const CuMatrixBase<BaseFloat> &nnet_output = computer->GetOutput(sup.name);
     bool use_xent = (chain_config_.xent_regularize != 0.0);
     std::string xent_name = sup.name + "-xent";  // typically "output-xent".
     CuMatrix<BaseFloat> nnet_output_deriv, xent_deriv;
     if (nnet_config_.compute_deriv)
       nnet_output_deriv.Resize(nnet_output.NumRows(), nnet_output.NumCols(),
                                kUndefined);
     if (use_xent)
       xent_deriv.Resize(nnet_output.NumRows(), nnet_output.NumCols(),
                         kUndefined);
 
     BaseFloat tot_like, tot_l2_term, tot_weight;
 
     ComputeChainObjfAndDeriv(chain_config_, den_graph_,
                              sup.supervision, nnet_output,
                              &tot_like, &tot_l2_term, &tot_weight,
                              (nnet_config_.compute_deriv ? &nnet_output_deriv :
                               NULL), (use_xent ? &xent_deriv : NULL));
 
     // note: in this context we don't want to apply 'sup.deriv_weights' because
     // this code is used only in combination, where it's part of an L-BFGS
     // optimization algorithm, and in that case if there is a mismatch between
     // the computed objective function and the derivatives, it may cause errors
     // in the optimization procedure such as early termination.  (line search
     // and conjugate gradient descent both rely on the derivatives being
     // accurate, and don't fail gracefully if the derivatives are not accurate).
 
     ChainObjectiveInfo &totals = objf_info_[sup.name];
     totals.tot_weight += tot_weight;
     totals.tot_like += tot_like;
     totals.tot_l2_term += tot_l2_term;
 
     if (nnet_config_.compute_deriv)
       computer->AcceptInput(sup.name, &nnet_output_deriv);
 
     if (use_xent) {
       ChainObjectiveInfo &xent_totals = objf_info_[xent_name];
       // this block computes the cross-entropy objective.
       const CuMatrixBase<BaseFloat> &xent_output = computer->GetOutput(
           xent_name);
       // at this point, xent_deriv is posteriors derived from the numerator
       // computation.  note, xent_deriv has a factor of '.supervision.weight',
       // but so does tot_weight.
       BaseFloat xent_objf = TraceMatMat(xent_output, xent_deriv, kTrans);
       xent_totals.tot_weight += tot_weight;
       xent_totals.tot_like += xent_objf;
     }
     num_minibatches_processed_++;
   }
 }

◆ Reset()

void Reset ( )

Definition at line 79 of file nnet-chain-diagnostics.cc.

References NnetChainComputeProb::deriv_nnet_, NnetChainComputeProb::num_minibatches_processed_, NnetChainComputeProb::objf_info_, kaldi::nnet3::ScaleNnet(), and kaldi::nnet3::SetNnetAsGradient().

                                  {
   num_minibatches_processed_ = 0;
   objf_info_.clear();
   if (deriv_nnet_) {
     ScaleNnet(0.0, deriv_nnet_);
     SetNnetAsGradient(deriv_nnet_);
   }
 }