tesseract  5.0.0-alpha-619-ge9db
networkbuilder.h
Go to the documentation of this file.
1 // File: networkbuilder.h
3 // Description: Class to parse the network description language and
4 // build a corresponding network.
5 // Author: Ray Smith
6 // Created: Wed Jul 16 18:35:38 PST 2014
7 //
8 // (C) Copyright 2014, Google Inc.
9 // Licensed under the Apache License, Version 2.0 (the "License");
10 // you may not use this file except in compliance with the License.
11 // You may obtain a copy of the License at
12 // http://www.apache.org/licenses/LICENSE-2.0
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
19 
20 #ifndef TESSERACT_LSTM_NETWORKBUILDER_H_
21 #define TESSERACT_LSTM_NETWORKBUILDER_H_
22 
23 #include "static_shape.h"
24 #include "stridemap.h"
25 
26 class STRING;
27 class UNICHARSET;
28 
29 namespace tesseract {
30 
31 class Input;
32 class Network;
33 class Parallel;
34 class TRand;
35 
37  public:
38  explicit NetworkBuilder(int num_softmax_outputs)
39  : num_softmax_outputs_(num_softmax_outputs) {}
40 
41  // Builds a network with a network_spec in the network description
42  // language, to recognize a character set of num_outputs size.
43  // If append_index is non-negative, then *network must be non-null and the
44  // given network_spec will be appended to *network AFTER append_index, with
45  // the top of the input *network discarded.
46  // Note that network_spec is call by value to allow a non-const char* pointer
47  // into the string for BuildFromString.
48  // net_flags control network behavior according to the NetworkFlags enum.
49  // The resulting network is returned via **network.
50  // Returns false if something failed.
51  static bool InitNetwork(int num_outputs, STRING network_spec,
52  int append_index, int net_flags, float weight_range,
53  TRand* randomizer, Network** network);
54 
55  // Parses the given string and returns a network according to the following
56  // language:
57  // ============ Syntax of description below: ============
58  // <d> represents a number.
59  // <net> represents any single network element, including (recursively) a
60  // [...] series or (...) parallel construct.
61  // (s|t|r|l|m) (regex notation) represents a single required letter.
62  // NOTE THAT THROUGHOUT, x and y are REVERSED from conventional mathematics,
63  // to use the same convention as Tensor Flow. The reason TF adopts this
64  // convention is to eliminate the need to transpose images on input, since
65  // adjacent memory locations in images increase x and then y, while adjacent
66  // memory locations in tensors in TF, and NetworkIO in tesseract increase the
67  // rightmost index first, then the next-left and so-on, like C arrays.
68  // ============ INPUTS ============
69  // <b>,<h>,<w>,<d> A batch of b images with height h, width w, and depth d.
70  // b, h and/or w may be zero, to indicate variable size. Some network layer
71  // (summarizing LSTM) must be used to make a variable h known.
72  // d may be 1 for greyscale, 3 for color.
73  // NOTE that throughout the constructed network, the inputs/outputs are all of
74  // the same [batch,height,width,depth] dimensions, even if a different size.
75  // ============ PLUMBING ============
76  // [...] Execute ... networks in series (layers).
77  // (...) Execute ... networks in parallel, with their output depths added.
78  // R<d><net> Execute d replicas of net in parallel, with their output depths
79  // added.
80  // Rx<net> Execute <net> with x-dimension reversal.
81  // Ry<net> Execute <net> with y-dimension reversal.
82  // S<y>,<x> Rescale 2-D input by shrink factor x,y, rearranging the data by
83  // increasing the depth of the input by factor xy.
84  // Mp<y>,<x> Maxpool the input, reducing the size by an (x,y) rectangle.
85  // ============ FUNCTIONAL UNITS ============
86  // C(s|t|r|l|m)<y>,<x>,<d> Convolves using a (x,y) window, with no shrinkage,
87  // random infill, producing d outputs, then applies a non-linearity:
88  // s: Sigmoid, t: Tanh, r: Relu, l: Linear, m: Softmax.
89  // F(s|t|r|l|m)<d> Truly fully-connected with s|t|r|l|m non-linearity and d
90  // outputs. Connects to every x,y,depth position of the input, reducing
91  // height, width to 1, producing a single <d> vector as the output.
92  // Input height and width must be constant.
93  // For a sliding-window linear or non-linear map that connects just to the
94  // input depth, and leaves the input image size as-is, use a 1x1 convolution
95  // eg. Cr1,1,64 instead of Fr64.
96  // L(f|r|b)(x|y)[s]<n> LSTM cell with n states/outputs.
97  // The LSTM must have one of:
98  // f runs the LSTM forward only.
99  // r runs the LSTM reversed only.
100  // b runs the LSTM bidirectionally.
101  // It will operate on either the x- or y-dimension, treating the other
102  // dimension independently (as if part of the batch).
103  // s (optional) summarizes the output in the requested dimension,
104  // outputting only the final step, collapsing the dimension to a
105  // single element.
106  // LS<n> Forward-only LSTM cell in the x-direction, with built-in Softmax.
107  // LE<n> Forward-only LSTM cell in the x-direction, with built-in softmax,
108  // with binary Encoding.
109  // L2xy<n> Full 2-d LSTM operating in quad-directions (bidi in x and y) and
110  // all the output depths added.
111  // ============ OUTPUTS ============
112  // The network description must finish with an output specification:
113  // O(2|1|0)(l|s|c)<n> output layer with n classes
114  // 2 (heatmap) Output is a 2-d vector map of the input (possibly at
115  // different scale).
116  // 1 (sequence) Output is a 1-d sequence of vector values.
117  // 0 (category) Output is a 0-d single vector value.
118  // l uses a logistic non-linearity on the output, allowing multiple
119  // hot elements in any output vector value.
120  // s uses a softmax non-linearity, with one-hot output in each value.
121  // c uses a softmax with CTC. Can only be used with s (sequence).
122  // NOTE1: Only O1s and O1c are currently supported.
123  // NOTE2: n is totally ignored, and for compatibility purposes only. The
124  // output number of classes is obtained automatically from the
125  // unicharset.
126  Network* BuildFromString(const StaticShape& input_shape, char** str);
127 
128  private:
129  // Parses an input specification and returns the result, which may include a
130  // series.
131  Network* ParseInput(char** str);
132  // Parses a sequential series of networks, defined by [<net><net>...].
133  Network* ParseSeries(const StaticShape& input_shape, Input* input_layer,
134  char** str);
135  // Parses a parallel set of networks, defined by (<net><net>...).
136  Network* ParseParallel(const StaticShape& input_shape, char** str);
137  // Parses a network that begins with 'R'.
138  Network* ParseR(const StaticShape& input_shape, char** str);
139  // Parses a network that begins with 'S'.
140  Network* ParseS(const StaticShape& input_shape, char** str);
141  // Parses a network that begins with 'C'.
142  Network* ParseC(const StaticShape& input_shape, char** str);
143  // Parses a network that begins with 'M'.
144  Network* ParseM(const StaticShape& input_shape, char** str);
145  // Parses an LSTM network, either individual, bi- or quad-directional.
146  Network* ParseLSTM(const StaticShape& input_shape, char** str);
147  // Builds a set of 4 lstms with t and y reversal, running in true parallel.
148  static Network* BuildLSTMXYQuad(int num_inputs, int num_states);
149  // Parses a Fully connected network.
150  Network* ParseFullyConnected(const StaticShape& input_shape, char** str);
151  // Parses an Output spec.
152  Network* ParseOutput(const StaticShape& input_shape, char** str);
153 
154  private:
155  int num_softmax_outputs_;
156 };
157 
158 } // namespace tesseract.
159 
160 #endif // TESSERACT_LSTM_NETWORKBUILDER_H_
tesseract::StaticShape
Definition: static_shape.h:38
STRING
Definition: strngs.h:45
tesseract::NetworkBuilder::BuildFromString
Network * BuildFromString(const StaticShape &input_shape, char **str)
Definition: networkbuilder.cpp:86
UNICHARSET
Definition: unicharset.h:145
tesseract
Definition: baseapi.h:65
stridemap.h
tesseract::NetworkBuilder::NetworkBuilder
NetworkBuilder(int num_softmax_outputs)
Definition: networkbuilder.h:38
tesseract::Network
Definition: network.h:105
static_shape.h
tesseract::NetworkBuilder::InitNetwork
static bool InitNetwork(int num_outputs, STRING network_spec, int append_index, int net_flags, float weight_range, TRand *randomizer, Network **network)
Definition: networkbuilder.cpp:45
tesseract::TRand
Definition: helpers.h:50
tesseract::Input
Definition: input.h:27
tesseract::NetworkBuilder
Definition: networkbuilder.h:36