#include <recodebeam.h>

Public Member Functions
	RecodeBeamSearch (const UnicharCompress &recoder, int null_char, bool simple_text, Dict *dict)

void	Decode (const NetworkIO &output, double dict_ratio, double cert_offset, double worst_dict_cert, const UNICHARSET *charset, int lstm_choice_mode=0)

void	Decode (const GENERIC_2D_ARRAY< float > &output, double dict_ratio, double cert_offset, double worst_dict_cert, const UNICHARSET *charset)

void	ExtractBestPathAsLabels (GenericVector< int > labels, GenericVector< int > xcoords) const

void	ExtractBestPathAsUnicharIds (bool debug, const UNICHARSET unicharset, GenericVector< int > unichar_ids, GenericVector< float > certs, GenericVector< float > ratings, GenericVector< int > *xcoords) const

void	ExtractBestPathAsWords (const TBOX &line_box, float scale_factor, bool debug, const UNICHARSET unicharset, PointerVector< WERD_RES > words, int lstm_choice_mode=0)

void	DebugBeams (const UNICHARSET &unicharset) const

Static Public Member Functions
static int	LengthFromBeamsIndex (int index)

static NodeContinuation	ContinuationFromBeamsIndex (int index)

static bool	IsDawgFromBeamsIndex (int index)

static int	BeamIndex (bool is_dawg, NodeContinuation cont, int length)

Public Attributes
std::vector< std::vector< std::pair< const char *, float > > >	timesteps

Static Public Attributes
static const float	kMinCertainty = -20.0f

static const int	kNumLengths = RecodedCharID::kMaxCodeLen + 1

static const int	kNumBeams = 2 * NC_COUNT * kNumLengths

Detailed Description

Definition at line 179 of file recodebeam.h.

Constructor & Destructor Documentation

tesseract::RecodeBeamSearch::RecodeBeamSearch	(	const UnicharCompress &	recoder,
		int	null_char,
		bool	simple_text,
		Dict *	dict
	)

Definition at line 68 of file recodebeam.cpp.

     : recoder_(recoder),
       beam_size_(0),
       top_code_(-1),
       second_code_(-1),
       dict_(dict),
       space_delimited_(true),
       is_simple_text_(simple_text),
       null_char_(null_char) {
   if (dict_ != nullptr && !dict_->IsSpaceDelimitedLang()) space_delimited_ = false;
 }

Member Function Documentation

static int tesseract::RecodeBeamSearch::BeamIndex	(	bool	is_dawg,
		NodeContinuation	cont,
		int	length
	)

inlinestatic

Definition at line 237 of file recodebeam.h.

                                                                         {
     return (is_dawg * NC_COUNT + cont) * kNumLengths + length;
   }

static NodeContinuation tesseract::RecodeBeamSearch::ContinuationFromBeamsIndex ( int index )

inlinestatic

Definition at line 230 of file recodebeam.h.

                                                                 {
     return static_cast<NodeContinuation>((index / kNumLengths) % NC_COUNT);
   }

void tesseract::RecodeBeamSearch::DebugBeams ( const UNICHARSET & unicharset ) const

Definition at line 309 of file recodebeam.cpp.

                                                                     {
   for (int p = 0; p < beam_size_; ++p) {
     for (int d = 0; d < 2; ++d) {
       for (int c = 0; c < NC_COUNT; ++c) {
         auto cont = static_cast<NodeContinuation>(c);
         int index = BeamIndex(d, cont, 0);
         if (beam_[p]->beams_[index].empty()) continue;
         // Print all the best scoring nodes for each unichar found.
         tprintf("Position %d: %s+%s beam\n", p, d ? "Dict" : "Non-Dict",
                 kNodeContNames[c]);
         DebugBeamPos(unicharset, beam_[p]->beams_[index]);
       }
     }
   }
 }

void tesseract::RecodeBeamSearch::Decode	(	const NetworkIO &	output,
		double	dict_ratio,
		double	cert_offset,
		double	worst_dict_cert,
		const UNICHARSET *	charset,
		int	lstm_choice_mode = `0`
	)

Definition at line 82 of file recodebeam.cpp.

                                                                                {
   beam_size_ = 0;
   int width = output.Width();
   if (lstm_choice_mode)
     timesteps.clear();
   for (int t = 0; t < width; ++t) {
     ComputeTopN(output.f(t), output.NumFeatures(), kBeamWidths[0]);
     DecodeStep(output.f(t), t, dict_ratio, cert_offset, worst_dict_cert,
                charset);
     if (lstm_choice_mode) {
       SaveMostCertainChoices(output.f(t), output.NumFeatures(), charset, t);
     }
   }
 }

void tesseract::RecodeBeamSearch::Decode	(	const GENERIC_2D_ARRAY< float > &	output,
		double	dict_ratio,
		double	cert_offset,
		double	worst_dict_cert,
		const UNICHARSET *	charset
	)

Definition at line 98 of file recodebeam.cpp.

                                                          {
   beam_size_ = 0;
   int width = output.dim1();
   for (int t = 0; t < width; ++t) {
     ComputeTopN(output[t], output.dim2(), kBeamWidths[0]);
     DecodeStep(output[t], t, dict_ratio, cert_offset, worst_dict_cert, charset);
   }
 }

void tesseract::RecodeBeamSearch::ExtractBestPathAsLabels	(	GenericVector< int > *	labels,
		GenericVector< int > *	xcoords
	)		const

Definition at line 139 of file recodebeam.cpp.

                                                                    {
   labels->truncate(0);
   xcoords->truncate(0);
   GenericVector<const RecodeNode*> best_nodes;
   ExtractBestPaths(&best_nodes, nullptr);
   // Now just run CTC on the best nodes.
   int t = 0;
   int width = best_nodes.size();
   while (t < width) {
     int label = best_nodes[t]->code;
     if (label != null_char_) {
       labels->push_back(label);
       xcoords->push_back(t);
     }
     while (++t < width && !is_simple_text_ && best_nodes[t]->code == label) {
     }
   }
   xcoords->push_back(width);
 }

void tesseract::RecodeBeamSearch::ExtractBestPathAsUnicharIds	(	bool	debug,
		const UNICHARSET *	unicharset,
		GenericVector< int > *	unichar_ids,
		GenericVector< float > *	certs,
		GenericVector< float > *	ratings,
		GenericVector< int > *	xcoords
	)		const

Definition at line 162 of file recodebeam.cpp.

                                        {
   GenericVector<const RecodeNode*> best_nodes;
   ExtractBestPaths(&best_nodes, nullptr);
   ExtractPathAsUnicharIds(best_nodes, unichar_ids, certs, ratings, xcoords);
   if (debug) {
     DebugPath(unicharset, best_nodes);
     DebugUnicharPath(unicharset, best_nodes, *unichar_ids, *certs, *ratings,
                      *xcoords);
   }
 }

void tesseract::RecodeBeamSearch::ExtractBestPathAsWords	(	const TBOX &	line_box,
		float	scale_factor,
		bool	debug,
		const UNICHARSET *	unicharset,
		PointerVector< WERD_RES > *	words,
		int	lstm_choice_mode = `0`
	)

Definition at line 177 of file recodebeam.cpp.

                                                                     {
   words->truncate(0);
   GenericVector<int> unichar_ids;
   GenericVector<float> certs;
   GenericVector<float> ratings;
   GenericVector<int> xcoords;
   GenericVector<const RecodeNode*> best_nodes;
   GenericVector<const RecodeNode*> second_nodes;
   std::deque<std::tuple<int, int>> best_choices;
   ExtractBestPaths(&best_nodes, &second_nodes);
   if (debug) {
     DebugPath(unicharset, best_nodes);
     ExtractPathAsUnicharIds(second_nodes, &unichar_ids, &certs, &ratings,
                             &xcoords);
     tprintf("\nSecond choice path:\n");
     DebugUnicharPath(unicharset, second_nodes, unichar_ids, certs, ratings,
                      xcoords);
   }
   int timestepEnd= 0;
   //if lstm choice mode is required in granularity level 2 it stores the x
   //Coordinates of every chosen character to match the alternative choices to it
   if (lstm_choice_mode == 2) {
     ExtractPathAsUnicharIds(best_nodes, &unichar_ids, &certs, &ratings,
                             &xcoords, &best_choices);
     if (best_choices.size() > 0) {
       timestepEnd = std::get<1>(best_choices.front());
       best_choices.pop_front();
     }
   } else {
     ExtractPathAsUnicharIds(best_nodes, &unichar_ids, &certs, &ratings,
                             &xcoords);
   }
   int num_ids = unichar_ids.size();
   if (debug) {
     DebugUnicharPath(unicharset, best_nodes, unichar_ids, certs, ratings,
                      xcoords);
   }
   // Convert labels to unichar-ids.
   int word_end = 0;
   float prev_space_cert = 0.0f;
   for (int word_start = 0; word_start < num_ids; word_start = word_end) {
     for (word_end = word_start + 1; word_end < num_ids; ++word_end) {
       // A word is terminated when a space character or start_of_word flag is
       // hit. We also want to force a separate word for every non
       // space-delimited character when not in a dictionary context.
       if (unichar_ids[word_end] == UNICHAR_SPACE) break;
       int index = xcoords[word_end];
       if (best_nodes[index]->start_of_word) break;
       if (best_nodes[index]->permuter == TOP_CHOICE_PERM &&
           (!unicharset->IsSpaceDelimited(unichar_ids[word_end]) ||
            !unicharset->IsSpaceDelimited(unichar_ids[word_end - 1])))
         break;
     }
     float space_cert = 0.0f;
     if (word_end < num_ids && unichar_ids[word_end] == UNICHAR_SPACE)
       space_cert = certs[word_end];
     bool leading_space =
         word_start > 0 && unichar_ids[word_start - 1] == UNICHAR_SPACE;
     // Create a WERD_RES for the output word.
     WERD_RES* word_res = InitializeWord(
         leading_space, line_box, word_start, word_end,
         std::min(space_cert, prev_space_cert), unicharset, xcoords, scale_factor);
     if (lstm_choice_mode == 1) {
       for (size_t i = timestepEnd; i < xcoords[word_end]; i++) {
         word_res->timesteps.push_back(timesteps[i]);
       }
       timestepEnd = xcoords[word_end];
     } else if (lstm_choice_mode == 2){
       // Accumulated Timesteps (choice mode 2 processing)
       float sum = 0;
       std::vector<std::pair<const char*, float>> choice_pairs;
       for (size_t i = timestepEnd; i < xcoords[word_end]; i++) {
         for (std::pair<const char*, float> choice : timesteps[i]) {
           if (std::strcmp(choice.first, "")) {
             sum += choice.second;
             choice_pairs.push_back(choice);
           }
         }
         if ((best_choices.size() > 0 && i == std::get<1>(best_choices.front()) - 1)
             || i == xcoords[word_end]-1) {
           std::map<const char*, float> summed_propabilities;
           for (auto & choice_pair : choice_pairs) {
             summed_propabilities[choice_pair.first] += choice_pair.second;
           }
           std::vector<std::pair<const char*, float>> accumulated_timestep;
           for (auto& summed_propability : summed_propabilities) {
             if(sum == 0) break;
             summed_propability.second/=sum;
             size_t pos = 0;
             while (accumulated_timestep.size() > pos
                    && accumulated_timestep[pos].second > summed_propability.second) {
               pos++;
             }
             accumulated_timestep.insert(accumulated_timestep.begin() + pos,
                                         std::pair<const char*,float>(summed_propability.first,
                                         summed_propability.second));
           }
           if (best_choices.size() > 0) {
             best_choices.pop_front();
           }
           choice_pairs.clear();
           word_res->timesteps.push_back(accumulated_timestep);
           sum = 0;
         }
       }
       timestepEnd = xcoords[word_end];
     }
     for (int i = word_start; i < word_end; ++i) {
       auto* choices = new BLOB_CHOICE_LIST;
       BLOB_CHOICE_IT bc_it(choices);
       auto* choice = new BLOB_CHOICE(
           unichar_ids[i], ratings[i], certs[i], -1, 1.0f,
           static_cast<float>(INT16_MAX), 0.0f, BCC_STATIC_CLASSIFIER);
       int col = i - word_start;
       choice->set_matrix_cell(col, col);
       bc_it.add_after_then_move(choice);
       word_res->ratings->put(col, col, choices);
     }
     int index = xcoords[word_end - 1];
     word_res->FakeWordFromRatings(best_nodes[index]->permuter);
     words->push_back(word_res);
     prev_space_cert = space_cert;
     if (word_end < num_ids && unichar_ids[word_end] == UNICHAR_SPACE)
       ++word_end;
   }
 }

static bool tesseract::RecodeBeamSearch::IsDawgFromBeamsIndex ( int index )

inlinestatic

Definition at line 233 of file recodebeam.h.

                                               {
     return index / (kNumLengths * NC_COUNT) > 0;
   }

static int tesseract::RecodeBeamSearch::LengthFromBeamsIndex ( int index )

inlinestatic

Definition at line 229 of file recodebeam.h.

229 { return index % kNumLengths; }

tesseract::RecodeBeamSearch::kNumLengths

static const int kNumLengths

Definition: recodebeam.h:224

Member Data Documentation

const float tesseract::RecodeBeamSearch::kMinCertainty = -20.0f

static

Definition at line 222 of file recodebeam.h.

const int tesseract::RecodeBeamSearch::kNumBeams = 2 * NC_COUNT * kNumLengths

static

Definition at line 227 of file recodebeam.h.

const int tesseract::RecodeBeamSearch::kNumLengths = RecodedCharID::kMaxCodeLen + 1

static

Definition at line 224 of file recodebeam.h.

std::vector< std::vector<std::pair<const char*, float> > > tesseract::RecodeBeamSearch::timesteps

Definition at line 216 of file recodebeam.h.

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

src/lstm/recodebeam.h
src/lstm/recodebeam.cpp

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation