#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

bool	IsHardening () const

LossType	OutputLossType () const

bool	SimpleTextOutput () const

bool	IsIntMode () const

bool	IsRecoding () const

CachingStrategy	CacheStrategy () 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)

bool	IsUsingAdaGrad () const

const UNICHARSET &	GetUnicharset () const

const Dict *	GetDict () const

void	SetIteration (int iteration)

int	NumInputs () const

int	null_char () const

bool	Serialize (TFile *fp) const

bool	DeSerialize (TFile *fp)

bool	LoadDictionary (const char lang, TessdataManager mgr)

void	RecognizeLine (const ImageData &image_data, bool invert, bool debug, double worst_dict_cert, bool use_alternates, const UNICHARSET target_unicharset, const TBOX &line_box, float score_ratio, bool one_word, PointerVector< WERD_RES > words)

void	WordsFromOutputs (const NetworkIO &outputs, const GenericVector< int > &labels, const GenericVector< int > label_coords, const TBOX &line_box, bool debug, bool use_alternates, bool one_word, float score_ratio, float scale_factor, const UNICHARSET target_unicharset, 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, float label_threshold, float scale_factor, NetworkIO inputs, NetworkIO *outputs)

WERD_RES *	WordFromOutput (const TBOX &line_box, const NetworkIO &outputs, int word_start, int word_end, float score_ratio, float space_certainty, bool debug, bool use_alternates, const UNICHARSET *target_unicharset, const GenericVector< int > &labels, const GenericVector< int > &label_coords, float scale_factor)

WERD_RES *	InitializeWord (const TBOX &line_box, int word_start, int word_end, float space_certainty, bool use_alternates, const UNICHARSET *target_unicharset, const GenericVector< int > &labels, const GenericVector< int > &label_coords, float scale_factor)

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)

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	LabelsFromOutputs (const NetworkIO &outputs, float null_thr, GenericVector< int > labels, GenericVector< int > xcoords)

void	LabelsViaThreshold (const NetworkIO &output, float null_threshold, GenericVector< int > labels, GenericVector< int > xcoords)

void	LabelsViaCTC (const NetworkIO &output, GenericVector< int > labels, GenericVector< int > xcoords)

void	LabelsViaReEncode (const NetworkIO &output, GenericVector< int > labels, GenericVector< int > xcoords)

void	LabelsViaSimpleText (const NetworkIO &output, GenericVector< int > labels, GenericVector< int > xcoords)

BLOB_CHOICE_LIST *	GetBlobChoices (int col, int row, bool debug, const NetworkIO &output, const UNICHARSET *target_unicharset, int x_start, int x_end, float score_ratio)

bool	AddBlobChoices (int unichar_id, float rating, float certainty, int col, int row, const UNICHARSET target_unicharset, BLOB_CHOICE_IT bc_it)

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	weight_range_

float	learning_rate_

float	momentum_

TRand	randomizer_

NetworkScratch	scratch_space_

Dict *	dict_

RecodeBeamSearch *	search_

ScrollView *	debug_win_

Detailed Description

Definition at line 55 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),
       weight_range_(0.0f),
       learning_rate_(0.0f),
       momentum_(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

◆ AddBlobChoices()

bool tesseract::LSTMRecognizer::AddBlobChoices	(	int	unichar_id,
		float	rating,
		float	certainty,
		int	col,
		int	row,
		const UNICHARSET *	target_unicharset,
		BLOB_CHOICE_IT *	bc_it
	)

protected

Definition at line 739 of file lstmrecognizer.cpp.

                                                            {
   int target_id = unichar_id;
   if (target_unicharset != NULL) {
     const char* utf8 = GetUnicharset().id_to_unichar(unichar_id);
     if (target_unicharset->contains_unichar(utf8)) {
       target_id = target_unicharset->unichar_to_id(utf8);
     } else {
       return false;
     }
   }
   BLOB_CHOICE* choice = new BLOB_CHOICE(target_id, rating, certainty, -1, 1.0f,
                                         static_cast<float>(MAX_INT16), 0.0f,
                                         BCC_STATIC_CLASSIFIER);
   choice->set_matrix_cell(col, row);
   bc_it->add_after_then_move(choice);
   return true;
 }

◆ CacheStrategy()

CachingStrategy tesseract::LSTMRecognizer::CacheStrategy ( ) const

inline

Definition at line 88 of file lstmrecognizer.h.

                                         {
     return training_flags_ & TF_ROUND_ROBIN_TRAINING ? CS_ROUND_ROBIN
                                                      : CS_SEQUENTIAL;
   }

◆ DebugActivationPath()

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

protected

Definition at line 504 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 531 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 762 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 446 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 804 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 ( TFile * fp )

Definition at line 91 of file lstmrecognizer.cpp.

                                           {
   delete network_;
   network_ = Network::CreateFromFile(fp);
   if (network_ == NULL) return false;
   if (!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(&weight_range_, sizeof(weight_range_), 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 (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;
     }
   }
   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 461 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 477 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 96 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;
   }

◆ GetBlobChoices()

BLOB_CHOICE_LIST * tesseract::LSTMRecognizer::GetBlobChoices	(	int	col,
		int	row,
		bool	debug,
		const NetworkIO &	output,
		const UNICHARSET *	target_unicharset,
		int	x_start,
		int	x_end,
		float	score_ratio
	)

protected

Definition at line 689 of file lstmrecognizer.cpp.

                        {
   float rating = 0.0f, certainty = 0.0f;
   int label = output.BestChoiceOverRange(x_start, x_end, UNICHAR_SPACE,
                                          null_char_, &rating, &certainty);
   int unichar_id = label == null_char_ ? UNICHAR_SPACE : label;
   if (debug) {
     tprintf("Best choice over range %d,%d=unichar%d=%s r = %g, cert=%g\n",
             x_start, x_end, unichar_id, DecodeSingleLabel(label), rating,
             certainty);
   }
   BLOB_CHOICE_LIST* choices = new BLOB_CHOICE_LIST;
   BLOB_CHOICE_IT bc_it(choices);
   if (!AddBlobChoices(unichar_id, rating, certainty, col, row,
                       target_unicharset, &bc_it)) {
     delete choices;
     return NULL;
   }
   // Get the other choices.
   double best_cert = certainty;
   for (int c = 0; c < output.NumFeatures(); ++c) {
     if (c == label || c == UNICHAR_SPACE || c == null_char_) continue;
     // Compute the score over the range.
     output.ScoresOverRange(x_start, x_end, c, null_char_, &rating, &certainty);
     int unichar_id = c == null_char_ ? UNICHAR_SPACE : c;
     if (certainty >= best_cert - score_ratio &&
         !AddBlobChoices(unichar_id, rating, certainty, col, row,
                         target_unicharset, &bc_it)) {
       delete choices;
       return NULL;
     }
   }
   choices->sort(&BLOB_CHOICE::SortByRating);
   if (bc_it.length() > kMaxChoices) {
     bc_it.move_to_first();
     for (int i = 0; i < kMaxChoices; ++i)
       bc_it.forward();
     while (!bc_it.at_first()) {
       delete bc_it.extract();
       bc_it.forward();
     }
   }
   return choices;
 }

◆ GetDict()

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

inline

Definition at line 145 of file lstmrecognizer.h.

145 { return dict_; }

tesseract::LSTMRecognizer::dict_

Dict * dict_

Definition: lstmrecognizer.h:382

◆ GetLayer()

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

inline

Definition at line 104 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 111 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_;
     }
   }

◆ GetUnicharset()

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

inline

Definition at line 143 of file lstmrecognizer.h.

143 { return ccutil_.unicharset; }

tesseract::LSTMRecognizer::ccutil_

CCUtil ccutil_

Definition: lstmrecognizer.h:354

tesseract::CCUtil::unicharset

UNICHARSET unicharset

Definition: ccutil.h:68

◆ InitializeWord()

WERD_RES * tesseract::LSTMRecognizer::InitializeWord	(	const TBOX &	line_box,
		int	word_start,
		int	word_end,
		float	space_certainty,
		bool	use_alternates,
		const UNICHARSET *	target_unicharset,
		const GenericVector< int > &	labels,
		const GenericVector< int > &	label_coords,
		float	scale_factor
	)

Definition at line 398 of file lstmrecognizer.cpp.

                                                              {
   // Make a fake blob for each non-zero label.
   C_BLOB_LIST blobs;
   C_BLOB_IT b_it(&blobs);
   // num_blobs is the length of the diagonal of the ratings matrix.
   int num_blobs = 0;
   // max_blob_run is the diagonal width of the ratings matrix
   int max_blob_run = 0;
   int blob_run = 0;
   for (int i = word_start; i < word_end; ++i) {
     if (IsRecoding() && !recoder_.IsValidFirstCode(labels[i])) continue;
     if (labels[i] != null_char_) {
       // Make a fake blob.
       TBOX box(label_coords[i], 0, label_coords[i + 1], line_box.height());
       box.scale(scale_factor);
       box.move(ICOORD(line_box.left(), line_box.bottom()));
       box.set_top(line_box.top());
       b_it.add_after_then_move(C_BLOB::FakeBlob(box));
       ++num_blobs;
       ++blob_run;
     }
     if (labels[i] == null_char_ || i + 1 == word_end) {
       if (blob_run > max_blob_run)
         max_blob_run = blob_run;
     }
   }
   if (!use_alternates) max_blob_run = 1;
   ASSERT_HOST(label_coords.size() >= word_end);
   // Make a fake word from the blobs.
   WERD* word = new WERD(&blobs, word_start > 1 ? 1 : 0, NULL);
   // Make a WERD_RES from the word.
   WERD_RES* word_res = new WERD_RES(word);
   word_res->uch_set =
       target_unicharset != NULL ? target_unicharset : &GetUnicharset();
   word_res->combination = true;  // Give it ownership of the word.
   word_res->space_certainty = space_certainty;
   word_res->ratings = new MATRIX(num_blobs, max_blob_run);
   return word_res;
 }

◆ IsHardening()

bool tesseract::LSTMRecognizer::IsHardening ( ) const

inline

Definition at line 72 of file lstmrecognizer.h.

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

◆ IsIntMode()

bool tesseract::LSTMRecognizer::IsIntMode ( ) const

inline

Definition at line 82 of file lstmrecognizer.h.

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

tesseract::LSTMRecognizer::training_flags_

inT32 training_flags_

Definition: lstmrecognizer.h:364

tesseract::TF_INT_MODE

Definition: lstmrecognizer.h:47

◆ IsRecoding()

bool tesseract::LSTMRecognizer::IsRecoding ( ) const

inline

Definition at line 84 of file lstmrecognizer.h.

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

◆ IsTensorFlow()

bool tesseract::LSTMRecognizer::IsTensorFlow ( ) const

inline

Definition at line 93 of file lstmrecognizer.h.

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

tesseract::Network::type

NetworkType type() const

Definition: network.h:112

tesseract::NT_TENSORFLOW

Definition: network.h:78

tesseract::LSTMRecognizer::network_

Network * network_

Definition: lstmrecognizer.h:351

◆ IsUsingAdaGrad()

bool tesseract::LSTMRecognizer::IsUsingAdaGrad ( ) const

inline

Definition at line 141 of file lstmrecognizer.h.

141 { return network_->TestFlag(NF_ADA_GRAD); }

tesseract::NF_ADA_GRAD

Definition: network.h:88

tesseract::Network::TestFlag

bool TestFlag(NetworkFlags flag) const

Definition: network.h:144

tesseract::LSTMRecognizer::network_

Network * network_

Definition: lstmrecognizer.h:351

◆ LabelsFromOutputs()

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

protected

Definition at line 572 of file lstmrecognizer.cpp.

                                                                     {
   if (SimpleTextOutput()) {
     LabelsViaSimpleText(outputs, labels, xcoords);
   } else if (IsRecoding()) {
     LabelsViaReEncode(outputs, labels, xcoords);
   } else if (null_thr <= 0.0) {
     LabelsViaCTC(outputs, labels, xcoords);
   } else {
     LabelsViaThreshold(outputs, null_thr, labels, xcoords);
   }
 }

◆ LabelsViaCTC()

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

protected

Definition at line 633 of file lstmrecognizer.cpp.

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

◆ LabelsViaReEncode()

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

protected

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

◆ LabelsViaThreshold()

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

protected

Definition at line 592 of file lstmrecognizer.cpp.

                                                                      {
   labels->truncate(0);
   xcoords->truncate(0);
   int width = output.Width();
   int t = 0;
   // Skip any initial non-char.
   while (t < width && NullIsBest(output, null_thr, null_char_, t)) {
     ++t;
   }
   while (t < width) {
     ASSERT_HOST(!std::isnan(output.f(t)[null_char_]));
     int label = output.BestLabel(t, null_char_, null_char_, NULL);
     int char_start = t++;
     while (t < width && !NullIsBest(output, null_thr, null_char_, t) &&
            label == output.BestLabel(t, null_char_, null_char_, NULL)) {
       ++t;
     }
     int char_end = t;
     labels->push_back(label);
     xcoords->push_back(char_start);
     // Find the end of the non-char, and compute its score.
     while (t < width && NullIsBest(output, null_thr, null_char_, t)) {
       ++t;
     }
     if (t > char_end) {
       labels->push_back(null_char_);
       xcoords->push_back(char_end);
     }
   }
   xcoords->push_back(width);
 }

◆ learning_rate()

double tesseract::LSTMRecognizer::learning_rate ( ) const

inline

Definition at line 69 of file lstmrecognizer.h.

                                {
     return learning_rate_;
   }

◆ LoadDictionary()

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

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

◆ null_char()

int tesseract::LSTMRecognizer::null_char ( ) const

inline

Definition at line 156 of file lstmrecognizer.h.

156 { return null_char_; }

tesseract::LSTMRecognizer::null_char_

inT32 null_char_

Definition: lstmrecognizer.h:371

◆ NumInputs()

int tesseract::LSTMRecognizer::NumInputs ( ) const

inline

Definition at line 153 of file lstmrecognizer.h.

                         {
     return network_->NumInputs();
   }

◆ NumOutputs()

int tesseract::LSTMRecognizer::NumOutputs ( ) const

inline

Definition at line 60 of file lstmrecognizer.h.

                          {
     return network_->NumOutputs();
   }

◆ OutputLossType()

LossType tesseract::LSTMRecognizer::OutputLossType ( ) const

inline

Definition at line 75 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 236 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_ || t == 0) {
       float best_output = outputs.f(t)[best_label];
       stats.add(static_cast<int>(kOutputScale * best_output), 1);
     }
   }
   *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,
		bool	use_alternates,
		const UNICHARSET *	target_unicharset,
		const TBOX &	line_box,
		float	score_ratio,
		bool	one_word,
		PointerVector< WERD_RES > *	words
	)

Definition at line 146 of file lstmrecognizer.cpp.

                                                                    {
   NetworkIO outputs;
   float label_threshold = use_alternates ? 0.75f : 0.0f;
   float scale_factor;
   NetworkIO inputs;
   if (!RecognizeLine(image_data, invert, debug, false, label_threshold,
                      &scale_factor, &inputs, &outputs))
     return;
   if (IsRecoding()) {
     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);
   } else {
     GenericVector<int> label_coords;
     GenericVector<int> labels;
     LabelsFromOutputs(outputs, label_threshold, &labels, &label_coords);
     WordsFromOutputs(outputs, labels, label_coords, line_box, debug,
                      use_alternates, one_word, score_ratio, scale_factor,
                      target_unicharset, words);
   }
 }

◆ RecognizeLine() [2/2]

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

Definition at line 256 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;
   }
   // 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, label_threshold, &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 66 of file lstmrecognizer.h.

                                {
     return sample_iteration_;
   }

◆ ScaleLayerLearningRate()

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

inline

Definition at line 133 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 122 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 ( TFile * fp ) const

Definition at line 72 of file lstmrecognizer.cpp.

                                               {
   if (!network_->Serialize(fp)) return false;
   if (!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(&weight_range_, sizeof(weight_range_), 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 (IsRecoding() && !recoder_.Serialize(fp)) return false;
   return true;
 }

◆ SetIteration()

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

inline

Definition at line 149 of file lstmrecognizer.h.

                                    {
     sample_iteration_ = iteration;
   }

◆ SetRandomSeed()

void tesseract::LSTMRecognizer::SetRandomSeed ( )

inlineprotected

Definition at line 263 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 81 of file lstmrecognizer.h.

81 { return OutputLossType() == LT_SOFTMAX; }

tesseract::LSTMRecognizer::OutputLossType

LossType OutputLossType() const

Definition: lstmrecognizer.h:75

tesseract::LT_SOFTMAX

Definition: static_shape.h:30

◆ training_iteration()

int tesseract::LSTMRecognizer::training_iteration ( ) const

inline

Definition at line 63 of file lstmrecognizer.h.

                                  {
     return training_iteration_;
   }

◆ WordFromOutput()

WERD_RES * tesseract::LSTMRecognizer::WordFromOutput	(	const TBOX &	line_box,
		const NetworkIO &	outputs,
		int	word_start,
		int	word_end,
		float	score_ratio,
		float	space_certainty,
		bool	debug,
		bool	use_alternates,
		const UNICHARSET *	target_unicharset,
		const GenericVector< int > &	labels,
		const GenericVector< int > &	label_coords,
		float	scale_factor
	)

Definition at line 332 of file lstmrecognizer.cpp.

                         {
   WERD_RES* word_res = InitializeWord(
       line_box, word_start, word_end, space_certainty, use_alternates,
       target_unicharset, labels, label_coords, scale_factor);
   int max_blob_run = word_res->ratings->bandwidth();
   for (int width = 1; width <= max_blob_run; ++width) {
     int col = 0;
     for (int i = word_start; i + width <= word_end; ++i) {
       if (labels[i] != null_char_) {
         // Starting at i, use width labels, but stop at the next null_char_.
         // This forms all combinations of blobs between regions of null_char_.
         int j = i + 1;
         while (j - i < width && labels[j] != null_char_) ++j;
         if (j - i == width) {
           // Make the blob choices.
           int end_coord = label_coords[j];
           if (j < word_end && labels[j] == null_char_)
             end_coord = label_coords[j + 1];
           BLOB_CHOICE_LIST* choices = GetBlobChoices(
               col, col + width - 1, debug, outputs, target_unicharset,
               label_coords[i], end_coord, score_ratio);
           if (choices == NULL) {
             delete word_res;
             return NULL;
           }
           word_res->ratings->put(col, col + width - 1, choices);
         }
         ++col;
       }
     }
   }
   if (use_alternates) {
     // Merge adjacent single results over null_char boundaries.
     int col = 0;
     for (int i = word_start; i + 2 < word_end; ++i) {
       if (labels[i] != null_char_ && labels[i + 1] == null_char_ &&
           labels[i + 2] != null_char_ &&
           (i == word_start || labels[i - 1] == null_char_) &&
           (i + 3 == word_end || labels[i + 3] == null_char_)) {
         int end_coord = label_coords[i + 3];
         if (i + 3 < word_end && labels[i + 3] == null_char_)
           end_coord = label_coords[i + 4];
         BLOB_CHOICE_LIST* choices =
             GetBlobChoices(col, col + 1, debug, outputs, target_unicharset,
                            label_coords[i], end_coord, score_ratio);
         if (choices == NULL) {
           delete word_res;
           return NULL;
         }
         word_res->ratings->put(col, col + 1, choices);
       }
       if (labels[i] != null_char_) ++col;
     }
   } else {
     word_res->FakeWordFromRatings(TOP_CHOICE_PERM);
   }
   return word_res;
 }

◆ WordsFromOutputs()

void tesseract::LSTMRecognizer::WordsFromOutputs	(	const NetworkIO &	outputs,
		const GenericVector< int > &	labels,
		const GenericVector< int >	label_coords,
		const TBOX &	line_box,
		bool	debug,
		bool	use_alternates,
		bool	one_word,
		float	score_ratio,
		float	scale_factor,
		const UNICHARSET *	target_unicharset,
		PointerVector< WERD_RES > *	words
	)

Definition at line 185 of file lstmrecognizer.cpp.

                                                                          {
   // Convert labels to unichar-ids.
   int word_end = 0;
   float prev_space_cert = 0.0f;
   for (int i = 0; i < labels.size(); i = word_end) {
     word_end = i + 1;
     if (labels[i] == null_char_ || labels[i] == UNICHAR_SPACE) {
       continue;
     }
     float space_cert = 0.0f;
     if (one_word) {
       word_end = labels.size();
     } else {
       // Find the end of the word at the first null_char_ that leads to the
       // first UNICHAR_SPACE.
       while (word_end < labels.size() && labels[word_end] != UNICHAR_SPACE)
         ++word_end;
       if (word_end < labels.size()) {
         float rating;
         outputs.ScoresOverRange(label_coords[word_end],
                                 label_coords[word_end] + 1, UNICHAR_SPACE,
                                 null_char_, &rating, &space_cert);
       }
       while (word_end > i && labels[word_end - 1] == null_char_) --word_end;
     }
     ASSERT_HOST(word_end > i);
     // Create a WERD_RES for the output word.
     if (debug)
       tprintf("Creating word from outputs over [%d,%d)\n", i, word_end);
     WERD_RES* word =
         WordFromOutput(line_box, outputs, i, word_end, score_ratio,
                        MIN(prev_space_cert, space_cert), debug,
                        use_alternates && !SimpleTextOutput(), target_unicharset,
                        labels, label_coords, scale_factor);
     if (word == NULL && target_unicharset != NULL) {
       // Unicharset translation failed - use decoder_ instead, and disable
       // the segmentation search on output, as it won't understand the encoding.
       word = WordFromOutput(line_box, outputs, i, word_end, score_ratio,
                             MIN(prev_space_cert, space_cert), debug, false,
                             NULL, labels, label_coords, scale_factor);
     }
     prev_space_cert = space_cert;
     words->push_back(word);
   }
 }

Member Data Documentation

◆ ccutil_

CCUtil tesseract::LSTMRecognizer::ccutil_

protected

Definition at line 354 of file lstmrecognizer.h.

◆ debug_win_

ScrollView* tesseract::LSTMRecognizer::debug_win_

protected

Definition at line 388 of file lstmrecognizer.h.

◆ dict_

Dict* tesseract::LSTMRecognizer::dict_

protected

Definition at line 382 of file lstmrecognizer.h.

◆ learning_rate_

float tesseract::LSTMRecognizer::learning_rate_

protected

Definition at line 375 of file lstmrecognizer.h.

◆ momentum_

float tesseract::LSTMRecognizer::momentum_

protected

Definition at line 376 of file lstmrecognizer.h.

◆ network_

Network* tesseract::LSTMRecognizer::network_

protected

Definition at line 351 of file lstmrecognizer.h.

◆ network_str_

STRING tesseract::LSTMRecognizer::network_str_

protected

Definition at line 361 of file lstmrecognizer.h.

◆ null_char_

inT32 tesseract::LSTMRecognizer::null_char_

protected

Definition at line 371 of file lstmrecognizer.h.

◆ randomizer_

TRand tesseract::LSTMRecognizer::randomizer_

protected

Definition at line 379 of file lstmrecognizer.h.

◆ recoder_

UnicharCompress tesseract::LSTMRecognizer::recoder_

protected

Definition at line 358 of file lstmrecognizer.h.

◆ sample_iteration_

inT32 tesseract::LSTMRecognizer::sample_iteration_

protected

Definition at line 368 of file lstmrecognizer.h.

◆ scratch_space_

NetworkScratch tesseract::LSTMRecognizer::scratch_space_

protected

Definition at line 380 of file lstmrecognizer.h.

◆ search_

RecodeBeamSearch* tesseract::LSTMRecognizer::search_

protected

Definition at line 384 of file lstmrecognizer.h.

◆ training_flags_

inT32 tesseract::LSTMRecognizer::training_flags_

protected

Definition at line 364 of file lstmrecognizer.h.

◆ training_iteration_

inT32 tesseract::LSTMRecognizer::training_iteration_

protected

Definition at line 366 of file lstmrecognizer.h.

◆ weight_range_

float tesseract::LSTMRecognizer::weight_range_

protected

Definition at line 373 of file lstmrecognizer.h.

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

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

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ LSTMRecognizer()

◆ ~LSTMRecognizer()

Member Function Documentation

◆ AddBlobChoices()

◆ CacheStrategy()

◆ DebugActivationPath()

◆ DebugActivationRange()

◆ DecodeLabel()

◆ DecodeLabels()

◆ DecodeSingleLabel()

◆ DeSerialize()

◆ DisplayForward()

◆ DisplayLSTMOutput()

◆ EnumerateLayers()

◆ GetBlobChoices()

◆ GetDict()

◆ GetLayer()

◆ GetLayerLearningRate()

◆ GetUnicharset()

◆ InitializeWord()

◆ IsHardening()

◆ IsIntMode()

◆ IsRecoding()

◆ IsTensorFlow()

◆ IsUsingAdaGrad()

◆ LabelsFromOutputs()

◆ LabelsViaCTC()

◆ LabelsViaReEncode()

◆ LabelsViaSimpleText()

◆ LabelsViaThreshold()

◆ learning_rate()

◆ LoadDictionary()

◆ null_char()

◆ NumInputs()

◆ NumOutputs()

◆ OutputLossType()

◆ OutputStats()

◆ RecognizeLine() [1/2]

◆ RecognizeLine() [2/2]

◆ sample_iteration()

◆ ScaleLayerLearningRate()

◆ ScaleLearningRate()

◆ Serialize()

◆ SetIteration()

◆ SetRandomSeed()

◆ SimpleTextOutput()

◆ training_iteration()

◆ WordFromOutput()

◆ WordsFromOutputs()

Member Data Documentation

◆ ccutil_

◆ debug_win_

◆ dict_

◆ learning_rate_

◆ momentum_

◆ network_

◆ network_str_

◆ null_char_

◆ randomizer_

◆ recoder_

◆ sample_iteration_

◆ scratch_space_

◆ search_

◆ training_flags_

◆ training_iteration_

◆ weight_range_