tesseract  4.0.0-1-g2a2b
params_model.cpp
Go to the documentation of this file.
1 // File: params_model.cpp
3 // Description: Trained language model parameters.
4 // Author: David Eger
5 // Created: Mon Jun 11 11:26:42 PDT 2012
6 //
7 // (C) Copyright 2012, Google Inc.
8 // Licensed under the Apache License, Version 2.0 (the "License");
9 // you may not use this file except in compliance with the License.
10 // You may obtain a copy of the License at
11 // http://www.apache.org/licenses/LICENSE-2.0
12 // Unless required by applicable law or agreed to in writing, software
13 // distributed under the License is distributed on an "AS IS" BASIS,
14 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 // See the License for the specific language governing permissions and
16 // limitations under the License.
17 //
19 
20 #include "params_model.h"
21 
22 #include <cctype>
23 #include <cmath>
24 #include <cstdio>
25 
26 #include "bitvector.h"
27 #include "tprintf.h"
28 
29 namespace tesseract {
30 
31 // Scale factor to apply to params model scores.
32 static const float kScoreScaleFactor = 100.0f;
33 // Minimum cost result to return.
34 static const float kMinFinalCost = 0.001f;
35 // Maximum cost result to return.
36 static const float kMaxFinalCost = 100.0f;
37 
39  for (int p = 0; p < PTRAIN_NUM_PASSES; ++p) {
40  tprintf("ParamsModel for pass %d lang %s\n", p, lang_.string());
41  for (int i = 0; i < weights_vec_[p].size(); ++i) {
42  tprintf("%s = %g\n", kParamsTrainingFeatureTypeName[i],
43  weights_vec_[p][i]);
44  }
45  }
46 }
47 
48 void ParamsModel::Copy(const ParamsModel &other_model) {
49  for (int p = 0; p < PTRAIN_NUM_PASSES; ++p) {
50  weights_vec_[p] = other_model.weights_for_pass(
51  static_cast<PassEnum>(p));
52  }
53 }
54 
55 // Given a (modifiable) line, parse out a key / value pair.
56 // Return true on success.
57 bool ParamsModel::ParseLine(char *line, char** key, float *val) {
58  if (line[0] == '#')
59  return false;
60  int end_of_key = 0;
61  while (line[end_of_key] &&
62  !(isascii(line[end_of_key]) && isspace(line[end_of_key]))) {
63  end_of_key++;
64  }
65  if (!line[end_of_key]) {
66  tprintf("ParamsModel::Incomplete line %s\n", line);
67  return false;
68  }
69  line[end_of_key++] = 0;
70  *key = line;
71  if (sscanf(line + end_of_key, " %f", val) != 1)
72  return false;
73  return true;
74 }
75 
76 // Applies params model weights to the given features.
77 // Assumes that features is an array of size PTRAIN_NUM_FEATURE_TYPES.
78 // The cost is set to a number that can be multiplied by the outline length,
79 // as with the old ratings scheme. This enables words of different length
80 // and combinations of words to be compared meaningfully.
81 float ParamsModel::ComputeCost(const float features[]) const {
82  float unnorm_score = 0.0;
83  for (int f = 0; f < PTRAIN_NUM_FEATURE_TYPES; ++f) {
84  unnorm_score += weights_vec_[pass_][f] * features[f];
85  }
86  return ClipToRange(-unnorm_score / kScoreScaleFactor,
87  kMinFinalCost, kMaxFinalCost);
88 }
89 
90 bool ParamsModel::Equivalent(const ParamsModel &that) const {
91  float epsilon = 0.0001;
92  for (int p = 0; p < PTRAIN_NUM_PASSES; ++p) {
93  if (weights_vec_[p].size() != that.weights_vec_[p].size()) return false;
94  for (int i = 0; i < weights_vec_[p].size(); i++) {
95  if (weights_vec_[p][i] != that.weights_vec_[p][i] &&
96  fabs(weights_vec_[p][i] - that.weights_vec_[p][i]) > epsilon)
97  return false;
98  }
99  }
100  return true;
101 }
102 
104  const char *lang,
105  const char *full_path) {
106  TFile fp;
107  if (!fp.Open(full_path, nullptr)) {
108  tprintf("Error opening file %s\n", full_path);
109  return false;
110  }
111  return LoadFromFp(lang, &fp);
112 }
113 
114 bool ParamsModel::LoadFromFp(const char *lang, TFile *fp) {
115  const int kMaxLineSize = 100;
116  char line[kMaxLineSize];
117  BitVector present;
119  lang_ = lang;
120  // Load weights for passes with adaption on.
121  GenericVector<float> &weights = weights_vec_[pass_];
123 
124  while (fp->FGets(line, kMaxLineSize) != nullptr) {
125  char *key = nullptr;
126  float value;
127  if (!ParseLine(line, &key, &value))
128  continue;
129  int idx = ParamsTrainingFeatureByName(key);
130  if (idx < 0) {
131  tprintf("ParamsModel::Unknown parameter %s\n", key);
132  continue;
133  }
134  if (!present[idx]) {
135  present.SetValue(idx, true);
136  }
137  weights[idx] = value;
138  }
139  bool complete = (present.NumSetBits() == PTRAIN_NUM_FEATURE_TYPES);
140  if (!complete) {
141  for (int i = 0; i < PTRAIN_NUM_FEATURE_TYPES; i++) {
142  if (!present[i]) {
143  tprintf("Missing field %s.\n", kParamsTrainingFeatureTypeName[i]);
144  }
145  }
146  lang_ = "";
147  weights.truncate(0);
148  }
149  return complete;
150 }
151 
152 bool ParamsModel::SaveToFile(const char *full_path) const {
153  const GenericVector<float> &weights = weights_vec_[pass_];
155  tprintf("Refusing to save ParamsModel that has not been initialized.\n");
156  return false;
157  }
158  FILE *fp = fopen(full_path, "wb");
159  if (!fp) {
160  tprintf("Could not open %s for writing.\n", full_path);
161  return false;
162  }
163  bool all_good = true;
164  for (int i = 0; i < weights.size(); i++) {
165  if (fprintf(fp, "%s %f\n", kParamsTrainingFeatureTypeName[i], weights[i])
166  < 0) {
167  all_good = false;
168  }
169  }
170  fclose(fp);
171  return all_good;
172 }
173 
174 } // namespace tesseract
bool LoadFromFp(const char *lang, TFile *fp)
void Init(int length)
Definition: bitvector.cpp:133
int size() const
Definition: genericvector.h:71
void SetValue(int index, bool value)
Definition: bitvector.h:78
const char * string() const
Definition: strngs.cpp:196
char * FGets(char *buffer, int buffer_size)
Definition: serialis.cpp:248
const GenericVector< float > & weights_for_pass(PassEnum pass) const
Definition: params_model.h:71
float ComputeCost(const float features[]) const
int ParamsTrainingFeatureByName(const char *name)
void init_to_size(int size, const T &t)
bool Equivalent(const ParamsModel &that) const
DLLSYM void tprintf(const char *format,...)
Definition: tprintf.cpp:37
bool Open(const STRING &filename, FileReader reader)
Definition: serialis.cpp:196
bool LoadFromFile(const char *lang, const char *full_path)
bool SaveToFile(const char *full_path) const
int NumSetBits() const
Definition: bitvector.cpp:210
const GenericVector< float > & weights() const
Definition: params_model.h:68
void truncate(int size)
T ClipToRange(const T &x, const T &lower_bound, const T &upper_bound)
Definition: helpers.h:111
void Copy(const ParamsModel &other_model)