#include <parallel.h>

Inheritance diagram for tesseract::Parallel:

Public Member Functions
	Parallel (const STRING &name, NetworkType type)

	~Parallel () override=default

StaticShape	OutputShape (const StaticShape &input_shape) const override

STRING	spec () const override

void	Forward (bool debug, const NetworkIO &input, const TransposedArray input_transpose, NetworkScratch scratch, NetworkIO *output) override

bool	Backward (bool debug, const NetworkIO &fwd_deltas, NetworkScratch scratch, NetworkIO back_deltas) override

Public Member Functions inherited from tesseract::Plumbing
	Plumbing (const STRING &name)

	~Plumbing () override=default

StaticShape	InputShape () const override

STRING	spec () const override

bool	IsPlumbingType () const override

void	SetEnableTraining (TrainingState state) override

void	SetNetworkFlags (uint32_t flags) override

int	InitWeights (float range, TRand *randomizer) override

int	RemapOutputs (int old_no, const std::vector< int > &code_map) override

void	ConvertToInt () override

void	SetRandomizer (TRand *randomizer) override

virtual void	AddToStack (Network *network)

bool	SetupNeedsBackprop (bool needs_backprop) override

int	XScaleFactor () const override

void	CacheXScaleFactor (int factor) override

void	DebugWeights () override

const PointerVector< Network > &	stack () const

void	EnumerateLayers (const STRING prefix, GenericVector< STRING > layers) const

Network *	GetLayer (const char *id) const

float	LayerLearningRate (const char *id) const

void	ScaleLayerLearningRate (const char *id, double factor)

float *	LayerLearningRatePtr (const char *id) const

bool	Serialize (TFile *fp) const override

bool	DeSerialize (TFile *fp) override

void	Update (float learning_rate, float momentum, float adam_beta, int num_samples) override

void	CountAlternators (const Network &other, double same, double changed) const override

Public Member Functions inherited from tesseract::Network
	Network ()

	Network (NetworkType type, const STRING &name, int ni, int no)

virtual	~Network ()=default

NetworkType	type () const

bool	IsTraining () const

bool	needs_to_backprop () const

int	num_weights () const

int	NumInputs () const

int	NumOutputs () const

const STRING &	name () const

bool	TestFlag (NetworkFlags flag) const

void	DisplayForward (const NetworkIO &matrix)

void	DisplayBackward (const NetworkIO &matrix)

Additional Inherited Members
Static Public Member Functions inherited from tesseract::Network
static Network *	CreateFromFile (TFile *fp)

static void	ClearWindow (bool tess_coords, const char window_name, int width, int height, ScrollView *window)

static int	DisplayImage (Pix pix, ScrollView window)

Protected Member Functions inherited from tesseract::Network
double	Random (double range)

Protected Attributes inherited from tesseract::Plumbing
PointerVector< Network >	stack_

GenericVector< float >	learning_rates_

Protected Attributes inherited from tesseract::Network
NetworkType	type_

TrainingState	training_

bool	needs_to_backprop_

int32_t	network_flags_

int32_t	ni_

int32_t	no_

int32_t	num_weights_

STRING	name_

ScrollView *	forward_win_

ScrollView *	backward_win_

TRand *	randomizer_

Detailed Description

Definition at line 27 of file parallel.h.

Constructor & Destructor Documentation

◆ Parallel()

tesseract::Parallel::Parallel	(	const STRING &	name,
		NetworkType	type
	)

Definition at line 31 of file parallel.cpp.

                                                        : Plumbing(name) {
   type_ = type;
 }

◆ ~Parallel()

tesseract::Parallel::~Parallel ( )

overridedefault

Member Function Documentation

◆ Backward()

bool tesseract::Parallel::Backward	(	bool	debug,
		const NetworkIO &	fwd_deltas,
		NetworkScratch *	scratch,
		NetworkIO *	back_deltas
	)

overridevirtual

Implements tesseract::Network.

Definition at line 110 of file parallel.cpp.

                                                 {
   // If this parallel is a replicator of convolvers, or holds a 1-d LSTM pair,
   // or a 2-d LSTM quad, do debug locally, and don't pass the flag on.
   if (debug && type_ != NT_PARALLEL) {
     DisplayBackward(fwd_deltas);
     debug = false;
   }
   int stack_size = stack_.size();
   if (type_ == NT_PAR_2D_LSTM) {
     // Special case, run parallel in parallel.
     GenericVector<NetworkScratch::IO> in_deltas, out_deltas;
     in_deltas.init_to_size(stack_size, NetworkScratch::IO());
     out_deltas.init_to_size(stack_size, NetworkScratch::IO());
     // Split the forward deltas for each stack element.
     int feature_offset = 0;
     for (int i = 0; i < stack_.size(); ++i) {
       int num_features = stack_[i]->NumOutputs();
       in_deltas[i].Resize(fwd_deltas, num_features, scratch);
       out_deltas[i].Resize(fwd_deltas, stack_[i]->NumInputs(), scratch);
       in_deltas[i]->CopyUnpacking(fwd_deltas, feature_offset, num_features);
       feature_offset += num_features;
     }
 #ifdef _OPENMP
 #pragma omp parallel for num_threads(stack_size)
 #endif
     for (int i = 0; i < stack_size; ++i) {
       stack_[i]->Backward(debug, *in_deltas[i], scratch,
                           i == 0 ? back_deltas : out_deltas[i]);
     }
     if (needs_to_backprop_) {
       for (int i = 1; i < stack_size; ++i) {
         back_deltas->AddAllToFloat(*out_deltas[i]);
       }
     }
   } else {
     // Revolving partial deltas.
     NetworkScratch::IO in_deltas(fwd_deltas, scratch);
     // The sum of deltas from different sources, which will eventually go into
     // back_deltas.
     NetworkScratch::IO out_deltas;
     int feature_offset = 0;
     for (int i = 0; i < stack_.size(); ++i) {
       int num_features = stack_[i]->NumOutputs();
       in_deltas->CopyUnpacking(fwd_deltas, feature_offset, num_features);
       feature_offset += num_features;
       if (stack_[i]->Backward(debug, *in_deltas, scratch, back_deltas)) {
         if (i == 0) {
           out_deltas.ResizeFloat(*back_deltas, back_deltas->NumFeatures(),
                                  scratch);
           out_deltas->CopyAll(*back_deltas);
         } else if (back_deltas->NumFeatures() == out_deltas->NumFeatures()) {
           // Widths are allowed to be different going back, as we may have
           // input nets, so only accumulate the deltas if the widths are the
           // same.
           out_deltas->AddAllToFloat(*back_deltas);
         }
       }
     }
     if (needs_to_backprop_) back_deltas->CopyAll(*out_deltas);
   }
   if (needs_to_backprop_) back_deltas->ScaleFloatBy(1.0f / stack_size);
   return needs_to_backprop_;
 }

◆ Forward()

void tesseract::Parallel::Forward	(	bool	debug,
		const NetworkIO &	input,
		const TransposedArray *	input_transpose,
		NetworkScratch *	scratch,
		NetworkIO *	output
	)

overridevirtual

Implements tesseract::Network.

Definition at line 49 of file parallel.cpp.

                                                                    {
   bool parallel_debug = false;
   // If this parallel is a replicator of convolvers, or holds a 1-d LSTM pair,
   // or a 2-d LSTM quad, do debug locally, and don't pass the flag on.
   if (debug && type_ != NT_PARALLEL) {
     parallel_debug = true;
     debug = false;
   }
   int stack_size = stack_.size();
   if (type_ == NT_PAR_2D_LSTM) {
     // Special case, run parallel in parallel.
     GenericVector<NetworkScratch::IO> results;
     results.init_to_size(stack_size, NetworkScratch::IO());
     for (int i = 0; i < stack_size; ++i) {
       results[i].Resize(input, stack_[i]->NumOutputs(), scratch);
     }
 #ifdef _OPENMP
 #pragma omp parallel for num_threads(stack_size)
 #endif
     for (int i = 0; i < stack_size; ++i) {
       stack_[i]->Forward(debug, input, nullptr, scratch, results[i]);
     }
     // Now pack all the results (serially) into the output.
     int out_offset = 0;
     output->Resize(*results[0], NumOutputs());
     for (int i = 0; i < stack_size; ++i) {
       out_offset = output->CopyPacking(*results[i], out_offset);
     }
   } else {
     // Revolving intermediate result.
     NetworkScratch::IO result(input, scratch);
     // Source for divided replicated.
     NetworkScratch::IO source_part;
     TransposedArray* src_transpose = nullptr;
     if (IsTraining() && type_ == NT_REPLICATED) {
       // Make a transposed copy of the input.
       input.Transpose(&transposed_input_);
       src_transpose = &transposed_input_;
     }
     // Run each network, putting the outputs into result.
     int out_offset = 0;
     for (int i = 0; i < stack_size; ++i) {
       stack_[i]->Forward(debug, input, src_transpose, scratch, result);
       // All networks must have the same output width
       if (i == 0) {
         output->Resize(*result, NumOutputs());
       } else {
         ASSERT_HOST(result->Width() == output->Width());
       }
       out_offset = output->CopyPacking(*result, out_offset);
     }
   }
   if (parallel_debug) {
     DisplayForward(*output);
   }
 }

◆ OutputShape()

StaticShape tesseract::Parallel::OutputShape ( const StaticShape & input_shape ) const

overridevirtual

Reimplemented from tesseract::Network.

Definition at line 37 of file parallel.cpp.

                                                                       {
   StaticShape result = stack_[0]->OutputShape(input_shape);
   int stack_size = stack_.size();
   for (int i = 1; i < stack_size; ++i) {
     StaticShape shape = stack_[i]->OutputShape(input_shape);
     result.set_depth(result.depth() + shape.depth());
   }
   return result;
 }

◆ spec()

STRING tesseract::Parallel::spec ( ) const

inlineoverridevirtual

Reimplemented from tesseract::Network.

Definition at line 37 of file parallel.h.

                                {
     STRING spec;
     if (type_ == NT_PAR_2D_LSTM) {
       // We have 4 LSTMs operating in parallel here, so the size of each is
       // the number of outputs/4.
       spec.add_str_int("L2xy", no_ / 4);
     } else if (type_ == NT_PAR_RL_LSTM) {
       // We have 2 LSTMs operating in parallel here, so the size of each is
       // the number of outputs/2.
       if (stack_[0]->type() == NT_LSTM_SUMMARY)
         spec.add_str_int("Lbxs", no_ / 2);
       else
         spec.add_str_int("Lbx", no_ / 2);
     } else {
       if (type_ == NT_REPLICATED) {
         spec.add_str_int("R", stack_.size());
         spec += "(";
         spec += stack_[0]->spec();
       } else {
         spec = "(";
         for (int i = 0; i < stack_.size(); ++i) spec += stack_[i]->spec();
       }
       spec += ")";
     }
     return spec;
   }

The documentation for this class was generated from the following files:

/tesseract/src/lstm/parallel.h
/tesseract/src/lstm/parallel.cpp

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Parallel()

◆ ~Parallel()

Member Function Documentation

◆ Backward()

◆ Forward()

◆ OutputShape()

◆ spec()