This class is for computing cross-entropy and accuracy values in a neural network, for diagnostics. More...

#include <nnet-diagnostics.h>

Collaboration diagram for NnetComputeProb:

[legend]

Public Member Functions
	NnetComputeProb (const NnetComputeProbOptions &config, const Nnet &nnet)

	NnetComputeProb (const NnetComputeProbOptions &config, Nnet *nnet)

void	Reset ()

void	Compute (const NnetExample &eg)

bool	PrintTotalStats () const

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

double	GetTotalObjective (double *tot_weight) const

const Nnet &	GetDeriv () const

	~NnetComputeProb ()

Private Member Functions
void	ProcessOutputs (const NnetExample &eg, NnetComputer *computer)

Private Attributes
NnetComputeProbOptions	config_

const Nnet &	nnet_

bool	deriv_nnet_owned_

Nnet *	deriv_nnet_

CachingOptimizingCompiler	compiler_

int32	num_minibatches_processed_

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

unordered_map< std::string, PerDimObjectiveInfo, StringHasher >	accuracy_info_

Detailed Description

This class is for computing cross-entropy and accuracy values in a neural network, for diagnostics.

Note: because we put a "logsoftmax" component in the nnet, the actual objective function becomes linear at the output, but the printed messages reflect the fact that it's the cross-entropy objective.

Definition at line 107 of file nnet-diagnostics.h.

Constructor & Destructor Documentation

◆ NnetComputeProb() [1/2]

NnetComputeProb	(	const NnetComputeProbOptions &	config,
		const Nnet &	nnet
	)

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

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

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

◆ NnetComputeProb() [2/2]

NnetComputeProb	(	const NnetComputeProbOptions &	config,
		Nnet *	nnet
	)

Definition at line 45 of file nnet-diagnostics.cc.

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

                                             :
     config_(config),
     nnet_(*nnet),
     deriv_nnet_owned_(false),
     deriv_nnet_(nnet),
     compiler_(*nnet, config_.optimize_config, config_.compiler_config),
     num_minibatches_processed_(0) {
   KALDI_ASSERT(config.store_component_stats && !config.compute_deriv);
 }

◆ ~NnetComputeProb()

~NnetComputeProb ( )

Definition at line 64 of file nnet-diagnostics.cc.

References NnetComputeProb::deriv_nnet_, and NnetComputeProb::deriv_nnet_owned_.

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

Member Function Documentation

◆ Compute()

void Compute ( const NnetExample & eg )

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

References NnetComputer::AcceptInputs(), CachingOptimizingCompiler::Compile(), NnetComputeProb::compiler_, NnetComputeProbOptions::compute_config, NnetComputeProbOptions::compute_deriv, NnetComputeProb::config_, NnetComputeProb::deriv_nnet_, kaldi::nnet3::GetComputationRequest(), NnetExample::io, NnetComputeProb::nnet_, NnetComputeProb::ProcessOutputs(), NnetComputer::Run(), and NnetComputeProbOptions::store_component_stats.

Referenced by kaldi::nnet3::ComputeObjf(), main(), and kaldi::nnet3::RecomputeStats().

                                                    {
   bool need_model_derivative = config_.compute_deriv,
       store_component_stats = config_.store_component_stats;
   ComputationRequest request;
   GetComputationRequest(nnet_, eg, need_model_derivative,
                         store_component_stats,
                         &request);
   std::shared_ptr<const NnetComputation> computation = compiler_.Compile(request);
   NnetComputer computer(config_.compute_config, *computation,
                         nnet_, deriv_nnet_);
   // give the inputs to the computer object.
   computer.AcceptInputs(nnet_, eg.io);
   computer.Run();
   this->ProcessOutputs(eg, &computer);
   if (config_.compute_deriv)
     computer.Run();
 }

◆ GetDeriv()

const Nnet & GetDeriv ( ) const

Definition at line 58 of file nnet-diagnostics.cc.

References NnetComputeProbOptions::compute_deriv, NnetComputeProb::config_, NnetComputeProb::deriv_nnet_, and KALDI_ERR.

Referenced by main().

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

◆ GetObjective()

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

Definition at line 299 of file nnet-diagnostics.cc.

References NnetComputeProb::objf_info_.

Referenced by main().

                                         {
   unordered_map<std::string, SimpleObjectiveInfo, 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 309 of file nnet-diagnostics.cc.

References NnetComputeProb::objf_info_.

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

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

◆ PrintTotalStats()

bool PrintTotalStats ( ) const

Definition at line 149 of file nnet-diagnostics.cc.

References NnetComputeProb::accuracy_info_, Nnet::GetNode(), Nnet::GetNodeIndex(), rnnlm::j, KALDI_ASSERT, KALDI_LOG, kaldi::nnet3::kLinear, NnetComputeProb::nnet_, NetworkNode::objective_type, NnetComputeProb::objf_info_, SimpleObjectiveInfo::tot_objective, PerDimObjectiveInfo::tot_objective_vec, SimpleObjectiveInfo::tot_weight, PerDimObjectiveInfo::tot_weight_vec, and NetworkNode::u.

Referenced by main(), and kaldi::nnet3::RecomputeStats().

                                             {
   bool ans = false;
   { // First print regular objectives
     unordered_map<std::string, SimpleObjectiveInfo,
                   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);
       ObjectiveType obj_type = nnet_.GetNode(node_index).u.objective_type;
       const SimpleObjectiveInfo &info = iter->second;
       KALDI_LOG << "Overall "
                 << (obj_type == kLinear ? "log-likelihood" : "objective")
                 << " for '" << name << "' is "
                 << (info.tot_objective / info.tot_weight) << " per frame"
                 << ", over " << info.tot_weight << " frames.";
       if (info.tot_weight > 0)
         ans = true;
     }
   }
   {
     unordered_map<std::string, PerDimObjectiveInfo,
                   StringHasher>::const_iterator iter, end;
     // now print accuracies.
     iter = accuracy_info_.begin();
     end = accuracy_info_.end();
     for (; iter != end; ++iter) {
       const std::string &name = iter->first;
       const PerDimObjectiveInfo &info = iter->second;
       KALDI_LOG << "Overall accuracy for '" << name << "' is "
                 << (info.tot_objective / info.tot_weight) << " per frame"
                 << ", over " << info.tot_weight << " frames.";
 
       if (info.tot_weight_vec.Dim() > 0) {
         Vector<BaseFloat> accuracy_vec(info.tot_weight_vec.Dim());
         for (size_t j = 0; j < info.tot_weight_vec.Dim(); j++) {
           if (info.tot_weight_vec(j) !=  0) {
             accuracy_vec(j) = info.tot_objective_vec(j)
                               / info.tot_weight_vec(j);
           } else {
             accuracy_vec(j) = -1.0;
           }
         }
 
         KALDI_LOG << "Overall per-dim accuracy vector for '" << name
                   << "' is " << accuracy_vec << " per frame"
                   << ", over " << info.tot_weight << " frames.";
       }
       // don't bother changing ans; the loop over the regular objective should
       // already have set it to true if we got any data.
     }
   }
   return ans;
 }

◆ ProcessOutputs()

void ProcessOutputs	(	const NnetExample &	eg,
		NnetComputer *	computer
	)

private

Definition at line 97 of file nnet-diagnostics.cc.

References NnetComputeProb::accuracy_info_, NnetComputeProbOptions::compute_accuracy, NnetComputeProbOptions::compute_deriv, NnetComputeProbOptions::compute_per_dim_accuracy, kaldi::nnet3::ComputeAccuracy(), kaldi::nnet3::ComputeObjectiveFunction(), NnetComputeProb::config_, NnetIo::features, Nnet::GetNode(), Nnet::GetNodeIndex(), NnetComputer::GetOutput(), NnetExample::io, Nnet::IsOutputNode(), KALDI_ERR, NnetIo::name, NnetComputeProb::nnet_, NnetComputeProb::num_minibatches_processed_, CuMatrixBase< Real >::NumCols(), GeneralMatrix::NumCols(), NetworkNode::objective_type, NnetComputeProb::objf_info_, SimpleObjectiveInfo::tot_objective, PerDimObjectiveInfo::tot_objective_vec, SimpleObjectiveInfo::tot_weight, PerDimObjectiveInfo::tot_weight_vec, and NetworkNode::u.

Referenced by NnetComputeProb::Compute().

                                                              {
   std::vector<NnetIo>::const_iterator iter = eg.io.begin(),
       end = eg.io.end();
   for (; iter != end; ++iter) {
     const NnetIo &io = *iter;
     int32 node_index = nnet_.GetNodeIndex(io.name);
     if (node_index < 0)
       KALDI_ERR << "Network has no output named " << io.name;
     ObjectiveType obj_type = nnet_.GetNode(node_index).u.objective_type;
     if (nnet_.IsOutputNode(node_index)) {
       const CuMatrixBase<BaseFloat> &output = computer->GetOutput(io.name);
       if (output.NumCols() != io.features.NumCols()) {
         KALDI_ERR << "Nnet versus example output dimension (num-classes) "
                   << "mismatch for '" << io.name << "': " << output.NumCols()
                   << " (nnet) vs. " << io.features.NumCols() << " (egs)\n";
       }
       {
         BaseFloat tot_weight, tot_objf;
         bool supply_deriv = config_.compute_deriv;
         ComputeObjectiveFunction(io.features, obj_type, io.name,
                                  supply_deriv, computer,
                                  &tot_weight, &tot_objf);
         SimpleObjectiveInfo &totals = objf_info_[io.name];
         totals.tot_weight += tot_weight;
         totals.tot_objective += tot_objf;
       }
       // May not be meaningful in non-classification tasks
       if (config_.compute_accuracy) {
         BaseFloat tot_weight, tot_accuracy;
         PerDimObjectiveInfo &acc_totals = accuracy_info_[io.name];
 
         if (config_.compute_per_dim_accuracy &&
             acc_totals.tot_objective_vec.Dim() == 0) {
           acc_totals.tot_objective_vec.Resize(output.NumCols());
           acc_totals.tot_weight_vec.Resize(output.NumCols());
         }
 
         ComputeAccuracy(io.features, output,
                         &tot_weight, &tot_accuracy,
                         config_.compute_per_dim_accuracy ?
                           &acc_totals.tot_weight_vec : NULL,
                         config_.compute_per_dim_accuracy ?
                           &acc_totals.tot_objective_vec : NULL);
         acc_totals.tot_weight += tot_weight;
         acc_totals.tot_objective += tot_accuracy;
       }
     }
   }
   num_minibatches_processed_++;
 }

◆ Reset()

void Reset ( )

Definition at line 69 of file nnet-diagnostics.cc.

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

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

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