tesseract::RecodeBeamSearch Class Reference

#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

RecodeBeamSearch()

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

BeamIndex()

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

ContinuationFromBeamsIndex()

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

inlinestatic

Definition at line 230 of file recodebeam.h.

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

DebugBeams()

void tesseract::RecodeBeamSearch::DebugBeams

(

const UNICHARSET &

unicharset

)

const

Definition at line 317 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) {
        NodeContinuation 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]);
      }
    }
  }
}

Decode() [1/2]

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);
    }
  }
}

Decode() [2/2]

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);
  }
}

ExtractBestPathAsLabels()

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

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

ExtractBestPathAsUnicharIds()

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 163 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);
  }
}

ExtractBestPathAsWords()

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 178 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::pair<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 current_char;
  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) {
      current_char = best_choices.front().first;
      timestepEnd = best_choices.front().second;
      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) {
      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, "") != 0) {
            sum += choice.second;
            choice_pairs.push_back(choice);
          }
        }
        if ((best_choices.size() > 0 && i == best_choices.front().second - 1)
            || i == xcoords[word_end]-1) {
          std::map<const char*, float> summed_propabilities;
          for (auto it = choice_pairs.begin(); it != choice_pairs.end(); ++it) {
            summed_propabilities[it->first] += it->second;
          }
          std::vector<std::pair<const char*, float>> accumulated_timestep;
          accumulated_timestep.push_back(std::pair<const char*,float>
                                        (unicharset->id_to_unichar_ext
                                        (current_char), 2.0));
          int pos;
          for (auto it = summed_propabilities.begin();
               it != summed_propabilities.end(); ++it) {
            if(sum == 0) break;
            it->second/=sum;
            pos = 0;
            while (accumulated_timestep.size() > pos
                   && accumulated_timestep[pos].second > it->second) {
              pos++;
            }
            accumulated_timestep.insert(accumulated_timestep.begin() + pos,
                                        std::pair<const char*,float>(it->first,
                                        it->second));
          }
          if (best_choices.size() > 0) {
            current_char = best_choices.front().first;
            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) {
      BLOB_CHOICE_LIST* choices = new BLOB_CHOICE_LIST;
      BLOB_CHOICE_IT bc_it(choices);
      BLOB_CHOICE* 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;
  }
}

IsDawgFromBeamsIndex()

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

inlinestatic

Definition at line 233 of file recodebeam.h.

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

LengthFromBeamsIndex()

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

inlinestatic

Definition at line 229 of file recodebeam.h.

{ return index % kNumLengths; }

Member Data Documentation

kMinCertainty

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

static

Definition at line 222 of file recodebeam.h.

kNumBeams

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

static

Definition at line 227 of file recodebeam.h.

kNumLengths

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

static

Definition at line 224 of file recodebeam.h.

timesteps

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:

• /usr/src/tesseract-ocr.master/src/lstm/recodebeam.h
• /usr/src/tesseract-ocr.master/src/lstm/recodebeam.cpp