root
/
MNN
mirror of https://github.com/alibaba/MNN.git
1
0
Fork 0
Code Issues Actions 6 Packages Projects Releases Wiki Activity
MNN/docs/pymnn/expr.md

3193 lines
68 KiB
Markdown
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

## expr
```python
module expr
```
expr是MNN的表达式模块，包含了一系列的表达式函数能够构造MNN中所有的算子，并提供了类型[Var](Var.md)用来描述数据与表达式。
通过表达式函数和Var变量的组合，可以实现以下功能：
- 模型推理
- 数值计算
- 模型构造
---
### `expr Types`
- [Var](Var.md)
- `var_like` 指`Var`或者可以转换为`Var`的数据，如：`list`，`tuple`，`scalar`等
---
### `const(value_list, shape, data_format, dtype)`
根据输入数据创建一个`Const`类型的`Var`；该函数是创建的`Var`的最基本函数，
能够将`list`，`tuple`，`bytes`，`ndarray`，`PyCapsule`，`int指针`等格式的数据转换成`Var`
*注意：`value_list`仅在PYMNN_NUMPY_USABLE打开的情况下支持`ndarray`，移动端默认关闭*
参数：
- `value_list:ndarray/list/tuple/bytes/PyCapsule/int_addr` 输入数据
- `shape:[int]` 构造`Var`的形状
- `data_format:data_format` 数据排布格式，参考[data_format](Var.html#data-format)
- `dtype:dtype` 数据类型，参考[dtype](Var.html#dtype)
返回：创建的`Var`
返回类型：`Var`
示例：
```python
>>> import numpy as np
>>> expr.const(np.arange(4.0).astype(np.float32), [1, 4], expr.NCHW, expr.float) # ndarray
array([[0., 1., 2., 3.]], dtype=float32)
>>> expr.const([2, 3, 4], [3], expr.NCHW, expr.int) # list/tuple
array([2, 3, 4], dtype=int32)
>>> expr.const(bytes('abc', encoding='utf8'), [3], expr.NCHW, expr.uint8) # bytes
array([97, 98, 99], dtype=uint8)
>>> expr.const(MNN.Tensor([2, 3]).getData(), [2], expr.NCHW, expr.int) # PyCapsule
array([2, 3], dtype=int32)
>>> expr.const(np.arange(4.0).astype(np.float32).__array_interface__['data'][0], [4], expr.NCHW, expr.float) # int_addr 该方法要求ndarray内存必须连续
array([0., 1., 2., 3.], dtype=float32)
```
---
### `set_thread_number(numberThread)`
设置表达式求值的线程数
参数：
- `numberThread:int` 线程数，当`numberThread < 1`时，设置`numberThread=1`，当`numberThread > 8`时，设置`numberThread=8`
返回：`None`
返回类型：`None`
示例：
```python
>>> expr.set_thread_number(4)
```
---
### `load_as_list(fileName)`
从文件中加载模型，并将模型转换为计算图，以`list`的形式返回计算图的所有`Var`节点
参数：
- `fileName:str` 模型文件路径
返回：加载的模型计算图
返回类型：`[Var]`
示例：
```python
>>> len(expr.load_as_list('mobilenet_v1.mnn'))
31
```
---
### `save(vars, fileName, |forInference)`
将`list`形式的计算图存储为模型文件，此函数也用于将`Var`保存到磁盘中
参数：
- `vars:list` 计算图的`list`形式
- `fileName:str` 模型文件路径
- `forInference:bool` 是否仅保存为推理使用，默认为`True`
返回：存储计算图到模型文件中
返回类型：`None`
示例：
```python
>>> x = expr.const([1., 2., 3., 4.], [2, 2])
>>> expr.save([x], 'x.mnn')
>>> expr.load_as_list('x.mnn')
[array([[1., 2.],
[3., 4.]], dtype=float32)]
```
---
### `gc(full)`
手动回收内存，当在循环中调用MNN表达式求值时，常量部分数据不会在每次循环结束释放，当执行次数增加时会有内存增长现象，可以在每次循环结束时调用该函数回收常量内存
参数：
- `full:bool` 是否全部回收，*目前回收方式`True`和`False`没有区别*
返回：`None`
返回类型：`None`
示例：
```python
>>> expr.gc(1)
```
---
### `lazy_eval(lazy)`
是否开启惰性求值，在Python中默认关闭；主要区别如下：
| 模式 | 开启惰性求值 | 关闭惰性求值 |
|:----|:-----------|:-----------|
| 构建区别 | 创建的`Var`时实际表达式类型 | 创建的`Var`都是`Const`类型 |
| 计算方式 | 对`Var`执行read操作时触发计算 | 构建表达式时会立即执行计算 |
| 应用场景 | 使用表达式构建模型，训练，需要对表达式进行修改 | 数值计算，关闭后会加速和降低内存占用 |
参数：
- `lazy:bool` 是否开启惰性求值
返回：`None`
返回类型：`None`
示例：
```python
>>> expr.placeholder().op_type
'Const'
>>> expr.lazy_eval(True)
>>> expr.placeholder().op_type
'Input'
```
---
### `set_lazy_mode(mode)`
设置惰性计算的模式，仅在开启惰性求值的状态下生效，
- 0 : 所有计算均延迟执行
- 1 : 立即进行几何计算，内容计算延迟执行，适用于构建静态模型或训练时求导
默认为0
参数：
- `x:int` 模式类型
返回：`None`
返回类型：`None`
示例：
```python
>>> expr.lazy_eval(True)
>>> expr.set_lazy_mode(0)
>>> y = expr.concat([x], -1)
>>> expr.save([y], "concat.mnn") # 模型中为 concat 算子
>>> expr.set_lazy_mode(1)
>>> y = expr.concat([x], -1)
>>> expr.save([y], "concat_static.mnn") # 模型中为 raster 算子
```
---
### `set_global_executor_config(backend, precision, threadnum)`
设置expr运行后端、精度、线程数(gpu代表mode)：
参数：
- `backend:int` 例如：0->CPU 1->Metal 2->CUDA 3->OPENCL
- `precision:int` 例如：0—>Normal 1->High 2->Low
- `threadnum:int` 例如：CPU表示线程数 GPU表示Mode
返回：`None`
返回类型：`None`
示例：
```python
>>> expr.set_global_executor_config(2, 2, 1)
```
---
### `sync()`
MNN VARP同步，调用后可以保证改VARP计算完毕
返回：`None`
返回类型：`None`
示例：
```python
>>> mnn_var = expr.placeholder([2,2])
>>> mnn_var.sync()
```
---
### `set_device_ptr(device_ptr, memory_type)`
设置MNN VARP GPU内存地址，同时指定给定内存地址对应的内存类型(CUDA/OPENCL/OPENGL等)，仅在MNN VARP有GPU内存时可用：
参数：
- `device_ptr:uint64_t` 整形内存指针地址
- `memory_type:int` 例如： 2->CUDA 3->OpenCL等, 详见include/MNN/MNNForwardType.h文件中MNNForwardType结构体
返回：`None`
返回类型：`None`
示例：
```python
>>> torch_tensor = torch.empty([1, 1000], dtype=torch.float16).cuda()
>>> mnn_var = expr.placeholder([2,2])
>>> mnn_var.set_device_ptr(torch_tensor.data_ptr() ,2)
```
---
### `copy_to_device_ptr(device_ptr, memory_type)`
拷贝MNN VARP GPU内存到指定内存地址, 同时指定给定内存地址对应的内存类型(CUDA/OPENCL/OPENGL等)：
参数：
- `device_ptr:uint64_t` 整形内存指针地址
- `memory_type:int` 例如： 2->CUDA 3->OpenCL等, 详见include/MNN/MNNForwardType.h文件中MNNForwardType结构体
返回：`None`
返回类型：`None`
示例：
```python
>>> torch_tensor = torch.empty([1, 1000], dtype=torch.float16).cuda()
>>> mnn_var = expr.placeholder([2,2])
>>> mnn_var.copy_to_device_ptr(torch_tensor.data_ptr() ,2)
```
---
### `sign(x)`
返回输入值的符号，正数返回1，负数返回-1
参数：
- `x:Var_like` 输入变量
返回：x的符号，`1`或`-1`
返回类型：`Var`
示例：
```python
>>> expr.sign([-5., 4.5])
array([-1., 1.])
```
---
### `abs(x)`
返回输入值的绝对值，正数返回原值，负数返回相反数
参数：
- `x:Var_like` 输入变量
返回：x的绝对值
返回类型：`Var`
示例：
```python
>>> expr.abs([-5., 4.5])
array([5., 4.5])
```
---
### `negative(x)`
返回输入值的相反数
参数：
- `x:Var_like` 输入变量
返回：x的相反数
返回类型：`Var`
示例：
```python
>>> expr.abs([-5., 4.5])
array([5., -4.5])
```
---
### `floor(x)`
返回不大于输入值的最大整数
参数：
- `x:Var_like` 输入变量
返回：不大于x的最大整数
返回类型：`Var`
示例：
```python
>>> expr.floor([-5.1, 4.5])
array([-6., 4.])
```
---
### `round(x)`
返回输入值的四舍五入的值
参数：
- `x:Var_like` 输入变量
返回：x的四舍五入的值
返回类型：`Var`
示例：
```python
>>> expr.round([-5.1, 4.5])
array([-5., 5.])
```
---
### `ceil(x)`
返回输入值的整数部分的值
参数：
- `x:Var_like` 输入变量
返回：x的整数部分的值
返回类型：`Var`
示例：
```python
>>> expr.ceil([-4.9, 4.5])
array([-4., 5.])
```
---
### `square(x)`
返回输入值的平方值
参数：
- `x:Var_like` 输入变量
返回：x的平方值
返回类型：`Var`
示例：
```python
>>> expr.square([-5., 4.5])
array([25., 20.25])
```
---
### `sqrt(x)`
返回输入值的平方根的值，输入值为非负实数
参数：
- `x:Var_like` 输入变量
返回：x的平方根的值
返回类型：`Var`
示例：
```python
>>> expr.sqrt([9., 4.5])
array([3., 2.1213202])
```
---
### `rsqrt(x)`
返回输入值的平方根的倒数的值，输入值为非负实数
参数：
- `x:Var_like` 输入变量
返回：x的平方根的倒数的值
返回类型：`Var`
示例：
```python
>>> expr.rsqrt([9., 4.5])
array([0.33333334, 0.47140455])
```
---
### `exp(x)`
返回自然常数e的输入值(x)次方的值
参数：
- `x:Var_like` 输入变量
返回：自然常数e的x次方的值
返回类型：`Var`
示例：
```python
>>> expr.exp([9., 4.5])
array([8102.449, 90.01698])
```
---
### `log(x)`
返回输入值以自然常数e为底的对数值
参数：
- `x:Var_like` 输入变量
返回：x的以自然常数e为底的对数值
返回类型：`Var`
示例：
```python
>>> expr.log([9., 4.5])
array([2.1972246, 1.5040774])
```
---
### `sin(x)`
返回输入值的正弦值
参数：
- `x:Var_like` 输入变量
返回：x的正弦值
返回类型：`Var`
示例：
```python
>>> expr.sin([9., 4.5])
array([0.4121185, -0.9775301])
```
---
### `sinh(x)`
返回输入值的双曲正弦值
相当于 1/2 * (np.exp(x) - np.exp(-x)) 或者 -1j * np.sin(1j*x)
参数：
- `x:Var_like` 输入变量
返回：x的双曲正弦值
返回类型：`Var`
示例：
```python
>>> expr.sinh([9., 4.5])
array([4051.542, 45.00301])
```
---
### `cos(x)`
返回输入值的余弦值
参数：
- `x:Var_like` 输入变量
返回：x的余弦值
返回类型：`Var`
示例：
```python
>>> expr.cos([9., 4.5])
array([-0.91113025, -0.2107958])
```
---
### `cosh(x)`
返回输入值的双曲余弦值
相当于 1/2 * (np.exp(x) + np.exp(-x)) 或者 np.cos(1j*x)
参数：
- `x:Var_like` 输入变量
返回：x的双曲余弦值
返回类型：`Var`
示例：
```python
>>> expr.cosh([9., 4.5])
array([4051.542, 45.014122])
```
---
### `tan(x)`
返回输入值的正切值
参数：
- `x:Var_like` 输入变量
返回：x的正切值
返回类型：`Var`
示例：
```python
>>> expr.tan([9., 4.5])
array([-0.45231566, 4.637332])
```
---
### `tanh(x)`
返回输入值的双曲正切值
相当于 np.sinh(x)/np.cosh(x) 或者 -1j * np.tan(1j*x)
参数：
- `x:Var_like` 输入变量
返回：x的双曲正切值
返回类型：`Var`
示例：
```python
>>> expr.tanh([9., 4.5])
array([1., 0.9997533])
```
---
### `asin(x)`
返回输入值的反正弦值，别名arcsin
参数：
- `x:Var_like` 输入变量
返回：x的反正弦值
返回类型：`Var`
示例：
```python
>>> expr.asin([9., 0.5])
array([nan, 0.5235988])
```
---
### `asinh(x)`
返回输入值的双曲反正弦值，别名arcsinh
参数：
- `x:Var_like` 输入变量
返回：x的双曲反正弦值
返回类型：`Var`
示例：
```python
>>> expr.asinh([9., 0.5])
array([2.893444, 0.4812118])
```
---
### `acos(x)`
返回输入值的反余弦值，别名arccos
参数：
- `x:Var_like` 输入变量
返回：x的反余弦值
返回类型：`Var`
示例：
```python
>>> expr.asin([9., 0.5])
array([nan, 1.0471975])
```
---
### `acosh(x)`
返回输入值的双曲反余弦值，别名arccosh
参数：
- `x:Var_like` 输入变量
返回：x的双曲反余弦值
返回类型：`Var`
示例：
```python
>>> expr.acosh([9., 0.5])
array([2.887271, nan])
```
---
### `atan(x)`
返回输入值的反正切值，别名arctan
参数：
- `x:Var_like` 输入变量
返回：x的反正切值
返回类型：`Var`
示例：
```python
>>> expr.atan([9., 0.5])
array([1.4601392, 0.4636476])
```
---
### `atanh(x)`
返回输入值的双曲反正切值，别名arctanh
参数：
- `x:Var_like` 输入变量
返回：x的双曲反正切值
返回类型：`Var`
示例：
```python
>>> expr.atanh([9., 0.5])
array([1.4601392, 0.4636476])
```
---
### `reciprocal(x)`
返回输入值的倒数，输入值不能为0
参数：
- `x:Var_like` 输入变量
返回：x的倒数
返回类型：`Var`
示例：
```python
>>> expr.reciprocal([9., 0.5])
array([0.11111111, 2.])
```
---
### `log1p(x)`
返回log(1 + x)的值
参数：
- `x:Var_like` 输入变量
返回：log(1 + x)的值
返回类型：`Var`
示例：
```python
>>> expr.log1p([9., 0.5])
array([2.3025851, 0.4054651])
```
### `gelu(x)`
返回 0.5x(1+tanh(sqrt(pi/2)*(0.044715*x^3))) 的值
参数：
- `x:Var_like` 输入变量
返回：0.5x(1+tanh(sqrt(pi/2)*(0.044715*x^3))) 的值
返回类型：`Var`
示例：
```python
>>> expr.gelu([9., 0.5])
array([9., 0.345714])
```
---
### `sigmoid(x)`
返回 1/(1+exp(-1) 的值
参数：
- `x:Var_like` 输入变量
返回：1/(1+exp(-1)的值
返回类型：`Var`
示例：
```python
>>> expr.sigmoid([9., 0.5])
array([0.9998766, 0.62246716])
```
---
### `erf(x)`
计算高斯误差函数值的数据输入
参数：
- `x:Var_like` 输入变量
返回：高斯误差函数值的数据
返回类型：`Var`
示例：
```python
>>> expr.erf([[1., 25., 16., 0.]])
array([0.8427007., 1., 1., 0.])
```
---
### `erfc(x)`
返回 x 的互补误差
参数：
- `x:Var_like` 输入变量
返回： x的互补误差
返回类型：`Var`
示例：
```python
>>> expr.erfc([0.67., 1.34., -6.])
array([0.34337229769969496., 0.05808628474163466., 2.0.])
```
---
### `erfinv(x)`
返回x的逆误差
参数：
- `x:Var_like` 输入变量
返回：x的逆误差
返回类型：`Var`
示例：
```python
>>> expr.erfinv([0.1., 0.2])
array([0.08885599., 0.17914345.])
```
---
### `expm1(x)`
返回 exp(x) - 1 的值
参数：
- `x:Var_like` 输入变量
返回：exp(x) - 1的值
返回类型：`Var`
示例：
```python
>>> expr.expm1([9., 0.5])
array([8.1014492e+03, 6.4869785e-01])
```
---
### `add(x, y)`
返回两个输入数的和
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
返回：x+y的值
返回类型：`Var`
示例：
```python
>>> expr.add([9., 0.5], [1.2, -3.0])
array([10.2, -2.5])
```
---
### `subtract(x, y)`
返回两个输入数的差值
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
返回：x - y 的值
返回类型：`Var`
示例：
```python
>>> expr.subtract([9., 0.5], [1.2, -3.0])
array([7.8, 3.5])
```
---
### `multiply(x, y)`
返回两个输入数的乘积
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
返回：x * y 的值
返回类型：`Var`
示例：
```python
>>> expr.multiply([9., 0.5], [1.2, -3.0])
array([10.8, -1.5])
```
---
### `divide(x, y)`
返回两个输入数相除的值，y值不能为0
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
返回：x / y 的值
返回类型：`Var`
示例：
```python
>>> expr.divide([9., 0.5], [1.2, -3.0])
array([7.4999995, -0.16666667])
```
---
### `floordiv(x, y)`
返回小于或等于代数商的最大(最接近正无穷大)int值
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
返回：x // y 的值
返回类型：`Var`
示例：
```python
>>> expr.floordiv([9., 0.5], [1.2, -3.0])
array([7., -1.])
```
---
### `mod(x, y)`
返回两个输入数求余的值，y不能为0，取余运算在计算商值向0方向舍弃小数位
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
返回：x % y 的值
返回类型：`Var`
示例：
```python
>>> expr.mod([9., 0.5], [1.2, -3.0])
array([0.59999967, 0.5])
```
---
### `floormod(x, y)`
返回两个输入数取模的值，y不能为0，取模运算在计算商值向负无穷方向舍弃小数位
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
返回：(1)与y符号相同
(2)x > y：结果的绝对值与 % 运算相同;
(3)x < y：①符号相同 结果的绝对值为 y – x ；②符号不同 结果的绝对值与 % 运算相同
返回类型：`Var`
示例：
```python
>>> expr.floormod([9., 0.5], [1.2, -3.0])
array([0.5999994, -2.5])
```
---
### `pow(x, y)`
返回x的y次方的值
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
返回：x的y次方的值
返回类型：`Var`
示例：
```python
>>> expr.pow([9., 0.5], [1.2, -3.0])
array([13.966612, 8.])
```
---
### `minimum(x, y)`
返回输入数中的最小值
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
返回：x和y中的最小值
返回类型：`Var`
示例：
```python
>>> expr.minimum([9., 0.5], [1.2, -3.0])
array([1.2, -3.])
```
---
### `maximum(x, y)`
返回输入数中的最大值
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
返回：x和y中的最大值
返回类型：`Var`
示例：
```python
>>> expr.maximum([9., 0.5], [1.2, -3.0])
array([9., 0.5])
```
---
### `equal(x, y)`
判断输入数是否相等，相等返回1，不等返回0
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
返回：1或0
返回类型：`Var`
示例：
```python
>>> expr.equal([-9., 0.5], [1.2, 0.5])
array([0, 1])
```
---
### `not_equal(x, y)`
判断输入数是否相等，相等返回0，不等返回1
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
返回：1或0
返回类型：`Var`
示例：
```python
>>> expr.not_equal([-9., 0.5], [1.2, 0.5])
array([1, 0])
```
---
### `greater(x, y)`
判断输入数x和y的大小，如果x > y返回1，否者返回0
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
返回：1或0
返回类型：`Var`
示例：
```python
>>> expr.greater([-9., 0.5], [1.2, -3.0])
array([0, 1])
```
---
### `greater_equal(x, y)`
判断输入数x和y的大小，如果x >= y返回1，否者返回0
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
返回：1或0
返回类型：`Var`
示例：
```python
>>> expr.greater_equal([-9., 0.5], [1.2, -3.0])
array([0, 1])
```
---
### `less(x, y)`
判断输入数x和y的大小，如果x < y返回1，否者返回0
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
返回：1或0
返回类型：`Var`
示例：
```python
>>> expr.less([-9., 0.5], [1.2, -3.0])
array([1, 0])
```
---
### `less_equal(x, y)`
判断输入数x和y的大小，如果x <= y返回1，否者返回0
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
返回：1或0
返回类型：`Var`
示例：
```python
>>> expr.less_equal([-9., 0.5], [1.2, -3.0])
array([1, 0])
```
---
### `squared_difference(x, y)`
返回输入数x和输入数y的差的平方值
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
返回：(x - y)^2
返回类型：`Var`
示例：
```python
>>> expr.squared_difference([-9., 0.5], [1.2, -3.0])
array([104.03999, 12.25])
```
---
### `atan2(x, y)`
返回 x / y 的反正切值，别名arctan2
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
返回：arctan(x / y)的值
返回类型：`Var`
示例：
```python
>>> expr.atan2([-9., 0.5], [1.2, -3.0])
array([-1.4382448, -0.16514869])
```
---
### `logical_or(x, y)`
返回输入数的“或”逻辑的值，x和y形状相同，返回1，否则返回0
参数：
- `x:Var_like` 输入变量，仅支持int32
- `y:Var_like` 输入变量，仅支持int32
返回：1或0
返回类型：`Var`
示例：
```python
>>> expr.logical_or([2, 1], [4, 2])
array([1, 1])
```
---
### `bias_add(value, bias)`
这(主要)是加法的一个特殊情况，其中偏差限制在1-D，value可以有任意数量的维度，与加法不同，在量子化的情况下，偏差的类型允许与值不同。
参数：
- `value` 输入变量，dtype.float或者dtype.int类型
- `bias` 输入变量，一个一维变量，其大小与值的通道维度相匹配，必须与值的类型相同，除非值是量化类型，在这种情况下可以使用不同的量化类型。
返回：与value类型相同的变量
返回类型：`Var`
示例：
```python
>>> expr.bias_add(np.eye(3,3), np.ones(3))
array([[2., 1., 1.],
[1., 2., 1.],
[1., 1., 2.]], dtype=float32)
```
---
### `bitwise_and(x, y)`
返回输入数的“与”运算的值（x & y，x, y必须为dtype.int32
参数：
- `x:Var_like` 输入变量，仅支持int32
- `y:Var_like` 输入变量，仅支持int32
返回：1或0
返回类型：`Var`
示例：
```python
>>> expr.bitwise_and([1, 2], [3, 4])
array([1, 0])
```
---
### `bitwise_or(x, y)`
返回输入数的“或”运算的值（x | y），x, y必须为dtype.int32
参数：
- `x:Var_like` 输入变量，仅支持int32
- `y:Var_like` 输入变量，仅支持int32
返回：x | y
返回类型：`Var`
示例：
```python
>>> expr.bitwise_or([1, 2], [3, 4])
array([3, 6])
```
---
### `bitwise_xor(x, y)`
返回输入数的“异或”运算的值（x ^ y），x, y必须为dtype.int32
参数：
- `x:Var_like` 输入变量，仅支持int32
- `y:Var_like` 输入变量，仅支持int32
返回：x ^ y
返回类型：`Var`
示例：
```python
>>> expr.bitwise_xor([1, 2], [3, 4])
array([2, 6])
```
---
### `reduce_sum(x, axis=[], keepdims=False)`
计算张量x沿着指定的数轴（x的某一维度）上的和
参数：
- `x:Var_like` 输入变量
- `axis : axis_like` 仅支持int32，默认为[],指定按哪个维度进行加和，默认将所有元素进行加和
- `keepdims : bool` 默认为false，表示不维持原来张量的维度，反之维持原张量维度
返回：x沿着指定的数轴（x的某一维度）上的和
返回类型：`Var`
示例：
```python
>>> expr.reduce_sum([[1.,2.],[3.,4.]])
array(10.)
>>> expr.reduce_sum([[1.,2.],[3.,4.]], 0)
array([4., 6.])
```
---
### `reduce_mean(x, axis=[], keepdims=False)`
计算张量x沿着指定的数轴（x的某一维度）上的平均值
参数：
- `x:Var_like` 输入变量
- `axis : axis_like` 仅支持int32，默认为[],指定按哪个维度进行加和，默认将所有元素进行加和
- `keepdims : bool` 默认为false，表示不维持原来张量的维度，反之维持原张量维度
返回：x沿着指定的数轴（x的某一维度）上的平均值
返回类型：`Var`
示例：
```python
>>> expr.reduce_mean([[1.,2.],[3.,4.]])
array(2.5.)
>>> expr.reduce_mean([[1.,2.],[3.,4.]], 0)
array([2., 3.])
```
---
### `reduce_max(x, axis=[], keepdims=False)`
计算x沿着指定的数轴（x的某一维度）上的最大值
参数：
- `x:Var_like` 输入变量
- `axis : axis_like` 仅支持int32，默认为[],指定按哪个维度进行加和，默认将所有元素进行加和
- `keepdims : bool` 默认为false，表示不维持原来张量的维度，反之维持原张量维度
返回：x沿着指定的数轴（x的某一维度）上的最大值
返回类型：`Var`
示例：
```python
>>> expr.reduce_max([[1.,2.],[3.,4.]])
array(4.)
>>> expr.reduce_max([[1.,2.],[3.,4.]], 0)
array([3., 4.])
```
---
### `reduce_min(x, axis=[], keepdims=False)`
计算x沿着指定的数轴（x的某一维度）上的最小值
参数：
- `x:Var_like` 输入变量
- `axis : axis_like` 仅支持int32，默认为[],指定按哪个维度进行加和，默认将所有元素进行加和
- `keepdims : bool` 默认为false，表示不维持原来张量的维度，反之维持原张量维度
返回：x沿着指定的数轴（x的某一维度）上的最小值
返回类型：`Var`
示例：
```python
>>> expr.reduce_min([[1.,2.],[3.,4.]])
array(1.)
>>> expr.reduce_min([[1.,2.],[3.,4.]], 0)
array([1., 2.])
```
---
### `reduce_prod(x, axis=[], keepdims=False)`
计算x沿着指定的数轴（x的某一维度）上的乘积
参数：
- `x:Var_like` 输入变量
- `axis : axis_like` 仅支持int32，默认为[],指定按哪个维度进行加和，默认将所有元素进行加和
- `keepdims : bool` 默认为false，表示不维持原来张量的维度，反之维持原张量维度
返回：x沿着指定的数轴（x的某一维度）上的乘积
返回类型：`Var`
示例：
```python
>>> expr.reduce_prod([[1.,2.],[3.,4.]])
array(24.)
>>> expr.reduce_prod([[1.,2.],[3.,4.]], 0)
array([3., 8.])
```
---
### `reduce_any(x, axis=[], keepdims=False)`
计算x沿着指定的数轴（x的某一维度）上的“逻辑或”的值
参数：
- `x:Var_like` 输入变量
- `axis : axis_like` 仅支持int32，默认为[],指定按哪个维度进行加和，默认将所有元素进行加和
- `keepdims : bool` 默认为false，表示不维持原来张量的维度，反之维持原张量维度
返回：x沿着指定的数轴（x的某一维度）上的“逻辑或”的值
返回类型：`Var`
示例：
```python
>>> expr.reduce_any([[0,1],[0,3]])
array(1)
>>> expr.reduce_any([[0,1],[0,3]], 1)
array([0, 1])
```
---
### `reduce_all(x, axis=[], keepdims=False)`
计算x沿着指定的数轴（x的某一维度）上的“逻辑和”的值
参数：
- `x:Var_like` 输入变量
- `axis : axis_like` 仅支持int32，默认为[],指定按哪个维度进行加和，默认将所有元素进行加和
- `keepdims : bool` 默认为false，表示不维持原来张量的维度，反之维持原张量维度
返回：x沿着指定的数轴（x的某一维度）上的“逻辑和”的值
返回类型：`Var`
示例：
```python
>>> expr.reduce_all([[0,1],[0,3]])
array(0)
>>> expr.reduce_all([[0,1],[0,3]], 0)
array([0, 1])
```
---
### `eltwise_prod(x, y, coeff)`
逐元素对输入的变量执行乘法运算
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
- `coeff:[float]` 系数，目前仅支持`[1.,0.]`或`[]/[0.]`
返回：`x*y`, 当`coeff=[1.,0.]`时返回`x`
返回类型：`Var`
示例：
```python
>>> expr.eltwise_prod([1., 2., 3.], [2., 2., 2.], [])
array([2., 4., 6.], dtype=float32)
>>> expr.eltwise_prod([1., 2., 3.], [2., 2., 2.], [1., 0.])
array([1., 2., 3.], dtype=float32)
```
---
### `eltwise_sum(x, y, coeff)`
逐元素对输入的变量执行加法运算
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
- `coeff:[float]` 系数，目前仅支持`[1.,0.]`或`[]/[0.]`
返回：`x+y`, 当`coeff=[1.,0.]`时返回`x`
返回类型：`Var`
示例：
```python
>>> expr.eltwise_sum([1., 2., 3.], [2., 2., 2.], [])
array([3., 4., 5.], dtype=float32)
>>> expr.eltwise_sum([1., 2., 3.], [2., 2., 2.], [1., 0.])
array([1., 2., 3.], dtype=float32)
```
---
### `eltwise_sub(x, y, coeff)`
逐元素对输入的变量执行减法运算
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
- `coeff:[float]` 系数，目前仅支持`[1.,0.]`或`[]/[0.]`
返回：`x-y`, 当`coeff=[1.,0.]`时返回`x`
返回类型：`Var`
示例：
```python
>>> expr.eltwise_sub([1., 2., 3.], [2., 2., 2.], [])
array([-1., 0., 1.], dtype=float32)
>>> expr.eltwise_sub([1., 2., 3.], [2., 2., 2.], [1., 0.])
array([1., 2., 3.], dtype=float32)
```
---
### `eltwise_max(x, y, coeff)`
逐元素对输入的变量执行比较运算，取最大值
参数：
- `x:Var_like` 输入变量
- `y:Var_like` 输入变量
- `coeff:[float]` 系数，目前仅支持`[1.,0.]`或`[]/[0.]`
返回：`max(x,y)`, 当`coeff=[1.,0.]`时返回`x`
返回类型：`Var`
示例：
```python
>>> expr.eltwise_max([1., 2., 3.], [2., 2., 2.], [])
array([2., 2., 3.], dtype=float32)
>>> expr.eltwise_max([1., 2., 3.], [2., 2., 2.], [1., 0.])
array([1., 2., 3.], dtype=float32)
```
---
### `cast(x, dtype=_F.float)`
返回输入数的dtype
参数：
- `x:Var_like` 输入变量
- `dtype` 默认是float类型
返回：x的dtype
返回类型：`Var`
示例：
```python
>>> expr.cast([[0,1],[0,3]], float)
array([[0., 1.],
[0., 3.]], dtype=float32)
```
---
### `matmul(a, b, transposeA=False, transposeB=False)`
返回两个数组的矩阵乘积
参数：
- `a:Var_like` 输入变量
- `b:Var_like` 输入变量
- `transposeA` 布尔值，用于判定a是否为转置矩阵，默认为false
- `transposeB` 布尔值，用于判定b是否为转置矩阵，默认为false
返回：a @ b 的值，dtype是float32
返回类型：`Var`
示例：
```python
>>> expr.matmul([[1,2],[3,4]], [[1,1],[2,2]])
array([[0., 1.],
[0., 3.]], dtype=float32)
```
---
### `normalize(x, acrossSpatial, channelShared, eps, scale)`
返回x数据转换成指定的标准化的格式
参数：
- `a:Var_like` 输入变量
- `acrossSpatial` 输入变量，int类型
- `channelShared` 输入变量，int类型
- `eps` 输入变量，float类型，data_format
- `scale` 输入变量，[float]
返回：x数据转换成指定的标准化的格式
返回类型：`Var`
示例：
```python
>>> x = expr.const([-1.0, -2.0, 3.0, 4.0], [1, 2, 2, 1], expr.NCHW)
>>> expr.normalize(x, 0, 0, 0.0, [0.5, 0.5])
array([[[[-0.2236068],
[-0.4472136]],
[[ 0.3 ],
[ 0.4 ]]]], dtype=float32)
```
---
### `argmax(x, axis=0)`
返回数据最大值的索引，根据axis判断返回的是行还是列的最大值索引
参数：
- `x:Var_like` 输入变量
- `axis` 输入变量，int类型，默认为0，当值为0时则按照每一列操作，为1时按照每一行操作
返回：x最大值的索引
返回类型：`Var`
示例：
```python
>>> expr.argmax([[1,2],[3,4]])
array([1, 1], dtype=int32)
```
---
### `argmin(x, axis=0)`
返回数据最小值的索引，根据axis判断返回的是行还是列的最小值索引
参数：
- `x:Var_like` 输入变量
- `axis` 输入变量，int类型，默认为0，0代表列，1代表行
返回：x最小值的索引
返回类型：`Var`
示例：
```python
>>> expr.argmax([[1,2],[3,4]])
array([1, 1], dtype=int32)
```
---
### `cumsum(x, axis=0)`
返回给定axis上的累计和，如果axis == 0，行一不变，行二累加，以此类推；axis == 1，列一不变，列二累加，以此类推
参数：
- `x:Var_like` 输入变量
- `axis` 输入变量，int类型，默认为0，0代表列，1代表行
返回：x在给定axis上的累计和
返回类型：`Var`
示例：
```python
>>> expr.cumsum([[1,2],[3,4]])
array([[1, 2],
[4, 6]], dtype=int32)
```
---
### `cumprod(x, axis=0)`
返回给定axis上的累计乘积，如果axis == 0，行一不变，行二累计相乘，以此类推；axis == 1，列一不变，列二累计相乘，以此类推
参数：
- `x:Var_like` 输入变量
- `axis` 输入变量，int类型，默认为0，0代表列，1代表行
返回：x在给定axis上的累计乘积
返回类型：`Var`
示例：
```python
>>> expr.cumprod([[1.,2.],[3.,4.]])
array([[1., 2.],
[3., 8.]], dtype=float32)
```
---
### `svd(x)`
返回'x'的svd矩阵，'x'是一个2D矩阵。
返回'w'，'u'，'vt'为 a = u @ w @ vt。
参数：
- `x:Var_like` 输入变量
返回：w : 形状是 (N).
u : 形状是 (M, N).
vt : 形状是 (N, N).
返回类型：`Var`
示例：
```python
>>> expr.cumprod([[1.,2.],[3.,4.]])
[array([5.464986 , 0.36596605], dtype=float32), array([[ 0.40455356, 0.91451436],
[ 0.91451424, -0.40455365]], dtype=float32), array([[ 0.5760485 , 0.81741554],
[-0.81741554, 0.5760485 ]], dtype=float32)]
```
---
### `unravel_index(indices, shape)`
求出数组某元素（或某组元素）拉成一维后的索引值在原本维度（或指定新维度）中对应的索引
参数：
- `indices:Var_like` 输入变量，int32构成的数组， 其中元素是索引值
- `shape:Var_like` 输入变量，一般是原本数组的维度，也可以给定的新维度
返回：索引
返回类型：`Var`
示例：
```python
>>> expr.unravel_index([22, 41, 37], (7,6))
array([[3, 6, 6],
[4, 5, 1]], dtype=int32)
```
---
### `scatter_nd(indices, updates, shape)`
根据indices将updates散布到新的（初始为零）张量
参数：
- `indices:Var_like` 输入变量，指数张量
- `updates:Var_like` 输入变量，分散到输出的更新
- `shape:Var_like` 输入变量，得到的张量的形状
返回：（初始为零）张量
返回类型：`Var`
示例：
```python
>>> indices = expr.const([4, 3, 1, 7], [4, 1], expr.NHWC, expr.int)
>>> expr.scatter_nd(indices, [9.0, 10.0, 11.0, 12.0], [8])
array([ 0., 11., 0., 10., 9., 0., 0., 12.], dtype=float32)
```
---
### `one_hot(indices, depth, onValue=1.0, offValue=0.0, axis=-1)`
转换成one_hot类型的张量输出
参数：
- `indices: Var_like` 输入变量，指示on_value的位置，不指示的地方都为off_value。indices可以是向量、矩阵。
- `depth: int` 输入变量，输出张量的尺寸，indices中元素默认不超过（depth-1），如果超过，输出为[0,0,···,0]
- `onValue: float` 输入变量，定义在indices[j] = i 时填充输出值的标量，默认为1
- `offValue: float` 输入变量，定义在indices[j] != i 时填充输出值的标量，默认为0
- `axis: int` 输入变量，要填充的轴，默认为-1，即一个新的最内层轴
返回：one_hot类型的张量输出
返回类型：`Var`
示例：
```python
>>> expr.one_hot([0, 1, 2], 3)
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]], dtype=float32)
```
---
### `broadcast_to(input, shape)`
利用广播将原始矩阵成倍增加
参数：
- `input: Var_like` 输入变量，一个张量，广播的张量
- `shape: int` 输入变量，一个一维的int32张量，期望输出的形状
返回：成倍增加的原始矩阵
返回类型：`Var`
示例：
```python
>>> expr.broadcast_to([1,2], 4)
array([1, 2, 1571999095, -536868871], dtype=int32)
```
---
### `placeholder(shape=[], format=_F.NCHW, dtype=_F.float)`
构建一个Var类型的占位符
参数：
- `shape: [int]` 输入变量，默认是[]
- `format: data_format` 输入变量，默认是NCHW
- `dtype: dtype` 输入变量，默认是float
返回：Var类型的占位符，使用之前需先`write`
返回类型：`Var`
示例：
```python
>>> expr.placeholder()
array(1., dtype=float32)
>>> expr.placeholder([2,2])
array([[1.67e-43, 1.60e-43],
[1.36e-43, 1.54e-43]], dtype=float32)
```
---
### `clone(x, deepCopy=False)`
克隆一个`Var`
参数：
- `x: Var_like` 输入变量
- `deepCopy: bool` 输入变量，true代表深拷贝，false代表浅拷贝，默认为false
返回：通过x拷贝一个Var
返回类型：`Var`
示例：
```python
>>> x = expr.const([1.,2.], [2])
>>> expr.clone(x, True)
array([1., 2.], dtype=float32)
```
---
### `conv2d(input, weight, bias, stride=(1,1), padding=(0,0), dilate=(1,1), group=1, padding_mode=_F.VALID)`
对由多个输入平面组成的输入信号进行二维卷积
参数：
- `input: var_like` 输入变量，data_format为NC4HW4，输入图像通道数
- `weight: var_like` 输入变量，卷积产生的通道数
- `bias: var_like` 输入变量，在输出中添加一个可学习的偏差
- `stride: tuple of int` 输入变量，卷积步长，默认为(1,1)
- `padding: tuple of int` 输入变量，填充操作，控制padding_mode的数目
- `dilate: tuple of int` 输入变量，扩张操作：控制kernel点（卷积核点）的间距，默认值为(1,1)
- `group: int` 输入变量，控制分组卷积，默认不分组，为1组
- `padding_mode: Padding_Mode` 输入变量，填充模式，默认是VALID
返回：二维卷积
返回类型：`Var`
示例：
```python
>>> x = expr.reshape(expr.range(0., 18., 1.), [1, 2, 3, 3])
>>> x = expr.convert(x, expr.NC4HW4)
>>> w = expr.reshape(expr.range(0., 16., 1.), [2, 2, 2, 2])
>>> b = expr.const([1.0, 1.0], [2])
>>> expr.convert(expr.conv2d(x, w, b), expr.NCHW)
array([[[[ 269., 297.],
[ 353., 381.]],
[[ 685., 777.],
[ 961., 1053.]]]], dtype=float32)
```
---
### `conv2d_transpose(input, weight, bias, stride=(1,1), padding=(0,0), dilate=(1,1), group=1, padding_mode=_F.VALID)`
转置卷积，是卷积的反向操作
参数：
- `input: var_like` 输入变量，需要做反卷积的输入图像
- `weight: var_like` 输入变量，反卷积产生的通道数
- `bias: var_like` 输入变量，在输出中添加一个可学习的偏差
- `stride: tuple of int` 输入变量，反卷积步长，默认为(1,1)
- `padding: tuple of int` 输入变量，填充操作，控制padding_mode的数目
- `dilate: tuple of int` 输入变量，扩张操作：控制kernel点（反卷积核点）的间距，默认值为(1,1)
- `group: int` 输入变量，控制分组反卷积，默认不分组，为1组
- `padding_mode: Padding_Mode` 输入变量，填充模式，默认是VALID
返回：转置卷积（反卷积）
返回类型：`Var`
示例：
```python
>>> x = expr.reshape(expr.range(0., 18., 1.), [1, 2, 3, 3])
>>> x = expr.convert(x, expr.NC4HW4)
>>> w = expr.reshape(expr.range(0., 16., 1.), [2, 2, 2, 2])
>>> b = expr.const([1.0, 1.0], [2])
>>> expr.convert(expr.conv2d_transpose(x, w, b), expr.NCHW)
array([[[[ 73., 162., 180., 102.],
[187., 417., 461., 259.],
[247., 549., 593., 331.],
[163., 358., 384., 212.]],
[[109., 242., 276., 154.],
[283., 625., 701., 387.],
[391., 853., 929., 507.],
[247., 534., 576., 312.]]]], dtype=float32)
```
---
### `max_pool(x, kernel, stride, padding_mode=_F.VALID, pads=(0,0))`
最大值池化操作
参数：
- `x: var_like` 输入变量，池化的输入
- `kernel: var_like` 输入变量
- `stride: tuple of int` 输入变量，窗口在每一个维度上滑动的步长
- `padding_mode: Padding_Mode` 输入变量，填充模式，默认是VALID
- `pads: tuple of int` 输入变量
返回：最大池化
返回类型：`Var`
示例：
```python
>>> x = expr.reshape(expr.range(0., 18., 1.), [1, 2, 3, 3])
>>> expr.max_pool(x, [2,2], [1,1])
array([[[[ 4., 5.],
[ 7., 8.]],
[[13., 14.],
[16., 17.]]]], dtype=float32)
```
---
### `avg_pool(x, kernel, stride, padding_mode=_F.VALID, pads=(0,0))`
平均池化操作
参数：
- `x: var_like` 输入变量，池化的输入
- `kernel: var_like` 输入变量
- `stride: tuple of int` 输入变量，窗口在每一个维度上滑动的步长
- `padding_mode: Padding_Mode` 输入变量，填充模式，默认是VALID
- `pads: tuple of int` 输入变量
返回：平均池化
返回类型：`Var`
示例：
```python
>>> x = expr.reshape(expr.range(0., 18., 1.), [1, 2, 3, 3])
>>> expr.avg_pool(x, [2,2], [1,1])
array([[[[ 2., 3.],
[ 5., 6.]],
[[11., 12.],
[14., 15.]]]], dtype=float32)
```
---
### `reshape(x, shape, original_format=_F.NCHW)`
改变输入数的形状
参数：
- `x: var_like` 输入变量，数组或者矩阵
- `shape: axis_like` 输入变量，返回数据的形状
- `original_format : data_format` 输入变量，默认是NCHW
返回：输入数对应的`shape`
返回类型：`Var`
示例：
```python
>>> x = expr.reshape(expr.range(0., 18., 1.), [1, 2, 3, 3])
>>> reshape(x, [3, 6])
array([[ 0., 1., 2., 3., 4., 5.],
[ 6., 7., 8., 9., 10., 11.],
[12., 13., 14., 15., 16., 17.]], dtype=float32)
```
---
### `scale(x, channels, scale, bias)`
返回`x * scale + bias`的值
参数：
- `x: var_like` 输入变量
- `channels : int` 输入变量
- `scale : [float]` 输入变量
- `bias : [float]` 输入变量
返回：`x * scale + bias`的值
返回类型：`Var`
示例：
```python
>>> x = expr.reshape(expr.range(0., 18., 1.), [1, 2, 3, 3])
>>> x = expr.convert(x, expr.NC4HW4)
>>> y = expr.scale(x, 2, [2.0, 1.0], [3.0, 4.0])
>>> expr.convert(y, expr.NCHW)
array([[[[ 3., 5., 7.],
[ 9., 11., 13.],
[15., 17., 19.]],
[[13., 14., 15.],
[16., 17., 18.],
[19., 20., 21.]]]], dtype=float32)
```
---
### `relu(x, slope=0.0)`
修正线性单元，修正公式为`slope*x if x < 0 else x`
参数：
- `x: var_like` 输入变量
- `slope : float` 输入变量，修正梯度，默认是0.0
返回：修正后的值
返回类型：`Var`
示例：
```python
>>> expr.relu([-1.0, 0.0, 2.0])
var[0., 0., 2.], dtype=float32)
```
---
### `relu6(x, min=0.0, max=6.0)`
修正线性单元，修正公式为`max(min(x, max), min)`
参数：
- `x: var_like` 输入变量
- `min : float` 输入变量，修正最小范围，默认是0.0
- `max : float` 输入变量，修正最大范围，默认是6.0
返回：修正后的值
返回类型：`Var`
示例：
```python
>>> expr.relu6([-1.0, 7.0, 2.0])
var[0., 6., 2.], dtype=float32)
```
---
### `prelu(x, slopes)`
查找指定张量输入的泄漏校正线性，修正公式为`slope*x if x < 0 else x`
参数：
- `x: var_like` 输入变量，data_format 是 NC4HW4.
- `slopes : [float]` 输入变量，修正梯度
返回：修正后的值
返回类型：`Var`
示例：
```python
>>> x = expr.reshape(expr.range(-4., 4., 1.), [1, 2, 2, 2])
>>> x = expr.convert(x, expr.NC4HW4)
>>> expr.convert(expr.prelu(x, [0.5, 0.6]), expr.NCHW)
array([[[[-2. , -1.5],
[-1. , -0.5]],
[[ 0. , 1. ],
[ 2. , 3. ]]]], dtype=float32)
```
---
### `softmax(x, axis=-1)`
数学公式:`exp(x)/sum(exp(x), axis)`
参数：
- `x: var_like` 输入变量
- `axis : int` 输入变量，默认为-1
返回：修正后的值
返回类型：`Var`
示例：
```python
>>> expr.softmax([[1., 2.], [3., 4.]], 0)
array([[0.1191897 , 0.1191897 ],
[0.88081026, 0.88081026]], dtype=float32)
```
---
### `softplus(x)`
通过输入数据 x（张量）并生成一个输出数据（张量）转换公式:`log(exp(x) + 1)`
参数：
- `x: var_like` 输入变量
返回：输出数据（张量）
返回类型：`Var`
示例：
```python
>>> expr.softplus([[1., 2.], [3., 4.]])
array([[1.313261 , 2.1268892],
[3.048587 , 4.01813 ]], dtype=float32)
```
---
### `softsign(x)`
返回通过转换公式:`x / (abs(x) + 1)`转换后的数据
参数：
- `x: var_like` 输入变量
返回：转换公式`x / (abs(x) + 1)`转换后的数据
返回类型：`Var`
示例：
```python
>>> expr.softsign([[1., 2.], [3., 4.]])
array([[0.5 , 0.6666667],
[0.75 , 0.8 ]], dtype=float32)
```
---
### `slice(x, starts, sizes)`
返回从张量中提取想要的切片，此操作从由starts指定位置开始的张量x中提取一个尺寸sizes的切片，切片sizes被表示为张量形状，提供公式`x[starts[0]:starts[0]+sizes[0], ..., starts[-1]:starts[-1]+sizes[-1]]`
参数：
- `x: var_like` 输入变量
- `starts : var_like` 输入变量，切片提取起始位置
- `sizes : var_like` 输入变量，切片提取的尺寸
返回：切片数据
返回类型：`Var`
示例：
```python
>>> expr.slice([[1., 2., 3.], [4., 5., 6.]], [0, 1], [1, 2])
array([[2., 3.]], dtype=float32)
```
---
### `split(x, size_splits, axis)`
返回切割张量的子张量数据
参数：
- `x: var_like` 输入变量
- `size_splits : var_like` 输入变量，int类型，切成的份数
- `axis : int` 输入变量，进行切割的维度
返回：切割张量的子张量数据
返回类型：`Var`
示例：
```python
>>> expr.split([[1., 2., 3.], [4., 5., 6.]], [1, 1], 0)
[array([[1., 2., 3.]], dtype=float32), array([[4., 5., 6.]], dtype=float32)]
```
---
### `strided_slice(x, begin, end, strides, begin_mask=0, end_mask=0, ellipsis_mask=0, new_axis_mask=0, shrink_axis_mask=0)`
从给定的 x 张量中提取一个尺寸 (end-begin)/stride 的片段，从 begin 片段指定的位置开始，以步长 stride 添加索引，直到所有维度都不小于 end，这里的 stride 可以是负值，表示反向切片,公式：`x[begin[0]:strides[0]:end[0], ..., begin[-1]:strides[-1]:end[-1]]`。
参数：
- `x: var_like` 输入变量
- `begin : var_like` 输入变量，int类型，开始切片处
- `end : var_like` 输入变量，int类型，终止切片处
- `strides : var_like` 输入变量，int类型，步长
- `begin_mask : int` 输入变量，默认为0
- `end_mask : int` 输入变量，默认为0
- `ellipsis_mask : int` 输入变量，默认为0
- `new_axis_mask : int` 输入变量，默认为0
- `shrink_axis_mask : int` 输入变量，默认为0
返回：提取的片段
返回类型：`Var`
示例：
```python
>>> expr.strided_slice([[1., 2., 3.], [4., 5., 6.]], [0, 0], [1, 2], [1, 2])
array([[1.]], dtype=float32)
```
---
### `concat(values, axis)`
根据axis设置的维度拼接输入变量values中的数据
参数：
- `values : [var_like]` 输入变量
- `axis : int` 输入变量，操作的维度
返回：拼接后的数据
返回类型：`Var`
示例：
```python
>>> expr.concat([[1., 2., 3.], [4., 5., 6.]], 0)
array([1., 2., 3., 4., 5., 6.], dtype=float32)
```
---
### `where(x)`
返回满足条件`x > 0`的索引
参数：
- `x : [var_like]` 输入变量
返回：索引，int类型
返回类型：`Var`
示例：
```python
>>> expr.where([0., 1., -2., 3.3])
array([[1],[3]], dtype=int32)
```
---
### `convert(x, format)`
将输入变量 x 的 data_format 转换为 format
参数：
- `x : [var_like]` 输入变量
- `format : data_format` 输入变量，[NCHW, NHWC, NC4HW4]
返回：转换后的format
返回类型：`Var`
示例：
```python
>>> x = expr.reshape(expr.range(0., 8., 1.), [1, 2, 2, 2]) # data_format is NCHW
>>> expr.convert(x, expr.NHWC)
array([[[[0., 4.], [1., 5.]],
[[2., 6.], [3., 7.]]]], dtype=float32)
```
---
### `transpose(x, perm)`
返回一个转置的数据，转置的维度为perm
参数：
- `x : [var_like]` 输入变量
- `perm : [int] or var_like` 新的维度序列
返回：通过perm转置的数据
返回类型：`Var`
示例：
```python
>>> expr.transpose([[1.,2.,3.],[4.,5.,6.]], [1,0])
array([[1., 4.],
[2., 5.],
[3., 6.]], dtype=float32)
```
---
### `channel_shuffle(x, axis)`
做以下操作：
x = _Convert(x, NHWC);
x = _Reshape(x, {0, 0, 0, group, -1}, NHWC);
x = _Transpose(x, {0, 1, 2, 4, 3});
x = _Reshape(x, {0, 0, 0, -1}, NHWC);
channel_shuffle_res = _Convert(x, NC4HW4);
参数：
- `x : [var_like]` 输入变量
- `axis : int` 输入变量
返回：
返回类型：`Var`
示例：
```python
>>> x = expr.reshape(expr.range(0., 8., 1.), [1, 4, 1, 2])
>>> expr.convert(expr.channel_shuffle(x, 2), expr.NCHW)
array([[[[0., 1.]],
[[4., 5.]],
[[2., 3.]],
[[6., 7.]]]], dtype=float32)
```
---
### `reverse(x, axis)`
在输入x变量在axis[0]维度进行翻转
参数：
- `x : var_like` 输入变量
- `axis : var_like` 输入变量
返回：反转序列的值
返回类型：`Var`
示例：
```python
>>> expr.reverse(expr.range(-4., 4., 1.), [0])
array([ 3., 2., 1., 0., -1., -2., -3., -4.], dtype=float32)
```
---
### `reverse_sequence(x, y, batch_dim, seq_dim)`
沿着batch_dim维度对x进行切片并反转维度seq_dim上的y[i]元素
参数：
- `x : var_like` 输入变量
- `y : var_like` 输入变量
- `batch_dim : int` 输入变量，切片的维度
- `seq_dim : int` 输入变量，反转的维度
返回：反转序列的值
返回类型：`Var`
示例：
```python
>>> x = expr.reshape(expr.range(0., 8., 1.), [2, 4])
>>> expr.reverse_sequence(x, [1, 1], 0, 1)
array([[0., 1., 2., 3.],
[4., 5., 6., 7.]], dtype=float32)
```
---
### `crop(x, size, axis, offset)`
裁剪输入数据x到size对应的尺寸，通过axis维度，起始点offset
参数：
- `x : var_like` 输入变量，data_format 为 NC4HW4.
- `size : var_like` 返回裁剪的尺寸
- `axis : int` 输入变量，裁剪的维度
- `offset : [int]` 输入变量，裁剪的起始点
返回：裁剪后的数据
返回类型：`Var`
示例：
```python
>>> x = expr.reshape(expr.range(0., 16., 1.), [1, 1, 4, 4])
>>> x = expr.convert(x, expr.NC4HW4)
>>> size = expr.const([0.0, 0.0, 0.0, 0.0], [1, 1, 2, 2])
>>> expr.convert(expr.crop(x, size, 2, [1, 1]), expr.NCHW)
array([[[[ 5., 6.],
[ 9., 10.]]]], dtype=float32)
```
---
### `resize(x, x_scale, y_scale)`
调整输入值x的(高度、宽度)的大小，公式为：(y_scale * height, x_scale * width).
参数：
- `x : var_like` 输入变量
- `x_scale : float` 输入变量，图像高度缩放比例
- `y_scale : float` 输入变量，图像宽度缩放比例
返回：(y_scale * height, x_scale * width)的值
返回类型：`Var`
示例：
```python
>>> x = expr.reshape(expr.range(0., 4., 1.), [1, 1, 2, 2])
>>> x = expr.convert(x, expr.NC4HW4)
>>> expr.convert(expr.resize(x, size, 2, 2), expr.NCHW)
array([[[[0. , 0.5, 1. , 1. ],
[1. , 1.5, 2. , 2. ],
[2. , 2.5, 3. , 3. ],
[2. , 2.5, 3. , 3. ]]]], dtype=float32)
```
---
### `crop_and_resize(x, boxes, box_ind, crop_size, method=_F.BILINEAR, extrapolation_value=0.)`
从输入图像数据中提取固定大小的切片，并指定插值算法 (method) resize成指定的输出大小(crop_size)
参数：
- `x : var_like` 输入变量，data_format 为 NHWC.
- `boxes : var_like` 输入变量，int类型，需要划分的区域
- `box_ind : var_like` 输入变量，是boxes和x之间的索引
- `crop_size : var_like` 输入变量，表示RoiAlign之后的大小
- `method : Interp_Method` 输入变量，[NEAREST, BILINEAR]，默认是BILINEAR，差值算法
- `extrapolation_value : float` 输入变量，默认为0，外插值，boxes>1时裁剪超出图像范围，自动补齐的填充值
返回：crop_size数据
返回类型：`Var`
示例：
```python
>>> x = expr.reshape(expr.range(0., 16., 1.), [1, 1, 4, 4])
>>> x = expr.convert(x, expr.NHWC)
>>> boxes = expr.const([0.2, 0.3, 0.4, 0.5], [1, 4])
>>> expr.convert(expr.crop_and_resize(x, boxes, [0], [2, 2]), expr.NHWC)
array([[[[3.3000002],
[3.9 ]],
[[5.7000003],
[6.3 ]]]], dtype=float32)
```
---
### `pad(x, paddings, mode=_F.CONSTANT)`
对输入数x某个维度进行填充或复制
参数：
- `x : var_like` 输入变量
- `paddings : var_like` 输入变量，形状是[x.ndim, 2]，int类型，填充的维度
- `mode : PadValue_Mode` 输入变量，[CONSTANT(填充常数), REFLECT(镜像复制), SYMMETRIC(对称复制)]， 默认为CONSTANT
返回：填充或复制后的数据
返回类型：`Var`
示例：
```python
>>> expr.pad([[1.,2.],[3.,4.]], [[0, 1], [1,2]])
array([[0., 1., 2., 0., 0.],
[0., 3., 4., 0., 0.],
[0., 0., 0., 0., 0.]], dtype=float32)
```
---
### `randomuniform(shape, dtype=_F.float, low=0.0, high=1.0, seed0=0, seed1=1)`
用于从均匀分布中输出随机值
参数：
- `shape : axis_like` 输入变量，数据形状
- `dtype : dtype` 输出的类型：[float, double, int, int64, uint8]，默认为float
- `low : float` 输入变量，随机值范围下限，默认为0
- `high : float` 输入变量，随机值范围上限，默认为1
- `seed0 : int` 输入变量，随机因子，默认为0
- `seed1 : int` 输入变量，随机因子，默认为0
返回：随机值
返回类型：`Var`
示例：
```python
>>> expr.pad([[1.,2.],[3.,4.]], [[0, 1], [1,2]])
array([[0., 1., 2., 0., 0.],
[0., 3., 4., 0., 0.],
[0., 0., 0., 0., 0.]], dtype=float32)
```
---
### `expand_dims(x, axis)`
给输入数据在axis轴上新增一个维度
参数：
- `x : var_like` 输入变量
- `axis : int or var_like` 输入变量，int类型，指定扩大输入数据形状的维度索引值
返回：新增维度后的数据
返回类型：`Var`
示例：
```python
>>> expr.expand_dims([1.,2.], 0)
array([[1., 2.]], dtype=float32)
```
---
### `rank(x)`
返回输入数据的维度
参数：
- `x : var_like` 输入变量
返回：维度信息
返回类型：`Var`
示例：
```python
>>> expr.rank([[1.,2.],[3.,4.]])
array(2, dtype=int32)
```
---
### `size(x)`
返回输入数据的大小
参数：
- `x : var_like` 输入变量
返回：大小size
返回类型：`Var`
示例：
```python
>>> expr.size([[1.,2.],[3.,4.]])
array(4, dtype=int32)
```
---
### `shape(x)`
返回输入数据的形状
参数：
- `x : var_like` 输入变量
返回：形状
返回类型：`Var`
示例：
```python
>>> expr.shape([[1.,2.],[3.,4.]])
array([2, 2], dtype=int32)
```
---
### `stack(values, axis=0)`
将输入数据x和要沿着axis维度进行拼接
参数：
- `x : var_like` 输入变量
- `axis : int` 输入变量，默认为0，指明对矩阵的哪个维度进行拼接
返回：拼接的数据
返回类型：`Var`
示例：
```python
>>> x = expr.const([1., 2.], [2])
>>> y = expr.const([3., 4.], [2])
>>> expr.stack([x, y])
array([[1., 2.],
[3., 4.]], dtype=float32)
```
---
### `unstack(x, axis=0)`
将输入数据x沿着axis维度堆叠为r-1级数据
参数：
- `x : var_like` 输入变量
- `axis : int` 输入变量，默认为0，指明对矩阵的哪个维度进行分解
返回：分解的数据
返回类型：`Var`
示例：
```python
>>> expr.unstack([[1., 2.], [3., 4.]])
[array([1., 2.], dtype=float32), array([3., 4.], dtype=float32)]
```
---
### `fill(shape, value)`
创建一个填充有标量值的数据
参数：
- `shape : var_like` 输入变量，int类型，定义输出张量形状的整数数组
- `value : var_like` 输入变量，一个标量值，用于填充输出数据。
返回：填充有标量值的指定形状的数据
返回类型：`Var`
示例：
```python
>>> expr.fill([2,3], 1.0)
array([[1., 1., 1.],
[1., 1., 1.]], dtype=float32)
```
---
### `tile(x, multiples)`
返回输入数x在同一维度上重复multiples次的数据
参数：
- `x : var_like` 输入变量
- `multiples : var_like` 输入变量，int类型，同一维度上重复的次数
返回：x重复multiples次的数据
返回类型：`Var`
示例：
```python
>>> expr.tile([2,3], [3])
array([2, 3, 2, 3, 2, 3], dtype=int32)
```
---
### `gather(x, index)`
根据下标返回对应的值
参数：
- `x : var_like` 输入变量
- `index : var_like` 输入变量，int类型，下标索引
返回：`x[index]`的值
返回类型：`Var`
示例：
```python
>>> expr.gather([[1.,2.],[3.,4.]], [1])
array([[3., 4.]], dtype=float32)
```
---
### `gather_nd(x, indices)`
根据indeces描述的索引，在x中提取元素，拼接成一个新的数据
参数：
- `x : var_like` 输入变量
- `indices : var_like` 输入变量，int类型，索引
返回：`x[indices[0], ..., indices[-1]]`
返回类型：`Var`
示例：
```python
>>> expr.gather_nd([[1.,2.],[3.,4.]], [1, 0])
array(3., dtype=float32)
```
---
### `select(cond, x, y)`
返回根据'cond'从'x'或'y'中选择的元素
参数：
- `cond : var_like` 输入变量
- `x : var_like` 输入变量
- `y : var_like` 输入变量
返回：根据条件选中的元素
返回类型：`Var`
示例：
```python
>>> expr.select([1., 0., 2.], [-1., -2., -3.], [1., 2., 3.])
array([-1., 2., -3.], dtype=float32)
```
---
### `squeeze(x, axes=[])`
删除到指定位置的尺寸为1的新数据
参数：
- `x : var_like` 输入变量
- `axes : axis_like` 输入变量，默认为[]，用来指定要删掉的为1的维度
返回：变换后的数据
返回类型：`Var`
示例：
```python
>>> expr.squeeze([[[1.0, 2.0]]], [0, 1])
array([1., 2.], dtype=float32)
```
---
### `unsqueeze(x, axes=[])`
插入到指定位置的尺寸为1的新数据
参数：
- `x : var_like` 输入变量
- `axes : axis_like` 输入变量，默认为[]，用来指定要增加的为1的维度
返回：变换后的数据
返回类型：`Var`
示例：
```python
>>> expr.unsqueeze([1.0, 2.0], [0, 1])
array([[[1., 2.]]], dtype=float32)
```
---
### `depth_to_space(x, axis)`
将数据从深度重新排列为空间数据块
参数：
- `x : var_like` 输入变量，data_format为NHWC.
- `axis : int` 输入变量，操作的维度
返回：空间数据块
返回类型：`Var`
示例：
```python
>>> x = expr.reshape(expr.range(0., 12., 1.), [1, 4, 1, 3])
>>> expr.depth_to_space(x, 2)
array([[[[ 0., 3., 1., 4., 2., 5.],
[ 6., 9., 7., 10., 8., 11.]]]], dtype=float32)
```
---
### `space_to_depth(x, axis)`
重新排列空间数据块，进入深度。
参数：
- `x : var_like` 输入变量，data_format为NHWC.
- `axis : int` 输入变量，操作的维度
返回：空间数据块，进入深度
返回类型：`Var`
示例：
```python
>>> x = expr.reshape(expr.range(0., 16., 1.), [1, 1, 4, 4])
>>> x = expr.convert(x, expr.NHWC)
>>> expr.space_to_depth(x, 2)
array([[[[ 0., 1., 4., 5.],
[ 2., 3., 6., 7.]],
[[ 8., 9., 12., 13.],
[10., 11., 14., 15.]]]], dtype=float32)
```
---
### `batch_to_space_nd(x, block_shape, crops)`
将给定的 “batch” 从零维重构为具有“block-Shape + [batch]”形状的 “M+1” 维，其中 block-Shape 是参数，batch 是指定的张量。这里根据给定的裁剪数组对 in-between 结果进行裁剪。
参数：
- `x : var_like` 输入变量，data_format为NC4HW4.
- `block_shape : var_like` 输入变量，int类型，一维数组的形状必须为 [M]，因为所有值都必须大于或等于 1
- `crops : var_like` 输入变量，int类型，[M, 2] 的二维数组形状，其​​中所有值必须大于或等于0，这里的crop[i] = [cropStart,cropEnd] 定义了从输入维度 i + 1 裁剪的部分
返回：指定批次的重塑版本的数据
返回类型：`Var`
示例：
```python
>>> x = expr.reshape(expr.range(0., 12., 1.), [4, 1, 1, 3])
>>> x = expr.convert(x, expr.NC4HW4)
>>> crops = expr.const([0, 0, 0, 0], [2, 2], expr.NCHW, expr.int)
>>> expr.convert(expr.batch_to_space_nd(x, [2, 2], crops), expr.NHWC)
array([[[[ 0.],
[ 3.],
[ 1.],
[ 4.],
[ 2.],
[ 5.]],
[[ 6.],
[ 9.],
[ 7.],
[10.],
[ 8.],
[11.]]]], dtype=float32)
```
---
### `space_to_batch_nd(x, block_shape, paddings)`
将指定输入空间的空间维度拆分为块的矩阵，其形状为 blockShape，其中 blockshape 是参数。这里根据指定的填充数组填充空间维度
参数：
- `x : var_like` 输入变量，data_format为NC4HW4.
- `block_shape : var_like` 输入变量，int类型，它是一维数组，必须具有 [M] 的形状，因为所有值必须大于或等于 1
- `paddings : var_like` 输入变量，int类型，一个形状为 [M, 2] 的二维数组，所有值必须大于或等于0。这里 padding 等于 [padStart, padEnd]
返回：指定输入空间的拆分版本的数据
返回类型：`Var`
示例：
```python
>>> x = expr.reshape(expr.range(0., 12., 1.), [3, 1, 2, 2])
>>> x = expr.convert(x, expr.NC4HW4)
>>> paddings = expr.const([0, 0, 0, 0], [2, 2], expr.NCHW, expr.int)
>>> expr.convert(expr.space_to_batch_nd(x, [2, 2], paddings), expr.NHWC)
array([[[[ 0.]]],
[[[ 4.]]],
[[[ 8.]]],
[[[ 1.]]],
[[[ 5.]]],
[[[ 9.]]],
[[[ 2.]]],
[[[ 6.]]],
[[[10.]]],
[[[ 3.]]],
[[[ 7.]]],
[[[11.]]]], dtype=float32)
```
---
### `elu(x, alpha)`
激励函数，主要是为计算图归一化返回结果而引进的非线性部分
参数：
- `x : var_like` 输入变量
- `alpha : float` 输入变量，预定义常量
返回：
返回类型：`Var`
示例：
```python
>>> expr.elu([-1.0, 2.0], 1.673263)
array([-1.0577048, 2.], dtype=float32)
```
---
### `selu(x, scale, alpha)`
比例指数线性单元激活函数
参数：
- `x : var_like` 输入变量
- `scale : float` 输入变量，预定义常量
- `alpha : float` 输入变量，预定义常量
返回：缩放的指数单位激活： scale * elu(x, alpha).
返回类型：`Var`
示例：
```python
>>> expr.selu([-1.0, 2.0], 1.0507, 1.673263)
array([-1.1113304, 2.1014], dtype=float32)
```
---
### `matrix_band_part(x, num_lower, num_upper)`
计算矩阵维度
参数：
- `x : var_like` 输入变量
- `num_lower : var_like` 输入变量，int类型，要保持的对角线的数量，如果为负,则保留整个下三角
- `num_upper : var_like` 输入变量，int类型，要保留的superdiagonals数，如果为负,则保持整个上三角.
返回：返回一个与 x 具有相同的类型且有相同形状的秩为k的数据，提取的带状数据
返回类型：`Var`
示例：
```python
>>> expr.matrix_band_part([[-2., 1.], [-1., 2.]], 1, -1)
array([[-2., 1.],
[-1., 2.]], dtype=float32)
```
---
### `moments(x, axes=[2, 3], shift=None, keep_dims=True)`
用于在指定维度计算均值和方差
参数：
- `x : var_like` 输入变量，data_format为NC4HW4
- `axes : axis_like` 输入变量，int类型，指定计算均值和方差的轴，默认是[2,3]
- `shift : var_like` 输入变量，int类型，未在当前实现中使用，默认是None
- `keep_dims : bool` 输入变量，保持维度，表示产生是否与输入数据具有相同的维度，默认是true
返回：均值和方差
返回类型：`Var`
示例：
```python
>>> x = expr.reshape(expr.range(0., 4., 1.), [1, 1, 2, 2])
>>> x = expr.convert(x, expr.NC4HW4)
>>> expr.moments(x)
[array([[[[1.5]]]], dtype=float32), array([[[[1.25]]]], dtype=float32)]
```
---
### `setdiff1d(x, y)`
返回在x中出现，但是在y中没有出现的的元素
参数：
- `x : var_like` 输入变量
- `y : var_like` 输入变量
返回：在x中出现，但是在y中没有出现的的元素
返回类型：`Var`
示例：
```python
>>> expr.setdiff1d([1, 2, 3], [2, 3, 4])
array([1], dtype=int32)
```
---
### `zeros_like(x)`
把所有元素都置为零
参数：
- `x : var_like` 输入变量
返回：所有元素都为零的张量
返回类型：`Var`
示例：
```python
>>> expr.zeros_like([[1, 2], [3, 4]])
array([[0, 0],
[0, 0]], dtype=int32)
```
---
### `range(start, limit, delta)`
创建数字序列变量
参数：
- `start : var_like` 输入变量，int类型，表示范围的起始编号
- `limit : var_like` 输入变量，int类型，最大编号限制，并且不包括在内
- `delta : var_like` 输入变量，int类型，增量
返回：数字序列变量
返回类型：`Var`
示例：
```python
>>> expr.range(1.0, 7.0, 2.0)
array([1., 3., 5.], dtype=float32)
```
---
### `sort(x, axis=-1, arg=False, descend=False)`
排序
参数：
- `x : var_like` 输入变量
- `axis : int` 输入变量，int类型
- `arg : bool` 输入变量，是否返回排序元素的index， 默认为false
- `descend : bool` 输入变量，true代表倒序，false代表正序，默认为false
返回：排序结果
返回类型：`Var`
示例：
```python
>>> expr.sort([[5, 0], [1, 3]])
array([[1, 0],
[5, 3]], dtype=int32)
```
---
### `nms(boxes, scores, max_detections, iou_threshold=-1.0, score_threshold=-1.0)`
非极大值抑制算法，搜索局部极大值，抑制非极大值元素
参数：
- `boxes : var_like` 输入变量，形状必须为[num, 4]
- `scores : var_like` 输入变量，float类型的大小为[num_boxes]代表上面boxes的每一行，对应的每一个box的一个score
- `max_detections : int` 输入变量，一个整数张量，代表最多可以利用NMS选中多少个边框
- `iou_threshold : float` 输入变量，IOU阙值展示的是否与选中的那个边框具有较大的重叠度，默认为0
- `score_threshold : float` 输入变量，默认为float_min，来决定什么时候删除这个边框
返回：搜索局部极大值，抑制非极大值元素
返回类型：`Var`
示例：
```python
>>> expr.nms([[1, 1, 4, 4], [0, 0, 3, 3], [5, 5, 7, 7]], [0.9, 0.5, 0.1], 3, 0.1)
array([0, 2], dtype=int32)
array([5., 4.5])
```
---
### `raster(vars, region, shape)`
使用`Raster`创建一个映射关系，`Raster`是表示内存映射的元算子；
`region`使用`[int]`来描述；其表示了从`var`到结果的内存映射关系，对应的C++数据结构如下：
```cpp
struct View {
int32_t offset = 0;
int32_t stride[3] = {1, 1, 1};
};
struct Region {
View src;
View dst;
int32_t size[3] = {1, 1, 1};
};
```
在Python中使用11个`int`来表示Region，顺序为：`src_offset, src_stride[3], dst_offset, dst_stride[3], size[3]`；多个region则继续增加int数目，总数目应该为11的倍数；并且region的数目应该与vars的数目相等
参数：
- `var : [Var]` 输入变量，内存映射的数据来源
- `region : [int]` 表示内存映射关系
- `shape : [int]` 输出变量的形状
返回：内存映射后的变量
返回类型：`Var`
示例：
```python
>>> var = expr.const([1., 2., 3. ,4.], [2, 2])
>>> expr.raster([var], [0, 4, 1, 2, 0, 4, 2, 1, 1, 2, 2], [2, 2]) # do transpose
array([[1., 3.],
[2., 4.]], dtype=float32)
```
---
### `quant(var, scale, min=-128, max=127, zero=0)`
量化，根据`scale`把float类型的输入量化为int8类型的输出，量化公式为：`y = clamp(x / scale + zero, min, max)`
参数：
- `var : Var` 输入变量，dtype为`float`, data_format为`NC4HW4`
- `scale : Var` 量化的scale值，dtype为`float`
- `min : int` 输出变量的最小值，默认为-128
- `max : int` 输出变量的最大值，默认为127
- `zero : int` 零点值，默认为0
返回：量化后的int8类型变量
返回类型：`Var`
示例：
```python
>>> x = expr.const([1., 2., 3. ,4.], [4])
>>> x = expr.convert(x, expr.NC4HW4)
>>> expr.quant(x, 0.2, -128, 127)
array([-128, -128, -127, -127], dtype=int8)
```
---
### `dequant(var, scale, zero=0)`
反量化，根据`scale`把int8类型的输入反量化为float类型的输出，量化公式为：`y = (x - zero) * scale`
参数：
- `var : Var` 输入变量，dtype为int8
- `scale : Var` 反量化的scale值，dtype为float
- `zero : int` 反量化的zero值，默认为0
返回：反量化后的float类型变量
返回类型：`Var`
示例：
```python
>>> x = expr.const([-128, -128, -127, -127], [4], NCHW, expr.int8)
>>> x = expr.convert(x, expr.NC4HW4)
>>> expr.dequant(x, 0.2, 0)
array([0. , 0. , 0.2, 0.2], dtype=float32)
```
---
### `histogram(input, binNum, minVal, maxVal)`
计算输入变量在指定范围内的直方图分布
参数：
- `input : var_like` 输入变量
- `binNum : int` 直方图桶的个数
- `minVal : int` 直方图计算的最小值
- `maxVal : int` 直方图计算的最大值
返回：直方图统计结果
返回类型：`Var`
示例：
```python
>>> expr.histogram(expr.range(0., 10.0, 1.0), 5, 1, 9)
array([2., 2., 1., 2., 2.], dtype=float32)
```
---
### `detection_post_process(encode_boxes, class_predictions, anchors, num_classes, max_detections, max_class_per_detection, detections_per_class, nms_threshold, iou_threshold, use_regular_nms, centersize_encoding)`
SSD检测模型后处理函数
参数：
- `encode_boxes : Var` 检测框坐标
- `class_predictions : Var` 分类结果概率
- `anchors : Var` 锚点
- `num_classes : int` 分类个数
- `max_detections : int` 最大检测值
- `max_class_per_detection : int` 每个检测的最大种类
- `detections_per_class : int` 每个类别的检测结果
- `nms_threshold : float` nms阈值
- `iou_threshold : float` iou阈值
- `use_regular_nms : bool` 是否使用常规nms，目前仅支持`False`
- `centersize_encoding : [float]` 中心尺寸编码
返回：后处理结果
返回类型：`Var`
---
### `roi_pooling(input, roi, pooledHeight, pooledWidth, spatialScale, outputGrad, backwardDiff)`
roi_pooling
参数：
- `input : Var` 输入变量，dtype为int8
- `roi : Var` 反量化的scale值，dtype为float
- `pooledHeight : int` 反量化的zero值，默认为0
- `pooledWidth : int` 反量化的zero值，默认为0
返回：roipooling结果
返回类型：`Var`
示例：
```python
TODO
```
---
### `roi_align(input, roi, pooledHeight, pooledWidth, spatialScale, samplingRatio, aligned, poolType, outputGrad, backwardDiff)`
roialign
参数：
- `input : Var` 输入变量，dtype为int8
- `roi : Var` 反量化的scale值，dtype为float
- `pooledHeight : int` pooling的
- `pooledHeight : int` 反量化的zero值，默认为0
返回：roialign结果
返回类型：`Var`
示例：
```python
TODO
```
---
### `jsonop(inputs, describe, output_number)`
jsonop
对于MNN模型支持的算子，但没有相应表达式透出的情况，可以使用jsonop接口，以json描述算子
参数：
- `inputs` : List[Var] 输入变量数组，任意类型
- `describe` : str ，算子的json描述
- `output_number` : int, 算子输出数
---
**以下函数为框架开发者使用函数，普通用户不建议使用！**
---
### `load_as_dict(fileName)` *[deprecated]*
从文件中加载模型，并将模型转换为计算图，以`dict`的形式返回计算图的所有节点名称和`Var`
*不建议使用该接口*
参数：
- `fileName:str` 模型文件路径
返回：加载的模型计算图，其`key`为`str`，`value`为`Var`
返回类型：`dict`
示例：
```python
>>> vars = expr.load_as_dict('mobilenet_v1.mnn')
>>> vars.keys()
dict_keys(['conv1', 'conv2_1/dw', 'conv2_1/sep', 'conv2_2/dw', 'conv2_2/sep', 'conv3_1/dw', 'conv3_1/sep', 'conv3_2/dw', 'conv3_2/sep', 'conv4_1/dw', 'conv4_1/sep', 'conv4_2/dw', 'conv4_2/sep', 'conv5_1/dw', 'conv5_1/sep', 'conv5_2/dw', 'conv5_2/sep', 'conv5_3/dw', 'conv5_3/sep', 'conv5_4/dw', 'conv5_4/sep', 'conv5_5/dw', 'conv5_5/sep', 'conv5_6/dw', 'conv5_6/sep', 'conv6/dw', 'conv6/sep', 'data', 'fc7', 'pool6', 'prob'])
```
---
### `get_inputs_and_outputs(allVariable)` *[deprecated]*
获取`dict`形式计算图的输入输出节点，可以在使用V3接口时获取输入输出的信息
参数：
- `allVariable:dict` 计算图的`dict`形式，其`key`为`str`，`value`为`Var`
返回：计算图的输入输出，其中输入输出都为`dict`形式，其`key`为`str`，`value`为`Var`
返回类型：`(dict, dict)`
示例：
```python
>>> vars = expr.load_as_dict('mobilenet_v1.mnn')
>>> inputs, outputs = expr.get_inputs_and_outputs(vars)
>>> inputs.keys()
dict_keys(['data'])
>>> outputs.keys()
dict_keys(['prob'])
```
Reference in New Issue View Git Blame Copy Permalink