tesseract::LSTMRecognizer Class Reference

#include <lstmrecognizer.h>

Inheritance diagram for tesseract::LSTMRecognizer:

Public Member Functions
	LSTMRecognizer ()
	~LSTMRecognizer ()
int	NumOutputs () const
int	training_iteration () const
int	sample_iteration () const
double	learning_rate () const
LossType	OutputLossType () const
bool	SimpleTextOutput () const
bool	IsIntMode () const
bool	IsRecoding () const
bool	IsTensorFlow () const
GenericVector< STRING >	EnumerateLayers () const
Network *	GetLayer (const STRING &id) const
float	GetLayerLearningRate (const STRING &id) const
void	ScaleLearningRate (double factor)
void	ScaleLayerLearningRate (const STRING &id, double factor)
void	ConvertToInt ()
const UNICHARSET &	GetUnicharset () const
const UnicharCompress &	GetRecoder () const
const Dict *	GetDict () const
void	SetIteration (int iteration)
int	NumInputs () const
int	null_char () const
bool	Load (const char *lang, TessdataManager *mgr)
bool	Serialize (const TessdataManager *mgr, TFile *fp) const
bool	DeSerialize (const TessdataManager *mgr, TFile *fp)
bool	LoadCharsets (const TessdataManager *mgr)
bool	LoadRecoder (TFile *fp)
bool	LoadDictionary (const char *lang, TessdataManager *mgr)
void	RecognizeLine (const ImageData &image_data, bool invert, bool debug, double worst_dict_cert, const TBOX &line_box, PointerVector< WERD_RES > *words)
void	OutputStats (const NetworkIO &outputs, float *min_output, float *mean_output, float *sd)
bool	RecognizeLine (const ImageData &image_data, bool invert, bool debug, bool re_invert, bool upside_down, float *scale_factor, NetworkIO *inputs, NetworkIO *outputs)
STRING	DecodeLabels (const GenericVector< int > &labels)
void	DisplayForward (const NetworkIO &inputs, const GenericVector< int > &labels, const GenericVector< int > &label_coords, const char *window_name, ScrollView **window)
void	LabelsFromOutputs (const NetworkIO &outputs, GenericVector< int > *labels, GenericVector< int > *xcoords)

Protected Member Functions
void	SetRandomSeed ()
void	DisplayLSTMOutput (const GenericVector< int > &labels, const GenericVector< int > &xcoords, int height, ScrollView *window)
void	DebugActivationPath (const NetworkIO &outputs, const GenericVector< int > &labels, const GenericVector< int > &xcoords)
void	DebugActivationRange (const NetworkIO &outputs, const char *label, int best_choice, int x_start, int x_end)
void	LabelsViaReEncode (const NetworkIO &output, GenericVector< int > *labels, GenericVector< int > *xcoords)
void	LabelsViaSimpleText (const NetworkIO &output, GenericVector< int > *labels, GenericVector< int > *xcoords)
const char *	DecodeLabel (const GenericVector< int > &labels, int start, int *end, int *decoded)
const char *	DecodeSingleLabel (int label)

Protected Attributes
Network *	network_
CCUtil	ccutil_
UnicharCompress	recoder_
STRING	network_str_
inT32	training_flags_
inT32	training_iteration_
inT32	sample_iteration_
inT32	null_char_
float	learning_rate_
float	momentum_
float	adam_beta_
TRand	randomizer_
NetworkScratch	scratch_space_
Dict *	dict_
RecodeBeamSearch *	search_
ScrollView *	debug_win_

Detailed Description

Definition at line 53 of file lstmrecognizer.h.

Constructor & Destructor Documentation

LSTMRecognizer()

tesseract::LSTMRecognizer::LSTMRecognizer

(

)

Definition at line 52 of file lstmrecognizer.cpp.

    : network_(NULL),
      training_flags_(0),
      training_iteration_(0),
      sample_iteration_(0),
      null_char_(UNICHAR_BROKEN),
      learning_rate_(0.0f),
      momentum_(0.0f),
      adam_beta_(0.0f),
      dict_(NULL),
      search_(NULL),
      debug_win_(NULL) {}

~LSTMRecognizer()

tesseract::LSTMRecognizer::~LSTMRecognizer

(

)

Definition at line 65 of file lstmrecognizer.cpp.

                                {
  delete network_;
  delete dict_;
  delete search_;
}

Member Function Documentation

ConvertToInt()

void tesseract::LSTMRecognizer::ConvertToInt ( )

inline

Definition at line 131 of file lstmrecognizer.h.

                      {
    if ((training_flags_ & TF_INT_MODE) == 0) {
      network_->ConvertToInt();
      training_flags_ |= TF_INT_MODE;
    }
  }

DebugActivationPath()

void tesseract::LSTMRecognizer::DebugActivationPath ( const NetworkIO &  outputs, const GenericVector< int > &  labels, const GenericVector< int > &  xcoords  )

protected

Definition at line 356 of file lstmrecognizer.cpp.

                                                                            {
  if (xcoords[0] > 0)
    DebugActivationRange(outputs, "<null>", null_char_, 0, xcoords[0]);
  int end = 1;
  for (int start = 0; start < labels.size(); start = end) {
    if (labels[start] == null_char_) {
      end = start + 1;
      DebugActivationRange(outputs, "<null>", null_char_, xcoords[start],
                           xcoords[end]);
      continue;
    } else {
      int decoded;
      const char* label = DecodeLabel(labels, start, &end, &decoded);
      DebugActivationRange(outputs, label, labels[start], xcoords[start],
                           xcoords[start + 1]);
      for (int i = start + 1; i < end; ++i) {
        DebugActivationRange(outputs, DecodeSingleLabel(labels[i]), labels[i],
                             xcoords[i], xcoords[i + 1]);
      }
    }
  }
}

DebugActivationRange()

void tesseract::LSTMRecognizer::DebugActivationRange ( const NetworkIO &  outputs, const char *  label, int  best_choice, int  x_start, int  x_end  )

protected

Definition at line 383 of file lstmrecognizer.cpp.

                                                                  {
  tprintf("%s=%d On [%d, %d), scores=", label, best_choice, x_start, x_end);
  double max_score = 0.0;
  double mean_score = 0.0;
  int width = x_end - x_start;
  for (int x = x_start; x < x_end; ++x) {
    const float* line = outputs.f(x);
    double score = line[best_choice] * 100.0;
    if (score > max_score) max_score = score;
    mean_score += score / width;
    int best_c = 0;
    double best_score = 0.0;
    for (int c = 0; c < outputs.NumFeatures(); ++c) {
      if (c != best_choice && line[c] > best_score) {
        best_c = c;
        best_score = line[c];
      }
    }
    tprintf(" %.3g(%s=%d=%.3g)", score, DecodeSingleLabel(best_c), best_c,
            best_score * 100.0);
  }
  tprintf(", Mean=%g, max=%g\n", mean_score, max_score);
}

DecodeLabel()

const char * tesseract::LSTMRecognizer::DecodeLabel ( const GenericVector< int > &  labels, int  start, int *  end, int *  decoded  )

protected

Definition at line 469 of file lstmrecognizer.cpp.

                                                                           {
  *end = start + 1;
  if (IsRecoding()) {
    // Decode labels via recoder_.
    RecodedCharID code;
    if (labels[start] == null_char_) {
      if (decoded != NULL) {
        code.Set(0, null_char_);
        *decoded = recoder_.DecodeUnichar(code);
      }
      return "<null>";
    }
    int index = start;
    while (index < labels.size() &&
           code.length() < RecodedCharID::kMaxCodeLen) {
      code.Set(code.length(), labels[index++]);
      while (index < labels.size() && labels[index] == null_char_) ++index;
      int uni_id = recoder_.DecodeUnichar(code);
      // If the next label isn't a valid first code, then we need to continue
      // extending even if we have a valid uni_id from this prefix.
      if (uni_id != INVALID_UNICHAR_ID &&
          (index == labels.size() ||
           code.length() == RecodedCharID::kMaxCodeLen ||
           recoder_.IsValidFirstCode(labels[index]))) {
        *end = index;
        if (decoded != NULL) *decoded = uni_id;
        if (uni_id == UNICHAR_SPACE) return " ";
        return GetUnicharset().get_normed_unichar(uni_id);
      }
    }
    return "<Undecodable>";
  } else {
    if (decoded != NULL) *decoded = labels[start];
    if (labels[start] == null_char_) return "<null>";
    if (labels[start] == UNICHAR_SPACE) return " ";
    return GetUnicharset().get_normed_unichar(labels[start]);
  }
}

DecodeLabels()

STRING tesseract::LSTMRecognizer::DecodeLabels

(

const GenericVector< int > &

labels

)

Definition at line 298 of file lstmrecognizer.cpp.

                                                                    {
  STRING result;
  int end = 1;
  for (int start = 0; start < labels.size(); start = end) {
    if (labels[start] == null_char_) {
      end = start + 1;
    } else {
      result += DecodeLabel(labels, start, &end, NULL);
    }
  }
  return result;
}

DecodeSingleLabel()

const char * tesseract::LSTMRecognizer::DecodeSingleLabel ( int  label )

protected

Definition at line 511 of file lstmrecognizer.cpp.

                                                       {
  if (label == null_char_) return "<null>";
  if (IsRecoding()) {
    // Decode label via recoder_.
    RecodedCharID code;
    code.Set(0, label);
    label = recoder_.DecodeUnichar(code);
    if (label == INVALID_UNICHAR_ID) return "..";  // Part of a bigger code.
  }
  if (label == UNICHAR_SPACE) return " ";
  return GetUnicharset().get_normed_unichar(label);
}

DeSerialize()

bool tesseract::LSTMRecognizer::DeSerialize	(	const TessdataManager *	mgr,
		TFile *	fp
	)

Definition at line 105 of file lstmrecognizer.cpp.

                                                                      {
  delete network_;
  network_ = Network::CreateFromFile(fp);
  if (network_ == NULL) return false;
  bool include_charsets = mgr == nullptr ||
                          !mgr->IsComponentAvailable(TESSDATA_LSTM_RECODER) ||
                          !mgr->IsComponentAvailable(TESSDATA_LSTM_UNICHARSET);
  if (include_charsets && !ccutil_.unicharset.load_from_file(fp, false))
    return false;
  if (!network_str_.DeSerialize(fp)) return false;
  if (fp->FReadEndian(&training_flags_, sizeof(training_flags_), 1) != 1)
    return false;
  if (fp->FReadEndian(&training_iteration_, sizeof(training_iteration_), 1) !=
      1)
    return false;
  if (fp->FReadEndian(&sample_iteration_, sizeof(sample_iteration_), 1) != 1)
    return false;
  if (fp->FReadEndian(&null_char_, sizeof(null_char_), 1) != 1) return false;
  if (fp->FReadEndian(&adam_beta_, sizeof(adam_beta_), 1) != 1) return false;
  if (fp->FReadEndian(&learning_rate_, sizeof(learning_rate_), 1) != 1)
    return false;
  if (fp->FReadEndian(&momentum_, sizeof(momentum_), 1) != 1) return false;
  if (include_charsets && !LoadRecoder(fp)) return false;
  if (!include_charsets && !LoadCharsets(mgr)) return false;
  network_->SetRandomizer(&randomizer_);
  network_->CacheXScaleFactor(network_->XScaleFactor());
  return true;
}

DisplayForward()

void tesseract::LSTMRecognizer::DisplayForward	(	const NetworkIO &	inputs,
		const GenericVector< int > &	labels,
		const GenericVector< int > &	label_coords,
		const char *	window_name,
		ScrollView **	window
	)

Definition at line 313 of file lstmrecognizer.cpp.

                                                         {
#ifndef GRAPHICS_DISABLED  // do nothing if there's no graphics
  Pix* input_pix = inputs.ToPix();
  Network::ClearWindow(false, window_name, pixGetWidth(input_pix),
                       pixGetHeight(input_pix), window);
  int line_height = Network::DisplayImage(input_pix, *window);
  DisplayLSTMOutput(labels, label_coords, line_height, *window);
#endif  // GRAPHICS_DISABLED
}

DisplayLSTMOutput()

void tesseract::LSTMRecognizer::DisplayLSTMOutput ( const GenericVector< int > &  labels, const GenericVector< int > &  xcoords, int  height, ScrollView *  window  )

protected

Definition at line 329 of file lstmrecognizer.cpp.

                                                                       {
#ifndef GRAPHICS_DISABLED  // do nothing if there's no graphics
  int x_scale = network_->XScaleFactor();
  window->TextAttributes("Arial", height / 4, false, false, false);
  int end = 1;
  for (int start = 0; start < labels.size(); start = end) {
    int xpos = xcoords[start] * x_scale;
    if (labels[start] == null_char_) {
      end = start + 1;
      window->Pen(ScrollView::RED);
    } else {
      window->Pen(ScrollView::GREEN);
      const char* str = DecodeLabel(labels, start, &end, NULL);
      if (*str == '\\') str = "\\\\";
      xpos = xcoords[(start + end) / 2] * x_scale;
      window->Text(xpos, height, str);
    }
    window->Line(xpos, 0, xpos, height * 3 / 2);
  }
  window->Update();
#endif  // GRAPHICS_DISABLED
}

EnumerateLayers()

GenericVector<STRING> tesseract::LSTMRecognizer::EnumerateLayers ( ) const

inline

Definition at line 86 of file lstmrecognizer.h.

                                                {
    ASSERT_HOST(network_ != NULL && network_->type() == NT_SERIES);
    Series* series = static_cast<Series*>(network_);
    GenericVector<STRING> layers;
    series->EnumerateLayers(NULL, &layers);
    return layers;
  }

GetDict()

const Dict* tesseract::LSTMRecognizer::GetDict ( ) const

inline

Definition at line 143 of file lstmrecognizer.h.

{ return dict_; }

GetLayer()

Network* tesseract::LSTMRecognizer::GetLayer ( const STRING &  id ) const

inline

Definition at line 94 of file lstmrecognizer.h.

                                            {
    ASSERT_HOST(network_ != NULL && network_->type() == NT_SERIES);
    ASSERT_HOST(id.length() > 1 && id[0] == ':');
    Series* series = static_cast<Series*>(network_);
    return series->GetLayer(&id[1]);
  }

GetLayerLearningRate()

float tesseract::LSTMRecognizer::GetLayerLearningRate ( const STRING &  id ) const

inline

Definition at line 101 of file lstmrecognizer.h.

                                                     {
    ASSERT_HOST(network_ != NULL && network_->type() == NT_SERIES);
    if (network_->TestFlag(NF_LAYER_SPECIFIC_LR)) {
      ASSERT_HOST(id.length() > 1 && id[0] == ':');
      Series* series = static_cast<Series*>(network_);
      return series->LayerLearningRate(&id[1]);
    } else {
      return learning_rate_;
    }
  }

GetRecoder()

const UnicharCompress& tesseract::LSTMRecognizer::GetRecoder ( ) const

inline

Definition at line 141 of file lstmrecognizer.h.

{ return recoder_; }

GetUnicharset()

const UNICHARSET& tesseract::LSTMRecognizer::GetUnicharset ( ) const

inline

Definition at line 139 of file lstmrecognizer.h.

{ return ccutil_.unicharset; }

IsIntMode()

bool tesseract::LSTMRecognizer::IsIntMode ( ) const

inline

Definition at line 77 of file lstmrecognizer.h.

{ return (training_flags_ & TF_INT_MODE) != 0; }

IsRecoding()

bool tesseract::LSTMRecognizer::IsRecoding ( ) const

inline

Definition at line 79 of file lstmrecognizer.h.

                          {
    return (training_flags_ & TF_COMPRESS_UNICHARSET) != 0;
  }

IsTensorFlow()

bool tesseract::LSTMRecognizer::IsTensorFlow ( ) const

inline

Definition at line 83 of file lstmrecognizer.h.

{ return network_->type() == NT_TENSORFLOW; }

LabelsFromOutputs()

void tesseract::LSTMRecognizer::LabelsFromOutputs	(	const NetworkIO &	outputs,
		GenericVector< int > *	labels,
		GenericVector< int > *	xcoords
	)

Definition at line 424 of file lstmrecognizer.cpp.

                                                                    {
  if (SimpleTextOutput()) {
    LabelsViaSimpleText(outputs, labels, xcoords);
  } else {
    LabelsViaReEncode(outputs, labels, xcoords);
  }
}

LabelsViaReEncode()

void tesseract::LSTMRecognizer::LabelsViaReEncode ( const NetworkIO &  output, GenericVector< int > *  labels, GenericVector< int > *  xcoords  )

protected

Definition at line 436 of file lstmrecognizer.cpp.

                                                                    {
  if (search_ == NULL) {
    search_ =
        new RecodeBeamSearch(recoder_, null_char_, SimpleTextOutput(), dict_);
  }
  search_->Decode(output, 1.0, 0.0, RecodeBeamSearch::kMinCertainty, NULL);
  search_->ExtractBestPathAsLabels(labels, xcoords);
}

LabelsViaSimpleText()

void tesseract::LSTMRecognizer::LabelsViaSimpleText ( const NetworkIO &  output, GenericVector< int > *  labels, GenericVector< int > *  xcoords  )

protected

Definition at line 450 of file lstmrecognizer.cpp.

                                                                      {
  labels->truncate(0);
  xcoords->truncate(0);
  int width = output.Width();
  for (int t = 0; t < width; ++t) {
    float score = 0.0f;
    int label = output.BestLabel(t, &score);
    if (label != null_char_) {
      labels->push_back(label);
      xcoords->push_back(t);
    }
  }
  xcoords->push_back(width);
}

learning_rate()

double tesseract::LSTMRecognizer::learning_rate ( ) const

inline

Definition at line 67 of file lstmrecognizer.h.

                               {
    return learning_rate_;
  }

Load()

bool tesseract::LSTMRecognizer::Load	(	const char *	lang,
		TessdataManager *	mgr
	)

Definition at line 72 of file lstmrecognizer.cpp.

                                                                {
  TFile fp;
  if (!mgr->GetComponent(TESSDATA_LSTM, &fp)) return false;
  if (!DeSerialize(mgr, &fp)) return false;
  if (lang == nullptr) return true;
  // Allow it to run without a dictionary.
  LoadDictionary(lang, mgr);
  return true;
}

LoadCharsets()

bool tesseract::LSTMRecognizer::LoadCharsets

(

const TessdataManager *

mgr

)

Definition at line 135 of file lstmrecognizer.cpp.

                                                            {
  TFile fp;
  if (!mgr->GetComponent(TESSDATA_LSTM_UNICHARSET, &fp)) return false;
  if (!ccutil_.unicharset.load_from_file(&fp, false)) return false;
  if (!mgr->GetComponent(TESSDATA_LSTM_RECODER, &fp)) return false;
  if (!LoadRecoder(&fp)) return false;
  return true;
}

LoadDictionary()

bool tesseract::LSTMRecognizer::LoadDictionary	(	const char *	lang,
		TessdataManager *	mgr
	)

Definition at line 168 of file lstmrecognizer.cpp.

                                                                          {
  delete dict_;
  dict_ = new Dict(&ccutil_);
  dict_->SetupForLoad(Dict::GlobalDawgCache());
  dict_->LoadLSTM(lang, mgr);
  if (dict_->FinishLoad()) return true;  // Success.
  tprintf("Failed to load any lstm-specific dictionaries for lang %s!!\n",
          lang);
  delete dict_;
  dict_ = NULL;
  return false;
}

LoadRecoder()

bool tesseract::LSTMRecognizer::LoadRecoder

(

TFile *

fp

)

Definition at line 145 of file lstmrecognizer.cpp.

                                          {
  if (IsRecoding()) {
    if (!recoder_.DeSerialize(fp)) return false;
    RecodedCharID code;
    recoder_.EncodeUnichar(UNICHAR_SPACE, &code);
    if (code(0) != UNICHAR_SPACE) {
      tprintf("Space was garbled in recoding!!\n");
      return false;
    }
  } else {
    recoder_.SetupPassThrough(GetUnicharset());
    training_flags_ |= TF_COMPRESS_UNICHARSET;
  }
  return true;
}

null_char()

int tesseract::LSTMRecognizer::null_char ( ) const

inline

Definition at line 154 of file lstmrecognizer.h.

{ return null_char_; }

NumInputs()

int tesseract::LSTMRecognizer::NumInputs ( ) const

inline

Definition at line 151 of file lstmrecognizer.h.

                        {
    return network_->NumInputs();
  }

NumOutputs()

int tesseract::LSTMRecognizer::NumOutputs ( ) const

inline

Definition at line 58 of file lstmrecognizer.h.

                         {
    return network_->NumOutputs();
  }

OutputLossType()

LossType tesseract::LSTMRecognizer::OutputLossType ( ) const

inline

Definition at line 70 of file lstmrecognizer.h.

                                  {
    if (network_ == nullptr) return LT_NONE;
    StaticShape shape;
    shape = network_->OutputShape(shape);
    return shape.loss_type();
  }

OutputStats()

void tesseract::LSTMRecognizer::OutputStats	(	const NetworkIO &	outputs,
		float *	min_output,
		float *	mean_output,
		float *	sd
	)

Definition at line 203 of file lstmrecognizer.cpp.

                                                                {
  const int kOutputScale = MAX_INT8;
  STATS stats(0, kOutputScale + 1);
  for (int t = 0; t < outputs.Width(); ++t) {
    int best_label = outputs.BestLabel(t, NULL);
    if (best_label != null_char_) {
      float best_output = outputs.f(t)[best_label];
      stats.add(static_cast<int>(kOutputScale * best_output), 1);
    }
  }
  // If the output is all nulls it could be that the photometric interpretation
  // is wrong, so make it look bad, so the other way can win, even if not great.
  if (stats.get_total() == 0) {
    *min_output = 0.0f;
    *mean_output = 0.0f;
    *sd = 1.0f;
  } else {
    *min_output = static_cast<float>(stats.min_bucket()) / kOutputScale;
    *mean_output = stats.mean() / kOutputScale;
    *sd = stats.sd() / kOutputScale;
  }
}

RecognizeLine() [1/2]

void tesseract::LSTMRecognizer::RecognizeLine	(	const ImageData &	image_data,
		bool	invert,
		bool	debug,
		double	worst_dict_cert,
		const TBOX &	line_box,
		PointerVector< WERD_RES > *	words
	)

Definition at line 183 of file lstmrecognizer.cpp.

                                                                   {
  NetworkIO outputs;
  float scale_factor;
  NetworkIO inputs;
  if (!RecognizeLine(image_data, invert, debug, false, false, &scale_factor,
                     &inputs, &outputs))
    return;
  if (search_ == NULL) {
    search_ =
        new RecodeBeamSearch(recoder_, null_char_, SimpleTextOutput(), dict_);
  }
  search_->Decode(outputs, kDictRatio, kCertOffset, worst_dict_cert, NULL);
  search_->ExtractBestPathAsWords(line_box, scale_factor, debug,
                                  &GetUnicharset(), words);
}

RecognizeLine() [2/2]

bool tesseract::LSTMRecognizer::RecognizeLine	(	const ImageData &	image_data,
		bool	invert,
		bool	debug,
		bool	re_invert,
		bool	upside_down,
		float *	scale_factor,
		NetworkIO *	inputs,
		NetworkIO *	outputs
	)

Definition at line 229 of file lstmrecognizer.cpp.

                                                       {
  // Maximum width of image to train on.
  const int kMaxImageWidth = 2560;
  // This ensures consistent recognition results.
  SetRandomSeed();
  int min_width = network_->XScaleFactor();
  Pix* pix = Input::PrepareLSTMInputs(image_data, network_, min_width,
                                      &randomizer_, scale_factor);
  if (pix == NULL) {
    tprintf("Line cannot be recognized!!\n");
    return false;
  }
  if (network_->IsTraining() && pixGetWidth(pix) > kMaxImageWidth) {
    tprintf("Image too large to learn!! Size = %dx%d\n", pixGetWidth(pix),
            pixGetHeight(pix));
    pixDestroy(&pix);
    return false;
  }
  if (upside_down) pixRotate180(pix, pix);
  // Reduction factor from image to coords.
  *scale_factor = min_width / *scale_factor;
  inputs->set_int_mode(IsIntMode());
  SetRandomSeed();
  Input::PreparePixInput(network_->InputShape(), pix, &randomizer_, inputs);
  network_->Forward(debug, *inputs, NULL, &scratch_space_, outputs);
  // Check for auto inversion.
  float pos_min, pos_mean, pos_sd;
  OutputStats(*outputs, &pos_min, &pos_mean, &pos_sd);
  if (invert && pos_min < 0.5) {
    // Run again inverted and see if it is any better.
    NetworkIO inv_inputs, inv_outputs;
    inv_inputs.set_int_mode(IsIntMode());
    SetRandomSeed();
    pixInvert(pix, pix);
    Input::PreparePixInput(network_->InputShape(), pix, &randomizer_,
                           &inv_inputs);
    network_->Forward(debug, inv_inputs, NULL, &scratch_space_, &inv_outputs);
    float inv_min, inv_mean, inv_sd;
    OutputStats(inv_outputs, &inv_min, &inv_mean, &inv_sd);
    if (inv_min > pos_min && inv_mean > pos_mean && inv_sd < pos_sd) {
      // Inverted did better. Use inverted data.
      if (debug) {
        tprintf("Inverting image: old min=%g, mean=%g, sd=%g, inv %g,%g,%g\n",
                pos_min, pos_mean, pos_sd, inv_min, inv_mean, inv_sd);
      }
      *outputs = inv_outputs;
      *inputs = inv_inputs;
    } else if (re_invert) {
      // Inverting was not an improvement, so undo and run again, so the
      // outputs match the best forward result.
      SetRandomSeed();
      network_->Forward(debug, *inputs, NULL, &scratch_space_, outputs);
    }
  }
  pixDestroy(&pix);
  if (debug) {
    GenericVector<int> labels, coords;
    LabelsFromOutputs(*outputs, &labels, &coords);
    DisplayForward(*inputs, labels, coords, "LSTMForward", &debug_win_);
    DebugActivationPath(*outputs, labels, coords);
  }
  return true;
}

sample_iteration()

int tesseract::LSTMRecognizer::sample_iteration ( ) const

inline

Definition at line 64 of file lstmrecognizer.h.

                               {
    return sample_iteration_;
  }

ScaleLayerLearningRate()

void tesseract::LSTMRecognizer::ScaleLayerLearningRate ( const STRING &  id, double  factor  )

inline

Definition at line 123 of file lstmrecognizer.h.

                                                               {
    ASSERT_HOST(network_ != NULL && network_->type() == NT_SERIES);
    ASSERT_HOST(id.length() > 1 && id[0] == ':');
    Series* series = static_cast<Series*>(network_);
    series->ScaleLayerLearningRate(&id[1], factor);
  }

ScaleLearningRate()

void tesseract::LSTMRecognizer::ScaleLearningRate ( double  factor )

inline

Definition at line 112 of file lstmrecognizer.h.

                                        {
    ASSERT_HOST(network_ != NULL && network_->type() == NT_SERIES);
    learning_rate_ *= factor;
    if (network_->TestFlag(NF_LAYER_SPECIFIC_LR)) {
      GenericVector<STRING> layers = EnumerateLayers();
      for (int i = 0; i < layers.size(); ++i) {
        ScaleLayerLearningRate(layers[i], factor);
      }
    }
  }

Serialize()

bool tesseract::LSTMRecognizer::Serialize	(	const TessdataManager *	mgr,
		TFile *	fp
	)		const

Definition at line 83 of file lstmrecognizer.cpp.

                                                                          {
  bool include_charsets = mgr == nullptr ||
                          !mgr->IsComponentAvailable(TESSDATA_LSTM_RECODER) ||
                          !mgr->IsComponentAvailable(TESSDATA_LSTM_UNICHARSET);
  if (!network_->Serialize(fp)) return false;
  if (include_charsets && !GetUnicharset().save_to_file(fp)) return false;
  if (!network_str_.Serialize(fp)) return false;
  if (fp->FWrite(&training_flags_, sizeof(training_flags_), 1) != 1)
    return false;
  if (fp->FWrite(&training_iteration_, sizeof(training_iteration_), 1) != 1)
    return false;
  if (fp->FWrite(&sample_iteration_, sizeof(sample_iteration_), 1) != 1)
    return false;
  if (fp->FWrite(&null_char_, sizeof(null_char_), 1) != 1) return false;
  if (fp->FWrite(&adam_beta_, sizeof(adam_beta_), 1) != 1) return false;
  if (fp->FWrite(&learning_rate_, sizeof(learning_rate_), 1) != 1) return false;
  if (fp->FWrite(&momentum_, sizeof(momentum_), 1) != 1) return false;
  if (include_charsets && IsRecoding() && !recoder_.Serialize(fp)) return false;
  return true;
}

SetIteration()

void tesseract::LSTMRecognizer::SetIteration ( int  iteration )

inline

Definition at line 147 of file lstmrecognizer.h.

                                   {
    sample_iteration_ = iteration;
  }

SetRandomSeed()

void tesseract::LSTMRecognizer::SetRandomSeed ( )

inlineprotected

Definition at line 225 of file lstmrecognizer.h.

                       {
    inT64 seed = static_cast<inT64>(sample_iteration_) * 0x10000001;
    randomizer_.set_seed(seed);
    randomizer_.IntRand();
  }

SimpleTextOutput()

bool tesseract::LSTMRecognizer::SimpleTextOutput ( ) const

inline

Definition at line 76 of file lstmrecognizer.h.

{ return OutputLossType() == LT_SOFTMAX; }

training_iteration()

int tesseract::LSTMRecognizer::training_iteration ( ) const

inline

Definition at line 61 of file lstmrecognizer.h.

                                 {
    return training_iteration_;
  }

Member Data Documentation

adam_beta_

float tesseract::LSTMRecognizer::adam_beta_

protected

Definition at line 295 of file lstmrecognizer.h.

ccutil_

CCUtil tesseract::LSTMRecognizer::ccutil_

protected

Definition at line 273 of file lstmrecognizer.h.

debug_win_

ScrollView* tesseract::LSTMRecognizer::debug_win_

protected

Definition at line 307 of file lstmrecognizer.h.

dict_

Dict* tesseract::LSTMRecognizer::dict_

protected

Definition at line 301 of file lstmrecognizer.h.

learning_rate_

float tesseract::LSTMRecognizer::learning_rate_

protected

Definition at line 292 of file lstmrecognizer.h.

momentum_

float tesseract::LSTMRecognizer::momentum_

protected

Definition at line 293 of file lstmrecognizer.h.

network_

Network* tesseract::LSTMRecognizer::network_

protected

Definition at line 270 of file lstmrecognizer.h.

network_str_

STRING tesseract::LSTMRecognizer::network_str_

protected

Definition at line 280 of file lstmrecognizer.h.

null_char_

inT32 tesseract::LSTMRecognizer::null_char_

protected

Definition at line 290 of file lstmrecognizer.h.

randomizer_

TRand tesseract::LSTMRecognizer::randomizer_

protected

Definition at line 298 of file lstmrecognizer.h.

recoder_

UnicharCompress tesseract::LSTMRecognizer::recoder_

protected

Definition at line 277 of file lstmrecognizer.h.

sample_iteration_

inT32 tesseract::LSTMRecognizer::sample_iteration_

protected

Definition at line 287 of file lstmrecognizer.h.

scratch_space_

NetworkScratch tesseract::LSTMRecognizer::scratch_space_

protected

Definition at line 299 of file lstmrecognizer.h.

search_

RecodeBeamSearch* tesseract::LSTMRecognizer::search_

protected

Definition at line 303 of file lstmrecognizer.h.

training_flags_

inT32 tesseract::LSTMRecognizer::training_flags_

protected

Definition at line 283 of file lstmrecognizer.h.

training_iteration_

inT32 tesseract::LSTMRecognizer::training_iteration_

protected

Definition at line 285 of file lstmrecognizer.h.

---

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

• /home/stweil/src/github/tesseract-ocr/tesseract/lstm/lstmrecognizer.h
• /home/stweil/src/github/tesseract-ocr/tesseract/lstm/lstmrecognizer.cpp