#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 ParamsVectors params, 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 ParamsVectors params, 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, int lstm_choice_mode=0)

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_t	training_flags_

int32_t	training_iteration_

int32_t	sample_iteration_

int32_t	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 54 of file lstmrecognizer.h.

Constructor & Destructor Documentation

tesseract::LSTMRecognizer::LSTMRecognizer ( )

Definition at line 49 of file lstmrecognizer.cpp.

     : network_(nullptr),
       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_(nullptr),
       search_(nullptr),
       debug_win_(nullptr) {}

tesseract::LSTMRecognizer::~LSTMRecognizer ( )

Definition at line 62 of file lstmrecognizer.cpp.

                                 {
   delete network_;
   delete dict_;
   delete search_;
 }

Member Function Documentation

void tesseract::LSTMRecognizer::ConvertToInt ( )

inline

Definition at line 124 of file lstmrecognizer.h.

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

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

protected

Definition at line 355 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]);
       }
     }
   }
 }

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

protected

Definition at line 382 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;
   const int width = x_end - x_start;
   for (int x = x_start; x < x_end; ++x) {
     const float* line = outputs.f(x);
     const 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);
 }

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

protected

Definition at line 470 of file lstmrecognizer.cpp.

                                                                            {
   *end = start + 1;
   if (IsRecoding()) {
     // Decode labels via recoder_.
     RecodedCharID code;
     if (labels[start] == null_char_) {
       if (decoded != nullptr) {
         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 != nullptr) *decoded = uni_id;
         if (uni_id == UNICHAR_SPACE) return " ";
         return GetUnicharset().get_normed_unichar(uni_id);
       }
     }
     return "<Undecodable>";
   } else {
     if (decoded != nullptr) *decoded = labels[start];
     if (labels[start] == null_char_) return "<null>";
     if (labels[start] == UNICHAR_SPACE) return " ";
     return GetUnicharset().get_normed_unichar(labels[start]);
   }
 }

STRING tesseract::LSTMRecognizer::DecodeLabels ( const GenericVector< int > & labels )

Definition at line 297 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, nullptr);
     }
   }
   return result;
 }

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

protected

Definition at line 512 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);
 }

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

Definition at line 100 of file lstmrecognizer.cpp.

                                                                       {
   delete network_;
   network_ = Network::CreateFromFile(fp);
   if (network_ == nullptr) 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->DeSerialize(&training_flags_)) return false;
   if (!fp->DeSerialize(&training_iteration_)) return false;
   if (!fp->DeSerialize(&sample_iteration_)) return false;
   if (!fp->DeSerialize(&null_char_)) return false;
   if (!fp->DeSerialize(&adam_beta_)) return false;
   if (!fp->DeSerialize(&learning_rate_)) return false;
   if (!fp->DeSerialize(&momentum_)) 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;
 }

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 312 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
 }

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

protected

Definition at line 328 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, nullptr);
       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
 }

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

inline

Definition at line 79 of file lstmrecognizer.h.

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

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

inline

Definition at line 136 of file lstmrecognizer.h.

136 { return dict_; }

tesseract::LSTMRecognizer::dict_

Dict * dict_

Definition: lstmrecognizer.h:289

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

inline

Definition at line 87 of file lstmrecognizer.h.

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

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

inline

Definition at line 94 of file lstmrecognizer.h.

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

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

inline

Definition at line 134 of file lstmrecognizer.h.

134 { return recoder_; }

tesseract::LSTMRecognizer::recoder_

UnicharCompress recoder_

Definition: lstmrecognizer.h:265

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

inline

Definition at line 132 of file lstmrecognizer.h.

132 { return ccutil_.unicharset; }

tesseract::CCUtil::unicharset

UNICHARSET unicharset

Definition: ccutil.h:71

tesseract::LSTMRecognizer::ccutil_

CCUtil ccutil_

Definition: lstmrecognizer.h:261

bool tesseract::LSTMRecognizer::IsIntMode ( ) const

inline

Definition at line 70 of file lstmrecognizer.h.

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

tesseract::LSTMRecognizer::training_flags_

int32_t training_flags_

Definition: lstmrecognizer.h:271

tesseract::TF_INT_MODE

Definition: lstmrecognizer.h:48

bool tesseract::LSTMRecognizer::IsRecoding ( ) const

inline

Definition at line 72 of file lstmrecognizer.h.

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

bool tesseract::LSTMRecognizer::IsTensorFlow ( ) const

inline

Definition at line 76 of file lstmrecognizer.h.

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

tesseract::LSTMRecognizer::network_

Network * network_

Definition: lstmrecognizer.h:258

tesseract::NT_TENSORFLOW

Definition: network.h:77

tesseract::Network::type

NetworkType type() const

Definition: network.h:111

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

Definition at line 425 of file lstmrecognizer.cpp.

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

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

protected

Definition at line 437 of file lstmrecognizer.cpp.

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

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

protected

Definition at line 451 of file lstmrecognizer.cpp.

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

double tesseract::LSTMRecognizer::learning_rate ( ) const

inline

Definition at line 62 of file lstmrecognizer.h.

62 { return learning_rate_; }

tesseract::LSTMRecognizer::learning_rate_

float learning_rate_

Definition: lstmrecognizer.h:280

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

Definition at line 69 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(params, lang, mgr);
   return true;
 }

bool tesseract::LSTMRecognizer::LoadCharsets ( const TessdataManager * mgr )

Definition at line 125 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;
 }

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

Definition at line 159 of file lstmrecognizer.cpp.

                                                                             {
   delete dict_;
   dict_ = new Dict(&ccutil_);
   dict_->user_words_file.ResetFrom(params);
   dict_->user_words_suffix.ResetFrom(params);
   dict_->user_patterns_file.ResetFrom(params);
   dict_->user_patterns_suffix.ResetFrom(params);
   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_ = nullptr;
   return false;
 }

bool tesseract::LSTMRecognizer::LoadRecoder ( TFile * fp )

Definition at line 135 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;
 }

int tesseract::LSTMRecognizer::null_char ( ) const

inline

Definition at line 143 of file lstmrecognizer.h.

143 { return null_char_; }

tesseract::LSTMRecognizer::null_char_

int32_t null_char_

Definition: lstmrecognizer.h:278

int tesseract::LSTMRecognizer::NumInputs ( ) const

inline

Definition at line 142 of file lstmrecognizer.h.

142 { return network_->NumInputs(); }

tesseract::LSTMRecognizer::network_

Network * network_

Definition: lstmrecognizer.h:258

tesseract::Network::NumInputs

int NumInputs() const

Definition: network.h:119

int tesseract::LSTMRecognizer::NumOutputs ( ) const

inline

Definition at line 59 of file lstmrecognizer.h.

59 { return network_->NumOutputs(); }

tesseract::LSTMRecognizer::network_

Network * network_

Definition: lstmrecognizer.h:258

tesseract::Network::NumOutputs

int NumOutputs() const

Definition: network.h:122

LossType tesseract::LSTMRecognizer::OutputLossType ( ) const

inline

Definition at line 63 of file lstmrecognizer.h.

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

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

Definition at line 201 of file lstmrecognizer.cpp.

                                                                 {
   const int kOutputScale = INT8_MAX;
   STATS stats(0, kOutputScale + 1);
   for (int t = 0; t < outputs.Width(); ++t) {
     int best_label = outputs.BestLabel(t, nullptr);
     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;
   }
 }

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

Definition at line 179 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_ == nullptr) {
     search_ =
         new RecodeBeamSearch(recoder_, null_char_, SimpleTextOutput(), dict_);
   }
   search_->Decode(outputs, kDictRatio, kCertOffset, worst_dict_cert,
                   &GetUnicharset(), lstm_choice_mode);
   search_->ExtractBestPathAsWords(line_box, scale_factor, debug,
                                   &GetUnicharset(), words, lstm_choice_mode);
 }

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 227 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 == nullptr) {
     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, nullptr, &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, nullptr, &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, nullptr, &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;
 }

int tesseract::LSTMRecognizer::sample_iteration ( ) const

inline

Definition at line 61 of file lstmrecognizer.h.

61 { return sample_iteration_; }

tesseract::LSTMRecognizer::sample_iteration_

int32_t sample_iteration_

Definition: lstmrecognizer.h:275

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

inline

Definition at line 116 of file lstmrecognizer.h.

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

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

inline

Definition at line 105 of file lstmrecognizer.h.

                                         {
     ASSERT_HOST(network_ != nullptr && 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);
       }
     }
   }

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

Definition at line 81 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->Serialize(&training_flags_)) return false;
   if (!fp->Serialize(&training_iteration_)) return false;
   if (!fp->Serialize(&sample_iteration_)) return false;
   if (!fp->Serialize(&null_char_)) return false;
   if (!fp->Serialize(&adam_beta_)) return false;
   if (!fp->Serialize(&learning_rate_)) return false;
   if (!fp->Serialize(&momentum_)) return false;
   if (include_charsets && IsRecoding() && !recoder_.Serialize(fp)) return false;
   return true;
 }

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

inline

Definition at line 140 of file lstmrecognizer.h.

140 { sample_iteration_ = iteration; }

tesseract::LSTMRecognizer::sample_iteration_

int32_t sample_iteration_

Definition: lstmrecognizer.h:275

void tesseract::LSTMRecognizer::SetRandomSeed ( )

inlineprotected

Definition at line 214 of file lstmrecognizer.h.

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

bool tesseract::LSTMRecognizer::SimpleTextOutput ( ) const

inline

Definition at line 69 of file lstmrecognizer.h.

69 { return OutputLossType() == LT_SOFTMAX; }

tesseract::LSTMRecognizer::OutputLossType

LossType OutputLossType() const

Definition: lstmrecognizer.h:63

tesseract::LT_SOFTMAX

Definition: static_shape.h:32

int tesseract::LSTMRecognizer::training_iteration ( ) const

inline

Definition at line 60 of file lstmrecognizer.h.

60 { return training_iteration_; }

tesseract::LSTMRecognizer::training_iteration_

int32_t training_iteration_

Definition: lstmrecognizer.h:273

Member Data Documentation

float tesseract::LSTMRecognizer::adam_beta_

protected

Definition at line 283 of file lstmrecognizer.h.

CCUtil tesseract::LSTMRecognizer::ccutil_

protected

Definition at line 261 of file lstmrecognizer.h.

ScrollView* tesseract::LSTMRecognizer::debug_win_

protected

Definition at line 295 of file lstmrecognizer.h.

Dict* tesseract::LSTMRecognizer::dict_

protected

Definition at line 289 of file lstmrecognizer.h.

float tesseract::LSTMRecognizer::learning_rate_

protected

Definition at line 280 of file lstmrecognizer.h.

float tesseract::LSTMRecognizer::momentum_

protected

Definition at line 281 of file lstmrecognizer.h.

Network* tesseract::LSTMRecognizer::network_

protected

Definition at line 258 of file lstmrecognizer.h.

STRING tesseract::LSTMRecognizer::network_str_

protected

Definition at line 268 of file lstmrecognizer.h.

int32_t tesseract::LSTMRecognizer::null_char_

protected

Definition at line 278 of file lstmrecognizer.h.

TRand tesseract::LSTMRecognizer::randomizer_

protected

Definition at line 286 of file lstmrecognizer.h.

UnicharCompress tesseract::LSTMRecognizer::recoder_

protected

Definition at line 265 of file lstmrecognizer.h.

int32_t tesseract::LSTMRecognizer::sample_iteration_

protected

Definition at line 275 of file lstmrecognizer.h.

NetworkScratch tesseract::LSTMRecognizer::scratch_space_

protected

Definition at line 287 of file lstmrecognizer.h.

RecodeBeamSearch* tesseract::LSTMRecognizer::search_

protected

Definition at line 291 of file lstmrecognizer.h.

int32_t tesseract::LSTMRecognizer::training_flags_

protected

Definition at line 271 of file lstmrecognizer.h.

int32_t tesseract::LSTMRecognizer::training_iteration_

protected

Definition at line 273 of file lstmrecognizer.h.

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

src/lstm/lstmrecognizer.h
src/lstm/lstmrecognizer.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation