tesseract  5.0.0-alpha-619-ge9db
Public Member Functions | Static Public Member Functions | List of all members
tesseract::NetworkIO Class Reference

#include <networkio.h>

Public Member Functions

 NetworkIO ()
 
void Resize (const NetworkIO &src, int num_features)
 
void Resize2d (bool int_mode, int width, int num_features)
 
void ResizeFloat (const NetworkIO &src, int num_features)
 
void ResizeToMap (bool int_mode, const StrideMap &stride_map, int num_features)
 
void ResizeScaled (const NetworkIO &src, int x_scale, int y_scale, int num_features)
 
void ResizeXTo1 (const NetworkIO &src, int num_features)
 
void Zero ()
 
void ZeroInvalidElements ()
 
void FromPix (const StaticShape &shape, const Pix *pix, TRand *randomizer)
 
void FromPixes (const StaticShape &shape, const std::vector< const Pix * > &pixes, TRand *randomizer)
 
void Copy2DImage (int batch, Pix *pix, float black, float contrast, TRand *randomizer)
 
void Copy1DGreyImage (int batch, Pix *pix, float black, float contrast, TRand *randomizer)
 
void SetPixel (int t, int f, int pixel, float black, float contrast)
 
Pix * ToPix () const
 
void Print (int num) const
 
int Width () const
 
int NumFeatures () const
 
float * f (int t)
 
const float * f (int t) const
 
const int8_t * i (int t) const
 
bool int_mode () const
 
void set_int_mode (bool is_quantized)
 
const StrideMap & stride_map () const
 
void set_stride_map (const StrideMap &map)
 
const GENERIC_2D_ARRAY< float > & float_array () const
 
GENERIC_2D_ARRAY< float > * mutable_float_array ()
 
void CopyTimeStepFrom (int dest_t, const NetworkIO &src, int src_t)
 
void CopyTimeStepGeneral (int dest_t, int dest_offset, int num_features, const NetworkIO &src, int src_t, int src_offset)
 
void ZeroTimeStep (int t)
 
void ZeroTimeStepGeneral (int t, int offset, int num_features)
 
void Randomize (int t, int offset, int num_features, TRand *randomizer)
 
int BestChoiceOverRange (int t_start, int t_end, int not_this, int null_ch, float *rating, float *certainty) const
 
void ScoresOverRange (int t_start, int t_end, int choice, int null_ch, float *rating, float *certainty) const
 
int BestLabel (int t, float *score) const
 
int BestLabel (int t, int not_this, int not_that, float *score) const
 
int PositionOfBestMatch (const GenericVector< int > &labels, int start, int end) const
 
double ScoreOfLabels (const GenericVector< int > &labels, int start) const
 
void SetActivations (int t, int label, float ok_score)
 
void EnsureBestLabel (int t, int label)
 
bool AnySuspiciousTruth (float confidence_thr) const
 
void ReadTimeStep (int t, double *output) const
 
void AddTimeStep (int t, double *inout) const
 
void AddTimeStepPart (int t, int offset, int num_features, float *inout) const
 
void WriteTimeStep (int t, const double *input)
 
void WriteTimeStepPart (int t, int offset, int num_features, const double *input)
 
void MaxpoolTimeStep (int dest_t, const NetworkIO &src, int src_t, int *max_line)
 
void MaxpoolBackward (const NetworkIO &fwd, const GENERIC_2D_ARRAY< int > &maxes)
 
float MinOfMaxes () const
 
float Max () const
 
void CombineOutputs (const NetworkIO &base_output, const NetworkIO &combiner_output)
 
void ComputeCombinerDeltas (const NetworkIO &fwd_deltas, const NetworkIO &base_output)
 
void CopyAll (const NetworkIO &src)
 
void AddAllToFloat (const NetworkIO &src)
 
void SubtractAllFromFloat (const NetworkIO &src)
 
void CopyWithNormalization (const NetworkIO &src, const NetworkIO &scale)
 
void ScaleFloatBy (float factor)
 
void CopyWithYReversal (const NetworkIO &src)
 
void CopyWithXReversal (const NetworkIO &src)
 
void CopyWithXYTranspose (const NetworkIO &src)
 
int CopyPacking (const NetworkIO &src, int feature_offset)
 
void CopyUnpacking (const NetworkIO &src, int feature_offset, int num_features)
 
void Transpose (TransposedArray *dest) const
 
void ClipVector (int t, float range)
 
template<class Func >
void FuncMultiply (const NetworkIO &v_io, int t, double *product)
 
template<class Func >
void FuncMultiply3 (int u_t, const NetworkIO &v_io, int v_t, const double *w, double *product) const
 
template<class Func >
void FuncMultiply3Add (const NetworkIO &v_io, int t, const double *w, double *product) const
 
template<class Func1 , class Func2 >
void Func2Multiply3 (const NetworkIO &v_io, int t, const double *w, double *product) const
 

Static Public Member Functions

static float ProbToCertainty (float prob)
 

Detailed Description

Definition at line 39 of file networkio.h.

Constructor & Destructor Documentation

◆ NetworkIO()

tesseract::NetworkIO::NetworkIO ( )
inline

Definition at line 41 of file networkio.h.

41 : int_mode_(false) {}

Member Function Documentation

◆ AddAllToFloat()

void tesseract::NetworkIO::AddAllToFloat ( const NetworkIO &  src)

Definition at line 817 of file networkio.cpp.

817  {
818  ASSERT_HOST(!int_mode_);
819  ASSERT_HOST(!src.int_mode_);
820  f_ += src.f_;
821 }

◆ AddTimeStep()

void tesseract::NetworkIO::AddTimeStep ( int  t,
double *  inout 
) const

Definition at line 613 of file networkio.cpp.

613  {
614  int num_features = NumFeatures();
615  if (int_mode_) {
616  const int8_t* line = i_[t];
617  for (int i = 0; i < num_features; ++i) {
618  inout[i] += static_cast<double>(line[i]) / INT8_MAX;
619  }
620  } else {
621  const float* line = f_[t];
622  for (int i = 0; i < num_features; ++i) {
623  inout[i] += line[i];
624  }
625  }
626 }

◆ AddTimeStepPart()

void tesseract::NetworkIO::AddTimeStepPart ( int  t,
int  offset,
int  num_features,
float *  inout 
) const

Definition at line 629 of file networkio.cpp.

630  {
631  if (int_mode_) {
632  const int8_t* line = i_[t] + offset;
633  for (int i = 0; i < num_features; ++i) {
634  inout[i] += static_cast<float>(line[i]) / INT8_MAX;
635  }
636  } else {
637  const float* line = f_[t] + offset;
638  for (int i = 0; i < num_features; ++i) {
639  inout[i] += line[i];
640  }
641  }
642 }

◆ AnySuspiciousTruth()

bool tesseract::NetworkIO::AnySuspiciousTruth ( float  confidence_thr) const

Definition at line 579 of file networkio.cpp.

579  {
580  int num_features = NumFeatures();
581  for (int t = 0; t < Width(); ++t) {
582  const float* features = f_[t];
583  for (int y = 0; y < num_features; ++y) {
584  float grad = features[y];
585  if (grad < -confidence_thr) {
586  // Correcting strong output. Check for movement.
587  if ((t == 0 || f_[t - 1][y] < confidence_thr / 2) &&
588  (t + 1 == Width() || f_[t + 1][y] < confidence_thr / 2)) {
589  return true; // No strong positive on either side.
590  }
591  }
592  }
593  }
594  return false;
595 }

◆ BestChoiceOverRange()

int tesseract::NetworkIO::BestChoiceOverRange ( int  t_start,
int  t_end,
int  not_this,
int  null_ch,
float *  rating,
float *  certainty 
) const

Definition at line 431 of file networkio.cpp.

433  {
434  if (t_end <= t_start) return -1;
435  int max_char = -1;
436  float min_score = 0.0f;
437  for (int c = 0; c < NumFeatures(); ++c) {
438  if (c == not_this || c == null_ch) continue;
439  ScoresOverRange(t_start, t_end, c, null_ch, rating, certainty);
440  if (max_char < 0 || *rating < min_score) {
441  min_score = *rating;
442  max_char = c;
443  }
444  }
445  ScoresOverRange(t_start, t_end, max_char, null_ch, rating, certainty);
446  return max_char;
447 }

◆ BestLabel() [1/2]

int tesseract::NetworkIO::BestLabel ( int  t,
float *  score 
) const
inline

Definition at line 161 of file networkio.h.

161  {
162  return BestLabel(t, -1, -1, score);
163  }

◆ BestLabel() [2/2]

int tesseract::NetworkIO::BestLabel ( int  t,
int  not_this,
int  not_that,
float *  score 
) const

Definition at line 489 of file networkio.cpp.

490  {
491  ASSERT_HOST(!int_mode_);
492  int best_index = -1;
493  float best_score = -FLT_MAX;
494  const float* line = f_[t];
495  for (int i = 0; i < f_.dim2(); ++i) {
496  if (line[i] > best_score && i != not_this && i != not_that) {
497  best_score = line[i];
498  best_index = i;
499  }
500  }
501  if (score != nullptr) *score = ProbToCertainty(best_score);
502  return best_index;
503 }

◆ ClipVector()

void tesseract::NetworkIO::ClipVector ( int  t,
float  range 
)

Definition at line 971 of file networkio.cpp.

971  {
972  ASSERT_HOST(!int_mode_);
973  float* v = f_[t];
974  int dim = f_.dim2();
975  for (int i = 0; i < dim; ++i)
976  v[i] = ClipToRange<float>(v[i], -range, range);
977 }

◆ CombineOutputs()

void tesseract::NetworkIO::CombineOutputs ( const NetworkIO &  base_output,
const NetworkIO &  combiner_output 
)

Definition at line 736 of file networkio.cpp.

737  {
738  int no = base_output.NumFeatures();
739  ASSERT_HOST(combiner_output.NumFeatures() == no + 1);
740  Resize(base_output, no);
741  int width = Width();
742  if (int_mode_) {
743  // Number of outputs from base and final result.
744  for (int t = 0; t < width; ++t) {
745  int8_t* out_line = i_[t];
746  const int8_t* base_line = base_output.i_[t];
747  const int8_t* comb_line = combiner_output.i_[t];
748  float base_weight = static_cast<float>(comb_line[no]) / INT8_MAX;
749  float boost_weight = 1.0f - base_weight;
750  for (int i = 0; i < no; ++i) {
751  out_line[i] = IntCastRounded(base_line[i] * base_weight +
752  comb_line[i] * boost_weight);
753  }
754  }
755  } else {
756  for (int t = 0; t < width; ++t) {
757  float* out_line = f_[t];
758  const float* base_line = base_output.f_[t];
759  const float* comb_line = combiner_output.f_[t];
760  float base_weight = comb_line[no];
761  float boost_weight = 1.0f - base_weight;
762  for (int i = 0; i < no; ++i) {
763  out_line[i] = base_line[i] * base_weight + comb_line[i] * boost_weight;
764  }
765  }
766  }
767 }

◆ ComputeCombinerDeltas()

void tesseract::NetworkIO::ComputeCombinerDeltas ( const NetworkIO &  fwd_deltas,
const NetworkIO &  base_output 
)

Definition at line 770 of file networkio.cpp.

771  {
772  ASSERT_HOST(!int_mode_);
773  // Compute the deltas for the combiner.
774  int width = Width();
775  int no = NumFeatures() - 1;
776  ASSERT_HOST(fwd_deltas.NumFeatures() == no);
777  ASSERT_HOST(base_output.NumFeatures() == no);
778  // Number of outputs from base and final result.
779  for (int t = 0; t < width; ++t) {
780  const float* delta_line = fwd_deltas.f_[t];
781  const float* base_line = base_output.f_[t];
782  float* comb_line = f_[t];
783  float base_weight = comb_line[no];
784  float boost_weight = 1.0f - base_weight;
785  float max_base_delta = 0.0;
786  for (int i = 0; i < no; ++i) {
787  // What did the combiner actually produce?
788  float output = base_line[i] * base_weight + comb_line[i] * boost_weight;
789  // Reconstruct the target from the delta.
790  float comb_target = delta_line[i] + output;
791  comb_line[i] = comb_target - comb_line[i];
792  float base_delta = fabs(comb_target - base_line[i]);
793  if (base_delta > max_base_delta) max_base_delta = base_delta;
794  }
795  if (max_base_delta >= 0.5) {
796  // The base network got it wrong. The combiner should output the right
797  // answer and 0 for the base network.
798  comb_line[no] = 0.0 - base_weight;
799  } else {
800  // The base network was right. The combiner should flag that.
801  for (int i = 0; i < no; ++i) {
802  // All other targets are 0.
803  if (comb_line[i] > 0.0) comb_line[i] -= 1.0;
804  }
805  comb_line[no] = 1.0 - base_weight;
806  }
807  }
808 }

◆ Copy1DGreyImage()

void tesseract::NetworkIO::Copy1DGreyImage ( int  batch,
Pix *  pix,
float  black,
float  contrast,
TRand *  randomizer 
)

Definition at line 246 of file networkio.cpp.

247  {
248  int width = pixGetWidth(pix);
249  int height = pixGetHeight(pix);
250  ASSERT_HOST(height == NumFeatures());
251  int wpl = pixGetWpl(pix);
252  StrideMap::Index index(stride_map_);
253  index.AddOffset(batch, FD_BATCH);
254  int t = index.t();
255  int target_width = stride_map_.Size(FD_WIDTH);
256  if (width > target_width) width = target_width;
257  int x;
258  for (x = 0; x < width; ++x, ++t) {
259  for (int y = 0; y < height; ++y) {
260  uint32_t* line = pixGetData(pix) + wpl * y;
261  int pixel = GET_DATA_BYTE(line, x);
262  SetPixel(t, y, pixel, black, contrast);
263  }
264  }
265  for (; x < target_width; ++x) Randomize(t++, 0, height, randomizer);
266 }

◆ Copy2DImage()

void tesseract::NetworkIO::Copy2DImage ( int  batch,
Pix *  pix,
float  black,
float  contrast,
TRand *  randomizer 
)

Definition at line 208 of file networkio.cpp.

209  {
210  int width = pixGetWidth(pix);
211  int height = pixGetHeight(pix);
212  int wpl = pixGetWpl(pix);
213  StrideMap::Index index(stride_map_);
214  index.AddOffset(batch, FD_BATCH);
215  int t = index.t();
216  int target_height = stride_map_.Size(FD_HEIGHT);
217  int target_width = stride_map_.Size(FD_WIDTH);
218  int num_features = NumFeatures();
219  bool color = num_features == 3;
220  if (width > target_width) width = target_width;
221  uint32_t* line = pixGetData(pix);
222  for (int y = 0; y < target_height; ++y, line += wpl) {
223  int x = 0;
224  if (y < height) {
225  for (x = 0; x < width; ++x, ++t) {
226  if (color) {
227  int f = 0;
228  for (int c = COLOR_RED; c <= COLOR_BLUE; ++c) {
229  int pixel = GET_DATA_BYTE(line + x, c);
230  SetPixel(t, f++, pixel, black, contrast);
231  }
232  } else {
233  int pixel = GET_DATA_BYTE(line, x);
234  SetPixel(t, 0, pixel, black, contrast);
235  }
236  }
237  }
238  for (; x < target_width; ++x) Randomize(t++, 0, num_features, randomizer);
239  }
240 }

◆ CopyAll()

void tesseract::NetworkIO::CopyAll ( const NetworkIO &  src)

Definition at line 811 of file networkio.cpp.

811  {
812  ASSERT_HOST(src.int_mode_ == int_mode_);
813  f_ = src.f_;
814 }

◆ CopyPacking()

int tesseract::NetworkIO::CopyPacking ( const NetworkIO &  src,
int  feature_offset 
)

Definition at line 917 of file networkio.cpp.

917  {
918  ASSERT_HOST(int_mode_ == src.int_mode_);
919  int width = src.Width();
920  ASSERT_HOST(width <= Width());
921  int num_features = src.NumFeatures();
922  ASSERT_HOST(num_features + feature_offset <= NumFeatures());
923  if (int_mode_) {
924  for (int t = 0; t < width; ++t) {
925  memcpy(i_[t] + feature_offset, src.i_[t],
926  num_features * sizeof(i_[t][0]));
927  }
928  for (int t = width; t < i_.dim1(); ++t) {
929  memset(i_[t], 0, num_features * sizeof(i_[t][0]));
930  }
931  } else {
932  for (int t = 0; t < width; ++t) {
933  memcpy(f_[t] + feature_offset, src.f_[t],
934  num_features * sizeof(f_[t][0]));
935  }
936  for (int t = width; t < f_.dim1(); ++t) {
937  memset(f_[t], 0, num_features * sizeof(f_[t][0]));
938  }
939  }
940  return num_features + feature_offset;
941 }

◆ CopyTimeStepFrom()

void tesseract::NetworkIO::CopyTimeStepFrom ( int  dest_t,
const NetworkIO &  src,
int  src_t 
)

Definition at line 383 of file networkio.cpp.

383  {
384  ASSERT_HOST(int_mode_ == src.int_mode_);
385  if (int_mode_) {
386  memcpy(i_[dest_t], src.i_[src_t], i_.dim2() * sizeof(i_[0][0]));
387  } else {
388  memcpy(f_[dest_t], src.f_[src_t], f_.dim2() * sizeof(f_[0][0]));
389  }
390 }

◆ CopyTimeStepGeneral()

void tesseract::NetworkIO::CopyTimeStepGeneral ( int  dest_t,
int  dest_offset,
int  num_features,
const NetworkIO &  src,
int  src_t,
int  src_offset 
)

Definition at line 393 of file networkio.cpp.

395  {
396  ASSERT_HOST(int_mode_ == src.int_mode_);
397  if (int_mode_) {
398  memcpy(i_[dest_t] + dest_offset, src.i_[src_t] + src_offset,
399  num_features * sizeof(i_[0][0]));
400  } else {
401  memcpy(f_[dest_t] + dest_offset, src.f_[src_t] + src_offset,
402  num_features * sizeof(f_[0][0]));
403  }
404 }

◆ CopyUnpacking()

void tesseract::NetworkIO::CopyUnpacking ( const NetworkIO &  src,
int  feature_offset,
int  num_features 
)

Definition at line 945 of file networkio.cpp.

946  {
947  Resize(src, num_features);
948  int width = src.Width();
949  ASSERT_HOST(num_features + feature_offset <= src.NumFeatures());
950  if (int_mode_) {
951  for (int t = 0; t < width; ++t) {
952  memcpy(i_[t], src.i_[t] + feature_offset,
953  num_features * sizeof(i_[t][0]));
954  }
955  } else {
956  for (int t = 0; t < width; ++t) {
957  memcpy(f_[t], src.f_[t] + feature_offset,
958  num_features * sizeof(f_[t][0]));
959  }
960  }
961 }

◆ CopyWithNormalization()

void tesseract::NetworkIO::CopyWithNormalization ( const NetworkIO &  src,
const NetworkIO &  scale 
)

Definition at line 831 of file networkio.cpp.

832  {
833  ASSERT_HOST(!int_mode_);
834  ASSERT_HOST(!src.int_mode_);
835  ASSERT_HOST(!scale.int_mode_);
836  float src_max = src.f_.MaxAbs();
837  ASSERT_HOST(std::isfinite(src_max));
838  float scale_max = scale.f_.MaxAbs();
839  ASSERT_HOST(std::isfinite(scale_max));
840  if (src_max > 0.0f) {
841  float factor = scale_max / src_max;
842  for (int t = 0; t < src.Width(); ++t) {
843  const float* src_ptr = src.f_[t];
844  float* dest_ptr = f_[t];
845  for (int i = 0; i < src.f_.dim2(); ++i) dest_ptr[i] = src_ptr[i] * factor;
846  }
847  } else {
848  f_.Clear();
849  }
850 }

◆ CopyWithXReversal()

void tesseract::NetworkIO::CopyWithXReversal ( const NetworkIO &  src)

Definition at line 872 of file networkio.cpp.

872  {
873  int num_features = src.NumFeatures();
874  Resize(src, num_features);
875  StrideMap::Index b_index(src.stride_map_);
876  do {
877  StrideMap::Index y_index(b_index);
878  do {
879  StrideMap::Index fwd_index(y_index);
880  StrideMap::Index rev_index(y_index);
881  rev_index.AddOffset(rev_index.MaxIndexOfDim(FD_WIDTH), FD_WIDTH);
882  do {
883  CopyTimeStepFrom(rev_index.t(), src, fwd_index.t());
884  } while (fwd_index.AddOffset(1, FD_WIDTH) &&
885  rev_index.AddOffset(-1, FD_WIDTH));
886  } while (y_index.AddOffset(1, FD_HEIGHT));
887  } while (b_index.AddOffset(1, FD_BATCH));
888 }

◆ CopyWithXYTranspose()

void tesseract::NetworkIO::CopyWithXYTranspose ( const NetworkIO &  src)

Definition at line 891 of file networkio.cpp.

891  {
892  int num_features = src.NumFeatures();
893  stride_map_ = src.stride_map_;
894  stride_map_.TransposeXY();
895  ResizeToMap(src.int_mode(), stride_map_, num_features);
896  StrideMap::Index src_b_index(src.stride_map_);
897  StrideMap::Index dest_b_index(stride_map_);
898  do {
899  StrideMap::Index src_y_index(src_b_index);
900  StrideMap::Index dest_x_index(dest_b_index);
901  do {
902  StrideMap::Index src_x_index(src_y_index);
903  StrideMap::Index dest_y_index(dest_x_index);
904  do {
905  CopyTimeStepFrom(dest_y_index.t(), src, src_x_index.t());
906  } while (src_x_index.AddOffset(1, FD_WIDTH) &&
907  dest_y_index.AddOffset(1, FD_HEIGHT));
908  } while (src_y_index.AddOffset(1, FD_HEIGHT) &&
909  dest_x_index.AddOffset(1, FD_WIDTH));
910  } while (src_b_index.AddOffset(1, FD_BATCH) &&
911  dest_b_index.AddOffset(1, FD_BATCH));
912 }

◆ CopyWithYReversal()

void tesseract::NetworkIO::CopyWithYReversal ( const NetworkIO &  src)

Definition at line 853 of file networkio.cpp.

853  {
854  int num_features = src.NumFeatures();
855  Resize(src, num_features);
856  StrideMap::Index b_index(src.stride_map_);
857  do {
858  int width = b_index.MaxIndexOfDim(FD_WIDTH) + 1;
859  StrideMap::Index fwd_index(b_index);
860  StrideMap::Index rev_index(b_index);
861  rev_index.AddOffset(rev_index.MaxIndexOfDim(FD_HEIGHT), FD_HEIGHT);
862  do {
863  int fwd_t = fwd_index.t();
864  int rev_t = rev_index.t();
865  for (int x = 0; x < width; ++x) CopyTimeStepFrom(rev_t++, src, fwd_t++);
866  } while (fwd_index.AddOffset(1, FD_HEIGHT) &&
867  rev_index.AddOffset(-1, FD_HEIGHT));
868  } while (b_index.AddOffset(1, FD_BATCH));
869 }

◆ EnsureBestLabel()

void tesseract::NetworkIO::EnsureBestLabel ( int  t,
int  label 
)

Definition at line 549 of file networkio.cpp.

549  {
550  ASSERT_HOST(!int_mode_);
551  if (BestLabel(t, nullptr) != label) {
552  // Output value needs enhancing. Third all the other elements and add the
553  // remainder to best_label.
554  int num_classes = NumFeatures();
555  float* targets = f_[t];
556  for (int c = 0; c < num_classes; ++c) {
557  if (c == label) {
558  targets[c] += (1.0 - targets[c]) * (2 / 3.0);
559  } else {
560  targets[c] /= 3.0;
561  }
562  }
563  }
564 }

◆ f() [1/2]

float* tesseract::NetworkIO::f ( int  t)
inline

Definition at line 115 of file networkio.h.

115  {
116  ASSERT_HOST(!int_mode_);
117  return f_[t];
118  }

◆ f() [2/2]

const float* tesseract::NetworkIO::f ( int  t) const
inline

Definition at line 119 of file networkio.h.

119  {
120  ASSERT_HOST(!int_mode_);
121  return f_[t];
122  }

◆ float_array()

const GENERIC_2D_ARRAY<float>& tesseract::NetworkIO::float_array ( ) const
inline

Definition at line 139 of file networkio.h.

139 { return f_; }

◆ FromPix()

void tesseract::NetworkIO::FromPix ( const StaticShape &  shape,
const Pix *  pix,
TRand *  randomizer 
)

Definition at line 161 of file networkio.cpp.

162  {
163  std::vector<const Pix*> pixes(1, pix);
164  FromPixes(shape, pixes, randomizer);
165 }

◆ FromPixes()

void tesseract::NetworkIO::FromPixes ( const StaticShape &  shape,
const std::vector< const Pix * > &  pixes,
TRand *  randomizer 
)

Definition at line 170 of file networkio.cpp.

172  {
173  int target_height = shape.height();
174  int target_width = shape.width();
175  std::vector<std::pair<int, int>> h_w_pairs;
176  for (auto pix : pixes) {
177  Pix* var_pix = const_cast<Pix*>(pix);
178  int width = pixGetWidth(var_pix);
179  if (target_width != 0) width = target_width;
180  int height = pixGetHeight(var_pix);
181  if (target_height != 0) height = target_height;
182  h_w_pairs.emplace_back(height, width);
183  }
184  stride_map_.SetStride(h_w_pairs);
185  ResizeToMap(int_mode(), stride_map_, shape.depth());
186  // Iterate over the images again to copy the data.
187  for (size_t b = 0; b < pixes.size(); ++b) {
188  Pix* pix = const_cast<Pix*>(pixes[b]);
189  float black = 0.0f, white = 255.0f;
190  if (shape.depth() != 3) ComputeBlackWhite(pix, &black, &white);
191  float contrast = (white - black) / 2.0f;
192  if (contrast <= 0.0f) contrast = 1.0f;
193  if (shape.height() == 1) {
194  Copy1DGreyImage(b, pix, black, contrast, randomizer);
195  } else {
196  Copy2DImage(b, pix, black, contrast, randomizer);
197  }
198  }
199 }

◆ Func2Multiply3()

template<class Func1 , class Func2 >
void tesseract::NetworkIO::Func2Multiply3 ( const NetworkIO &  v_io,
int  t,
const double *  w,
double *  product 
) const
inline

Definition at line 315 of file networkio.h.

316  {
317  ASSERT_HOST(!int_mode_);
318  ASSERT_HOST(!v_io.int_mode_);
319  Func1 f;
320  Func2 g;
321  const float* u = f_[t];
322  const float* v = v_io.f_[t];
323  int dim = f_.dim2();
324  for (int i = 0; i < dim; ++i) {
325  product[i] = f(u[i]) * g(v[i]) * w[i];
326  }
327  }

◆ FuncMultiply()

template<class Func >
void tesseract::NetworkIO::FuncMultiply ( const NetworkIO &  v_io,
int  t,
double *  product 
)
inline

Definition at line 259 of file networkio.h.

259  {
260  Func f;
261  ASSERT_HOST(!int_mode_);
262  ASSERT_HOST(!v_io.int_mode_);
263  int dim = f_.dim2();
264  if (int_mode_) {
265  const int8_t* u = i_[t];
266  const int8_t* v = v_io.i_[t];
267  for (int i = 0; i < dim; ++i) {
268  product[i] = f(u[i] / static_cast<double>(INT8_MAX)) * v[i] /
269  static_cast<double>(INT8_MAX);
270  }
271  } else {
272  const float* u = f_[t];
273  const float* v = v_io.f_[t];
274  for (int i = 0; i < dim; ++i) {
275  product[i] = f(u[i]) * v[i];
276  }
277  }
278  }

◆ FuncMultiply3()

template<class Func >
void tesseract::NetworkIO::FuncMultiply3 ( int  u_t,
const NetworkIO &  v_io,
int  v_t,
const double *  w,
double *  product 
) const
inline

Definition at line 283 of file networkio.h.

284  {
285  ASSERT_HOST(!int_mode_);
286  ASSERT_HOST(!v_io.int_mode_);
287  Func f;
288  const float* u = f_[u_t];
289  const float* v = v_io.f_[v_t];
290  int dim = f_.dim2();
291  for (int i = 0; i < dim; ++i) {
292  product[i] = f(u[i]) * v[i] * w[i];
293  }
294  }

◆ FuncMultiply3Add()

template<class Func >
void tesseract::NetworkIO::FuncMultiply3Add ( const NetworkIO &  v_io,
int  t,
const double *  w,
double *  product 
) const
inline

Definition at line 299 of file networkio.h.

300  {
301  ASSERT_HOST(!int_mode_);
302  ASSERT_HOST(!v_io.int_mode_);
303  Func f;
304  const float* u = f_[t];
305  const float* v = v_io.f_[t];
306  int dim = f_.dim2();
307  for (int i = 0; i < dim; ++i) {
308  product[i] += f(u[i]) * v[i] * w[i];
309  }
310  }

◆ i()

const int8_t* tesseract::NetworkIO::i ( int  t) const
inline

Definition at line 123 of file networkio.h.

123  {
124  ASSERT_HOST(int_mode_);
125  return i_[t];
126  }

◆ int_mode()

bool tesseract::NetworkIO::int_mode ( ) const
inline

Definition at line 127 of file networkio.h.

127  {
128  return int_mode_;
129  }

◆ Max()

float tesseract::NetworkIO::Max ( ) const
inline

Definition at line 215 of file networkio.h.

215 { return int_mode_ ? i_.Max() : f_.Max(); }

◆ MaxpoolBackward()

void tesseract::NetworkIO::MaxpoolBackward ( const NetworkIO &  fwd,
const GENERIC_2D_ARRAY< int > &  maxes 
)

Definition at line 695 of file networkio.cpp.

696  {
697  ASSERT_HOST(!int_mode_);
698  Zero();
699  StrideMap::Index index(fwd.stride_map_);
700  do {
701  int t = index.t();
702  const int* max_line = maxes[t];
703  const float* fwd_line = fwd.f_[t];
704  int num_features = fwd.f_.dim2();
705  for (int i = 0; i < num_features; ++i) {
706  f_[max_line[i]][i] = fwd_line[i];
707  }
708  } while (index.Increment());
709 }

◆ MaxpoolTimeStep()

void tesseract::NetworkIO::MaxpoolTimeStep ( int  dest_t,
const NetworkIO &  src,
int  src_t,
int *  max_line 
)

Definition at line 668 of file networkio.cpp.

669  {
670  ASSERT_HOST(int_mode_ == src.int_mode_);
671  if (int_mode_) {
672  int dim = i_.dim2();
673  int8_t* dest_line = i_[dest_t];
674  const int8_t* src_line = src.i_[src_t];
675  for (int i = 0; i < dim; ++i) {
676  if (dest_line[i] < src_line[i]) {
677  dest_line[i] = src_line[i];
678  max_line[i] = src_t;
679  }
680  }
681  } else {
682  int dim = f_.dim2();
683  float* dest_line = f_[dest_t];
684  const float* src_line = src.f_[src_t];
685  for (int i = 0; i < dim; ++i) {
686  if (dest_line[i] < src_line[i]) {
687  dest_line[i] = src_line[i];
688  max_line[i] = src_t;
689  }
690  }
691  }
692 }

◆ MinOfMaxes()

float tesseract::NetworkIO::MinOfMaxes ( ) const

Definition at line 712 of file networkio.cpp.

712  {
713  float min_max = 0.0f;
714  int width = Width();
715  int num_features = NumFeatures();
716  for (int t = 0; t < width; ++t) {
717  float max_value = -FLT_MAX;
718  if (int_mode_) {
719  const int8_t* column = i_[t];
720  for (int i = 0; i < num_features; ++i) {
721  if (column[i] > max_value) max_value = column[i];
722  }
723  } else {
724  const float* column = f_[t];
725  for (int i = 0; i < num_features; ++i) {
726  if (column[i] > max_value) max_value = column[i];
727  }
728  }
729  if (t == 0 || max_value < min_max) min_max = max_value;
730  }
731  return min_max;
732 }

◆ mutable_float_array()

GENERIC_2D_ARRAY<float>* tesseract::NetworkIO::mutable_float_array ( )
inline

Definition at line 140 of file networkio.h.

140 { return &f_; }

◆ NumFeatures()

int tesseract::NetworkIO::NumFeatures ( ) const
inline

Definition at line 111 of file networkio.h.

111  {
112  return int_mode_ ? i_.dim2() : f_.dim2();
113  }

◆ PositionOfBestMatch()

int tesseract::NetworkIO::PositionOfBestMatch ( const GenericVector< int > &  labels,
int  start,
int  end 
) const

Definition at line 507 of file networkio.cpp.

508  {
509  int length = labels.size();
510  int last_start = end - length;
511  int best_start = -1;
512  double best_score = 0.0;
513  for (int s = start; s <= last_start; ++s) {
514  double score = ScoreOfLabels(labels, s);
515  if (score > best_score || best_start < 0) {
516  best_score = score;
517  best_start = s;
518  }
519  }
520  return best_start;
521 }

◆ Print()

void tesseract::NetworkIO::Print ( int  num) const

Definition at line 366 of file networkio.cpp.

366  {
367  int num_features = NumFeatures();
368  for (int y = 0; y < num_features; ++y) {
369  for (int t = 0; t < Width(); ++t) {
370  if (num == 0 || t < num || t + num >= Width()) {
371  if (int_mode_) {
372  tprintf(" %g", static_cast<float>(i_[t][y]) / INT8_MAX);
373  } else {
374  tprintf(" %g", f_[t][y]);
375  }
376  }
377  }
378  tprintf("\n");
379  }
380 }

◆ ProbToCertainty()

float tesseract::NetworkIO::ProbToCertainty ( float  prob)
static

Definition at line 568 of file networkio.cpp.

568  {
569  return prob > kMinProb ? log(prob) : kMinCertainty;
570 }

◆ Randomize()

void tesseract::NetworkIO::Randomize ( int  t,
int  offset,
int  num_features,
TRand *  randomizer 
)

Definition at line 416 of file networkio.cpp.

417  {
418  if (int_mode_) {
419  int8_t* line = i_[t] + offset;
420  for (int i = 0; i < num_features; ++i)
421  line[i] = IntCastRounded(randomizer->SignedRand(INT8_MAX));
422  } else {
423  // float mode.
424  float* line = f_[t] + offset;
425  for (int i = 0; i < num_features; ++i)
426  line[i] = randomizer->SignedRand(1.0);
427  }
428 }

◆ ReadTimeStep()

void tesseract::NetworkIO::ReadTimeStep ( int  t,
double *  output 
) const

Definition at line 598 of file networkio.cpp.

598  {
599  if (int_mode_) {
600  const int8_t* line = i_[t];
601  for (int i = 0; i < i_.dim2(); ++i) {
602  output[i] = static_cast<double>(line[i]) / INT8_MAX;
603  }
604  } else {
605  const float* line = f_[t];
606  for (int i = 0; i < f_.dim2(); ++i) {
607  output[i] = static_cast<double>(line[i]);
608  }
609  }
610 }

◆ Resize()

void tesseract::NetworkIO::Resize ( const NetworkIO &  src,
int  num_features 
)
inline

Definition at line 45 of file networkio.h.

45  {
46  ResizeToMap(src.int_mode(), src.stride_map(), num_features);
47  }

◆ Resize2d()

void tesseract::NetworkIO::Resize2d ( bool  int_mode,
int  width,
int  num_features 
)

Definition at line 35 of file networkio.cpp.

35  {
36  stride_map_ = StrideMap();
37  int_mode_ = int_mode;
38  if (int_mode_) {
39  i_.ResizeNoInit(width, num_features, GetPadding(num_features));
40  } else {
41  f_.ResizeNoInit(width, num_features);
42  }
43 }

◆ ResizeFloat()

void tesseract::NetworkIO::ResizeFloat ( const NetworkIO &  src,
int  num_features 
)
inline

Definition at line 52 of file networkio.h.

52  {
53  ResizeToMap(false, src.stride_map(), num_features);
54  }

◆ ResizeScaled()

void tesseract::NetworkIO::ResizeScaled ( const NetworkIO &  src,
int  x_scale,
int  y_scale,
int  num_features 
)

Definition at line 62 of file networkio.cpp.

63  {
64  StrideMap stride_map = src.stride_map_;
65  stride_map.ScaleXY(x_scale, y_scale);
66  ResizeToMap(src.int_mode_, stride_map, num_features);
67 }

◆ ResizeToMap()

void tesseract::NetworkIO::ResizeToMap ( bool  int_mode,
const StrideMap &  stride_map,
int  num_features 
)

Definition at line 46 of file networkio.cpp.

47  {
48  // If this method crashes with this == nullptr,
49  // it most likely got here through an uninitialized scratch element,
50  // ie call NetworkScratch::IO::Resizexxx() not NetworkIO::Resizexxx()!!
51  stride_map_ = stride_map;
52  int_mode_ = int_mode;
53  if (int_mode_) {
54  i_.ResizeNoInit(stride_map.Width(), num_features, GetPadding(num_features));
55  } else {
56  f_.ResizeNoInit(stride_map.Width(), num_features);
57  }
58  ZeroInvalidElements();
59 }

◆ ResizeXTo1()

void tesseract::NetworkIO::ResizeXTo1 ( const NetworkIO &  src,
int  num_features 
)

Definition at line 70 of file networkio.cpp.

70  {
71  StrideMap stride_map = src.stride_map_;
72  stride_map.ReduceWidthTo1();
73  ResizeToMap(src.int_mode_, stride_map, num_features);
74 }

◆ ScaleFloatBy()

void tesseract::NetworkIO::ScaleFloatBy ( float  factor)
inline

Definition at line 234 of file networkio.h.

234 { f_ *= factor; }

◆ ScoreOfLabels()

double tesseract::NetworkIO::ScoreOfLabels ( const GenericVector< int > &  labels,
int  start 
) const

Definition at line 525 of file networkio.cpp.

526  {
527  int length = labels.size();
528  double score = 0.0;
529  for (int i = 0; i < length; ++i) {
530  score += f_(start + i, labels[i]);
531  }
532  return score;
533 }

◆ ScoresOverRange()

void tesseract::NetworkIO::ScoresOverRange ( int  t_start,
int  t_end,
int  choice,
int  null_ch,
float *  rating,
float *  certainty 
) const

Definition at line 450 of file networkio.cpp.

451  {
452  ASSERT_HOST(!int_mode_);
453  *rating = 0.0f;
454  *certainty = 0.0f;
455  if (t_end <= t_start || t_end <= 0) return;
456  float ratings[3] = {0.0f, 0.0f, 0.0f};
457  float certs[3] = {0.0f, 0.0f, 0.0f};
458  for (int t = t_start; t < t_end; ++t) {
459  const float* line = f_[t];
460  float score = ProbToCertainty(line[choice]);
461  float zero = ProbToCertainty(line[null_ch]);
462  if (t == t_start) {
463  ratings[2] = FLT_MAX;
464  ratings[1] = -score;
465  certs[1] = score;
466  } else {
467  for (int i = 2; i >= 1; --i) {
468  if (ratings[i] > ratings[i - 1]) {
469  ratings[i] = ratings[i - 1];
470  certs[i] = certs[i - 1];
471  }
472  }
473  ratings[2] -= zero;
474  if (zero < certs[2]) certs[2] = zero;
475  ratings[1] -= score;
476  if (score < certs[1]) certs[1] = score;
477  }
478  ratings[0] -= zero;
479  if (zero < certs[0]) certs[0] = zero;
480  }
481  int best_i = ratings[2] < ratings[1] ? 2 : 1;
482  *rating = ratings[best_i] + t_end - t_start;
483  *certainty = certs[best_i];
484 }

◆ set_int_mode()

void tesseract::NetworkIO::set_int_mode ( bool  is_quantized)
inline

Definition at line 130 of file networkio.h.

130  {
131  int_mode_ = is_quantized;
132  }

◆ set_stride_map()

void tesseract::NetworkIO::set_stride_map ( const StrideMap &  map)
inline

Definition at line 136 of file networkio.h.

136  {
137  stride_map_ = map;
138  }

◆ SetActivations()

void tesseract::NetworkIO::SetActivations ( int  t,
int  label,
float  ok_score 
)

Definition at line 537 of file networkio.cpp.

537  {
538  ASSERT_HOST(!int_mode_);
539  int num_classes = NumFeatures();
540  float bad_score = (1.0f - ok_score) / (num_classes - 1);
541  float* targets = f_[t];
542  for (int i = 0; i < num_classes; ++i)
543  targets[i] = bad_score;
544  targets[label] = ok_score;
545 }

◆ SetPixel()

void tesseract::NetworkIO::SetPixel ( int  t,
int  f,
int  pixel,
float  black,
float  contrast 
)

Definition at line 275 of file networkio.cpp.

275  {
276  float float_pixel = (pixel - black) / contrast - 1.0f;
277  if (int_mode_) {
278  i_[t][f] = ClipToRange<int>(IntCastRounded((INT8_MAX + 1) * float_pixel),
279  -INT8_MAX, INT8_MAX);
280  } else {
281  f_[t][f] = float_pixel;
282  }
283 }

◆ stride_map()

const StrideMap& tesseract::NetworkIO::stride_map ( ) const
inline

Definition at line 133 of file networkio.h.

133  {
134  return stride_map_;
135  }

◆ SubtractAllFromFloat()

void tesseract::NetworkIO::SubtractAllFromFloat ( const NetworkIO &  src)

Definition at line 824 of file networkio.cpp.

824  {
825  ASSERT_HOST(!int_mode_);
826  ASSERT_HOST(!src.int_mode_);
827  f_ -= src.f_;
828 }

◆ ToPix()

Pix * tesseract::NetworkIO::ToPix ( ) const

Definition at line 286 of file networkio.cpp.

286  {
287  // Count the width of the image, and find the max multiplication factor.
288  int im_width = stride_map_.Size(FD_WIDTH);
289  int im_height = stride_map_.Size(FD_HEIGHT);
290  int num_features = NumFeatures();
291  int feature_factor = 1;
292  if (num_features == 3) {
293  // Special hack for color.
294  num_features = 1;
295  feature_factor = 3;
296  }
297  Pix* pix = pixCreate(im_width, im_height * num_features, 32);
298  StrideMap::Index index(stride_map_);
299  do {
300  int im_x = index.index(FD_WIDTH);
301  int top_im_y = index.index(FD_HEIGHT);
302  int im_y = top_im_y;
303  int t = index.t();
304  if (int_mode_) {
305  const int8_t* features = i_[t];
306  for (int y = 0; y < num_features; ++y, im_y += im_height) {
307  int pixel = features[y * feature_factor];
308  // 1 or 2 features use greyscale.
309  int red = ClipToRange<int>(pixel + 128, 0, 255);
310  int green = red, blue = red;
311  if (feature_factor == 3) {
312  // With 3 features assume RGB color.
313  green = ClipToRange<int>(features[y * feature_factor + 1] + 128, 0, 255);
314  blue = ClipToRange<int>(features[y * feature_factor + 2] + 128, 0, 255);
315  } else if (num_features > 3) {
316  // More than 3 features use false yellow/blue color, assuming a signed
317  // input in the range [-1,1].
318  red = abs(pixel) * 2;
319  if (pixel >= 0) {
320  green = red;
321  blue = 0;
322  } else {
323  blue = red;
324  green = red = 0;
325  }
326  }
327  pixSetPixel(pix, im_x, im_y, (red << L_RED_SHIFT) |
328  (green << L_GREEN_SHIFT) |
329  (blue << L_BLUE_SHIFT));
330  }
331  } else {
332  const float* features = f_[t];
333  for (int y = 0; y < num_features; ++y, im_y += im_height) {
334  float pixel = features[y * feature_factor];
335  // 1 or 2 features use greyscale.
336  int red = ClipToRange<int>(IntCastRounded((pixel + 1.0f) * 127.5f), 0, 255);
337  int green = red, blue = red;
338  if (feature_factor == 3) {
339  // With 3 features assume RGB color.
340  pixel = features[y * feature_factor + 1];
341  green = ClipToRange<int>(IntCastRounded((pixel + 1.0f) * 127.5f), 0, 255);
342  pixel = features[y * feature_factor + 2];
343  blue = ClipToRange<int>(IntCastRounded((pixel + 1.0f) * 127.5f), 0, 255);
344  } else if (num_features > 3) {
345  // More than 3 features use false yellow/blue color, assuming a signed
346  // input in the range [-1,1].
347  red = ClipToRange<int>(IntCastRounded(fabs(pixel) * 255), 0, 255);
348  if (pixel >= 0) {
349  green = red;
350  blue = 0;
351  } else {
352  blue = red;
353  green = red = 0;
354  }
355  }
356  pixSetPixel(pix, im_x, im_y, (red << L_RED_SHIFT) |
357  (green << L_GREEN_SHIFT) |
358  (blue << L_BLUE_SHIFT));
359  }
360  }
361  } while (index.Increment());
362  return pix;
363 }

◆ Transpose()

void tesseract::NetworkIO::Transpose ( TransposedArray *  dest) const

Definition at line 964 of file networkio.cpp.

964  {
965  int width = Width();
966  dest->ResizeNoInit(NumFeatures(), width);
967  for (int t = 0; t < width; ++t) dest->WriteStrided(t, f_[t]);
968 }

◆ Width()

int tesseract::NetworkIO::Width ( ) const
inline

Definition at line 107 of file networkio.h.

107  {
108  return int_mode_ ? i_.dim1() : f_.dim1();
109  }

◆ WriteTimeStep()

void tesseract::NetworkIO::WriteTimeStep ( int  t,
const double *  input 
)

Definition at line 645 of file networkio.cpp.

645  {
646  WriteTimeStepPart(t, 0, NumFeatures(), input);
647 }

◆ WriteTimeStepPart()

void tesseract::NetworkIO::WriteTimeStepPart ( int  t,
int  offset,
int  num_features,
const double *  input 
)

Definition at line 651 of file networkio.cpp.

652  {
653  if (int_mode_) {
654  int8_t* line = i_[t] + offset;
655  for (int i = 0; i < num_features; ++i) {
656  line[i] = ClipToRange<int>(IntCastRounded(input[i] * INT8_MAX),
657  -INT8_MAX, INT8_MAX);
658  }
659  } else {
660  float* line = f_[t] + offset;
661  for (int i = 0; i < num_features; ++i) {
662  line[i] = static_cast<float>(input[i]);
663  }
664  }
665 }

◆ Zero()

void tesseract::NetworkIO::Zero ( )

Definition at line 77 of file networkio.cpp.

77  {
78  int width = Width();
79  // Zero out the everything. Column-by-column in case it is aligned.
80  for (int t = 0; t < width; ++t) {
81  ZeroTimeStep(t);
82  }
83 }

◆ ZeroInvalidElements()

void tesseract::NetworkIO::ZeroInvalidElements ( )

Definition at line 88 of file networkio.cpp.

88  {
89  int num_features = NumFeatures();
90  int full_width = stride_map_.Size(FD_WIDTH);
91  int full_height = stride_map_.Size(FD_HEIGHT);
92  StrideMap::Index b_index(stride_map_);
93  do {
94  int end_x = b_index.MaxIndexOfDim(FD_WIDTH) + 1;
95  if (end_x < full_width) {
96  // The width is small, so fill for every valid y.
97  StrideMap::Index y_index(b_index);
98  int fill_size = num_features * (full_width - end_x);
99  do {
100  StrideMap::Index z_index(y_index);
101  z_index.AddOffset(end_x, FD_WIDTH);
102  if (int_mode_) {
103  ZeroVector(fill_size, i_[z_index.t()]);
104  } else {
105  ZeroVector(fill_size, f_[z_index.t()]);
106  }
107  } while (y_index.AddOffset(1, FD_HEIGHT));
108  }
109  int end_y = b_index.MaxIndexOfDim(FD_HEIGHT) + 1;
110  if (end_y < full_height) {
111  // The height is small, so fill in the space in one go.
112  StrideMap::Index y_index(b_index);
113  y_index.AddOffset(end_y, FD_HEIGHT);
114  int fill_size = num_features * full_width * (full_height - end_y);
115  if (int_mode_) {
116  ZeroVector(fill_size, i_[y_index.t()]);
117  } else {
118  ZeroVector(fill_size, f_[y_index.t()]);
119  }
120  }
121  } while (b_index.AddOffset(1, FD_BATCH));
122 }

◆ ZeroTimeStep()

void tesseract::NetworkIO::ZeroTimeStep ( int  t)
inline

Definition at line 148 of file networkio.h.

148 { ZeroTimeStepGeneral(t, 0, NumFeatures()); }

◆ ZeroTimeStepGeneral()

void tesseract::NetworkIO::ZeroTimeStepGeneral ( int  t,
int  offset,
int  num_features 
)

Definition at line 407 of file networkio.cpp.

407  {
408  if (int_mode_) {
409  ZeroVector(num_features, i_[t] + offset);
410  } else {
411  ZeroVector(num_features, f_[t] + offset);
412  }
413 }
The documentation for this class was generated from the following files:
tesseract::StrideMap::Size
int Size(FlexDimensions dimension) const
Definition: stridemap.h:114
tesseract::NetworkIO::i
const int8_t * i(int t) const
Definition: networkio.h:123
tesseract::NetworkIO::Copy1DGreyImage
void Copy1DGreyImage(int batch, Pix *pix, float black, float contrast, TRand *randomizer)
Definition: networkio.cpp:246
tesseract::NetworkIO::Randomize
void Randomize(int t, int offset, int num_features, TRand *randomizer)
Definition: networkio.cpp:416
tesseract::NetworkIO::ZeroInvalidElements
void ZeroInvalidElements()
Definition: networkio.cpp:88
tesseract::NetworkIO::int_mode
bool int_mode() const
Definition: networkio.h:127
ASSERT_HOST
#define ASSERT_HOST(x)
Definition: errcode.h:87
language_specific.log
log
Definition: language_specific.py:25
tesseract::NetworkIO::ScoresOverRange
void ScoresOverRange(int t_start, int t_end, int choice, int null_ch, float *rating, float *certainty) const
Definition: networkio.cpp:450
tesseract::NetworkIO::ZeroTimeStepGeneral
void ZeroTimeStepGeneral(int t, int offset, int num_features)
Definition: networkio.cpp:407
tesseract::NetworkIO::Width
int Width() const
Definition: networkio.h:107
tesseract::NetworkIO::stride_map
const StrideMap & stride_map() const
Definition: networkio.h:133
tesseract::StrideMap::ReduceWidthTo1
void ReduceWidthTo1()
Definition: stridemap.cpp:153
IntCastRounded
int IntCastRounded(double x)
Definition: helpers.h:173
tesseract::NetworkIO::FromPixes
void FromPixes(const StaticShape &shape, const std::vector< const Pix * > &pixes, TRand *randomizer)
Definition: networkio.cpp:170
tesseract::NetworkIO::ZeroTimeStep
void ZeroTimeStep(int t)
Definition: networkio.h:148
GENERIC_2D_ARRAY::Max
T Max() const
Definition: matrix.h:341
tesseract::NetworkIO::ScoreOfLabels
double ScoreOfLabels(const GenericVector< int > &labels, int start) const
Definition: networkio.cpp:525
GENERIC_2D_ARRAY::dim2
int dim2() const
Definition: matrix.h:206
tesseract::StrideMap::SetStride
void SetStride(const std::vector< std::pair< int, int >> &h_w_pairs)
Definition: stridemap.cpp:126
tesseract::FD_WIDTH
Definition: stridemap.h:35
GENERIC_2D_ARRAY::ResizeNoInit
void ResizeNoInit(int size1, int size2, int pad=0)
Definition: matrix.h:90
tesseract::NetworkIO::f
float * f(int t)
Definition: networkio.h:115
tesseract::NetworkIO::SetPixel
void SetPixel(int t, int f, int pixel, float black, float contrast)
Definition: networkio.cpp:275
tesseract::NetworkIO::CopyTimeStepFrom
void CopyTimeStepFrom(int dest_t, const NetworkIO &src, int src_t)
Definition: networkio.cpp:383
tesseract::StrideMap::ScaleXY
void ScaleXY(int x_factor, int y_factor)
Definition: stridemap.cpp:144
GENERIC_2D_ARRAY::Clear
void Clear()
Definition: matrix.h:135
tesseract::NetworkIO::BestLabel
int BestLabel(int t, float *score) const
Definition: networkio.h:161
tesseract::kMinCertainty
const float kMinCertainty
Definition: networkio.cpp:30
tesseract::NetworkIO::Copy2DImage
void Copy2DImage(int batch, Pix *pix, float black, float contrast, TRand *randomizer)
Definition: networkio.cpp:208
tesseract::ZeroVector
void ZeroVector(int n, T *vec)
Definition: functions.h:202
tesseract::NetworkIO::ResizeToMap
void ResizeToMap(bool int_mode, const StrideMap &stride_map, int num_features)
Definition: networkio.cpp:46
tesseract::NetworkIO::Zero
void Zero()
Definition: networkio.cpp:77
tesseract::NetworkIO::ProbToCertainty
static float ProbToCertainty(float prob)
Definition: networkio.cpp:568
tesseract::NetworkIO::Resize
void Resize(const NetworkIO &src, int num_features)
Definition: networkio.h:45
tesseract::kMinProb
const float kMinProb
Definition: networkio.cpp:32
tesseract::FD_HEIGHT
Definition: stridemap.h:34
tesseract::StrideMap::Width
int Width() const
Definition: stridemap.h:116
tesstrain_utils.dest
dest
Definition: tesstrain_utils.py:139
tprintf
DLLSYM void tprintf(const char *format,...)
Definition: tprintf.cpp:34
tesseract::NetworkIO::NumFeatures
int NumFeatures() const
Definition: networkio.h:111
tesseract::FD_BATCH
Definition: stridemap.h:33
tesseract::NetworkIO::WriteTimeStepPart
void WriteTimeStepPart(int t, int offset, int num_features, const double *input)
Definition: networkio.cpp:651
GenericVector::size
int size() const
Definition: genericvector.h:71
tesseract::StrideMap::TransposeXY
void TransposeXY()
Definition: stridemap.cpp:160
GENERIC_2D_ARRAY::dim1
int dim1() const
Definition: matrix.h:205