
# Tensorflow算子边界
".om"模型支持的Tensorflow算子边界如[表1]所示。
 表1TensorFlow算子边界 
| **序号** | **Python API**                   | **C++ API**                                         | **边界**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|:---|:---|:---|:---|
| 1      | tf.nn.avg_pool                   | AvgPool Type：Mean   | 【参数】 - value：4-D tensor，格式：\[batch，height，width，channels\]，数据类型：float32  - ksize：包含四个int的列表或元组，其中每个值对应相应维度的窗口大小  - strides：包含四个int的列表或元组，其中每个值对应相应维度的滑动步长  - padding：类型：string，值必须为'VALID'或'SAME'  - data_format：类型：string，值为'NHWC'（默认值）或'NCHW'  - name：可选参数，类型：string   【约束】 - kernelH\<=inputH+padTop+padBottom  - kernelW\<=inputW+padLeft+padRight  - padTop\<windowH  - padBottom\<windowH  - padLeft\<windowW  - padRight\<windowW   除公共约束外，还需满足下列某一场景支持范围： global pool模式只支持下列场景： - outputH==1 \&\& outputW==1 \&\& kernelH\>=inputH \&\& kernelW\>=inputW  - inputH\*inputW\<=10000   【输出】 1个tensor，数据类型与value相同 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                  |
| 2      | tf.nn.max_pool                   | MaxPool                                             | 同tf.nn.avg_pool                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 3      | tf.nn.conv2d                     | Conv2D                                              | 【参数】 - value：4-D tensor，格式：\[batch，height，width，channels\]  - 数据类型：float32  - filter：1个常量tensor，数据类型与维度与value相同，\[filter_height，filter_width，in_channels，out_channels\]  - strides：非空，包含四个int的列表或元组，其中每个值对应相应维度的滑动步长  - padding：非空，类型：string，值必须为'VALID'或'SAME'  - data_format：非空，类型：string，值为'NHWC'（默认值）或'NCHW'  - dilations：可选参数，1个int列表（长度为4）；默认为\[1，1，1，1\]，对应输入的每一维；如果k\>1，相应维度做filter间跳过k-1个单元；维度顺序由data_format决定；dilations的batch与depth维度上的值必须是1  - name：可选参数，类型：string   【约束】 - （inputW + padWHead + padWTail） \>= （（（FilterW- 1） \* dilationW） + 1）  - （inputW + padWHead + padWTail） /StrideW + 1 \<= INT32_MAX  - （inputH + padHHead + padHTail） \>= （（（FilterH- 1） \* dilationH） + 1）  - （inputH + padHHead + padHTail） /StrideH + 1 \<= INT32_MAX  - 0 \<= Pad \< 256， 0 \< FilterSize \< 256， 0 \< Stride \< 64， 1 \<= dilationsize \< 256   【输出】 Tensor，数据类型与Value相同 【量化工具支持】 是                                                                                                                                                                                                                   |
| 4      | tf.concat                        | Concat                                              | 【参数】 - values：输入，包含tensor对象的列表或单个tensor，除要拼接的维度外，其他维度上的值要一致  - axis：0-D tensor，类型：int32，指定要拼接的维度，范围在\[-rank（values），rank（values）\]；python中，索引以0开始，axis为正值时，表示对第axis维拼接；axis为负值时，对第axis+rank（values）维拼接   【约束】 输入的tensor，除了进行concat的维度外，其他维度的size必须相等 输入的的tensor个数范围属于\[1，1000\] 【输出】 1个tensor，为输入tensors拼接后的结果 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 5      | tf.matmul                        | MatMul                                              | 【参数】 - a：非常量tensor，rank\>=2，类型：float32  - b：常量tensor，类型与rank同a  - transpose_a：如果属性为True，a在乘法前做转置  - transpose_b：如果属性为True，b在乘法前做转置；transpose_a属性为False，transpose_b属性也为False  - adjoint_a：如果属性为True，a在乘法前被共轭和转置  - adjoint_b：如果属性为True，b在乘法前被共轭和转置  - a_is_sparse：如果属性为True，a被看作是稀疏矩阵  - b_is_sparse：如果属性为True，b被看作是稀疏矩阵  - name：可选参数   【约束】 - weight的转置属性为false  - 不能支持两个tensor相乘，只能支持1个tensor乘以1个常量   【输出】 1个tensor，类型同a与b 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 6      | tf.nn.fused_batch_norm           | FusedBatchNorm                                      | 【参数】 - x：输入，4-D tensor，类型：float32  - scale：1-D tensor，用于缩放  - offset：1-D tensor，偏差  - mean：1-D tensor，用于推理总体均值  - variance：1-D tensor，用于推理总体方差  - epsilon：在x的方差中添加的1个小的浮点数  - data_format：x的数据格式，值为'NHWC'（默认）或'NCHW'  - is_training：bool值，用于指定操作是用于训练还是推断  - name：操作的名称，可选参数   【约束】 scale，bias，mean，var的shape只支持（1，C，1，1），且c维度与input的c维度相等 【输出】 - y：标准化、缩放、偏移x的4-D tensor  - batch_mean：1-D tensor，表示x的均值  - batch_var：1-D tensor，表示x的方差   【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| 7      | tf.abs                           | Abs                                                 | 【参数】 - x：tensor或稀疏tensor，类型：float32  - name：操作的名称，可选参数   【约束】 无限制 【输出】 返回x的绝对值，tensor或稀疏tensor，尺寸与类型同x 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| 8      | tf.image.resize_nearest_neighbor | ResizeNearestNeighbor                               | 【参数】 - images：4维tensor，\[batch，height，width，channels\]；3维tensor，\[height，width，channels\]；类型：float32  - size：1维tensor，常量，2个元素（新的高宽）  - method：ResizeMethod.NEARESTNEIGHBOR  - align_corners：bool值，默认为False；如果为True，输入和输出的4个角像素的中心对齐，保留角像素处的值   【约束】 无限制 【输出】 shape同输入，类型：float 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 9      | tf.image.resize_bilinear         | ResizeBilinear                                      | 【参数】 - images：4维非常量tensor，\[batch，height，width，channels\]；类型：float32  - size：1维tensor，常量，2个元素（新的高宽）  - method：ResizeMethod.BILINEAR  - align_corners：bool值，默认为False；如果为True，输入和输出的4个角像素的中心对齐，保留角像素处的值   【约束】 （outputH\*outputW）/（inputH\*inputW） \> 1/7 【输出】 shape同输入，类型：float 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 10     | tf.cast                          | Cast                                                | 【输入】 类型：float32，int32，bool，int64，int16，int8，uint8，uint16，double 【参数】 - x：tensor或sparseTensor或indexedSlices  - dtype：目标类型，同x支持的数据类型  - name：名称（可选）   【约束】 无限制 【输出】 tensor或sparseTensor或indexedSlices，同输入的dtype、shape 【量化工具支持】 无需支持                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 11     | tf.nn.depthwise_conv2d           | DepthwiseConv2dNative                               | 【参数】 - input：4维  - filter：4维，常量，数据格式：\[filter_height，filter_width，in_channels，channel_multiplier\]  - strides：输入的每个维度的滑动窗口的步长，属性必须是list（int），且大小为4  - padding：类型：string，值为'VALID'或'SAME'  - rate：1维，大小为2；等值卷积中在height和width维度上对输入值进行采样的扩张率；如果值大于1，则步长的所有值必须为1  - data_format：输入的数据格式，可以是NHWC（默认）或NCHW  - name：名称（可选）   【约束】 filterN=inputC=group 【输出】 4维tensor，形状与data_format一致，例如，对于NHWC格式，形状是\[batch，out_height，out_width，in_channels \* channel_multiplier\] 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 12     | tf.reshape                       | Reshape                                             | 【参数】 - tensor：输入，1个tensor  - shape：定义输出的shape，常量tensor，数据类型：int64，int  - name：此操作的名称（可选）   【约束】 无限制 【输出】 1个tensor，类型同输入 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 13     | tf.squeeze                       | Squeeze                                             | 【参数】 - input：1个tensor，非常量输入  - axis：1个int型列表，指定要移除的维度，默认为\[\]；不能指定非1的维度  - name：此操作的名称（可选）  - squeeze_dims：不推荐使用的参数，axis和dim不能同时存在   【约束】 无限制 【输出】 1个tensor，与input的类型、数据相同，但删除了1个或多个值为1的维度 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 14     | tf.expand_dims                   | ExpandDims                                          | 【参数】 - input：输入，1个tensor  - axis：0-D（标量），指定扩展input形状的维度索引  - name：输出tensor的名称  - dim：0-D（标量），相当于axis，被弃用   【约束】 无限制 【输出】 1个tensor，与input数据相同，shape增加了一维（值为1） 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 15     | tf.greater                       | Greater                                             | 【参数】 - x：输入，1个tensor  - y：标量  - name：此操作的名称（可选）   【约束】 支持广播broadcast，对比x和y的shape，在同一维度上，dim\[x\]只能相同或者一方为1或者一方缺失 【输出】 1个tensor，类型：bool 【量化工具支持】 无需支持                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 16     | tf.nn.relu                       | Relu                                                | 【参数】 - features：非常量输入，tensor  - name：此操作的名称（可选）   【约束】 无限制 【输出】 1个tensor，类型同features 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 17     | tf.nn.relu6                      | Relu6                                               | 【参数】 - features：非常量输入，tensor  - name：此操作的名称（可选）   【约束】 无限制 【输出】 1个tensor，类型同features 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 18     | tf.nn.leaky_relu                 | /                                                   | 【参数】 - features：非常量输入，tensor，表示预激活的值  - alpha：x\<0时激活函数的斜率  - name：此操作的名称（可选）   【约束】 无限制 【输出】 激活值 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 19     | tf.exp                           | exp                                                 | 【参数】 - x：1个输入tensor，类型float32，double  - name：此操作的名称（可选）   【约束】 无限制 【输出】 1个tensor，类型同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 20     | tf.nn.conv2d_transpose           | Conv2DBackpropInput                                 | 【参数】 - value：输入，4-D tensor，数据格式：NHWC（\[batch，height，width，in_channels\]）或NCHW（\[batch，in_channel，height，width\]）  - filter：4-D tensor，常量，shape：\[height，width，output_channels，in_channels\]  - output_shape：1-D tensor，表示输出的shape  - strides：int型列表，非空，输入的每个维度的滑动窗口的步长  - padding：类型：string，值为'VALID'或'SAME'，非空  - data_format：类型：string，'NHWC'或'NCHW'，非空  - name：输出名（可选）   【约束】 - group = 1  - dilation = 1  - filterH - padHHead - 1 \>= 0  - filterW - padWHead - 1 \>= 0   还有一条约束涉及中间变量，公式如下： 1. a = ALIGN（filter_num，16） \* ALIGN（filter_c，16） \* filter_h \* filter_w \* 2；  2. 如果ALIGN（filter_c，16）%32 = 0，a = a/2  3. conv_input_width=（反卷积输入w - 1） \* strideW + 1  4. b = （conv_input_width） \* filter_h \* ALIGN（filter_num，16） \* 2 \* 2  5. a + b \<= 1024\*1024   【输出】 1个tensor，类型同value 【量化工具支持】 是 |
| 21     | tf.sigmoid                       | Sigmoid                                             | 【参数】 - x：1个tensor，输入  - name：此操作的名称（可选）   【约束】 无限制 【输出】 1个tensor，类型同value 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 22     | tf.add                           | Add                                                 | 【参数】 - x：输入，1个tensor，类型：float32、int32  - y：输入，1个tensor，类型同x；两个输入为常量时，1个输入为标量  - name：此操作的名称（可选）   【约束】 支持两组输入的维度不一致，进行广播操作（广播即维度补齐） 目前支持以下几种广播场景： - NHWC+NHWC，NHWC+scalar  - NHWC +1 1 1 1  - NHWC+W和HWC+W和HW+W（备注，W维度做广播）  - NCHW + NH1C和HWC + H1C和HW + H1  - HWC + 1 WC（备注，H维度做广播）   说明： 两个tensor的输入顺序可以互换。 【输出】 1个tensor，类型同y 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 23     | tf.multiply                      | Multiply Type：Mul | 【参数】 - x：输入，1个tensor，类型：float32、int32  - y：输入，1个tensor，类型同x；两个输入为常量时，维度必须一致，为标量或者1-D tensor  - name：此操作的名称（可选）   【约束】 支持两组输入的维度不一致，进行广播操作（广播即维度补齐）， 目前支持以下几种广播场景： - NHWC+NHWC，NHWC+scalar  - NHWC +1 1 1 1，  - NHWC+W和HWC+W和HW+W（备注，W维度做广播）  - NCHW + NH1C和HWC + H1C和HW + H1  - HWC + 1 WC（备注，H维度做广播）   说明： 两个tensor的输入顺序可以互换。 【输出】 1个tensor 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 24     | tf.subtract                      | Subtract Type：Sub   | 【参数】 - x：输入，1个tensor  - y：输入，1个tensor，类型同x；两个输入，可支持常量或非常量  - name：此操作的名称（可选）   【约束】 支持两组输入的维度不一致，进行广播操作（广播即维度补齐）， 目前支持以下几种广播场景： - NHWC+NHWC，NHWC+scalar  - NHWC +1 1 1 1  - NHWC+W和HWC+W 和HW+W（备注，W维度做广播）  - NCHW + NH1C和HWC + H1C和HW + H1  - HWC + 1 WC（备注，H维度做广播）   说明： 两个tensor的输入顺序可以互换。 【输出】 1个tensor 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 25     | tf.nn.bias_add                   | BiasAdd                                             | 【参数】 - value：输入，1个tensor，非常量  - bias：1-D tensor，常量，尺寸与value的最后一维一致；除非value为量化类型，否则类型需同value  - data_format：类型：string，'NHWC'或'NCHW'  - name：此操作的名称（可选）   【约束】 - C \< 10000  - input和bias的数据排布要一致  - 当在c通道上加bias时，input和bias的C维度大小要一致   【输出】 1个tensor，类型同value 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 26     | tf.nn.lrn                        | LRN                                                 | 【参数】 - input：输入，4-D tensor，类型：float32  - depth_radius：0-D int型，默认值为5，1-D标准化窗口的半宽  - bias：可选参数，float型，默认为1；偏移（通常为正值，以避免除以0）  - alpha：可选参数，float型，默认为1；比例因子，通常为正值  - beta：可选参数，float型，默认为0.5；1个指数  - name：此操作的名称（可选）   【约束】 - depth_radius \>0，且必须为奇数  - 通道间： 当depth_radius∈\[1，15\]时，alpha \>0.00001且beta\>0.01，否则alpha和beta为任意值；当C维度大于1776时，depth_radius \<1728    【输出】 1个tensor，类型同input 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 27     | tf.nn.elu                        | Elu                                                 | 【参数】 - features：输入tensor，非常量  - name：名称（可选）   【约束】 无限制 【输出】 输出tensor，类型同features 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| 28     | tf.rsqrt                         | Rsqrt                                               | 【参数】 - x：输入tensor  - name：名称（可选）   【约束】 无限制 【输出】 输出tensor，类型同x 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 29     | tf.log                           | Log                                                 | 【参数】 - x：输入tensor，类型：float32  - name：名称（可选）   【约束】 无限制 【输出】 输出tensor，类型同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 30     | tf.tanh                          | Tanh                                                | 【参数】 - x：输入tensor，非常量  - name：名称（可选）   【约束】 无限制 【输出】 输出tensor，类型同x 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 31     | tf.slice                         | Slice                                               | 【参数】 - input_：输入tensor  - begin：tensor，类型：int32或int64  - size：tensor，类型：int32或int64  - name：名称（可选）   【约束】 输入tensor元素个数不超过INT32_MAX 【输出】 输出tensor，类型同input_ 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 32     | tf.split                         | Split                                               | 【参数】 - value：输入Tensor  - num_or_size_splits：不支持这个参数  - axis：标准，整型，指定输出维度  - name：string；名称（可选）   【约束】 无限制 【输出】 List，包含split后的各Tensor 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 33     | tf.nn.softplus                   | Softplus                                            | 【参数】 - features：输入Tensor；数据类型：\`float32\`  - name：string；名称（可选）   【约束】 无限制 【输出】 输出Tensor，数据类型与features相同 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 34     | tf.nn.softsign                   | Softsign                                            | 【参数】 - features：输入Tensor；数据类型：\`float32\`  - name：string；名称（可选）   【约束】 无限制 【输出】 输出Tensor，数据类型与features相同 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 35     | tf.pad                           | Pad/MirrorPad/ PadV2                                | 【参数】 - tensor：4-D Tensor；数据类型：\`float32\`，\`int32\`  - paddings：Tensor，常量，数据类型：\`int32\`  - mode：string，值为"CONSTANT"，或"REFLECT"，或"SYMMETRIC"  - name：string；名称（可选）  - constant_values：Pad默认填充的值，标量，数据类型与tensor相同   【约束】 CONSTANT模式时，0=\<PAD\<=128，0\<W\<=3000 【输出】 输出Tensor，数据类型与tensor相同 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 36     | tf.fake_quant_with_min_max_vars  | FakeQuantWithMinMaxVars                             | 【参数】 - inputs ：输入Tensor；数据类型：\`float32\`  - min：Tensor，数据类型：\`float32\`  - max：Tensor，数据类型：\`float32\`  - num_bits：标量，整型，默认值\`8\`  - narrow_range：bool（可选），默认值\`False\`  - name：string；名称（可选）   【约束】 -65504\<=min\<=65504，-65504\<=max\<=65504 【输出】 输出Tensor，数据类型：\`float32\` 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 37     | tf.reduce_max                    | Max                                                 | 【参数】 - input_tensor：输入tensor；数据类型：\`float32\`，\`int64\`，\`int32\`，\`uint8\`，\`uint16\`，\`int16\`，\`int8\`  - axis：1-D list或标量，数据类型整型  - keepdims：bool，是否保留维度为1  - name：string；名称（可选）  - reduction_indices：axis旧的别名（不推荐）  - keep_dims：keepdims别名（不推荐）   【约束】 - 当输入的tensor维数等于4时：输入axis={3，{1，2，3}}，keepDims=true，H\*W\*16\*2 \<= 16\*1024  - 当输入的tensor维数等于2时，输入axis={1，{1}}，keepDims=true，H\*W\*CEIL（C，16）\*16\*2 \<= 16\*1024   【输出】 输出reduce后的Tensor，数据类型同input_tensor 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 38     | tf.strided_slice                 | StridedSlice                                        | 【参数】 - input_：1个Tensor  - begin：1-D Tensor，数据类型：\`int32\`  - end：1-D Tensor，数据类型：\`int32\`  - strides：1-D Tensor，数据类型：\`int32\`  - begin_mask：标量，数据类型：\`int32\`  - end_mask：标量，数据类型：\`int32\`  - ellipsis_mask：标量，数据类型：\`int32\`  - new_axis_mask：：标量，数据类型：\`int32\`  - shrink_axis_mask：标量，数据类型：\`int32\`  - var：与input_或None对应的变量  - name：string；名称（可选）   【约束】 strides不允许为0 【输出】 输出Tensor，数据类型同input_ 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 39     | tf.reverse                       | Reverse                                             | 【参数】 - tensor：1个包含Tensor的列表，  - axis：Tensor reverse轴向，数据类型：\`int32\`，\`int64\`  - name：string；名称（可选）   【约束】 无限制 【输出】 1个Tensor，数据类型同tensor 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 40     | tf.realdiv                       | RealDiv                                             | 【参数】 - x：输入Tensor；数据类型：float32\`  - y：输入Tensor；数据类型：float32\`  - name：string；名称（可选）   【约束】 无限制 【输出】 输出Tensor，数据类型同x 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 41     | tf.stack                         | Stack                                               | 【参数】 - values：包含tensor对象（形状与类型相同，类型：float32，int32）的列表  - axis：整数，沿axis维度堆叠，默认是第一维，必须设置  - name：名称（可选）   【约束】 无限制 【输出】 堆叠后的tensor，类型同values 属性T、N和axis必须存在 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 42     | tf.unstack                       | Unpack                                              | 【参数】 - value：输入tensor，值\>0，类型：float32、int32  - num：整数，表示axis维度的长度，默认为None  - axis：整数，沿axis拆分，默认是第一维  - name：名称（可选）   【约束】 无限制 【输出】 从value中拆分出的包含tensor对象的列表 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 43     | tf.transpose                     | Transpose                                           | 【参数】 - a：输入tensor  - perm：a的维数的排列  - name：名称（可选）  - conjugate：可选，类型：bool，默认为False；设置为True时，等同于tf.conj（tf.transpose（input））   【约束】 无限制 【输出】 被转置后的tensor 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 44     | tf.space_to_batch_nd             | SpaceToBatchND                                      | 【参数】 - input：1个Tensor，是N维的并且具有形状input_shape = \[batch\] + spatial_shape + remaining_shape，其中spatial_shape有M维度；支持数据类型为：uint8，int8，int16，uint16，int32，int64，float32  - block_shape：1个Tensor，必须是以下类型之一：int32，int64；1-D，shape为\[M\]，所有值必须\>=1  - paddings：1个Tensor，必须是以下类型之一：int32，int64；二维，shape为\[M，2\]，所有值必须\>=0   【约束】 当tensor维数为4时： blockShape的长度必须等于2，paddings的长度必须等于4 - blockShape元素的大小必须要大于等于1，paddings元素值的大小必须大于等于0  - padding后的h维度要能够被blockShape\[0\]整除，padding后的w维度要能够被blockShape\[1\]整除   【输出】 1个Tensor，与input具有相同的类型 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 45     | tf.batch_to_space_nd             | BatchToSpaceND                                      | 【参数】 - input：1个Tensor，是N维的并且具有形状input_shape = \[batch\] + spatial_shape + remaining_shape，其中spatial_shape有M维度；支持数据类型为：uint8，int8，int16，uint16，int32，int64，float32  - block_shape：1个Tensor；必须是以下类型之一：int32，int64；1-D，shape为\[M\]，所有值必须\>=1  - crops：1个Tensor；必须是以下类型之一：int32，int64；二维，shape为\[M，2\]，所有值必须\>=0   【约束】 - blockShape和crops的元素值数据类型必须是int32，当tensor维数为4时：blockShape的长度必须等于2，crops的长度必须等于4  - blockShape元素的大小必须要大于等于1，crops元素值的大小必须大于等于0，crops数组的大小必须满足crop_start\[i\] + crop_end\[i\] \< block_shape\[i\] \* input_shape\[i+1\]   【输出】 1个Tensor，与images具有相同的类型 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 46     | tf.extract_image_patches         | ExtractImagePatches                                 | 【参数】 - images：1个Tensor，支持数据类型：float32，int32，int64，uint8，int8，uint16，int16；4-D Tensor shape：\[batch，in_rows，in_cols，depth\]  - ksizes：1个整型list，长度\>=4  - strides：1个整型list，必须是：\[1，stride_rows，stride_cols，1\]  - rate：1个整型list，必须是：\[1，rate_rows，rate_cols，1\]  - padding：string，取值："VALID"或者"SAME"，"VALID"表示所取的patch区域必须完全包含在原始图中"SAME"表示取超出原始图像的部分，以0填充该部分  - name：名称（可选）   【约束】 无约束 【输出】 1个Tensor，与images具有相同的类型 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 47     | tf.floormod                      | FloorMod                                            | 【参数】 - x：1个Tensor，支持数据类型：float32，int32  - y：1个Tensor，与x具有相同类型  - name：名称（可选）   【约束】 由于支持广播broadcast，对比x和y的shape，在同一维度上，dim\[x\]只能相同或者一方为1或者一方缺失 【输出】 1个Tensor，与x具有相同的类型 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 48     | tf.nn.softmax                    | Softmax                                             | 【参数】 - logits：1个非空的Tensor，支持数据类型：float32  - axis：在其上执行维度softmax。默认值为-1，表示最后1个维度，不超过logits维度  - name：名称（可选）  - dim：axis的已弃用的别名   【约束】 - 输入4维时可以针对每一维做softmax： 根据分类的轴不同，计算边界分别为： axis=1时，c\<=（（256\*1024/4）-8\*1024-256）/2 axis=0时，n\<=（56\*1024-256）/2 axis=2时，W=1，0\<h\<（1024\*1024/32） axis=3时，0\<W\<（1024\*1024/32）   - 输入维度不足4维时，仅支持对最后一维做softmax计算，并且最后一维不超过46080   【输出】 1个Tensor，与logits具有相同的类型和shape 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 49     | tf.math.pow                      | Power                                               | 【参数】 - x：1个Tensor，支持数据类型：float32  - y：1个Tensor，支持数据类型：float32  - name：名称（可选）   【约束】 power!=1 scale\*x+shift\>0 【输出】 1个Tensor 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 50     | tf.placeholder                   | -                                                   | 【参数】 - dtype：数据类型（必须）  - shape：Tensor的维度和大小（必须）   【约束】 无限制 【输出】 1个Tensor 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 51     | tf.shape                         | Shape                                               | 【参数】 - input：1个Tensor或\`SparseTensor\`  - name：string；名称（可选）  - out_type输出Tensor数据类型，\`int32\`或\`int64\`（可选，默认为\`int32\`）   【约束】 无限制 【输出】 1个Tensor，输出数据类型为out_type 【量化工具支持】 无需支持                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 52     | tf.math.argmax                   | ArgMax                                              | 【参数】 - input：1个Tensor，支持数据类型：\`int8\`，\`uint8\`，\`int16\`，\`uint16\`，\`int32\`，\`int64\`，\`float32\`  - axis：1个Tensor，数据类型\`int32\`，\`int64\`  - out_type输出Tensor数据类型，\`int32\`或\`int64\`（可选，默认为\`int64\`）  - name：string；名称（可选）   【约束】 无限制 【输出】 1个Tensor，输出数据类型为out_type 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 53     | tf.gather                        | Gather GatherV2  | 【参数】 - params：1个Tensor，维度必须大于\`axis + 1\`  - indices：1个Tensor，数据类型\`int32\`，\`int64\`，范围\[0，params.shape\[axis\]）  - axis：输出Tensor数据类型，\`int32\`或\`int64\`，指定indices选取的维度，rank=0  - name：string，名称（可选）   【约束】 无限制 【输出】 1个Tensor，输出数据类型与params相同 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 54     | tf.gather_nd                     | GatherNd                                            | 【参数】 - params：1个Tensor，维度必须大于\`axis + 1\`  - indices：1个Tensor，数据类型\`int32\`，\`int64\`  - name：string；名称（可选）   【约束】 - indices最后一维的大小不能超过params的维数  - indices最后一维中的元素对应着params中的1个维度上的坐标，必须满足坐标规则  - indices中对应维度上的坐标不能超过维度的大小   【输出】 1个Tensor，输出数据类型与params相同 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 55     | tf.math.floordiv                 | FloorDiv                                            | 【参数】 - x：1个Tensor，数据类型：\`float32\`，\`int32\`，  - y：1个Tensor，分母，数据类型：\`float32\`，\`int32\`  - name：string；名称（可选）   【约束】 由于支持广播broadcast，对比x和y的shape，在同一维度上，dim\[x\]只能相同或者一方为1或者一方缺失 【输出】 1个Tensor，floor（x/y） 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 56     | tf.range                         | Range                                               | 【参数】 - start：开始标量，数据类型\`float32\`，\`int32\`，必须为常量  - limit：结束标量，数据类型\`float32\`，\`int32\`，必须为常量  - delta：步长标量，数据类型\`float32\`，\`int32\`，必须为常量  - dtype：返回Tensor的数据类型  - name：string；名称（可选）   【约束】 无限制 【输出】 1个1-D Tensor 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 57     | tf.tile                          | Tile                                                | 【参数】 - input：输入Tensor，数据类型： \`int8\`，\`uint8\`，\`int16\`，\`uint16\`，\`int32\`，\`int64\`，\`float32\`   - multiples：1-D Tensor，长度须和input的秩相同，数据类型：\`int32\`，必须为常量  - name：string；名称（可选）   【约束】 无限制 【输出】 1个Tensor 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 58     | tf.size                          | Size                                                | 【参数】 - input：输入Tensor，数据类型：float32\`  - name：string；名称（可选）  - out_type：输出Tensor数据类型，默认\`int32\`   【约束】 无限制 【输出】 1个Tensor，类型由out_type指定 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 59     | tf.fill                          | Fill                                                | 【参数】 - dims：1-D Tensor，数据类型：\`int32\`，  - value：变量，数据类型：\`int32\`，\`float32\`  - name：string；名称（可选）   【约束】 支持Constant、GivenTensor、Range、Diagonal、Gaussian、MSRA、Uniform、UniformInt、UniqueUniform、XavierFill这些填充模式，在Uniform填充、UniformInt填充、UniqueUniform填充、xavier填充时，生成的数值区间最大范围介于\[min，max）之间 【输出】 1个Tensor，类型同value数据类型 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 60     | tf.concat                        | Concat                                              | 【参数】 - value：1个包含Tensor的列表，数据类型：\`int32\`，\`float32\`  - axis：Tensor拼接轴向，数据类型：\`int32\`  - name：string；名称（可选）   【约束】 输入的tensor，除了进行concat的维度外，其他维度的size必须相等 输入的的tensor个数范围属于\[1，1000\] 【输出】 1个Tensor 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 61     | tf.reverse                       | Reverse                                             | 【参数】 - tensor：1个包含Tensor的列表，  - axis：Tensor reverse轴向，数据类型：\`int32\`  - name：string；名称（可选）   【约束】 无限制 【输出】 1个Tensor，数据类型同tensor 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 62     | tf. reduce_sum                   | sum                                                 | 【参数】 - input_tensor：输入Tensor，  - axis：Tensor sum轴向，数据类型：\`int32\`  - keepdims：bool值，是否保留维度  - name：string；名称（可选）  - reduction_indices：axis旧的string；名称  - keep_dims：不推荐使用，参数keepdims别名   【约束】 无约束 【输出】 输出Tensor，数据类型同tensor 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 63     | tf. math.maximum                 | Maximum                                             | 【参数】 - x：Tensor数据类型：\`int32\`，\`int64\`，\`float32\`  - y：Tensor数据类型同x  - name：string；名称（可选）   【约束】 由于支持广播broadcast，对比x和y的shape，在同一维度上，dim\[x\]只能相同或者一方为1或者一方缺失 【输出】 输出Tensor，返回值（x \> y ? x ：y） 数据类型同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 64     | tf. math.minimum                 | Minimum                                             | 【参数】 - x：Tensor数据类型：\`int32\`，\`int64\`，\`float32\`  - y：Tensor数据类型同x  - name：名称（可选）   【约束】 广播场景只支持下面两种： NHWC+scaler，NHWC+NHWC 【输出】 输出Tensor，返回值（x \< y ? x ：y） 数据类型同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| 65     | tf.clip_by_value                 | ClipByValue                                         | 【参数】 - t：Tensor  - clip_value_min：clip最小值  - clip_value_max：clip最大值  - name：string；名称（可选）   【约束】 min值要小于或者等于max值 【输出】 输出Tensor，返回值范围【clip_value_min，clip_value_max】 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 66     | tf.math.logical_not              | LogicalNot                                          | 【参数】 - x：Tensor数据类型bool  - name：string；名称（可选）   【约束】 无限制 【输出】 输出Tensor，数据类型bool 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 67     | tf.math.logical_and              | LogicalAnd                                          | 【参数】 - x：Tensor数据类型bool  - y：Tensor数据类型bool  - name：string；名称（可选）   【约束】 BroadCast只支持如下几种维度的广播，NHWC和\[1，1，1，1\]，\[N，H，W，C\]，\[N，H，W，1\]，\[1，H，W，C\]，\[N，1，1，C\] 【输出】 输出Tensor，数据类型bool 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 68     | tf.equal                         | Equal                                               | 【参数】 - x：Tensor  - y：Tensor，数据类型同x  - name：string，名称（可选）   【约束】 由于支持广播broadcast，对比x和y的shape，在同一维度上右对齐的情况下，xdim\[i\]和ydim\[i\]只能相同或者一方为1或者一方缺失 【输出】 输出Tensor，数据类型bool 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 69     | tf.square                        | Square                                              | 【参数】 - x：Tensor  - name：string，名称（可选）   【约束】 无限制 【输出】 输出Tensor，数据类型同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 70     | tf.image.crop_and_resize         | CropAndResize                                       | 【参数】 - image：4-D Tensor；数据类型：\`float32\`，\`int8\`，\`int32\`，\`int64\`，shape：\`\[num_boxes，4\]\`  - boxes：2-D Tensor；数据类型：\`float32\`，shape：\`\[num_boxes\]\`  - box_ind：1-D Tensor，数据类型：\`int32\`  - crop_size：1-D Tensor，包含2个元素，数据类型：\`int32\`  - method：string，表示插值方法，值为"bilinear"（默认），"nearest"  - name：string；名称（可选）   【约束】 无限制 【输出】 Tensor，数据类型：\`float32\` 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 71     | tf.math.top_k                    | TopKV2                                              | 【参数】 - input：Tensor，\>=1-D，最后1个维度大小必须大于k，数据类型：\`float32\`k：标量，\>=1；数据类型：\`int32\`  - sorted：bool  - name：string；名称（可选）   【约束】 K一定要以常量传入 【输出】 - values：Tensor返回最后维度上的K个最大向量  - indices：Tensor，values在input中的索引位置 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 72     | tf.invert_permutation            | InvertPermutation                                   | 【参数】 - x：1-D Tensor，数据类型：\`int32\`，\`int64\`，  - name：string；名称（可选）   【约束】 无限制 【输出】 Tensor，数据类型同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 73     | tf.multinomial                   | Multinomial                                         | 【参数】 - logits：2-D Tensor，shape \`\[batch_size，num_classes\]\`  - num_samples：标量，抽样个数  - seed：随机数种子，数据类型：\`int32\`，\`int64\`，  - name：string；名称（可选）  - output_dtype：输出Tensor数据类型：整型默认\`int64\`   【约束】 seed为0时产生随机数是动态的 输出数据行数等于输出数据的行，输出数据的列数等num_samples 【输出】 Tensor，数据类型同output_dtype 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 74     | tf.reverse_sequence              | ReverseSequence                                     | 【参数】 - input：输入Tensor  - seq_lengths：1-D Tensor；数据类型：\`int32\`，\`int64\`  - seq_axis：标量，，数据类型：整型  - batch_axis：标量（可选），数据类型：整型  - name：string；名称（可选）   【约束】 - seq_lengths的长度必须等于input在batchAxis的元素数  - seq_lengths的最大元素必须要小于等于seq_dim的元素数  - seqAxis、batchAxis、seqDim、batchDim必须是int64类型  - seqAxis与seqDim不可同时指定，batchAxis与batchDim不可同时指定  - batchAxis和batchDim是可选参数，缺省值为0，权值个数需要为1   【输出】 Tensor，数据类型同input 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 75     | tf.math.reciprocal               | Reciprocal                                          | 【参数】 - x：输入Tensor数据类型\`float32\`  - name：string；名称（可选）   【约束】 不支持输入数据中包含0 【输出】 Tensor，数据类型同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 76     | tf.nn.selu                       | Selu                                                | 【参数】 - features：输入Tensor数据类型\`float32\`，  - name：string；名称（可选）   【约束】 无约束 【输出】 Tensor，数据类型同features 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 77     | tf.math.acosh                    | Acosh                                               | 【参数】 - x：输入Tensor数据类型\`float32\`  - name：string；名称（可选）   【约束】 无约束 【输出】 Tensor，数据类型同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 78     | tf.math.asinh                    | Asinh                                               | 【参数】 - x：输入Tensor数据类型\`float32\`  - name：string；名称（可选）   【约束】 无约束 【输出】 Tensor，数据类型同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 79     | tf.math.reduce_prod              | Prod                                                | 【参数】 - input_tensor：输入Tensor  - axis：reduce维度  - keepdims：bool是否需要保存reduce维度  - name：string；名称（可选）  - reduction_indices：参数axis旧的别名（不推荐）  - keep_dims：参数keepdims别名（不推荐）   【约束】 无约束 【输出】 Tensor，raduce后的Tensor 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 80     | tf.math.sqrt                     | Sqrt                                                | 【参数】 - x：输入Tensor；数据类型：\`float32\`  - name：string；名称（可选）   【约束】 无约束 【输出】 Tensor，数据类型同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 81     | tf.math.reduce_all               | All                                                 | 【参数】 - input_tensor：输入Tensor；数据类型：bool  - axis：指定reduce的维度  - keepdims：bool值  - name：string；名称（可选）  - reduction_indices：axis旧的别名（不推荐）  - keep_dims：keepdims别名（不推荐）   【约束】 无约束 【输出】 Tensor，数据类型同input_tensor 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 82     | tf.nn.l2_normalize               | L2Normalize                                         | 【参数】 - x：输入Tensor；数据类型：boolean  - axis：指定normalize的维度轴向 - 如果format为NCHW，则axis必须为1  - 如果format为NHWC，则axis必须为3    - epsilon：规范化的下限值.如果norm\<sqrt（epsilon），将使用sqrt（epsilon）作为除数  - name：string；名称（可选）  - dim：axis旧的别名（不推荐）   【约束】 H\*W\*2 \< 256\*1024/4 【输出】 Tensor，数据类型同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 83     | tf.keras.backend.hard_sigmoid    | Hardsigmoid                                         | 【参数】 x：输入Tensor 【约束】 无限制 【输出】 输出Tensor，返回值：\`0.\` if \`x \< -2.5\`，\`1.\` if \`x \> 2.5\` 当\`-2.5 \<= x \<= 2.5\`，返回\`0.2 \* x + 0.5\` 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 84     | tf.keras.layers.ThresholdedReLU  | ThresholdedReLU                                     | 【参数】 theta：标量\>=0，数据类型：；\`float32\` 【约束】 无限制 【输出】 Tensor 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 85     | tf.math.acos                     | Acos                                                | 【参数】 x：输入Tensor数据类型\`float32\`，\`int32\`，\`int64\` name：string；名称（可选） 【约束】 输入数据范围（-1\<=x\<=1），输出数据范围（0\<=y\<=π） 【输出】 Tensor，数据类型同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 86     | tf.math.atan                     | Arctan                                              | 【参数】 x：输入Tensor数据类型\`float32\`，\`int32\`，\`int64\` name：string；名称（可选） 【约束】 输入数据范围（-65504\<=x\<=65504），输出数据范围（-π/2\<y\<π/2） 【输出】 Tensor，数据类型同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 87     | tf.math.asin                     | Asin                                                | 【参数】 - x：输入Tensor数据类型\`float32\`，\`int32\`，\`int64\`  - name：string；名称（可选）   【约束】 输入数据范围（-1\<=x\<=1），输出数据范围（-π/2\<=y\<=π/2） 【输出】 Tensor，数据类型同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 88     | tf.math.atanh                    | Atanh                                               | 【参数】 - x：输入Tensor数据类型\`float32\`，\`int32\`，\`int64\`  - name：string；名称（可选）   【约束】 输入数据范围：x∈（-1，1） 【输出】 Tensor，数据类型同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 89     | tf.math.tan                      | Tan                                                 | 【参数】 - x：输入Tensor数据类型\`float32\`，\`int32\`，\`int64\`  - name：string；名称（可选）   【约束】 无限制 【输出】 Tensor，数据类型同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 90     | tf.math.logical_or               | LogicalOr                                           | 【参数】 - x：输入Tensor数据类型：\`bool\`  - y：输入Tensor数据类型：\`bool\`  - name：string；名称（可选）   【约束】 由于支持广播broadcast，对比x和y的shape，在同一维度上右对齐的情况下，xdim\[i\]和ydim\[i\]只能相同或者一方为1或者一方缺失 【输出】 Tensor，数据类型：\`bool\` 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 91     | tf.math.reduce_min               | ReduceMin                                           | 【参数】 - input_tensor：输入Tensor数据类型：\`float32\`，\`int64\`，\`int32\`，\`uint8\`，\`uint16\`，\`int8\`，\`int16\`，  - axis：reduce的维度轴向  - keepdims：标量，bool类型  - name：string；名称（可选）  - reduction_indices：axis旧的别名  - keep_dims：keepdims别名（不推荐）   【约束】 - 当输入的tensor维数等于4时：输入axis={3，{1，2，3}}，keepDims=true，H\*W\*16\*2 \<= 16\*1024  - 当输入的tensor维数等于2时，输入axis={1，{1}}，keepDims=true，H\*W\*CEIL（C，16）\*16\*2 \<= 16\*1024   【输出】 Tensor，数据类型同input_tensor 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 92     | tf.math.negative                 | Neg                                                 | 【参数】 - x：输入Tensor数据类型：\`float32\`，\`int64\`，\`int32\`  - name：string；名称（可选）   【约束】 输入数据范围（-65504\<=x\<=65504），输出数据范围（-65504\<=y\<=65504） 【输出】 Tensor，输出=-x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 93     | tf.math.greater_equal            | Greaterequal                                        | 【参数】 - x：输入Tensor数据类型：\`float32\`，\`int64\`，\`int32\`，\`uint8\`，\`uint16\`，\`int8\`，\`int16\`  - y：输入Tensor数据类型同x  - name：string；名称（可选）   【约束】 输入数据范围（-65504\<=x\<=65504） 【输出】 Tensor，输出类型bool 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 94     | tf.space_to_depth                | SpaceToDepth                                        | 【参数】 - input：输入Tensor数据类型：\`float32\`，\`int64\`，\`int32\`，\`uint8\`，\`int8\`  - block_size：标量，整型，值\>=2  - data_format：数据类型：string值："NHWC"，"NCHW"，"NCHW_VECT_C"；默认值"NHWC"  - name：string；名称（可选）   【约束】 blockSize的大小必须大于等于1，且能被H和W整除 【输出】 Tensor，输出类型input 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 95     | tf.depth_to_space                | DepthToSpace                                        | 【参数】 - input：输入Tensor数据类型：\`float32\`，\`int64\`，\`int32\`，\`uint8\`，\`int8\`  - block_size：标量，整型，值\>=2  - data_format：数据类型：string值："NHWC"，"NCHW"，"NCHW_VECT_C"；默认值是"NHWC"  - name：string；名称（可选）   【约束】 blockSize必须大于等于1，且blockSize\*blockSize必须能被C整除 【输出】 Tensor，输出类型input 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 96     | tf.math.round                    | Round                                               | 【参数】 - x：输入Tensor；数据类型：\`float32\`，\`int64\`，\`int32\`  - name：string；名称（可选）   【约束】 无限制 【输出】 Tensor，输出类型同x，输出shape同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 97     | tf.math.rint                     | Rint                                                | 【参数】 - x：输入Tensor；数据类型：\`float32\`，\`int64\`，\`int32\`，\`uint8\`，\`int8\`  - name：string；名称（可选）   【约束】 无限制 【输出】 Tensor，输出类型同x，输出shape同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 98     | tf.math.less                     | Less                                                | 【参数】 - x：输入Tensor数据类型：\`float32\`，\`int64\`，\`int32\`，\`uint8\`，\`uint16\`，\`int8\`，\`int16\`  - y：输入Tensor数据类型同x，  - name：string；名称（可选）   【约束】 无限制 【输出】 Tensor，输出类型bool 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 99     | tf.math.sinh                     | Sinh                                                | 【参数】 - x：输入Tensor数据类型：\`float32\`  - name：string；名称（可选）   【约束】 无限制 【输出】 Tensor，输出类型同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 100    | tf.math.cosh                     | Cosh                                                | 【参数】 - x：输入Tensor数据类型：\`float32\`  - name：string；名称（可选）   【约束】 无限制 【输出】 Tensor，输出类型同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 101    | tf.math.squared_difference       | Squared_difference                                  | 【参数】 - x：输入Tensor；数据类型：\`float32\`，\`int64\`，\`int32\`  - y：输入Tensor数据类型同x  - name：string；名称（可选）   【约束】 广播模式只支持下列场景： 第1个的tensor_format是NCHW，另1个的dim{}可以是\[1，1，1，1\]，\[N，C，H，W\]，\[N，1，H，W\]，\[1，C，H，W\]，\[N，C，1，1\]，\[1，C，1，1\]，\[1，1，H，W\]，\[N，1，1，1\]这几种情况 【输出】 Tensor，数据类型同x 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
   
