
# Caffe算子边界
对于Caffe框架，当算子的输入维度不是4时，如果存在axis参数，不能使用负数。
".om"模型支持的Caffe算子边界如[表1]所示。
 表1Caffe算子边界 
| **序号** | **算子**               | **含义**                                                    | **边界**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|:---|:---|:---|:---|
| 1      | Absval               | 对输入求绝对值                                                   | 【输入】 1个输入 【参数】 engine：枚举型，默认为0（DEFAULT=0，CAFFE=1，CUDNN=2），可选 【约束】 无限制 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 2      | Argmax               | 返回输入的最大值对应的索引序号                                           | 【输入】 1个输入 【参数】 - out_max_val：布尔型，默认为false，可选  - top_k：unit32，默认为1，可选  - axis：int32，可选   【约束】 无限制 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 3      | BatchNorm            | 对输入做标准化 （x - avg（x））/x的标准差 | 【输入】 1个输入 【参数】 - use_global_stats：布尔型，必须为true  - moving_average_fraction：float，默认为0.999，可选  - eps：float，默认为1e-5，可选   【约束】 仅支持对C维度方向做归一化 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 4      | Concat               | 输入数据按维度拼接                                                 | 【输入】 多个输入 【参数】 - concat_dim：uint32，默认为1，取值：大于0，可选  - axis：int32，默认1，可选；与concat_dim功能相同，二者择其一；axis==-1时，输入维度必须等于4，否则结果可能错误   【约束】 - 输入的tensor，除了进行concat的维度外，其他维度的size必须相等  - 输入tensor的个数范围不超过\[1，1000\]   【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 5      | DepthwiseConvolution | 深度卷积                                                      | 【输入】 1个输入，且filter为常量，维度为4 【参数】 - num_output：uint32，可选  - bias_term：布尔型，默认为true，可选  - pad：uint32，默认为0；数组  - kernel_size：uint32；数组  - stride：uint32，默认为1；数组  - dilation：uint32，默认为1；数组  - pad_h：uint32，默认为0，可选（仅2D）  - pad_w：uint32，默认为0，可选（仅2D）  - kernel_h：uint32，可选（仅2D）  - kernel_w：uint32，可选（仅2D）  - stride_h：uint32，可选（仅2D）  - stride_w：uint32，可选（仅2D）  - group：uint32，默认为1，可选  - weight_filler：类型为FillerParameter，可选  - bias_filler：类型为FillerParameter，可选  - engine：枚举型，默认为0（DEFAULT=0，CAFFE=1，CUDNN=2），可选  - force_nd_im2col：布尔型，默认为false，可选  - axis：int32，默认为1，可选   【约束】 filterN=inputC=group 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 6      | Convolution          | 卷积                                                        | 【输入】 1个输入，且filter为常量，维度为4 【参数】 - num_output：uint32，可选  - bias_term：布尔型，默认为true，可选  - pad：uint32，默认为0；数组  - kernel_size：uint32；数组  - stride：uint32，默认为1；数组  - dilation：uint32，默认为1；数组  - pad_h：uint32，默认为0，可选（仅2D）  - pad_w：uint32，默认为0，可选（仅2D）  - kernel_h：uint32，可选（仅2D）  - kernel_w：uint32，可选（仅2D）  - stride_h：uint32，可选（仅2D）  - stride_w：uint32，可选（仅2D）  - group：uint32，默认为1，可选  - weight_filler：类型为FillerParameter，可选  - bias_filler：类型为FillerParameter，可选  - engine：枚举型，默认为0（DEFAULT=0，CAFFE=1，CUDNN=2），可选  - force_nd_im2col：布尔型，默认为false，可选  - axis：int32，默认为1，可选   【约束】 - （inputW + padWHead + padWTail） \>= （（（FilterW- 1） \* dilationW） + 1）  - （inputW + padWHead + padWTail） /StrideW + 1 \<= 2147483647  - （inputH + padHHead + padHTail） \>= （（（FilterH- 1） \* dilationH） + 1）  - （inputH + padHHead + padHTail） /StrideH + 1 \<= 2147483647  - 0 \<= Pad \< 256， 0 \< FilterSize \< 256， 0 \< Stride \< 64， 1 \<= dilationsize \< 256   【量化工具支持】 是                                                                                                                                                                                                                                                                                                                    |
| 7      | Crop                 | 截取                                                        | 【输入】 2个输入 【参数】 - axis：int32，默认为2，axis=-1，input dim必须等于4，可选  - offset：uint32，数组   【约束】 无限制 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 8      | Deconvolution        | 反卷积                                                       | 【输入】 1个输入，且filter为常量，维度为4 【参数】 - num_output：uint32，可选  - bias_term：布尔型，默认为true，可选  - pad：uint32，默认为0；数组  - kernel_size：uint32；数组  - stride：uint32，默认为1；数组  - dilation：uint32，默认为1；数组  - pad_h：uint32，默认为0，可选（仅2D）  - pad_w：uint32，默认为0，可选（仅2D）  - kernel_h：uint32，可选（仅2D）  - kernel_w：uint32，可选（仅2D）  - stride_h：uint32，可选（仅2D）  - stride_w：uint32，可选（仅2D）  - group：uint32，默认为1，可选  - weight_filler：类型为FillerParameter，可选  - bias_filler：类型为FillerParameter，可选  - engine：枚举型，默认为0（DEFAULT=0，CAFFE=1，CUDNN=2），可选  - force_nd_im2col：布尔型，默认为false，可选  - axis：int32，默认为1，可选   【约束】 - 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   【量化工具支持】 是 |
| 9      | DetectionOutput      | 检测结果输出FSR                                                 | 【输入】 3个输入 【参数】 - num_classes：必选，类型：int32，要预测的类数  - share_location：可选，类型：bool，默认为true（表示不同类间共享bounding box）  - background_label_id：可选，类型：int32，默认为0  - nms_param：可选，非最大抑制  - save_output_param：可选，用于保存检测结果  - code_type：可选，默认为CENTER_SIZE  - variance_encoded_in_target：可选，类型：bool，默认为true；如果为true，方差编码在目标中，否则需要相应地调整预测偏移量  - keep_top_k：可选，类型：int32，在nms步骤后每个图像要保留的总bbox数  - confidence_threshold：可选，类型：float，仅考虑置信度大于阈值的检测；如果没有设置，考虑所有的box  - nms_threshold：可选，类型：float  - top_k：可选，类型：int32  - boxes：可选，类型：int32，默认为1  - relative：可选，类型：bool，默认为true  - objectness_threshold，可选，类型：float，默认为0.5  - class_threshold：可选，类型：float，默认为0.5  - biases：数组  - general_nms_param：可选   【约束】 - 支持fasterrcnn网络  - 非极大值抑制比nmsThreshold∈（0，1）  - 概率阈值postConfThreshold∈（0，1）  - 类别\>=2  - 最大支持1024个框输入  - 输出的w维度是16   【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 10     | Eltwise              | 按元素操作层（求和、乘积、最大值）                                         | 【输入】 至少2个输入 【参数】 - operation：可选，类型：枚举型（PROD = 0； SUM = 1； MAX = 2），默认为SUM  - coeff：数组；类型：float  - stable_prod_grad：可选，类型：bool，默认为true   【约束】 - 最大支持4个输入  - 与原生算子相比，不支持stable_prod_grad参数  - 支持prod、sum、max三种模式   【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 11     | Elu                  | 激活函数                                                      | 【输入】 1个输入 【参数】 alpha （optional）：类型：float，默认为1 【约束】 无限制 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 12     | Exp                  | 对输入求以e为底的x次方值                                             | 【输入】 1个输入 【参数】 - base：可选，类型：float，默认为-1.0  - scale：可选，类型：float，默认为1.0  - shift：可选，类型：float，默认为0.0   【约束】 无限制 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 13     | Flatten              | 输入n\*c\*h\*w 变为向量 n\* （c\*h\*w）                           | 【输入】 1个输入 （top_size与bottom_size必须不一致，且不为1；当axis=-1时，输入的dim必须等于4） 【参数】 - axis：可选，类型：int32，默认为1  - end_axis：可选，类型：int32，默认为-1   【约束】 axis必须小于end axis 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 14     | FullConnection       | 全连接                                                       | 【输入】 1个输入 【参数】 - num_output：可选，类型：uint32  - bias_term：可选，类型：bool，默认为true  - weight_filler：可选，类型：FillerParameter，维度为2  - bias_filler：可选，类型：FillerParameter，维度为1  - axis：可选，类型：int32，默认为1  - transpose：可选，类型：bool，默认为false   【约束】 - 仅支持transpose=false，axis=1  - Bias_C \<= 56832  - 如果客户要量化模型时，需要满足下列维度： - 当N = 1，2 \* CEIL（C，16） \* 16 \* xH \* xW\<= 1024 \* 1024 - 当N\>1，2 \* 16 \* CEIL（C，16） \* 16 \* xH \* xW \<= 1024 \* 1024    【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 15     | Interp               | 插值层                                                       | 【输入】 1个输入 【参数】 - height：可选，类型：int32，默认为0  - width：可选，类型：int32，默认为0  - zoom_factor：可选，类型：int32，默认为1  - shrink_factor：可选，类型：int32，默认为1  - pad_beg：可选，类型：int32，默认为0  - pad_end：可选，类型：int32， 默认为0   说明： l zoom_factor与shrink_factor不能同时存在 l height与zoom_factor不能同时存在 l height与shrink_factor不能同时存在 【约束】 （outputH\*outputW）/（inputH\*inputW） \> 1/30 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 16     | Log                  | 对输入进行log计算                                                | 【输入】 1个输入 【参数】 - base：可选，类型：float，默认为-1.0  - scale：可选，类型：float，默认为1.0  - shift：可选，类型：float，默认为0.0   【约束】 无限制 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 17     | LRN                  | 局部响应归一化层                                                  | 【输入】 1个输入，不支持常量输入 【参数】 - local_size：可选，类型：uint32，默认为5  - alpha：可选，类型：float，默认为1  - beta：可选，类型：float，默认为0.75  - norm_region：可选，类型：枚举型，默认为ACROSS_CHANNELS，（ACROSS_CHANNELS=0；WITHIN_CHANNEL = 1）  - lrnk：可选，类型：float，默认为1  - engine：可选，类型：枚举型（DEFAULT = 0；CAFFE = 1； CUDNN = 2）   【约束】 - local_size \>0，且必须为奇数  - 通道间：当local_size∈\[1，15\]时，lrnK\>0.00001且beta\>0.01，否则lrnK和beta为任意值；LrnK和alpha不同时为0；当C维度大于1776时，local_size \<1728  - 通道内：LrnK=1，local_size∈\[1，15\]，beta\>0.01   【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 18     | LSTM                 | 长短期记忆网络                                                   | 【输入】 2个或3个输入 - X：时间序列数据(T\*B\*Xt)，按4D的NCHW格式排布传入  - 需要保证：N对应时间序列长度T，C对应Batch数B，H对应t时刻的输入数据Xt，W取1  - Cont：序列连续性标志（T\*B）  - Xs：静态数据（B\*Xt），可选   【参数】 - num_output：可选，类型：uint32，默认为0  - weight_filler：可选，类型：FillerParameter  - bias_filler：可选，类型：FillerParameter  - debug_info：可选，类型：bool，默认为false  - expose_hidden：可选，类型：bool，默认为false   【约束】 此约束涉及中间变量计算，公式如列： a = （ALIGN（xt，16） + ALIGN（output，16）） \* 16 \* 2 \* 2 b = （ALIGN（xt，16） + ALIGN（output，16）） \* 16 \* 4 \* 2 \* 2 c = use_projection ? ALIGN（ht，16） \* ALIGN（output，16） \* 2）：0 d = 16 \* ALIGN（ht，16） \* 2 e = batchNum\* 4 则，约束为： a + b + c \<= 1024 \* 1024 d \<= 256\*1024 / 8 e \<= 256\*1024 / 32 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 19     | Normalize            | 标准化层                                                      | 【输入】 1个输入 【参数】 - across_spatial：可选，类型：bool，默认为true  - scale_filler：可选，默认为1.0  - channel_shared：可选，类型：bool，默认为true  - eps：可选，类型：float，默认为1e-10   【约束】 - eps应大于1e-7，并且小于等于0.1+（1e-6）  - Caffe框架中的参数across_spatial目前只支持true，按channel进行norm操作   【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 20     | Permute              | 将输入维度按照给定模式进行重排                                           | 【输入】 1个输入 【参数】 order：uint32，数组 【约束】 无约束 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 21     | Pooling              | 池化层                                                       | 【输入】 1个输入 【参数】 - pool：池化方法，可选，类型：枚举，取值：MAX=0，AVE=1，STOCHASTIC = 2，默认为MAX  - pad：可选，类型：uint32，默认为0  - pad_h：可选，类型：uint32，默认为0  - pad_w：可选，类型：uint32，默认为0  - kernel_size：可选，类型：uint32，kernel_size和kernel_h/kernel_w不能同时出现  - kernel_h：可选，类型：uint32  - kernel_w：可选，类型：uint32，kernel_h/kernel_w必须同时存在  - stride：可选，类型：uint32，默认为1  - stride_h：可选，类型：uint32  - stride_w：可选，类型：uint32  - engine：可选，类型：枚举，取值：DEFAULT=0，CAFFE=1，CUDNN=2  - global_pooling：可选，类型：bool，默认值为false  - ceil_mode：可选，类型：bool，默认为true  - round_mode：可选，类型：枚举，取值：CEIL=0，FLOOR=1；默认为CEIL   【约束】 - kernelH\<=inputH+padTop+padBottom  - kernelW\<=inputW+padLeft+padRight  - padTop\<windowH  - padBottom\<windowH  - padLeft\<windowW  - padRight\<windowW   除公共约束外，还需满足下列某一场景支持范围 global pool模式只支持以下范围： 1. outputH==1 \&\& outputW==1 \&\& kernelH\>=inputH \&\& kernelW\>=inputW  2. inputH\*inputW\<=10000   【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                        |
| 22     | Power                | 计算 y = （scale\*x+shift）\^ power                           | 【输入】 1个输入 【参数】 - power：可选，类型：float，默认为1.0  - scale：可选，类型：float，默认为1.0  - shift：可选，类型：float，默认为0.0   【约束】 - power!=1  - scale\*x+shift\>0   【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 23     | Prelu                | 激活函数                                                      | 【输入】 1个输入 【参数】 - filler：可选  - channel_shared：可选，类型：bool，默认为false，是否跨channel共享斜率参数   【约束】 无限制 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 24     | PriorBox             | 从目标预选框获取真实目标的位置                                           | 【输入】 1个输入 【参数】 - min_size：必须设置，最小框大小（以像素为单位）  - max_size：必须设置，最大框大小（以像素为单位）  - aspect_ratio：数组；类型：float；各种宽高比，重复的比率将被忽略，如果没有提供，使用默认比率1  - flip：可选，类型：bool，默认为true；如果为true，将翻转每个宽高比，例如，如果有宽高比'r'，也将生成宽高比'1.0/r'  - clip：可选，类型：bool，默认为false；如果为true，将剪切先前的值，使其在\[0，1\]范围内  - variance：数组；调整先前bbox的方差  - img_size：可选，类型：uint32，img_size与img_h/img_w不能同时存在  - img_h：可选，类型：uint32  - img_w：可选，类型：uint32  - step：可选，类型：float，step与step_h/step_w不能同时存在  - step_h：可选，类型：float  - step_w：可选，类型：float  - offset：类型：float，默认为0.5   【约束】 只支持ssd网络 输出维度：\[n，2，检测框\*4，1\] 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 25     | Proposal             | 将预选框通过（proposal， score）排序，通过nms获取topN proposal            | 【输入】 3个输入（scores，bbox_pred，im_info） 【参数】 - feat_stride：可选，类型：float  - base_size：可选，类型：float  - min_size：可选，类型：float  - ratio：数组；类型：float  - scale：数组；类型：float  - pre_nms_topn：可选，类型：int32  - post_nms_topn：可选，类型：int32  - nms_thresh：可选，类型：float   【约束】 - 只用于fastercnn  - ProposalParameter、PythonParameter不能同时存在  - preTopK范围为1\~6144  - postTopK范围为1\~1024  - scaleCnt\*ratioCnt的最大值支持到64  - nmsTresh：过滤框使用的阈值，0\<nmsTresh\<=1  - minSize：框的边长的最小值，所有小于此最小值的框将会被过滤掉  - featStride：在生成默认框时，指定两个相邻的框延H或W的步长  - baseSize：用来生成默认框用到的参数，表示框的基本大小  - ratio \& scale：生成默认框用到的参数  - imgH\&imgW：输入到网络的图片高和宽，其值必须大于0  - input维度约束： clsProb：C=2\*scaleCnt\*ratioCnt bboxPred：C=4\*scaleCnt\*ratioCnt bboxPrior：N=clsProb.N，C=4\*scaleCnt\*ratioCnt imInfo：N=clsProb.N，C=3    【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 26     | PSROIPooling         | 位置敏感的区域池化                                                 | 【输入】 2个输入 【参数】 - spatial_scale：必须配置，类型：float  - output_dim：必须配置，类型：int32，输出通道数  - group_size：必须配置，类型：int32，编码位置敏感分数图的组数   【约束】 用于RFCN网络 - 输入Roi框的坐标信息为\[roiN，roiC，roiH，roiW\]，格式范围是：1\<= roiN \<=65535，roiC == 5，roiH == 1，roiW == 1  - 输入的featuremap维度为\[xN，xC，xH，xW\] pooledH==pooledW==groupSize \<= 128 \[pooledH pooledW \]表示pool框的长宽   - 输出的格式 y\[yN， yC， yH， yW\]  - poolingMode == avg pooling， pooledH == pooledW == groupSize， pooledH \<= 128， spatialScale \> 0， groupSize \> 0， outputDim \> 0  - 1\<=xN\<=65535， roisN % xN == 0  - HW_LIMIT是xh、xw的约束 xHW = xH \* xW pooledHW = pooledH \* pooledW HW_LIMIT = （64\*1024--8\*1024） / 32 xH \>= pooledH，xW \>= pooledW xHW \>= pooledHW xHW/pooledHW\<=HW_LIMIT   - 多batch场景时，每个batch的roi框个数相同，且roi的batch排列顺序与feature相同   【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 27     | Relu                 | 激活函数，同时包含普通的relu和leaky relu，可通过参数指定                       | 【输入】 1个输入 【参数】 - negative_slope：可选，类型：float，默认为0  - engine：可选，类型：枚举，取值：DEFAULT=0，CAFFE=1，CUDNN=2   【约束】 无限制 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 28     | Reshape              | 改变输入维度                                                    | 【输入】 1个输入 【参数】 - shape：常量，类型：int64或int  - axis：可选，类型：int32，默认为0  - num_axes：可选，类型：int32，默认为-1   【约束】 无限制 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 29     | ROIAlign             | 一种区域特征聚集的方式                                               | 【输入】 至少有2个输入 【参数】 - pooled_h：可选，类型：uint32，默认为0  - pooled_w：可选，类型：uint32，默认为0  - spatial_scale：可选，类型：float，默认为1  - sampling_ratio：可选，类型：int32，默认为-1   【约束】 主要用于maskrcnn - FeatureMap（特征图）约束：   （1）H \* W \<= 5248（N\>1）或W \* C \< 40960（N=1） （2）C \<= 1280 （3）（（C-1）/128+1）\*pooledW \<= 216 - RoI（感兴区域）约束：   （1）C=5（caffe），H=1，W=1 （2）samplingRatio\*pooledW \<= 128且samplingRatio\*pooledH \<= 128 （3）H \>= pooledH， W \>= pooledW 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 30     | ROIPooling           | 将"候选框"映射到特征图上                                             | 【输入】 至少有2个输入 【参数】 - pooled_h：必须设置，类型：uint32，默认为0  - pooled_w：必须设置，类型：uint32，默认为0  - spatial_scale：必须设置，类型：float；默认为1；乘法空间比例因子将ROI坐标从其输入比例转换为pool时使用的比例   【约束】 主要用于fasterrcnn - 输入维度：H \* W\<=8160；且H\<=120；且W\<=120  - 输出维度：pooledH \<=20，且pooledW \<=20   【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 31     | Scale                | out=alpha\*Input+beta                                     | 【输入】 2个输入，input的dim为4 【参数】 - axis：可选，类型：int32，默认为1，仅支持axis为1或者-3  - num_axes：可选，类型：int32，默认为1  - filler：可选；filler被忽略，除非只给1个bottom且scale是学习参数  - bias_term：可选，类型：bool，默认为false；是否也学习bias（相当于ScaleLayer + BiasLayer，但可能更有效率），使用bias_filler初始化  - bias_filler：可选，默认为0   【约束】 scale，bias的shape只支持（n，c，1，1），且c维度与input的c维度相等 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 32     | ShuffleChannel       | 帮助信息在特征通道交叉流动                                             | 【输入】 1个输入 【参数】 group：可选，类型：uint32，默认为1 【约束】 无限制 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 33     | Sigmoid              | 激活函数                                                      | 【输入】 1个输入 【参数】 engine：可选，类型：枚举，取值：DEFAULT=0，CAFFE=1，CUDNN=2 【约束】 无限制 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 34     | Slice                | 将输入分解成多个输出                                                | 【输入】 1个输入 【参数】 - slice_dim：可选，类型：uint32，默认为1；axis和slice_dim不能同时存在  - slice_point：数组；类型：uint32  - axis：可选，类型：int32，默认为1（表示沿channel拼接）   【约束】 无限制 【输出】 无限制 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 35     | Softmax              | 归一化逻辑函数                                                   | 【输入】 1个输入 【参数】 - engine：可选，取值：DEFAULT=0，CAFFE=1，CUDNN=2  - axis：可选，类型：int32，默认为1；表示沿哪个axis作softmax   【约束】 输入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 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 36     | Tanh                 | 激活函数                                                      | 【输入】 1个输入 【参数】 engine：可选，类型：枚举，取值：DEFAULT=0，CAFFE=1，CUDNN=2 【约束】 输入tensor元素个数不超过INT32_MAX 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 37     | Upsample             | maxpool的反向传播过程                                            | 【输入】 2个输入 【参数】 scale：可选，类型：int32，默认为1 【约束】 无限制 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 38     | SSDDetectionOutput   | SSD网络检测输出                                                 | 【输入】 3个输入 【参数】 - num_classes：必选，类型：int32，要预测的类数  - share_location：可选，类型：bool，默认为true（表示不同类间共享bounding box）  - background_label_id：可选，类型：int32，默认为0  - nms_param：可选，非最大抑制  - save_output_param：可选，用于保存检测结果  - code_type：可选，默认为CENTER_SIZE  - variance_encoded_in_target：可选，类型：bool，默认为true；如果为true，方差编码在目标中，否则需要相应地调整预测偏移量  - keep_top_k：可选，类型：int32，在nms步骤后每个图像要保留的总bbox数  - confidence_threshold：可选，类型：float，仅考虑置信度大于阈值的检测；如果没有设置，考虑所有的box  - nms_threshold：可选，类型：float  - top_k：可选，类型：int32  - boxes：可选，类型：int32，默认为1  - relative：可选，类型：bool，默认为true  - objectness_threshold，可选，类型：float，默认为0.5  - class_threshold：可选，类型：float，默认为0.5  - biases：数组  - general_nms_param：可选   【约束】 - 只支持SSD网络  - preTopK和postTopK的取值范围当前仅支持1\~1024  - shareLocation仅支持true  - nmsEta仅支持1  - numClasses支持的范围是1\~2048  - code_type仅支持CENTER_SIZE  - nms_threshold和confidence_threshold的范围为0.0\~1.0   【量化工具支持】 是                                                                                                                                                                                                                                                                                                                               |
| 39     | Reorg                | 实时物体检测                                                    | 【输入】 1个输入 【参数】 - stride：可选，类型：uint32，默认为2  - reverse：可选，类型：bool，默认为false   【约束】 只用于YOLOV2 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 40     | Reverse              | 逆转                                                        | 【输入】 1个输入 【参数】 axis：可选，类型：int32，默认为1；控制需翻转的数据轴，内容的布局不会被颠倒 【约束】 无限制 【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| 41     | LeakyRelu            | LeakyRelu激活函数                                             | 【输入】 1个输入 【参数】 同Relu 【约束】 无限制 【量化工具支持】 是                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 42     | YOLODetectionOutput  | YOLO网络检测输出                                                | 【输入】 4个输入 【参数】 - num_classes：必选，类型：int32，要预测的类数  - share_location：可选，类型：bool，默认为true（表示不同类间共享bounding box）  - background_label_id：可选，类型：int32，默认为0  - nms_param：可选，非最大抑制  - save_output_param：可选，用于保存检测结果  - code_type：可选，默认为CENTER_SIZE  - variance_encoded_in_target：可选，类型：bool，默认为true；如果为true，方差编码在目标中，否则需要相应地调整预测偏移量  - keep_top_k：可选，类型：int32，在nms步骤后每个图像要保留的总bbox数  - confidence_threshold：可选，类型：float，仅考虑置信度大于阈值的检测；如果没有设置，考虑所有的box  - nms_threshold：可选，类型：float  - top_k：可选，类型：int32  - boxes：可选，类型：int32，默认为1  - relative：可选，类型：bool，默认为true  - objectness_threshold，可选，类型：float，默认为0.5  - class_threshold：可选，类型：float，默认为0.5  - biases：数组  - general_nms_param：可选   【约束】 - 只用于YOLOV2  - classNUm\<10240；anchorBox \<= 8  - W \<= 1536  - yolodetectionoutput的上层必须为yoloregion算子   【量化工具支持】 否                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
   
