Collaboration diagram for NnetExampleBackgroundReader:

[legend]

Public Member Functions
	NnetExampleBackgroundReader (int32 minibatch_size, Nnet nnet, SequentialNnetExampleReader reader)

	~NnetExampleBackgroundReader ()

void	ReadExamples ()

bool	GetNextMinibatch (std::vector< NnetExample > examples, Matrix< BaseFloat > formatted_examples, double *total_weight)

Static Public Member Functions
static void *	Run (void *ptr_in)

Private Attributes
int32	minibatch_size_

Nnet *	nnet_

SequentialNnetExampleReader *	reader_

std::thread	thread_

std::vector< NnetExample >	examples_

Matrix< BaseFloat >	formatted_examples_

double	total_weight_

Semaphore	producer_semaphore_

Semaphore	consumer_semaphore_

bool	finished_

Detailed Description

Definition at line 27 of file train-nnet.cc.

Constructor & Destructor Documentation

◆ NnetExampleBackgroundReader()

NnetExampleBackgroundReader	(	int32	minibatch_size,
		Nnet *	nnet,
		SequentialNnetExampleReader *	reader
	)

inline

Definition at line 29 of file train-nnet.cc.

References NnetExampleBackgroundReader::consumer_semaphore_, NnetExampleBackgroundReader::Run(), Semaphore::Signal(), and NnetExampleBackgroundReader::thread_.

                                                                   :
       minibatch_size_(minibatch_size), nnet_(nnet), reader_(reader),
       finished_(false) {
     // When this class is created, it spawns a thread which calls ReadExamples()
     // in the background. Below, Run is the static class-member function.
     thread_ = std::thread(Run, this);
     // the following call is a signal that no-one is currently using the examples_ and
     // formatted_examples_ class members.
     consumer_semaphore_.Signal();
   }

◆ ~NnetExampleBackgroundReader()

~NnetExampleBackgroundReader ( )

inline

Definition at line 41 of file train-nnet.cc.

References KALDI_ERR, and NnetExampleBackgroundReader::thread_.

                                  {
     if (!thread_.joinable())
       KALDI_ERR << "No thread to join.";
     thread_.join();
   }

Member Function Documentation

◆ GetNextMinibatch()

bool GetNextMinibatch	(	std::vector< NnetExample > *	examples,
		Matrix< BaseFloat > *	formatted_examples,
		double *	total_weight
	)

inline

Definition at line 104 of file train-nnet.cc.

References NnetExampleBackgroundReader::consumer_semaphore_, NnetExampleBackgroundReader::examples_, NnetExampleBackgroundReader::finished_, NnetExampleBackgroundReader::formatted_examples_, KALDI_ASSERT, NnetExampleBackgroundReader::producer_semaphore_, Semaphore::Signal(), Matrix< Real >::Swap(), NnetExampleBackgroundReader::total_weight_, and Semaphore::Wait().

Referenced by kaldi::nnet2::TrainNnetSimple().

                                               {
     KALDI_ASSERT(!finished_);
     // wait until examples_ and formatted_examples_ have been created by
     // the background thread.
     producer_semaphore_.Wait();
     // the calls to swap and Swap are lightweight.
     examples_.swap(*examples);
     formatted_examples_.Swap(formatted_examples);
     *total_weight = total_weight_;
 
     // signal the background thread that it is now free to write
     // again to examples_ and formatted_examples_.
     consumer_semaphore_.Signal();
 
     if (examples->empty()) {
       finished_ = true;
       return false;
     } else {
       return true;
     }
   }

◆ ReadExamples()

void ReadExamples ( )

inline

Definition at line 49 of file train-nnet.cc.

References NnetExampleBackgroundReader::consumer_semaphore_, SequentialTableReader< Holder >::Done(), NnetExampleBackgroundReader::examples_, kaldi::nnet2::FormatNnetInput(), NnetExampleBackgroundReader::formatted_examples_, KALDI_ASSERT, NnetExampleBackgroundReader::minibatch_size_, SequentialTableReader< Holder >::Next(), NnetExampleBackgroundReader::nnet_, NnetExampleBackgroundReader::producer_semaphore_, NnetExampleBackgroundReader::reader_, Matrix< Real >::Resize(), Semaphore::Signal(), NnetExampleBackgroundReader::total_weight_, kaldi::nnet2::TotalNnetTrainingWeight(), SequentialTableReader< Holder >::Value(), and Semaphore::Wait().

Referenced by NnetExampleBackgroundReader::Run().

                       {
     KALDI_ASSERT(minibatch_size_ > 0);
     int32 minibatch_size = minibatch_size_;
 
 
     // Loop over minibatches...
     while (true) {
       // When the following call succeeds we interpret it as a signal that
       // we are free to write to the class-member variables examples_ and formatted_examples_.
       consumer_semaphore_.Wait();
 
       examples_.clear();
       examples_.reserve(minibatch_size);
       // Read the examples.
       for (; examples_.size() < minibatch_size && !reader_->Done(); reader_->Next())
         examples_.push_back(reader_->Value());
 
       // Format the examples as a single matrix.  The reason we do this here is
       // that it's a somewhat CPU-intensive operation (involves decompressing
       // the matrix), so we do it in a separate thread from the one that's
       // controlling the GPU (assuming we're using a GPU), so we can get better
       // GPU utilization.  If we have no GPU this doesn't hurt us.
       if (examples_.empty()) {
         formatted_examples_.Resize(0, 0);
         total_weight_ = 0.0;
       } else {
         FormatNnetInput(*nnet_, examples_, &formatted_examples_);
         total_weight_ = TotalNnetTrainingWeight(examples_);
       }
 
       bool finished = examples_.empty();
 
       // The following call alerts the main program thread (that calls
       // GetNextMinibatch() that it can how use the contents of
       // examples_ and formatted_examples_.
       producer_semaphore_.Signal();
 
       // If we just read an empty minibatch (because no more examples),
       // then return.
       if (finished)
         return;
     }
   }

◆ Run()

static void* Run ( void * ptr_in )

inlinestatic

Definition at line 94 of file train-nnet.cc.

References NnetExampleBackgroundReader::ReadExamples().

Referenced by NnetExampleBackgroundReader::NnetExampleBackgroundReader().

                                  {
     NnetExampleBackgroundReader *ptr =
         reinterpret_cast<NnetExampleBackgroundReader*>(ptr_in);
     ptr->ReadExamples();
     return NULL;
   }