Inheritance diagram for DoBackpropParallelClass:

Collaboration diagram for DoBackpropParallelClass:

[legend]

Public Member Functions
	DoBackpropParallelClass (const Nnet &nnet, ExamplesRepository repository, double tot_weight_ptr, double log_prob_ptr, Nnet nnet_to_update, bool store_separate_gradients)

	DoBackpropParallelClass (const DoBackpropParallelClass &other)

void	operator() ()

	~DoBackpropParallelClass ()

Public Member Functions inherited from MultiThreadable
virtual	~MultiThreadable ()

Private Attributes
const Nnet &	nnet_

ExamplesRepository *	repository_

Nnet *	nnet_to_update_

Nnet *	nnet_to_update_orig_

bool	store_separate_gradients_

double *	tot_weight_ptr_

double *	log_prob_ptr_

double	tot_weight_

double	log_prob_

Additional Inherited Members
Public Attributes inherited from MultiThreadable
int32	thread_id_

int32	num_threads_

Detailed Description

Definition at line 29 of file nnet-update-parallel.cc.

Constructor & Destructor Documentation

◆ DoBackpropParallelClass() [1/2]

DoBackpropParallelClass	(	const Nnet &	nnet,
		ExamplesRepository *	repository,
		double *	tot_weight_ptr,
		double *	log_prob_ptr,
		Nnet *	nnet_to_update,
		bool	store_separate_gradients
	)

inline

Definition at line 33 of file nnet-update-parallel.cc.

                                                         :
       nnet_(nnet), repository_(repository),
       nnet_to_update_(nnet_to_update),
       nnet_to_update_orig_(nnet_to_update),
       store_separate_gradients_(store_separate_gradients),
       tot_weight_ptr_(tot_weight_ptr),
       log_prob_ptr_(log_prob_ptr),
       tot_weight_(0.0),
       log_prob_(0.0) { }

◆ DoBackpropParallelClass() [2/2]

DoBackpropParallelClass ( const DoBackpropParallelClass & other )

inline

Definition at line 50 of file nnet-update-parallel.cc.

References DoBackpropParallelClass::nnet_to_update_, Nnet::SetZero(), and DoBackpropParallelClass::store_separate_gradients_.

                                                                :
       MultiThreadable(other),
       nnet_(other.nnet_),
       repository_(other.repository_),
       nnet_to_update_(other.nnet_to_update_),
       nnet_to_update_orig_(other.nnet_to_update_orig_),
       store_separate_gradients_(other.store_separate_gradients_),
       tot_weight_ptr_(other.tot_weight_ptr_),
       log_prob_ptr_(other.log_prob_ptr_),
       tot_weight_(0),
       log_prob_(0.0) {
     if (store_separate_gradients_) {
       // To ensure correctness, we work on separate copies of the gradient
       // object, which we'll sum at the end.  This is used for exact gradient
       // computation.
       if (other.nnet_to_update_ != NULL) {
         nnet_to_update_ = new Nnet(*(other.nnet_to_update_));
         // our "nnet_to_update_" variable is a copy of the neural network
         // we are to update (presumably a gradient).  If we don't set these
         // to zero we would end up adding multiple copies of the any initial
         // gradient that "nnet_to_update_" contained when we initialize
         // the first instance of the class.
         nnet_to_update_->SetZero(true);
       } else { // support case where we don't really need a gradient.
         nnet_to_update_ = NULL;
       }
     }
   }

◆ ~DoBackpropParallelClass()

~DoBackpropParallelClass ( )

inline

Definition at line 98 of file nnet-update-parallel.cc.

References Nnet::AddNnet(), DoBackpropParallelClass::log_prob_, DoBackpropParallelClass::log_prob_ptr_, DoBackpropParallelClass::nnet_to_update_, DoBackpropParallelClass::nnet_to_update_orig_, DoBackpropParallelClass::tot_weight_, and DoBackpropParallelClass::tot_weight_ptr_.

                              {
     if (nnet_to_update_orig_ != nnet_to_update_) {
       // This branch is only taken if this instance of the class is
       // one of the multiple instances allocated inside the RunMultiThreaded
       // template function, *and* store_separate_gradients_ has been set to true.
       // In the typical hogwild case, we don't do this.
       nnet_to_update_orig_->AddNnet(1.0, *nnet_to_update_);
       delete nnet_to_update_;
     }
     *log_prob_ptr_ += log_prob_;
     *tot_weight_ptr_ += tot_weight_;
   }

Member Function Documentation

◆ operator()()

void operator() ( )

inlinevirtual

Implements MultiThreadable.

Definition at line 79 of file nnet-update-parallel.cc.

References kaldi::nnet2::ComputeNnetObjf(), kaldi::nnet2::DoBackprop(), KALDI_VLOG, DoBackpropParallelClass::log_prob_, DoBackpropParallelClass::nnet_, DoBackpropParallelClass::nnet_to_update_, ExamplesRepository::ProvideExamples(), DoBackpropParallelClass::repository_, MultiThreadable::thread_id_, DoBackpropParallelClass::tot_weight_, and kaldi::nnet2::TotalNnetTrainingWeight().

                       {
     std::vector<NnetExample> examples;
     while (repository_->ProvideExamples(&examples)) {
       // This is a function call to a function defined in
       // nnet-update.h
       double tot_loglike;
       if (nnet_to_update_ != NULL)
         tot_loglike = DoBackprop(nnet_, examples, nnet_to_update_);
       else
         tot_loglike = ComputeNnetObjf(nnet_, examples);
       tot_weight_ += TotalNnetTrainingWeight(examples);
       log_prob_ += tot_loglike;
       KALDI_VLOG(4) << "Thread " << thread_id_ << " saw "
                     << tot_weight_ << " frames so far (weighted); likelihood "
                     << "per frame so far is " << (log_prob_ / tot_weight_);
       examples.clear();
     }
   }