1/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
2
3Licensed under the Apache License, Version 2.0 (the "License");
4you may not use this file except in compliance with the License.
5You may obtain a copy of the License at
6
7 http://www.apache.org/licenses/LICENSE-2.0
8
9Unless required by applicable law or agreed to in writing, software
10distributed under the License is distributed on an "AS IS" BASIS,
11WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12See the License for the specific language governing permissions and
13limitations under the License.
14==============================================================================*/
15#ifndef TENSORFLOW_LITE_C_BUILTIN_OP_DATA_H_
16#define TENSORFLOW_LITE_C_BUILTIN_OP_DATA_H_
17
18#include <stdint.h>
19
20#include "tensorflow/lite/c/common.h"
21
22#ifdef __cplusplus
23extern "C" {
24#endif // __cplusplus
25
26// TfLiteReshapeParams can't have dynamic data so we fix the maximum possible
27// number of dimensions.
28#define TFLITE_RESHAPE_PARAMS_MAX_DIMENSION_COUNT 8
29
30// TODO(aselle): Consider using "if this then that" for testing.
31
32// Useful placeholder to put in otherwise empty structs to avoid size warnings.
33typedef struct {
34 char dummy;
35} EmptyStructPlaceholder;
36
37// IMPORTANT: All new members of structs must be added at the end to ensure
38// backwards compatibility.
39
40// Possible padding types (for convolutions)
41typedef enum {
42 kTfLitePaddingUnknown = 0,
43 kTfLitePaddingSame,
44 kTfLitePaddingValid,
45} TfLitePadding;
46
47typedef enum {
48 kTfLiteMirrorPaddingUnknown = 0,
49 kTfLiteMirrorPaddingReflect,
50 kTfLiteMirrorPaddingSymmetric,
51} TfLiteMirrorPaddingMode;
52
53// TODO(b/130259536): We should move this out of builtin_op_data.
54typedef struct {
55 int width;
56 int height;
57 int width_offset;
58 int height_offset;
59} TfLitePaddingValues;
60
61typedef struct {
62 TfLiteMirrorPaddingMode mode;
63} TfLiteMirrorPaddingParams;
64
65// Possible fused activation functions.
66typedef enum {
67 kTfLiteActNone = 0,
68 kTfLiteActRelu,
69 kTfLiteActReluN1To1, // min(max(-1, x), 1)
70 kTfLiteActRelu6, // min(max(0, x), 6)
71 kTfLiteActTanh,
72 kTfLiteActSignBit,
73 kTfLiteActSigmoid,
74} TfLiteFusedActivation;
75
76typedef struct {
77 // Parameters for CONV_2D version 1.
78 TfLitePadding padding;
79 int stride_width;
80 int stride_height;
81 TfLiteFusedActivation activation;
82
83 // Parameters for CONV_2D version 2.
84 // Note: Version 2 supports dilation values not equal to 1.
85 int dilation_width_factor;
86 int dilation_height_factor;
87} TfLiteConvParams;
88
89typedef struct {
90 TfLitePadding padding;
91 int stride_width;
92 int stride_height;
93 int stride_depth;
94 int dilation_width_factor;
95 int dilation_height_factor;
96 int dilation_depth_factor;
97 TfLiteFusedActivation activation;
98} TfLiteConv3DParams;
99
100typedef TfLiteConv3DParams TfLiteConv3DTransposeParams;
101
102typedef struct {
103 TfLitePadding padding;
104 int stride_width;
105 int stride_height;
106 int filter_width;
107 int filter_height;
108 TfLiteFusedActivation activation;
109 struct {
110 TfLitePaddingValues padding;
111 } computed;
112} TfLitePoolParams;
113
114typedef struct {
115 // Parameters for DepthwiseConv version 1 or above.
116 TfLitePadding padding;
117 int stride_width;
118 int stride_height;
119 // `depth_multiplier` is redundant. It's used by CPU kernels in
120 // TensorFlow 2.0 or below, but ignored in versions above.
121 //
122 // The information can be deduced from the shape of input and the shape of
123 // weights. Since the TFLiteConverter toolchain doesn't support partially
124 // specified shapes, relying on `depth_multiplier` stops us from supporting
125 // graphs with dynamic shape tensors.
126 //
127 // Note: Some of the delegates (e.g. NNAPI, GPU) are still relying on this
128 // field.
129 int depth_multiplier;
130 TfLiteFusedActivation activation;
131 // Parameters for DepthwiseConv version 2 or above.
132 int dilation_width_factor;
133 int dilation_height_factor;
134} TfLiteDepthwiseConvParams;
135
136typedef struct {
137 int rank;
138 TfLiteFusedActivation activation;
139
140 // Parameter for SVDF version 4.
141 bool asymmetric_quantize_inputs;
142} TfLiteSVDFParams;
143
144typedef struct {
145 TfLiteFusedActivation activation;
146
147 // Parameter for RNN version 3.
148 bool asymmetric_quantize_inputs;
149} TfLiteRNNParams;
150
151typedef struct {
152 bool time_major;
153 TfLiteFusedActivation activation;
154
155 // Parameter for Sequence RNN version 3.
156 bool asymmetric_quantize_inputs;
157} TfLiteSequenceRNNParams;
158
159typedef struct {
160 bool time_major;
161 TfLiteFusedActivation activation;
162 bool merge_outputs;
163
164 // Parameter for Bidirectional RNN verison 3.
165 bool asymmetric_quantize_inputs;
166} TfLiteBidirectionalSequenceRNNParams;
167
168typedef enum {
169 kTfLiteFullyConnectedWeightsFormatDefault = 0,
170 kTfLiteFullyConnectedWeightsFormatShuffled4x16Int8 = 1,
171} TfLiteFullyConnectedWeightsFormat;
172
173typedef struct {
174 // Parameters for FullyConnected version 1 or above.
175 TfLiteFusedActivation activation;
176
177 // Parameters for FullyConnected version 2 or above.
178 TfLiteFullyConnectedWeightsFormat weights_format;
179
180 // Parameters for FullyConnected version 5 or above.
181 // If set to true, then the number of dimensions in the input and the output
182 // tensors are the same. Furthermore, all but the last dimension of the input
183 // and output shapes will be equal.
184 bool keep_num_dims;
185
186 // Parameters for FullyConnected version 7 or above.
187 // If set to true and the weights are quantized, then non constant inputs
188 // are quantized at evaluation time with asymmetric quantization.
189 bool asymmetric_quantize_inputs;
190} TfLiteFullyConnectedParams;
191
192typedef enum {
193 kTfLiteLshProjectionUnknown = 0,
194 kTfLiteLshProjectionSparse = 1,
195 kTfLiteLshProjectionDense = 2,
196} TfLiteLSHProjectionType;
197
198typedef struct {
199 TfLiteLSHProjectionType type;
200} TfLiteLSHProjectionParams;
201
202typedef struct {
203 float beta;
204} TfLiteSoftmaxParams;
205
206typedef struct {
207 int axis;
208 TfLiteFusedActivation activation;
209} TfLiteConcatenationParams;
210
211typedef struct {
212 TfLiteFusedActivation activation;
213 // Parameter added for the version 4.
214 bool pot_scale_int16;
215} TfLiteAddParams;
216
217typedef struct {
218 EmptyStructPlaceholder placeholder;
219} TfLiteSpaceToBatchNDParams;
220
221typedef struct {
222 EmptyStructPlaceholder placeholder;
223} TfLiteBatchToSpaceNDParams;
224
225typedef struct {
226 bool adj_x;
227 bool adj_y;
228 // Parameters for BatchMatMul version 4 or above.
229 // If set to true and the weights are quantized, then non constant inputs
230 // are quantized at evaluation time with asymmetric quantization.
231 bool asymmetric_quantize_inputs;
232} TfLiteBatchMatMulParams;
233
234typedef struct {
235 TfLiteFusedActivation activation;
236} TfLiteMulParams;
237
238typedef struct {
239 TfLiteFusedActivation activation;
240 // Parameter added for the version 5.
241 bool pot_scale_int16;
242} TfLiteSubParams;
243
244typedef struct {
245 TfLiteFusedActivation activation;
246} TfLiteDivParams;
247
248typedef struct {
249 TfLiteFusedActivation activation;
250} TfLiteL2NormParams;
251
252typedef struct {
253 int radius;
254 float bias;
255 float alpha;
256 float beta;
257} TfLiteLocalResponseNormParams;
258
259typedef enum {
260 kTfLiteLSTMFullKernel = 0,
261 kTfLiteLSTMBasicKernel
262} TfLiteLSTMKernelType;
263
264typedef struct {
265 // Parameters for LSTM version 1.
266 TfLiteFusedActivation activation;
267 float cell_clip;
268 float proj_clip;
269
270 // Parameters for LSTM version 2.
271 // kTfLiteLSTMBasicKernel is only supported in version 2 or above.
272 TfLiteLSTMKernelType kernel_type;
273
274 // Parameters for LSTM version 4.
275 bool asymmetric_quantize_inputs;
276} TfLiteLSTMParams;
277
278typedef struct {
279 // Parameters needed for the underlying LSTM.
280 TfLiteFusedActivation activation;
281 float cell_clip;
282 float proj_clip;
283
284 // If set to true then the first dimension is time, otherwise batch.
285 bool time_major;
286
287 // Parameter for unidirectional sequence RNN version 3.
288 bool asymmetric_quantize_inputs;
289} TfLiteUnidirectionalSequenceLSTMParams;
290
291typedef struct {
292 // Parameters supported by version 1:
293 // Parameters inherited for the LSTM kernel.
294 TfLiteFusedActivation activation;
295 float cell_clip;
296 float proj_clip;
297
298 // If true, store the outputs of both directions in the first output.
299 bool merge_outputs;
300
301 // Parameters supported by version 2:
302 // If set to true then the first dimension is time, otherwise batch.
303 bool time_major;
304
305 // Parameters supported by version 4:
306 // If set to true, then hybrid ops use asymmetric quantization for inputs.
307 bool asymmetric_quantize_inputs;
308} TfLiteBidirectionalSequenceLSTMParams;
309
310typedef struct {
311 bool align_corners;
312 // half_pixel_centers assumes pixels are of half the actual dimensions, and
313 // yields more accurate resizes. Corresponds to the same argument for the
314 // original TensorFlow op in TF2.0.
315 bool half_pixel_centers;
316} TfLiteResizeBilinearParams;
317
318typedef struct {
319 bool align_corners;
320 bool half_pixel_centers;
321} TfLiteResizeNearestNeighborParams;
322
323typedef struct {
324 EmptyStructPlaceholder placeholder;
325} TfLitePadParams;
326
327typedef struct {
328 EmptyStructPlaceholder placeholder;
329} TfLitePadV2Params;
330
331typedef struct {
332 // These fields are only used in old models for backward compatibility.
333 // In the current implementation, we use the 2nd input of the op as the shape,
334 // and these fields are unused.
335 int shape[TFLITE_RESHAPE_PARAMS_MAX_DIMENSION_COUNT];
336 int num_dimensions;
337} TfLiteReshapeParams;
338
339typedef struct {
340 int ngram_size;
341 int max_skip_size;
342 bool include_all_ngrams;
343} TfLiteSkipGramParams;
344
345typedef struct {
346 int block_size;
347} TfLiteSpaceToDepthParams;
348
349typedef struct {
350 int block_size;
351} TfLiteDepthToSpaceParams;
352
353typedef struct {
354 TfLiteType in_data_type;
355 TfLiteType out_data_type;
356} TfLiteCastParams;
357
358typedef enum {
359 kTfLiteCombinerTypeSum = 0,
360 kTfLiteCombinerTypeMean = 1,
361 kTfLiteCombinerTypeSqrtn = 2,
362} TfLiteCombinerType;
363
364typedef struct {
365 TfLiteCombinerType combiner;
366} TfLiteEmbeddingLookupSparseParams;
367
368typedef struct {
369 int axis;
370 int batch_dims;
371} TfLiteGatherParams;
372
373typedef struct {
374 EmptyStructPlaceholder placeholder;
375} TfLiteTransposeParams;
376
377typedef struct {
378 bool keep_dims;
379} TfLiteReducerParams;
380
381typedef struct {
382 int num_splits;
383} TfLiteSplitParams;
384
385typedef struct {
386 int num_splits;
387} TfLiteSplitVParams;
388
389typedef struct {
390 // TODO(ahentz): We can't have dynamic data in this struct, at least not yet.
391 // For now we will fix the maximum possible number of dimensions.
392 int squeeze_dims[8];
393 int num_squeeze_dims;
394} TfLiteSqueezeParams;
395
396typedef struct {
397 int begin_mask;
398 int end_mask;
399 int ellipsis_mask;
400 int new_axis_mask;
401 int shrink_axis_mask;
402} TfLiteStridedSliceParams;
403
404typedef struct {
405 TfLiteType output_type;
406} TfLiteArgMaxParams;
407
408typedef struct {
409 TfLiteType output_type;
410} TfLiteArgMinParams;
411
412typedef struct {
413 TfLitePadding padding;
414 int stride_width;
415 int stride_height;
416} TfLiteTransposeConvParams;
417
418typedef struct {
419 bool validate_indices;
420} TfLiteSparseToDenseParams;
421
422typedef struct {
423 TfLiteType out_type;
424} TfLiteShapeParams;
425
426typedef struct {
427 EmptyStructPlaceholder placeholder;
428} TfLiteRankParams;
429
430typedef struct {
431 // Parameters supported by version 1:
432 float min;
433 float max;
434 int num_bits;
435
436 // Parameters supported by version 2:
437 bool narrow_range;
438} TfLiteFakeQuantParams;
439
440typedef struct {
441 int values_count;
442 int axis;
443} TfLitePackParams;
444
445typedef struct {
446 int axis;
447} TfLiteOneHotParams;
448
449typedef struct {
450 int num;
451 int axis;
452} TfLiteUnpackParams;
453
454typedef struct {
455 float alpha;
456} TfLiteLeakyReluParams;
457
458typedef struct {
459 TfLiteType index_out_type;
460} TfLiteUniqueParams;
461
462typedef struct {
463 int seq_dim;
464 int batch_dim;
465} TfLiteReverseSequenceParams;
466
467typedef struct {
468 EmptyStructPlaceholder placeholder;
469} TfLiteMatrixDiagParams;
470
471typedef struct {
472 EmptyStructPlaceholder placeholder;
473} TfLiteMatrixSetDiagParams;
474
475typedef struct {
476 int then_subgraph_index;
477 int else_subgraph_index;
478} TfLiteIfParams;
479
480typedef struct {
481 int cond_subgraph_index;
482 int body_subgraph_index;
483} TfLiteWhileParams;
484
485typedef struct {
486 bool exclusive;
487 bool reverse;
488} TfLiteCumsumParams;
489
490typedef struct {
491 int init_subgraph_index;
492} TfLiteCallOnceParams;
493
494typedef struct {
495 int table_id;
496 TfLiteType key_dtype;
497 TfLiteType value_dtype;
498} TfLiteHashtableParams;
499
500typedef struct {
501 const char* container;
502 const char* shared_name;
503} TfLiteVarHandleParams;
504
505typedef struct {
506 int seed;
507 int seed2;
508} TfLiteRandomParams;
509
510typedef struct {
511 int num_boundaries;
512 // This points to the memory stored in the model (flatbuffer),
513 // and is not owned.
514 const float* boundaries;
515} TfLiteBucketizeParams;
516
517typedef struct {
518 bool approximate;
519} TfLiteGeluParams;
520
521#ifdef __cplusplus
522} // extern "C"
523#endif // __cplusplus
524
525#endif // TENSORFLOW_LITE_C_BUILTIN_OP_DATA_H_
526