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