1 /* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
2
3 Licensed under the Apache License, Version 2.0 (the "License");
4 you may not use this file except in compliance with the License.
5 You may obtain a copy of the License at
6
7 http://www.apache.org/licenses/LICENSE-2.0
8
9 Unless required by applicable law or agreed to in writing, software
10 distributed under the License is distributed on an "AS IS" BASIS,
11 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 See the License for the specific language governing permissions and
13 limitations under the License.
14 ==============================================================================*/
15
16 #include "tensorflow/lite/kernels/register_ref.h"
17
18 #include "tensorflow/lite/c/common.h"
19 #include "tensorflow/lite/mutable_op_resolver.h"
20 #include "tensorflow/lite/schema/schema_generated.h"
21 #include "tensorflow/lite/util.h"
22
23 namespace tflite {
24 namespace ops {
25
26 namespace custom {
27
28 TfLiteRegistration* Register_NUMERIC_VERIFY_REF();
29 TfLiteRegistration* Register_AUDIO_SPECTROGRAM();
30 TfLiteRegistration* Register_MFCC();
31 TfLiteRegistration* Register_DETECTION_POSTPROCESS();
32
33 } // namespace custom
34
35 namespace builtin {
36
37 // TODO(yunluli): Some of the registries, e.g. Tanh(), could only invoke
38 // optimized kernels. Add a _REF() variant for them.
39 TfLiteRegistration* Register_ABS();
40 TfLiteRegistration* Register_RELU();
41 TfLiteRegistration* Register_RELU_N1_TO_1();
42 TfLiteRegistration* Register_RELU6();
43 TfLiteRegistration* Register_TANH_REF();
44 TfLiteRegistration* Register_LOGISTIC_REF();
45 TfLiteRegistration* Register_AVERAGE_POOL_REF();
46 TfLiteRegistration* Register_MAX_POOL_REF();
47 TfLiteRegistration* Register_L2_POOL_REF();
48 TfLiteRegistration* Register_CONVOLUTION_REF();
49 TfLiteRegistration* Register_DEPTHWISE_CONVOLUTION_REF();
50 TfLiteRegistration* Register_SVDF();
51 TfLiteRegistration* Register_RNN();
52 TfLiteRegistration* Register_BIDIRECTIONAL_SEQUENCE_RNN();
53 TfLiteRegistration* Register_UNIDIRECTIONAL_SEQUENCE_RNN();
54 TfLiteRegistration* Register_EMBEDDING_LOOKUP();
55 TfLiteRegistration* Register_EMBEDDING_LOOKUP_SPARSE();
56 TfLiteRegistration* Register_FULLY_CONNECTED_REF();
57 TfLiteRegistration* Register_LSH_PROJECTION();
58 TfLiteRegistration* Register_HASHTABLE_LOOKUP();
59 TfLiteRegistration* Register_SOFTMAX_REF();
60 TfLiteRegistration* Register_CONCATENATION_REF();
61 TfLiteRegistration* Register_ADD_REF();
62 TfLiteRegistration* Register_SPACE_TO_BATCH_ND_REF();
63 TfLiteRegistration* Register_DIV_REF();
64 TfLiteRegistration* Register_SUB_REF();
65 TfLiteRegistration* Register_BATCH_TO_SPACE_ND_REF();
66 TfLiteRegistration* Register_MUL_REF();
67 TfLiteRegistration* Register_L2NORM_REF();
68 TfLiteRegistration* Register_LOCAL_RESPONSE_NORM_REF();
69 TfLiteRegistration* Register_LSTM();
70 TfLiteRegistration* Register_BIDIRECTIONAL_SEQUENCE_LSTM();
71 TfLiteRegistration* Register_UNIDIRECTIONAL_SEQUENCE_LSTM();
72 TfLiteRegistration* Register_PAD_REF();
73 TfLiteRegistration* Register_PADV2_REF();
74 TfLiteRegistration* Register_RESHAPE();
75 TfLiteRegistration* Register_RESIZE_BILINEAR_REF();
76 TfLiteRegistration* Register_RESIZE_NEAREST_NEIGHBOR_REF();
77 TfLiteRegistration* Register_SKIP_GRAM();
78 TfLiteRegistration* Register_SPACE_TO_DEPTH_REF();
79 TfLiteRegistration* Register_GATHER();
80 TfLiteRegistration* Register_TRANSPOSE_REF();
81 TfLiteRegistration* Register_MEAN_REF();
82 TfLiteRegistration* Register_SPLIT();
83 TfLiteRegistration* Register_SPLIT_V();
84 TfLiteRegistration* Register_SQUEEZE();
85 TfLiteRegistration* Register_STRIDED_SLICE_REF();
86 TfLiteRegistration* Register_EXP_REF();
87 TfLiteRegistration* Register_TOPK_V2();
88 TfLiteRegistration* Register_LOG();
89 TfLiteRegistration* Register_LOG_SOFTMAX_REF();
90 TfLiteRegistration* Register_CAST();
91 TfLiteRegistration* Register_DEQUANTIZE_REF();
92 TfLiteRegistration* Register_PRELU_REF();
93 TfLiteRegistration* Register_MAXIMUM_REF();
94 TfLiteRegistration* Register_MINIMUM_REF();
95 TfLiteRegistration* Register_ARG_MAX();
96 TfLiteRegistration* Register_ARG_MIN();
97 TfLiteRegistration* Register_GREATER();
98 TfLiteRegistration* Register_GREATER_EQUAL();
99 TfLiteRegistration* Register_LESS();
100 TfLiteRegistration* Register_LESS_EQUAL();
101 TfLiteRegistration* Register_FLOOR_REF();
102 TfLiteRegistration* Register_TILE();
103 TfLiteRegistration* Register_NEG();
104 TfLiteRegistration* Register_SUM_REF();
105 TfLiteRegistration* Register_REDUCE_PROD_REF();
106 TfLiteRegistration* Register_REDUCE_MAX_REF();
107 TfLiteRegistration* Register_REDUCE_MIN_REF();
108 TfLiteRegistration* Register_REDUCE_ANY_REF();
109 TfLiteRegistration* Register_REDUCE_ALL_REF();
110 TfLiteRegistration* Register_SELECT();
111 TfLiteRegistration* Register_SLICE_REF();
112 TfLiteRegistration* Register_SIN();
113 TfLiteRegistration* Register_COS();
114 TfLiteRegistration* Register_TRANSPOSECONV_REF();
115 TfLiteRegistration* Register_EXPAND_DIMS();
116 TfLiteRegistration* Register_SPARSE_TO_DENSE();
117 TfLiteRegistration* Register_EQUAL();
118 TfLiteRegistration* Register_NOT_EQUAL();
119 TfLiteRegistration* Register_SQRT();
120 TfLiteRegistration* Register_RSQRT();
121 TfLiteRegistration* Register_SHAPE();
122 TfLiteRegistration* Register_RANK();
123 TfLiteRegistration* Register_POW();
124 TfLiteRegistration* Register_FAKE_QUANT_REF();
125 TfLiteRegistration* Register_PACK();
126 TfLiteRegistration* Register_ONE_HOT();
127 TfLiteRegistration* Register_LOGICAL_OR();
128 TfLiteRegistration* Register_LOGICAL_AND();
129 TfLiteRegistration* Register_LOGICAL_NOT();
130 TfLiteRegistration* Register_UNPACK();
131 TfLiteRegistration* Register_FLOOR_DIV();
132 TfLiteRegistration* Register_SQUARE();
133 TfLiteRegistration* Register_ZEROS_LIKE();
134 TfLiteRegistration* Register_FLOOR_MOD();
135 TfLiteRegistration* Register_RANGE();
136 TfLiteRegistration* Register_LEAKY_RELU();
137 TfLiteRegistration* Register_SQUARED_DIFFERENCE();
138 TfLiteRegistration* Register_FILL();
139 TfLiteRegistration* Register_MIRROR_PAD();
140 TfLiteRegistration* Register_UNIQUE();
141 TfLiteRegistration* Register_REVERSE_V2();
142 TfLiteRegistration* Register_ADD_N();
143 TfLiteRegistration* Register_GATHER_ND();
144 TfLiteRegistration* Register_WHERE();
145 TfLiteRegistration* Register_REVERSE_SEQUENCE();
146 TfLiteRegistration* Register_MATRIX_DIAG();
147 TfLiteRegistration* Register_QUANTIZE_REF();
148 TfLiteRegistration* Register_MATRIX_SET_DIAG();
149 TfLiteRegistration* Register_IF();
150 TfLiteRegistration* Register_WHILE();
151 TfLiteRegistration* Register_NON_MAX_SUPPRESSION_V4();
152 TfLiteRegistration* Register_NON_MAX_SUPPRESSION_V5();
153 TfLiteRegistration* Register_SCATTER_ND();
154 TfLiteRegistration* Register_DENSIFY();
155 TfLiteRegistration* Register_BATCH_MATMUL_REF();
156 TfLiteRegistration* Register_HARD_SWISH_REF();
157 TfLiteRegistration* Register_DEPTH_TO_SPACE_REF();
158 TfLiteRegistration* Register_SELECT_V2();
159 TfLiteRegistration* Register_SEGMENT_SUM();
160 TfLiteRegistration* Register_BROADCAST_TO();
161 TfLiteRegistration* Register_CONV_3D_REF();
162 TfLiteRegistration* Register_IMAG();
163 TfLiteRegistration* Register_REAL();
164 TfLiteRegistration* Register_COMPLEX_ABS();
165 TfLiteRegistration* Register_CONV_3D_TRANSPOSE_REF();
166 TfLiteRegistration* Register_BROADCAST_ARGS();
167
168 namespace {
169
UnsupportedTensorFlowOp(TfLiteContext * context,TfLiteNode * node)170 TfLiteStatus UnsupportedTensorFlowOp(TfLiteContext* context, TfLiteNode* node) {
171 context->ReportError(
172 context,
173 "Regular TensorFlow ops are not supported by this interpreter. Make sure "
174 "you invoke the Flex delegate before inference.");
175 return kTfLiteError;
176 }
177
178 } // namespace
179
FindOp(tflite::BuiltinOperator op,int version) const180 const TfLiteRegistration* BuiltinRefOpResolver::FindOp(
181 tflite::BuiltinOperator op, int version) const {
182 return MutableOpResolver::FindOp(op, version);
183 }
184
FindOp(const char * op,int version) const185 const TfLiteRegistration* BuiltinRefOpResolver::FindOp(const char* op,
186 int version) const {
187 // Return the NULL Op for all ops whose name start with "Flex", allowing
188 // the interpreter to delegate their execution.
189 if (IsFlexOp(op)) {
190 static TfLiteRegistration null_op{
191 nullptr, nullptr, &UnsupportedTensorFlowOp,
192 nullptr, nullptr, BuiltinOperator_CUSTOM,
193 "Flex", 1};
194 return &null_op;
195 }
196 return MutableOpResolver::FindOp(op, version);
197 }
198
BuiltinRefOpResolver()199 BuiltinRefOpResolver::BuiltinRefOpResolver() {
200 AddBuiltin(BuiltinOperator_ABS, Register_ABS(), /* min_version = */ 1,
201 /* max_version = */ 3);
202 AddBuiltin(BuiltinOperator_HARD_SWISH, Register_HARD_SWISH_REF());
203 AddBuiltin(BuiltinOperator_RELU, Register_RELU(), /* min_version = */ 1,
204 /* max_version = */ 3);
205 AddBuiltin(BuiltinOperator_RELU_N1_TO_1, Register_RELU_N1_TO_1());
206 AddBuiltin(BuiltinOperator_RELU6, Register_RELU6(), /* min_version = */ 1,
207 /* max_version = */ 3);
208 AddBuiltin(BuiltinOperator_TANH, Register_TANH_REF(), /* min_version = */ 1,
209 /* max_version = */ 3);
210 AddBuiltin(BuiltinOperator_LOGISTIC, Register_LOGISTIC_REF(),
211 /* min_version = */ 1,
212 /* max_version = */ 3);
213 AddBuiltin(BuiltinOperator_AVERAGE_POOL_2D, Register_AVERAGE_POOL_REF(),
214 /* min_version = */ 1,
215 /* max_version = */ 3);
216 AddBuiltin(BuiltinOperator_MAX_POOL_2D, Register_MAX_POOL_REF(),
217 /* min_version = */ 1,
218 /* max_version = */ 3);
219 AddBuiltin(BuiltinOperator_L2_POOL_2D, Register_L2_POOL_REF());
220 AddBuiltin(BuiltinOperator_CONV_2D, Register_CONVOLUTION_REF(),
221 /* min_version = */ 1,
222 /* max_version = */ 5);
223 AddBuiltin(BuiltinOperator_DEPTHWISE_CONV_2D,
224 Register_DEPTHWISE_CONVOLUTION_REF(),
225 /* min_version = */ 1,
226 /* max_version = */ 6);
227 AddBuiltin(BuiltinOperator_SVDF, Register_SVDF(),
228 /* min_version = */ 1,
229 /* max_version = */ 4);
230 AddBuiltin(BuiltinOperator_RNN, Register_RNN(),
231 /* min_version = */ 1,
232 /* max_version = */ 3);
233 AddBuiltin(BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN,
234 Register_BIDIRECTIONAL_SEQUENCE_RNN(),
235 /* min_version = */ 1,
236 /* max_version = */ 3);
237 AddBuiltin(BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN,
238 Register_UNIDIRECTIONAL_SEQUENCE_RNN(),
239 /* min_version = */ 1,
240 /* max_version = */ 3);
241 AddBuiltin(BuiltinOperator_EMBEDDING_LOOKUP, Register_EMBEDDING_LOOKUP(),
242 /* min_version = */ 1,
243 /* max_version = */ 3);
244 AddBuiltin(BuiltinOperator_EMBEDDING_LOOKUP_SPARSE,
245 Register_EMBEDDING_LOOKUP_SPARSE());
246 AddBuiltin(BuiltinOperator_FULLY_CONNECTED, Register_FULLY_CONNECTED_REF(),
247 /* min_version */ 1,
248 /* max_version */ 9);
249 AddBuiltin(BuiltinOperator_LSH_PROJECTION, Register_LSH_PROJECTION());
250 AddBuiltin(BuiltinOperator_HASHTABLE_LOOKUP, Register_HASHTABLE_LOOKUP());
251 AddBuiltin(BuiltinOperator_SOFTMAX, Register_SOFTMAX_REF(),
252 /* min_version = */ 1,
253 /* max_version = */ 3);
254 AddBuiltin(BuiltinOperator_CONCATENATION, Register_CONCATENATION_REF(),
255 /* min_version = */ 1,
256 /* max_version = */ 3);
257 AddBuiltin(BuiltinOperator_ADD, Register_ADD_REF(),
258 /* min_version */ 1,
259 /* max_version */ 4);
260 AddBuiltin(BuiltinOperator_SPACE_TO_BATCH_ND,
261 Register_SPACE_TO_BATCH_ND_REF(),
262 /* min_version = */ 1,
263 /* max_version = */ 3);
264 AddBuiltin(BuiltinOperator_BATCH_TO_SPACE_ND,
265 Register_BATCH_TO_SPACE_ND_REF(),
266 /* min_version = */ 1,
267 /* max_version = */ 3);
268 AddBuiltin(BuiltinOperator_MUL, Register_MUL_REF(), /* min_version = */ 1,
269 /* max_version = */ 5);
270 AddBuiltin(BuiltinOperator_L2_NORMALIZATION, Register_L2NORM_REF(),
271 /* min_version = */ 1,
272 /* max_version = */ 2);
273 // The version one of broadcast to op won't be not supported since the version
274 // one was rollbacked and the builtin op code number has been changed because
275 // of builtin op code shortage problem.
276 AddBuiltin(BuiltinOperator_BROADCAST_TO, Register_BROADCAST_TO(),
277 /* min_version = */ 2,
278 /* max_version = */ 3);
279 AddBuiltin(BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION,
280 Register_LOCAL_RESPONSE_NORM_REF());
281 AddBuiltin(BuiltinOperator_LSTM, Register_LSTM(), /* min_version */ 1,
282 /* max_version */ 4);
283 AddBuiltin(BuiltinOperator_BIDIRECTIONAL_SEQUENCE_LSTM,
284 Register_BIDIRECTIONAL_SEQUENCE_LSTM(), /* min_version */ 1,
285 /* max_version */ 3);
286 AddBuiltin(BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM,
287 Register_UNIDIRECTIONAL_SEQUENCE_LSTM(), /* min_version = */ 1,
288 /* max_version = */ 3);
289 AddBuiltin(BuiltinOperator_PAD, Register_PAD_REF(), /* min_version = */ 1,
290 /* max_version = */ 4);
291 AddBuiltin(BuiltinOperator_PADV2, Register_PADV2_REF(), /* min_version = */ 1,
292 /* max_version = */ 4);
293 AddBuiltin(BuiltinOperator_RESHAPE, Register_RESHAPE());
294 AddBuiltin(BuiltinOperator_RESIZE_BILINEAR, Register_RESIZE_BILINEAR_REF(),
295 /* min_version = */ 1,
296 /* max_version = */ 4);
297 AddBuiltin(BuiltinOperator_RESIZE_NEAREST_NEIGHBOR,
298 Register_RESIZE_NEAREST_NEIGHBOR_REF(),
299 /* min_version = */ 1,
300 /* max_version = */ 4);
301 AddBuiltin(BuiltinOperator_SKIP_GRAM, Register_SKIP_GRAM());
302 AddBuiltin(BuiltinOperator_SPACE_TO_DEPTH, Register_SPACE_TO_DEPTH_REF(),
303 /* min_version = */ 1,
304 /* max_version = */ 2);
305 AddBuiltin(BuiltinOperator_DEPTH_TO_SPACE, Register_DEPTH_TO_SPACE_REF());
306 AddBuiltin(BuiltinOperator_GATHER, Register_GATHER(),
307 /* min_version = */ 1,
308 /* max_version = */ 4);
309 AddBuiltin(BuiltinOperator_TRANSPOSE, Register_TRANSPOSE_REF(),
310 /* min_version = */ 1,
311 /* max_version = */ 5);
312 AddBuiltin(BuiltinOperator_MEAN, Register_MEAN_REF(),
313 /* min_version = */ 1,
314 /* max_version = */ 3);
315 AddBuiltin(BuiltinOperator_DIV, Register_DIV_REF(),
316 /* min_version = */ 1,
317 /* max_version = */ 2);
318 AddBuiltin(BuiltinOperator_SUB, Register_SUB_REF(),
319 /* min_version = */ 1,
320 /* max_version = */ 5);
321 AddBuiltin(BuiltinOperator_SPLIT, Register_SPLIT(),
322 /* min_version = */ 1,
323 /* max_version = */ 4);
324 AddBuiltin(BuiltinOperator_SPLIT_V, Register_SPLIT_V(),
325 /* min_version = */ 1,
326 /* max_version = */ 2);
327 AddBuiltin(BuiltinOperator_SQUEEZE, Register_SQUEEZE());
328 AddBuiltin(BuiltinOperator_STRIDED_SLICE, Register_STRIDED_SLICE_REF(),
329 /* min_version = */ 1,
330 /* max_version = */ 4);
331 AddBuiltin(BuiltinOperator_EXP, Register_EXP_REF());
332 AddBuiltin(BuiltinOperator_TOPK_V2, Register_TOPK_V2(),
333 /* min_version = */ 1,
334 /* max_version = */ 2);
335 AddBuiltin(BuiltinOperator_LOG, Register_LOG());
336 AddBuiltin(BuiltinOperator_LOG_SOFTMAX, Register_LOG_SOFTMAX_REF(),
337 /* min_version = */ 1,
338 /* max_version = */ 2);
339 AddBuiltin(BuiltinOperator_CAST, Register_CAST());
340 AddBuiltin(BuiltinOperator_DEQUANTIZE, Register_DEQUANTIZE_REF(),
341 /* min_version = */ 1,
342 /* max_version = */ 4);
343 AddBuiltin(BuiltinOperator_PRELU, Register_PRELU_REF());
344 AddBuiltin(BuiltinOperator_MAXIMUM, Register_MAXIMUM_REF(),
345 /* min_version = */ 1,
346 /* max_version = */ 4);
347 AddBuiltin(BuiltinOperator_MINIMUM, Register_MINIMUM_REF(),
348 /* min_version = */ 1,
349 /* max_version = */ 4);
350 AddBuiltin(BuiltinOperator_ARG_MAX, Register_ARG_MAX(),
351 /* min_version = */ 1,
352 /* max_version = */ 2);
353 AddBuiltin(BuiltinOperator_ARG_MIN, Register_ARG_MIN(),
354 /* min_version = */ 1,
355 /* max_version = */ 2);
356 AddBuiltin(BuiltinOperator_GREATER, Register_GREATER(),
357 /* min_version = */ 1,
358 /* max_version = */ 2);
359 AddBuiltin(BuiltinOperator_GREATER_EQUAL, Register_GREATER_EQUAL(),
360 /* min_version = */ 1,
361 /* max_version = */ 2);
362 AddBuiltin(BuiltinOperator_LESS, Register_LESS(),
363 /* min_version = */ 1,
364 /* max_version = */ 2);
365 AddBuiltin(BuiltinOperator_LESS_EQUAL, Register_LESS_EQUAL(),
366 /* min_version = */ 1,
367 /* max_version = */ 2);
368 AddBuiltin(BuiltinOperator_FLOOR, Register_FLOOR_REF());
369 AddBuiltin(BuiltinOperator_NEG, Register_NEG());
370 AddBuiltin(BuiltinOperator_SELECT, Register_SELECT(),
371 /* min_version = */ 1,
372 /* max_version = */ 2);
373 AddBuiltin(BuiltinOperator_SELECT_V2, Register_SELECT_V2());
374 AddBuiltin(BuiltinOperator_SLICE, Register_SLICE_REF(),
375 /* min_version = */ 1,
376 /* max_version = */ 5);
377 AddBuiltin(BuiltinOperator_SIN, Register_SIN());
378 AddBuiltin(BuiltinOperator_COS, Register_COS());
379 AddBuiltin(BuiltinOperator_TRANSPOSE_CONV, Register_TRANSPOSECONV_REF(),
380 /* min_version = */ 1,
381 /* max_version = */ 3);
382 AddBuiltin(BuiltinOperator_TILE, Register_TILE(),
383 /* min_version = */ 1,
384 /* max_version = */ 2);
385 AddBuiltin(BuiltinOperator_SUM, Register_SUM_REF(),
386 /* min_version = */ 1,
387 /* max_version = */ 2);
388 AddBuiltin(BuiltinOperator_REDUCE_PROD, Register_REDUCE_PROD_REF(),
389 /* min_version = */ 1,
390 /* max_version = */ 2);
391 AddBuiltin(BuiltinOperator_REDUCE_MAX, Register_REDUCE_MAX_REF(),
392 /* min_version = */ 1,
393 /* max_version = */ 3);
394 AddBuiltin(BuiltinOperator_REDUCE_MIN, Register_REDUCE_MIN_REF(),
395 /* min_version = */ 1,
396 /* max_version = */ 3);
397 AddBuiltin(BuiltinOperator_REDUCE_ANY, Register_REDUCE_ANY_REF());
398 AddBuiltin(BuiltinOperator_REDUCE_ALL, Register_REDUCE_ALL_REF());
399 AddBuiltin(BuiltinOperator_EXPAND_DIMS, Register_EXPAND_DIMS());
400 AddBuiltin(BuiltinOperator_SPARSE_TO_DENSE, Register_SPARSE_TO_DENSE(),
401 /* min_version = */ 1,
402 /* max_version = */ 3);
403 AddBuiltin(BuiltinOperator_EQUAL, Register_EQUAL(),
404 /* min_version = */ 1,
405 /* max_version = */ 3);
406 AddBuiltin(BuiltinOperator_NOT_EQUAL, Register_NOT_EQUAL(),
407 /* min_version = */ 1,
408 /* max_version = */ 3);
409 AddBuiltin(BuiltinOperator_SQRT, Register_SQRT());
410 AddBuiltin(BuiltinOperator_RSQRT, Register_RSQRT(),
411 /* min_version = */ 1,
412 /* max_version = */ 2);
413 AddBuiltin(BuiltinOperator_SHAPE, Register_SHAPE());
414 AddBuiltin(BuiltinOperator_RANK, Register_RANK());
415 AddBuiltin(BuiltinOperator_POW, Register_POW());
416 AddBuiltin(BuiltinOperator_FAKE_QUANT, Register_FAKE_QUANT_REF(),
417 /* min_version = */ 1,
418 /* max_version = */ 2);
419 AddBuiltin(BuiltinOperator_PACK, Register_PACK(),
420 /* min_version = */ 1,
421 /* max_version = */ 3);
422 AddBuiltin(BuiltinOperator_ONE_HOT, Register_ONE_HOT());
423 AddBuiltin(BuiltinOperator_LOGICAL_OR, Register_LOGICAL_OR());
424 AddBuiltin(BuiltinOperator_LOGICAL_AND, Register_LOGICAL_AND());
425 AddBuiltin(BuiltinOperator_LOGICAL_NOT, Register_LOGICAL_NOT());
426 AddBuiltin(BuiltinOperator_UNPACK, Register_UNPACK(),
427 /* min_version = */ 1,
428 /* max_version = */ 4);
429 AddBuiltin(BuiltinOperator_FLOOR_DIV, Register_FLOOR_DIV(),
430 /* min_version = */ 1,
431 /* max_version = */ 2);
432 AddBuiltin(BuiltinOperator_SQUARE, Register_SQUARE());
433 AddBuiltin(BuiltinOperator_ZEROS_LIKE, Register_ZEROS_LIKE());
434 AddBuiltin(BuiltinOperator_FLOOR_MOD, Register_FLOOR_MOD());
435 AddBuiltin(BuiltinOperator_RANGE, Register_RANGE());
436 AddBuiltin(BuiltinOperator_LEAKY_RELU, Register_LEAKY_RELU(),
437 /* min_version = */ 1,
438 /* max_version = */ 2);
439 AddBuiltin(BuiltinOperator_SQUARED_DIFFERENCE, Register_SQUARED_DIFFERENCE(),
440 /* min_version = */ 1,
441 /* max_version = */ 2);
442 AddBuiltin(BuiltinOperator_FILL, Register_FILL(),
443 /* min_version = */ 1,
444 /* max_version = */ 3);
445 AddBuiltin(BuiltinOperator_MIRROR_PAD, Register_MIRROR_PAD(),
446 /* min_version = */ 1,
447 /* max_version = */ 2);
448 AddBuiltin(BuiltinOperator_UNIQUE, Register_UNIQUE());
449 AddBuiltin(BuiltinOperator_REVERSE_V2, Register_REVERSE_V2(),
450 /* min_version = */ 1,
451 /* max_version = */ 2);
452 AddBuiltin(BuiltinOperator_ADD_N, Register_ADD_N());
453 AddBuiltin(BuiltinOperator_GATHER_ND, Register_GATHER_ND(),
454 /* min_version = */ 1,
455 /* max_version = */ 3);
456 AddBuiltin(BuiltinOperator_WHERE, Register_WHERE());
457 AddBuiltin(BuiltinOperator_REVERSE_SEQUENCE, Register_REVERSE_SEQUENCE());
458 AddBuiltin(BuiltinOperator_MATRIX_DIAG, Register_MATRIX_DIAG());
459 AddBuiltin(BuiltinOperator_QUANTIZE, Register_QUANTIZE_REF(),
460 /* min_version = */ 1,
461 /* max_version = */ 2);
462 AddBuiltin(BuiltinOperator_MATRIX_SET_DIAG, Register_MATRIX_SET_DIAG());
463 AddBuiltin(BuiltinOperator_IF, Register_IF());
464 AddBuiltin(BuiltinOperator_WHILE, Register_WHILE());
465 AddBuiltin(BuiltinOperator_NON_MAX_SUPPRESSION_V4,
466 Register_NON_MAX_SUPPRESSION_V4());
467 AddBuiltin(BuiltinOperator_NON_MAX_SUPPRESSION_V5,
468 Register_NON_MAX_SUPPRESSION_V5());
469 AddBuiltin(BuiltinOperator_SCATTER_ND, Register_SCATTER_ND());
470 AddBuiltin(BuiltinOperator_DENSIFY, Register_DENSIFY());
471 AddBuiltin(BuiltinOperator_BATCH_MATMUL, Register_BATCH_MATMUL_REF(),
472 /* min_version = */ 1,
473 /* max_version = */ 3);
474 AddBuiltin(BuiltinOperator_CONV_3D, Register_CONV_3D_REF());
475 AddBuiltin(BuiltinOperator_IMAG, Register_IMAG());
476 AddBuiltin(BuiltinOperator_REAL, Register_REAL());
477 AddBuiltin(BuiltinOperator_COMPLEX_ABS, Register_COMPLEX_ABS());
478 AddBuiltin(BuiltinOperator_CONV_3D_TRANSPOSE,
479 Register_CONV_3D_TRANSPOSE_REF());
480 AddBuiltin(BuiltinOperator_BROADCAST_ARGS, Register_BROADCAST_ARGS());
481 AddCustom("NumericVerify",
482 tflite::ops::custom::Register_NUMERIC_VERIFY_REF());
483 // TODO(andrewharp, ahentz): Move these somewhere more appropriate so that
484 // custom ops aren't always included by default.
485 // AddCustom("Mfcc", tflite::ops::custom::Register_MFCC());
486 // AddCustom("AudioSpectrogram",
487 // tflite::ops::custom::Register_AUDIO_SPECTROGRAM());
488 AddCustom("TFLite_Detection_PostProcess",
489 tflite::ops::custom::Register_DETECTION_POSTPROCESS());
490 }
491
492 } // namespace builtin
493 } // namespace ops
494 } // namespace tflite
495