tesseract::LSTMTrainerTest Class Reference

#include <lstm_test.h>

Inheritance diagram for tesseract::LSTMTrainerTest:

Protected Member Functions
void	SetUp ()
	LSTMTrainerTest ()
std::string	TestDataNameToPath (const std::string &name)
std::string	TessDataNameToPath (const std::string &name)
std::string	TestingNameToPath (const std::string &name)
void	SetupTrainerEng (const std::string &network_spec, const std::string &model_name, bool recode, bool adam)
void	SetupTrainer (const std::string &network_spec, const std::string &model_name, const std::string &unicharset_file, const std::string &lstmf_file, bool recode, bool adam, double learning_rate, bool layer_specific, const std::string &kLang)
double	TrainIterations (int max_iterations)
double	TestIterations (int max_iterations)
double	TestIntMode (int test_iterations)
void	TestEncodeDecode (const std::string &lang, const std::string &str, bool recode)
void	TestEncodeDecodeBoth (const std::string &lang, const std::string &str)

Protected Attributes
std::unique_ptr< LSTMTrainer >	trainer_

Detailed Description

Definition at line 46 of file lstm_test.h.

Constructor & Destructor Documentation

LSTMTrainerTest()

tesseract::LSTMTrainerTest::LSTMTrainerTest ( )

inlineprotected

Definition at line 52 of file lstm_test.h.

{}

Member Function Documentation

SetUp()

void tesseract::LSTMTrainerTest::SetUp ( )

inlineprotected

Definition at line 48 of file lstm_test.h.

               {
    std::locale::global(std::locale(""));
  }

SetupTrainer()

void tesseract::LSTMTrainerTest::SetupTrainer ( const std::string &  network_spec, const std::string &  model_name, const std::string &  unicharset_file, const std::string &  lstmf_file, bool  recode, bool  adam, double  learning_rate, bool  layer_specific, const std::string &  kLang  )

inlineprotected

Definition at line 71 of file lstm_test.h.

                                                                 {
//    constexpr char kLang[] = "eng";  // Exact value doesn't matter.
    std::string unicharset_name = TestDataNameToPath(unicharset_file);
    UNICHARSET unicharset;
    ASSERT_TRUE(unicharset.load_from_file(unicharset_name.c_str(), false));
    std::string script_dir = file::JoinPath(
        LANGDATA_DIR, "");
    GenericVector<STRING> words;
    EXPECT_EQ(0, CombineLangModel(unicharset, script_dir, "", FLAGS_test_tmpdir,
                                  kLang, !recode, words, words, words, false,
                                  nullptr, nullptr));
    std::string model_path = file::JoinPath(FLAGS_test_tmpdir, model_name);
    std::string checkpoint_path = model_path + "_checkpoint";
    trainer_.reset(new LSTMTrainer(model_path.c_str(), checkpoint_path.c_str(),
                                   0, 0));
    trainer_->InitCharSet(file::JoinPath(FLAGS_test_tmpdir, kLang,
    absl::StrCat(kLang, ".traineddata")));
    int net_mode = adam ? NF_ADAM : 0;
    // Adam needs a higher learning rate, due to not multiplying the effective
    // rate by 1/(1-momentum).
    if (adam) learning_rate *= 20.0;
    if (layer_specific) net_mode |= NF_LAYER_SPECIFIC_LR;
    EXPECT_TRUE(trainer_->InitNetwork(network_spec.c_str(), -1, net_mode, 0.1,
                                      learning_rate, 0.9, 0.999));
    GenericVector<STRING> filenames;
    filenames.push_back(STRING(TestDataNameToPath(lstmf_file).c_str()));
    EXPECT_TRUE(trainer_->LoadAllTrainingData(filenames, CS_SEQUENTIAL, false));
    LOG(INFO) << "Setup network:" << model_name << "\n" ;
  }

SetupTrainerEng()

void tesseract::LSTMTrainerTest::SetupTrainerEng ( const std::string &  network_spec, const std::string &  model_name, bool  recode, bool  adam  )

inlineprotected

Definition at line 66 of file lstm_test.h.

                                               {
    SetupTrainer(network_spec, model_name, "eng/eng.unicharset",
                 "eng.Arial.exp0.lstmf", recode, adam, 5e-4, false, "eng");
  }

TessDataNameToPath()

std::string tesseract::LSTMTrainerTest::TessDataNameToPath ( const std::string &  name )

inlineprotected

Definition at line 57 of file lstm_test.h.

                                                      {
    return file::JoinPath(TESSDATA_DIR,
                          "" + name);
  }

TestDataNameToPath()

std::string tesseract::LSTMTrainerTest::TestDataNameToPath ( const std::string &  name )

inlineprotected

Definition at line 53 of file lstm_test.h.

                                                      {
    return file::JoinPath(TESTDATA_DIR,
                          "" + name);
  }

TestEncodeDecode()

void tesseract::LSTMTrainerTest::TestEncodeDecode ( const std::string &  lang, const std::string &  str, bool  recode  )

inlineprotected

Definition at line 169 of file lstm_test.h.

                                                                                  {
    std::string unicharset_name = lang + "/" + lang + ".unicharset";
    std::string lstmf_name = lang +  ".Arial_Unicode_MS.exp0.lstmf";
    SetupTrainer("[1,1,0,32 Lbx100 O1c1]", "bidi-lstm", unicharset_name,
                 lstmf_name, recode, true, 5e-4, true, lang);
    GenericVector<int> labels;
    EXPECT_TRUE(trainer_->EncodeString(str.c_str(), &labels));
    STRING decoded = trainer_->DecodeLabels(labels);
    std::string decoded_str(&decoded[0], decoded.length());
    EXPECT_EQ(str, decoded_str);
  }

TestEncodeDecodeBoth()

void tesseract::LSTMTrainerTest::TestEncodeDecodeBoth ( const std::string &  lang, const std::string &  str  )

inlineprotected

Definition at line 181 of file lstm_test.h.

                                                                         {
    TestEncodeDecode(lang, str, false);
    TestEncodeDecode(lang, str, true);
  }

TestingNameToPath()

std::string tesseract::LSTMTrainerTest::TestingNameToPath ( const std::string &  name )

inlineprotected

Definition at line 61 of file lstm_test.h.

                                                     {
    return file::JoinPath(TESTING_DIR,
                          "" + name);
  }

TestIntMode()

double tesseract::LSTMTrainerTest::TestIntMode ( int  test_iterations )

inlineprotected

Definition at line 153 of file lstm_test.h.

                                          {
    GenericVector<char> trainer_data;
    EXPECT_TRUE(trainer_->SaveTrainingDump(NO_BEST_TRAINER, trainer_.get(),
                                           &trainer_data));
    // Get the error on the next few iterations in float mode.
    double float_err = TestIterations(test_iterations);
    // Restore the dump, convert to int and test error on that.
    EXPECT_TRUE(trainer_->ReadTrainingDump(trainer_data, trainer_.get()));
    trainer_->ConvertToInt();
    double int_err = TestIterations(test_iterations);
    EXPECT_LT(int_err, float_err + 1.0);
    return int_err - float_err;
  }

TestIterations()

double tesseract::LSTMTrainerTest::TestIterations ( int  max_iterations )

inlineprotected

Definition at line 130 of file lstm_test.h.

                                            {
    CHECK_GT(max_iterations, 0);
    int iteration = trainer_->sample_iteration();
    double mean_error = 0.0;
    int error_count = 0;
    while (error_count < max_iterations) {
      const ImageData& trainingdata =
          *trainer_->mutable_training_data()->GetPageBySerial(iteration);
      NetworkIO fwd_outputs, targets;
      if (trainer_->PrepareForBackward(&trainingdata, &fwd_outputs, &targets) !=
          UNENCODABLE) {
        mean_error += trainer_->NewSingleError(ET_CHAR_ERROR);
        ++error_count;
      }
      trainer_->SetIteration(++iteration);
    }
    mean_error *= 100.0 / max_iterations;
    LOG(INFO) << "Tester error rate = " << mean_error << "\n" ;
    return mean_error;
  }

TrainIterations()

double tesseract::LSTMTrainerTest::TrainIterations ( int  max_iterations )

inlineprotected

Definition at line 104 of file lstm_test.h.

                                             {
    int iteration = trainer_->training_iteration();
    int iteration_limit = iteration + max_iterations;
    double best_error = 100.0;
    do {
      STRING log_str;
      int target_iteration = iteration + kBatchIterations;
      // Train a few.
      double mean_error = 0.0;
      while (iteration < target_iteration && iteration < iteration_limit) {
        trainer_->TrainOnLine(trainer_.get(), false);
        iteration = trainer_->training_iteration();
        mean_error += trainer_->LastSingleError(ET_CHAR_ERROR);
      }
      trainer_->MaintainCheckpoints(nullptr, &log_str);
      iteration = trainer_->training_iteration();
      mean_error *= 100.0 / kBatchIterations;
      LOG(INFO) << log_str.c_str();
      LOG(INFO) << "Best error = " << best_error << "\n" ;
      LOG(INFO) << "Mean error = " << mean_error << "\n" ;
      if (mean_error < best_error) best_error = mean_error;
    } while (iteration < iteration_limit);
    LOG(INFO) << "Trainer error rate = " << best_error << "\n";
    return best_error;
  }

Member Data Documentation

trainer_

std::unique_ptr<LSTMTrainer> tesseract::LSTMTrainerTest::trainer_

protected

Definition at line 186 of file lstm_test.h.

---

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

• /tesseract/unittest/lstm_test.h