res/TensorFlowLiteSchema/2.10.1/schema.fbs

   1 // Copyright 2017 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 // Revision History
  16 // Version 0: Initial version.
  17 // Version 1: Add subgraphs to schema.
  18 // Version 2: Rename operators to conform to NN API.
  19 // Version 3: Move buffer data from Model.Subgraph.Tensors to Model.Buffers.
  20 // Version 3a: Add new builtin op code field. Has backward compatibility with
  21 //             version 3.
  22 // Version 3b: Rename fields in SignatureDef. Has backward compatibility with
  23 //             version 3 and 3a.
  24
  25 namespace tflite;
  26
  27 // This corresponds to the version.
  28 file_identifier "TFL3";
  29 // File extension of any written files.
  30 file_extension "tflite";
  31
  32 // IMPORTANT: All new members of tables, enums and unions must be added at the
  33 // end to ensure backwards compatibility.
  34
  35 // The type of data stored in a tensor.
  36 enum TensorType : byte {
  37   FLOAT32 = 0,
  38   FLOAT16 = 1,
  39   INT32 = 2,
  40   UINT8 = 3,
  41   INT64 = 4,
  42   STRING = 5,
  43   BOOL = 6,
  44   INT16 = 7,
  45   COMPLEX64 = 8,
  46   INT8 = 9,
  47   FLOAT64 = 10,
  48   COMPLEX128 = 11,
  49   UINT64 = 12,
  50   // Experimental: Resource and variant types are experimental, that are subject
  51   // to change. Do not implement custom kernels using resource & variant types
  52   // now.
  53   RESOURCE = 13,
  54   VARIANT = 14,
  55   UINT32 = 15,
  56   UINT16 = 16
  57 }
  58
  59 // Custom quantization parameters for experimenting with new quantization
  60 // techniques.
  61 table CustomQuantization {
  62   custom:[ubyte] (force_align: 16);
  63 }
  64
  65 // Represents a specific quantization technique's parameters.
  66 union QuantizationDetails {
  67   CustomQuantization,
  68 }
  69
  70 // Parameters for converting a quantized tensor back to float.
  71 table QuantizationParameters {
  72   // These four parameters are the asymmetric linear quantization parameters.
  73   // Given a quantized value q, the corresponding float value f should be:
  74   //   f = scale * (q - zero_point)
  75   // For other quantization types, the QuantizationDetails below is used.
  76   min:[float];  // For importing back into tensorflow.
  77   max:[float];  // For importing back into tensorflow.
  78   scale:[float];  // For dequantizing the tensor's values.
  79   zero_point:[long];
  80
  81   // If this is not none, the other quantization parameters (i.e. min, max,
  82   // scale, zero_point fields above) are ignored and the value of the
  83   // QuantizationDetails union should be used.
  84   details:QuantizationDetails;
  85
  86   // Specifies the dimension of the Tensor's shape that the scales and
  87   // zero_points correspond to. For example, a tensor t, with dims=[4, 3, 2, 1]
  88   // with quantization params:
  89   //   scale=[1.0, 2.0, 3.0], zero_point=[1, 2, 3], quantization_dimension=1
  90   // will be quantized across the second dimension of t.
  91   //   t[:, 0, :, :] will have scale[0]=1.0, zero_point[0]=1
  92   //   t[:, 1, :, :] will have scale[1]=2.0, zero_point[0]=2
  93   //   t[:, 2, :, :] will have scale[2]=3.0, zero_point[0]=3
  94   quantized_dimension:int;
  95 }
  96
  97 // Sparse tensors.
  98 // We use a modification of the TACO format.
  99 // Reference: http://tensor-compiler.org/kjolstad-oopsla17-tensor-compiler.pdf
 100 //
 101 // To encode a conceptual n-dimensional dense tensor with dims (d0, ..., dn-1),
 102 // potentially with a k-dimensional block (0 <= k <= n) with dims
 103 // (dn, ..., dn+k-1), the format needs to specify:
 104 //   1. In what order to traverse these dimensions. For example, to store a 2-D
 105 //      matrix in row major order, the traversal order would be (d0, d1),
 106 //      whereas to store it in column major order, the traversal order would be
 107 //      (d1, d0). If the 2-D matrix has a 2-D inner block, the traversal order
 108 //      could be (d0, d1, d2, d3).
 109 //   2. How each block dimension in (dn, ..., dn+k-1) maps to the original
 110 //      tensor dimension in (d0, ..., dn-1).
 111 //   3. In the traversal order defined above, the format (dense vs. sparse) and
 112 //      index metadata for each dimension. For a dense dimension, this is just
 113 //      the size of that dimension. For a sparse dimension, it's the same as
 114 //      the compressed index defined in the Compressed Sparse Row (CSR) format.
 115 //      (http://scipy-lectures.org/advanced/scipy_sparse/csr_matrix.html)
 116
 117 // The storage type for a dimension. Currently we support:
 118 //   1. DENSE: each coordinate in this dimension is stored implicitly.
 119 //   2. SPARSE_CSR: only the coordinates with non-zero elements are stored. The
 120 //      compression technique is the same what CSR uses.
 121 // More types like a sparse dimension with a different compression technique
 122 // could be added to the list in the future.
 123 enum DimensionType : byte {
 124   DENSE = 0,
 125   SPARSE_CSR = 1,
 126 }
 127
 128 table Int32Vector {
 129   values:[int];
 130 }
 131
 132 table Uint16Vector {
 133   values:[ushort] (force_align: 4);
 134 }
 135
 136 table Uint8Vector {
 137   values:[ubyte] (force_align: 4);
 138 }
 139
 140 // Variable-typed buffer to store the index metadata for a sparse dimension.
 141 // The widest type is Int32 instead of UInt32 because tensor's shape is a int32
 142 // vector. We don't want the per-dimensional index to overflow that range.
 143 union SparseIndexVector {
 144   Int32Vector,
 145   Uint16Vector,
 146   Uint8Vector
 147 }
 148
 149 table DimensionMetadata {
 150   // Whether a dimension is dense or sparse.
 151   format:DimensionType;
 152   // Index metadata used for a dimension.
 153   //   - If format is DimensionType.DENSE then we use the dense_size field to
 154   //     store the size of that dimension. Each index in that dimension is
 155   //     stored implicitly.
 156   //   - If format is DimensionType.SPARSE_CSR then we use array_segments and
 157   //     array_indices to encode that dimension. array_segments represents how
 158   //     to segment the indices array, each segment corresponds to one element
 159   //     in the previous dimension. array_indices represents the index of the
 160   //     non-zero elements within this dimension (as those in the CSR matrix
 161   //     format, where the first array is row pointers and the second array is
 162   //     column indices).
 163   dense_size:int;
 164   array_segments:SparseIndexVector;
 165   array_indices:SparseIndexVector;
 166 }
 167
 168 // Parameters to encode a sparse TfLite tensor.
 169 table SparsityParameters {
 170   // The traversal order of the dimensions defined in the `shape` field of the
 171   // conceptual dense tensor. For a n-dimensional tensors with dims (d0, d1,
 172   // ..., dn-1),
 173   //   - if not block sparse, the traversal_order is just a permutation of (d0,
 174   //     ..., dn-1). For example, a 2-D matrix stored in row-major order would
 175   //     have traversal_order = (d0, d1).
 176   //   - if block sparse with a k-dimensional block (0 <= k <= n), the
 177   //     traversal_order has n + k elements. The first n elements are still a
 178   //     permutation of (d0, ..., dn-1). The lask k elements are a permutation
 179   //     of (dn, ..., dn+k-1), defining how to traverse a block internally. For
 180   //     example, a 2-D matrix with 2-D blocks, both stored in row-major order
 181   //     would have traversal_order = (d0, d1, d2, d3).
 182   traversal_order:[int];
 183   // For an n-dimensional tensor with a k-dimensional block (0 <= k <= n),
 184   // stores how a block dimension in (dn, ..., dn+k-1) maps to the original
 185   // tensor dimension in (d0, ..., dn).
 186   // It's stored in the order of (dn, ..., dn+k-1).
 187   // If not block-sparse, this field is NULL.
 188   block_map:[int];
 189   // In the traversal order defined above, the metadata needed for
 190   // each dimension to locate the non-zero values in the original dense tensor.
 191   // The size of the dim_metadata array = the size of the traversal_order array
 192   // = n + k.
 193   dim_metadata:[DimensionMetadata];
 194 }
 195
 196 table Tensor {
 197   // The tensor shape. The meaning of each entry is operator-specific but
 198   // builtin ops use: [batch size, height, width, number of channels] (That's
 199   // Tensorflow's NHWC).
 200   shape:[int];
 201   type:TensorType;
 202   // An index that refers to the buffers table at the root of the model. Or,
 203   // if there is no data buffer associated (i.e. intermediate results), then
 204   // this is 0 (which refers to an always existent empty buffer).
 205   //
 206   // The data_buffer itself is an opaque container, with the assumption that the
 207   // target device is little-endian. In addition, all builtin operators assume
 208   // the memory is ordered such that if `shape` is [4, 3, 2], then index
 209   // [i, j, k] maps to data_buffer[i*3*2 + j*2 + k].
 210   buffer:uint;
 211   name:string;  // For debugging and importing back into tensorflow.
 212   quantization:QuantizationParameters;  // Optional.
 213
 214   is_variable:bool = false;
 215
 216   // Parameters to encode a sparse tensor. See the example in
 217   // tensorflow/lite/testdata/sparse_tensor.json.
 218   sparsity:SparsityParameters;  // Optional.
 219
 220   // Encodes `shape` with unknown dimensions. Unknown dimensions are
 221   // represented with -1.
 222   shape_signature:[int]; // Optional.
 223
 224   // If false, the rank or the number of tensor dimensions is unknown.
 225   // If false, "shape" must be [].
 226   has_rank: bool = false;
 227 }
 228
 229 // A list of builtin operators. Builtin operators are slightly faster than custom
 230 // ones, but not by much. Moreover, while custom operators accept an opaque
 231 // object containing configuration parameters, builtins have a predetermined
 232 // set of acceptable options.
 233 // LINT.IfChange
 234 enum BuiltinOperator : int32 {
 235   ADD = 0,
 236   AVERAGE_POOL_2D = 1,
 237   CONCATENATION = 2,
 238   CONV_2D = 3,
 239   DEPTHWISE_CONV_2D = 4,
 240   DEPTH_TO_SPACE = 5,
 241   DEQUANTIZE = 6,
 242   EMBEDDING_LOOKUP = 7,
 243   FLOOR = 8,
 244   FULLY_CONNECTED = 9,
 245   HASHTABLE_LOOKUP = 10,
 246   L2_NORMALIZATION = 11,
 247   L2_POOL_2D = 12,
 248   LOCAL_RESPONSE_NORMALIZATION = 13,
 249   LOGISTIC = 14,
 250   LSH_PROJECTION = 15,
 251   LSTM = 16,
 252   MAX_POOL_2D = 17,
 253   MUL = 18,
 254   RELU = 19,
 255   // NOTE(aselle): RELU_N1_TO_1 used to be called RELU1, but it was renamed
 256   // since different model developers use RELU1 in different ways. Never
 257   // create another op called RELU1.
 258   RELU_N1_TO_1 = 20,
 259   RELU6 = 21,
 260   RESHAPE = 22,
 261   RESIZE_BILINEAR = 23,
 262   RNN = 24,
 263   SOFTMAX = 25,
 264   SPACE_TO_DEPTH = 26,
 265   SVDF = 27,
 266   TANH = 28,
 267   CONCAT_EMBEDDINGS = 29,
 268   SKIP_GRAM = 30,
 269   CALL = 31,
 270   CUSTOM = 32,
 271   EMBEDDING_LOOKUP_SPARSE = 33,
 272   PAD = 34,
 273   UNIDIRECTIONAL_SEQUENCE_RNN = 35,
 274   GATHER = 36,
 275   BATCH_TO_SPACE_ND = 37,
 276   SPACE_TO_BATCH_ND = 38,
 277   TRANSPOSE = 39,
 278   MEAN = 40,
 279   SUB = 41,
 280   DIV = 42,
 281   SQUEEZE = 43,
 282   UNIDIRECTIONAL_SEQUENCE_LSTM = 44,
 283   STRIDED_SLICE = 45,
 284   BIDIRECTIONAL_SEQUENCE_RNN = 46,
 285   EXP = 47,
 286   TOPK_V2 = 48,
 287   SPLIT = 49,
 288   LOG_SOFTMAX = 50,
 289   // DELEGATE is a special op type for the operations which are delegated to
 290   // other backends.
 291   // WARNING: Experimental interface, subject to change
 292   DELEGATE = 51,
 293   BIDIRECTIONAL_SEQUENCE_LSTM = 52,
 294   CAST = 53,
 295   PRELU = 54,
 296   MAXIMUM = 55,
 297   ARG_MAX = 56,
 298   MINIMUM = 57,
 299   LESS = 58,
 300   NEG = 59,
 301   PADV2 = 60,
 302   GREATER = 61,
 303   GREATER_EQUAL = 62,
 304   LESS_EQUAL = 63,
 305   SELECT = 64,
 306   SLICE = 65,
 307   SIN = 66,
 308   TRANSPOSE_CONV = 67,
 309   SPARSE_TO_DENSE = 68,
 310   TILE = 69,
 311   EXPAND_DIMS = 70,
 312   EQUAL = 71,
 313   NOT_EQUAL = 72,
 314   LOG = 73,
 315   SUM = 74,
 316   SQRT = 75,
 317   RSQRT = 76,
 318   SHAPE = 77,
 319   POW = 78,
 320   ARG_MIN = 79,
 321   FAKE_QUANT = 80,
 322   REDUCE_PROD = 81,
 323   REDUCE_MAX = 82,
 324   PACK = 83,
 325   LOGICAL_OR = 84,
 326   ONE_HOT = 85,
 327   LOGICAL_AND = 86,
 328   LOGICAL_NOT = 87,
 329   UNPACK = 88,
 330   REDUCE_MIN = 89,
 331   FLOOR_DIV = 90,
 332   REDUCE_ANY = 91,
 333   SQUARE = 92,
 334   ZEROS_LIKE = 93,
 335   FILL = 94,
 336   FLOOR_MOD = 95,
 337   RANGE = 96,
 338   RESIZE_NEAREST_NEIGHBOR = 97,
 339   LEAKY_RELU = 98,
 340   SQUARED_DIFFERENCE = 99,
 341   MIRROR_PAD = 100,
 342   ABS = 101,
 343   SPLIT_V = 102,
 344   UNIQUE = 103,
 345   CEIL = 104,
 346   REVERSE_V2 = 105,
 347   ADD_N = 106,
 348   GATHER_ND = 107,
 349   COS = 108,
 350   WHERE = 109,
 351   RANK = 110,
 352   ELU = 111,
 353   REVERSE_SEQUENCE = 112,
 354   MATRIX_DIAG = 113,
 355   QUANTIZE = 114,
 356   MATRIX_SET_DIAG = 115,
 357   ROUND = 116,
 358   HARD_SWISH = 117,
 359   IF = 118,
 360   WHILE = 119,
 361   NON_MAX_SUPPRESSION_V4 = 120,
 362   NON_MAX_SUPPRESSION_V5 = 121,
 363   SCATTER_ND = 122,
 364   SELECT_V2 = 123,
 365   DENSIFY = 124,
 366   SEGMENT_SUM = 125,
 367   BATCH_MATMUL = 126,
 368   PLACEHOLDER_FOR_GREATER_OP_CODES = 127,
 369   CUMSUM = 128,
 370   CALL_ONCE = 129,
 371   BROADCAST_TO = 130,
 372   RFFT2D = 131,
 373   CONV_3D = 132,
 374   IMAG=133,
 375   REAL=134,
 376   COMPLEX_ABS=135,
 377   HASHTABLE = 136,
 378   HASHTABLE_FIND = 137,
 379   HASHTABLE_IMPORT = 138,
 380   HASHTABLE_SIZE = 139,
 381   REDUCE_ALL = 140,
 382   CONV_3D_TRANSPOSE = 141,
 383   VAR_HANDLE = 142,
 384   READ_VARIABLE = 143,
 385   ASSIGN_VARIABLE = 144,
 386   BROADCAST_ARGS = 145,
 387   RANDOM_STANDARD_NORMAL = 146,
 388   BUCKETIZE = 147,
 389   RANDOM_UNIFORM = 148,
 390   MULTINOMIAL = 149,
 391   GELU = 150,
 392   DYNAMIC_UPDATE_SLICE = 151,
 393   RELU_0_TO_1 = 152,
 394   UNSORTED_SEGMENT_PROD = 153,
 395   UNSORTED_SEGMENT_MAX = 154,
 396   UNSORTED_SEGMENT_SUM = 155,
 397   ATAN2 = 156
 398 }
 399 // LINT.ThenChange(nnapi_linter/linter.proto)
 400
 401 // Options for the builtin operators.
 402 union BuiltinOptions {
 403   Conv2DOptions,
 404   DepthwiseConv2DOptions,
 405   ConcatEmbeddingsOptions,
 406   LSHProjectionOptions,
 407   Pool2DOptions,
 408   SVDFOptions,
 409   RNNOptions,
 410   FullyConnectedOptions,
 411   SoftmaxOptions,
 412   ConcatenationOptions,
 413   AddOptions,
 414   L2NormOptions,
 415   LocalResponseNormalizationOptions,
 416   LSTMOptions,
 417   ResizeBilinearOptions,
 418   CallOptions,
 419   ReshapeOptions,
 420   SkipGramOptions,
 421   SpaceToDepthOptions,
 422   EmbeddingLookupSparseOptions,
 423   MulOptions,
 424   PadOptions,
 425   GatherOptions,
 426   BatchToSpaceNDOptions,
 427   SpaceToBatchNDOptions,
 428   TransposeOptions,
 429   ReducerOptions,
 430   SubOptions,
 431   DivOptions,
 432   SqueezeOptions,
 433   SequenceRNNOptions,
 434   StridedSliceOptions,
 435   ExpOptions,
 436   TopKV2Options,
 437   SplitOptions,
 438   LogSoftmaxOptions,
 439   CastOptions,
 440   DequantizeOptions,
 441   MaximumMinimumOptions,
 442   ArgMaxOptions,
 443   LessOptions,
 444   NegOptions,
 445   PadV2Options,
 446   GreaterOptions,
 447   GreaterEqualOptions,
 448   LessEqualOptions,
 449   SelectOptions,
 450   SliceOptions,
 451   TransposeConvOptions,
 452   SparseToDenseOptions,
 453   TileOptions,
 454   ExpandDimsOptions,
 455   EqualOptions,
 456   NotEqualOptions,
 457   ShapeOptions,
 458   PowOptions,
 459   ArgMinOptions,
 460   FakeQuantOptions,
 461   PackOptions,
 462   LogicalOrOptions,
 463   OneHotOptions,
 464   LogicalAndOptions,
 465   LogicalNotOptions,
 466   UnpackOptions,
 467   FloorDivOptions,
 468   SquareOptions,
 469   ZerosLikeOptions,
 470   FillOptions,
 471   BidirectionalSequenceLSTMOptions,
 472   BidirectionalSequenceRNNOptions,
 473   UnidirectionalSequenceLSTMOptions,
 474   FloorModOptions,
 475   RangeOptions,
 476   ResizeNearestNeighborOptions,
 477   LeakyReluOptions,
 478   SquaredDifferenceOptions,
 479   MirrorPadOptions,
 480   AbsOptions,
 481   SplitVOptions,
 482   UniqueOptions,
 483   ReverseV2Options,
 484   AddNOptions,
 485   GatherNdOptions,
 486   CosOptions,
 487   WhereOptions,
 488   RankOptions,
 489   ReverseSequenceOptions,
 490   MatrixDiagOptions,
 491   QuantizeOptions,
 492   MatrixSetDiagOptions,
 493   HardSwishOptions,
 494   IfOptions,
 495   WhileOptions,
 496   DepthToSpaceOptions,
 497   NonMaxSuppressionV4Options,
 498   NonMaxSuppressionV5Options,
 499   ScatterNdOptions,
 500   SelectV2Options,
 501   DensifyOptions,
 502   SegmentSumOptions,
 503   BatchMatMulOptions,
 504   CumsumOptions,
 505   CallOnceOptions,
 506   BroadcastToOptions,
 507   Rfft2dOptions,
 508   Conv3DOptions,
 509   HashtableOptions,
 510   HashtableFindOptions,
 511   HashtableImportOptions,
 512   HashtableSizeOptions,
 513   VarHandleOptions,
 514   ReadVariableOptions,
 515   AssignVariableOptions,
 516   RandomOptions,
 517   BucketizeOptions,
 518   GeluOptions,
 519   DynamicUpdateSliceOptions,
 520   UnsortedSegmentProdOptions,
 521   UnsortedSegmentMaxOptions,
 522   UnsortedSegmentSumOptions,
 523   ATan2Options
 524 }
 525
 526 // LINT.IfChange
 527 enum Padding : byte { SAME, VALID }
 528 // LINT.ThenChange(//tensorflow/compiler/mlir/lite/ir/tfl_op_enums.td)
 529
 530 // LINT.IfChange
 531 enum ActivationFunctionType : byte {
 532   NONE = 0,
 533   RELU = 1,
 534   RELU_N1_TO_1 = 2,
 535   RELU6 = 3,
 536   TANH = 4,
 537   SIGN_BIT = 5,
 538 }
 539 // LINT.ThenChange(//tensorflow/compiler/mlir/lite/ir/tfl_op_enums.td)
 540
 541 table Conv2DOptions {
 542   padding:Padding;
 543   stride_w:int;
 544   stride_h:int;
 545   fused_activation_function:ActivationFunctionType;
 546   dilation_w_factor:int = 1;
 547   dilation_h_factor:int = 1;
 548 }
 549
 550 // Options for both Conv3D and Conv3DTranspose.
 551 table Conv3DOptions {
 552   padding:Padding;
 553   stride_d:int;
 554   stride_w:int;
 555   stride_h:int;
 556   fused_activation_function:ActivationFunctionType;
 557   dilation_d_factor:int = 1;
 558   dilation_w_factor:int = 1;
 559   dilation_h_factor:int = 1;
 560 }
 561
 562 table Pool2DOptions {
 563   padding:Padding;
 564   stride_w:int;
 565   stride_h:int;
 566   filter_width:int;
 567   filter_height:int;
 568   fused_activation_function:ActivationFunctionType;
 569 }
 570
 571 table DepthwiseConv2DOptions {
 572   // Parameters for DepthwiseConv version 1 or above.
 573   padding:Padding;
 574   stride_w:int;
 575   stride_h:int;
 576   // `depth_multiplier` is redundant. It's used by CPU kernels in
 577   // TensorFlow 2.0 or below, but ignored in versions above.
 578   // See comments in lite/c/builtin_op_data.h for more details.
 579   depth_multiplier:int;
 580   fused_activation_function:ActivationFunctionType;
 581   // Parameters for DepthwiseConv version 2 or above.
 582   dilation_w_factor:int = 1;
 583   dilation_h_factor:int = 1;
 584 }
 585
 586 table ConcatEmbeddingsOptions {
 587   num_channels:int;
 588   num_columns_per_channel:[int];
 589   embedding_dim_per_channel:[int]; // This could be inferred from parameters.
 590 }
 591
 592 enum LSHProjectionType: byte {
 593   UNKNOWN = 0,
 594   SPARSE = 1,
 595   DENSE = 2,
 596 }
 597
 598 table LSHProjectionOptions {
 599   type: LSHProjectionType;
 600 }
 601
 602 table SVDFOptions {
 603   rank:int;
 604   fused_activation_function:ActivationFunctionType;
 605   // For weights-only quantization, use asymmetric quantization for non
 606   // constant inputs at evaluation time.
 607   asymmetric_quantize_inputs:bool;
 608 }
 609
 610 // An implementation of TensorFlow RNNCell.
 611 table RNNOptions {
 612   fused_activation_function:ActivationFunctionType;
 613   asymmetric_quantize_inputs:bool;
 614 }
 615
 616 // An implementation of TensorFlow dynamic_rnn with RNNCell.
 617 table SequenceRNNOptions {
 618   time_major:bool;
 619   fused_activation_function:ActivationFunctionType;
 620   asymmetric_quantize_inputs:bool;
 621 }
 622
 623 // An implementation of TensorFlow bidrectional_dynamic_rnn with RNNCell.
 624 table BidirectionalSequenceRNNOptions {
 625   time_major:bool;
 626   fused_activation_function:ActivationFunctionType;
 627   merge_outputs: bool;
 628   asymmetric_quantize_inputs:bool;
 629 }
 630
 631 // LINT.IfChange
 632 enum FullyConnectedOptionsWeightsFormat: byte {
 633   DEFAULT = 0,
 634   SHUFFLED4x16INT8 = 1,
 635 }
 636 // LINT.ThenChange(//tensorflow/compiler/mlir/lite/ir/tfl_op_enums.td)
 637
 638 // An implementation of TensorFlow fully_connected (a.k.a Dense) layer.
 639 table FullyConnectedOptions {
 640   // Parameters for FullyConnected version 1 or above.
 641   fused_activation_function:ActivationFunctionType;
 642
 643   // Parameters for FullyConnected version 2 or above.
 644   weights_format:FullyConnectedOptionsWeightsFormat = DEFAULT;
 645
 646   // Parameters for FullyConnected version 5 or above.
 647   // If set to true, then the number of dimension is preserved. Furthermore,
 648   // all but the last dimension of the input and output shapes will be equal.
 649   keep_num_dims: bool;
 650
 651   // Parameters for FullyConnected version 7 or above.
 652   // If set to true, then weights-only op will use asymmetric quantization for
 653   // inputs.
 654   asymmetric_quantize_inputs: bool;
 655 }
 656
 657 table SoftmaxOptions {
 658   beta: float;
 659 }
 660
 661 // An implementation of TensorFlow concat.
 662 table ConcatenationOptions {
 663   axis:int;
 664   fused_activation_function:ActivationFunctionType;
 665 }
 666
 667 table AddOptions {
 668   fused_activation_function:ActivationFunctionType;
 669   // Parameters supported by version 3.
 670   pot_scale_int16:bool = true;
 671 }
 672
 673 table MulOptions {
 674   fused_activation_function:ActivationFunctionType;
 675 }
 676
 677 table L2NormOptions {
 678   // This field is currently ignored in the L2 Norm Op.
 679   fused_activation_function:ActivationFunctionType;
 680 }
 681
 682 table LocalResponseNormalizationOptions {
 683   radius:int;
 684   bias:float;
 685   alpha:float;
 686   beta:float;
 687 }
 688
 689 // LINT.IfChange
 690 enum LSTMKernelType : byte {
 691   // Full LSTM kernel which supports peephole and projection.
 692   FULL = 0,
 693   // Basic LSTM kernels. Equivalent to TensorFlow BasicLSTMCell.
 694   BASIC = 1,
 695 }
 696 // LINT.ThenChange(//tensorflow/compiler/mlir/lite/ir/tfl_op_enums.td)
 697
 698 // An implementation of TensorFlow LSTMCell and CoupledInputForgetGateLSTMCell
 699 table LSTMOptions {
 700   // Parameters for LSTM version 1 or above.
 701   fused_activation_function:ActivationFunctionType;
 702   cell_clip: float; // Optional, 0.0 means no clipping
 703   proj_clip: float; // Optional, 0.0 means no clipping
 704
 705   // Parameters for LSTM version 2 or above.
 706   // Basic kernel is only supported in version 2 or above.
 707   kernel_type: LSTMKernelType = FULL;
 708
 709   // Parameters for LSTM version 4 or above.
 710   asymmetric_quantize_inputs: bool;
 711 }
 712
 713 // An implementation of TensorFlow dynamic_rnn with LSTMCell.
 714 table UnidirectionalSequenceLSTMOptions {
 715   fused_activation_function:ActivationFunctionType;
 716   cell_clip: float; // Optional, 0.0 means no clipping
 717   proj_clip: float; // Optional, 0.0 means no clipping
 718
 719   // If true then first dimension is sequence, otherwise batch.
 720   time_major:bool;
 721
 722   // Parameter for Unidirectional Sequence LSTM version 4.
 723   asymmetric_quantize_inputs:bool;
 724 }
 725
 726 table BidirectionalSequenceLSTMOptions {
 727   // Parameters supported by version 1:
 728   fused_activation_function:ActivationFunctionType;
 729   cell_clip: float; // Optional, 0.0 means no clipping
 730   proj_clip: float; // Optional, 0.0 means no clipping
 731
 732   // If true, store the outputs of both directions into the first output.
 733   merge_outputs: bool;
 734
 735   // Parameters supported by version 2:
 736   // If true then first dimension is sequence, otherwise batch.
 737   // Version 1 implementations assumed time_major to be true, so this default
 738   // value should never change.
 739   time_major: bool = true;
 740
 741   // Parameters for version 3 or above.
 742   asymmetric_quantize_inputs:bool;
 743 }
 744
 745 table ResizeBilinearOptions {
 746   new_height: int (deprecated);
 747   new_width: int (deprecated);
 748   align_corners: bool;
 749   half_pixel_centers: bool;
 750 }
 751
 752 table ResizeNearestNeighborOptions {
 753   align_corners: bool;
 754   half_pixel_centers: bool;
 755 }
 756
 757 // A call operation options
 758 table CallOptions {
 759   // The subgraph index that needs to be called.
 760   subgraph:uint;
 761 }
 762
 763 table PadOptions {
 764 }
 765
 766 table PadV2Options {
 767 }
 768
 769 table ReshapeOptions {
 770   new_shape:[int];
 771 }
 772
 773 table SpaceToBatchNDOptions {
 774 }
 775
 776 table BatchToSpaceNDOptions {
 777 }
 778
 779 table SkipGramOptions {
 780   ngram_size: int;
 781   max_skip_size: int;
 782   include_all_ngrams: bool;
 783 }
 784
 785 table SpaceToDepthOptions {
 786   block_size: int;
 787 }
 788
 789 table DepthToSpaceOptions {
 790   block_size: int;
 791 }
 792
 793 table SubOptions {
 794   fused_activation_function:ActivationFunctionType;
 795   // Parameters supported by version 5
 796   pot_scale_int16:bool = true;
 797 }
 798
 799 table DivOptions {
 800   fused_activation_function:ActivationFunctionType;
 801 }
 802
 803 table TopKV2Options {
 804 }
 805
 806 enum CombinerType : byte {
 807   SUM = 0,
 808   MEAN = 1,
 809   SQRTN = 2,
 810 }
 811
 812 table EmbeddingLookupSparseOptions {
 813   combiner:CombinerType;
 814 }
 815
 816 table GatherOptions {
 817   axis: int;
 818   // Parameters for Gather version 5 or above.
 819   batch_dims: int = 0;
 820 }
 821
 822 table TransposeOptions {
 823 }
 824
 825 table ExpOptions {
 826 }
 827
 828 table CosOptions {
 829 }
 830
 831 table ReducerOptions {
 832   keep_dims: bool;
 833 }
 834
 835 table SqueezeOptions {
 836   squeeze_dims:[int];
 837 }
 838
 839 table SplitOptions {
 840   num_splits: int;
 841 }
 842
 843 table SplitVOptions {
 844   num_splits: int;
 845 }
 846
 847 table StridedSliceOptions {
 848   begin_mask: int;
 849   end_mask: int;
 850   ellipsis_mask: int;
 851   new_axis_mask: int;
 852   shrink_axis_mask: int;
 853 }
 854
 855 table LogSoftmaxOptions {
 856 }
 857
 858 table CastOptions {
 859   in_data_type: TensorType;
 860   out_data_type: TensorType;
 861 }
 862
 863 table DequantizeOptions {
 864 }
 865
 866 table MaximumMinimumOptions {
 867 }
 868
 869 table TileOptions {
 870 }
 871
 872 table ArgMaxOptions {
 873   output_type : TensorType;
 874 }
 875
 876 table ArgMinOptions {
 877   output_type : TensorType;
 878 }
 879
 880 table GreaterOptions {
 881 }
 882
 883 table GreaterEqualOptions {
 884 }
 885
 886 table LessOptions {
 887 }
 888
 889 table LessEqualOptions {
 890 }
 891
 892 table NegOptions {
 893 }
 894
 895 table SelectOptions {
 896 }
 897
 898 table SliceOptions {
 899 }
 900
 901 table TransposeConvOptions {
 902   padding:Padding;
 903   stride_w:int;
 904   stride_h:int;
 905 }
 906
 907 table ExpandDimsOptions {
 908 }
 909
 910 table SparseToDenseOptions {
 911   validate_indices:bool;
 912 }
 913
 914 table EqualOptions {
 915 }
 916
 917 table NotEqualOptions {
 918 }
 919
 920 table ShapeOptions {
 921   // Optional output type of the operation (int32 or int64). Defaults to int32.
 922   out_type : TensorType;
 923 }
 924
 925 table RankOptions {
 926 }
 927
 928 table PowOptions {
 929 }
 930
 931 table FakeQuantOptions {
 932   // Parameters supported by version 1:
 933   min:float;
 934   max:float;
 935   num_bits:int;
 936
 937   // Parameters supported by version 2:
 938   narrow_range:bool;
 939 }
 940
 941 table PackOptions {
 942   values_count:int;
 943   axis:int;
 944 }
 945
 946 table LogicalOrOptions {
 947 }
 948
 949 table OneHotOptions {
 950   axis:int;
 951 }
 952
 953 table AbsOptions {
 954 }
 955
 956
 957 table HardSwishOptions {
 958 }
 959
 960 table LogicalAndOptions {
 961 }
 962
 963 table LogicalNotOptions {
 964 }
 965
 966 table UnpackOptions {
 967   num:int;
 968   axis:int;
 969 }
 970
 971 table FloorDivOptions {
 972 }
 973
 974 table SquareOptions {
 975 }
 976
 977 table ZerosLikeOptions {
 978 }
 979
 980 table FillOptions {
 981 }
 982
 983 table FloorModOptions {
 984 }
 985
 986 table RangeOptions {
 987 }
 988
 989 table LeakyReluOptions {
 990   alpha:float;
 991 }
 992
 993 table SquaredDifferenceOptions {
 994 }
 995
 996 // LINT.IfChange
 997 enum MirrorPadMode : byte {
 998   // Doesn't include borders.
 999   REFLECT = 0,
1000   // Includes borders.
1001   SYMMETRIC = 1,
1002 }
1003 // LINT.ThenChange(//tensorflow/compiler/mlir/lite/ir/tfl_op_enums.td)
1004
1005 table MirrorPadOptions {
1006   mode:MirrorPadMode;
1007 }
1008
1009 table UniqueOptions {
1010   idx_out_type:TensorType = INT32;
1011 }
1012
1013 table ReverseV2Options {
1014 }
1015
1016 table AddNOptions {
1017 }
1018
1019 table GatherNdOptions {
1020 }
1021
1022 table WhereOptions {
1023 }
1024
1025 table ReverseSequenceOptions {
1026   seq_dim:int;
1027   batch_dim:int = 0;
1028 }
1029
1030 table MatrixDiagOptions {
1031 }
1032
1033 table QuantizeOptions {
1034 }
1035
1036 table MatrixSetDiagOptions {
1037 }
1038
1039 table IfOptions {
1040   then_subgraph_index:int;
1041   else_subgraph_index:int;
1042 }
1043
1044 table CallOnceOptions {
1045   init_subgraph_index:int;
1046 }
1047
1048 table WhileOptions {
1049   cond_subgraph_index:int;
1050   body_subgraph_index:int;
1051 }
1052
1053 table NonMaxSuppressionV4Options {
1054 }
1055
1056 table NonMaxSuppressionV5Options {
1057 }
1058
1059 table ScatterNdOptions {
1060 }
1061
1062 table SelectV2Options {
1063 }
1064
1065 table DensifyOptions {
1066 }
1067
1068 table SegmentSumOptions {
1069 }
1070
1071 table BatchMatMulOptions {
1072   adj_x:bool;
1073   adj_y:bool;
1074   // Parameters for BatchMatMul version 4 or above.
1075   // If set to true, then weights-only op will use asymmetric quantization for
1076   // inputs.
1077   asymmetric_quantize_inputs: bool;
1078 }
1079
1080 table CumsumOptions {
1081   exclusive:bool;
1082   reverse:bool;
1083 }
1084
1085 table BroadcastToOptions {
1086 }
1087
1088 table Rfft2dOptions {
1089 }
1090
1091 table HashtableOptions {
1092   // The identity of hash tables. This identity will be used across different
1093   // subgraphs in the same interpreter instance.
1094   table_id:int;
1095   key_dtype:TensorType;
1096   value_dtype:TensorType;
1097 }
1098
1099 table HashtableFindOptions {
1100 }
1101
1102 table HashtableImportOptions {
1103 }
1104
1105 table HashtableSizeOptions {
1106 }
1107
1108 table VarHandleOptions {
1109   container:string;
1110   shared_name:string;
1111 }
1112
1113 table ReadVariableOptions {
1114 }
1115
1116 table AssignVariableOptions {
1117 }
1118
1119 table RandomOptions {
1120   seed: long;
1121   seed2: long;
1122 }
1123
1124 table BucketizeOptions {
1125   boundaries: [float];  // The bucket boundaries.
1126 }
1127
1128 table GeluOptions {
1129   approximate: bool;
1130 }
1131
1132 table DynamicUpdateSliceOptions {
1133 }
1134
1135 table UnsortedSegmentProdOptions {
1136 }
1137
1138 table UnsortedSegmentMaxOptions {
1139 }
1140
1141 table UnsortedSegmentSumOptions {
1142 }
1143
1144 table ATan2Options {
1145 }
1146
1147
1148 // An OperatorCode can be an enum value (BuiltinOperator) if the operator is a
1149 // builtin, or a string if the operator is custom.
1150 table OperatorCode {
1151   // This field is for backward compatibility. This field will be used when
1152   // the value of the extended builtin_code field has less than
1153   // BulitinOperator_PLACEHOLDER_FOR_GREATER_OP_CODES.
1154   deprecated_builtin_code:byte;
1155   custom_code:string;
1156
1157   // The version of the operator. The version need to be bumped whenever new
1158   // parameters are introduced into an op.
1159   version:int = 1;
1160
1161   // This field is introduced for resolving op builtin code shortage problem
1162   // (the original BuiltinOperator enum field was represented as a byte).
1163   // This field will be used when the value of the extended builtin_code field
1164   // has greater than BulitinOperator_PLACEHOLDER_FOR_GREATER_OP_CODES.
1165   builtin_code:BuiltinOperator;
1166 }
1167
1168 enum CustomOptionsFormat : byte {
1169   FLEXBUFFERS = 0,
1170 }
1171
1172 // An operator takes tensors as inputs and outputs. The type of operation being
1173 // performed is determined by an index into the list of valid OperatorCodes,
1174 // while the specifics of each operations is configured using builtin_options
1175 // or custom_options.
1176 table Operator {
1177   // Index into the operator_codes array. Using an integer here avoids
1178   // complicate map lookups.
1179   opcode_index:uint;
1180
1181   // Optional input are indicated by -1.
1182   inputs:[int];
1183   outputs:[int];
1184
1185   builtin_options:BuiltinOptions;
1186   custom_options:[ubyte];
1187   custom_options_format:CustomOptionsFormat;
1188
1189   // A list of booleans indicating the input tensors which are being mutated by
1190   // this operator.(e.g. used by RNN and LSTM).
1191   // For example, if the "inputs" array refers to 5 tensors and the second and
1192   // fifth are mutable variables, then this list will contain
1193   // [false, true, false, false, true].
1194   //
1195   // If the list is empty, no variable is mutated in this operator.
1196   // The list either has the same length as `inputs`, or is empty.
1197   mutating_variable_inputs:[bool];
1198
1199   // A list of indices to the subgraph's "tensors" that are internal to an Op.
1200   // Internal tensors are those that do not flow in or out of the operation,
1201   // but instead are part of internal computation. As such, the operation's
1202   // implementation may manage its memory more efficiently. They are needed
1203   // however (i.e. not just an implementation detail) since they are part of the
1204   // computation, which may require relevant metadata such as quantization
1205   // parameters.
1206   intermediates:[int];
1207 }
1208
1209 // The root type, defining a subgraph, which typically represents an entire
1210 // model.
1211 table SubGraph {
1212   // A list of all tensors used in this subgraph.
1213   tensors:[Tensor];
1214
1215   // Indices of the tensors that are inputs into this subgraph. Note this is
1216   // the list of non-static tensors that feed into the subgraph for inference.
1217   inputs:[int];
1218
1219   // Indices of the tensors that are outputs out of this subgraph. Note this is
1220   // the list of output tensors that are considered the product of the
1221   // subgraph's inference.
1222   outputs:[int];
1223
1224   // All operators, in execution order.
1225   operators:[Operator];
1226
1227   // Name of this subgraph (used for debugging).
1228   name:string;
1229 }
1230
1231 // Table of raw data buffers (used for constant tensors). Referenced by tensors
1232 // by index. The generous alignment accommodates mmap-friendly data structures.
1233 table Buffer {
1234   data:[ubyte] (force_align: 16);
1235 }
1236
1237 table Metadata {
1238   // A human readable string to uniquely identify a Metadata.
1239   name:string;
1240   // An index to the buffers table.
1241   buffer:uint;
1242 }
1243
1244 // Map from an alias name of tensor to tensor index in the graph.
1245 // This is used in Signature def.
1246 table TensorMap {
1247   // Represents the alias to use for this tensor.
1248   name:string;
1249
1250   // The actual tensor index in the primary graph, that 'name' corresponds to.
1251   tensor_index:uint;
1252 }
1253
1254 // This corresponds to SignatureDef in Tensorflow SavedModel.
1255 // The SignatureDef will be part of the SavedModel provided for conversion.
1256 table SignatureDef {
1257   // Named inputs for this signature.
1258   inputs:[TensorMap];
1259
1260   // Named outputs for this signature.
1261   outputs:[TensorMap];
1262
1263   // Key value which was in the Tensorflow SavedModel SignatureDef map.
1264   signature_key:string;
1265
1266   // Model tag, deprecated.
1267   deprecated_tag:string (deprecated);
1268
1269   // Index of subgraphs that corresponds to the exported method.
1270   subgraph_index:uint;
1271 }
1272
1273 table Model {
1274   // Version of the schema.
1275   version:uint;
1276
1277   // A list of all operator codes used in this model. This is
1278   // kept in order because operators carry an index into this
1279   // vector.
1280   operator_codes:[OperatorCode];
1281
1282   // All the subgraphs of the model. The 0th is assumed to be the main
1283   // model.
1284   subgraphs:[SubGraph];
1285
1286   // A description of the model.
1287   description:string;
1288
1289   // Buffers of the model.
1290   // Note the 0th entry of this array must be an empty buffer (sentinel).
1291   // This is a convention so that tensors without a buffer can provide 0 as
1292   // their buffer.
1293   buffers:[Buffer];
1294
1295   // Metadata about the model. Indirects into the existings buffers list.
1296   // Deprecated, prefer to use metadata field.
1297   metadata_buffer:[int];
1298
1299   // Metadata about the model.
1300   metadata:[Metadata];
1301
1302   // Optional SignatureDefs for the model.
1303   signature_defs:[SignatureDef];
1304 }
1305
1306 root_type Model;