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();
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_SELECT();
110 TfLiteRegistration* Register_SLICE_REF();
111 TfLiteRegistration* Register_SIN();
112 TfLiteRegistration* Register_COS();
113 TfLiteRegistration* Register_TRANSPOSECONV_REF();
114 TfLiteRegistration* Register_EXPAND_DIMS();
115 TfLiteRegistration* Register_SPARSE_TO_DENSE();
116 TfLiteRegistration* Register_EQUAL();
117 TfLiteRegistration* Register_NOT_EQUAL();
118 TfLiteRegistration* Register_SQRT();
119 TfLiteRegistration* Register_RSQRT();
120 TfLiteRegistration* Register_SHAPE();
121 TfLiteRegistration* Register_RANK();
122 TfLiteRegistration* Register_POW();
123 TfLiteRegistration* Register_FAKE_QUANT_REF();
124 TfLiteRegistration* Register_PACK();
125 TfLiteRegistration* Register_ONE_HOT();
126 TfLiteRegistration* Register_LOGICAL_OR();
127 TfLiteRegistration* Register_LOGICAL_AND();
128 TfLiteRegistration* Register_LOGICAL_NOT();
129 TfLiteRegistration* Register_UNPACK();
130 TfLiteRegistration* Register_FLOOR_DIV();
131 TfLiteRegistration* Register_SQUARE();
132 TfLiteRegistration* Register_ZEROS_LIKE();
133 TfLiteRegistration* Register_FLOOR_MOD();
134 TfLiteRegistration* Register_RANGE();
135 TfLiteRegistration* Register_LEAKY_RELU();
136 TfLiteRegistration* Register_SQUARED_DIFFERENCE();
137 TfLiteRegistration* Register_FILL();
138 TfLiteRegistration* Register_MIRROR_PAD();
139 TfLiteRegistration* Register_UNIQUE();
140 TfLiteRegistration* Register_REVERSE_V2();
141 TfLiteRegistration* Register_ADD_N();
142 TfLiteRegistration* Register_GATHER_ND();
143 TfLiteRegistration* Register_WHERE();
144 TfLiteRegistration* Register_REVERSE_SEQUENCE();
145 TfLiteRegistration* Register_MATRIX_DIAG();
146 TfLiteRegistration* Register_QUANTIZE_REF();
147 TfLiteRegistration* Register_MATRIX_SET_DIAG();
148 TfLiteRegistration* Register_IF();
149 TfLiteRegistration* Register_WHILE();
150 TfLiteRegistration* Register_NON_MAX_SUPPRESSION_V4();
151 TfLiteRegistration* Register_NON_MAX_SUPPRESSION_V5();
152 TfLiteRegistration* Register_SCATTER_ND();
153 TfLiteRegistration* Register_DENSIFY();
154 TfLiteRegistration* Register_BATCH_MATMUL_REF();
155 TfLiteRegistration* Register_HARD_SWISH_REF();
156 TfLiteRegistration* Register_DEPTH_TO_SPACE_REF();
157 TfLiteRegistration* Register_SELECT_V2();
158 TfLiteRegistration* Register_SEGMENT_SUM();
159 TfLiteRegistration* Register_BROADCAST_TO();
160 TfLiteRegistration* Register_CONV_3D();
161 TfLiteRegistration* Register_IMAG();
162 TfLiteRegistration* Register_REAL();
163 TfLiteRegistration* Register_COMPLEX_ABS();
164
165 namespace {
166
UnsupportedTensorFlowOp(TfLiteContext * context,TfLiteNode * node)167 TfLiteStatus UnsupportedTensorFlowOp(TfLiteContext* context, TfLiteNode* node) {
168 context->ReportError(
169 context,
170 "Regular TensorFlow ops are not supported by this interpreter. Make sure "
171 "you invoke the Flex delegate before inference.");
172 return kTfLiteError;
173 }
174
175 } // namespace
176
FindOp(tflite::BuiltinOperator op,int version) const177 const TfLiteRegistration* BuiltinRefOpResolver::FindOp(
178 tflite::BuiltinOperator op, int version) const {
179 return MutableOpResolver::FindOp(op, version);
180 }
181
FindOp(const char * op,int version) const182 const TfLiteRegistration* BuiltinRefOpResolver::FindOp(const char* op,
183 int version) const {
184 // Return the NULL Op for all ops whose name start with "Flex", allowing
185 // the interpreter to delegate their execution.
186 if (IsFlexOp(op)) {
187 static TfLiteRegistration null_op{
188 nullptr, nullptr, &UnsupportedTensorFlowOp,
189 nullptr, nullptr, BuiltinOperator_CUSTOM,
190 "Flex", 1};
191 return &null_op;
192 }
193 return MutableOpResolver::FindOp(op, version);
194 }
195
BuiltinRefOpResolver()196 BuiltinRefOpResolver::BuiltinRefOpResolver() {
197 AddBuiltin(BuiltinOperator_ABS, Register_ABS(), /* min_version = */ 1,
198 /* max_version = */ 3);
199 AddBuiltin(BuiltinOperator_HARD_SWISH, Register_HARD_SWISH_REF());
200 AddBuiltin(BuiltinOperator_RELU, Register_RELU(), /* min_version = */ 1,
201 /* max_version = */ 3);
202 AddBuiltin(BuiltinOperator_RELU_N1_TO_1, Register_RELU_N1_TO_1());
203 AddBuiltin(BuiltinOperator_RELU6, Register_RELU6(), /* min_version = */ 1,
204 /* max_version = */ 3);
205 AddBuiltin(BuiltinOperator_TANH, Register_TANH_REF(), /* min_version = */ 1,
206 /* max_version = */ 3);
207 AddBuiltin(BuiltinOperator_LOGISTIC, Register_LOGISTIC_REF(),
208 /* min_version = */ 1,
209 /* max_version = */ 3);
210 AddBuiltin(BuiltinOperator_AVERAGE_POOL_2D, Register_AVERAGE_POOL_REF(),
211 /* min_version = */ 1,
212 /* max_version = */ 3);
213 AddBuiltin(BuiltinOperator_MAX_POOL_2D, Register_MAX_POOL_REF(),
214 /* min_version = */ 1,
215 /* max_version = */ 3);
216 AddBuiltin(BuiltinOperator_L2_POOL_2D, Register_L2_POOL_REF());
217 AddBuiltin(BuiltinOperator_CONV_2D, Register_CONVOLUTION_REF(),
218 /* min_version = */ 1,
219 /* max_version = */ 5);
220 AddBuiltin(BuiltinOperator_DEPTHWISE_CONV_2D,
221 Register_DEPTHWISE_CONVOLUTION_REF(),
222 /* min_version = */ 1,
223 /* max_version = */ 6);
224 AddBuiltin(BuiltinOperator_SVDF, Register_SVDF(),
225 /* min_version = */ 1,
226 /* max_version = */ 4);
227 AddBuiltin(BuiltinOperator_RNN, Register_RNN(),
228 /* min_version = */ 1,
229 /* max_version = */ 3);
230 AddBuiltin(BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN,
231 Register_BIDIRECTIONAL_SEQUENCE_RNN(),
232 /* min_version = */ 1,
233 /* max_version = */ 3);
234 AddBuiltin(BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN,
235 Register_UNIDIRECTIONAL_SEQUENCE_RNN(),
236 /* min_version = */ 1,
237 /* max_version = */ 3);
238 AddBuiltin(BuiltinOperator_EMBEDDING_LOOKUP, Register_EMBEDDING_LOOKUP(),
239 /* min_version = */ 1,
240 /* max_version = */ 3);
241 AddBuiltin(BuiltinOperator_EMBEDDING_LOOKUP_SPARSE,
242 Register_EMBEDDING_LOOKUP_SPARSE());
243 AddBuiltin(BuiltinOperator_FULLY_CONNECTED, Register_FULLY_CONNECTED_REF(),
244 /* min_version */ 1,
245 /* max_version */ 9);
246 AddBuiltin(BuiltinOperator_LSH_PROJECTION, Register_LSH_PROJECTION());
247 AddBuiltin(BuiltinOperator_HASHTABLE_LOOKUP, Register_HASHTABLE_LOOKUP());
248 AddBuiltin(BuiltinOperator_SOFTMAX, Register_SOFTMAX(),
249 /* min_version = */ 1,
250 /* max_version = */ 3);
251 AddBuiltin(BuiltinOperator_CONCATENATION, Register_CONCATENATION_REF(),
252 /* min_version = */ 1,
253 /* max_version = */ 3);
254 AddBuiltin(BuiltinOperator_ADD, Register_ADD_REF(),
255 /* min_version */ 1,
256 /* max_version */ 4);
257 AddBuiltin(BuiltinOperator_SPACE_TO_BATCH_ND,
258 Register_SPACE_TO_BATCH_ND_REF(),
259 /* min_version = */ 1,
260 /* max_version = */ 3);
261 AddBuiltin(BuiltinOperator_BATCH_TO_SPACE_ND,
262 Register_BATCH_TO_SPACE_ND_REF(),
263 /* min_version = */ 1,
264 /* max_version = */ 3);
265 AddBuiltin(BuiltinOperator_MUL, Register_MUL_REF(), /* min_version = */ 1,
266 /* max_version = */ 4);
267 AddBuiltin(BuiltinOperator_L2_NORMALIZATION, Register_L2NORM_REF(),
268 /* min_version = */ 1,
269 /* max_version = */ 2);
270 // The version one of broadcast to op won't be not supported since the version
271 // one was rollbacked and the builtin op code number has been changed because
272 // of builtin op code shortage problem.
273 AddBuiltin(BuiltinOperator_BROADCAST_TO, Register_BROADCAST_TO(),
274 /* min_version = */ 2,
275 /* max_version = */ 3);
276 AddBuiltin(BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION,
277 Register_LOCAL_RESPONSE_NORM_REF());
278 AddBuiltin(BuiltinOperator_LSTM, Register_LSTM(), /* min_version */ 1,
279 /* max_version */ 4);
280 AddBuiltin(BuiltinOperator_BIDIRECTIONAL_SEQUENCE_LSTM,
281 Register_BIDIRECTIONAL_SEQUENCE_LSTM(), /* min_version */ 1,
282 /* max_version */ 3);
283 AddBuiltin(BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM,
284 Register_UNIDIRECTIONAL_SEQUENCE_LSTM(), /* min_version = */ 1,
285 /* max_version = */ 3);
286 AddBuiltin(BuiltinOperator_PAD, Register_PAD_REF(), /* min_version = */ 1,
287 /* max_version = */ 3);
288 AddBuiltin(BuiltinOperator_PADV2, Register_PADV2_REF(), /* min_version = */ 1,
289 /* max_version = */ 3);
290 AddBuiltin(BuiltinOperator_RESHAPE, Register_RESHAPE());
291 AddBuiltin(BuiltinOperator_RESIZE_BILINEAR, Register_RESIZE_BILINEAR_REF(),
292 /* min_version = */ 1,
293 /* max_version = */ 4);
294 AddBuiltin(BuiltinOperator_RESIZE_NEAREST_NEIGHBOR,
295 Register_RESIZE_NEAREST_NEIGHBOR_REF(),
296 /* min_version = */ 1,
297 /* max_version = */ 4);
298 AddBuiltin(BuiltinOperator_SKIP_GRAM, Register_SKIP_GRAM());
299 AddBuiltin(BuiltinOperator_SPACE_TO_DEPTH, Register_SPACE_TO_DEPTH_REF(),
300 /* min_version = */ 1,
301 /* max_version = */ 2);
302 AddBuiltin(BuiltinOperator_DEPTH_TO_SPACE, Register_DEPTH_TO_SPACE_REF());
303 AddBuiltin(BuiltinOperator_GATHER, Register_GATHER(),
304 /* min_version = */ 1,
305 /* max_version = */ 4);
306 AddBuiltin(BuiltinOperator_TRANSPOSE, Register_TRANSPOSE_REF(),
307 /* min_version = */ 1,
308 /* max_version = */ 5);
309 AddBuiltin(BuiltinOperator_MEAN, Register_MEAN_REF(),
310 /* min_version = */ 1,
311 /* max_version = */ 3);
312 AddBuiltin(BuiltinOperator_DIV, Register_DIV_REF(),
313 /* min_version = */ 1,
314 /* max_version = */ 2);
315 AddBuiltin(BuiltinOperator_SUB, Register_SUB_REF(),
316 /* min_version = */ 1,
317 /* max_version = */ 5);
318 AddBuiltin(BuiltinOperator_SPLIT, Register_SPLIT(),
319 /* min_version = */ 1,
320 /* max_version = */ 4);
321 AddBuiltin(BuiltinOperator_SPLIT_V, Register_SPLIT_V(),
322 /* min_version = */ 1,
323 /* max_version = */ 2);
324 AddBuiltin(BuiltinOperator_SQUEEZE, Register_SQUEEZE());
325 AddBuiltin(BuiltinOperator_STRIDED_SLICE, Register_STRIDED_SLICE_REF(),
326 /* min_version = */ 1,
327 /* max_version = */ 4);
328 AddBuiltin(BuiltinOperator_EXP, Register_EXP_REF());
329 AddBuiltin(BuiltinOperator_TOPK_V2, Register_TOPK_V2(),
330 /* min_version = */ 1,
331 /* max_version = */ 2);
332 AddBuiltin(BuiltinOperator_LOG, Register_LOG());
333 AddBuiltin(BuiltinOperator_LOG_SOFTMAX, Register_LOG_SOFTMAX_REF(),
334 /* min_version = */ 1,
335 /* max_version = */ 2);
336 AddBuiltin(BuiltinOperator_CAST, Register_CAST());
337 AddBuiltin(BuiltinOperator_DEQUANTIZE, Register_DEQUANTIZE_REF(),
338 /* min_version = */ 1,
339 /* max_version = */ 4);
340 AddBuiltin(BuiltinOperator_PRELU, Register_PRELU_REF());
341 AddBuiltin(BuiltinOperator_MAXIMUM, Register_MAXIMUM_REF(),
342 /* min_version = */ 1,
343 /* max_version = */ 4);
344 AddBuiltin(BuiltinOperator_MINIMUM, Register_MINIMUM_REF(),
345 /* min_version = */ 1,
346 /* max_version = */ 4);
347 AddBuiltin(BuiltinOperator_ARG_MAX, Register_ARG_MAX(),
348 /* min_version = */ 1,
349 /* max_version = */ 2);
350 AddBuiltin(BuiltinOperator_ARG_MIN, Register_ARG_MIN(),
351 /* min_version = */ 1,
352 /* max_version = */ 2);
353 AddBuiltin(BuiltinOperator_GREATER, Register_GREATER(),
354 /* min_version = */ 1,
355 /* max_version = */ 2);
356 AddBuiltin(BuiltinOperator_GREATER_EQUAL, Register_GREATER_EQUAL(),
357 /* min_version = */ 1,
358 /* max_version = */ 2);
359 AddBuiltin(BuiltinOperator_LESS, Register_LESS(),
360 /* min_version = */ 1,
361 /* max_version = */ 2);
362 AddBuiltin(BuiltinOperator_LESS_EQUAL, Register_LESS_EQUAL(),
363 /* min_version = */ 1,
364 /* max_version = */ 2);
365 AddBuiltin(BuiltinOperator_FLOOR, Register_FLOOR_REF());
366 AddBuiltin(BuiltinOperator_NEG, Register_NEG());
367 AddBuiltin(BuiltinOperator_SELECT, Register_SELECT(),
368 /* min_version = */ 1,
369 /* max_version = */ 2);
370 AddBuiltin(BuiltinOperator_SELECT_V2, Register_SELECT_V2());
371 AddBuiltin(BuiltinOperator_SLICE, Register_SLICE_REF(),
372 /* min_version = */ 1,
373 /* max_version = */ 5);
374 AddBuiltin(BuiltinOperator_SIN, Register_SIN());
375 AddBuiltin(BuiltinOperator_COS, Register_COS());
376 AddBuiltin(BuiltinOperator_TRANSPOSE_CONV, Register_TRANSPOSECONV_REF(),
377 /* min_version = */ 1,
378 /* max_version = */ 3);
379 AddBuiltin(BuiltinOperator_TILE, Register_TILE(),
380 /* min_version = */ 1,
381 /* max_version = */ 2);
382 AddBuiltin(BuiltinOperator_SUM, Register_SUM_REF(),
383 /* min_version = */ 1,
384 /* max_version = */ 2);
385 AddBuiltin(BuiltinOperator_REDUCE_PROD, Register_REDUCE_PROD_REF());
386 AddBuiltin(BuiltinOperator_REDUCE_MAX, Register_REDUCE_MAX_REF(),
387 /* min_version = */ 1,
388 /* max_version = */ 3);
389 AddBuiltin(BuiltinOperator_REDUCE_MIN, Register_REDUCE_MIN_REF(),
390 /* min_version = */ 1,
391 /* max_version = */ 3);
392 AddBuiltin(BuiltinOperator_REDUCE_ANY, Register_REDUCE_ANY_REF());
393 AddBuiltin(BuiltinOperator_EXPAND_DIMS, Register_EXPAND_DIMS());
394 AddBuiltin(BuiltinOperator_SPARSE_TO_DENSE, Register_SPARSE_TO_DENSE(),
395 /* min_version = */ 1,
396 /* max_version = */ 3);
397 AddBuiltin(BuiltinOperator_EQUAL, Register_EQUAL(),
398 /* min_version = */ 1,
399 /* max_version = */ 3);
400 AddBuiltin(BuiltinOperator_NOT_EQUAL, Register_NOT_EQUAL(),
401 /* min_version = */ 1,
402 /* max_version = */ 3);
403 AddBuiltin(BuiltinOperator_SQRT, Register_SQRT());
404 AddBuiltin(BuiltinOperator_RSQRT, Register_RSQRT(),
405 /* min_version = */ 1,
406 /* max_version = */ 2);
407 AddBuiltin(BuiltinOperator_SHAPE, Register_SHAPE());
408 AddBuiltin(BuiltinOperator_RANK, Register_RANK());
409 AddBuiltin(BuiltinOperator_POW, Register_POW());
410 AddBuiltin(BuiltinOperator_FAKE_QUANT, Register_FAKE_QUANT_REF(),
411 /* min_version = */ 1,
412 /* max_version = */ 2);
413 AddBuiltin(BuiltinOperator_PACK, Register_PACK(),
414 /* min_version = */ 1,
415 /* max_version = */ 3);
416 AddBuiltin(BuiltinOperator_ONE_HOT, Register_ONE_HOT());
417 AddBuiltin(BuiltinOperator_LOGICAL_OR, Register_LOGICAL_OR());
418 AddBuiltin(BuiltinOperator_LOGICAL_AND, Register_LOGICAL_AND());
419 AddBuiltin(BuiltinOperator_LOGICAL_NOT, Register_LOGICAL_NOT());
420 AddBuiltin(BuiltinOperator_UNPACK, Register_UNPACK(),
421 /* min_version = */ 1,
422 /* max_version = */ 4);
423 AddBuiltin(BuiltinOperator_FLOOR_DIV, Register_FLOOR_DIV(),
424 /* min_version = */ 1,
425 /* max_version = */ 2);
426 AddBuiltin(BuiltinOperator_SQUARE, Register_SQUARE());
427 AddBuiltin(BuiltinOperator_ZEROS_LIKE, Register_ZEROS_LIKE());
428 AddBuiltin(BuiltinOperator_FLOOR_MOD, Register_FLOOR_MOD());
429 AddBuiltin(BuiltinOperator_RANGE, Register_RANGE());
430 AddBuiltin(BuiltinOperator_LEAKY_RELU, Register_LEAKY_RELU(),
431 /* min_version = */ 1,
432 /* max_version = */ 2);
433 AddBuiltin(BuiltinOperator_SQUARED_DIFFERENCE, Register_SQUARED_DIFFERENCE(),
434 /* min_version = */ 1,
435 /* max_version = */ 2);
436 AddBuiltin(BuiltinOperator_FILL, Register_FILL(),
437 /* min_version = */ 1,
438 /* max_version = */ 3);
439 AddBuiltin(BuiltinOperator_MIRROR_PAD, Register_MIRROR_PAD(),
440 /* min_version = */ 1,
441 /* max_version = */ 2);
442 AddBuiltin(BuiltinOperator_UNIQUE, Register_UNIQUE());
443 AddBuiltin(BuiltinOperator_REVERSE_V2, Register_REVERSE_V2(),
444 /* min_version = */ 1,
445 /* max_version = */ 2);
446 AddBuiltin(BuiltinOperator_ADD_N, Register_ADD_N());
447 AddBuiltin(BuiltinOperator_GATHER_ND, Register_GATHER_ND(),
448 /* min_version = */ 1,
449 /* max_version = */ 3);
450 AddBuiltin(BuiltinOperator_WHERE, Register_WHERE());
451 AddBuiltin(BuiltinOperator_REVERSE_SEQUENCE, Register_REVERSE_SEQUENCE());
452 AddBuiltin(BuiltinOperator_MATRIX_DIAG, Register_MATRIX_DIAG());
453 AddBuiltin(BuiltinOperator_QUANTIZE, Register_QUANTIZE_REF(),
454 /* min_version = */ 1,
455 /* max_version = */ 2);
456 AddBuiltin(BuiltinOperator_MATRIX_SET_DIAG, Register_MATRIX_SET_DIAG());
457 AddBuiltin(BuiltinOperator_IF, Register_IF());
458 AddBuiltin(BuiltinOperator_WHILE, Register_WHILE());
459 AddBuiltin(BuiltinOperator_NON_MAX_SUPPRESSION_V4,
460 Register_NON_MAX_SUPPRESSION_V4());
461 AddBuiltin(BuiltinOperator_NON_MAX_SUPPRESSION_V5,
462 Register_NON_MAX_SUPPRESSION_V5());
463 AddBuiltin(BuiltinOperator_SCATTER_ND, Register_SCATTER_ND());
464 AddBuiltin(BuiltinOperator_DENSIFY, Register_DENSIFY());
465 AddBuiltin(BuiltinOperator_BATCH_MATMUL, Register_BATCH_MATMUL_REF(),
466 /* min_version = */ 1,
467 /* max_version = */ 3);
468 AddBuiltin(BuiltinOperator_CONV_3D, Register_CONV_3D());
469 AddBuiltin(BuiltinOperator_IMAG, Register_IMAG());
470 AddBuiltin(BuiltinOperator_REAL, Register_REAL());
471 AddBuiltin(BuiltinOperator_COMPLEX_ABS, Register_COMPLEX_ABS());
472 AddCustom("NumericVerify",
473 tflite::ops::custom::Register_NUMERIC_VERIFY_REF());
474 // TODO(andrewharp, ahentz): Move these somewhere more appropriate so that
475 // custom ops aren't always included by default.
476 // AddCustom("Mfcc", tflite::ops::custom::Register_MFCC());
477 // AddCustom("AudioSpectrogram",
478 // tflite::ops::custom::Register_AUDIO_SPECTROGRAM());
479 AddCustom("TFLite_Detection_PostProcess",
480 tflite::ops::custom::Register_DETECTION_POSTPROCESS());
481 }
482
483 } // namespace builtin
484 } // namespace ops
485 } // namespace tflite
486