#include <parallel.h>

Inheritance diagram for tesseract::Parallel:

Public Member Functions
TESS_API	Parallel (const char *name, NetworkType type)

StaticShape	OutputShape (const StaticShape &input_shape) const override

std::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 std::string &name)

	~Plumbing () override

StaticShape	InputShape () const override

std::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 std::vector< Network * > &	stack () const

void	EnumerateLayers (const std::string *prefix, std::vector< std::string > &layers) const

Network *	GetLayer (const char *id) const

float	LayerLearningRate (const char *id)

void	ScaleLayerLearningRate (const char *id, double factor)

void	SetLayerLearningRate (const char *id, float learning_rate)

float *	LayerLearningRatePtr (const char *id)

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, TFloat same, TFloat changed) const override

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

	Network (NetworkType type, const std::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

virtual StaticShape	InputShape () const

virtual StaticShape	OutputShape (const StaticShape &input_shape) const

const std::string &	name () const

virtual std::string	spec () const

bool	TestFlag (NetworkFlags flag) const

virtual bool	IsPlumbingType () const

virtual void	SetEnableTraining (TrainingState state)

virtual void	SetNetworkFlags (uint32_t flags)

virtual int	InitWeights (float range, TRand *randomizer)

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

virtual void	ConvertToInt ()

virtual void	SetRandomizer (TRand *randomizer)

virtual bool	SetupNeedsBackprop (bool needs_backprop)

virtual int	XScaleFactor () const

virtual void	CacheXScaleFactor (int factor)

virtual void	DebugWeights ()=0

virtual bool	Serialize (TFile *fp) const

virtual bool	DeSerialize (TFile *fp)=0

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

virtual void	CountAlternators (const Network &other, TFloat same, TFloat changed) const

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

virtual bool	Backward (bool debug, const NetworkIO &fwd_deltas, NetworkScratch scratch, NetworkIO back_deltas)=0

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 (Image pix, ScrollView *window)

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

Protected Attributes inherited from tesseract::Plumbing
std::vector< Network * >	stack_

std::vector< 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_

std::string	name_

ScrollView *	forward_win_

ScrollView *	backward_win_

TRand *	randomizer_

Detailed Description

Definition at line 26 of file parallel.h.

Constructor & Destructor Documentation

◆ Parallel()

tesseract::Parallel::Parallel	(	const char *	name,
		NetworkType	type
	)

Definition at line 34 of file parallel.cpp.

                                                     : Plumbing(name) {
  type_ = type;
}

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 113 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) {
#ifndef GRAPHICS_DISABLED
    DisplayBackward(fwd_deltas);
#endif
    debug = false;
  }
  auto stack_size = stack_.size();
  if (type_ == NT_PAR_2D_LSTM) {
    // Special case, run parallel in parallel.
    std::vector<NetworkScratch::IO> in_deltas(stack_size);
    std::vector<NetworkScratch::IO> out_deltas(stack_size);
    // Split the forward deltas for each stack element.
    int feature_offset = 0;
    for (unsigned 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 (unsigned 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 (unsigned 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 (unsigned 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 52 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.
    std::vector<NetworkScratch::IO> results(stack_size);
    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);
    }
  }
#ifndef GRAPHICS_DISABLED
  if (parallel_debug) {
    DisplayForward(*output);
  }
#endif
}

◆ OutputShape()

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

overridevirtual

Reimplemented from tesseract::Network.

Definition at line 40 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()

std::string tesseract::Parallel::spec ( ) const

inlineoverridevirtual

Reimplemented from tesseract::Network.

Definition at line 36 of file parallel.h.

                                  {
    std::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 += "L2xy" + std::to_string(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 += "Lbxs" + std::to_string(no_ / 2);
      } else {
        spec += "Lbx" + std::to_string(no_ / 2);
      }
    } else {
      if (type_ == NT_REPLICATED) {
        spec += "R" + std::to_string(stack_.size()) + "(" + stack_[0]->spec();
      } else {
        for (auto &it : stack_) {
          spec += it->spec();
        }
      }
      spec += ")";
    }
    return spec;
  }

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

/media/home/debian/src/github/tesseract-ocr/tesseract/src/lstm/parallel.h
/media/home/debian/src/github/tesseract-ocr/tesseract/src/lstm/parallel.cpp

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Parallel()

Member Function Documentation

◆ Backward()

◆ Forward()

◆ OutputShape()

◆ spec()