tesseract  4.1.1
tesseract::LSTMTrainer Class Reference

#include <lstmtrainer.h>

Inheritance diagram for tesseract::LSTMTrainer:
tesseract::LSTMRecognizer

Public Member Functions

 LSTMTrainer ()
 
 LSTMTrainer (FileReader file_reader, FileWriter file_writer, CheckPointReader checkpoint_reader, CheckPointWriter checkpoint_writer, const char *model_base, const char *checkpoint_name, int debug_interval, int64_t max_memory)
 
virtual ~LSTMTrainer ()
 
bool TryLoadingCheckpoint (const char *filename, const char *old_traineddata)
 
void InitCharSet (const std::string &traineddata_path)
 
void InitCharSet (const TessdataManager &mgr)
 
bool InitNetwork (const STRING &network_spec, int append_index, int net_flags, float weight_range, float learning_rate, float momentum, float adam_beta)
 
int InitTensorFlowNetwork (const std::string &tf_proto)
 
void InitIterations ()
 
double ActivationError () const
 
double CharError () const
 
const double * error_rates () const
 
double best_error_rate () const
 
int best_iteration () const
 
int learning_iteration () const
 
int32_t improvement_steps () const
 
void set_perfect_delay (int delay)
 
const GenericVector< char > & best_trainer () const
 
double NewSingleError (ErrorTypes type) const
 
double LastSingleError (ErrorTypes type) const
 
const DocumentCachetraining_data () const
 
DocumentCachemutable_training_data ()
 
Trainability GridSearchDictParams (const ImageData *trainingdata, int iteration, double min_dict_ratio, double dict_ratio_step, double max_dict_ratio, double min_cert_offset, double cert_offset_step, double max_cert_offset, STRING *results)
 
void DebugNetwork ()
 
bool LoadAllTrainingData (const GenericVector< STRING > &filenames, CachingStrategy cache_strategy, bool randomly_rotate)
 
bool MaintainCheckpoints (TestCallback tester, STRING *log_msg)
 
bool MaintainCheckpointsSpecific (int iteration, const GenericVector< char > *train_model, const GenericVector< char > *rec_model, TestCallback tester, STRING *log_msg)
 
void PrepareLogMsg (STRING *log_msg) const
 
void LogIterations (const char *intro_str, STRING *log_msg) const
 
bool TransitionTrainingStage (float error_threshold)
 
int CurrentTrainingStage () const
 
bool Serialize (SerializeAmount serialize_amount, const TessdataManager *mgr, TFile *fp) const
 
bool DeSerialize (const TessdataManager *mgr, TFile *fp)
 
void StartSubtrainer (STRING *log_msg)
 
SubTrainerResult UpdateSubtrainer (STRING *log_msg)
 
void ReduceLearningRates (LSTMTrainer *samples_trainer, STRING *log_msg)
 
int ReduceLayerLearningRates (double factor, int num_samples, LSTMTrainer *samples_trainer)
 
bool EncodeString (const STRING &str, GenericVector< int > *labels) const
 
const ImageDataTrainOnLine (LSTMTrainer *samples_trainer, bool batch)
 
Trainability TrainOnLine (const ImageData *trainingdata, bool batch)
 
Trainability PrepareForBackward (const ImageData *trainingdata, NetworkIO *fwd_outputs, NetworkIO *targets)
 
bool SaveTrainingDump (SerializeAmount serialize_amount, const LSTMTrainer *trainer, GenericVector< char > *data) const
 
bool ReadTrainingDump (const GenericVector< char > &data, LSTMTrainer *trainer) const
 
bool ReadSizedTrainingDump (const char *data, int size, LSTMTrainer *trainer) const
 
bool ReadLocalTrainingDump (const TessdataManager *mgr, const char *data, int size)
 
void SetupCheckpointInfo ()
 
bool SaveTraineddata (const STRING &filename)
 
void SaveRecognitionDump (GenericVector< char > *data) const
 
STRING DumpFilename () const
 
void FillErrorBuffer (double new_error, ErrorTypes type)
 
std::vector< int > MapRecoder (const UNICHARSET &old_chset, const UnicharCompress &old_recoder) const
 
- Public Member Functions inherited from tesseract::LSTMRecognizer
 LSTMRecognizer ()
 
 LSTMRecognizer (const STRING language_data_path_prefix)
 
 ~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< STRINGEnumerateLayers () const
 
NetworkGetLayer (const STRING &id) const
 
float GetLayerLearningRate (const STRING &id) const
 
void ScaleLearningRate (double factor)
 
void ScaleLayerLearningRate (const STRING &id, double factor)
 
void ConvertToInt ()
 
const UNICHARSETGetUnicharset () const
 
const UnicharCompressGetRecoder () const
 
const DictGetDict () 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)
 

Static Public Member Functions

static bool EncodeString (const STRING &str, const UNICHARSET &unicharset, const UnicharCompress *recoder, bool simple_text, int null_char, GenericVector< int > *labels)
 

Protected Member Functions

void InitCharSet ()
 
void SetNullChar ()
 
void EmptyConstructor ()
 
bool DebugLSTMTraining (const NetworkIO &inputs, const ImageData &trainingdata, const NetworkIO &fwd_outputs, const GenericVector< int > &truth_labels, const NetworkIO &outputs)
 
void DisplayTargets (const NetworkIO &targets, const char *window_name, ScrollView **window)
 
bool ComputeTextTargets (const NetworkIO &outputs, const GenericVector< int > &truth_labels, NetworkIO *targets)
 
bool ComputeCTCTargets (const GenericVector< int > &truth_labels, NetworkIO *outputs, NetworkIO *targets)
 
double ComputeErrorRates (const NetworkIO &deltas, double char_error, double word_error)
 
double ComputeRMSError (const NetworkIO &deltas)
 
double ComputeWinnerError (const NetworkIO &deltas)
 
double ComputeCharError (const GenericVector< int > &truth_str, const GenericVector< int > &ocr_str)
 
double ComputeWordError (STRING *truth_str, STRING *ocr_str)
 
void UpdateErrorBuffer (double new_error, ErrorTypes type)
 
void RollErrorBuffers ()
 
STRING UpdateErrorGraph (int iteration, double error_rate, const GenericVector< char > &model_data, TestCallback tester)
 
- Protected Member Functions inherited from tesseract::LSTMRecognizer
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

ScrollViewalign_win_
 
ScrollViewtarget_win_
 
ScrollViewctc_win_
 
ScrollViewrecon_win_
 
int debug_interval_
 
int checkpoint_iteration_
 
STRING model_base_
 
STRING checkpoint_name_
 
bool randomly_rotate_
 
DocumentCache training_data_
 
STRING best_model_name_
 
int num_training_stages_
 
FileReader file_reader_
 
FileWriter file_writer_
 
CheckPointReader checkpoint_reader_
 
CheckPointWriter checkpoint_writer_
 
double best_error_rate_
 
double best_error_rates_ [ET_COUNT]
 
int best_iteration_
 
double worst_error_rate_
 
double worst_error_rates_ [ET_COUNT]
 
int worst_iteration_
 
int stall_iteration_
 
GenericVector< char > best_model_data_
 
GenericVector< char > worst_model_data_
 
GenericVector< char > best_trainer_
 
LSTMTrainersub_trainer_
 
float error_rate_of_last_saved_best_
 
int training_stage_
 
GenericVector< double > best_error_history_
 
GenericVector< int > best_error_iterations_
 
int32_t improvement_steps_
 
int learning_iteration_
 
int prev_sample_iteration_
 
int perfect_delay_
 
int last_perfect_training_iteration_
 
GenericVector< double > error_buffers_ [ET_COUNT]
 
double error_rates_ [ET_COUNT]
 
TessdataManager mgr_
 
- Protected Attributes inherited from tesseract::LSTMRecognizer
Networknetwork_
 
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_
 
Dictdict_
 
RecodeBeamSearchsearch_
 
ScrollViewdebug_win_
 

Static Protected Attributes

static const int kRollingBufferSize_ = 1000
 

Detailed Description

Definition at line 89 of file lstmtrainer.h.

Constructor & Destructor Documentation

◆ LSTMTrainer() [1/2]

tesseract::LSTMTrainer::LSTMTrainer ( )

Definition at line 74 of file lstmtrainer.cpp.

75  : randomly_rotate_(false),
76  training_data_(0),
83  sub_trainer_(nullptr) {
85  debug_interval_ = 0;
86 }
bool LoadDataFromFile(const char *filename, GenericVector< char > *data)
bool ReadTrainingDump(const GenericVector< char > &data, LSTMTrainer *trainer) const
Definition: lstmtrainer.h:291
LSTMTrainer * sub_trainer_
Definition: lstmtrainer.h:450
CheckPointReader checkpoint_reader_
Definition: lstmtrainer.h:424
bool SaveDataToFile(const GenericVector< char > &data, const STRING &filename)
CheckPointWriter checkpoint_writer_
Definition: lstmtrainer.h:425
_ConstTessMemberResultCallback_5_0< false, R, T1, P1, P2, P3, P4, P5 >::base * NewPermanentTessCallback(const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5) const, typename Identity< P1 >::type p1, typename Identity< P2 >::type p2, typename Identity< P3 >::type p3, typename Identity< P4 >::type p4, typename Identity< P5 >::type p5)
Definition: tesscallback.h:258
DocumentCache training_data_
Definition: lstmtrainer.h:414
bool SaveTrainingDump(SerializeAmount serialize_amount, const LSTMTrainer *trainer, GenericVector< char > *data) const

◆ LSTMTrainer() [2/2]

tesseract::LSTMTrainer::LSTMTrainer ( FileReader  file_reader,
FileWriter  file_writer,
CheckPointReader  checkpoint_reader,
CheckPointWriter  checkpoint_writer,
const char *  model_base,
const char *  checkpoint_name,
int  debug_interval,
int64_t  max_memory 
)

Definition at line 88 of file lstmtrainer.cpp.

93  : randomly_rotate_(false),
94  training_data_(max_memory),
95  file_reader_(file_reader),
96  file_writer_(file_writer),
97  checkpoint_reader_(checkpoint_reader),
98  checkpoint_writer_(checkpoint_writer),
99  sub_trainer_(nullptr),
100  mgr_(file_reader) {
102  if (file_reader_ == nullptr) file_reader_ = LoadDataFromFile;
103  if (file_writer_ == nullptr) file_writer_ = SaveDataToFile;
104  if (checkpoint_reader_ == nullptr) {
107  }
108  if (checkpoint_writer_ == nullptr) {
111  }
112  debug_interval_ = debug_interval;
113  model_base_ = model_base;
114  checkpoint_name_ = checkpoint_name;
115 }
bool LoadDataFromFile(const char *filename, GenericVector< char > *data)
bool ReadTrainingDump(const GenericVector< char > &data, LSTMTrainer *trainer) const
Definition: lstmtrainer.h:291
LSTMTrainer * sub_trainer_
Definition: lstmtrainer.h:450
CheckPointReader checkpoint_reader_
Definition: lstmtrainer.h:424
bool SaveDataToFile(const GenericVector< char > &data, const STRING &filename)
CheckPointWriter checkpoint_writer_
Definition: lstmtrainer.h:425
TessdataManager mgr_
Definition: lstmtrainer.h:483
_ConstTessMemberResultCallback_5_0< false, R, T1, P1, P2, P3, P4, P5 >::base * NewPermanentTessCallback(const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5) const, typename Identity< P1 >::type p1, typename Identity< P2 >::type p2, typename Identity< P3 >::type p3, typename Identity< P4 >::type p4, typename Identity< P5 >::type p5)
Definition: tesscallback.h:258
DocumentCache training_data_
Definition: lstmtrainer.h:414
bool SaveTrainingDump(SerializeAmount serialize_amount, const LSTMTrainer *trainer, GenericVector< char > *data) const

◆ ~LSTMTrainer()

tesseract::LSTMTrainer::~LSTMTrainer ( )
virtual

Definition at line 117 of file lstmtrainer.cpp.

117  {
118  delete align_win_;
119  delete target_win_;
120  delete ctc_win_;
121  delete recon_win_;
122  delete checkpoint_reader_;
123  delete checkpoint_writer_;
124  delete sub_trainer_;
125 }
LSTMTrainer * sub_trainer_
Definition: lstmtrainer.h:450
ScrollView * ctc_win_
Definition: lstmtrainer.h:401
CheckPointReader checkpoint_reader_
Definition: lstmtrainer.h:424
ScrollView * target_win_
Definition: lstmtrainer.h:399
CheckPointWriter checkpoint_writer_
Definition: lstmtrainer.h:425
ScrollView * recon_win_
Definition: lstmtrainer.h:403
ScrollView * align_win_
Definition: lstmtrainer.h:397

Member Function Documentation

◆ ActivationError()

double tesseract::LSTMTrainer::ActivationError ( ) const
inline

Definition at line 136 of file lstmtrainer.h.

136  {
137  return error_rates_[ET_DELTA];
138  }
double error_rates_[ET_COUNT]
Definition: lstmtrainer.h:481

◆ best_error_rate()

double tesseract::LSTMTrainer::best_error_rate ( ) const
inline

Definition at line 143 of file lstmtrainer.h.

143  {
144  return best_error_rate_;
145  }

◆ best_iteration()

int tesseract::LSTMTrainer::best_iteration ( ) const
inline

Definition at line 146 of file lstmtrainer.h.

146  {
147  return best_iteration_;
148  }

◆ best_trainer()

const GenericVector<char>& tesseract::LSTMTrainer::best_trainer ( ) const
inline

Definition at line 152 of file lstmtrainer.h.

152 { return best_trainer_; }
GenericVector< char > best_trainer_
Definition: lstmtrainer.h:447

◆ CharError()

double tesseract::LSTMTrainer::CharError ( ) const
inline

Definition at line 139 of file lstmtrainer.h.

◆ ComputeCharError()

double tesseract::LSTMTrainer::ComputeCharError ( const GenericVector< int > &  truth_str,
const GenericVector< int > &  ocr_str 
)
protected

Definition at line 1191 of file lstmtrainer.cpp.

1192  {
1193  GenericVector<int> label_counts;
1194  label_counts.init_to_size(NumOutputs(), 0);
1195  int truth_size = 0;
1196  for (int i = 0; i < truth_str.size(); ++i) {
1197  if (truth_str[i] != null_char_) {
1198  ++label_counts[truth_str[i]];
1199  ++truth_size;
1200  }
1201  }
1202  for (int i = 0; i < ocr_str.size(); ++i) {
1203  if (ocr_str[i] != null_char_) {
1204  --label_counts[ocr_str[i]];
1205  }
1206  }
1207  int char_errors = 0;
1208  for (int i = 0; i < label_counts.size(); ++i) {
1209  char_errors += abs(label_counts[i]);
1210  }
1211  if (truth_size == 0) {
1212  return (char_errors == 0) ? 0.0 : 1.0;
1213  }
1214  return static_cast<double>(char_errors) / truth_size;
1215 }
void init_to_size(int size, const T &t)
int size() const
Definition: genericvector.h:72

◆ ComputeCTCTargets()

bool tesseract::LSTMTrainer::ComputeCTCTargets ( const GenericVector< int > &  truth_labels,
NetworkIO outputs,
NetworkIO targets 
)
protected

Definition at line 1123 of file lstmtrainer.cpp.

1124  {
1125  // Bottom-clip outputs to a minimum probability.
1126  CTC::NormalizeProbs(outputs);
1127  return CTC::ComputeCTCTargets(truth_labels, null_char_,
1128  outputs->float_array(), targets);
1129 }
static void NormalizeProbs(NetworkIO *probs)
Definition: ctc.h:36
static bool ComputeCTCTargets(const GenericVector< int > &truth_labels, int null_char, const GENERIC_2D_ARRAY< float > &outputs, NetworkIO *targets)
Definition: ctc.cpp:54

◆ ComputeErrorRates()

double tesseract::LSTMTrainer::ComputeErrorRates ( const NetworkIO deltas,
double  char_error,
double  word_error 
)
protected

Definition at line 1134 of file lstmtrainer.cpp.

1135  {
1137  // Delta error is the fraction of timesteps with >0.5 error in the top choice
1138  // score. If zero, then the top choice characters are guaranteed correct,
1139  // even when there is residue in the RMS error.
1140  double delta_error = ComputeWinnerError(deltas);
1141  UpdateErrorBuffer(delta_error, ET_DELTA);
1142  UpdateErrorBuffer(word_error, ET_WORD_RECERR);
1143  UpdateErrorBuffer(char_error, ET_CHAR_ERROR);
1144  // Skip ratio measures the difference between sample_iteration_ and
1145  // training_iteration_, which reflects the number of unusable samples,
1146  // usually due to unencodable truth text, or the text not fitting in the
1147  // space for the output.
1148  double skip_count = sample_iteration_ - prev_sample_iteration_;
1149  UpdateErrorBuffer(skip_count, ET_SKIP_RATIO);
1150  return delta_error;
1151 }
void UpdateErrorBuffer(double new_error, ErrorTypes type)
double ComputeRMSError(const NetworkIO &deltas)
double ComputeWinnerError(const NetworkIO &deltas)

◆ ComputeRMSError()

double tesseract::LSTMTrainer::ComputeRMSError ( const NetworkIO deltas)
protected

Definition at line 1154 of file lstmtrainer.cpp.

1154  {
1155  double total_error = 0.0;
1156  int width = deltas.Width();
1157  int num_classes = deltas.NumFeatures();
1158  for (int t = 0; t < width; ++t) {
1159  const float* class_errs = deltas.f(t);
1160  for (int c = 0; c < num_classes; ++c) {
1161  double error = class_errs[c];
1162  total_error += error * error;
1163  }
1164  }
1165  return sqrt(total_error / (width * num_classes));
1166 }

◆ ComputeTextTargets()

bool tesseract::LSTMTrainer::ComputeTextTargets ( const NetworkIO outputs,
const GenericVector< int > &  truth_labels,
NetworkIO targets 
)
protected

Definition at line 1103 of file lstmtrainer.cpp.

1105  {
1106  if (truth_labels.size() > targets->Width()) {
1107  tprintf("Error: transcription %s too long to fit into target of width %d\n",
1108  DecodeLabels(truth_labels).string(), targets->Width());
1109  return false;
1110  }
1111  for (int i = 0; i < truth_labels.size() && i < targets->Width(); ++i) {
1112  targets->SetActivations(i, truth_labels[i], 1.0);
1113  }
1114  for (int i = truth_labels.size(); i < targets->Width(); ++i) {
1115  targets->SetActivations(i, null_char_, 1.0);
1116  }
1117  return true;
1118 }
DLLSYM void tprintf(const char *format,...)
Definition: tprintf.cpp:35
STRING DecodeLabels(const GenericVector< int > &labels)
int size() const
Definition: genericvector.h:72

◆ ComputeWinnerError()

double tesseract::LSTMTrainer::ComputeWinnerError ( const NetworkIO deltas)
protected

Definition at line 1173 of file lstmtrainer.cpp.

1173  {
1174  int num_errors = 0;
1175  int width = deltas.Width();
1176  int num_classes = deltas.NumFeatures();
1177  for (int t = 0; t < width; ++t) {
1178  const float* class_errs = deltas.f(t);
1179  for (int c = 0; c < num_classes; ++c) {
1180  float abs_delta = fabs(class_errs[c]);
1181  // TODO(rays) Filtering cases where the delta is very large to cut out
1182  // GT errors doesn't work. Find a better way or get better truth.
1183  if (0.5 <= abs_delta)
1184  ++num_errors;
1185  }
1186  }
1187  return static_cast<double>(num_errors) / width;
1188 }

◆ ComputeWordError()

double tesseract::LSTMTrainer::ComputeWordError ( STRING truth_str,
STRING ocr_str 
)
protected

Definition at line 1219 of file lstmtrainer.cpp.

1219  {
1220  using StrMap = std::unordered_map<std::string, int, std::hash<std::string>>;
1221  GenericVector<STRING> truth_words, ocr_words;
1222  truth_str->split(' ', &truth_words);
1223  if (truth_words.empty()) return 0.0;
1224  ocr_str->split(' ', &ocr_words);
1225  StrMap word_counts;
1226  for (int i = 0; i < truth_words.size(); ++i) {
1227  std::string truth_word(truth_words[i].string());
1228  auto it = word_counts.find(truth_word);
1229  if (it == word_counts.end())
1230  word_counts.insert(std::make_pair(truth_word, 1));
1231  else
1232  ++it->second;
1233  }
1234  for (int i = 0; i < ocr_words.size(); ++i) {
1235  std::string ocr_word(ocr_words[i].string());
1236  auto it = word_counts.find(ocr_word);
1237  if (it == word_counts.end())
1238  word_counts.insert(std::make_pair(ocr_word, -1));
1239  else
1240  --it->second;
1241  }
1242  int word_recall_errs = 0;
1243  for (StrMap::const_iterator it = word_counts.begin(); it != word_counts.end();
1244  ++it) {
1245  if (it->second > 0) word_recall_errs += it->second;
1246  }
1247  return static_cast<double>(word_recall_errs) / truth_words.size();
1248 }
bool empty() const
Definition: genericvector.h:91
void split(char c, GenericVector< STRING > *splited)
Definition: strngs.cpp:282
int size() const
Definition: genericvector.h:72

◆ CurrentTrainingStage()

int tesseract::LSTMTrainer::CurrentTrainingStage ( ) const
inline

Definition at line 211 of file lstmtrainer.h.

211 { return training_stage_; }

◆ DebugLSTMTraining()

bool tesseract::LSTMTrainer::DebugLSTMTraining ( const NetworkIO inputs,
const ImageData trainingdata,
const NetworkIO fwd_outputs,
const GenericVector< int > &  truth_labels,
const NetworkIO outputs 
)
protected

Definition at line 1029 of file lstmtrainer.cpp.

1033  {
1034  const STRING& truth_text = DecodeLabels(truth_labels);
1035  if (truth_text.string() == nullptr || truth_text.length() <= 0) {
1036  tprintf("Empty truth string at decode time!\n");
1037  return false;
1038  }
1039  if (debug_interval_ != 0) {
1040  // Get class labels, xcoords and string.
1041  GenericVector<int> labels;
1042  GenericVector<int> xcoords;
1043  LabelsFromOutputs(outputs, &labels, &xcoords);
1044  STRING text = DecodeLabels(labels);
1045  tprintf("Iteration %d: GROUND TRUTH : %s\n",
1046  training_iteration(), truth_text.string());
1047  if (truth_text != text) {
1048  tprintf("Iteration %d: ALIGNED TRUTH : %s\n",
1049  training_iteration(), text.string());
1050  }
1051  if (debug_interval_ > 0 && training_iteration() % debug_interval_ == 0) {
1052  tprintf("TRAINING activation path for truth string %s\n",
1053  truth_text.string());
1054  DebugActivationPath(outputs, labels, xcoords);
1055  DisplayForward(inputs, labels, xcoords, "LSTMTraining", &align_win_);
1056  if (OutputLossType() == LT_CTC) {
1057  DisplayTargets(fwd_outputs, "CTC Outputs", &ctc_win_);
1058  DisplayTargets(outputs, "CTC Targets", &target_win_);
1059  }
1060  }
1061  }
1062  return true;
1063 }
LossType OutputLossType() const
DLLSYM void tprintf(const char *format,...)
Definition: tprintf.cpp:35
ScrollView * ctc_win_
Definition: lstmtrainer.h:401
ScrollView * target_win_
Definition: lstmtrainer.h:399
const char * string() const
Definition: strngs.cpp:194
void DisplayForward(const NetworkIO &inputs, const GenericVector< int > &labels, const GenericVector< int > &label_coords, const char *window_name, ScrollView **window)
void DisplayTargets(const NetworkIO &targets, const char *window_name, ScrollView **window)
int32_t length() const
Definition: strngs.cpp:189
STRING DecodeLabels(const GenericVector< int > &labels)
void DebugActivationPath(const NetworkIO &outputs, const GenericVector< int > &labels, const GenericVector< int > &xcoords)
Definition: strngs.h:45
void LabelsFromOutputs(const NetworkIO &outputs, GenericVector< int > *labels, GenericVector< int > *xcoords)
ScrollView * align_win_
Definition: lstmtrainer.h:397

◆ DebugNetwork()

void tesseract::LSTMTrainer::DebugNetwork ( )

Definition at line 291 of file lstmtrainer.cpp.

291  {
293 }
virtual void DebugWeights()=0

◆ DeSerialize()

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

Definition at line 466 of file lstmtrainer.cpp.

466  {
467  if (!LSTMRecognizer::DeSerialize(mgr, fp)) return false;
468  if (!fp->DeSerialize(&learning_iteration_)) {
469  // Special case. If we successfully decoded the recognizer, but fail here
470  // then it means we were just given a recognizer, so issue a warning and
471  // allow it.
472  tprintf("Warning: LSTMTrainer deserialized an LSTMRecognizer!\n");
475  return true;
476  }
477  if (!fp->DeSerialize(&prev_sample_iteration_)) return false;
478  if (!fp->DeSerialize(&perfect_delay_)) return false;
479  if (!fp->DeSerialize(&last_perfect_training_iteration_)) return false;
480  for (auto & error_buffer : error_buffers_) {
481  if (!error_buffer.DeSerialize(fp)) return false;
482  }
483  if (!fp->DeSerialize(&error_rates_[0], countof(error_rates_))) return false;
484  if (!fp->DeSerialize(&training_stage_)) return false;
485  uint8_t amount;
486  if (!fp->DeSerialize(&amount)) return false;
487  if (amount == LIGHT) return true; // Don't read the rest.
488  if (!fp->DeSerialize(&best_error_rate_)) return false;
489  if (!fp->DeSerialize(&best_error_rates_[0], countof(best_error_rates_))) return false;
490  if (!fp->DeSerialize(&best_iteration_)) return false;
491  if (!fp->DeSerialize(&worst_error_rate_)) return false;
492  if (!fp->DeSerialize(&worst_error_rates_[0], countof(worst_error_rates_))) return false;
493  if (!fp->DeSerialize(&worst_iteration_)) return false;
494  if (!fp->DeSerialize(&stall_iteration_)) return false;
495  if (!best_model_data_.DeSerialize(fp)) return false;
496  if (!worst_model_data_.DeSerialize(fp)) return false;
497  if (amount != NO_BEST_TRAINER && !best_trainer_.DeSerialize(fp)) return false;
498  GenericVector<char> sub_data;
499  if (!sub_data.DeSerialize(fp)) return false;
500  delete sub_trainer_;
501  if (sub_data.empty()) {
502  sub_trainer_ = nullptr;
503  } else {
504  sub_trainer_ = new LSTMTrainer();
505  if (!ReadTrainingDump(sub_data, sub_trainer_)) return false;
506  }
507  if (!best_error_history_.DeSerialize(fp)) return false;
508  if (!best_error_iterations_.DeSerialize(fp)) return false;
509  return fp->DeSerialize(&improvement_steps_);
510 }
bool empty() const
Definition: genericvector.h:91
DLLSYM void tprintf(const char *format,...)
Definition: tprintf.cpp:35
bool ReadTrainingDump(const GenericVector< char > &data, LSTMTrainer *trainer) const
Definition: lstmtrainer.h:291
LSTMTrainer * sub_trainer_
Definition: lstmtrainer.h:450
GenericVector< int > best_error_iterations_
Definition: lstmtrainer.h:458
GenericVector< char > worst_model_data_
Definition: lstmtrainer.h:445
double best_error_rates_[ET_COUNT]
Definition: lstmtrainer.h:432
GenericVector< double > best_error_history_
Definition: lstmtrainer.h:457
double error_rates_[ET_COUNT]
Definition: lstmtrainer.h:481
constexpr size_t countof(T const (&)[N]) noexcept
Definition: serialis.h:43
bool DeSerialize(const TessdataManager *mgr, TFile *fp)
bool DeSerialize(bool swap, FILE *fp)
double worst_error_rates_[ET_COUNT]
Definition: lstmtrainer.h:438
GenericVector< char > best_model_data_
Definition: lstmtrainer.h:444
GenericVector< char > best_trainer_
Definition: lstmtrainer.h:447
virtual void SetEnableTraining(TrainingState state)
Definition: network.cpp:110
GenericVector< double > error_buffers_[ET_COUNT]
Definition: lstmtrainer.h:479

◆ DisplayTargets()

void tesseract::LSTMTrainer::DisplayTargets ( const NetworkIO targets,
const char *  window_name,
ScrollView **  window 
)
protected

Definition at line 1066 of file lstmtrainer.cpp.

1067  {
1068 #ifndef GRAPHICS_DISABLED // do nothing if there's no graphics.
1069  int width = targets.Width();
1070  int num_features = targets.NumFeatures();
1071  Network::ClearWindow(true, window_name, width * kTargetXScale, kTargetYScale,
1072  window);
1073  for (int c = 0; c < num_features; ++c) {
1074  int color = c % (ScrollView::GREEN_YELLOW - 1) + 2;
1075  (*window)->Pen(static_cast<ScrollView::Color>(color));
1076  int start_t = -1;
1077  for (int t = 0; t < width; ++t) {
1078  double target = targets.f(t)[c];
1079  target *= kTargetYScale;
1080  if (target >= 1) {
1081  if (start_t < 0) {
1082  (*window)->SetCursor(t - 1, 0);
1083  start_t = t;
1084  }
1085  (*window)->DrawTo(t, target);
1086  } else if (start_t >= 0) {
1087  (*window)->DrawTo(t, 0);
1088  (*window)->DrawTo(start_t - 1, 0);
1089  start_t = -1;
1090  }
1091  }
1092  if (start_t >= 0) {
1093  (*window)->DrawTo(width, 0);
1094  (*window)->DrawTo(start_t - 1, 0);
1095  }
1096  }
1097  (*window)->Update();
1098 #endif // GRAPHICS_DISABLED
1099 }
const int kTargetYScale
Definition: lstmtrainer.cpp:72
static void ClearWindow(bool tess_coords, const char *window_name, int width, int height, ScrollView **window)
Definition: network.cpp:312
const int kTargetXScale
Definition: lstmtrainer.cpp:71

◆ DumpFilename()

STRING tesseract::LSTMTrainer::DumpFilename ( ) const

Definition at line 940 of file lstmtrainer.cpp.

940  {
941  STRING filename;
943  filename.add_str_int("_", best_iteration_);
944  filename += ".checkpoint";
945  return filename;
946 }
const char * string() const
Definition: strngs.cpp:194
void add_str_int(const char *str, int number)
Definition: strngs.cpp:377
Definition: strngs.h:45
void add_str_double(const char *str, double number)
Definition: strngs.cpp:387

◆ EmptyConstructor()

void tesseract::LSTMTrainer::EmptyConstructor ( )
protected

Definition at line 1014 of file lstmtrainer.cpp.

1014  {
1015  align_win_ = nullptr;
1016  target_win_ = nullptr;
1017  ctc_win_ = nullptr;
1018  recon_win_ = nullptr;
1020  training_stage_ = 0;
1022  InitIterations();
1023 }
ScrollView * ctc_win_
Definition: lstmtrainer.h:401
ScrollView * target_win_
Definition: lstmtrainer.h:399
ScrollView * recon_win_
Definition: lstmtrainer.h:403
ScrollView * align_win_
Definition: lstmtrainer.h:397

◆ EncodeString() [1/2]

bool tesseract::LSTMTrainer::EncodeString ( const STRING str,
GenericVector< int > *  labels 
) const
inline

Definition at line 246 of file lstmtrainer.h.

246  {
247  return EncodeString(str, GetUnicharset(), IsRecoding() ? &recoder_ : nullptr,
248  SimpleTextOutput(), null_char_, labels);
249  }
const UNICHARSET & GetUnicharset() const
bool EncodeString(const STRING &str, GenericVector< int > *labels) const
Definition: lstmtrainer.h:246

◆ EncodeString() [2/2]

bool tesseract::LSTMTrainer::EncodeString ( const STRING str,
const UNICHARSET unicharset,
const UnicharCompress recoder,
bool  simple_text,
int  null_char,
GenericVector< int > *  labels 
)
static

Definition at line 716 of file lstmtrainer.cpp.

718  {
719  if (str.string() == nullptr || str.length() <= 0) {
720  tprintf("Empty truth string!\n");
721  return false;
722  }
723  int err_index;
724  GenericVector<int> internal_labels;
725  labels->truncate(0);
726  if (!simple_text) labels->push_back(null_char);
727  std::string cleaned = unicharset.CleanupString(str.string());
728  if (unicharset.encode_string(cleaned.c_str(), true, &internal_labels, nullptr,
729  &err_index)) {
730  bool success = true;
731  for (int i = 0; i < internal_labels.size(); ++i) {
732  if (recoder != nullptr) {
733  // Re-encode labels via recoder.
734  RecodedCharID code;
735  int len = recoder->EncodeUnichar(internal_labels[i], &code);
736  if (len > 0) {
737  for (int j = 0; j < len; ++j) {
738  labels->push_back(code(j));
739  if (!simple_text) labels->push_back(null_char);
740  }
741  } else {
742  success = false;
743  err_index = 0;
744  break;
745  }
746  } else {
747  labels->push_back(internal_labels[i]);
748  if (!simple_text) labels->push_back(null_char);
749  }
750  }
751  if (success) return true;
752  }
753  tprintf("Encoding of string failed! Failure bytes:");
754  while (err_index < cleaned.size()) {
755  tprintf(" %x", cleaned[err_index++]);
756  }
757  tprintf("\n");
758  return false;
759 }
DLLSYM void tprintf(const char *format,...)
Definition: tprintf.cpp:35
const char * string() const
Definition: strngs.cpp:194
void truncate(int size)
int32_t length() const
Definition: strngs.cpp:189
int push_back(T object)
static std::string CleanupString(const char *utf8_str)
Definition: unicharset.h:246
int size() const
Definition: genericvector.h:72
bool encode_string(const char *str, bool give_up_on_failure, GenericVector< UNICHAR_ID > *encoding, GenericVector< char > *lengths, int *encoded_length) const
Definition: unicharset.cpp:259

◆ error_rates()

const double* tesseract::LSTMTrainer::error_rates ( ) const
inline

Definition at line 140 of file lstmtrainer.h.

140  {
141  return error_rates_;
142  }
double error_rates_[ET_COUNT]
Definition: lstmtrainer.h:481

◆ FillErrorBuffer()

void tesseract::LSTMTrainer::FillErrorBuffer ( double  new_error,
ErrorTypes  type 
)

Definition at line 949 of file lstmtrainer.cpp.

949  {
950  for (int i = 0; i < kRollingBufferSize_; ++i)
951  error_buffers_[type][i] = new_error;
952  error_rates_[type] = 100.0 * new_error;
953 }
double error_rates_[ET_COUNT]
Definition: lstmtrainer.h:481
static const int kRollingBufferSize_
Definition: lstmtrainer.h:478
GenericVector< double > error_buffers_[ET_COUNT]
Definition: lstmtrainer.h:479

◆ GridSearchDictParams()

Trainability tesseract::LSTMTrainer::GridSearchDictParams ( const ImageData trainingdata,
int  iteration,
double  min_dict_ratio,
double  dict_ratio_step,
double  max_dict_ratio,
double  min_cert_offset,
double  cert_offset_step,
double  max_cert_offset,
STRING results 
)

Definition at line 241 of file lstmtrainer.cpp.

244  {
245  sample_iteration_ = iteration;
246  NetworkIO fwd_outputs, targets;
247  Trainability result =
248  PrepareForBackward(trainingdata, &fwd_outputs, &targets);
249  if (result == UNENCODABLE || result == HI_PRECISION_ERR || dict_ == nullptr)
250  return result;
251 
252  // Encode/decode the truth to get the normalization.
253  GenericVector<int> truth_labels, ocr_labels, xcoords;
254  ASSERT_HOST(EncodeString(trainingdata->transcription(), &truth_labels));
255  // NO-dict error.
256  RecodeBeamSearch base_search(recoder_, null_char_, SimpleTextOutput(), nullptr);
257  base_search.Decode(fwd_outputs, 1.0, 0.0, RecodeBeamSearch::kMinCertainty,
258  nullptr);
259  base_search.ExtractBestPathAsLabels(&ocr_labels, &xcoords);
260  STRING truth_text = DecodeLabels(truth_labels);
261  STRING ocr_text = DecodeLabels(ocr_labels);
262  double baseline_error = ComputeWordError(&truth_text, &ocr_text);
263  results->add_str_double("0,0=", baseline_error);
264 
265  RecodeBeamSearch search(recoder_, null_char_, SimpleTextOutput(), dict_);
266  for (double r = min_dict_ratio; r < max_dict_ratio; r += dict_ratio_step) {
267  for (double c = min_cert_offset; c < max_cert_offset;
268  c += cert_offset_step) {
269  search.Decode(fwd_outputs, r, c, RecodeBeamSearch::kMinCertainty, nullptr);
270  search.ExtractBestPathAsLabels(&ocr_labels, &xcoords);
271  truth_text = DecodeLabels(truth_labels);
272  ocr_text = DecodeLabels(ocr_labels);
273  // This is destructive on both strings.
274  double word_error = ComputeWordError(&truth_text, &ocr_text);
275  if ((r == min_dict_ratio && c == min_cert_offset) ||
276  !std::isfinite(word_error)) {
277  STRING t = DecodeLabels(truth_labels);
278  STRING o = DecodeLabels(ocr_labels);
279  tprintf("r=%g, c=%g, truth=%s, ocr=%s, wderr=%g, truth[0]=%d\n", r, c,
280  t.string(), o.string(), word_error, truth_labels[0]);
281  }
282  results->add_str_double(" ", r);
283  results->add_str_double(",", c);
284  results->add_str_double("=", word_error);
285  }
286  }
287  return result;
288 }
LIST search(LIST list, void *key, int_compare is_equal)
Definition: oldlist.cpp:258
DLLSYM void tprintf(const char *format,...)
Definition: tprintf.cpp:35
Trainability PrepareForBackward(const ImageData *trainingdata, NetworkIO *fwd_outputs, NetworkIO *targets)
static constexpr float kMinCertainty
Definition: recodebeam.h:222
const char * string() const
Definition: strngs.cpp:194
STRING DecodeLabels(const GenericVector< int > &labels)
bool EncodeString(const STRING &str, GenericVector< int > *labels) const
Definition: lstmtrainer.h:246
Definition: strngs.h:45
double ComputeWordError(STRING *truth_str, STRING *ocr_str)
void add_str_double(const char *str, double number)
Definition: strngs.cpp:387
#define ASSERT_HOST(x)
Definition: errcode.h:88

◆ improvement_steps()

int32_t tesseract::LSTMTrainer::improvement_steps ( ) const
inline

Definition at line 150 of file lstmtrainer.h.

150 { return improvement_steps_; }

◆ InitCharSet() [1/3]

void tesseract::LSTMTrainer::InitCharSet ( const std::string &  traineddata_path)
inline

Definition at line 109 of file lstmtrainer.h.

109  {
110  ASSERT_HOST(mgr_.Init(traineddata_path.c_str()));
111  InitCharSet();
112  }
bool Init(const char *data_file_name)
TessdataManager mgr_
Definition: lstmtrainer.h:483
#define ASSERT_HOST(x)
Definition: errcode.h:88

◆ InitCharSet() [2/3]

void tesseract::LSTMTrainer::InitCharSet ( const TessdataManager mgr)
inline

Definition at line 113 of file lstmtrainer.h.

113  {
114  mgr_ = mgr;
115  InitCharSet();
116  }
TessdataManager mgr_
Definition: lstmtrainer.h:483

◆ InitCharSet() [3/3]

void tesseract::LSTMTrainer::InitCharSet ( )
protected

Definition at line 992 of file lstmtrainer.cpp.

992  {
995  // Initialize the unicharset and recoder.
996  if (!LoadCharsets(&mgr_)) {
997  ASSERT_HOST(
998  "Must provide a traineddata containing lstm_unicharset and"
999  " lstm_recoder!\n" != nullptr);
1000  }
1001  SetNullChar();
1002 }
bool LoadCharsets(const TessdataManager *mgr)
TessdataManager mgr_
Definition: lstmtrainer.h:483
#define ASSERT_HOST(x)
Definition: errcode.h:88

◆ InitIterations()

void tesseract::LSTMTrainer::InitIterations ( )

Definition at line 216 of file lstmtrainer.cpp.

216  {
217  sample_iteration_ = 0;
221  best_error_rate_ = 100.0;
222  best_iteration_ = 0;
223  worst_error_rate_ = 0.0;
224  worst_iteration_ = 0;
227  perfect_delay_ = 0;
229  for (int i = 0; i < ET_COUNT; ++i) {
230  best_error_rates_[i] = 100.0;
231  worst_error_rates_[i] = 0.0;
233  error_rates_[i] = 100.0;
234  }
236 }
void init_to_size(int size, const T &t)
const int kMinStartedErrorRate
Definition: lstmtrainer.cpp:61
double best_error_rates_[ET_COUNT]
Definition: lstmtrainer.h:432
double error_rates_[ET_COUNT]
Definition: lstmtrainer.h:481
double worst_error_rates_[ET_COUNT]
Definition: lstmtrainer.h:438
static const int kRollingBufferSize_
Definition: lstmtrainer.h:478
const int kMinStallIterations
Definition: lstmtrainer.cpp:48
float error_rate_of_last_saved_best_
Definition: lstmtrainer.h:452
GenericVector< double > error_buffers_[ET_COUNT]
Definition: lstmtrainer.h:479

◆ InitNetwork()

bool tesseract::LSTMTrainer::InitNetwork ( const STRING network_spec,
int  append_index,
int  net_flags,
float  weight_range,
float  learning_rate,
float  momentum,
float  adam_beta 
)

Definition at line 172 of file lstmtrainer.cpp.

175  {
176  mgr_.SetVersionString(mgr_.VersionString() + ":" + network_spec.string());
177  adam_beta_ = adam_beta;
179  momentum_ = momentum;
180  SetNullChar();
181  if (!NetworkBuilder::InitNetwork(recoder_.code_range(), network_spec,
182  append_index, net_flags, weight_range,
183  &randomizer_, &network_)) {
184  return false;
185  }
186  network_str_ += network_spec;
187  tprintf("Built network:%s from request %s\n",
188  network_->spec().string(), network_spec.string());
189  tprintf(
190  "Training parameters:\n Debug interval = %d,"
191  " weights = %g, learning rate = %g, momentum=%g\n",
192  debug_interval_, weight_range, learning_rate_, momentum_);
193  tprintf("null char=%d\n", null_char_);
194  return true;
195 }
DLLSYM void tprintf(const char *format,...)
Definition: tprintf.cpp:35
std::string VersionString() const
virtual STRING spec() const
Definition: network.h:141
const char * string() const
Definition: strngs.cpp:194
static bool InitNetwork(int num_outputs, STRING network_spec, int append_index, int net_flags, float weight_range, TRand *randomizer, Network **network)
TessdataManager mgr_
Definition: lstmtrainer.h:483
void SetVersionString(const std::string &v_str)
double learning_rate() const

◆ InitTensorFlowNetwork()

int tesseract::LSTMTrainer::InitTensorFlowNetwork ( const std::string &  tf_proto)

◆ LastSingleError()

double tesseract::LSTMTrainer::LastSingleError ( ErrorTypes  type) const
inline

Definition at line 160 of file lstmtrainer.h.

160  {
161  return error_buffers_[type]
164  }
static const int kRollingBufferSize_
Definition: lstmtrainer.h:478
GenericVector< double > error_buffers_[ET_COUNT]
Definition: lstmtrainer.h:479

◆ learning_iteration()

int tesseract::LSTMTrainer::learning_iteration ( ) const
inline

Definition at line 149 of file lstmtrainer.h.

149 { return learning_iteration_; }

◆ LoadAllTrainingData()

bool tesseract::LSTMTrainer::LoadAllTrainingData ( const GenericVector< STRING > &  filenames,
CachingStrategy  cache_strategy,
bool  randomly_rotate 
)

Definition at line 298 of file lstmtrainer.cpp.

300  {
301  randomly_rotate_ = randomly_rotate;
303  return training_data_.LoadDocuments(filenames, cache_strategy, file_reader_);
304 }
bool LoadDocuments(const GenericVector< STRING > &filenames, CachingStrategy cache_strategy, FileReader reader)
Definition: imagedata.cpp:580
DocumentCache training_data_
Definition: lstmtrainer.h:414

◆ LogIterations()

void tesseract::LSTMTrainer::LogIterations ( const char *  intro_str,
STRING log_msg 
) const

Definition at line 410 of file lstmtrainer.cpp.

410  {
411  *log_msg += intro_str;
412  log_msg->add_str_int(" iteration ", learning_iteration());
413  log_msg->add_str_int("/", training_iteration());
414  log_msg->add_str_int("/", sample_iteration());
415 }
int learning_iteration() const
Definition: lstmtrainer.h:149
void add_str_int(const char *str, int number)
Definition: strngs.cpp:377

◆ MaintainCheckpoints()

bool tesseract::LSTMTrainer::MaintainCheckpoints ( TestCallback  tester,
STRING log_msg 
)

Definition at line 310 of file lstmtrainer.cpp.

310  {
311  PrepareLogMsg(log_msg);
312  double error_rate = CharError();
313  int iteration = learning_iteration();
314  if (iteration >= stall_iteration_ &&
315  error_rate > best_error_rate_ * (1.0 + kSubTrainerMarginFraction) &&
317  // It hasn't got any better in a long while, and is a margin worse than the
318  // best, so go back to the best model and try a different learning rate.
319  StartSubtrainer(log_msg);
320  }
321  SubTrainerResult sub_trainer_result = STR_NONE;
322  if (sub_trainer_ != nullptr) {
323  sub_trainer_result = UpdateSubtrainer(log_msg);
324  if (sub_trainer_result == STR_REPLACED) {
325  // Reset the inputs, as we have overwritten *this.
326  error_rate = CharError();
327  iteration = learning_iteration();
328  PrepareLogMsg(log_msg);
329  }
330  }
331  bool result = true; // Something interesting happened.
332  GenericVector<char> rec_model_data;
333  if (error_rate < best_error_rate_) {
334  SaveRecognitionDump(&rec_model_data);
335  log_msg->add_str_double(" New best char error = ", error_rate);
336  *log_msg += UpdateErrorGraph(iteration, error_rate, rec_model_data, tester);
337  // If sub_trainer_ is not nullptr, either *this beat it to a new best, or it
338  // just overwrote *this. In either case, we have finished with it.
339  delete sub_trainer_;
340  sub_trainer_ = nullptr;
343  log_msg->add_str_int(" Transitioned to stage ", CurrentTrainingStage());
344  }
347  STRING best_model_name = DumpFilename();
348  if (!(*file_writer_)(best_trainer_, best_model_name.c_str())) {
349  *log_msg += " failed to write best model:";
350  } else {
351  *log_msg += " wrote best model:";
353  }
354  *log_msg += best_model_name;
355  }
356  } else if (error_rate > worst_error_rate_) {
357  SaveRecognitionDump(&rec_model_data);
358  log_msg->add_str_double(" New worst char error = ", error_rate);
359  *log_msg += UpdateErrorGraph(iteration, error_rate, rec_model_data, tester);
362  // Error rate has ballooned. Go back to the best model.
363  *log_msg += "\nDivergence! ";
364  // Copy best_trainer_ before reading it, as it will get overwritten.
365  GenericVector<char> revert_data(best_trainer_);
366  if (checkpoint_reader_->Run(revert_data, this)) {
367  LogIterations("Reverted to", log_msg);
368  ReduceLearningRates(this, log_msg);
369  } else {
370  LogIterations("Failed to Revert at", log_msg);
371  }
372  // If it fails again, we will wait twice as long before reverting again.
373  stall_iteration_ = iteration + 2 * (iteration - learning_iteration());
374  // Re-save the best trainer with the new learning rates and stall
375  // iteration.
377  }
378  } else {
379  // Something interesting happened only if the sub_trainer_ was trained.
380  result = sub_trainer_result != STR_NONE;
381  }
382  if (checkpoint_writer_ != nullptr && file_writer_ != nullptr &&
383  checkpoint_name_.length() > 0) {
384  // Write a current checkpoint.
385  GenericVector<char> checkpoint;
386  if (!checkpoint_writer_->Run(FULL, this, &checkpoint) ||
387  !(*file_writer_)(checkpoint, checkpoint_name_.c_str())) {
388  *log_msg += " failed to write checkpoint.";
389  } else {
390  *log_msg += " wrote checkpoint.";
391  }
392  }
393  *log_msg += "\n";
394  return result;
395 }
bool empty() const
Definition: genericvector.h:91
const double kMinDivergenceRate
Definition: lstmtrainer.cpp:46
void StartSubtrainer(STRING *log_msg)
bool TransitionTrainingStage(float error_threshold)
LSTMTrainer * sub_trainer_
Definition: lstmtrainer.h:450
const int kMinStartedErrorRate
Definition: lstmtrainer.cpp:61
CheckPointReader checkpoint_reader_
Definition: lstmtrainer.h:424
const char * c_str() const
Definition: strngs.cpp:205
STRING UpdateErrorGraph(int iteration, double error_rate, const GenericVector< char > &model_data, TestCallback tester)
virtual R Run(A1, A2)=0
const double kSubTrainerMarginFraction
Definition: lstmtrainer.cpp:51
SubTrainerResult UpdateSubtrainer(STRING *log_msg)
double CharError() const
Definition: lstmtrainer.h:139
int32_t length() const
Definition: strngs.cpp:189
const double kStageTransitionThreshold
Definition: lstmtrainer.cpp:63
int learning_iteration() const
Definition: lstmtrainer.h:149
void SaveRecognitionDump(GenericVector< char > *data) const
CheckPointWriter checkpoint_writer_
Definition: lstmtrainer.h:425
void add_str_int(const char *str, int number)
Definition: strngs.cpp:377
const int kMinStallIterations
Definition: lstmtrainer.cpp:48
void PrepareLogMsg(STRING *log_msg) const
float error_rate_of_last_saved_best_
Definition: lstmtrainer.h:452
Definition: strngs.h:45
void LogIterations(const char *intro_str, STRING *log_msg) const
STRING DumpFilename() const
const double kBestCheckpointFraction
Definition: lstmtrainer.cpp:69
void ReduceLearningRates(LSTMTrainer *samples_trainer, STRING *log_msg)
int CurrentTrainingStage() const
Definition: lstmtrainer.h:211
GenericVector< char > best_trainer_
Definition: lstmtrainer.h:447
virtual R Run(A1, A2, A3)=0
void add_str_double(const char *str, double number)
Definition: strngs.cpp:387

◆ MaintainCheckpointsSpecific()

bool tesseract::LSTMTrainer::MaintainCheckpointsSpecific ( int  iteration,
const GenericVector< char > *  train_model,
const GenericVector< char > *  rec_model,
TestCallback  tester,
STRING log_msg 
)

◆ MapRecoder()

std::vector< int > tesseract::LSTMTrainer::MapRecoder ( const UNICHARSET old_chset,
const UnicharCompress old_recoder 
) const

Definition at line 957 of file lstmtrainer.cpp.

958  {
959  int num_new_codes = recoder_.code_range();
960  int num_new_unichars = GetUnicharset().size();
961  std::vector<int> code_map(num_new_codes, -1);
962  for (int c = 0; c < num_new_codes; ++c) {
963  int old_code = -1;
964  // Find all new unichar_ids that recode to something that includes c.
965  // The <= is to include the null char, which may be beyond the unicharset.
966  for (int uid = 0; uid <= num_new_unichars; ++uid) {
967  RecodedCharID codes;
968  int length = recoder_.EncodeUnichar(uid, &codes);
969  int code_index = 0;
970  while (code_index < length && codes(code_index) != c) ++code_index;
971  if (code_index == length) continue;
972  // The old unicharset must have the same unichar.
973  int old_uid =
974  uid < num_new_unichars
975  ? old_chset.unichar_to_id(GetUnicharset().id_to_unichar(uid))
976  : old_chset.size() - 1;
977  if (old_uid == INVALID_UNICHAR_ID) continue;
978  // The encoding of old_uid at the same code_index is the old code.
979  RecodedCharID old_codes;
980  if (code_index < old_recoder.EncodeUnichar(old_uid, &old_codes)) {
981  old_code = old_codes(code_index);
982  break;
983  }
984  }
985  code_map[c] = old_code;
986  }
987  return code_map;
988 }
int size() const
Definition: unicharset.h:341
int EncodeUnichar(int unichar_id, RecodedCharID *code) const
const UNICHARSET & GetUnicharset() const
UNICHAR_ID unichar_to_id(const char *const unichar_repr) const
Definition: unicharset.cpp:210

◆ mutable_training_data()

DocumentCache* tesseract::LSTMTrainer::mutable_training_data ( )
inline

Definition at line 168 of file lstmtrainer.h.

168 { return &training_data_; }
DocumentCache training_data_
Definition: lstmtrainer.h:414

◆ NewSingleError()

double tesseract::LSTMTrainer::NewSingleError ( ErrorTypes  type) const
inline

Definition at line 154 of file lstmtrainer.h.

154  {
156  }
static const int kRollingBufferSize_
Definition: lstmtrainer.h:478
GenericVector< double > error_buffers_[ET_COUNT]
Definition: lstmtrainer.h:479

◆ PrepareForBackward()

Trainability tesseract::LSTMTrainer::PrepareForBackward ( const ImageData trainingdata,
NetworkIO fwd_outputs,
NetworkIO targets 
)

Definition at line 796 of file lstmtrainer.cpp.

798  {
799  if (trainingdata == nullptr) {
800  tprintf("Null trainingdata.\n");
801  return UNENCODABLE;
802  }
803  // Ensure repeatability of random elements even across checkpoints.
804  bool debug = debug_interval_ > 0 &&
806  GenericVector<int> truth_labels;
807  if (!EncodeString(trainingdata->transcription(), &truth_labels)) {
808  tprintf("Can't encode transcription: '%s' in language '%s'\n",
809  trainingdata->transcription().string(),
810  trainingdata->language().string());
811  return UNENCODABLE;
812  }
813  bool upside_down = false;
814  if (randomly_rotate_) {
815  // This ensures consistent training results.
816  SetRandomSeed();
817  upside_down = randomizer_.SignedRand(1.0) > 0.0;
818  if (upside_down) {
819  // Modify the truth labels to match the rotation:
820  // Apart from space and null, increment the label. This is changes the
821  // script-id to the same script-id but upside-down.
822  // The labels need to be reversed in order, as the first is now the last.
823  for (int c = 0; c < truth_labels.size(); ++c) {
824  if (truth_labels[c] != UNICHAR_SPACE && truth_labels[c] != null_char_)
825  ++truth_labels[c];
826  }
827  truth_labels.reverse();
828  }
829  }
830  int w = 0;
831  while (w < truth_labels.size() &&
832  (truth_labels[w] == UNICHAR_SPACE || truth_labels[w] == null_char_))
833  ++w;
834  if (w == truth_labels.size()) {
835  tprintf("Blank transcription: %s\n",
836  trainingdata->transcription().string());
837  return UNENCODABLE;
838  }
839  float image_scale;
840  NetworkIO inputs;
841  bool invert = trainingdata->boxes().empty();
842  if (!RecognizeLine(*trainingdata, invert, debug, invert, upside_down,
843  &image_scale, &inputs, fwd_outputs)) {
844  tprintf("Image not trainable\n");
845  return UNENCODABLE;
846  }
847  targets->Resize(*fwd_outputs, network_->NumOutputs());
848  LossType loss_type = OutputLossType();
849  if (loss_type == LT_SOFTMAX) {
850  if (!ComputeTextTargets(*fwd_outputs, truth_labels, targets)) {
851  tprintf("Compute simple targets failed!\n");
852  return UNENCODABLE;
853  }
854  } else if (loss_type == LT_CTC) {
855  if (!ComputeCTCTargets(truth_labels, fwd_outputs, targets)) {
856  tprintf("Compute CTC targets failed!\n");
857  return UNENCODABLE;
858  }
859  } else {
860  tprintf("Logistic outputs not implemented yet!\n");
861  return UNENCODABLE;
862  }
863  GenericVector<int> ocr_labels;
864  GenericVector<int> xcoords;
865  LabelsFromOutputs(*fwd_outputs, &ocr_labels, &xcoords);
866  // CTC does not produce correct target labels to begin with.
867  if (loss_type != LT_CTC) {
868  LabelsFromOutputs(*targets, &truth_labels, &xcoords);
869  }
870  if (!DebugLSTMTraining(inputs, *trainingdata, *fwd_outputs, truth_labels,
871  *targets)) {
872  tprintf("Input width was %d\n", inputs.Width());
873  return UNENCODABLE;
874  }
875  STRING ocr_text = DecodeLabels(ocr_labels);
876  STRING truth_text = DecodeLabels(truth_labels);
877  targets->SubtractAllFromFloat(*fwd_outputs);
878  if (debug_interval_ != 0) {
879  if (truth_text != ocr_text) {
880  tprintf("Iteration %d: BEST OCR TEXT : %s\n",
881  training_iteration(), ocr_text.string());
882  }
883  }
884  double char_error = ComputeCharError(truth_labels, ocr_labels);
885  double word_error = ComputeWordError(&truth_text, &ocr_text);
886  double delta_error = ComputeErrorRates(*targets, char_error, word_error);
887  if (debug_interval_ != 0) {
888  tprintf("File %s line %d %s:\n", trainingdata->imagefilename().string(),
889  trainingdata->page_number(), delta_error == 0.0 ? "(Perfect)" : "");
890  }
891  if (delta_error == 0.0) return PERFECT;
892  if (targets->AnySuspiciousTruth(kHighConfidence)) return HI_PRECISION_ERR;
893  return TRAINABLE;
894 }
LossType OutputLossType() const
DLLSYM void tprintf(const char *format,...)
Definition: tprintf.cpp:35
bool DebugLSTMTraining(const NetworkIO &inputs, const ImageData &trainingdata, const NetworkIO &fwd_outputs, const GenericVector< int > &truth_labels, const NetworkIO &outputs)
double ComputeCharError(const GenericVector< int > &truth_str, const GenericVector< int > &ocr_str)
double ComputeErrorRates(const NetworkIO &deltas, double char_error, double word_error)
const char * string() const
Definition: strngs.cpp:194
bool ComputeTextTargets(const NetworkIO &outputs, const GenericVector< int > &truth_labels, NetworkIO *targets)
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)
STRING DecodeLabels(const GenericVector< int > &labels)
bool EncodeString(const STRING &str, GenericVector< int > *labels) const
Definition: lstmtrainer.h:246
bool ComputeCTCTargets(const GenericVector< int > &truth_labels, NetworkIO *outputs, NetworkIO *targets)
Definition: strngs.h:45
double SignedRand(double range)
Definition: helpers.h:55
void LabelsFromOutputs(const NetworkIO &outputs, GenericVector< int > *labels, GenericVector< int > *xcoords)
double ComputeWordError(STRING *truth_str, STRING *ocr_str)
const double kHighConfidence
Definition: lstmtrainer.cpp:65
int size() const
Definition: genericvector.h:72
int NumOutputs() const
Definition: network.h:123

◆ PrepareLogMsg()

void tesseract::LSTMTrainer::PrepareLogMsg ( STRING log_msg) const

Definition at line 398 of file lstmtrainer.cpp.

398  {
399  LogIterations("At", log_msg);
400  log_msg->add_str_double(", Mean rms=", error_rates_[ET_RMS]);
401  log_msg->add_str_double("%, delta=", error_rates_[ET_DELTA]);
402  log_msg->add_str_double("%, char train=", error_rates_[ET_CHAR_ERROR]);
403  log_msg->add_str_double("%, word train=", error_rates_[ET_WORD_RECERR]);
404  log_msg->add_str_double("%, skip ratio=", error_rates_[ET_SKIP_RATIO]);
405  *log_msg += "%, ";
406 }
double error_rates_[ET_COUNT]
Definition: lstmtrainer.h:481
void LogIterations(const char *intro_str, STRING *log_msg) const
void add_str_double(const char *str, double number)
Definition: strngs.cpp:387

◆ ReadLocalTrainingDump()

bool tesseract::LSTMTrainer::ReadLocalTrainingDump ( const TessdataManager mgr,
const char *  data,
int  size 
)

Definition at line 909 of file lstmtrainer.cpp.

910  {
911  if (size == 0) {
912  tprintf("Warning: data size is 0 in LSTMTrainer::ReadLocalTrainingDump\n");
913  return false;
914  }
915  TFile fp;
916  fp.Open(data, size);
917  return DeSerialize(mgr, &fp);
918 }
DLLSYM void tprintf(const char *format,...)
Definition: tprintf.cpp:35
bool DeSerialize(const TessdataManager *mgr, TFile *fp)

◆ ReadSizedTrainingDump()

bool tesseract::LSTMTrainer::ReadSizedTrainingDump ( const char *  data,
int  size,
LSTMTrainer trainer 
) const
inline

Definition at line 296 of file lstmtrainer.h.

297  {
298  return trainer->ReadLocalTrainingDump(&mgr_, data, size);
299  }
TessdataManager mgr_
Definition: lstmtrainer.h:483

◆ ReadTrainingDump()

bool tesseract::LSTMTrainer::ReadTrainingDump ( const GenericVector< char > &  data,
LSTMTrainer trainer 
) const
inline

Definition at line 291 of file lstmtrainer.h.

292  {
293  if (data.empty()) return false;
294  return ReadSizedTrainingDump(&data[0], data.size(), trainer);
295  }
bool empty() const
Definition: genericvector.h:91
bool ReadSizedTrainingDump(const char *data, int size, LSTMTrainer *trainer) const
Definition: lstmtrainer.h:296
int size() const
Definition: genericvector.h:72

◆ ReduceLayerLearningRates()

int tesseract::LSTMTrainer::ReduceLayerLearningRates ( double  factor,
int  num_samples,
LSTMTrainer samples_trainer 
)

Definition at line 607 of file lstmtrainer.cpp.

608  {
609  enum WhichWay {
610  LR_DOWN, // Learning rate will go down by factor.
611  LR_SAME, // Learning rate will stay the same.
612  LR_COUNT // Size of arrays.
613  };
615  int num_layers = layers.size();
616  GenericVector<int> num_weights;
617  num_weights.init_to_size(num_layers, 0);
618  GenericVector<double> bad_sums[LR_COUNT];
619  GenericVector<double> ok_sums[LR_COUNT];
620  for (int i = 0; i < LR_COUNT; ++i) {
621  bad_sums[i].init_to_size(num_layers, 0.0);
622  ok_sums[i].init_to_size(num_layers, 0.0);
623  }
624  double momentum_factor = 1.0 / (1.0 - momentum_);
625  GenericVector<char> orig_trainer;
626  samples_trainer->SaveTrainingDump(LIGHT, this, &orig_trainer);
627  for (int i = 0; i < num_layers; ++i) {
628  Network* layer = GetLayer(layers[i]);
629  num_weights[i] = layer->IsTraining() ? layer->num_weights() : 0;
630  }
631  int iteration = sample_iteration();
632  for (int s = 0; s < num_samples; ++s) {
633  // Which way will we modify the learning rate?
634  for (int ww = 0; ww < LR_COUNT; ++ww) {
635  // Transfer momentum to learning rate and adjust by the ww factor.
636  float ww_factor = momentum_factor;
637  if (ww == LR_DOWN) ww_factor *= factor;
638  // Make a copy of *this, so we can mess about without damaging anything.
639  LSTMTrainer copy_trainer;
640  samples_trainer->ReadTrainingDump(orig_trainer, &copy_trainer);
641  // Clear the updates, doing nothing else.
642  copy_trainer.network_->Update(0.0, 0.0, 0.0, 0);
643  // Adjust the learning rate in each layer.
644  for (int i = 0; i < num_layers; ++i) {
645  if (num_weights[i] == 0) continue;
646  copy_trainer.ScaleLayerLearningRate(layers[i], ww_factor);
647  }
648  copy_trainer.SetIteration(iteration);
649  // Train on the sample, but keep the update in updates_ instead of
650  // applying to the weights.
651  const ImageData* trainingdata =
652  copy_trainer.TrainOnLine(samples_trainer, true);
653  if (trainingdata == nullptr) continue;
654  // We'll now use this trainer again for each layer.
655  GenericVector<char> updated_trainer;
656  samples_trainer->SaveTrainingDump(LIGHT, &copy_trainer, &updated_trainer);
657  for (int i = 0; i < num_layers; ++i) {
658  if (num_weights[i] == 0) continue;
659  LSTMTrainer layer_trainer;
660  samples_trainer->ReadTrainingDump(updated_trainer, &layer_trainer);
661  Network* layer = layer_trainer.GetLayer(layers[i]);
662  // Update the weights in just the layer, using Adam if enabled.
663  layer->Update(0.0, momentum_, adam_beta_,
664  layer_trainer.training_iteration_ + 1);
665  // Zero the updates matrix again.
666  layer->Update(0.0, 0.0, 0.0, 0);
667  // Train again on the same sample, again holding back the updates.
668  layer_trainer.TrainOnLine(trainingdata, true);
669  // Count the sign changes in the updates in layer vs in copy_trainer.
670  float before_bad = bad_sums[ww][i];
671  float before_ok = ok_sums[ww][i];
672  layer->CountAlternators(*copy_trainer.GetLayer(layers[i]),
673  &ok_sums[ww][i], &bad_sums[ww][i]);
674  float bad_frac =
675  bad_sums[ww][i] + ok_sums[ww][i] - before_bad - before_ok;
676  if (bad_frac > 0.0f)
677  bad_frac = (bad_sums[ww][i] - before_bad) / bad_frac;
678  }
679  }
680  ++iteration;
681  }
682  int num_lowered = 0;
683  for (int i = 0; i < num_layers; ++i) {
684  if (num_weights[i] == 0) continue;
685  Network* layer = GetLayer(layers[i]);
686  float lr = GetLayerLearningRate(layers[i]);
687  double total_down = bad_sums[LR_DOWN][i] + ok_sums[LR_DOWN][i];
688  double total_same = bad_sums[LR_SAME][i] + ok_sums[LR_SAME][i];
689  double frac_down = bad_sums[LR_DOWN][i] / total_down;
690  double frac_same = bad_sums[LR_SAME][i] / total_same;
691  tprintf("Layer %d=%s: lr %g->%g%%, lr %g->%g%%", i, layer->name().string(),
692  lr * factor, 100.0 * frac_down, lr, 100.0 * frac_same);
693  if (frac_down < frac_same * kImprovementFraction) {
694  tprintf(" REDUCED\n");
695  ScaleLayerLearningRate(layers[i], factor);
696  ++num_lowered;
697  } else {
698  tprintf(" SAME\n");
699  }
700  }
701  if (num_lowered == 0) {
702  // Just lower everything to make sure.
703  for (int i = 0; i < num_layers; ++i) {
704  if (num_weights[i] > 0) {
705  ScaleLayerLearningRate(layers[i], factor);
706  ++num_lowered;
707  }
708  }
709  }
710  return num_lowered;
711 }
DLLSYM void tprintf(const char *format,...)
Definition: tprintf.cpp:35
void init_to_size(int size, const T &t)
void ScaleLayerLearningRate(const STRING &id, double factor)
float GetLayerLearningRate(const STRING &id) const
Network * GetLayer(const STRING &id) const
const double kImprovementFraction
Definition: lstmtrainer.cpp:67
GenericVector< STRING > EnumerateLayers() const
int size() const
Definition: genericvector.h:72

◆ ReduceLearningRates()

void tesseract::LSTMTrainer::ReduceLearningRates ( LSTMTrainer samples_trainer,
STRING log_msg 
)

Definition at line 588 of file lstmtrainer.cpp.

589  {
591  int num_reduced = ReduceLayerLearningRates(
592  kLearningRateDecay, kNumAdjustmentIterations, samples_trainer);
593  log_msg->add_str_int("\nReduced learning rate on layers: ", num_reduced);
594  } else {
596  log_msg->add_str_double("\nReduced learning rate to :", learning_rate_);
597  }
598  *log_msg += "\n";
599 }
void ScaleLearningRate(double factor)
const int kNumAdjustmentIterations
Definition: lstmtrainer.cpp:55
int ReduceLayerLearningRates(double factor, int num_samples, LSTMTrainer *samples_trainer)
bool TestFlag(NetworkFlags flag) const
Definition: network.h:144
const double kLearningRateDecay
Definition: lstmtrainer.cpp:53
void add_str_int(const char *str, int number)
Definition: strngs.cpp:377
void add_str_double(const char *str, double number)
Definition: strngs.cpp:387

◆ RollErrorBuffers()

void tesseract::LSTMTrainer::RollErrorBuffers ( )
protected

Definition at line 1265 of file lstmtrainer.cpp.

1265  {
1267  if (NewSingleError(ET_DELTA) > 0.0)
1269  else
1272  if (debug_interval_ != 0) {
1273  tprintf("Mean rms=%g%%, delta=%g%%, train=%g%%(%g%%), skip ratio=%g%%\n",
1277  }
1278 }
DLLSYM void tprintf(const char *format,...)
Definition: tprintf.cpp:35
double error_rates_[ET_COUNT]
Definition: lstmtrainer.h:481
double NewSingleError(ErrorTypes type) const
Definition: lstmtrainer.h:154

◆ SaveRecognitionDump()

void tesseract::LSTMTrainer::SaveRecognitionDump ( GenericVector< char > *  data) const

Definition at line 930 of file lstmtrainer.cpp.

930  {
931  TFile fp;
932  fp.OpenWrite(data);
936 }
bool Serialize(const TessdataManager *mgr, TFile *fp) const
TessdataManager mgr_
Definition: lstmtrainer.h:483
virtual void SetEnableTraining(TrainingState state)
Definition: network.cpp:110
#define ASSERT_HOST(x)
Definition: errcode.h:88

◆ SaveTraineddata()

bool tesseract::LSTMTrainer::SaveTraineddata ( const STRING filename)

Definition at line 921 of file lstmtrainer.cpp.

921  {
922  GenericVector<char> recognizer_data;
923  SaveRecognitionDump(&recognizer_data);
924  mgr_.OverwriteEntry(TESSDATA_LSTM, &recognizer_data[0],
925  recognizer_data.size());
926  return mgr_.SaveFile(filename, file_writer_);
927 }
bool SaveFile(const STRING &filename, FileWriter writer) const
void OverwriteEntry(TessdataType type, const char *data, int size)
void SaveRecognitionDump(GenericVector< char > *data) const
TessdataManager mgr_
Definition: lstmtrainer.h:483
int size() const
Definition: genericvector.h:72

◆ SaveTrainingDump()

bool tesseract::LSTMTrainer::SaveTrainingDump ( SerializeAmount  serialize_amount,
const LSTMTrainer trainer,
GenericVector< char > *  data 
) const

Definition at line 900 of file lstmtrainer.cpp.

902  {
903  TFile fp;
904  fp.OpenWrite(data);
905  return trainer->Serialize(serialize_amount, &mgr_, &fp);
906 }
TessdataManager mgr_
Definition: lstmtrainer.h:483

◆ Serialize()

bool tesseract::LSTMTrainer::Serialize ( SerializeAmount  serialize_amount,
const TessdataManager mgr,
TFile fp 
) const

Definition at line 429 of file lstmtrainer.cpp.

430  {
431  if (!LSTMRecognizer::Serialize(mgr, fp)) return false;
432  if (!fp->Serialize(&learning_iteration_)) return false;
433  if (!fp->Serialize(&prev_sample_iteration_)) return false;
434  if (!fp->Serialize(&perfect_delay_)) return false;
435  if (!fp->Serialize(&last_perfect_training_iteration_)) return false;
436  for (const auto & error_buffer : error_buffers_) {
437  if (!error_buffer.Serialize(fp)) return false;
438  }
439  if (!fp->Serialize(&error_rates_[0], countof(error_rates_))) return false;
440  if (!fp->Serialize(&training_stage_)) return false;
441  uint8_t amount = serialize_amount;
442  if (!fp->Serialize(&amount)) return false;
443  if (serialize_amount == LIGHT) return true; // We are done.
444  if (!fp->Serialize(&best_error_rate_)) return false;
445  if (!fp->Serialize(&best_error_rates_[0], countof(best_error_rates_))) return false;
446  if (!fp->Serialize(&best_iteration_)) return false;
447  if (!fp->Serialize(&worst_error_rate_)) return false;
448  if (!fp->Serialize(&worst_error_rates_[0], countof(worst_error_rates_))) return false;
449  if (!fp->Serialize(&worst_iteration_)) return false;
450  if (!fp->Serialize(&stall_iteration_)) return false;
451  if (!best_model_data_.Serialize(fp)) return false;
452  if (!worst_model_data_.Serialize(fp)) return false;
453  if (serialize_amount != NO_BEST_TRAINER && !best_trainer_.Serialize(fp))
454  return false;
455  GenericVector<char> sub_data;
456  if (sub_trainer_ != nullptr && !SaveTrainingDump(LIGHT, sub_trainer_, &sub_data))
457  return false;
458  if (!sub_data.Serialize(fp)) return false;
459  if (!best_error_history_.Serialize(fp)) return false;
460  if (!best_error_iterations_.Serialize(fp)) return false;
461  return fp->Serialize(&improvement_steps_);
462 }
LSTMTrainer * sub_trainer_
Definition: lstmtrainer.h:450
GenericVector< int > best_error_iterations_
Definition: lstmtrainer.h:458
GenericVector< char > worst_model_data_
Definition: lstmtrainer.h:445
double best_error_rates_[ET_COUNT]
Definition: lstmtrainer.h:432
GenericVector< double > best_error_history_
Definition: lstmtrainer.h:457
double error_rates_[ET_COUNT]
Definition: lstmtrainer.h:481
constexpr size_t countof(T const (&)[N]) noexcept
Definition: serialis.h:43
double worst_error_rates_[ET_COUNT]
Definition: lstmtrainer.h:438
bool Serialize(const TessdataManager *mgr, TFile *fp) const
GenericVector< char > best_model_data_
Definition: lstmtrainer.h:444
GenericVector< char > best_trainer_
Definition: lstmtrainer.h:447
bool SaveTrainingDump(SerializeAmount serialize_amount, const LSTMTrainer *trainer, GenericVector< char > *data) const
bool Serialize(FILE *fp) const
GenericVector< double > error_buffers_[ET_COUNT]
Definition: lstmtrainer.h:479

◆ set_perfect_delay()

void tesseract::LSTMTrainer::set_perfect_delay ( int  delay)
inline

Definition at line 151 of file lstmtrainer.h.

151 { perfect_delay_ = delay; }

◆ SetNullChar()

void tesseract::LSTMTrainer::SetNullChar ( )
protected

Definition at line 1005 of file lstmtrainer.cpp.

1005  {
1007  : GetUnicharset().size();
1008  RecodedCharID code;
1010  null_char_ = code(0);
1011 }
int size() const
Definition: unicharset.h:341
int EncodeUnichar(int unichar_id, RecodedCharID *code) const
const UNICHARSET & GetUnicharset() const
bool has_special_codes() const
Definition: unicharset.h:722

◆ SetupCheckpointInfo()

void tesseract::LSTMTrainer::SetupCheckpointInfo ( )

◆ StartSubtrainer()

void tesseract::LSTMTrainer::StartSubtrainer ( STRING log_msg)

Definition at line 515 of file lstmtrainer.cpp.

515  {
516  delete sub_trainer_;
517  sub_trainer_ = new LSTMTrainer();
519  *log_msg += " Failed to revert to previous best for trial!";
520  delete sub_trainer_;
521  sub_trainer_ = nullptr;
522  } else {
523  log_msg->add_str_int(" Trial sub_trainer_ from iteration ",
525  // Reduce learning rate so it doesn't diverge this time.
526  sub_trainer_->ReduceLearningRates(this, log_msg);
527  // If it fails again, we will wait twice as long before reverting again.
528  int stall_offset =
530  stall_iteration_ = learning_iteration() + 2 * stall_offset;
532  // Re-save the best trainer with the new learning rates and stall iteration.
534  }
535 }
LSTMTrainer * sub_trainer_
Definition: lstmtrainer.h:450
CheckPointReader checkpoint_reader_
Definition: lstmtrainer.h:424
virtual R Run(A1, A2)=0
int learning_iteration() const
Definition: lstmtrainer.h:149
CheckPointWriter checkpoint_writer_
Definition: lstmtrainer.h:425
void add_str_int(const char *str, int number)
Definition: strngs.cpp:377
void ReduceLearningRates(LSTMTrainer *samples_trainer, STRING *log_msg)
GenericVector< char > best_trainer_
Definition: lstmtrainer.h:447
virtual R Run(A1, A2, A3)=0

◆ training_data()

const DocumentCache& tesseract::LSTMTrainer::training_data ( ) const
inline

Definition at line 165 of file lstmtrainer.h.

165  {
166  return training_data_;
167  }
DocumentCache training_data_
Definition: lstmtrainer.h:414

◆ TrainOnLine() [1/2]

const ImageData* tesseract::LSTMTrainer::TrainOnLine ( LSTMTrainer samples_trainer,
bool  batch 
)
inline

Definition at line 259 of file lstmtrainer.h.

259  {
260  int sample_index = sample_iteration();
261  const ImageData* image =
262  samples_trainer->training_data_.GetPageBySerial(sample_index);
263  if (image != nullptr) {
264  Trainability trainable = TrainOnLine(image, batch);
265  if (trainable == UNENCODABLE || trainable == NOT_BOXED) {
266  return nullptr; // Sample was unusable.
267  }
268  } else {
270  }
271  return image;
272  }
const ImageData * TrainOnLine(LSTMTrainer *samples_trainer, bool batch)
Definition: lstmtrainer.h:259

◆ TrainOnLine() [2/2]

Trainability tesseract::LSTMTrainer::TrainOnLine ( const ImageData trainingdata,
bool  batch 
)

Definition at line 763 of file lstmtrainer.cpp.

764  {
765  NetworkIO fwd_outputs, targets;
766  Trainability trainable =
767  PrepareForBackward(trainingdata, &fwd_outputs, &targets);
769  if (trainable == UNENCODABLE || trainable == NOT_BOXED) {
770  return trainable; // Sample was unusable.
771  }
772  bool debug = debug_interval_ > 0 &&
774  // Run backprop on the output.
775  NetworkIO bp_deltas;
776  if (network_->IsTraining() &&
777  (trainable != PERFECT ||
780  network_->Backward(debug, targets, &scratch_space_, &bp_deltas);
782  training_iteration_ + 1);
783  }
784 #ifndef GRAPHICS_DISABLED
785  if (debug_interval_ == 1 && debug_win_ != nullptr) {
787  }
788 #endif // GRAPHICS_DISABLED
789  // Roll the memory of past means.
791  return trainable;
792 }
Trainability PrepareForBackward(const ImageData *trainingdata, NetworkIO *fwd_outputs, NetworkIO *targets)
SVEvent * AwaitEvent(SVEventType type)
Definition: scrollview.cpp:443
virtual void Update(float learning_rate, float momentum, float adam_beta, int num_samples)
Definition: network.h:230
NetworkScratch scratch_space_
bool IsTraining() const
Definition: network.h:115
virtual bool Backward(bool debug, const NetworkIO &fwd_deltas, NetworkScratch *scratch, NetworkIO *back_deltas)=0

◆ TransitionTrainingStage()

bool tesseract::LSTMTrainer::TransitionTrainingStage ( float  error_threshold)

Definition at line 419 of file lstmtrainer.cpp.

419  {
420  if (best_error_rate_ < error_threshold &&
422  ++training_stage_;
423  return true;
424  }
425  return false;
426 }

◆ TryLoadingCheckpoint()

bool tesseract::LSTMTrainer::TryLoadingCheckpoint ( const char *  filename,
const char *  old_traineddata 
)

Definition at line 129 of file lstmtrainer.cpp.

130  {
131  GenericVector<char> data;
132  if (!(*file_reader_)(filename, &data)) return false;
133  tprintf("Loaded file %s, unpacking...\n", filename);
134  if (!checkpoint_reader_->Run(data, this)) return false;
135  StaticShape shape = network_->OutputShape(network_->InputShape());
136  if (((old_traineddata == nullptr || *old_traineddata == '\0') &&
138  filename == old_traineddata) {
139  return true; // Normal checkpoint load complete.
140  }
141  tprintf("Code range changed from %d to %d!\n", network_->NumOutputs(),
142  recoder_.code_range());
143  if (old_traineddata == nullptr || *old_traineddata == '\0') {
144  tprintf("Must supply the old traineddata for code conversion!\n");
145  return false;
146  }
147  TessdataManager old_mgr;
148  ASSERT_HOST(old_mgr.Init(old_traineddata));
149  TFile fp;
150  if (!old_mgr.GetComponent(TESSDATA_LSTM_UNICHARSET, &fp)) return false;
151  UNICHARSET old_chset;
152  if (!old_chset.load_from_file(&fp, false)) return false;
153  if (!old_mgr.GetComponent(TESSDATA_LSTM_RECODER, &fp)) return false;
154  UnicharCompress old_recoder;
155  if (!old_recoder.DeSerialize(&fp)) return false;
156  std::vector<int> code_map = MapRecoder(old_chset, old_recoder);
157  // Set the null_char_ to the new value.
158  int old_null_char = null_char_;
159  SetNullChar();
160  // Map the softmax(s) in the network.
161  network_->RemapOutputs(old_recoder.code_range(), code_map);
162  tprintf("Previous null char=%d mapped to %d\n", old_null_char, null_char_);
163  return true;
164 }
DLLSYM void tprintf(const char *format,...)
Definition: tprintf.cpp:35
CheckPointReader checkpoint_reader_
Definition: lstmtrainer.h:424
virtual R Run(A1, A2)=0
virtual StaticShape OutputShape(const StaticShape &input_shape) const
Definition: network.h:133
std::vector< int > MapRecoder(const UNICHARSET &old_chset, const UnicharCompress &old_recoder) const
virtual StaticShape InputShape() const
Definition: network.h:127
int NumOutputs() const
Definition: network.h:123
#define ASSERT_HOST(x)
Definition: errcode.h:88
virtual int RemapOutputs(int old_no, const std::vector< int > &code_map)
Definition: network.h:186
bool load_from_file(const char *const filename, bool skip_fragments)
Definition: unicharset.h:388

◆ UpdateErrorBuffer()

void tesseract::LSTMTrainer::UpdateErrorBuffer ( double  new_error,
ErrorTypes  type 
)
protected

Definition at line 1252 of file lstmtrainer.cpp.

1252  {
1254  error_buffers_[type][index] = new_error;
1255  // Compute the mean error.
1256  int mean_count = std::min(training_iteration_ + 1, error_buffers_[type].size());
1257  double buffer_sum = 0.0;
1258  for (int i = 0; i < mean_count; ++i) buffer_sum += error_buffers_[type][i];
1259  double mean = buffer_sum / mean_count;
1260  // Trim precision to 1/1000 of 1%.
1261  error_rates_[type] = IntCastRounded(100000.0 * mean) / 1000.0;
1262 }
double error_rates_[ET_COUNT]
Definition: lstmtrainer.h:481
static const int kRollingBufferSize_
Definition: lstmtrainer.h:478
int IntCastRounded(double x)
Definition: helpers.h:175
GenericVector< double > error_buffers_[ET_COUNT]
Definition: lstmtrainer.h:479

◆ UpdateErrorGraph()

STRING tesseract::LSTMTrainer::UpdateErrorGraph ( int  iteration,
double  error_rate,
const GenericVector< char > &  model_data,
TestCallback  tester 
)
protected

Definition at line 1284 of file lstmtrainer.cpp.

1286  {
1287  if (error_rate > best_error_rate_
1288  && iteration < best_iteration_ + kErrorGraphInterval) {
1289  // Too soon to record a new point.
1290  if (tester != nullptr && !worst_model_data_.empty()) {
1293  return tester->Run(worst_iteration_, nullptr, mgr_, CurrentTrainingStage());
1294  } else {
1295  return "";
1296  }
1297  }
1298  STRING result;
1299  // NOTE: there are 2 asymmetries here:
1300  // 1. We are computing the global minimum, but the local maximum in between.
1301  // 2. If the tester returns an empty string, indicating that it is busy,
1302  // call it repeatedly on new local maxima to test the previous min, but
1303  // not the other way around, as there is little point testing the maxima
1304  // between very frequent minima.
1305  if (error_rate < best_error_rate_) {
1306  // This is a new (global) minimum.
1307  if (tester != nullptr && !worst_model_data_.empty()) {
1310  result = tester->Run(worst_iteration_, worst_error_rates_, mgr_,
1313  best_model_data_ = model_data;
1314  }
1315  best_error_rate_ = error_rate;
1316  memcpy(best_error_rates_, error_rates_, sizeof(error_rates_));
1317  best_iteration_ = iteration;
1318  best_error_history_.push_back(error_rate);
1319  best_error_iterations_.push_back(iteration);
1320  // Compute 2% decay time.
1321  double two_percent_more = error_rate + 2.0;
1322  int i;
1323  for (i = best_error_history_.size() - 1;
1324  i >= 0 && best_error_history_[i] < two_percent_more; --i) {
1325  }
1326  int old_iteration = i >= 0 ? best_error_iterations_[i] : 0;
1327  improvement_steps_ = iteration - old_iteration;
1328  tprintf("2 Percent improvement time=%d, best error was %g @ %d\n",
1329  improvement_steps_, i >= 0 ? best_error_history_[i] : 100.0,
1330  old_iteration);
1331  } else if (error_rate > best_error_rate_) {
1332  // This is a new (local) maximum.
1333  if (tester != nullptr) {
1334  if (!best_model_data_.empty()) {
1337  result = tester->Run(best_iteration_, best_error_rates_, mgr_,
1339  } else if (!worst_model_data_.empty()) {
1340  // Allow for multiple data points with "worst" error rate.
1343  result = tester->Run(worst_iteration_, worst_error_rates_, mgr_,
1345  }
1346  if (result.length() > 0)
1348  worst_model_data_ = model_data;
1349  }
1350  }
1351  worst_error_rate_ = error_rate;
1352  memcpy(worst_error_rates_, error_rates_, sizeof(error_rates_));
1353  worst_iteration_ = iteration;
1354  return result;
1355 }
bool empty() const
Definition: genericvector.h:91
DLLSYM void tprintf(const char *format,...)
Definition: tprintf.cpp:35
const int kErrorGraphInterval
Definition: lstmtrainer.cpp:57
GenericVector< int > best_error_iterations_
Definition: lstmtrainer.h:458
void OverwriteEntry(TessdataType type, const char *data, int size)
GenericVector< char > worst_model_data_
Definition: lstmtrainer.h:445
double best_error_rates_[ET_COUNT]
Definition: lstmtrainer.h:432
GenericVector< double > best_error_history_
Definition: lstmtrainer.h:457
double error_rates_[ET_COUNT]
Definition: lstmtrainer.h:481
void truncate(int size)
int32_t length() const
Definition: strngs.cpp:189
double worst_error_rates_[ET_COUNT]
Definition: lstmtrainer.h:438
TessdataManager mgr_
Definition: lstmtrainer.h:483
GenericVector< char > best_model_data_
Definition: lstmtrainer.h:444
Definition: strngs.h:45
int CurrentTrainingStage() const
Definition: lstmtrainer.h:211
int push_back(T object)
int size() const
Definition: genericvector.h:72

◆ UpdateSubtrainer()

SubTrainerResult tesseract::LSTMTrainer::UpdateSubtrainer ( STRING log_msg)

Definition at line 545 of file lstmtrainer.cpp.

545  {
546  double training_error = CharError();
547  double sub_error = sub_trainer_->CharError();
548  double sub_margin = (training_error - sub_error) / sub_error;
549  if (sub_margin >= kSubTrainerMarginFraction) {
550  log_msg->add_str_double(" sub_trainer=", sub_error);
551  log_msg->add_str_double(" margin=", 100.0 * sub_margin);
552  *log_msg += "\n";
553  // Catch up to current iteration.
554  int end_iteration = training_iteration();
555  while (sub_trainer_->training_iteration() < end_iteration &&
556  sub_margin >= kSubTrainerMarginFraction) {
557  int target_iteration =
559  while (sub_trainer_->training_iteration() < target_iteration) {
560  sub_trainer_->TrainOnLine(this, false);
561  }
562  STRING batch_log = "Sub:";
563  sub_trainer_->PrepareLogMsg(&batch_log);
564  batch_log += "\n";
565  tprintf("UpdateSubtrainer:%s", batch_log.string());
566  *log_msg += batch_log;
567  sub_error = sub_trainer_->CharError();
568  sub_margin = (training_error - sub_error) / sub_error;
569  }
570  if (sub_error < best_error_rate_ &&
571  sub_margin >= kSubTrainerMarginFraction) {
572  // The sub_trainer_ has won the race to a new best. Switch to it.
573  GenericVector<char> updated_trainer;
574  SaveTrainingDump(LIGHT, sub_trainer_, &updated_trainer);
575  ReadTrainingDump(updated_trainer, this);
576  log_msg->add_str_int(" Sub trainer wins at iteration ",
578  *log_msg += "\n";
579  return STR_REPLACED;
580  }
581  return STR_UPDATED;
582  }
583  return STR_NONE;
584 }
DLLSYM void tprintf(const char *format,...)
Definition: tprintf.cpp:35
bool ReadTrainingDump(const GenericVector< char > &data, LSTMTrainer *trainer) const
Definition: lstmtrainer.h:291
const ImageData * TrainOnLine(LSTMTrainer *samples_trainer, bool batch)
Definition: lstmtrainer.h:259
const int kNumPagesPerBatch
Definition: lstmtrainer.cpp:59
LSTMTrainer * sub_trainer_
Definition: lstmtrainer.h:450
const char * string() const
Definition: strngs.cpp:194
const double kSubTrainerMarginFraction
Definition: lstmtrainer.cpp:51
double CharError() const
Definition: lstmtrainer.h:139
void PrepareLogMsg(STRING *log_msg) const
Definition: strngs.h:45
bool SaveTrainingDump(SerializeAmount serialize_amount, const LSTMTrainer *trainer, GenericVector< char > *data) const
void add_str_double(const char *str, double number)
Definition: strngs.cpp:387

Member Data Documentation

◆ align_win_

ScrollView* tesseract::LSTMTrainer::align_win_
protected

Definition at line 397 of file lstmtrainer.h.

◆ best_error_history_

GenericVector<double> tesseract::LSTMTrainer::best_error_history_
protected

Definition at line 457 of file lstmtrainer.h.

◆ best_error_iterations_

GenericVector<int> tesseract::LSTMTrainer::best_error_iterations_
protected

Definition at line 458 of file lstmtrainer.h.

◆ best_error_rate_

double tesseract::LSTMTrainer::best_error_rate_
protected

Definition at line 430 of file lstmtrainer.h.

◆ best_error_rates_

double tesseract::LSTMTrainer::best_error_rates_[ET_COUNT]
protected

Definition at line 432 of file lstmtrainer.h.

◆ best_iteration_

int tesseract::LSTMTrainer::best_iteration_
protected

Definition at line 434 of file lstmtrainer.h.

◆ best_model_data_

GenericVector<char> tesseract::LSTMTrainer::best_model_data_
protected

Definition at line 444 of file lstmtrainer.h.

◆ best_model_name_

STRING tesseract::LSTMTrainer::best_model_name_
protected

Definition at line 416 of file lstmtrainer.h.

◆ best_trainer_

GenericVector<char> tesseract::LSTMTrainer::best_trainer_
protected

Definition at line 447 of file lstmtrainer.h.

◆ checkpoint_iteration_

int tesseract::LSTMTrainer::checkpoint_iteration_
protected

Definition at line 407 of file lstmtrainer.h.

◆ checkpoint_name_

STRING tesseract::LSTMTrainer::checkpoint_name_
protected

Definition at line 411 of file lstmtrainer.h.

◆ checkpoint_reader_

CheckPointReader tesseract::LSTMTrainer::checkpoint_reader_
protected

Definition at line 424 of file lstmtrainer.h.

◆ checkpoint_writer_

CheckPointWriter tesseract::LSTMTrainer::checkpoint_writer_
protected

Definition at line 425 of file lstmtrainer.h.

◆ ctc_win_

ScrollView* tesseract::LSTMTrainer::ctc_win_
protected

Definition at line 401 of file lstmtrainer.h.

◆ debug_interval_

int tesseract::LSTMTrainer::debug_interval_
protected

Definition at line 405 of file lstmtrainer.h.

◆ error_buffers_

GenericVector<double> tesseract::LSTMTrainer::error_buffers_[ET_COUNT]
protected

Definition at line 479 of file lstmtrainer.h.

◆ error_rate_of_last_saved_best_

float tesseract::LSTMTrainer::error_rate_of_last_saved_best_
protected

Definition at line 452 of file lstmtrainer.h.

◆ error_rates_

double tesseract::LSTMTrainer::error_rates_[ET_COUNT]
protected

Definition at line 481 of file lstmtrainer.h.

◆ file_reader_

FileReader tesseract::LSTMTrainer::file_reader_
protected

Definition at line 420 of file lstmtrainer.h.

◆ file_writer_

FileWriter tesseract::LSTMTrainer::file_writer_
protected

Definition at line 421 of file lstmtrainer.h.

◆ improvement_steps_

int32_t tesseract::LSTMTrainer::improvement_steps_
protected

Definition at line 460 of file lstmtrainer.h.

◆ kRollingBufferSize_

const int tesseract::LSTMTrainer::kRollingBufferSize_ = 1000
staticprotected

Definition at line 478 of file lstmtrainer.h.

◆ last_perfect_training_iteration_

int tesseract::LSTMTrainer::last_perfect_training_iteration_
protected

Definition at line 475 of file lstmtrainer.h.

◆ learning_iteration_

int tesseract::LSTMTrainer::learning_iteration_
protected

Definition at line 464 of file lstmtrainer.h.

◆ mgr_

TessdataManager tesseract::LSTMTrainer::mgr_
protected

Definition at line 483 of file lstmtrainer.h.

◆ model_base_

STRING tesseract::LSTMTrainer::model_base_
protected

Definition at line 409 of file lstmtrainer.h.

◆ num_training_stages_

int tesseract::LSTMTrainer::num_training_stages_
protected

Definition at line 418 of file lstmtrainer.h.

◆ perfect_delay_

int tesseract::LSTMTrainer::perfect_delay_
protected

Definition at line 472 of file lstmtrainer.h.

◆ prev_sample_iteration_

int tesseract::LSTMTrainer::prev_sample_iteration_
protected

Definition at line 466 of file lstmtrainer.h.

◆ randomly_rotate_

bool tesseract::LSTMTrainer::randomly_rotate_
protected

Definition at line 413 of file lstmtrainer.h.

◆ recon_win_

ScrollView* tesseract::LSTMTrainer::recon_win_
protected

Definition at line 403 of file lstmtrainer.h.

◆ stall_iteration_

int tesseract::LSTMTrainer::stall_iteration_
protected

Definition at line 442 of file lstmtrainer.h.

◆ sub_trainer_

LSTMTrainer* tesseract::LSTMTrainer::sub_trainer_
protected

Definition at line 450 of file lstmtrainer.h.

◆ target_win_

ScrollView* tesseract::LSTMTrainer::target_win_
protected

Definition at line 399 of file lstmtrainer.h.

◆ training_data_

DocumentCache tesseract::LSTMTrainer::training_data_
protected

Definition at line 414 of file lstmtrainer.h.

◆ training_stage_

int tesseract::LSTMTrainer::training_stage_
protected

Definition at line 454 of file lstmtrainer.h.

◆ worst_error_rate_

double tesseract::LSTMTrainer::worst_error_rate_
protected

Definition at line 436 of file lstmtrainer.h.

◆ worst_error_rates_

double tesseract::LSTMTrainer::worst_error_rates_[ET_COUNT]
protected

Definition at line 438 of file lstmtrainer.h.

◆ worst_iteration_

int tesseract::LSTMTrainer::worst_iteration_
protected

Definition at line 440 of file lstmtrainer.h.

◆ worst_model_data_

GenericVector<char> tesseract::LSTMTrainer::worst_model_data_
protected

Definition at line 445 of file lstmtrainer.h.


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