5.9.4. Ops API

4 月 ago
admin
119 minutes

5.9.4. Ops API

仓颉 TensorBoost 的 Operator 功能使用仓颉函数实现，用户只需要导入 operator package (from CangjieTB import ops.*) 即可直接使用仓颉 TensorBoost 已经封装好的函数。

仓颉 TensorBoost 的算子与 mindspore 算子完全一致，与 pytorch 的对照可参见 mindspore 与 pytorch 的 api 映射。

附录 D 中的示例代码，在动态图模式下可以直接运行，静态图模型下运行，需增加调用 Tensor 的evaluate 方法触发计算。

自动微分系统中，部分算子微分求解过程中需要人工定义伴随函数或反向传播函数，已在算子描述中注明，伴随函数自动微分系统会自动调用，建议用户不要直接调用。

算子的输入不符合要求时，会抛出异常，有以下几种类型：

  1. 输入的数据类型不支持
  2. 输入的值或者 Tensor 的形状不符合要求
  3. 运行后端或者模式不符合要求

abs

public func abs(input: Tensor): Tensor

函数 abs 实现 Abs 算子功能，用于计算 Tensor 元素的绝对值。

输入：

名称含义
input输入的 Tensor，GPU & CPU 支持 Float16\Float32\Float64 类型; Ascend 支持 Float16\Float32\Int32。

输出：

名称含义
outputTensor，与原始变量的类型相同。

支持平台：Ascend, GPU, CPU

反向函数：

public func absGrad(input: Tensor, gradOut: Tensor): Tensor

微分伴随函数：

public func adjointAbs(input: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([2.0, -4.0, -1.4, -5.0, 6.0]), shape: Array<Int64>([5]))
    let output = abs(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[5], dtype=Float32, value=
[2.00000000e+00 4.00000000e+00 1.39999998e+00 5.00000000e+00 6.00000000e+00])

acos

public func acos(input: Tensor): Tensor

函数 acos 实现 ACos 算子功能，按照 element-wise 的规则计算 Tensor 元素的 arccosine 值。

输入：

名称含义
x输入的 Tensor，支持 Float16\Float32 类型。

输出：

名称含义
outputTensor，与输入的 dtype 和 shape 相同。

支持平台：Ascend, GPU

反向函数：

public func acosGrad(x: Tensor, gradOut: Tensor): Tensor

微分伴随函数：

public func adjointAcos(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x = Tensor(Array<Float32>([0.0295925457, 0.6197745800, 0.4479851723, 0.3968157172, 0.2453137785]), shape: Array<Int64>([5]))
    let output = acos(x)
    print(output)
    return 0
}

输出为：

Tensor(shape=[5], dtype=Float32, value=
[1.54119945e+00 9.02340889e-01 1.10628593e+00 1.16275120e+00 1.32295299e+00])

acosh

public func acosh(input: Tensor): Tensor

计算输入元素的反向双曲余弦

outi=cosh−1(inputi)

输入：

名称含义
input输入 Tensor, 支持 Float16\Float32 类型, 输入 Tensor 的秩必须在[0,7]范围内。

输出：

名称含义
output输出 Tensor, 与输入 的 shape 和 dtype 相同

支持平台：Ascend, GPU, CPU

反向函数：

public func acoshGrad(x: Tensor, y: Tensor): Tensor

微分伴随函数：

public func adjointAcosh(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 1.5, 3.0, 100.0]), shape: [4])
    let output = acosh(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[4], dtype=Float32, value=
[0.00000000e+00 9.62423682e-01 1.76274729e+00 5.29829216e+00])

adamWeightDecay

public func adamWeightDecay(input: Tensor, m: Tensor, v: Tensor, lr: Float32, beta1: Float32, beta2: Float32, epsilon: Float32, decay: Float32, gradient: Tensor, useLocking!: Bool = false): Tensor

通过权重衰减的自适应力矩估计算法更新梯度(AdamWeightDecay)

Adam 原理详见 Adam: A Method for Stochastic Optimization, AdamWeightDecay 原理详见Decoupled Weight Decay Regularization

更新公式如下:

m=β1∗m+(1−β1)∗gv=β2∗v+(1−β2)∗g∗gupdate=mv+ϵupdate={update+weightdecay∗w if weightdecay>0update otherwise w=w−lr∗update

公式中符号与函数入参关系为:

m 代表第一个矩阵向量 m, v 代表第二个矩阵向量 v，g 代表 gradient, β1, β2 代表 beta1, beta2, lr 代表 lr, w 代表 input, decay 代表 decay, ϵ 代表 epsilon。

输入：

名称含义
input要更新的权重，支持 Float32 类型，必须设置为 parameter
m更新公式中的第一个矩阵向量，shape，dtype 与 input 一致，必须设置为 parameter
v更新公式中的第一个矩阵向量，shape，dtype 与 input 一致，均方梯度类型也与 input 一致，必须设置为 Parameter
lr更新公式中的 lr, 论文建议值为 10 的 -8 次方，shape，dtype 与 input 一致
beta1第一次评估的指数衰减率,论文建议值为 0.9
beta2第一次评估的指数衰减率,论文建议值为 0.999
epsilon与分母做加法提高数值稳定性
decay权重的衰减值
gradient梯度，shape 和 dtype 和 input 一致
useLocking是否启用锁保护变量更新。 如果为 true, input, m, n 的更新将被保护，如果为 false，结果将不可预测。默认值：false

输出：

名称含义
output0更新后的 input, shape， dtype 与输入 input 相同
output1更新后的 m, shape， dtype 与输入 m 相同
output2更新后的 v, shape， dtype 与输入 v 相同

支持平台：Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = parameter(onesTensor(Array<Int64>([2, 2])), "input")
    let m = parameter(onesTensor(Array<Int64>([2, 2])), "m")
    let v = parameter(onesTensor(Array<Int64>([2, 2])), "v")
    let gradient = onesTensor(Array<Int64>([2, 2]))
    let output = adamWeightDecay(input, m, v, 0.001, 0.9, 0.999, 1e-8, 0.0, gradient)
    print(input)
    print(m)
    print(v)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[ 9.99000013e-01  9.99000013e-01]
 [ 9.99000013e-01  9.99000013e-01]])
Tensor(shape=[2, 2], dtype=Float32, value=
[[ 1.00000000e+00  1.00000000e+00]
 [ 1.00000000e+00  1.00000000e+00]])
Tensor(shape=[2, 2], dtype=Float32, value=
[[ 1.00000000e+00  1.00000000e+00]
 [ 1.00000000e+00  1.00000000e+00]])

add

public func add(input0: Tensor, input1: Tensor): Tensor
public func add(input0: Float16, input1: Tensor): Tensor
public func add(input0: Tensor, input1: Float16): Tensor
public func add(input0: Float32, input1: Tensor): Tensor
public func add(input0: Tensor, input1: Float32): Tensor
public func add(input0: Float64, input1: Tensor): Tensor
public func add(input0: Tensor, input1: Float64): Tensor
public func add(input0: Int32, input1: Tensor): Tensor
public func add(input0: Tensor, input1: Int32): Tensor

函数 add 实现 Add 算子功能，用于计算两个 Tensor 逐个元素相加。输入必须是两个 Tensor 或者一个 Tensor 和一个标量。它们的输入类型必须一致，它们的形状可以被广播。当输入是一个 Tensor 和一个标量时，这个标量只能是一个常数。

输入：

名称含义
input0Tensor 或者 Number，GPU & CPU 支持 Float16\Float32\Float64\Int32 类型，Ascend 支持 Float16\Float32\Int32， dtype 或者类型要求与 input1 一致
input1Tensor 或者 Number，GPU & CPU 支持 Float16\Float32\Float64\Int32 类型，Ascend 支持 Float16\Float32\Int32， dtype 或者类型要求与 input0 一致

输出：

支持平台：Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input0 = Tensor(Array<Float32>([1.0, 2.0, 3.0]), shape: Array<Int64>([3]))
    let input1 = Tensor(Array<Float32>([4.0, 5.0, 6.0]), shape: Array<Int64>([3]))
    let output = add(input0, input1)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Float32, value=
[5.00000000e+00 7.00000000e+00 9.00000000e+00])

adaptiveAvgPool2D

public func adaptiveAvgPool2D(input: Tensor, outputSize: Array<Int64>): Tensor
public func adaptiveAvgPool2D(input: Tensor, outputSize: Int64): Tensor

AdaptiveAvgPool2D 计算

输出 Tensor 的格式为 “NCHW” 和 “CHW”，表示 [batch, channels, height, width]。

计算公式如下所示：

hstart=floor(i∗Hin/Hout)hend=ceil((i+1)∗Hin/Hout)wstart=floor(j∗Win/Wout)wend=ceil((j+1)∗Win/Wout)Output(i,j)=∑Input[hstart:hend,wstart:wend](hend−hstart)∗(wend−wstart)

输入：

名称含义
input输入，3 维 或者 4 维的 Tensor，支持 Float32 或者 Float64 类型
outputSize目标输出, outputSize 可以是代表 (H x W) 的 2 维数组或者代表 H 的 number，输入 number 时, 输出大小为 H x H

输出：

名称含义
output输出 Tensor，类型与 input 相同，outputSize 为二维数组时 shape 为 input_shape[:len(input_shape) – len(outputSize)] + outputSize， 为 number 时，shape 为 input_shape[:len(input_shape) – len(outputSize)] + [outputSize, outputSize]

支持平台：GPU

反向函数：

public func adaptiveAvgPool2DGrad(x: Tensor, y: Tensor): Tensor

微分伴随函数:

public func adjointAdaptiveAvgPool2D(x: Tensor, outputSize: Array<Int64>)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]), shape: [3, 3, 3])
    let output = adaptiveAvgPool2D(x, Array<Int64>([2, 1]))
    print(output)
    return 0
}

输出为：

Tensor(shape=[3, 2, 1], dtype=Float32, value=
[[[ 3.50000000e+00]
  [ 6.50000000e+00]]
 [[ 3.50000000e+00]
  [ 6.50000000e+00]]
 [[ 3.50000000e+00]
  [ 6.50000000e+00]]])

addN

public func addN(input: Tensor): Tensor
public func addN(input1: Tensor, input2: Tensor, input3: Tensor): Tensor

函数 addN 实现 AddN 算子功能，用来将输入加到一起，输入 Tensor 的 shape 必须相同。

输入：

名称含义
input多个 Tensor 合成的 Tuple, GPU & CPU 所有元素必须都为 Float32 类型; Ascend 所有元素必须都为 Float16\Float32\Int32 类型。
input1多个 Tensor 合成的 Tuple, GPU & CPU 所有元素必须都为 Float32 类型; Ascend 所有元素必须都为 Float16\Float32\Int32 类型。
input2多个 Tensor 合成的 Tuple, GPU & CPU 所有元素必须都为 Float32 类型; Ascend 所有元素必须都为 Float16\Float32\Int32 类型。
input3多个 Tensor 合成的 Tuple, GPU & CPU 所有元素必须都为 Float32 类型; Ascend 所有元素必须都为 Float16\Float32\Int32 类型。

输出：

名称含义
output输出，与 input 每一项的形状和类型相同。

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointAddN(input: Tensor)

public func adjointAddN(input1: Tensor, input2: Tensor, input3: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input0 = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]), shape: Array<Int64>([2, 3]))
    let input1 = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]), shape: Array<Int64>([2, 3]))
    let input = makeTuple([input0, input1])
    let output = addN(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 3], dtype=Float32, value=
[[2.00000000e+00 4.00000000e+00 6.00000000e+00]
[8.00000000e+00 1.00000000e+01 1.20000000e+01]])

allGather

public func allGather(input: Tensor, group!: String = "nccl_world_group"): Tensor

按照输入的 group 方式收集 Tensor

输入：

名称含义
input输入，支持 Float32,Int32 类型
group通信组类型，GPU 设备支持输入 “nccl_world_group”。

输出：

支持平台：Ascend, GPU

微分伴随函数：

public func adjointAllGather(input: Tensor, group!: String = "nccl_world_group")

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*
from CangjieTB import context.*

main(): Int64
{
    g_context.setBackend("nccl")
    let x = onesTensor(Array<Int64>([3, 3]))
    let output = allGather(x, group: "nccl_world_group")
    print(output)
    return 0
}

输出为(单 gpu):

Tensor(shape=[3, 3], dtype=Float32, value=
[[ 1.00000000e+00  1.00000000e+00  1.00000000e+00]
 [ 1.00000000e+00  1.00000000e+00  1.00000000e+00]
 [ 1.00000000e+00  1.00000000e+00  1.00000000e+00]])

allReduce

public func allReduce(input: Tensor, opType!: ReduceType = ReduceType.SUM, group!: String = "nccl_world_group"): Tensor

函数 allReduce 实现 AllReduce 算子功能，用于归并所有设备的张量数据，以保证所有设备可以获得相同的结果，通常用在并行训练中。

输入：

名称含义
input输入，支持 Int32, Int64, Float16, Float32 类型的 Tensor。
opType规约类型，支持四种输入，分别是 ReduceType.SUM、ReduceType.MAX、ReduceType.MIN、ReduceType.PROD。默认为 ReduceType.SUM
group通信组类型，GPU 设备支持输入 “nccl_world_group”。

输出：

名称含义
output输出 Tensor，与 input 具有相同的 shape 和 dtype。

支持平台：GPU

微分伴随函数：

public func adjointAllReduce(input: Tensor, opType!: ReduceType = ReduceType.SUM, group!: String = "nccl_world_group")

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*
from CangjieTB import context.*

main(): Int64
{
    g_context.setBackend("nccl")
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]), shape: Array<Int64>([2, 3]))
    let output = allReduce(input, opType: ReduceType.SUM, group: "nccl_world_group")
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 3], dtype=Float32, value=
[[1.00000000e+00 2.00000000e+00 3.00000000e+00]
[4.00000000e+00 5.00000000e+00 6.00000000e+00]])

applyCenteredRMSProp

public func applyCenteredRMSProp(input: Tensor, meanGradient: Tensor, meanSquare: Tensor, moment: Tensor, gradient: Tensor, learningRate: Tensor, decay: Float32, momentum: Float32, epsilon: Float32, useLocking!: Bool = false): Tensor
public func applyCenteredRMSProp(input: Tensor, meanGradient: Tensor, meanSquare: Tensor, moment: Tensor, gradient: Tensor, learningRate: Float32, decay: Float32, momentum: Float32, epsilon: Float32, useLocking!: Bool = false): Tensor

实现 centered RMSProp 算法的优化器

ApplyCenteredRMSProp 算法实现公式如下:

gt=ρgt−1+(1−ρ)∇Qi(w)st=ρst−1+(1−ρ)(∇Qi(w))2mt=βmt−1+ηst−gt2+ϵ∇Qi(w)w=w−mt

其中：$w$ 代表将被更新的 input。$g_{t}$代表$mean_gradien$，$g_{t-1}$是$g_{t}$最后部分。$s_{t}$代表$mean_square$，$s_{t-1}$是$s_{t}$的最后一部分。$m_{t}$代表$moment$，$m_{t-1}$代表$m_{t}$的最后一部分。$\rho$代表 decay。$\beta$是动量术语，代表 momentum。$\epsilon$是避免被 0 整除的平滑项，代表 epsilon。$\eta$代表$learning_rate$。$\nabla Q_{i}(w)$代表 gradient。

输入：

名称含义
useLocking是否启用锁保护 input 的更新。 默认值：false
input要更新的权重, 支持 Float32 类型的 Tensor
meanGradient平均梯度， shape 和 dtype 和 input 一致
meanSquare均值平方梯度，shape 和 dtype 和 input 一致
momentinput 的 Delta，shape 和 dtype 和 input 一致
gradient梯度，shape 和 dtype 和 input 一致
learningRate学习率，支持 Float32 类型的数字和 Float32 类型的标量 Tensor
decay衰退率, 支持 Float32 类型的 number
momentum动力指标, 支持 Float32 类型的 number
epsilonRidge, 避免被 0 整除的平滑项, 支持 Float32 类型的 number

输出：

名称含义
output输出 Tensor， 与输入 的 shape 和 dtype 相同

支持平台：Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = parameter(Tensor(Array<Float32>([2.0, 9.0, 7.0, 5.0]), shape: [2, 2]), "input")
    let meanGrad = onesTensor(Array<Int64>([2, 2]), dtype: FLOAT32)
    let meanSquare = onesTensor(Array<Int64>([2, 2]), dtype: FLOAT32)
    let moment = onesTensor(Array<Int64>([2, 2]), dtype: FLOAT32)
    let gradient = onesTensor(Array<Int64>([2, 2]), dtype: FLOAT32)

    let res = applyCenteredRMSProp(input, meanGrad, meanSquare, moment, gradient, 0.01, 1e-10, 0.001, 0.9)
    print(input)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[ 1.98845911e+00  8.98845863e+00]
 [ 6.98845911e+00  4.98845911e+00]])

applyAdagrad

public func applyAdagrad(input: Tensor, accum: Tensor, lr: Tensor, gradient: Tensor, update_slots!: Bool = true): (Tensor, Tensor)
public func applyAdagrad(input: Tensor, accum: Tensor, lr: Float32, gradient: Tensor, update_slots!: Bool = true): (Tensor, Tensor)

根据 adagrad 方案更新相关实例

accum+=gradient∗gradientinput−=lr∗gradient∗1accum

输入：

名称含义
update_slots是否启用锁保护 input 和 accum 张量不被更新。 默认值：true
input要更新的权重。 支持 Float32 类型，需要设置为 Parameter
accum平均梯度， shape 和 dtype 和 input 一致， 需要设置为 Parameter
lr学习率，支持 Float32 类型的数字和 Float32 类型的标量 Tensor
gradientinput 的 Delta，shape 和 dtype 和 input 一致

输出：

名称含义
output输出 Tensor，与 input 的 shape 和 dtype 相同
accum输出 Tensor，与 accum 的 shape 和 dtype 相同

支持平台：Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = parameter(Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: [2, 2]), "input")
    let accum = parameter(Tensor(Array<Float32>([10.0, 9.0, 8.0, 7.0]), shape: [2, 2]), "accum")
    let lr = Tensor(0.001, dtype: FLOAT32)
    let gradient = Tensor(Array<Float32>([1.5, 4.5, 3.7, 4.8]), shape: [2, 2])
    let (out1, out2) = applyAdagrad(input, accum, lr, gradient)
    print(out1)
    print(out2)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[ 9.99571443e-01  1.99916792e+00]
 [ 2.99920559e+00  3.99912429e+00]])
Tensor(shape=[2, 2], dtype=Float32, value=
[[ 1.22500000e+01  2.92500000e+01]
 [ 2.16900005e+01  3.00400009e+01]])

applyFtrl

public func applyFtrl(x: Tensor, accum: Tensor, linear: Tensor, gradOut: Tensor, lr: Tensor, l1: Tensor, l2: Tensor, lrPower: Tensor, useLocking!: Bool = false): Tensor
public func applyFtrl(x: Tensor, accum: Tensor, linear: Tensor, gradOut: Tensor, lr!: Float32 = 0.001, l1!: Float32 = 0.0, l2!: Float32 = 0.0, lrPower!: Float32 = -0.5, useLocking!: Bool = false): Tensor

根据 FTRL 方案更新输入，FTRL 表示一种在线凸优化算法，根据损失函数自适应选择正则化函数。可参考在线凸优化的自适应边界优化论文：a View from the Trenches for engineering document。其计算过程如下：

mt+1=mt+g2ut+1=ut+g−mt+1-p−mt-pα∗ωtωt+1={(sign(ut+1)∗l1−ut+1)mt+1-pα+2∗l2 if |ut+1|>l10.0 otherwise 

其中，$m$表示 accum，$g$表示 gradOut，$t$表示迭代步数，$u$表示 linear，$p$表示 lrPower，$\alpha$表示学习率 lr，$w$表示待更新的输入 x。

参数列表：

名称含义
useLocking如果为 true，x 和有累加 tensor 的更新将受到锁保护，Bool 类型，默认为 false

输入：

名称含义
x要更新的变量。 支持 Float32 类型，需要设置为 parameter
accum梯度的均方值。与 x 的类型和 shape 一致，需要设置为 parameter
linear线性增益。与 x 的类型和 shape 一致，需要设置为 parameter
gradOut梯度。与 x 的类型和 shape 一致
lr学习率。可以是 Float32 类型的数值或标量 Tensor, 默认值为 0.001
l1L1 正则化强度。可以是 Float32 类型的数值或标量 Tensor，默认值为 0.0
l2L2 正则化强度。可以是 Float32 类型的数值或标量 Tensor，默认值为 0.0
lrPower学习率下降的速度控制参数。可以是 Float32 类型的数值或标量 Tensor，默认值为 -0.5

输出：

名称含义
output更新后的 input, 与 x 的类型和 shape 一致

支持平台：GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x = parameter(Tensor(Array<Float32>([0.6, 0.4, 0.1, 0.5]), shape: Array<Int64>([2, 2])), "x")
    let accum = parameter(Tensor(Array<Float32>([0.6, 0.5, 0.2, 0.6]), shape: Array<Int64>([2, 2])), "accum")
    let linear = parameter(Tensor(Array<Float32>([0.9, 0.1, 0.7, 0.8]), shape: Array<Int64>([2, 2])), "linear")
    let gradOut = Tensor(Array<Float32>([0.3, 0.7, 0.1, 0.8]), shape: Array<Int64>([2, 2]))
    let lr: Float32 = 0.001
    let l1: Float32 = 0.0
    let l2: Float32 = 0.0
    let lrPower: Float32 = -0.5
    let out = applyFtrl(x, accum, linear, gradOut, lr: lr, l1: l1, l2: l2, lrPower: lrPower)
    print(x)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[ 3.90524976e-02  1.14928380e-01]
 [ 6.64254301e-04  1.50758967e-01]])

applyGradientDescent

public func applyGradientDescent(input: Tensor, alpha: Tensor, delta: Tensor): Tensor
public func applyGradientDescent(input: Tensor, alpha: Float32, delta: Tensor): Tensor

通过从 input 中减 alpha * delta 来更新 input

input=input−α∗δ

α代表alpha,δ代表delta

输入：

名称含义
input要更新的变量。 支持 Float32 类型，需要设置为 parameter
alpha系数，支持 Float32 类型的数字和 Float32 类型的标量 Tensor
deltainput 的 Delta，shape 和 dtype 和 input 一致

输出：

名称含义
output更新后的 input, 与 input 的 shape 和 dtype 相同

支持平台：Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = parameter(onesTensor(Array<Int64>([2, 2]), dtype: FLOAT32), "input")
    let delta = Tensor(Array<Float32>([0.1, 0.1, 0.1, 0.1]), shape: [2, 2])
    let out = applyGradientDescent(input, 0.001, delta)
    print(out)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[ 9.99899983e-01  9.99899983e-01]
 [ 9.99899983e-01  9.99899983e-01]])

applyRMSProp

public func applyRMSProp(x: Tensor, meanSquare: Tensor, moment: Tensor, learningRate: Tensor, gradOut: Tensor, decay: Float32, momentum: Float32, epsilon: Float32, useLocking!: Bool = false): Tensor
public func applyRMSProp(x: Tensor, meanSquare: Tensor, moment: Tensor, learningRate: Float32, gradOut: Tensor, decay: Float32, momentum: Float32, epsilon: Float32, useLocking!: Bool = false): Tensor

均方根(RMSProp: Root Mean Square prop)算法优化器，实现算法如下：

st+1=ρst+(1−ρ)(∇Qi(w))2mt+1=βmt+ηst+1+ϵ∇Qi(w)w=w−mt+1

其中，$w$表示要更新的权重 input；$s_{t+1}$表示待更新的均方 meanSquare，$s_t$表示前一次的均方；$m_{t+1}$表示 moment，$m_t$表示前一次的 moment；$\rho$表示 decay, $\beta$表示 momentum；$\epsilon$表示 epsilon，用于避免除 0；$\eta$表示学习率 learningRate；$\nabla Q_{i}(w)$表示梯度 gradOut。

参数列表：

名称含义
useLocking如果为 true，x 和有累加 tensors 的更新将受到锁保护，Bool 类型，默认为 false
decaydecay rate，meanSquare 更新衰变速度。 支持 Float32 类型
momentummoment 更新参数。 支持 Float32 类型
epsilon避免除 0，支持 Float32 类型

输入：

名称含义
input要更新的变量。 支持 Float32 类型，需要设置为 parameter
meanSquare梯度的均方值。与 input 的类型和 shape 一致
momentinput 的变化量。与 input 的类型和 shape 一致
learningRate学习率。支持 Float32 类型标量 Tensor 和 Float32 类型的标量
gradOut梯度。与 input 的类型和 shape 一致

输出：

名称含义
output更新后的 input, 与 input 的类型和 shape 一致

支持平台：Ascend, GPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = parameter(Tensor(Array<Float32>([1.0, 1.0, 1.0, 1.0]), shape: Array<Int64>([2, 2])), "input")
    let meanSquare = parameter(Tensor(Array<Float32>([1.0, 1.0, 1.0, 1.0]), shape: Array<Int64>([2, 2])), "meanSquare")
    let moment = parameter(Tensor(Array<Float32>([1.0, 1.0, 1.0, 1.0]), shape: Array<Int64>([2, 2])), "moment")
    let gradOut = Tensor(Array<Float32>([1.0, 1.0, 1.0, 1.0]), shape: Array<Int64>([2, 2]))
    let learningRate = Tensor(Float32(0.01))
    let decay = Float32(0.0)
    let momentum = Float32(0.0)
    let epsilon = Float32(0.001)
    let res = applyRMSProp(input, meanSquare, moment, learningRate, gradOut, decay, momentum, epsilon)
    print(input)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[ 9.90005016e-01  9.90005016e-01]
 [ 9.90005016e-01  9.90005016e-01]])

argmax

public func argmax(input: Tensor, axis!: Int64 = -1): Tensor

函数 argmax 实现 Argmax 算子功能，用于对输入 Tensor 的值沿着某个轴进行比较，返回最大值的索引。如果 input 的 shape 是 (x_1, …, x_N)，那么 output 的 shape 为 (x_1, …, x_{axis-1}, x_{axis+1}, …, x_N)。

【注意】：由于后端的限制, input 暂时只能为 1 维或 2 维。

输入：

名称含义
input输入 Tensor，Float32 类型的 Tensor。
axis要施行 Argmax 的维度，默认值为 – 1，如果 input 的维度数为 rank，那么 axis 的取值范围为 [-rank, rank)。

输出：

名称含义
output最大值的索引，Int32 类型的 Tensor。

支持平台：Ascend, GPU, CPU

微分伴随函数:

public func adjointArgmax(input: Tensor, axis!: Int64 = -1)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]), shape: Array<Int64>([2, 3]))
    let output = argmax(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2], dtype=Int32, value=
    [2 2])

argMaxWithValue

public func argMaxWithValue(input: Tensor, axis!: Int64 = 0, keepDims!: Bool = false): (Tensor, Tensor)

函数 argMaxWithValue 实现 ArgMaxWithValue 算子功能，用于对输入 Tensor 的值沿着某个轴进行比较，返回最大值及其索引。

【注意】：在 auto_parallel 和 semi_auto_parallel 模式下，不能使用第一个输出索引。

参数列表：

名称含义
axis要施行 ArgMaxWithValue 的维度，默认值为 0。
keepDims是否保留 axis 对应的维度，默认值为 false。

输入：

名称含义
input输入 Tensor，支持 Float32 类型。

输出：

名称含义
index最大值的索引 Int32 类型。
output输入 Tensor 的最大值，与 input 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU

反向函数：

public func argminOrArgmaxGrad(x: Tensor, axis: Int64, keepDims: Bool, op: String, out: Tensor, gradOut: Tensor): Tensor

微分伴随函数:

public func adjointArgMaxWithValue(input: Tensor, axis!: Int64 = 0, keepDims!: Bool = false)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 6.0, 5.0]), shape: Array<Int64>([2, 3]))
    let (index, output) = argMaxWithValue(input)
    print(index)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Int32, value=
    [1 1 1])
Tensor(shape=[3], dtype=Float32, value=
    [4.00000000e+00 6.00000000e+00 5.00000000e+00])

argMinWithValue

public func argMinWithValue(input: Tensor, axis!: Int64 = 0, keepDims!: Bool = false): (Tensor, Tensor)

函数 argMinWithValue 实现 ArgMinWithValue 算子功能，用于对输入 Tensor 的值沿着某个轴进行比较，返回最小值及其索引。

【注意】：如果存在多个最小值，输出第一个最小值的索引位置。

​ axis 的索引范围是[-dims, dims – 1]，其中，dims 是输入 input 的维度。

参数列表：

名称含义
axis要施行 ArgMinWithValue 的维度，默认值为 0。
keepDims是否保留 axis 对应的维度，默认值为 false。

输入：

名称含义
input输入 Tensor，支持 Float32 类型。

输出：

名称含义
index最小值的索引 Int32 类型。
output输入 Tensor 的最小值，与 input 具有相同的 shape 和 dtype。

支持平台：GPU

反向函数：

public func argminOrArgmaxGrad(x: Tensor, axis: Int64, keepDims: Bool, op: String, out: Tensor, gradOut: Tensor): Tensor

微分伴随函数:

public func adjointArgMinWithValue(input: Tensor, axis!: Int64 = 0, keepDims!: Bool = false)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 6.0, 5.0]), shape: Array<Int64>([2, 3]))
    let (index, output) = argMinWithValue(input)
    print(index)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Int32, value=
    [0 0 0])
Tensor(shape=[3], dtype=Float32, value=
    [1.00000000e+00 2.00000000e+00 3.00000000e+00])

asin

public func asin(input: Tensor)

函数 asin 实现 Asin 算子功能，用于计算输入的反正弦。

输入：

名称含义
x输入 Tensor，支持 Float16\Float32 数据类型。

输出：

名称含义
output输出 Tensor，与 x 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU

反向函数：

public func asinGrad(x: Tensor, gradOut: Tensor): Tensor

微分伴随函数：

public func adjointAsin(input: Tensor)

二阶伴随函数：

public func adjointAsinGrad(x: Tensor, gradOut: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x = Tensor(Array<Float32>([0.23, 0.44, -0.13, 0.58]), shape: Array<Int64>([2, 2]))
    let res = asin(x)
    print(res)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[2.32077688e-01 4.55598682e-01]
 [-1.30368978e-01 6.18728697e-01]])

asinh

public func asinh(input: Tensor)

函数 asinh 实现 Asinh 算子功能，用于计算输入的反双曲正弦。

输入：

名称含义
x输入 Tensor，支持 Float16\Float32 数据类型。

输出：

名称含义
output输出 Tensor，与 x 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU

反向函数：

public func asinhGrad(x: Tensor, y: Tensor): Tensor

微分伴随函数：

public func adjointAsinh(input: Tensor)

二阶伴随函数：

public func adjointAsinhGrad(x: Tensor, y: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x = Tensor(Array<Float32>([-5.0, 1.5, 3.0, 100.0]), shape: Array<Int64>([2, 2]))
    let res = asinh(x)
    print(res)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[-2.31243825e+00 1.19476318e+00]
 [1.81844640e+00 5.29834223e+00]])

assign

public func assign(input: Tensor, value:Tensor): Tensor

函数 assign 实现 Assign 算子功能，用于给参数赋值。

输入：

名称含义
input输入的参数, 需要设置为 Parameter, GPU & CPU 支持 Float32\Float64\Int32, Ascend 支持 Float32\Int32。
value要分配的值, 数据类型与 input 一致。

输出：

名称含义
outputTensor，与原始变量的类型相同。

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointAssign(input: Tensor, value: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = parameter(Tensor(Array<Int32>([1, 2, 3]), shape: Array<Int64>([3])), "input")
    let value = Tensor(Array<Int32>([4, 5, 6]), shape: Array<Int64>([3]))
    let output = assign(input, value)
    print(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Int32, value=
[4 5 6])
Tensor(shape=[3], dtype=Int32, value=
[4 5 6])

assignAdd

public func assignAdd(variable: Tensor, x: Int32): Tensor
public func assignAdd(variable: Tensor, x: Float16): Tensor
public func assignAdd(variable: Tensor, x: Float32): Tensor
public func assignAdd(variable: Tensor, x: Float64): Tensor
public func assignAdd(variable: Tensor, x: Tensor): Tensor

函数 assignAdd 实现 AssignAdd 算子功能，用于做参数的自增计算。

输入：

名称含义
variable自增参数, 需要设置为 Parameter, GPU & CPU 支持 Float16\Float32\Int32 类型; Ascend 支持 Float16\Float32\Int32\Int64 类型。
x自增数值，类型为 Tensor 时必须与 variable shape 和类型相同，为 number 时类型必须与 variable dtype 相同。

输出：

名称含义
output输出，与 variable 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointAssignAdd(variable: Tensor, x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let variable = parameter(Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([2, 2])), "variable")
    let x = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([2, 2]))
    let output = assignAdd(variable, x)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
    [[2.00000000e+00 4.00000000e+00]
     [6.00000000e+00 8.00000000e+00]])

atan

public func atan(x: Tensor): Tensor

函数 atan 实现 Atan 算子功能，用于计算输入 Tensor 的三角反正切值。

输入：

名称含义
x输入 Tensor，仅接受 Float16\Float32 类型。

输出：

名称含义
output输出，与 x 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU

反向函数：

public func atanGrad(x: Tensor, y: Tensor): Tensor

微分伴随函数：

public func adjointAtan(x: Tensor)

二阶伴随函数：

public func adjointAtanGrad(x: Tensor, y: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x = parameter(Tensor(Array<Float32>([-178.0730743408, -125.8694152832, -13.1253213882, -64.0065612793]), shape: Array<Int64>([2, 2])), "x")
    let output = atan(x)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[-1.56518078e+00 -1.56285179e+00]
 [-1.49475467e+00 -1.55517423e+00]])

atan2

public func atan2(x: Tensor, y: Tensor): Tensor

函数 atan2 实现 Atan2 算子功能，用于计算 x/y 的三角反正切值，该算子反向不支持 Float64 类型的输入。

输入：

名称含义
x输入 Tensor，仅接受 Float16\Float32\Float64 类型，Ascend 不支持 Float64 类型。
y输入 Tensor，仅接受 Float16\Float32\Float64 类型, shape 与 x 一致。

输出：

名称含义
output输出 Tensor，shape 与 x 和 y BroadcastTo 之后相同， 数据类型与 x 相同。

支持平台：Ascend, GPU

微分伴随函数：

public func adjointAtan2(x: Tensor, y: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x = parameter(Tensor(Array<Float32>([-233.6013336182, -166.4370422363, -264.0430297852, -100.0823135376]), shape: Array<Int64>([2, 2])), "x")
    let y = parameter(Tensor(Array<Float32>([-96.0830841064, -204.3753814697, -51.6355972290, -98.7397003174]), shape: Array<Int64>([2, 2])), "y")
    let output = atan2(x, y)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[-1.96101642e+00 -2.45815134e+00]
 [-1.76391673e+00 -2.34944177e+00]])

avgPool

public func avgPool(input: Tensor, ksizes: Array<Int64>, strides: Array<Int64>, padMod!: String = "VALID"): Tensor

函数 avgPool 实现 AvgPool 算子功能，用于在输入 Tensor 上应用二维平均池。操作如下：

output(Ni,Cj,h,w)=1hker∗wker∑m=0hker−1∑n=0wker−1input(Ni,Cj,s0×h+m,s1×w+n)

参数列表：

名称含义
ksizes滑窗大小。内核大小用于取平均值，为长度为 2 的 Int64 数组，分别表示滑窗的高度和宽度, 数值不小于 1。
strides滑窗跳步。为长度为 2 的 Int64 数组，分别表示移动的高度和宽度, 数值不小于 1。
padModpadMod 模式，可选值: “SAME”, “VALID”，忽略大小写。默认值：”VALID”。

输入：

名称含义
inputshape 是（N, C, H, W）的 Tensor, 支持 Float16\Float32 类型。

输出：

名称含义
outputshape 是 (N, C, H_out, W_out) 的 Tensor。

Ascend 平台暂不支持反向

支持平台：Ascend, GPU, CPU

反向函数：

public func avgPoolGrad(gradOut: Tensor, input: Tensor, value: Tensor, ksizes: Array<Int64>, strides: Array<Int64>, padding!: String = "VALID"): Tensor

微分伴随函数:

public func adjointAvgPool(input: Tensor, ksizes: Array<Int64>, strides: Array<Int64>, pad_mode: String)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([-0.00379059,-0.00749117, 0.00654396, 0.00295572, 0.00235576,-0.0118451, -0.00893178, 0.00429676]), shape: Array<Int64>([1, 1, 2, 4]))
    let output = avgPool(input, Array<Int64>([2, 2]), Array<Int64>([1, 1]))
    print(output)
    return 0
}

输出为：

Tensor(shape=[1, 1, 1, 3], dtype=Float32, value=
    [[[[-5.19277528e-03 -5.43102250e-03 1.21616491e-03]]]])

batchMatMul

public func batchMatMul(input: Tensor, weight: Tensor, transposeA!: Bool = false, transposeB!: Bool = false): Tensor

函数 batchMatMul 实现 BatchMatMul 算子功能，用于两个 Tensor 批量相乘。两个输入 Tensor 的 shape 维度数 n 必须相等且 n >= 3。 设 input 的 shape 为 (*B, N, C)，weight 的 shape 为 (*B, C, M)，input 的 shape 中的 C 必须等于 weight 中的 C，并且 input 的 shape 中的前 n – 2 个元素必须与 weight 中前 n – 2 个元素相等。

参数列表：

名称含义
transposeA如果取值是 true，就需要先对 input 的最后两维做转置后再跟 weight 相乘。默认值： false。
transposeB如果取值是 true，就需要先对 weight 的最后两维做转置后再跟 input 相乘。默认值： false。

输入：

名称含义
input如果 transposeA 是 false，要求 shape 是 (*B, N, C) 的 Tensor。 如果 transposeA 是 true，那么要求 input 转置后的 shape 是(*B, N, C)，GPU & CPU 支持 Float16\Float32\Float64 类型的 Tensor; Ascend 支持 Float16\Float32\Int32 类型的 Tensor。
weight如果 transposeB 是 false，要求 shape 是 (*B, C, M) 的 Tensor。 如果 transposeB 是 true，那么要求 weight 转置后的 shape 是(*B, C, M)，GPU & CPU 支持 Float16\Float32\Float64 类型的 Tensor; Ascend 支持 Float16\Float32\Int32 类型的 Tensor。

输出：

名称含义
outputshape 是 (*B, N, M) 的 Tensor，其值是 input 和 weight 相乘的结果。

支持平台：Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = onesTensor(Array<Int64>([2, 4, 1, 3]))
    let weight = onesTensor(Array<Int64>([2, 4, 3, 4]))
    let output = batchMatMul(input, weight)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 4, 1, 4], dtype=Float32, value=
    [[[[3.00000000e+00 3.00000000e+00 3.00000000e+00 3.00000000e+00]]
      [[3.00000000e+00 3.00000000e+00 3.00000000e+00 3.00000000e+00]]
      [[3.00000000e+00 3.00000000e+00 3.00000000e+00 3.00000000e+00]]
      [[3.00000000e+00 3.00000000e+00 3.00000000e+00 3.00000000e+00]]]
     [[[3.00000000e+00 3.00000000e+00 3.00000000e+00 3.00000000e+00]]
      [[3.00000000e+00 3.00000000e+00 3.00000000e+00 3.00000000e+00]]
      [[3.00000000e+00 3.00000000e+00 3.00000000e+00 3.00000000e+00]]
      [[3.00000000e+00 3.00000000e+00 3.00000000e+00 3.00000000e+00]]]])

batchNorm

public func batchNorm(input: Tensor, scale: Tensor, bias: Tensor, mean: Tensor, variance: Tensor, isTraining: Bool, epsilon!: Float32 = 1e-5, momentum!: Float32 = 0.1): (Tensor, Tensor, Tensor, Tensor, Tensor)

函数 batchNorm 实现 BatchNorm 归一化算子功能。

批处理规范化广泛用于卷积网络中，用于解决 “Internal Covariate Shift” 问题，原理详见论文 Accelerating Deep Network Training by Reducing Internal Covariate Shift。它使用每个 mini-batch 的数据和可更新参数对特征做重新缩放和更新，计算公式如下：

y=x−meanvariance+ϵ∗γ+β

每个 batch 处理时，mean 和 variance 的值都会变化，计算公式如下:

newrunningmean=(1−momentum)∗runningmean+momentum∗currentmean

参数列表：

名称含义
isTraining为 true 时, mean 和 variance 会随着训练过程进行计算。为 false 时，mean 和 variance 从 checkpoint 文件中加载。
epsilon为保证数值稳定性而加的一个小数, 默认值为 1e-5。
momentum之前的 batch 计算得到的均值对本次 batch 计算的影响因子, 默认值为 0.1。

输入：

名称含义
inputTensor，形状（N,C,H,W), 支持 Float16\Float32 类型。
scaleTensor，当 isTraining 为 true 时需要设置为 parameter。shape 为 (C), 支持 Float16\Float32 类型。
biasTensor，当 isTraining 为 true 时需要设置为 parameter。shape 为 (C), 与 scale 数据类型一致。
meanTensor，当 isTraining 为 true 时需要设置为 parameter。shape 为 (C), 与 scale 数据类型一致。
varianceTensor，当 isTraining 为 true 时需要设置为 parameter。shape 为 (C), 与 scale 数据类型一致。

输出：5 个 Tensor 的元组， 归一化的输入和更新后的参数。

名称含义
output形状（N,C,H,W)，与 input 有相同的类型和形状。
updatedScale更新后的 scale 值，dtype 为 Float32。
updatedBias更新后的 bias 值，dtype 为 Float32。
reserveSpace_1预留空间 1，dtype 为 Float32。
reserveSpace_2预留空间 2，dtype 为 Float32。

支持平台：GPU

反向函数：

public func batchNormGrad(dy: Tensor, x: Tensor, scale: Tensor, saveMean: Tensor, saveInvVariance: Tensor, reverse: Tensor, isTraining: Bool, epsilon!: Float32 = 1e-5, momentum!: Float32 = 0.1)

微分伴随函数:

public func adjointBatchNorm(input: Tensor, scale: Tensor, bias: Tensor, mean: Tensor, variance: Tensor, isTraining: Bool, epsilon!: Float32 = 1e-5, momentum!: Float32 = 0.1
)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let scale = onesTensor(Array<Int64>([2]))
    let bias = onesTensor(Array<Int64>([2]))
    let mean = onesTensor(Array<Int64>([2]))
    let variance = onesTensor(Array<Int64>([2]))
    let input = onesTensor(Array<Int64>([2, 2, 2, 2]))
    let (output, updatedScale, updatedBias, reserveSpace1, reserveSpace2) = batchNorm(input, scale, bias, mean, variance, false)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 2, 2, 2], dtype=Float32, value=
    [[[[1.00000000e+00 1.00000000e+00]
       [1.00000000e+00 1.00000000e+00]]
      [[1.00000000e+00 1.00000000e+00]
       [1.00000000e+00 1.00000000e+00]]]
     [[[1.00000000e+00 1.00000000e+00]
       [1.00000000e+00 1.00000000e+00]]
      [[1.00000000e+00 1.00000000e+00]
       [1.00000000e+00 1.00000000e+00]]]])

batchToSpace

public func batchToSpace(input: Tensor, blockSize: Int64, crops: Array<Array<Int64>>): Tensor

对于排列为 NCHW 维度的数据，将 batch 对应的维度 N 的数据按照 blockSize 的大小对应分到 H 和 W 对应的维度，并对结果进行裁切 crops。裁切之前对应维度计算公式：

$$ \begin{split}\begin{aligned} nOut &= nIn//(blockSize_blockSize) \ cOut &= cIn \ hOut &= hIn_blockSize-crops[0][0]-crops[0][1] \ wOut &= wIn*blockSize-crops[1][0]-crops[1][1] \end{aligned}\end{split} $$

参数列表：

名称含义
blockSize将 batch 按照 blockSize 对应分割。Int64 类型，必须不小于 2。
crops对转换后的数据进行裁切, 第 0 维的两个数组分别对应 H 和 W 的裁切值。 Array<Array<Int64>>类型，2*2 大小

输入：

名称含义
inputTensor，数据排列为 NCHW, N 必须是 blockSize*blockSize 的整数倍，支持 Float32\Float16 类型。

输出：

名称含义
outputTensor，数据排列为 NCHW，与 input 有相同的类型，shape 为转换之后的 shape。

支持平台：Ascend, GPU

微分伴随函数:

public func adjointBatchToSpace(input: Tensor, blockSize: Int64, crops: Array<Array<Int64>>)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let blockSize: Int64 = 2
    let crop0 = Array<Int64>([0, 0])
    let crop1 = Array<Int64>([0, 0])
    let crops = Array<Array<Int64>>([crop0, crop1])
    let x = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([4, 1, 1, 1]))
    let out = batchToSpace(x, blockSize, crops)
    print(out)
    return 0
}

输出为：

Tensor(shape=[1, 1, 2, 2], dtype=Float32, value=
[[[[ 1.00000000e+00  2.00000000e+00]
   [ 3.00000000e+00  4.00000000e+00]]]])

batchToSpaceND

public func batchToSpaceND(input: Tensor, blockShape: Array<Int64>, crops: Array<Array<Int64>>): Tensor

用块划分批次维度，并将这些块交错回空间维度。此函数会将批次维度 N 划分为具有 blockShape 的块，即输出张量的 N 维度是划分后对应的块数。 输出张量的 H 、W 维度是原始的 H 、W 维度和 blockShape 的乘积从维度裁剪给定。 如此，若输入的 shape 为 (n,c,h,w) ，则输出的 shape 为 (n′,c′,h′,w′) 。

$$ \begin{split}\begin{aligned} nOut &= nIn//blockShape[0]blockShape[1] \ cOut &= cIn \ hOut &= hIn_blockShape[0]-crops[0][0]-crops[0][1] \ wOut &= wIn_blockShape[1]-crops[1][0]-crops[1][1] \end{aligned}\end{split} $$

输入：

名称含义
inputTensor，数据排列为 NCHW, 必须等于四维。批次维度需能被 blockShape 整除。支持 Float16\Float32 类型。
blockShapeInt64 类型的数组，分割批次维度的块的数量，取值需大于 1。长度必须等于 2。
crops空间维度的裁剪大小， Array<Array<Int64>>类型，2*2 大小。

输出：

名称含义
outputTensor，数据排列为 NCHW，与 input 有相同的类型，shape 为转换之后的 shape。

支持平台：Ascend

微分伴随函数:

public func adjointBatchToSpaceND(input: Tensor, blockShape: Array<Int64>, crops: Array<Array<Int64>>)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let blockShape = Array<Int64>([2, 2])
    let crops = Array<Array<Int64>>([[0, 0], [0, 0]])
    let input = Tensor(Array<Float32>([1.0000000000, 2.0000000000, 3.0000000000, 4.0000000000]), shape: Array<Int64>([4, 1, 1, 1]))
    let out = batchToSpaceND(input, blockShape, crops)
    print(out)
    return 0
}

输出为：

Tensor(shape=[1, 1, 2, 2], dtype=Float32, value=
[[[[ 1.00000000e+00  2.00000000e+00]
   [ 3.00000000e+00  4.00000000e+00]]]])

biasAdd

public func biasAdd(input: Tensor, bias: Tensor): Tensor

函数 biasAdd 实现 BiasAdd 算子功能，完成对 input 和 bias 的加法运算，并返回计算结果。input 的维度必须大于 2，bias 必须为 1 维 Tensor，且 input 的第二维的长度必须与 bias 的第一维的长度相等。

参数列表：

名称含义
inputTensor，接受 Float16\Float32 类型，shape 是 (N, C) 或者(N, C, H, W), Ascend 平台 rank 必须为 2D 至 4D。
biasTensor，接受 Float16\Float32 类型，shape 是 (C)。

输出：

名称含义
outputdtype 和 shape 跟 input 相同的 Tensor。

支持平台：Ascend, GPU, CPU

反向函数：

public func biasAddGrad(input: Tensor): Tensor

微分伴随函数:

public func adjointBiasAddGrad(input: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = randomNormalTensor(Array<Int64>([32, 16, 32, 32]))
    let bias = randomNormalTensor(Array<Int64>([16]))
    var output = biasAdd(input, bias)
    print(output.getShape())
    return 0
}

输出为：

[32, 16, 32, 32]

boundingBoxDecode

public func boundingBoxDecode(anchorBoxes: Tensor, deltas: Tensor, maxShape: Array<Int64>, means!: Array<Float32> = [0.0, 0.0, 0.0, 0.0], stds!: Array<Float32> = [1.0, 1.0, 1.0, 1.0], whRatioClip!: Float32 = 0.016): Tensor

对边界框的位置解码。

参数列表：

名称含义
maxShapeArray类型，解码计算后框的取值范围, maxShape 的 size 必须等于 2。
meansArray类型，size 必须为 4，deltas 计算用的均值。
stdsArray类型，size 必须为 4，deltas 计算用的标准差。
whRatioClipFloat32 类型，解码框计算的宽高的比例。

输入：

名称含义
anchorBox输入 Tensor，锚点框。Float32 类型，shape 必须是[n, 4]
deltas输入 Tensor，box 的 delta 值。Float32 类型，shape 与 anchorBox 一致

输出：

名称含义
output输出 Tensor，解码后的框。Float32 类型，shape 与 anchorBox 一致。

支持平台：Ascend, GPU, CPU

示例代码如下：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let anchorBox = Tensor(Array<Float32>([4.0, 1.0, 2.0, 1.0, 2.0, 2.0, 2.0, 3.0]), shape: Array<Int64>([2, 4]))
    let deltas = Tensor(Array<Float32>([3.0, 1.0, 2.0, 2.0, 1.0, 2.0, 1.0, 4.0]), shape: Array<Int64>([2, 4]))
    var maxShape = Array<Int64>([768, 1280])
    var output = boundingBoxDecode(anchorBox, deltas, maxShape)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 4], dtype=Float32, value=
    [[4.19452810e+00 0.00000000e+00 0.00000000e+00 5.19452810e+00]
     [2.14085913e+00 0.00000000e+00 3.85914087e+00 6.05981483e+01]])

boundingBoxEncode

public func boundingBoxEncode(anchorBoxes: Tensor, groundtruthBox: Tensor, means!: Array<Float32> = [0.0, 0.0, 0.0, 0.0], stds!: Array<Float32> = [1.0, 1.0, 1.0, 1.0]): Tensor

对边界框的位置编码。

参数列表：

名称含义
meansArray类型，size 必须为 4，deltas 计算用的均值。
stdsArray类型，size 必须为 4，deltas 计算用的标准差, Ascend 平台上 stds 中不能含 0。

输入：

名称含义
anchorBox输入 Tensor，锚点框。Float32 类型，shape 必须是[n, 4]
groundtruthBox输入 Tensor，真实框。Float32 类型，shape 与 anchorBox 一致

输出：

名称含义
output输出 Tensor，编码后的框。Float32 类型，shape 与 anchorBox 一致。

支持平台：Ascend, GPU, CPU

示例代码如下：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let anchorBox = Tensor(Array<Float32>([2.0, 2.0, 2.0, 3.0, 2.0, 2.0, 2.0, 3.0]), shape: [2, 4])
    let groundtruthBox = Tensor(Array<Float32>([1.0, 2.0, 1.0, 4.0, 1.0, 2.0, 1.0, 4.0]), shape: [2, 4])
    let output = boundingBoxEncode(anchorBox, groundtruthBox)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 4], dtype=Float32, value=
    [[-1.00000000e+00 2.50000000e-01 0.00000000e+00 4.05465126e-01]
     [-1.00000000e+00 2.50000000e-01 0.00000000e+00 4.05465126e-01]])

broadcast

public func broadcast(input: Tensor, rootRank: Int64, group!: String = "nccl_world_group"): Tensor

将输入 Tensor 广播到整组

输入：

名称含义
input输入，支持 Float32，Int32 类型
rootRank源进程，发送数据的进程。单卡设备只支持输入 0。取值范围: [0, 设备节点数)
group通信组类型，GPU 设备支持输入 “nccl_world_group”。

输出：

名称含义
output输出，shape 和类型与 input 相同

支持平台：GPU

微分伴随函数：

public func adjointBroadcast(x: Tensor, rootRank: Int64, group!: String = "nccl_world_group")

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*
from CangjieTB import context.*

main(): Int64
{
    g_context.setBackend("nccl")
    let x = Tensor(Array<Int32>([2, 2]), shape: [1, 2])
    let output = broadcast(x, 0)
    print(output)
    return 0
}

输出为(单 gpu):

Tensor(shape=[1, 2], dtype=Int32, value=
[[ 2  2]])

broadcastTo

public func broadcastTo(input: Tensor, shape: Array<Int64>): Tensor

函数 broadcastTo 实现 BroadcastTo 算子功能，用于把输入 Tensor 广播成指定的 shape 的 Tensor。要求输入 Tensor 的 shape 维度必须不大于指定广播的 shape 的维度。并且，对于输入 shape 和指定广播 shape 的每一个维度值对，其维度值还需满足以下三个条件之一：

  • 当输入 shape 的维度值是 1。
  • 输入 shape 的维度值跟广播 shape 的维度值相同。
  • 广播 shape 的维度值是 – 1。

当指定广播 shape 的维度值是 – 1 是，其广播后的 Tensor 对应维度的维度值保持输入 shape 的维度值不变。

参数列表：

输入：

名称含义
input需要广播的 Tensor，GPU & CPU 支持 Float16\Float32\Float64\Int32\Int64\Bool 类型, Ascend 支持 Float16\Float32\Int32\Bool 类型。
当 BroadcastTo 算子在可微函数中调用时，仅支持 Float32 数据类型。

输出：

名称含义
output输入 Tensor 广播之后的结果，其 shape 即是 BroadcastTo 指定广播的 Tensor。

支持平台：Ascend, GPU, CPU

用户可以直接使用 broadcastTo 函数实现 Tensor 的广播，示例代码如下：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.23, 4.56, 0.0]), shape: Array<Int64>([3]))
    let output = broadcastTo(input, Array<Int64>([2, 3]))
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 3], dtype=Float32, value=
    [[1.23000002e+00 4.55999994e+00 0.00000000e+00]
     [1.23000002e+00 4.55999994e+00 0.00000000e+00]])

cast

public func cast(x: Tensor, toType: Int32): Tensor

函数 cast 实现 Cast 算子功能，转换输入 Tensor 的数据类型。

输入：

名称含义
x输入要进行数据类型转换的 Tensor。
toType指定转换的数据类型。支持常量值或数据类型输入。支持的常数值范围是 0 ~ 7 和 9 支持的数据类型包括 Float16\Float32\Float64\Int32\Int64\Uint8\Uint16\Uint32\Bool。 数据类型和常数值的对应关系见 附录 F: dtype-类型

输出：

名称含义
output输出 Tensor，shape 与 x 相同。

支持平台：Ascend, GPU, CPU

微分伴随函数:

public func adjointCast(x: Tensor, toType: Int32)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([2, 2]))
    let output = cast(input, INT32)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Int32, value=
    [[ 1  2]
     [ 3  4]])

checkValid

public func checkValid(bboxes: Tensor, imgMetas: Tensor): Tensor

CheckValid 算子用于检查边界框是否满足要求。

对于输入 imgMetas = [height, width, ratio]， 要求边界框小于（height * ratio， weight * ratio）。

输入：

名称含义
bboxes输入 Tensor，Float16\Float32 类型，shape 为[n, 4]。
imgMetas输入 Tensor，Float16\Float32 类型，shape 为[3]。

输出：

名称含义
output输出 Tensor，Bool 类型，shape 为[n]。

支持平台：Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let bboxes = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]), shape: [2, 4])
    let imgMetas = Tensor(Array<Float32>([9.0, 8.0, 1.0]), shape: [3])

    let output = checkValid(bboxes, imgMetas)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2], dtype=Bool, value=
    [true true])

concat

public func concat(input1: Tensor, input2: Tensor, axis!: Int64 = 0): Tensor 
public func concat(input: Array<Tensor>, axis!: Int64 = 0): Tensor 
public func concat(tupleInput: Tensor, axis!: Int64 = 0): Tensor

函数 concat 实现 Concat 算子功能，用于对输入 Tensor 在指定轴上进行合并。

假设输入 Tensor 有 N 个，第 i 个 Tensor 维度为 (x_1, x_2, ..., x_{mi}, ..., x_R) ，对第 mi 维进行合并，则输出维度如下：

(x1,x2,…,∑i=1Nxmi,…,xR)

也就是说, 只允许被 concat 的 axis 那一维不相等，元素 shape 的其他位置上必须都对应相等。

【备注】：由于仓颉 TensorBoost 自动微分尚不支持数组可微，当前输入是 Tensor 类型数组的函数 concat 是不可微函数。

输入：

名称含义
input1输入 Tensor，GPU & CPU 支持 Float16\Float32\Float64\Int32\Bool 类型，Ascend 不支持 Float64。 所有输入的 dtype 类型必须一致。
input2输入 Tensor，GPU & CPU 支持 Float16\Float32\Float64\Int32\Bool 类型，Ascend 不支持 Float64。所有输入的 dtype 类型必须一致。
input输入 Tensor 列表，GPU & CPU 支持 Float16\Float32\Float64\Int32\Bool 类型，Ascend 不支持 Float64。所有输入的 dtype 类型必须一致。
tupleInput多个 Tensor 合成的 Tuple，GPU & CPU 支持 Float16\Float32\Float64\Int32\Bool 类型，Ascend 不支持 Float64。所有输入的 dtype 类型必须一致。
axis参考轴，默认是 0，如果 input 的维度数为 rank, 那么 axis 的取值范围为 [-rank, rank)。

输出：

支持平台：Ascend, GPU, CPU

微分伴随函数:

public func adjointConcat(input1: Tensor, input2: Tensor, axis!: Int64 = 0)

代码示例 1：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input0 = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([2, 2]))
    let input1 = Tensor(Array<Float32>([5.0, 6.0, 7.0, 8.0]), shape: Array<Int64>([2, 2]))
    let output = concat(input0, input1)
    print(output)
    return 0
}

输出为：

Tensor(shape=[4, 2], dtype=Float32, value=
    [[1.00000000e+00 2.00000000e+00]
     [3.00000000e+00 4.00000000e+00]
     [5.00000000e+00 6.00000000e+00]
     [7.00000000e+00 8.00000000e+00]])

代码示例 2：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input0 = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([2, 2]))
    let input1 = Tensor(Array<Float32>([5.0, 6.0, 7.0, 8.0]), shape: Array<Int64>([2, 2]))
    let input:Array<Tensor> = [input0, input1]
    let output = concat(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[4, 2], dtype=Float32, value=
    [[1.00000000e+00 2.00000000e+00]
     [3.00000000e+00 4.00000000e+00]
     [5.00000000e+00 6.00000000e+00]
     [7.00000000e+00 8.00000000e+00]])

conv2d

public func conv2D(input: Tensor, weight: Tensor, outChannel: Int64, kernelSizes: Array<Int64>, mode!: Int64 = 1, padMod!: String = "valid", pad!: Array<Int64> = Array<Int64>([0, 0, 0, 0]), strides!: Array<Int64> = Array<Int64>([1, 1, 1, 1]), dilations!: Array<Int64> = Array<Int64>([1, 1, 1, 1]), group!: Int64 = 1): Tensor

函数 conv2D 实现 Conv2D 算子功能，用于对输入的 2D 卷积运算。

参数列表：

名称含义
input卷积算子的输入，接受 Float16\Float32 类型的 Tensor，shape 是 (N, C_in, H_in, W_in)。
weight卷积算子的权重，接受 Float16\Float32 类型的 Tensor，shape 是 (Cout, C_in, K_h, K_w)。
outChannel输出通道数。
kernelSizes卷积核大小，长度是 2 的数组，必须为正数。
mode0：数学卷积，1：互相关卷积，2：反卷积，3：深度卷积。默认值：1。
padModpadding 模式，可选值为：”same”、”valid”、”pad”。默认值：”valid”。
pad输入的隐含 pad, padMod 是 “pad” 时生效。默认值：Array([0, 0, 0, 0])。
strides滑窗跳步，长度是 4 的数组。默认值： Array([1, 1, 1, 1]) 。
dilations卷积核之间的间距，长度是 4 的数组。默认值： Array([1, 1, 1, 1]) 。
group权重分组数。默认值：1。

输出：

名称含义
output输出 dtype 为 Float32 类型的 Tensor，shape 是 (N, Cout, Hout, Wout)。

支持平台：Ascend, GPU, CPU

反向函数：

public func conv2DBackpropInput(gradOut: Tensor, weight: Tensor, shape: Array<Int64>, outChannel: Int64, kernelSizes: Array<Int64>, mode!: Int64 = 1, padMod!: String = "valid", pad!: Array<Int64> = [0, 0, 0, 0], padList!: Array<Int64> = [0, 0, 0, 0], strides!: Array<Int64> = [1, 1], dilations!: Array<Int64> = [1, 1, 1, 1], group!: Int64 = 1): Tensor

public func conv2DBackpropFilter(gradOut: Tensor, input: Tensor, shape: Array<Int64>, outChannel: Int64, kernelSizes: Array<Int64>, mode!: Int64 = 1, padMod!: String = "valid", pad!: Array<Int64> = [0, 0, 0, 0], padList!: Array<Int64> = [0, 0, 0, 0], strides!: Array<Int64> = [1, 1, 1, 1], dilations!: Array<Int64> = [1, 1, 1, 1], group!: Int64 = 1): Tensor

微分伴随函数：

public func adjointConv2D(input: Tensor, weight: Tensor, outChannel: Int64, kernelSizes: Array<Int64>, mode: Int64, padMod: String, pad: Array<Int64>, strides: Array<Int64>, dilations: Array<Int64>, group: Int64)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = randomNormalTensor(Array<Int64>([32, 1, 32, 32]))
    let weight = randomNormalTensor(Array<Int64>([6, 1, 5, 5]))
    let output = conv2D(input, weight, 6, Array<Int64>([5, 5]))
    print(output.getShape())
    return 0
}

输出为：

[32, 6, 28, 28]

conv3d

public func conv3D(input: Tensor, weight: Tensor, outChannel: Int64, kernelSizes: Array<Int64>,
    mode!: Int64 = 1, padMod!: String = "valid", pad!: Array<Int64> = [0, 0, 0, 0, 0, 0],
    strides!: Array<Int64> = [1, 1, 1, 1, 1], dilations!: Array<Int64> = [1, 1, 1, 1, 1], group!: Int64 = 1) : Tensor

函数 conv3D 实现 Conv3D 算子功能，用于对输入的 3D 卷积运算。

参数列表：

名称含义
outChannel输出通道数 C_out，必须为正整数。
kernelSizes卷积核大小，长度是 3 的数组，必须为正整数，且不大于输入的 shape (C_in, H_in, W_in)。
mode适配不同的卷积，当前未使用。默认值为：1
padModepadding 模式，String 类型。可选值为：”same”、”valid”、”pad”。默认值：”vaild”。
same：采用补全的方式。输出的深度、高度和宽度分别与输入整除 stride 后的值相同。如果设置了此模式，则 pad 数组的元素必须等于 0。
valid：采用丢弃方式。输出的可能最大深度、高度和宽度将在没有填充的情况下返回。多余的像素将被丢弃。如果设置了此模式，则 pad 数组的元素必须等于 0。
pad：在输入的深度、高度和宽度方向上填充 padding 大小的 0。 则 pad 数组的元素必须大于或等于 0, 且 pad[0] 和 pad[1] 小于 kernelSizes[0] - 1) * dilations[2] + 1; pad[2] 和 pad[3] 小于 kernelSizes[1] - 1) * dilations[3] + 1; pad[4] 和 pad[5] 小于 kernelSizes[2] - 1) * dilations[4] + 1。
padpadMod 是 “pad” 时生效。默认值：[0, 0, 0, 0, 0, 0]。
strides滑窗跳步，长度是 5 的数组, 前两维取值仅支持 1，其余取值需大于等于 1。默认值： [1, 1, 1, 1, 1] 。
dilations卷积核之间的间距，长度是 5 的数组，前三维取值仅支持 1，其余取值需大于等于 1。默认值： [1, 1, 1, 1, 1] 。
group权重分组数。默认值：1。目前仅支持取值为 1。

输入：

名称含义
input卷积算子的输入，接受 Float16\Float32 类型的 Tensor，shape 是 (N, C_in, D_in, H_in, W_in)。
weight卷积算子的权重，接受 Float16\Float32 类型的 Tensor，dtype 要求与 input 一致，卷积核大小设置为(K_d, K_h, K_w), 则 weight 的 shape 是 (C_out, C_in//group, K_d, K_h, K_w)。

输出：

名称含义
output输出与 input 类型一致的 Tensor，shape 是 (N, Cout, Dout, Hout, Wout)。

支持平台：Ascend, GPU, CPU

反向函数：

public func conv3DBackpropInput(weight: Tensor, gradOut: Tensor, shape: Array<Int64>, outChannel: Int64, kernelSizes: Array<Int64>, mode!: Int64 = 1, padMod!: String = "valid", pad!: Array<Int64> = [0, 0, 0, 0, 0, 0], strides!: Array<Int64> = [1, 1, 1, 1, 1], dilations!: Array<Int64> = [1, 1, 1, 1, 1], group!: Int64 = 1): Tensor

public func conv3DBackpropFilter(input: Tensor, gradOut: Tensor, shape: Array<Int64>, outChannel: Int64, kernelSizes: Array<Int64>, mode!: Int64 = 1, padMod!: String = "valid", pad!: Array<Int64> = [0, 0, 0, 0, 0, 0], strides!: Array<Int64> = [1, 1, 1, 1, 1], dilations!: Array<Int64> = [1, 1, 1, 1, 1], group!: Int64 = 1): Tensor

微分伴随函数：

public func adjointConv3D(input: Tensor, weight: Tensor, outChannel: Int64, kernelSizes: Array<Int64>, mode!: Int64 = 1, padMod!: String = "valid", pad!: Array<Int64> = [0, 0, 0, 0, 0, 0], strides!: Array<Int64> = [1, 1, 1, 1, 1], dilations!: Array<Int64> = [1, 1, 1, 1, 1], group!: Int64 = 1)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = randomNormalTensor(Array<Int64>([1, 16, 40, 24, 40]))
    let weight = randomNormalTensor(Array<Int64>([32, 16, 3, 3, 3]))
    let output = conv3D(input, weight, 32, Array<Int64>([3, 3, 3]),
                        strides: Array<Int64>([1, 1, 1, 1, 1]), dilations: Array<Int64>([1, 1, 1, 1, 1]))
    print(output.getShape())
    return 0
}

输出为：

[1, 32, 38, 22, 38]

cos

public func cos(input: Tensor): Tensor

函数 cos 实现 Cos 算子功能，用于计算输入数据的余弦。

输入：

名称含义
input输入 Tensor, GPU & CPU 支持 Float16\Float32\Float64 支持, Ascend 支持 Float16\Float32。

输出：

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointCos(input: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([0.62, 0.28, 0.43, 0.62]), shape: Array<Int64>([4]))
    let output = cos(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[4], dtype=Float32, value=
    [8.13878477e-01 9.61055458e-01 9.08965766e-01 8.13878477e-01])

cropAndResize

public func cropAndResize(x: Tensor, boxes: Tensor, boxIndex: Tensor, cropSize: Array<Int64>, method!: String = "bilinear", extrapolationValue!: Float32 = 0.0): Tensor

CropAndResize 对输入的 image 进行裁剪，然后调整图片尺寸大小。

参数列表：

名称含义
methodresize 时候的采样方法，String 类型，可选值有”bilinear”，”nearest”和”bilinear_v2″，默认值为”bilinear”。
extrapolationValue如果采样值越界，可以用来推断应该输入的值 ，Float32 类型，默认为 0.0。

输入：

名称含义
x输入数据，支持 Int32，Float32 与 Float64 类型，4D 格式：[batch, imageHeight, imageWidth, channels]。
boxesshape 为[n, 4]，表示 n 组裁剪方式的取值, 每组裁剪值表示为[y1, x1, y2, x2]，类型为 Float32。裁切值取值[0, 1]表示对应图片的高度[0, imageHeight-1]或者宽度[0, imageWeight-1]的位置。[y1, y2]成比例裁剪得到图片新高度为 (y2-y1)*(imageHeight)，允许 y1>y2，此时图片会上下翻转，宽度方向同理。如果裁切值越界，越界位置的值根据 extrapolationValue 外推。
boxIndexshape 为[n]，每个元素取值范围为[0,batch)，表示 boxes[i]用于对第 boxIndex[i]个 image 进行裁剪，Int32 类型。
cropSizeArray类型，长度为 2，对应宽高的大小[crop_height, crop_width]。仅支持常量输入

输出：

名称含义
output返回一个张量，shape 为[n, crop_height, crop_width, channels], 类型为 Float32。

支持平台：Ascend, GPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let batchSize = 1
    let numBoxex = 5
    let imageHeight = 256
    let imageWeight = 256
    let channels = 3
    let x = randomNormalTensor(Array<Int64>([batchSize, imageHeight, imageWeight, channels]))
    let bboxes = uniformTensor(Array<Int64>([numBoxex, 4]))
    let boxIndex = Tensor(Array<Int32>([0, 0, 0, 1, 1]), shape: [numBoxex])
    let cropSize = Array<Int64>([24, 24])
    let output = cropAndResize(x, bboxes, boxIndex, cropSize)
    print(output.getShape())
    return 0
}

输出为：

[5, 24, 24, 3]

ctcLoss

public func ctcLoss(x: Tensor, labelsIndices: Tensor, labelsValues: Tensor, sequenceLength: Tensor, preprocessCollapseRepeated!: Bool = false,
               ctcMergeRepeated!: Bool = true, ignoreLongerOutputsThanInputs!: Bool = false): (Tensor, Tensor)

函数 ctcLoss 实现 CTCLoss 算子功能，用于计算 CTC 的 loss 和梯度。

参数列表：

名称含义
preprocessCollapseRepeated如果为 true ，则在 CTC 计算之前折叠重复的标签，默认为 false 。
ctcMergeRepeated如果为 false，则在 CTC 计算期间，重复的非空白标签将不会合并，并被解释为单个标签，默认为 true 。
ignoreLongerOutputsThanInputs如果为 true ，则输出比输入长的序列将被忽略，默认为 false 。

输入：

名称含义
x输入 3-D Tensor (max_time, batch_size, num_classes)，仅支持 Float32 类型。其中 num_classes 代表 num_labels + 1 个类，num_labels 是实际标签的数量，空白标签被保留，默认为 num_classes – 1。
labelsIndices标签索引 2-D Tensor，仅支持 Int64 类型，第一列表示 batch，第二列表示 time，labelsValues[i] 以 labelsIndices 的第 i 行 (batch, time) 为索引存储对应的 id。
labelsValues1-D Tensor，仅支持 Int32 类型， labelsValues 的取值范围必须在 [0, num_classes) 的范围内。
sequenceLength序列长度，仅支持 Int32 类型，形状为 (batch_size)，其中的每一个值必须不超过 max_time。

输出：

名称含义
loss包含对数概率的张量，形状为 (batch_size)，数据类型与输入 x 相同。
gradient损失的梯度，与输入 x 具有相同的形状和数据类型。

输入要求：

  1. sequenceLength[batch] <= max_time
  2. labelsIndices 的第一列的最大值必须等于 batch_size – 1

支持平台：GPU

微分伴随函数:

public func adjointCtcLoss(x: Tensor, labelsIndices: Tensor, labelsValues: Tensor, sequenceLength: Tensor,  preprocessCollapseRepeated!: Bool = false, ctcMergeRepeated!: Bool = true, ignoreLongerOutputsThanInputs!: Bool = false)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*
main(): Int64
{
    let x = parameter(Tensor(Array<Float32>([0.3, 0.6, 0.6, 0.4, 0.3, 0.9, 0.9, 0.4, 0.2, 0.9, 0.9, 0.1]), shape: [2, 2, 3]), "x")
    let labelsIndices = parameter(Tensor(Array<Int64>([0, 0, 1, 0]), shape: [2, 2]), "labels_indices")
    let labelsValues = parameter(Tensor(Array<Int32>([2, 2]), shape: [2]), "labels_values")
    let sequenceLength = parameter(Tensor(Array<Int32>([2, 2]), shape: [2]), "sequence_length")
    let (loss, gradient) = ctcLoss(x, labelsIndices, labelsValues, sequenceLength)
    print(loss)
    return 0
}

输出为：

Tensor(shape=[2], dtype=Float32, value=
[7.96280026e-01 5.99515796e-01])

cumProd

public func cumProd(x: Tensor, axis: Int64, exclusive!: Bool = false, reverse!: Bool = false): Tensor

函数 cumProd 实现 CumProd 算子功能，用于计算输入张量 x 沿轴的累积积。

参数列表：

名称含义
exclusive如果为 true ，则执行独占的 CumProd ，默认为 false 。
reverse如果为 true ，则 CumProd 将以相反方向执行，默认为 false 。

输入：

名称含义
x输入数据，支持 Int32 与 Float32 类型。 Ascend 反向不支持 Int32 类型
axis用于计算累积积的维度，类型为 Int64 ，取值范围为[-rank, rank)。

输出：

名称含义
output返回一个张量，与 x 具有相同的 shape 和 dtype 。

支持平台：Ascend, GPU

微分伴随函数：

public func adjointCumProd(x: Tensor, axis: Int64, exclusive!: Bool = false, reverse!: Bool = false)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x = parameter(Tensor(Array<Int32>([2, 1, 3, 2, 3, 3, 0, 1, 2, 1]), shape: Array<Int64>([2, 5])), "x")
    let output = cumProd(x, 0, exclusive: true)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 5], dtype=Int32, value=
[[1 1 1 1 1]
 [2 1 3 2 3]])

cumSum

public func cumSum(input: Tensor, axis: Int64, exclusive!: Bool = false, reverse!: Bool = false): Tensor

函数 cumSum 实现 CumSum 算子功能，用于计算张量 x 沿轴的累积总和。

参数列表：

名称含义
exclusive如果为 true ，则执行专用的 CumSum ，默认为 false 。
reverse如果为 true ，则 CumSum 将以相反方向执行，默认为 false 。

输入：

名称含义
x输入数据，支持 Float16\Float32\Float64\Int32 类型, Ascend 不支持 Float64 类型。
axis用于计算累积张量值的维度，类型为 Int64 ，取值范围为[-rank, rank)。

输出：

名称含义
output返回一个张量，与 x 具有相同的 shape 和 dtype 。

支持平台：Ascend, GPU

微分伴随函数：

public func adjointCumSum(input: Tensor, axis: Int64, exclusive!: Bool = false, reverse!: Bool = false)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x = parameter(Tensor(Array<Float32>([-11.0726070404, -2.7946569920, -47.6111984253, -186.2480163574]), shape: Array<Int64>([2, 2])), "x")
    let output = cumSum(x, 0)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[-1.10726070e+01 -2.79465699e+00]
 [-5.86838074e+01 -1.89042679e+02]])

depthToSpace

public func depthToSpace(input: Tensor, blockSize: Int64): Tensor

对于格式为 NCHW 维度的数据，将 Channel 对应的维度 C 的数据按照 blockSize 的大小对应分到 H 和 W 对应的维度。对应维度计算公式：

$$ \begin{split}\begin{aligned} nOut &= nIn \ cOut &= cIn//(blockSize_blockSize) \ hOut &= hIn_blockSize \ wOut &= wIn*blockSize \end{aligned}\end{split} $$

参数列表：

名称含义
blockSize将 batch 按照 blockSize 对应分割。Int64 类型，必须不小于 2。

输入：

名称含义
inputTensor，数据排列为 NCHW, C 必须是 blockSize*blockSize 的整数倍，支持 Float32\Int32\Int64\UInt32 类型。

输出：

名称含义
outputTensor，数据排列为 NCHW，与 input 有相同的类型，shape 为转换之后的 shape。

支持平台：Ascend, GPU, CPU

微分伴随函数:

public func adjointDepthToSpace(input: Tensor, blockSize: Int64)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let blockSize: Int64 = 2
    let x = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([1, 4, 1, 1]))
    let out = depthToSpace(x, blockSize)
    print(out)
    return 0
}

输出为：

Tensor(shape=[1, 1, 2, 2], dtype=Float32, value=
[[[[ 1.00000000e+00  2.00000000e+00]
   [ 3.00000000e+00  4.00000000e+00]]]])

divNoNan

public func divNoNan(x: Int32, y: Tensor): Tensor
public func divNoNan(x: Float16, y: Tensor): Tensor
public func divNoNan(x: Float32, y: Tensor): Tensor
public func divNoNan(x: Tensor, y: Int32): Tensor
public func divNoNan(x: Tensor, y: Float16): Tensor
public func divNoNan(x: Tensor, y: Float32): Tensor
public func divNoNan(x: Tensor, y: Tensor): Tensor

函数 divNoNan 实现 DivNoNan 算子功能，用于计算 x/y 的值，如果 y 为 0，则返回 0。

输入：

名称含义
x第一个输入。类型为 Float16\Float32\Int32 的 tensor 或 number。
y第二个输入。类型为 Float16\Float32\Int32 的 tensor 或 number，dtype 类型与 x 一致

输出：

名称含义
output输出 Tensor，shape 跟 input1 和 input2 相同（或者跟两者 broadcasting 之后相同），数据类型与 x 相同。

支持平台：Ascend, GPU

微分伴随函数：

public func adjointDivNoNan(x: Tensor, y: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*
main(): Int64
{
    let x: Int32 = 1
    let y = parameter(Tensor(Array<Int32>([0, 1, 1, 0, 0, 0, 0, 0]), shape: [2, 1, 2, 2]), "y")
    let output = divNoNan(x, y)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 1, 2, 2], dtype=Int32, value=
[[[[0 1]
   [1 0]]]
 [[[0 0]
   [0 0]]]])

dropout

public func dropout(input: Tensor, keepProb!: Float32 = 0.5, seed0!: Int64 = 0, seed1!: Int64 = 0): (Tensor, Tensor)

函数 dropout 实现 Dropout 算子功能，用于将输入经过 dropout 处理，输出两个形状和输入一致的 Tensor，一个是根据 keepProb 生成的 mask，另一个是根据 mask 和 keepProb 计算得到的输出。

输入：

名称含义
input输入的 Tensor，只接受 Float32 类型。
keepProb进行 mask 的概率，value 在 (0.0, 1.0] 之间，默认值：0.5。
seed0随机种子，默认值：0。
seed1随机种子，默认值：0。

输出：2 个 Tensor 的元组，dropout 计算输出和 mask。

名称含义
outputdtype 是 Float32，mask 对应的位置上为 0 则该 Tensor 的元素为 0，否则为输入时对应位置的元素 keepProb, shape 与输入的 shape 相同。
maskdtype 是 Float32，元素的值为 0 或 1，shape 与输入的 shape 相同。

支持平台：Ascend, GPU, CPU

反向函数：

public func dropoutGrad(gradOut: Tensor, mask: Tensor, keepProb!: Float32 = 0.5): Tensor

微分伴随函数:

public func adjointDropout(input: Tensor, keepProb!: Float32 = 0.5, seed0!: Int64 = 0, seed1!: Int64 = 0)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([2.0, 2.0, 3.0]), shape: Array<Int64>([3]))
    let (output, prob) = dropout(input, keepProb: 1.0)
    print(output)
    print(prob)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Float32, value=
    [2.00000000e+00 2.00000000e+00 3.00000000e+00])
    Tensor(shape=[3], dtype=Float32, value=
    [1.00000000e+00 1.00000000e+00 1.00000000e+00])

dropout3D

public func dropout3D(x: Tensor, keepProb!: Float32 = 0.5): (Tensor, Tensor)

函数 dropout3D 实现 Dropout3D 算子功能，用于在训练期间，以概率 1 – keepProb 从伯努利分布中随机将输入张量的一些通道归零。

输入：

名称含义
x输入的 Tensor, shape 是 (N, C, D, H, W)，支持类型 GPU 支持 Float32，Ascend 支持 Float32 与 Int32。
keepProb进行 mask 的概率，value 在[0, 1] 之间，默认值：0.5。

输出：2 个 Tensor 的元组，dropout 计算输出和 mask。

名称含义
output与 x 的 shape 和 dtype 一致。
mask与 x 的 shape 一致，dtype 是 Bool 类型。

支持平台：Ascend, GPU

微分伴随函数:

public func adjointDropout3D(x: Tensor, keepProb!: Float32 = 0.5)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x = parameter(Tensor(Array<Float32>([3.0, 3.0, 1.0, 0.0, 0.0, 0.0, 3.0, 0.0]), shape: Array<Int64>([2, 1, 2, 1, 2])), "x")
    let (output, mask) = dropout3D(x, keepProb: 0.5)
    print(output.getShape())
    return 0
}

输出为：

[2, 1, 2, 1, 2]

dynamicShape

public func dynamicShape(input: Tensor): Tensor

返回输入 Tensor input 的 shape，应用于动态 shape 场景。

输入：

名称含义
input输入 Tensor。支持 Int32、Float32、Bool 类型

输出：

名称含义
outputinput 的 shape，Int32 类型 Tensor

支持平台：Ascend, GPU

微分伴随函数:

public func adjointDynamicShape(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    var input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([2, 2]))
    let out = dynamicShape(input)
    print(out)
    return 0
}

输出为：

Tensor(shape=[2], dtype=Int32, value=
[2 2])

elu

public func elu(input: Tensor, alpha!: Float32 = 1.0): Tensor

计算指数线性

\begin{split}\text{ELU}(x)= \left{\begin{array}{align}\alpha(e^{x}  – 1) & \text{if } x \le 0\x & \text{if } x \gt 0\\end{array}\right.\end{split}

输入：

名称含义
input输入，支持 Float32 类型 Tensor
alpha负面系数，Float32 类型的数字，目前仅支持 1.0, 默认值：1.0

输出：

名称含义
output输出, 与 input 的 shape 和 dtype 相同

支持平台：Ascend, GPU, CPU

反向函数：

public func eluGrad(x: Tensor, y: Tensor): Tensor

微分伴随函数:

public func adjointElu(input: Tensor, alpha!: Float32 = 1.0)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([-1.0, 4.0, -8.0, 2.0, -5.0, 9.0]), shape: [2, 3])
    let output = elu(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 3], dtype=Float32, value=
[[-6.32120490e-01  4.00000000e+00 -9.99664545e-01]
 [ 2.00000000e+00 -9.93262053e-01  9.00000000e+00]])

embeddingLookup

public func embeddingLookup(inputParams: Tensor, inputIndices: Tensor, offset: Int64): Tensor

通过索引从输入 Tensor 中取数据，索引通过 offset 做偏移，偏移后的 Indices 为 inputIndices – offset。索引值超过 input 张量的 0 维索引部分，对应位置值取零。如果索引值为负数，则对应输出张量部分是未定义的。 Ascend 平台只支持静态图模式。

输入：

名称含义
inputParams输入 Tensor。支持 Float32、Bool 类型 要求 dim 为 2
inputIndices索引 Tensor。支持 Int32、Int64 类型
offset对索引 Tensor 做偏移。Int64 类型标量

输出：

名称含义
output输出 Tensor，数据类型与输入 Tensor 一致

支持平台：GPU

微分伴随函数:

public func adjointEmbeddingLookup(inputParams: Tensor, inputIndices: Tensor, offset: Int64)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0]), shape: Array<Int64>([8, 2]))
    let idx = Tensor(Array<Int32>([5, 2, 8, 5]), shape: Array<Int64>([2, 2]))
    let offset: Int64 = 4
    let out = embeddingLookup(x, idx, offset)
    print(out)
    return 0
}

输出为：

Tensor(shape=[2, 2, 2], dtype=Float32, value=
[[[ 3.00000000e+00  4.00000000e+00]
  [ 0.00000000e+00  0.00000000e+00]]
 [[ 9.00000000e+00  1.00000000e+01]
  [ 3.00000000e+00  4.00000000e+00]]])

eps

public func eps(input: Tensor): Tensor

函数 eps 根据输入 Tensor 的 dtype 返回一个全是该数据类型下最小值的 Tensor。

输入：

名称含义
input输入 Tensor, 可选数据类型：Float16\Float32\Float64

输出：

名称含义
output输出的 Tensor, 其 shape 和 dtype 和输入的一致

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointEps(input: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 2.0, 5.0]), shape: [3])
    let output = eps(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Float32, value=
[1.52587891e-05 1.52587891e-05 1.52587891e-05])

equal

public func equal(input1: Tensor, input2: Tensor): Tensor
public func equal(input1: Tensor, input2: Float16): Tensor
public func equal(input1: Float16, input2: Tensor): Tensor
public func equal(input1: Tensor, input2: Float32): Tensor
public func equal(input1: Float32, input2: Tensor): Tensor
public func equal(input1: Tensor, input2: Float64): Tensor
public func equal(input1: Float64, input2: Tensor): Tensor
public func equal(input1: Int32, input2: Tensor): Tensor
public func equal(input1: Tensor, input2: Int32): Tensor

函数 equal 实现 Equal 算子功能，用于计算 x==y 元素的 Bool 值。

输入：

名称含义
input1输入 Tensor，GPU & CPU 支持 Float16\Float32\Float64\Int32, Ascend 支持 Float16\Float32\Int32 类型的标量或者 Tensor，两个输入必须为同一 dtype 类型，不能同时为标量。
input2输入 Tensor，GPU & CPU 支持 Float16\Float32\Float64\Int32, Ascend 支持 Float16\Float32\Int32 类型的标量或者 Tensor，两个输入必须为同一 dtype 类型，不能同时为标量。

输出：

名称含义
outputTensor，与广播后的形状相同，数据类型为 Bool。

支持平台：Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input1 = Tensor(Array<Float32>([3.0, 2.0, 1.0]), shape: Array<Int64>([3]))
    let input2 = Tensor(Array<Float32>([2.0, 2.0, 3.0]), shape: Array<Int64>([3]))
    let output = equal(input1, input2)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Bool, value=
[false true false])

equalCount

public func equalCount(x: Tensor, y: Tensor): Tensor

函数 equalCount 实现 EqualCount 算子功能，用于计算 x == y 元素的个数。

输入：

名称含义
x输入 Tensor，接收 Float16\Float32\Int32 类型的 Tensor，两个输入必须为同一 dtype 类型，shape 也必须相同。
y输入 Tensor，接收 Float16\Float32\Int32 类型的 Tensor，两个输入必须为同一 dtype 类型，shape 也必须相同。

输出：

名称含义
outputTensor，与输入的 dtype 相同，shape 为[1]。

支持平台：GPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x = Tensor(Array<Int32>([1, 0, 1, 1, 0]), shape: Array<Int64>([5]))
    let y = Tensor(Array<Int32>([3, 0, 0, 2, 2]), shape: Array<Int64>([5]))
    let output = equalCount(x, y)
    print(output)
    return 0
}

输出为：

Tensor(shape=[1], dtype=Int32, value= [1])

erfc

public func erfc(x: Tensor): Tensor

函数 erfc 实现 Erfc 算子功能，即 1 – 高斯误差函数。以 element-wise 的方式进行计算，计算公式如下：

erfc(x)=1−2π∫0xe−t2dt

输入：

名称含义
x输入 Tensor，支持 Float16\Float32 类型的 Tensor，且 rank 需要小于 8。

输出：

名称含义
output结果 Tensor， 与输入 Tensor 的数据类型和形状相同。

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointErfc(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x = Tensor(Array<Float32>([-0.9332344532, 0.5735540390, 0.1609500945, 0.5236085653]), shape: [2, 2])
    let output = erfc(x)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[1.81309581e+00 4.17292267e-01]
 [8.19943309e-01 4.59000111e-01]])

exp

public func exp(input: Tensor): Tensor

函数 exp 实现 Exp 算子功能，用于计算一个 Tensor 逐个元素的以欧拉数 ($e$) 为底的指数, 即: $e^{x}$。

输入：

名称含义
input输入 Tensor，支持 Float16\Float32 类型的 Tensor。

输出：

名称含义
output计算指数后的 Tensor， 与输入 Tensor 的数据类型和形状相同。

支持平台：Ascend, CPU

微分伴随函数：

public func adjointExpOp(input: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 2.0, 4.0]), shape: Array<Int64>([3]))
    let output = exp(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Float32, value=
    [2.71828175e+00 7.38905621e+00 5.45981483e+01])

expandDims

public func expandDims(input: Tensor, axis: Int64): Tensor

函数 expandDims 实现 ExpandDims 算子功能，用来对输入在指定维度扩维。

参数列表：

名称含义
input输入数据。
axis需要扩展的维度位置，如果 axis 是负数，则代表后往前的第 axis 个维度（从 1 开始）。如果 input 的维度数为 rank, 那么 axis 的取值范围为 [-rank -1, rank]。

输出：

名称含义
output输出维度在指定轴扩展之后的 Tensor，与 input 的数据类型相同。

支持平台：Ascend, CPU

微分伴随函数：

public func adjointExpandDims(x: Tensor, axis: Int64)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([2.0, 2.0, 2.0, 2.0]), shape: Array<Int64>([2, 2]))
    let expandDims = expandDims(input, -1)
    print(expandDims.getShape())
    return 0
}

输出为：

[2, 2, 1]

flatten

public func flatten(input: Tensor): Tensor

函数 flatten 实现 Flatten 算子功能，用来合并 Tensor 除第 0 维外的其他维度。

输入：

名称含义
input输入形状为 [N,…]的 Tensor 。

输出：

名称含义
output输出 Tensor 的形状为[N, X]，其中 X 是剩余维度的乘积。

支持平台：Ascend, GPU

反向函数：

public func flattenGrad(x: Tensor, shape: Array<Int64>): Tensor

微分伴随函数:

public func adjointFlatten(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = onesTensor(Array<Int64>([1, 2, 3, 4]))
    let flatten = flatten(input)
    print(flatten.getShape())
    return 0
}

输出为：

[1, 24]

floatStatus

public func floatStatus(input: Tensor): Tensor

函数 floatStatus 实现 FloatStatus 算子功能，用于对输入 Tensor 进行判断，是否存在下溢或者上溢。

输入：

名称含义
input正向计算的输入 Tensor, 目前支持 Float16，Float32 类型。

输出：

名称含义
output输出形状为 Array([1])，dtype 为 Float32。

支持平台：GPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([10000000.0]), shape: Array<Int64>([1]))
    let output = floatStatus(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[1], dtype=Float32, value= [0.00000000e+00])

floor

public func floor(input: Tensor): Tensor

函数 floor 实现 Floor 算子功能，用于将 Tensor 向下舍入到最接近的整数元素。

输入：

名称含义
input(Tensor) 输入 Tensor，GPU & CPU 支持 Float16\Float32 类型 Tensor; Ascend 支持 Float16\Float32 类型 Tensor。

输出：

名称含义
output输出 Tensor，与原始变量的类型相同。

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointFloor(input: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([2.5, -3.7, -1.4, 7.8, 6.3]), shape: Array<Int64>([5]))
    let output = floor(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[5], dtype=Float32, value=
    [2.00000000e+00 -4.00000000e+00 -2.00000000e+00 7.00000000e+00 6.00000000e+00])

floorDiv

public func floorDiv(input1: Tensor, input2: Tensor): Tensor
public func floorDiv(input1: Tensor, input2: Float32): Tensor
public func floorDiv(input1: Float32, input2: Tensor): Tensor
public func floorDiv(input1: Tensor, input2: Int32): Tensor
public func floorDiv(input1: Int32, input2: Tensor): Tensor

函数 floorDiv 实现 FloorDiv 算子功能，用于计算第一个输入与第二个输入逐个元素相除，并向下取整。输入可以是 Tensor 或者标量，但不能同时为标量。当输入为两个 Tensor 时，其 shape 必须可以进行 broadcast。

输入：

名称含义
input1第一个输入。支持 Float32 或 Int32 类型的 number 或 tensor，两个输入的 dtype 必须相同。
input2第二个输入。支持 Float32 或 Int32 类型的 number 或 tensor，两个输入的 dtype 必须相同。

输出：

名称含义
output相除的 Tensor，数据类型和形状与 broadcast 后的输入相同。

支持平台：Ascend, GPU

微分伴随函数：

public func adjointFloorDiv(input1: Tensor, input2: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input1 = Tensor(Array<Float32>([0.5965690017, 0.7835913897, 0.3291122615, 0.7661116719, 0.5438582897, 0.0798860192]), shape: Array<Int64>([3, 2]))
    let input2 = Tensor(Array<Float32>([0.0275930110, 0.7529847026, 0.4509352744, 0.1639176756, 0.2969887257, 0.4561915398]), shape: Array<Int64>([3, 2]))
    let output = floorDiv(input1, input2)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3, 2], dtype=Float32, value=
[[2.10000000e+01 1.00000000e+00]
 [0.00000000e+00 4.00000000e+00]
 [1.00000000e+00 0.00000000e+00]])

floorMod

public func floorMod(input1: Tensor, input2: Tensor): Tensor
public func floorMod(input1: Tensor, input2: Int32): Tensor
public func floorMod(input1: Int32, input2: Tensor): Tensor
public func floorMod(input1: Tensor, input2: Float32): Tensor
public func floorMod(input1: Float32, input2: Tensor): Tensor

函数 floorMod FloorMod 算子功能，按元素计算除法的余数，向下除法。输入可以是 Tensor 或者标量，但不能同时为标量。当输入为两个 Tensor 时，其 shape 必须可以进行 broadcast。

输入：

名称含义
input1第一个输入。支持 Float32 或 Int32 类型的 number 或 tensor，两个输入的 dtype 必须相同，Tensor 的 shape 的维度不能超过 7。
input2第二个输入。支持 Float32 或 Int32 类型的 number 或 tensor，两个输入的 dtype 必须相同，Tensor 的 shape 的维度不能超过 7。

输出：

名称含义
output相除的 Tensor，数据类型和形状与 broadcast 后的输入相同。

支持平台：Ascend, GPU

微分伴随函数：

public func adjointFloorMod(input1: Tensor, input2: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input1 = parameter(Tensor(Array<Int32>([2, 4, -1]), shape: Array<Int64>([3])), "x")
    let input2 = parameter(Tensor(Array<Int32>([3, 3, 3]), shape: Array<Int64>([3])), "y")
    let output = floorMod(input1, input2)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Int32, value=
[2 1 2])

gather

public func gather(inputParams: Tensor, inputIndices: Tensor, axis: Int64): Tensor

函数 gather 实现 Gather 算子功能，用于根据轴和索引获取 Tensor 中的某些值。

输入：

名称含义
inputParams输入 Tensor， GPU & CPU 支持 Float32\Float64\Int32\Int64\Bool, Ascend 支持 Float32\Int32。
inputIndices索引， 整型类型 Tensor。 当执行设备为 CPU 时，值必须在 [0, inputParams.getShape()[axis]) 范围内。GPU & CPU 支持 Int32\Int64, Ascend 支持 Int32
axis轴。

输出：

支持平台：Ascend, GPU, CPU

微分伴随函数:

public func adjointGather(inputParams: Tensor, inputIndices: Tensor, axis: Int64)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let inputParams = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]), shape: Array<Int64>([2, 3]))
    let shape:Array<Int32> = Array<Int32>([1, 2])
    let inputIndices = Tensor(shape, shape: Array<Int64>([2]))
    let output = gather(inputParams, inputIndices, 1)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[2.00000000e+00 3.00000000e+00]
 [5.00000000e+00 6.00000000e+00]])

gatherD

public func gatherD(x: Tensor, dim: Int64, index: Tensor): Tensor

沿着一个指定的轴获取 Tensor 中的数据，输出新的 Tensor。获取数据的方式如下：

output[i][j][k] = x[index[i][j][k]][j][k]  // if dim == 0
output[i][j][k] = x[i][index[i][j][k]][k]  // if dim == 1
output[i][j][k] = x[i][j][index[i][j][k]]  // if dim == 2

除 dim 所在的维度，x 和 index 的其他维度对应的 shape 值需保持一致。定义 xShape 为 x 的 shape，xShapeDims 为 x 的维度，dim 的取值范围是：[-xShapeDims, xShapeDims), index 中每个元素的取值范围在[-xShape[dim], xShape[dim])。

输入：

名称含义
x输入 Tensor。支持 Float32\Int32\Int64\UInt32\Bool 类型。
dim指定获取数据的轴的位置。标量，支持 Int64 类型。
index索引 Tensor。支持 Int64、Int32 类型。

输出：

名称含义
output结果 Tensor，与输入 Tensor 具有相同 dtype。shape 和 index 一致

支持平台：GPU

反向函数：

public func gatherDGrad(index: Tensor, gradOut: Tensor, dim: Int64, xshape: Array<Int64>): Tensor

微分伴随函数:

public func adjointGatherD(x: Tensor, dim: Int64, index: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let x = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([2, 2]))
    let idx = Tensor(Array<Int64>([0, 0, 1, 0, 0, 1]), shape: Array<Int64>([2, 3]))
    let dim: Int64 = 1
    let out = gatherD(x, dim, idx)
    print(out)
    return 0
}

输出为：

Tensor(shape=[2, 3], dtype=Float32, value=
[[ 1.00000000e+00  1.00000000e+00  2.00000000e+00]
 [ 3.00000000e+00  3.00000000e+00  4.00000000e+00]])

gatherNd

public func gatherNd(input: Tensor, indices: Tensor): Tensor

函数 gatherNd 实现 GatherNd 算子功能，用于从 input 中根据 indices 进行取值，得到特定 shape 的 Tensor，输出 shape 的计算公式为：

indicesshape[:−1]+xshape[indicesshape[−1]:]

其中 input 的 rank 必须大于等于 indices shape 的最后一维。

输入：

名称含义
input输入 Tensor，接受 Float32\Float64\Int32\Int64\Bool, Ascend 支持 Float32\Int32\Bool 类型的 Tensor。
indices索引构成的 Tensor，接受 Int32\Int64, Ascend 支持 Int32 类型的 Tensor。

输出：

名称含义
output输出，数据类型与 input 一致。

支持平台：Ascend, GPU

微分伴随函数:

public func adjointGatherNd(input: Tensor, indices: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input = Tensor(Array<Float32>([-0.1, 0.3, 3.6, 0.4, 0.5, -3.2]), shape: Array<Int64>([2, 3]))
    let indices = Tensor(Array<Int32>([0, 0, 1, 1]), shape: Array<Int64>([2, 2]))
    let output = gatherNd(input, indices)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2], dtype=Float32, value=
    [-1.00000001e-01 5.00000000e-01])

gelu

public func gelu(input: Tensor): Tensor

函数 gelu 实现 GeLU 算子功能，GeLU 是一种常见的激活函数。

输入：

名称含义
input输入 Tensor，支持 Float16, Float32 类型。

输出：

名称含义
output结果 Tensor，与输入 Tensor 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU, CPU

反向函数：

public func geluGrad(gradOut: Tensor, input: Tensor, out: Tensor): Tensor

微分伴随函数:

public func adjointGelu(x: Tensor)

二阶伴随函数：

public func adjointGeluGrad(gradOut: Tensor, input: Tensor, out: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input = Tensor(Array<Float32>([1.0, 0.5]), shape: Array<Int64>([2]))
    let output = gelu(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2], dtype=Float32, value=
    [8.41192007e-01 3.45714003e-01])

getTupleItem

public func getTupleItem(input: Tensor, index: Int64): Tensor

函数 getTupleItem 实现 TupleGetItem 算子功能，用来获取 Tensor 元组中的某个 Tensor。

输入：

名称含义
inputTensor 元组，通常是 makeTuple 的输出, 支持所有类型的 Tensor。
index获取第几个 Tensor。

输出：

名称含义
output输出，返回 input 对应索引下标 index 的 Tensor。

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointGetTupleItem(input: Tensor, index: Int64)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input0 = Tensor(Array<Int32>([1, 2, 3]), shape: Array<Int64>([3]))
    let input1 = Tensor(Array<Int32>([4, 5, 6]), shape: Array<Int64>([3]))
    let input = makeTuple([input0, input1])
    let index = 0
    let output = getTupleItem(input, index)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Int32, value=
[1 2 3])

greater

public func greater(input1: Tensor, input2: Tensor): Tensor
public func greater(input1: Tensor, input2: Float64): Tensor
public func greater(input1: Tensor, input2: Float32): Tensor
public func greater(input1: Tensor, input2: Float16): Tensor
public func greater(input1: Tensor, input2: Int32): Tensor
public func greater(input1: Float64, input2: Tensor): Tensor
public func greater(input1: Float32, input2: Tensor): Tensor
public func greater(input1: Float16, input2: Tensor): Tensor
public func greater(input1: Int32, input2: Tensor): Tensor

函数 greater 实现 Greater 算子功能，用于对输入 Tensor 进行 element-wise 的比较，第一个 Tensor 位置上元素大于第二个 Tensor 对应的元素则返回 Tensor 上对应位置为 true，否则为 false。

两个入参至少有一个是 Tensor。当两个都是 Tensor 时需要保证 shape 可以进行 broadcast。

输入：

名称含义
input1输入 Tensor，GPU & CPU 接受 Float16\Float32\Float64\Int32 类型的标量或者 Tensor; Ascend 接受 Float16\Float32\Int32 类型的标量或者 Tensor，两个输入必须为同一 dtype 类型，不能同时为标量。
input2输入 Tensor，GPU & CPU 接受 Float16\Float32\Float64\Int32 类型的标量或者 Tensor; Ascend 接受 Float16\Float32\Int32 类型的标量或者 Tensor，两个输入必须为同一 dtype 类型，不能同时为标量。

输出：

名称含义
output比较计算的结果 Tensor，Bool 类型，shape 跟 input1 和 input2 相同（或者跟两者 broadcasting 之后相同）。

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointGreater(input1: Tensor, input2: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input1 = Tensor(Array<Float32>([1.0, 2.0, 3.0]), shape: Array<Int64>([3]))
    let input2 = Tensor(Array<Float32>([1.0, 1.0, 4.0]), shape: Array<Int64>([3]))
    let output = greater(input1, input2)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Bool, value=
[false true false])

greaterEqual

public func greaterEqual(input1: Tensor, input2: Tensor): Tensor
public func greaterEqual(input1: Tensor, input2: Float16): Tensor
public func greaterEqual(input1: Float16, input2: Tensor): Tensor
public func greaterEqual(input1: Tensor, input2: Float32): Tensor
public func greaterEqual(input1: Float32, input2: Tensor): Tensor
public func greaterEqual(input1: Tensor, input2: Float64): Tensor
public func greaterEqual(input1: Float64, input2: Tensor): Tensor
public func greaterEqual(input1: Tensor, input2: Int32): Tensor
public func greaterEqual(input1: Int32, input2: Tensor): Tensor

函数 greaterEqual 实现 GreaterEqual 算子功能，用于对输入 Tensor 进行 element-wise 的比较，第一个 Tensor 位置上元素大于等于第二个 Tensor 对应的元素则返回 Tensor 上对应位置为 true，否则为 false。

两个入参至少有一个是 Tensor。当两个都是 Tensor 时需要保证 shape 可以进行 broadcast。

输入：

名称含义
input1输入 Tensor，GPU & CPU 支持 Float16\Float32\Float64\Int32 类型的标量或者 Tensor; Ascend 支持 Float16\Float32\Int32 类型的标量或者 Tensor，两个输入必须为同一 dtype 类型，不能同时为标量。
input2输入 Tensor，GPU & CPU 支持 Float16\Float32\Float64\Int32 类型的标量或者 Tensor; Ascend 支持 Float16\Float32\Int32 类型的标量或者 Tensor，两个输入必须为同一 dtype 类型，不能同时为标量。

输出：

名称含义
output输出 Tensor，Bool 类型，shape 跟 input1 和 input2 相同（或者跟两者 broadcasting 之后相同）。

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointGreaterEqual(input1: Tensor, input2: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input1 = Tensor(Array<Float32>([2.0, -3.0, -1.4, 7.0, 6.0]), shape: Array<Int64>([5]))
    let input2 = Tensor(Array<Float32>([3.5, -4.0, -0.4, -5.0, 6.0]), shape: Array<Int64>([5]))
    let output = greaterEqual(input1, input2)
    print(output)
    return 0
}

输出为：

Tensor(shape=[5], dtype=Bool, value=
[false true false true true])

hardsigmoid

public func hardsigmoid(input: Tensor) : Tensor

Hard sigmoid 的激活函数

Hard sigmoid 定义为：

hsigmoid(xi)=max(0,min(1,xi+36))

输入：

名称含义
input输入 Tensor, 支持 Float32 类型

输出：

名称含义
output输出 Tensor, 与输入 的 shape 和 dtype 相同

支持平台：Ascend, GPU, CPU

反向函数：

public func hardsigmoidGrad(input1: Tensor, input2: Tensor)

微分伴随函数:

public func adjointHardsigmoid(input: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([-1.0, -2.0, 0.0, 2.0, 1.0]), shape: Array<Int64>([5]))
    let output = hardsigmoid(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[5], dtype=Float32, value=
[3.33333343e-01 1.66666672e-01 5.00000000e-01 8.33333313e-01 6.66666687e-01])

hardswish

public func hardswish(input: Tensor): Tensor

Hard swish 的激活函数:

Hard swish 定义为：

hardswish(xi)=xi∗ReLU6(xi+3)6

输入：

名称含义
input输入 Tensor, 支持 Float32 类型

输出：

名称含义
output输出 Tensor, 与输入 的 shape 和 dtype 相同

支持平台：Ascend, GPU, CPU

反向函数：

public func hardswishGrad(input1: Tensor, input2: Tensor)

微分伴随函数:

public func adjointHardswish(input: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([-1.0, -2.0, 0.0, 2.0, 1.0]), shape: Array<Int64>([5]))
    let output = hardswish(input)
    print(output)
    return 0
}

代码示例：

Tensor(shape=[5], dtype=Float32, value=
[-3.33333343e-01 -3.33333343e-01 0.00000000e+00 1.66666663e+00 6.66666687e-01])

inTopK

public func inTopK(x1: Tensor, x2: Tensor, k: Int64): Tensor

给定一份样本 x1(Tensor)，再给定一组索引 x2(Tensor), 检测索引对应的元素是否在 A 组元素的前 k 大的数中，是返回 true，否返回 false

输入：

名称含义
x1一个 2 维 Tensor，表示待检测的样本值。支持 Float32, Float16 类型
x2一个 1 维 Tensor，指定检测索引。x2 的 shape 与 x1_shape[0]相等。支持 Int32 类型。 x2 取值不可为负且必须小于或等于 x1 第二维度的大小, 超出范围未定义。
k指定检测的范围

输出：

名称含义
output输出 Tensor, shape 与 x2 相同，Bool 类型，如果 x2 下标所表示的 value 在 x1 的前 k 个元素中，返回 true，否则返回 false

支持平台：Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x1 = Tensor(Array<Float32>([1.0, 8.0, 5.0, 2.0, 7.0, 4.0, 9.0, 1.0, 3.0, 5.0]), shape: Array<Int64>([2, 5]))
    let x2 = Tensor(Array<Int32>([1, 3]), shape: Array<Int64>([2]))
    let output = inTopK(x1, x2, 3)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2], dtype=Bool, value=
[true false])

iou

public func iou(anchorBoxes: Tensor, gtBoxes: Tensor, mode!: String = "iou"): Tensor

计算两个矩形的并交比

IOU 代表两个矩阵的交集在并集上的比例，IOF 代表两个矩阵的交集在正确的矩阵上的比例

IOU=Area of OverlapArea of UnionIOF=Area of OverlapArea of Ground Truth

输入：

名称含义
anchorBoxes待检测矩阵(Tensor) ，shape 为 (N,4) , x, y 代表横纵坐标, “4” 元素分别代表 “x0″(x 轴最小值), “y0″(y 轴最小值), “x1″(x 轴最大值), and “y1″(y 轴最大值)。支持 Float32, Float16 类型
gtBoxes真实的有效值矩阵（Ground truth）, shape 为(M,4), x, y 代表横纵坐标, “4” 元素分别代表 “x0”, “y0”, “x1”, and “y1″。支持 Float32, Float16 类型
mode计算方式。可选值：”iou”，”iof” 。默认值: “iou”

输出：

名称含义
output输出 Tensor, shape 为（M,N）, dtype 与 anchorBoxes 相同

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointIou(anchorBoxes: Tensor, gtBoxes: Tensor, mode!: String = "iou")

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let anchorBoxes = Tensor(Array<Float32>([1.0, 1.0, 4.0, 5.0]), shape: Array<Int64>([1, 4]))
    let gtBoxes = Tensor(Array<Float32>([3.0, 2.0, 3.0, 6.0]), shape: Array<Int64>([1, 4]))
    let output = iou(anchorBoxes, gtBoxes)
    print(output)
    return 0
}

输出为：

Tensor(shape=[1, 1], dtype=Float32, value=
[[ 1.90476194e-01]])

identity

public func identity(x: Tensor): Tensor

通过拷贝，返回一个跟输入 shape 和内容相同的新的 Tensor。

输入：

名称含义
x输入 Tensor 支持 Float16\Float32\Float64\Int32\Int64\Bool。

输出：

名称含义
output输出 Tensor，与输入 x shape 和 dtype 一致。

支持平台：GPU

微分伴随函数:

public func adjointIdentity(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let x = Tensor(Array<Int32>([1, 2, 3, 4]), shape: Array<Int64>([2, 2]))
    var out = identity(x)
    print(out)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Int32, value=
[[ 1  2]
 [ 3  4]])

isFinite

public func isFinite(x: Tensor): Tensor

判断 Tensor 中每个元素是否为 finite，finite 表示有限的数，inf 和 nan 都不是 finite。

输入：

名称含义
x输入 Tensor，支持 Float32 类型。

输出：

名称含义
output输出 Tensor，与输入 x shape 一致，Bool 类型。

支持平台：GPU

微分伴随函数:

public func adjointIsFinite(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let x = Tensor(Array<Float32>([1.0, 1.0/0.0]), shape: Array<Int64>([2]))
    var out = isFinite(x)
    print(out)
    return 0
}

输出为：

Tensor(shape=[2], dtype=Bool, value=
[true false])

isInf

public func isInf(input: Tensor): Tensor

函数 isInf 实现 IsInf 算子功能，判断输入 Tensor 的每个元素是否为无穷数，返回一个 Bool 类型的 Tensor。

输入：

名称含义
input输出 Tensor, 可选数据类型：Float32

输出：

名称含义
output输出 Tensor, 其 shape 与输入 Tensor 一致，数据类型为 Bool 类型

支持平台：GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*
from std import math.*

main(): Int64
{
    let input = Tensor(Array<Float32>([Float32.NaN, 2.0, Float32.Inf]), shape: [3])
    let output = isInf(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Bool, value=
[false false true])

isNan

public func isNan(input: Tensor): Tensor

函数 isNan 实现 IsNan 算子功能，判断输入 Tensor 的每个元素是否为非数，返回一个 Bool 类型的 Tensor。

输入：

名称含义
input输入 Tensor, 可选数据类型：Float32

输出

名称含义
output输出 Tensor, 其 shape 与输入 Tensor 一致，数据类型为 Bool 类型

支持平台：GPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*
from std import math.*

main(): Int64
{
    let input = Tensor(Array<Float32>([Float32.NaN, 2.0, Float32.Inf]), shape: [3])
    let output = isNan(input)
    print(output)
    return 0
}

输出：

Tensor(shape=[3], dtype=Bool, value=
[true false false])

indexAdd

public func indexAdd(inputX: Tensor, indice: Tensor, inputY: Tensor, axis: Int64, useLock!: Bool = true, checkIndexBound!: Bool = true): Tensor

函数 indexAdd 实现 IndexAdd 算子功能，把 inputX 中沿 axis 维度 indice 位置的元素分别与对应的 inputY 相加，返回相加后的 Tensor。

输入：

名称含义
inputX输入 Tensor, 可选数据类型：GPU 支持 Float16、Float32、Float64、Int32，反向不支持 Float16；Ascend 支持 Float32、Int32, 维度大于 0, 必须是 Parameter
indice索引信息, 可选数据类型：Int32, 必须是 1D 的 Tensor, indice 的值应在 inputX 沿 axis 方向的长度范围内, 即 [0, shapeX[axis]), 超出范围则不进行计算
inputY需要相加的 Tensor, 数据类型与 inputX 一致，除 axis 方向外 shape 与 inputX 一致，而在 axis 方向的长度等于 indice 元素的个数
axis索引方向，表示沿 inputX 的哪个维度进行索引，数据类型必须是 Int64, 数值范围必须在 InputX 的 rank 之内
useLockBool 类型, 是否开启 lock mode 以保护变量 Tensor 的更新过程, 默认值 true
checkIndexBoundBool 类型, 是否进行 index 边界检查, 默认值 true

输出：

名称含义
output输出 Tensor, 其 shape 和 dtype 与输入 Tensor 一致

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointIndexAdd(inputX: Tensor, indice: Tensor, inputY: Tensor, axis: Int64, useLock!: Bool = true, checkIndexBound!: Bool = true)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let inputX = parameter(Tensor(Array<Int32>([0, 0, 0, 0, 0, 0]), shape: [2, 3]), "inputX")
    let indice = parameter(Tensor(Array<Int32>([0]), shape: [1]), "indice")
    let inputY = parameter(Tensor(Array<Int32>([1, 2, 3]), shape: [1, 3]), "InputY")
    let axis: Int64 = 0
    let output = indexAdd(inputX, indice, inputY, axis)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 3], dtype=Int32, value=
[[ 1  2  3]
 [ 0  0  0]])

invertPermutation

public func invertPermutation(x: Tensor): Tensor

对于是索引的一组排列，交换其索引和值，仅支持动态图。其计算过程如下：

y[x[i]]=i,i∈[0,1,…,len(x)−1]

输入：

名称含义
x输入 Tensor，取值范围是[0, len(x) – 1]，不能有重复值。支持 Int32 类型，shape 为 1D。

输出：

名称含义
output输出 Tensor，与输入 x shape 和 dtype 一致。

支持平台：GPU

微分伴随函数:

public func adjointInvertPermutation(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let x = Tensor(Array<Int32>([3, 4, 0, 2, 1]), shape: Array<Int64>([5]))
    let out = invertPermutation(x)
    print(out)
    return 0
}

输出为：

Tensor(shape=[5], dtype=Int32, value=
[2 4 3 0 1])

klDivLoss

public func klDivLoss(logits: Tensor, labels: Tensor, reduction!: String = "mean"): Tensor

计算 logits 和 labels 之间的 Kullback-Leibler 散度

KLDivLoss 算法的更新公式如下:

L=l1,…,lN⊤,ln=yn⋅(log⁡yn−xn)Then,ℓ(x,y)={L,if reduction=’none’;mean⁡(L),if reduction=’mean’;sum⁡(L),if reduction=’sum’.x代表logits.y代表labels.ℓ(x,y)代表output.

输入：

名称含义
logits输入，支持 Float32 类型
labels标签，shape 和 类型 与 logits 相同
reduction指定以上公式中 reduction 的类型。GPU 可选值: “none”, “mean”, “sum”; Ascend 可选值: “none”, “batchmean”, “sum”。 默认值: “mean”.

输出：

名称含义
output输出，如果 reduction 为 “none”，输出为 shape 和 类型 与 logits 相同 的 Tensor，否则输出为标量 Tensor

支持平台：Ascend, GPU

反向函数：

public func klDivLossGrad(logits: Tensor, labels: Tensor, gradOut: Tensor, reduction!: String = "mean")

微分伴随函数:

public func adjointKlDivLoss(logits: Tensor, labels: Tensor, reduction!: String = "mean")

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let logits = Tensor(Array<Float32>([0.2, 0.7, 0.1]), shape: Array<Int64>([3]))
    let labels = Tensor(Array<Float32>([0.0, 1.0, 0.0]), shape: Array<Int64>([3]))
    let output = klDivLoss(logits, labels, reduction: "none")
    print(output)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Float32, value=
[-0.00000000e+00 -6.99999988e-01 -0.00000000e+00])

less

public func less(input1: Tensor, input2: Tensor): Tensor
public func less(input1: Tensor, input2: Float16): Tensor
public func less(input1: Float16, input2: Tensor): Tensor
public func less(input1: Tensor, input2: Float32): Tensor
public func less(input1: Float32, input2: Tensor): Tensor
public func less(input1: Tensor, input2: Float64): Tensor
public func less(input1: Float64, input2: Tensor): Tensor
public func less(input1: Int32, input2: Tensor): Tensor
public func less(input1: Tensor, input2: Int32): Tensor

函数 less 实现 Less 算子功能，用于对输入 Tensor 进行 element-wise 的比较，第一个 Tensor 位置上元素小于第二个 Tensor 对应的元素则返回 Tensor 上对应位置为 true，否则为 false。

两个入参至少有一个是 Tensor。两个都是 Tensor 时需要保证 shape 可以进行 broadcast。

输入：

名称含义
input1输入 Tensor，GPU & CPU 支持 Float16\Float32\Float64\Int32, Ascend 支持 Float16\Float32\Int32 类型的标量或者 Tensor，两个输入必须为同一 dtype 类型，不能同时为标量。
input2输入 Tensor，GPU & CPU 支持 Float16\Float32\Float64\Int32, Ascend 支持 Float16\Float32\Int32 类型的标量或者 Tensor，两个输入必须为同一 dtype 类型，不能同时为标量。

输出：

名称含义
output比较计算的结果 Tensor，Bool 类型，shape 跟 input1 和 input2 相同（或者跟两者 broadcasting 之后相同）。

支持平台：Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input1 = Tensor(Array<Float32>([9.0, 16.0]), shape: Array<Int64>([2]))
    let input2 = Tensor(Array<Float32>([1.0, 26.0]), shape: Array<Int64>([2]))
    let output = less(input1, input2)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2], dtype=Bool, value=
[false true])

lessEqual

public func lessEqual(input1: Tensor, input2: Tensor): Tensor
public func lessEqual(input1: Tensor, input2: Float64): Tensor
public func lessEqual(input1: Tensor, input2: Float32): Tensor
public func lessEqual(input1: Tensor, input2: Float16): Tensor
public func lessEqual(input1: Tensor, input2: Int32): Tensor
public func lessEqual(input1: Float64, input2: Tensor): Tensor
public func lessEqual(input1: Float32, input2: Tensor): Tensor
public func lessEqual(input1: Float16, input2: Tensor): Tensor
public func lessEqual(input1: Int32, input2: Tensor): Tensor

函数 lessEqual 实现 LessEqual 算子功能，用于对输入 Tensor 进行 element-wise 的比较，第一个 Tensor 位置上元素小于等于第二个 Tensor 对应的元素则返回 Tensor 上对应位置为 true，否则为 false。

两个入参至少有一个是 Tensor。两个都是 Tensor 时需要保证 shape 可以进行 broadcast。

输入：

名称含义
input1输入 Tensor，GPU & CPU 接受 Float16\Float32\Float64\Int32 类型的标量或者 Tensor; Ascend 接受 Float16\Float32\Int32 类型的标量或者 Tensor，两个输入必须为同一 dtype 类型，不能同时为标量。
input2输入 Tensor，GPU & CPU 接受 Float16\Float32\Float64\Int32 类型的标量或者 Tensor; Ascend 接受 Float16\Float32\Int32 类型的标量或者 Tensor，两个输入必须为同一 dtype 类型，不能同时为标量。

输出：

名称含义
output比较计算的结果 Tensor，Bool 类型，shape 跟 input1 和 input2 相同（或者跟两者 broadcasting 之后相同）。

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointLessEqual(input1: Tensor, input2: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input1 = Tensor(Array<Float32>([9.0, 16.0]), shape: Array<Int64>([2]))
    let input2 = Tensor(Array<Float32>([1.0, 26.0]), shape: Array<Int64>([2]))
    let output = lessEqual(input1, input2)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2], dtype=Bool, value=
[false true])

logicalAnd

public func logicalAnd(input1: Tensor, input2: Bool): Tensor
public func logicalAnd(input1: Bool, input2: Tensor): Tensor
public func logicalAnd(input1: Tensor, input2: Tensor): Tensor

函数 logicalAnd 实现 LogicalAnd 算子功能，用于计算两个输入的 “逻辑与” 运算。

输入：

名称含义
input1输入 Tensor，接收 Bool 类型的标量或者 Tensor，不能同时为标量。
input2输入 Tensor，接收 Bool 类型的标量或者 Tensor，不能同时为标量。

输出：

名称含义
output结果 Tensor，Bool 类型，shape 跟 input1 和 input2 相同（或者跟两者 broadcasting 之后相同）。

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointLogicalAnd(input1: Tensor, input2: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input1 = Tensor([true, false, true], shape: Array<Int64>([3]))
    let input2 = Tensor([true, true, false], shape: Array<Int64>([3]))
    let output = logicalAnd(input1, input2)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Bool, value=
[true false false])

logicalNot

public func logicalNot(input: Tensor): Tensor

函数 logicalNot 实现 LogicalNot 算子功能，用于对输入 Tensor 进行 element-wise 的取反计算。

输入：

名称含义
input输入 Tensor，支持 Bool 类型。

输出：

名称含义
output结果 Tensor，与输入 Tensor 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU

微分伴随函数：

public func adjointLogicalNot(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input = Tensor(Array<Bool>([true, false, true, false, false]), shape: Array<Int64>([5]))
    let output = logicalNot(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[5], dtype=Bool, value=
[false true false true true])

logicalOr

public func logicalOr(input1: Bool, input2: Tensor): Tensor
public func logicalOr(input1: Tensor, input2: Tensor): Tensor
public func logicalOr(input1: Tensor, input2: Bool): Tensor

函数 logicalOr 实现 LogicalOr 算子功能，用于计算两个输入的 “逻辑或” 运算。

输入：

名称含义
input1输入 Tensor，接收 Bool 类型的标量或者 Tensor，不能同时为标量。
input2输入 Tensor，接收 Bool 类型的标量或者 Tensor，不能同时为标量。

输出：

名称含义
output结果 Tensor，Bool 类型，shape 跟 input1 和 input2 相同（或者跟两者 broadcasting 之后相同）。

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointLogicalOr(input1: Tensor, input2: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input1 = Tensor([true, false, true], shape: Array<Int64>([3]))
    let input2 = Tensor([true, true, false], shape: Array<Int64>([3]))
    let output = logicalOr(input1, input2)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Bool, value=
[true true true])

log

public func log(input: Tensor): Tensor

函数 log 实现 Log 算子功能，用于对输入 Tensor 进行 element-wise 的 log 计算。

输入：

名称含义
input输入 Tensor，GPU & CPU 支持 Float16\Float32\Float64 类型, Ascend 支持 Float16\Float32 类型。

输出：

名称含义
output结果 Tensor，与输入 Tensor 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointLog(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input = Tensor(Array<Float32>([9.0, 16.0]), shape: Array<Int64>([2]))
    let output = log(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2], dtype=Float32, value=
    [2.19722462e+00 2.77258873e+00])

log1p

public func log1p(input: Tensor): Tensor

函数 log1p 实现 Log1p 算子功能，用于对输入 Tensor 进行 element-wise 的计算。计算公式如下：

outi=loge(xi+1)

输入：

名称含义
input输入 Tensor，支持 Float16\Float32 类型。

输出：

名称含义
output结果 Tensor，与输入 Tensor 具有相同的 shape 和 dtype。

支持平台: Ascend, GPU, CPU

微分伴随函数：

public func adjointLog1p(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input = Tensor(Array<Float32>([0.5284928083, -0.5617582798, -0.7654479146, -0.3952527642]), shape: Array<Int64>([2, 2]))
    let output = log1p(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[4.24282163e-01 -8.24984670e-01]
 [-1.45007765e+00 -5.02944708e-01]])

logSoftmax

public func logSoftmax(input: Tensor, axis!: Int64 = -1): Tensor

函数 logSoftmax 实现 LogSoftmax 算子功能。

将 LogSoftmax 函数应用于指定轴上的输入 Tensor。 假设给定 axis 中的一个单维度切片，对于每个 $x_i$，LogSoftmax 函数计算如下所示：

output(xi)=log(exp(xi)∑j=0N−1exp(xj)),

输入：

名称含义
input输入 Tensor，目前只支持 Float32 类型。
axis需要计算 softmax 的轴，默认值为 -1，即计算最后一维。 如果 input 的维度数为 rank，那么 axis 的取值范围为 [-rank, rank)。

输出：

名称含义
output输出 Tensor，与输入 Tensor 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU, CPU

反向函数：

public func logSoftmaxGrad(input1: Tensor, input2: Tensor, axis!: Int64 = -1): Tensor

微分伴随函数:

public func adjointLogSoftmax(input: Tensor, axis!: Int64 = -1)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input = Tensor(Array<Float32>([9.0, 16.0]), shape: Array<Int64>([2]))
    let output = logSoftmax(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2], dtype=Float32, value=
    [-7.00091171e+00 -9.11712646e-04])

layerNorm

public func layerNorm(input: Tensor, gamma: Tensor, beta: Tensor, beginNormAxis!: Int64 = 1, beginParamsAxis!: Int64 = 1, epsilon!: Float32 = 1e-7): Tensor

函数 layerNorm 实现 LayerNorm 算子功能，用于在本层的各个特征之间，对 batch 中的每一个样本进行激活之前的正则化。 输入之间的限制：设 input 的维度数为 rank，则 beginNormAxis 的取值范围为 [-1, rank)，beginParamsAxis 的取值范围为 [-1, rank)。gamma 和 beta 的 shape 必须完全相等，如果 beginParamsAxis 为 1，那么 input 从第二维起，gamma 从第一维起，两者的每一维度的值都应完全相等。

y=x−meanvariance+ϵ∗γ+β

输入：

名称含义
input输入 Tensor，目前只支持 Float32 类型。
gammagamma 参数，可跟随网络进行训练，对输出结果进行缩放，目前只支持 Float32 类型。
betabeta 参数，可跟随网络进行训练，对输出结果进行平移，目前只支持 Float32 类型。
beginNormAxis对输入开始执行正则化的维度，value 必须在 [-1, rank(input)) 区间中，默认值为 1。
beginParamsAxis对参数开始执行正则化的维度，value 必须在 [-1, rank(input)) 区间中， 默认值为 1。
epsilon:为了数值计算稳定而加入的小 number，默认为 0.0000001。

输出：

名称含义
outputlayernorm 计算的结果 Tensor. 与输入 Tensor 具有相同的 shape 和 dtype
meanlayernorm 计算的均值
variancelayernorm 计算的方差

支持平台：Ascend, GPU, CPU

反向函数：

public func layerNormGrad(input: Tensor, gradOut: Tensor, variance: Tensor, mean: Tensor, gamma: Tensor, beginNormAxis!: Int64 = 1, beginParamsAxis!: Int64 = 1): (Tensor, Tensor, Tensor)

微分伴随函数:

public func adjointLayerNorm(input: Tensor, gamma: Tensor, beta: Tensor, beginNormAxis!: Int64 = 1, beginParamsAxis!: Int64 = 1, epsilon!: Float32 = 1e-7)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input = randomNormalTensor(Array<Int64>([2, 2, 3]))
    let gamma = onesTensor(Array<Int64>([2, 3]))
    let beta = onesTensor(Array<Int64>([2, 3]))
    let (output, mean, variance) = layerNorm(input, gamma, beta)
    print(output)
    print(mean)
    print(variance)
    return 0
}

输出为：

Tensor(shape=[2, 2, 3], dtype=Float32, value=
    [[[ 1.04573095e+00  2.81799555e-01  1.54612660e-02]
      [ 1.62202418e-01  2.83852386e+00  1.65628195e+00]]
     [[ 1.95735395e+00  5.20567179e-01  2.25229478e+00]
      [ 1.56564367e+00  2.58231640e-01 -5.54091096e-01]]])
Tensor(shape=[2, 1, 1], dtype=Float32, value=
    [[[-6.47745386e-04]]
     [[-3.89819220e-03]]])
Tensor(shape=[2, 1, 1], dtype=Float32, value=
    [[[ 1.17331721e-04]]
     [[ 3.14546378e-05]]])

linSpace

public func linSpace(start: Tensor, stop: Tensor, num: Int64): Tensor

函数 linSpace 实现 LinSpace 算子功能，用于创建起始值为 start，终止值为 stop 的等差数列。

输入：

名称含义
start输入 0-D Tensor，仅支持 Float32 类型，表示起始值。
stop输入 0-D Tensor，仅支持 Float32 类型，表示终止值。
num大于 0 的 Int64 类型，表示起始值与终止值中间的刻度数，包括起始值与终止值。

输出：

名称含义
outputshape 是 (num) 的一维 Tensor。

支持平台：Ascend, GPU

微分伴随函数：

public func adjointLinSpace(start: Tensor, stop: Tensor, num: Int64)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let start = parameter(Tensor(Array<Float32>([1.0]), shape: []), "start")
    let stop = parameter(Tensor(Array<Float32>([10.0]), shape: []), "stop")
    let num: Int64 = 5
    let output = linSpace(start, stop, num)
    print(output)
    return 0
}

输出为：

Tensor(shape=[5], dtype=Float32, value=
[1.00000000e+00 3.25000000e+00 5.50000000e+00 7.75000000e+00 1.00000000e+01])

lrn

public func lrn(input: Tensor, depthRadius!: Int64 = 5, bias!: Float32 = 1.0, alpha!: Float32 = 1.0, beta!: Float32 = 0.5, normRegion!: String = "ACROSS_CHANNELS"): Tensor

函数 lrn 实现 Local Response Normalization 功能，用于数据的归一化。计算过程如下：

bc=ac(k+αn∑c′=max(0,c−n/2)min(N−1,c+n/2)ac′2)−β

其中，$a_c$表示特征图上 c 对应的像素值；$n/2$表示 depthRadius；$k$表示 bias；$\alpha$表示$alpha$；$\beta$表示 beta。

参数列表：

名称含义
depthRadius归一化窗口的一半的宽度，需要大于等于 0, 支持 Int64 类型，默认值为 5
bias一个偏移量（通常为正数为避免除 0），支持 Float32 类型，默认值 1.0。Ascend 反向仅支持正数
alpha一个标量值，支持 Float32 类型，一般为正，默认值为 1.0。Ascend 反向仅支持正数，前向支持非负数
beta指数值，支持 Float32 类型，默认值为 0.5
normRegion特别的归一化区域，String 类型，可选值为“ACROSS_CHANNELS”, 默认值为“ACROSS_CHANNELS”

输入：

名称含义
input输入，4-D Tensor，仅支持 Float32 类型。

输出：

名称含义
output输出，归一化结果，dtype 和 shape 与 input 一致

支持平台：Ascend, GPU, CPU

反向函数：

public func lrnGrad(grads: Tensor, x: Tensor, y: Tensor, depthRadius!: Int64 = 5, bias!: Float32 = 1.0, alpha!: Float32 = 1.0, beta!: Float32 = 0.5)

微分伴随函数:

public func adjointLrn(input: Tensor, depthRadius!: Int64 = 5, bias!: Float32 = 1.0, alpha!: Float32 = 1.0, beta!: Float32 = 0.5, normRegion!: String = "ACROSS_CHANNELS")

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let x = parameter(Tensor(Array<Float32>([0.1, 0.2, 0.3, 0.4]), shape: Array<Int64>([1, 2, 2, 1])), "x")
    let res = lrn(x)
    print(res)
    return 0
}

输出为：

Tensor(shape=[1, 2, 2, 1], dtype=Float32, value=
[[[[ 9.53462496e-02]
   [ 1.82574183e-01]]
  [[ 2.86038756e-01]
   [ 3.65148365e-01]]]])

lstm

public func lstm(x: Tensor, hx: Tensor, cx: Tensor, w: Tensor, inputSize: Int64, hiddenSize: Int64, numLayers: Int64, hasBias: Bool, bidirectional: Bool, dropout: Float32): (Tensor, Tensor, Tensor, Tensor, Tensor)

函数 lstm 实现 LSTM 算子功能，用于对输入执行 Long Short-Term Memory (LSTM) 的计算。

在 LSTM 模型中，有两条时间连续的 pipeline，分别对应两个单元。一条对应 Cell state 单元， 一条对应 Hidden state 单元。 记两个连续的时间节点 $t-1$ 和 $t$，$t$ 时刻的输入记为 $x_t$，$t-1$ 时刻的 layer，其 Hidden state 记为 $h_{t-1}$，Cell state 记为 $c_{t-1}$。 使用门机制来计算 $t$ 时刻的 Hidden state 和 Cell state。输入门 $i_t$ 用于避免输入的扰动，遗忘门 $f_t$ 则保护 Cell 受到上一个时刻 $h_{t-1}$ 过多的影响。 输出门则保护其他单元免受当前非相关记忆内容的扰动。候选 $\tilde{c}_t$ 由输入得到，再和 $i_t$ 一起得到当前的 $c_t$。 $c_t$ 和 $h_t$ 都是用当前时刻的门计算得到的，详见论文: [https://www.bioinf.jku.at/publications/older/2604.pdf https://static.googleusercontent.com/media/research.google.com/zh-CN//pubs/archive/43905.pdf\](https://www.bioinf.jku.at/publications/older/2604.pdf https://static.googleusercontent.com/media/research.google.com/zh-CN//pubs/archive/43905.pdf)

输入：

名称含义
x输入的 Tensor，只接受 Float32 类型的 Tensor。
hx初始的隐状态，通常为 0，shape 为 (numDirections * numLayers, batchSize, hiddenSize)。只接受 Float32 类型的 Tensor。
cx初始 Cell state，通常为 0，shape 为(numDirections * numLayers, batchSize, hiddenSize)，只接受 Float32 类型的 Tensor。
w权重，即 LSTM 中的各种门的权重矩阵按顺序合并在一个 Tensor 中。只接受 Float32 类型的 Tensor。
inputSize类型为 Int64，输入的特征数。
hiddenSize类型为 Int64，隐藏层的特征数。
numLayers类型为 Int64，LSTM 堆叠层数，默认为 1。
hasBias类型为 Bool，是否使用 bias。
bidirectional类型为 Bool，是否使用双向 LSTM。
dropout类型为 Float32，每一层 lstm 的网络之后的 dropout (最后一层除外)，默认为 0.0，取值范围为 [0.0, 1.0)。

输出：

名称含义
output输出，Float32 类型的 Tensor。shape 为 (seqLen, batchSize, numDirections * hiddenSize)。
hN最后一个时刻的隐状态，Float32 类型的 Tensor。shape 为 (numDirections * numLayers, batchSize, hiddenSize)。
cN最后一个时刻的 Cell 状态，Float32 类型的 Tensor。shape 为 (numDirections * numLayers, batchSize, hiddenSize)。
reserveFloat32 类型的 Tensor。shape 为 (r，1) ，供反向计算使用。
state随机数生成状态，Float32 类型的 Tensor。shape 为 (1, 1)，供反向计算使用。

反向函数：

public func lstmGradWeight(x: Tensor, hx: Tensor, y: Tensor, reserve: Tensor, state: Tensor, inputSize: Int64, hiddenSize: Int64, numLayers: Int64, hasBias: Bool, bidirectional: Bool, dropout: Float32): Tensor

public func lstmGradData(y: Tensor, dy: Tensor, dhy: Tensor, dcy: Tensor, w: Tensor, hx: Tensor, cx: Tensor, reserve: Tensor, state: Tensor, inputSize: Int64, hiddenSize: Int64, numLayers: Int64, hasBias: Bool, bidirectional: Bool, dropout: Float32): Tensor

微分伴随函数:

public func adjointLstm(x: Tensor, hx: Tensor, cx: Tensor, w: Tensor, inputSize: Int64, hiddenSize: Int64, numLayers: Int64, hasBias: Bool, bidirectional: Bool, dropout: Float32)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let inputSize = 10
    let hiddenSize = 2
    let numLayers = 1
    let seqLen = 5
    let batchSize = 2
    let input = randomNormalTensor([seqLen, batchSize, inputSize])
    let h0 = randomNormalTensor([numLayers, batchSize, hiddenSize])
    let c0 = randomNormalTensor([numLayers, batchSize, hiddenSize])
    let w = randomNormalTensor(Array<Int64>([112, 1, 1]))
    let (output, hn, cn, reverse, state) = lstm(input, h0, c0, w, inputSize, hiddenSize, numLayers, true, false, 0.0)
    print(output)
    return 0
}

输出为：

Tensor(shape=[5, 2, 2], dtype=Float32, value=
[[[5.71691152e-03 -2.18112604e-03]
  [5.49678551e-03 -6.48714742e-03]]
 [[6.91998517e-03 -4.01305873e-03]
  [6.87390612e-03 -5.91153279e-03]]
 [[7.69769028e-03 -4.71466361e-03]
  [7.68993190e-03 -5.57636376e-03]]
 [[8.00751708e-03 -5.03855059e-03]
  [8.05460289e-03 -5.63370017e-03]]
 [[8.17715563e-03 -5.22785494e-03]
  [8.41557886e-03 -5.57166804e-03]]])

l2Normalize

public func l2Normalize(x: Tensor, axis!: Int64 = 0, epsilon!: Float32 = 0.0001): Tensor
public func l2Normalize(x: Tensor, axis: Array<Int64>, epsilon!: Float32 = 0.0001): Tensor

函数 l2Normalize 实现 L2Normalize 算子功能，使用 L2 范数沿维度 axis 标准化。

参数列表：

名称含义
axis标准化的维度，如果输入 Tensor 的维度数为 rank, 那么 axis 的取值范围为 [-rank, rank), 目前支持 Int64 与 1-D Array 类型，默认值：0。
epsilon为了数值计算稳定而加入的小 number，支持 Float32 类型，默认为 0.0001。

输入：

名称含义
x输入 Tensor, 支持 Float32, Float16 类型。

输出：

名称含义
output输出 Tensor，与 x 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU, CPU

反向函数：

public func l2NormalizeGrad(x: Tensor, out: Tensor, dout: Tensor, axis!: Int64, epsilon!: Float32 = 0.0001): Tensor

微分伴随函数:

public func adjointL2Normalize(x: Tensor, axis!: Array<Int64> = [0], epsilon!: Float32 = 0.0001)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let x = parameter(Tensor(Array<Float32>([-133.8271636963, 134.3088836670, -176.9140930176, 16.7510051727, 19.5274810791]), shape: Array<Int64>([5])), "x")
    let output = l2Normalize(x)
    print(output)
    return 0
}

输出为：

Tensor(shape=[5], dtype=Float32, value=
[-5.13547182e-01 5.15395701e-01 -6.78888559e-01 6.42801598e-02 7.49345794e-02])

matmul

public func matmul(input_x: Tensor, input_y: Tensor, transpose_a!: Bool = false, transpose_b!: Bool = false): Tensor

函数 matmul 实现 Matmul 算子功能，完成两个二维矩阵相乘运算。

输入：

名称含义
input_x如果 transpose_a 是 false，shape 是 (N, C) 的二维 Tensor。如果 transpose_a 是 true，则需要 input_x 转置后的 shape 是(N, C)。CPU、GPU 支持 Float16\Float32\Float64 类型, Ascend 支持 Float16\Float32 类型。
input_y如果 transpose_b 是 false，shape 是 (C, M) 的二维 Tensor。如果 transpose_b 是 true，则需要 input_y 转置后的 shape 是(C, M）。数据类型必须和 input_x 一致。
transpose_a如果取值是 true，就会先对左矩阵做转置后再跟右矩阵相乘。 默认值: false。
transpose_b如果取值是 true，就会先对右矩阵做转置后再跟左矩阵相乘。 默认值: false。

支持平台：Ascend, GPU, CPU

输出：

名称含义
outputshape 是 (N, M) 的二维 Tensor，取值是 input_x 和 input_y 相乘的结果。

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input_x = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([2, 2]))
    let input_y = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([2, 2]))
    let output = matmul(input_x, input_y, transpose_a: true, transpose_b: false)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[1.00000000e+01 1.40000000e+01]
 [1.40000000e+01 2.00000000e+01]])

maxPool

public func maxPool(input: Tensor, ksizes: Array<Int64>, strides: Array<Int64>, padMod!: String = "VALID"): Tensor

函数 maxPool 实现 MaxPool 算子功能，在输入的 Tensor 上进行 2D 最大值池化操作。

输入：

名称含义
inputTensor, shape 是（N, C, H, W), 数据类型支持 Float16, Float32。
ksizesArray, 滑窗大小。 长度为 2 的数组，value 必须小于输入 shape 的宽和高并且大于 0。
stridesArray, 滑窗跳步。 长度为 2 的数组，value 必须大于 0。
padModString, padding 模式，可选值：”VALID”, “SAME”。 默认值: “VALID”。
注：Ascend 平台运行反向，在 ksizes 或 strides shape 值不可过大的；如接近 input 的 shape。

输出：

名称含义
outputshape 是 (N, C, H_out, W_out) 的 Tensor。

支持平台：Ascend, GPU, CPU

反向函数：

public func maxPoolGrad(gradOut: Tensor, input: Tensor, value: Tensor, ksizes: Array<Int64>, strides: Array<Int64>, padding!: String = "VALID"): Tensor

微分伴随函数:

public func adjointMaxPool(input: Tensor, ksizes: Array<Int64>, strides: Array<Int64>, pad_mode: String)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let inputx = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([2, 1, 1, 2]))
    let output = maxPool(inputx, Array<Int64>([1, 1]), Array<Int64>([1, 1]))
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 1, 1, 2], dtype=Float32, value=
    [[[[ 1.00000000e+00  2.00000000e+00]]]
     [[[ 3.00000000e+00  4.00000000e+00]]]])

maxPool3D

public func maxPool3D(input: Tensor, ksizes: Array<Int64>, strides: Array<Int64>, padMod!: String = "VALID", padList!: Array<Int64> = [0, 0, 0, 0, 0, 0]): Tensor

函数 maxPool3D 实现 MaxPool3D 算子功能，在输入的 Tensor 上进行 3D 最大值池化操作。

输入：

名称含义
inputTensor, 支持 Float16/Float32 类型, shape 是（N, C, D, H, W)。
ksizesArray, 滑窗大小。 长度为 3 的数组，value 必须大于 0，并且小于等于输入 shape 的深、宽和高加上对应 padList 的值。
stridesArray, 滑窗跳步。 长度为 3 的数组，value 必须大于 0。
padModString, padding 模式，可选值：”VALID”, “SAME”, “PAD”。 默认值: “VALID”。
padListArray, padMod 为”PAD”模式时，用于指定 pad 数值，长度为 6 的数组，value 必须大于等于 0，其余模式 value 取值必须为 0。默认值：[0, 0, 0, 0, 0, 0]

输出：

名称含义
outputshape 是 (N, C, D_out, H_out, W_out) 的 Tensor。

支持平台：Ascend, GPU

微分伴随函数:

public func adjointMaxPool3D(input: Tensor, ksizes: Array<Int64>, strides: Array<Int64>, padMod!: String = "VALID", padList!: Array<Int64> = [0, 0, 0, 0, 0, 0])

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let data = parameter(initialize([32, 1, 32, 32, 32], initType: InitType.NORMAL, dtype: FLOAT32), "data")
    let out = maxPool3D(data, [2, 2, 2], [2, 2, 2], padMod: "PAD", padList: [1, 1, 1, 1, 1, 1])
    print(out.getShape())
    return 0
}

输出为：

[32, 1, 17, 17, 17]

makeTuple

public func makeTuple(inputArray: Array<Tensor>): Tensor
public func makeTuple(inputArray: ArrayList<Tensor>): Tensor

函数 makeTuple 实现 MakeTuple 算子功能，用来把多个 Tensor 合并成一个元组。

输入：

名称含义
inputArray类型为 Tensor 的数组或 ArrayList。

输出：

支持平台：GPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input0 = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([2, 2]))
    let input1 = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([2, 2]))
    let output = makeTuple([input0, input1])
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
    [[ 1.00000000e+00  2.00000000e+00]
     [ 3.00000000e+00  4.00000000e+00]])
    Tensor(shape=[2, 2], dtype=Float32, value=
    [[ 1.00000000e+00  2.00000000e+00]
     [ 3.00000000e+00  4.00000000e+00]])

matrixInverse

public func matrixInverse(input: Tensor, adjoint!: Bool = false): Tensor

函数 matrixInverse 实现 MatrixInverse 算子功能，返回输入 Tensor 的逆， 如果输入 Tensor 不可逆，将会报错或返回未知结果

输入：

名称含义
input输入 Tensor, 可选数据类型：Float32\Float64, 维度必须大于 2，并且最后两个维度的长度相等
adjointBool 类型，表示是否支持复数，当前还未支持，默认 false

输出:

名称含义
output输出 Tensor, 形状和数据类型与 input 一致

支持平台: GPU, CPU

微分伴随函数：

public func adjointMatrixInverse(input: Tensor, adjoint!: Bool = false)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 2.0, 5.0, 6.0]), shape: [2, 2])
    let output = matrixInverse(input)
    print(output)
    return 0
}

输出：

Tensor(shape=[2, 2], dtype=Float32, value=
[[-1.50000000e+00  5.00000000e-01]
 [ 1.25000000e+00 -2.50000000e-01]])

maxPoolWithArgmax

public func maxPoolWithArgmax(input: Tensor, ksizes: Array<Int64>, strides: Array<Int64>, padMod!: String = "VALID"): Tensor

函数 maxPoolWithArgmax 实现 MaxPoolWithArgmax 算子功能，用于计算最大值池化运算。

输入：

名称含义
input输入 Tensor，shape 是 (N, Cin, Hin, Win)，数据类型支持 Float32。
ksizesArray, 滑窗大小。 长度为 2 的数组，value 必须小于输入 shape 的宽和高并且大于 0。
stridesArray, 滑窗跳步。 长度为 2 的数组，value 必须大于 0。
padModString, padding 模式，可选值：”VALID”, “SAME”。 默认值: “VALID”。

【注意】：

  • same：采用完成方式。 输出的高度和宽度将与输入的高度和宽度相同。 填充的总数将在水平和垂直方向上计算，并在可能的情况下均匀分布在顶部和底部，左侧和右侧。 否则，最后的额外填充将从底部和右侧开始。
  • valid：采用丢弃方式。 可能的最大输出高度和宽度将返回，而不会填充。 多余的像素将被丢弃。

输出：

名称含义
output池化结果，shape 是 (N, Cout, Hout, Wout)的 Tensor。dtype 和输入相同。
mask最大值索引，Int32 类型的 Tensor。

支持平台：GPU

反向函数：

public func maxPoolGradWithArgmax(input: Tensor, gradOut: Tensor, gradient: Tensor, ksizes: Array<Int64>, strides: Array<Int64>, padding!: String = "VALID"): Tensor

微分伴随函数:

public func adjointMaxPoolWithArgmax(input: Tensor, ksizes: Array<Int64>, strides: Array<Int64>, pad_mode: String)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let inputx = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([2, 1, 1, 2]))
    let (output, mask) = maxPoolWithArgmax(inputx, Array<Int64>([1, 1]), Array<Int64>([1, 1]))
    print(output)
    print(mask)
    return 0
}

输出为：

Tensor(shape=[2, 1, 1, 2], dtype=Float32, value=
    [[[[ 1.00000000e+00  2.00000000e+00]]]
     [[[ 3.00000000e+00  4.00000000e+00]]]])
Tensor(shape=[2, 1, 1, 2], dtype=Int32, value=
    [[[[ 0  1]]]
     [[[ 0  1]]]])

maximum

public func maximum(input1: Tensor, input2: Tensor): Tensor
public func maximum(input1: Tensor, input2: Float64): Tensor
public func maximum(input1: Tensor, input2: Float32): Tensor
public func maximum(input1: Tensor, input2: Float16): Tensor
public func maximum(input1: Tensor, input2: Int32): Tensor
public func maximum(input1: Float64, input2: Tensor): Tensor
public func maximum(input1: Float32, input2: Tensor): Tensor
public func maximum(input1: Float16, input2: Tensor): Tensor
public func maximum(input1: Int32, input2: Tensor): Tensor

函数 maximum 实现 Maximum 算子功能，用于计算两个 Tensor 取逐个元素最大值。输入必须是两个 Tensor 或者一个 Tensor 和一个标量。当输入是两个 Tensor 时，它们的 dtype 不能同时是 Bool，它们的形状可以被 Broadcast。当输入是一个 Tensor 和一个标量时，这个标量只能是一个常数。 该算子 Float16 类型的精度为 0.01，后续会精度提升到 0.001。

输入：

名称含义
input1第一个输入, 支持 Float16\Float32\Float64\Int32 类型, 可以为 Tensor 或者标量, 两个输入不能同时为标量。
input2第二个输入，数据类型与第一个相同, 可以为 Tensor 或者标量, 两个输入不能同时为标量。

支持平台：Ascend, GPU, CPU

输出：

名称含义
output结果 Tensor, dtype 与输入一致。

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointMaximum(input1: Tensor, input2: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input0 = Tensor(Array<Float32>([1.0, 5.0, 3.0]), shape: Array<Int64>([3]))
    let input1 = Tensor(Array<Float32>([4.0, 2.0, 6.0]), shape: Array<Int64>([3]))
    let output = maximum(input0, input1)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Float32, value=
    [4.00000000e+00 5.00000000e+00 6.00000000e+00])

meshgrid

public func meshgrid(input : Array<Tensor>, indexing!: String = "xy"): Tensor

从给定的坐标张量中构建坐标矩阵

给定 N 个一维的坐标向量，返回一个由 N 个 N-D 坐标张量组成的元组输出，用于在 N-D 网格上计算表达式

输入：

名称含义
inputN 个一维 Tensor 对象的数组，数组长度必须大于 1。支持 Float64,Float32, Int32, Int64 类型 Tensor
indexing输出索引选项。可选项: “xy”，”ij”, 默认值”xy”。在输入 Tensor 长度分别是 M 和 N 的二维情况下，输入为”xy”时输出形状为(N,M), 输入为”ij”时输出形状为(M,N)。在输入 Tensor 长度分别是 M,N 和 P 的情况下，输入为”xy”是输出形状为(N,M,P),输入为”ij”时输出形状为(M,N,P)

输出：

名称含义
output输出，N 个 N-D Tensor 类型的 tuple，dtype 与输入相同

支持平台: Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x = parameter(Tensor(Array<Int32>([2, 3]), shape: [2]), "x")
    let y = parameter(Tensor(Array<Int32>([2, 3, 4]), shape: [3]), "y")
    let z = parameter(Tensor(Array<Int32>([5]), shape: [1]), "z")
    let input = Array<Tensor>([x, y, z])
    let output = meshgrid(input)
    print(output[0])
    print(output[1])
    print(output[2])
    return 0
}

输出为：

Tensor(shape=[3, 2, 1], dtype=Int32, value=
[[[2]
  [3]]
 [[2]
  [3]]
 [[2]
  [3]]])
Tensor(shape=[3, 2, 1], dtype=Int32, value=
[[[2]
  [2]]
 [[3]
  [3]]
 [[4]
  [4]]])
Tensor(shape=[3, 2, 1], dtype=Int32, value=
[[[5]
  [5]]
 [[5]
  [5]]
 [[5]
  [5]]])

minimum

public func minimum(input1: Tensor, input2: Tensor): Tensor
public func minimum(input1: Tensor, input2: Float64): Tensor
public func minimum(input1: Tensor, input2: Float32): Tensor
public func minimum(input1: Tensor, input2: Float16): Tensor
public func minimum(input1: Tensor, input2: Int32): Tensor
public func minimum(input1: Float64, input2: Tensor): Tensor
public func minimum(input1: Float32, input2: Tensor): Tensor
public func minimum(input1: Float16, input2: Tensor): Tensor
public func minimum(input1: Int32, input2: Tensor): Tensor

函数 minimum 实现 Minimum 算子功能，用于计算两个 Tensor 取逐个元素最小值。输入必须是两个 Tensor 或者一个 Tensor 和一个标量。当输入是两个 Tensor 时，它们的 dtype 不能同时是 Bool，它们的形状可以被 Broadcast。当输入是一个 Tensor 和一个标量时，这个标量只能是一个常数。 该算子 Float16 类型的精度为 0.01，后续会精度提升到 0.001。

输入：

名称含义
input1第一个输入，支持 Float16\Float32\Float64\Int32 类型，可以为 Tensor 或者标量，两个输入不能同时为标量。
input2第二个输入，数据类型与第一个相同，可以为 Tensor 或者标量，两个输入不能同时为标量。

输出：

名称含义
output结果 Tensor，数据类型与输入一致。

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointMinimum(input1: Tensor, input2: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input0 = Tensor(Array<Float32>([1.0, 5.0, 3.0]), shape: Array<Int64>([3]))
    let input1 = Tensor(Array<Float32>([4.0, 2.0, 6.0]), shape: Array<Int64>([3]))
    let output = minimum(input0, input1)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Float32, value=
    [1.00000000e+00 2.00000000e+00 3.00000000e+00])

mirrorPad

public func mirrorPad(input: Tensor, paddings: Tensor, mode!: String = "REFLECT") : Tensor

通过 paddings 和 mode 对 input 进行扩充

输入：

名称含义
input输入 Tensor， 支持 Int32 和 Float32 类型, 只支持 2, 3, 4 维的输入
paddings填充的 Tensor， 只支持 Int64 类型。paddings 的值是一个矩阵，形状是（N，2)， N 表示输入 Tensor 的秩，对于第 D 维的 input， paddings[D，0]表示在第 D 维的 input 前扩充 paddings[D，0]个，paddings[D，1]表示在第 D 维的 input 后扩充 paddings[D，1]个。mode 为 REFLECT 时， paddings[D，0] 和 paddings[D，1]必须小于 input_shape[D], mode 为 SYMMETRIC 时， paddings[D，0] 和 paddings[D，1]必须小于等于 input_shape[D]
mode指定的填充方式，可选项:”REFLECT”， “SYMMETRIC” 默认”REFLECT”

输出

名称含义
output输出 Tensor。dtype 与输入 input 一致
如果输入 mode 是 “REFLECT”, 表示通过采用对称轴的方式复制填充。如果输入是[[1,2,3], [4,5,6], [7,8,9]], paddings 是 [[1,1], [2,2]], 输出是 [[6,5,4,5,6,5,4], [3,2,1,2,3,2,1], [6,5,4,5,6,5,4], [9,8,7,8,9,8,7], [6,5,4,5,6,5,4]].
如果输入 mode 是”SYMMETRIC”, 也表示通过对称轴的方式填充，但不包括对称轴，如果输入是[[1,2,3], [4,5,6], [7,8,9]], paddings 是 [[1,1], [2,2]],输出是 [[2,1,1,2,3,3,2], [2,1,1,2,3,3,2], [5,4,4,5,6,6,5], [8,7,7,8,9,9,8], [8,7,7,8,9,9,8]].

支持平台：Ascend, GPU, CPU

反向函数：

public func mirrorPadGrad(input: Tensor, paddings: Tensor, mode!: String = "REFLECT")

微分伴随函数:

public func adjointMirrorPad(input: Tensor, paddings: Tensor, mode!: String = "REFLECT")

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Int32>([1, 2, 3, 4, 5, 6, 7, 8, 9]), shape: Array<Int64>([3, 3]))
    let paddings = Tensor(Array<Int64>([1, 1, 1, 1]), shape: Array<Int64>([2, 2]))
    let output = mirrorPad(input, paddings)
    print(output)
    return 0
}

输出为：

Tensor(shape=[5, 5], dtype=Int32, value=
[[5 4 5 6 5]
 [2 1 2 3 2]
 [5 4 5 6 5]
 [8 7 8 9 8]
 [5 4 5 6 5]])

mod

public func mod(x: Int32, y: Tensor): Tensor
public func mod(x: Float32, y: Tensor): Tensor
public func mod(x: Tensor, y: Int32): Tensor
public func mod(x: Tensor, y: Float32): Tensor
public func mod(x: Tensor, y: Tensor): Tensor

函数 mod 实现 Mod 算子功能，逐元素计算第一个输入张量除以第二个输入张量的余数，输入 x 和 y 的 shape 需要满足 broadcasting 要求，如果输入是一个 Tensor 和一个标量，那么标量只能是一个常数。

【说明】：

  • 该操作输入不能为 0
  • 由于运行平台的体系架构不同，该操作结果在 NPU 和 CPU 上结果可能不同
  • 如果输入的形状表示为(D1,D2,Dn)，则 D1*D2*Dn<=1000000,n<=8。

输入：

名称含义
x输入 Tensor，数据类型为 number 或 Tensor。
y输入 Tensor，数据类型为 number 或 Tensor。

输出：

名称含义
output输出 Tensor，shape 跟 input1 和 input2 相同（或者跟两者 broadcasting 之后相同）。

支持平台：Ascend, GPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*
main(): Int64 {
    let x = parameter(Tensor(Array<Float32>([-189.5108184814, -213.9907989502, -129.7547760010, -256.0727233887, 53.2714538574]), shape: Array<Int64>([1, 5])), "x")
    let y = parameter(Tensor(Array<Float32>([-95.8178634644, 19.0195846558, 65.1648788452, -160.8015136719, -76.9250640869]), shape: Array<Int64>([1, 5])), "y")
    let output = mod(x, y)
    print(output)
    return 0
}

输出为：

Tensor(shape=[1, 5], dtype=Float32, value=
[[-9.36929550e+01 -4.77536774e+00 -6.45898972e+01 -9.52712097e+01 5.32714539e+01]])

mul

public func mul(input1: Tensor, input2: Tensor): Tensor
public func mul(input1: Float16, input2: Tensor): Tensor
public func mul(input1: Tensor, input2: Float16): Tensor
public func mul(input1: Float32, input2: Tensor): Tensor
public func mul(input1: Tensor, input2: Float32): Tensor
public func mul(input1: Float64, input2: Tensor): Tensor
public func mul(input1: Tensor, input2: Float64): Tensor
public func mul(input1: Int32, input2: Tensor): Tensor
public func mul(input1: Tensor, input2: Int32): Tensor

函数 mul 实现 Mul 算子功能，完成 Tensor 的 element-wise 相乘运算，输入 input1 和 input2 的 shape 需要满足 broadcasting 要求，如果输入是一个 Tensor 和一个标量，那么标量只能是一个常数。

输入：

名称含义
input0Tensor 或者 Number，GPU & CPU 支持 Float16\Float32\Float64\Int32 类型，Ascend 支持 Float16\Float32\Int32， dtype 或者类型要求与 input0 一致
input1Tensor 或者 Number，GPU & CPU 支持 Float16\Float32\Float64\Int32 类型，Ascend 支持 Float16\Float32\Int32， dtype 或者类型要求与 input0 一致

输出：

支持平台：Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let inputx = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([2, 2]))
    let inputy = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([2, 2]))
    let output = mul(inputx, inputy)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
    [[ 1.00000000e+00  4.00000000e+00]
     [ 9.00000000e+00  1.60000000e+01]])

multinomial

public func multinomial(x: Tensor, numSample: Int64, seed!: Int64 = 0, seed2!: Int64 = 0): Tensor

算子 multinomial 输出对输入张量的对应行进行采样的张量，采样的方式服从多项式概率分布。

参数列表：

名称含义
seed随机种子，必需为非负整数，Int64 类型，默认值为 0。
seed2随机种子，必需为非负整数，Int64 类型，默认值为 0。

输入：

名称含义
x输入 Tensor, 包含概率总和的输入张量，支持 Float32 类型，shape 要求 1D 或者 2D。
numSample要采样的样本数，支持 Int64 类型, 必须大于 0。

输出：

名称含义
output输出 Tensor，行与输入 x 的行一致，每行包含 numSample 个采样索引，Int32 类型。

支持平台：GPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let x = Tensor(Array<Float32>([0.0, 9.0, 4.0, 0.0]), shape: Array<Int64>([4]))
    let numSamples: Int64 = 2
    let output = multinomial(x, numSamples, seed: 1, seed2: 1)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2], dtype=Int32, value=
[1 2])

neg

public func neg(input: Tensor): Tensor

函数 neg 实现 Neg 算子功能，用于对输入 Tensor 进行 element-wise 的取负值。

输入：

名称含义
input正向计算的输入 Tensor，GPU & CPU 支持 Float16\Float32\Float64\Int32 类型; Ascend 支持 Float16\Float32\Int32 类型。

输出：

名称含义
output正向计算的结果 Tensor，与输入 Tensor 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointNeg(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input = Tensor(Array<Float32>([1.0, 5.0, 3.0]), shape: Array<Int64>([3]))
    let output = neg(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Float32, value=
    [-1.00000000e+00 -5.00000000e+00 -3.00000000e+00])

nmsWithMask

public func nmsWithMask(bbox: Tensor, iouThreshold!: Float32 = 0.5): Tensor

在计算机视觉领域中进行目标检测问题时，目标检测算法会产生多个边界框。按降序排序选择一些边界框(目前 Ascend 平台不支持降序排序)。使用得分最高的边界框计算其他边界框与当前边界框的重叠部分，并根据一定的阈值(IOU)删除该边界框。iou 计算公式为:

IOU=Area of OverlapArea of Union

参数列表：

名称含义
iouThreshold指定与 IOU 相关的重叠框的阈值，默认值：0.5。

输入：

名称含义
bbox张量的形状是 (N, 5) ，N 是输入边界框的数目。每个边界框包含 5 个值，前 4 个值是边界框的坐标（x0、y0、x1、y1），表示左上角和右下角的点，最后一个值是该边界框的分数, 支持 Float32 类型。

输出：

名称含义
output输出由三个张量组成的 tuple ，分别是 selected_box 、selected_idx 和 selected_mask 。 selected_box 形状为 (N,5) ，表示非最大抑制计算后的边界框列表；selected_idx 形状为 (N) ，表示有效输入边界框的索引列表；selected_mask 形状为 (N) ，表示有效输出边界框的掩码列表。

支持平台：Ascend, GPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let x = parameter(Tensor(Array<Float32>([1.5246382952, -61.6349449158, -30.6520633698, -30.2967433929, -283.8182678223]), shape: Array<Int64>([1, 5])), "x")
    let res = nmsWithMask(x, iouThreshold: 0.5)
    print(res)
    return 0
}

输出为：

Tensor(shape=[1, 5], dtype=Float32, value=
[[ 1.52463830e+00 -6.16349449e+01 -3.06520634e+01 -3.02967434e+01 -2.83818268e+02]])
Tensor(shape=[1], dtype=Int32, value= [0])
Tensor(shape=[1], dtype=Bool, value= [true])

notEqual

public func notEqual(input1: Tensor, input2: Tensor): Tensor
public func notEqual(input1: Tensor, input2: Float32): Tensor
public func notEqual(input1: Float32, input2: Tensor): Tensor
public func notEqual(input1: Tensor, input2: Float16): Tensor
public func notEqual(input1: Float16, input2: Tensor): Tensor
public func notEqual(input1: Int32, input2: Tensor): Tensor
public func notEqual(input1: Tensor, input2: Int32): Tensor
public func notEqual(input1: Float64, input2: Tensor): Tensor
public func notEqual(input1: Tensor, input2: Float64): Tensor

函数 notEqual 实现 NotEqual 算子功能，用于计算 x!=y 元素的 Bool 值。

输入：

名称含义
input1输入 Tensor，GPU & CPU 支持 Float16\Float32\Float64\Int32 类型的标量或者 Tensor, Ascend 支持 Float16\Float32\Int32 类型的标量或者 Tensor，两个输入必须为同一 dtype 类型，不能同时为标量。
input2输入 Tensor，GPU & CPU 支持 Float16\Float32\Float64\Int32 类型的标量或者 Tensor, Ascend 支持 Float16\Float32\Int32 类型的标量或者 Tensor，两个输入必须为同一 dtype 类型，不能同时为标量。

输出：

名称含义
outputTensor，与广播后的形状相同，数据类型为 Bool。

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointNotEqual(input1: Tensor, input2: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input1 = Tensor(Array<Float32>([3.0, 2.0, 1.0]), shape: Array<Int64>([3]))
    let input2 = Tensor(Array<Float32>([2.0, 2.0, 3.0]), shape: Array<Int64>([3]))
    let output = notEqual(input1, input2)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Bool, value=
[true false true])

oneHot

public func oneHot(indices: Tensor, depth: Int64, on_value: Float32, off_value: Float32, axis!: Int64 = -1): Tensor

函数 oneHot 实现 OneHot 算子功能，用于将输入转换成 oneHot 类型的 Tensor 输出。

输入：

名称含义
indicesindices 中的元素指示 on_value 的位置，不指示的地方都为 off_value。仅支持 Int32 数据类型的 Tensor。
depthdepth 表示输出 Tensor 的尺寸, Ascend 平台 必须大于等于 1。
on_valueon_value 一般为 1.0，如需标签平滑 (label smoothing)，可以设置为比 1 略小的值。
off_valueoff_value 一般为 0.0，如需标签平滑 (label smoothing)，可以设置为比 0 略大的值。
axis将指定维度转变为 onehot。假设 indices 的维度为 [n, c]，axis = -1 时，输出的 shape 为[n, c, depth]。axis = 0 时，输出的 shape 为[depth, n, c]。默认为-1。

输出：

名称含义
outputdtype 是 Float32 的 Tensor，shape 比输入 indices 的维度高一维，高的维度取决于 axis 的值。

支持平台：Ascend, GPU, CPU

微分伴随函数:

public func adjointOneHot(indices: Tensor, depth: Int64, on_value: Float32, off_value: Float32, axis!: Int64 = -1)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let data: Array<Int32> = Array<Int32>([0, 1, 2])
    let input = Tensor(data, shape: Array<Int64>([3]))
    let output = oneHot(input, 3, 1.0, 0.0)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3, 3], dtype=Float32, value=
    [[ 1.00000000e+00  0.00000000e+00  0.00000000e+00]
     [ 0.00000000e+00  1.00000000e+00  0.00000000e+00]
     [ 0.00000000e+00  0.00000000e+00  1.00000000e+00]])

ones

public func ones(input: Array<Int64>, dtype: Int32): Tensor
public func ones(input: Int64, dtype: Int32): Tensor

根据给定的 shape 和类型创建全 1 张量

输入：

名称含义
shape给定的 shape, 支持 Array 和 Number
dtype输出 Tensor 的类型, 支持 Int32, Int64, Float32, Float64, Bool 类型

输出：

名称含义
output输出， shape 为输入的 shape，dtype 为输入的 type

支持平台: Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let output = ones(Array<Int64>([2, 2]), FLOAT32)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[ 1.00000000e+00  1.00000000e+00]
 [ 1.00000000e+00  1.00000000e+00]])

onesLike

public func onesLike(input: Tensor): Tensor

函数 onesLike 用于根据输入 Tensor 的 shape 和 dtype 构造全 1 Tensor。

输入：

输出：

名称含义
output输出 Tensor，其 shape 和 dtype 跟 input 相同。

支持平台：Ascend, GPU, CPU

微分伴随函数:

public func adjointOnesLike(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]), shape: Array<Int64>([2, 3]))
    let output = onesLike(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 3], dtype=Float32, value=
[[ 1.00000000e+00  1.00000000e+00  1.00000000e+00]
 [ 1.00000000e+00  1.00000000e+00  1.00000000e+00]])

pad

public func pad(input: Tensor, paddings: Array<Array<Int64>>): Tensor

通过 paaddings 对 input 进行扩充

输入：

名称含义
input输入 Tensor, 支持 Int32 和 Float32 类型
paddingsArray<Array<Int64>>类型。paddings 的值是一个矩阵，形状是（N,2), N 表示输入 Tensor 的秩，对于第 D 维的 input, paddings[D,0]表示在第 D 维的 input 前扩充 paddings[D,0]个，paddings[D,1]表示在第 D 维的 input 后扩充 paddings[D,1]个，

输出：

名称含义
output输出 Tensor。dtype 与输入 input 一致。 dtype 为 Int32 类型填充 0， dtype 为 Float32 类型填充 0.0

支持平台：Ascend, GPU, CPU

微分伴随函数:

public func adjointPad(input: Tensor, paddings: Array<Array<Int64>>)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Int32>([1, 2, 3, 4, 5, 6]), shape: [2, 3])
    var paddings1 = Array<Int64>([1, 1])
    var paddings2 = Array<Int64>([1, 1])
    var paddings = Array<Array<Int64>>([paddings1, paddings2])
    let output = pad(input, paddings)
    print(output)
    return 0
}

输出为：

Tensor(shape=[4, 5], dtype=Int32, value=
[[ 0  0  0  0  0]
 [ 0  1  2  3  0]
 [ 0  4  5  6  0]
 [ 0  0  0  0  0]])

pow

public func pow(x: Tensor, y: Float16): Tensor
public func pow(x: Tensor, y: Float32): Tensor
public func pow(x: Tensor, y: Float64): Tensor
public func pow(x: Tensor, y: Int32): Tensor
public func pow(x: Tensor, y: Int64): Tensor
public func pow(x: Float16, y: Tensor): Tensor
public func pow(x: Float32, y: Tensor): Tensor
public func pow(x: Float64, y: Tensor): Tensor
public func pow(x: Int32, y: Tensor): Tensor
public func pow(x: Int64, y: Tensor): Tensor
public func pow(x: Tensor, y: Tensor): Tensor

函数 pow 实现 Pow 算子功能，用于计算以 x 为底，y 为指数运算。

输入：

名称含义
x正向计算的输入 Tensor 或 标量, GPU & CPU 支持 Float16\Float32\Float64\Int32\Int64; 反向仅支持 Float16\Float32\Float64。Ascend 支持 Float16\Float32\Int32; 反向仅支持 Float16\Float32。
y正向计算的输入 Tensor 或 标量，与 x 具有相同的数据类型。

注意：x, y 的 shape 需要买满足可广播的要求；且 x, y 只能有一个为标量。

输出：

名称含义
output正向计算的结果 Tensor，与输入 Tensor 具有相同的数据类型。

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointPow(x: Tensor, y: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let x = Tensor(Array<Float32>([9.0, 16.0]), shape: Array<Int64>([2]))
    let y = Tensor(Array<Float32>([2.0, 1.0]), shape: Array<Int64>([2]))
    let output = pow(x, y)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2], dtype=Float32, value=
    [8.10000000e+01 1.60000000e+01])

prelu

public func prelu(input: Tensor, weight: Tensor): Tensor

函数 prelu 实现 PReLU 算子功能，实现 PReLU 函数。

prelu(xi)=max(0,xi)+min(0,w∗xi)

输入：

名称含义
input输入 Tensor，dtype 为 Float16\Float32，shpae 为任意数量的附加维度。(N,C,*)。Ascend 不支持 0-D 或 1-D Tensor
weight第二个输入 Tensor，dtype 为 Float32。 只有两个 shape 是合法的，1 或 input_x 的通道数。 通道指是 input 的第二个维度。 当 input 为 0-D 或 1-D 张量时，通道数为 1。

输出：

名称含义
output输出 Tensor，shape 与 dtype 和 input 一致。

支持平台：Ascend, GPU

反向函数：

public func preluGrad(gradOut: Tensor, input: Tensor, weight: Tensor): Tensor

微分伴随函数:

public func adjointPrelu(input: Tensor, weight: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input = parameter(Tensor(Array<Float32>([-6.0000000000, -5.0000000000, -4.0000000000, -3.0000000000, -2.0000000000, -1.0000000000, 0.0000000000, 1.0000000000, 2.0000000000, 3.0000000000, 4.0000000000, 5.0000000000]), shape: Array<Int64>([2, 3, 2])), "x")
    let weight = parameter(Tensor(Array<Float32>([0.1000000015, 0.6000000238, -0.3000000119]), shape: Array<Int64>([3])), "y")
    let output = prelu(input, weight)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 3, 2], dtype=Float32, value=
[[[-6.00000024e-01 -5.00000000e-01]
  [-2.40000010e+00 -1.80000007e+00]
  [ 6.00000024e-01  3.00000012e-01]]
 [[ 0.00000000e+00  1.00000000e+00]
  [ 2.00000000e+00  3.00000000e+00]
  [ 4.00000000e+00  5.00000000e+00]]])

randomCategorical

public func randomCategorical(logits: Tensor, numSample: Int64, seed!: Int64 = 0, dtype!: Int32 = INT64): Tensor

算子 randomCategorical 输出对输入张量的对应行进行采样的张量，采样的方式服从分类分布。

参数列表：

名称含义
dtype用于指定输出 Tensor 的数据类型，支持 INT64 和 INT32，默认值为 INT64。

输入：

名称含义
logits输入 Tensor, 包含概率总和的输入张量，GPU 支持 Float16\Float32\Float64, Ascend 支持 Float16\Float32 shape 要求 2D。
numSample要采样的样本数，支持 Int64 类型, 必须是正整数。
seed随机种子，必需为非负整数，Int64 类型，默认值为 0。

输出：

名称含义
output输出 Tensor，行与输入 x 的行一致，每行包含 numSample 个采样索引，由输入 dtype 指定数据类型。

支持平台：Ascend, GPU

代码示例：

from CangjieTB import ops.*
from CangjieTB import common.*

main(): Int64 {
    let x = Tensor(Array<Float32>([0.0, 9.0, 4.0, 0.0]), shape: Array<Int64>([2, 2]))
    let numSamples: Int64 = 2
    let res = randomCategorical(x, numSamples, seed: Int64(1), dtype: INT32)
    print(res)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Int32, value=
[[ 1  1]
 [ 0  0]])

randomChoiceWithMask

public func randomChoiceWithMask(inputX: Tensor, count!: Int64 = 256, seed!: Int64 = 0, seed2!: Int64 = 0): (Tensor, Tensor)

randomChoiceWithMask 输出对输入张量的对应行进行采样的索引张量以及一个掩码张量。

参数列表：

名称含义
count要采样的样本数，采样数>0，支持 Int64 类型，默认值为 256。
seed随机种子，必需为非负整数，Int64 类型，默认值为 0。
seed2随机种子，必需为非负整数，Int64 类型，默认值为 0。

输入：

名称含义
inputX输入 Tensor, shape 必须>=1D，并且<=5D，支持 Bool 类型。

输出：

名称含义
index输出 Tensor，shape 为 2D，行与输入 x 的 dims 一致，每行包含 count 个采样索引，Int32 类型。
mask输出 Tensor，shape 为 1D，对应 count 个采样索引的掩码，Bool 类型。

支持平台：Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x = Tensor(Array<Bool>([true, true, false, false]), shape: Array<Int64>([2, 2]))
    let count: Int64 = 2
    let seed: Int64 = 1
    let seed2: Int64 = 3
    let (res0, res1) = randomChoiceWithMask(x, count: count, seed: seed, seed2: seed2)
    print(res0)
    print(res1)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Int32, value=
[[ 0  1]
 [ 0  0]])
Tensor(shape=[2], dtype=Bool, value=
[true true])

rank

public func rank(input: Tensor): Int64

返回给定 Tensor 的秩

返回一个 0-D Int64 类型数字来表示输入 Tensor 的 rank，

输入：

输出：

名称含义
outputInt64 类型，表示输入 Tensor 的秩

支持平台: Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = onesTensor(Array<Int64>([1, 2, 3, 4, 5]))
    let output = rank(input)
    print("${output}\n")
    return 0
}

输出为：

5

randperm

public func randperm(n: Tensor, maxLength!: Int32 = 1, pad!: Int32 = -1, dtype!: Int32 = INT32): Tensor

根据 n(Tensor 类型)指定的元素个数 N，构建 N 个从 0 到 N-1 的不重复的随机样本，如果给定的 maxLength > N,最后 maxLength-N 个元素使用 pad 代替

输入：

名称含义
nshape 为(1,)的张量，其唯一的值必须在[0, max_length]之间，支持 Int32 类型
maxLength期望获得向量的长度，该值必须大于 0，默认值：1
pad填充值，默认值：-1
dtype返回 Tensor 的类型，可选项：Int32, Int64, UInt32 默认值：Int32

【注意】： UInt32 取值范围为[0,4294967295], 当 dtype 为 UInt32, pad 输入在取值范围外时, pad 被 UInt32 最大值(4294967295)代替。

支持平台: Ascend, GPU

输出：

名称含义
output输出， shape 为(maxLength,), dtype 为输入 dtype 的张量

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let n = Tensor(Array<Int32>([1]), shape: Array<Int64>([1]))
    let output = randperm(n, maxLength: 5)
    print(output)
    return 0
}

输出为：

Tensor(shape=[5], dtype=Int32, value=
[0 -1 -1 -1 -1])

realDiv

public func realDiv(input1: Tensor, input2: Tensor): Tensor
public func realDiv(input1: Tensor, input2: Float16): Tensor
public func realDiv(input1: Float16, input2: Tensor): Tensor
public func realDiv(input1: Tensor, input2: Float32): Tensor
public func realDiv(input1: Float32, input2: Tensor): Tensor
public func realDiv(input1: Tensor, input2: Float64): Tensor
public func realDiv(input1: Float64, input2: Tensor): Tensor
public func realDiv(input1: Tensor, input2: Int32): Tensor
public func realDiv(input1: Int32, input2: Tensor): Tensor

函数 realDiv 实现 RealDiv 算子功能，用于计算第一个输入与第二个输入逐个元素相除，数据类型可以是浮点类型或整型。输入可以是 Tensor 或者标量，但不能同时为标量。当输入为两个 Tensor 时，其 shape 必须可以进行 broadcast。两个输入的数据类型需一致。

输入：

名称含义
input1第一个输入。GPU 支持 Float16\Float32\Float64\Int32 类型的 number 或 tensor; Ascend 支持 Float16\Float32 类型的 number 或 tensor。
input2第二个输入。GPU 支持 Float16\Float32\Float64\Int32 类型的 number 或 tensor; Ascend 支持 Float16\Float32 类型的 number 或 tensor。

输出：

名称含义
output相除的 Tensor，数据类型和形状与输入相同。

支持平台：Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let x = Tensor(Array<Float32>([9.0, 16.0]), shape: Array<Int64>([2]))
    let y = Tensor(Array<Float32>([2.0, 1.0]), shape: Array<Int64>([2]))
    let output = realDiv(x, y)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2], dtype=Float32, value=
    [4.50000000e+00 1.60000000e+01])

reduceAll

public func reduceAll(input: Tensor, keepDims!: Bool = false): Tensor
public func reduceAll(input: Tensor, axis: Int64, keepDims!: Bool = false): Tensor
public func reduceAll(input: Tensor, axis: Array<Int64>, keepDims!: Bool = false): Tensor

函数 ReduceAll 实现 ReduceAll 算子功能，用于将指定维度上的元素根据 logical AND 的规则进行降维操作。

输入：

名称含义
input需要降维的 tensor，只接受 Bool 类型，输入维度要求小于 8。
axis需要降维的维度，可以不输入，输入 Int64 类型或输入 Int64 类型数组。如果不输入表示对所有维度取 logicalAND。必须在 [-rank(input)，rank(input)) 范围内。
keepDims降维后，维度是否保留为 1，true 表示保留，false 表示不保留，默认 false。

输出：

名称含义
output降维后的 Tensor，与 input dtype 相同。

【注意】：

  • 如果 axis 是空，且 keepDims 为 false，则输出为 0-D Tensor，表示输入 Tensor 中所有元素取 logical AND 的结果。
  • 如果 axis 是整型，设置为 2，而 keepDims 为 false，则输出的形状为（x1，x3，…，xR）。
  • 如果 axis 是数组，设置为 [2，3]，而 keepDims 为 false，则输出的形状为（x1，x4，…，xR）。

支持平台：Ascend, GPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input = Tensor(Array<Bool>([true, true, true, false, false]), shape: Array<Int64>([5]))
    let output = reduceAll(input, 0)
    print(output)
    return 0
}

输出为：

Tensor(shape=[], dtype=Bool, value= false)

reduceAny

public func reduceAny(input: Tensor, keepDims!: Bool = false): Tensor
public func reduceAny(input: Tensor, axis: Int64, keepDims!: Bool = false): Tensor
public func reduceAny(input: Tensor, axis: Array<Int64>, keepDims!: Bool = false): Tensor

函数 ReduceAny 实现 ReduceAny 算子功能，用于将指定维度上的元素根据 logical OR 的规则进行降维操作。

输入：

名称含义
input需要降维的 tensor，只接受 Bool 类型，输入维度要求小于 8。
axis需要降维的维度，可以不输入，输入 Int64 类型或输入 Int64 类型数组。如果不输入表示对所有维度取 logical OR。必须在 [-rank(input)，rank(input)) 范围内。
keepDims降维后，维度是否保留为 1，true 表示保留，false 表示不保留，默认 false。

输出：

名称含义
output降维后的 Tensor，与 input dtype 相同。

【注意】：

  • 如果 axis 是空，且 keepDims 为 false，则输出为 0-D Tensor，表示输入 Tensor 中所有元素取 logical OR 的结果。
  • 如果 axis 是整型，设置为 2，而 keepDims 为 false，则输出的形状为（x1，x3，…，xR）。
  • 如果 axis 是数组，设置为 [2，3]，而 keepDims 为 false，则输出的形状为（x1，x4，…，xR）。

支持平台: Ascend, GPU

微分伴随函数：

public func adjointReduceAny(input: Tensor, axis: Array<Int64>, keepDims!: Bool = false)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input = Tensor(Array<Bool>([true, true, true, false, false]), shape: Array<Int64>([5]))
    let output = reduceAny(input, 0)
    print(output)
    return 0
}

输出为：

Tensor(shape=[], dtype=Bool, value= true)

reduceMax

public func reduceMax(input: Tensor, keepDims!: Bool = false): Tensor
public func reduceMax(input: Tensor, axis: Int64, keepDims!: Bool = false): Tensor
public func reduceMax(input: Tensor, axis: Array<Int64>, keepDims!: Bool = false): Tensor

函数 ReduceMax 实现 ReduceMax 算子功能，用于计算输入 Tensor 在指定维度上的最大值。

输入：

名称含义
input需要降维的 tensor，GPU & CPU 接受 Float16\Float32\Float64 类型; Ascend 接受 Float16\Float32 类型，输入维度要求小于 8。
axis需要降维的维度，可以不输入，输入 Int64 类型或输入 Int64 类型数组。如果不输入表示对所有维度取最大值。必须在 [-rank(input)，rank(input)) 范围内。
keepDims降维后，维度是否保留为 1，true 表示保留，false 表示不保留，默认 false。

输出：

名称含义
output降维后的 Tensor，与 input dtype 相同。

支持平台：Ascend, GPU, CPU

【注意】：

  • 如果 axis 是空，且 keepDims 为 false，则输出为 0-D Tensor，表示输入 Tensor 中所有元素的最大值。
  • 如果 axis 是整型，设置为 2，而 keepDims 为 false，则输出的形状为（x1，x3，…，xR）。
  • 如果 axis 是数组，设置为 [2，3]，而 keepDims 为 false，则输出的形状为（x1，x4，…，xR）。

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]), shape: Array<Int64>([2, 4]))
    let output = reduceMax(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[], dtype=Float32, value= 8.00000000e+00)

reduceMean

public func reduceMean(input: Tensor, keepDims!: Bool = false): Tensor
public func reduceMean(input: Tensor, axis: Int64, keepDims!: Bool = false): Tensor
public func reduceMean(input: Tensor, axis: Array<Int64>, keepDims!: Bool = false): Tensor

函数 reduceMean 实现 ReduceMean 算子功能，用于在指定维度上对 Tensor 进行取平均运算。

参数列表：

名称含义
input需要降维的 Tensor, 接受 Float16\Float32 类型，输入维度要求小于 8。
axis需要降维的维度，可以不输入，输入 Int64 类型或输入 Int64 类型数组，如果不输入表示对所有维度取平均。必须在 [-rank(input)，rank(input)) 范围内。
keepDims降维后，维度是否保留为 1，true 表示保留，false 表示不保留，默认 false。

输出：

名称含义
output降维后的 Tensor，与 input dtype 相同。

支持平台：Ascend, GPU, CPU

【注意】：

  • 如果 axis 是空，且 keepDims 为 false，则输出为 0-D Tensor，表示输入 Tensor 中所有元素的均值。
  • 如果 axis 是整型，设置为 2，而 keepDims 为 false，则输出的形状为（x1，x3，…，xR）。
  • 如果 axis 是数组，设置为 [2，3]，而 keepDims 为 false，则输出的形状为（x1，x4，…，xR）。

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]), shape: Array<Int64>([2, 4]))
    let output = reduceMean(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[], dtype=Float32, value= 4.50000000e+00)

reduceMin

public func reduceMin(input: Tensor, keepDims!: Bool = false): Tensor
public func reduceMin(input: Tensor, axis: Int64, keepDims!: Bool = false): Tensor
public func reduceMin(input: Tensor, axis: Array<Int64>, keepDims!: Bool = false): Tensor

函数 ReduceMin 实现 ReduceMin 算子功能，用于计算输入 Tensor 在指定维度上的最小值。

输入：

名称含义
input输入 Tensor，接受 Float16\Float32 类型，输入维度要求小于 8。
axis需要降维的维度，可以不输入，输入 Int64 类型或输入 Int64 类型数组。如果不输入表示对所有维度取最小值。必须在 [-rank(input)，rank(input)) 范围内。
keepDims降维后，维度是否保留为 1，true 表示保留，false 表示不保留，默认 false。

输出：

名称含义
output输出的 Tensor，与 input dtype 相同。

【注意】：

  • 如果 axis 是空，且 keepDims 为 false，则输出为 0-D Tensor，表示输入 Tensor 中所有元素的最小值。
  • 如果 axis 是整型，设置为 2，而 keepDims 为 false，则输出的形状为（x1, x3, …, xR）。
  • 如果 axis 是数组，设置为 [2, 3]，而 keepDims 为 false，则输出的形状为（x1, x4, …, xR）。

支持平台：Ascend, GPU

微分伴随函数：

public func adjointReduceMin(input: Tensor, axis: Array<Int64>, keepDims!: Bool = false)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let x = Tensor(Array<Float32>([-0.9895743132, -2.3158619404, -1.8102313280, 0.3145818710, -2.8364603519, -0.1768671125]), shape: Array<Int64>([2, 3, 1, 1]))
    let output = reduceMin(x, 1, keepDims: true)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 1, 1, 1], dtype=Float32, value=
[[[[-2.31586194e+00]]]
 [[[-2.83646035e+00]]]])

reduceProd

public func reduceProd(input: Tensor, keepDims!: Bool = false): Tensor
public func reduceProd(input: Tensor, axis: Int64, keepDims!: Bool = false): Tensor
public func reduceProd(input: Tensor, axis: Array<Int64>, keepDims!: Bool = false): Tensor

函数 reduceProd 实现 ReduceProd 算子功能，用于计算输入 Tensor 在指定维度上的乘积。

输入：

名称含义
input输入 Tensor，接受 Float16\Float32 类型，输入维度要求小于 8。
axis需要降维的维度，可以不输入，输入 Int64 类型或输入 Int64 类型数组。如果不输入表示对所有维度取最小值。必须在 [-rank(input)，rank(input)) 范围内。
keepDims降维后，维度是否保留为 1，true 表示保留，false 表示不保留，默认 false。

输出：

名称含义
output输出的 Tensor，与 input dtype 相同。

【注意】：

  • 如果 axis 是空，且 keepDims 为 false，则输出为 0-D Tensor，表示输入 Tensor 中所有元素的乘积。
  • 如果 axis 是整型，设置为 2，而 keepDims 为 false，则输出的形状为（x1, x3, …, xR）。
  • 如果 axis 是数组，设置为 [2, 3]，而 keepDims 为 false，则输出的形状为（x1, x4, …, xR）。

支持平台：Ascend, GPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let x = parameter(Tensor(Array<Float32>([-81.2111434937, -117.9023818970, 209.5803375244, -161.2210693359]), shape: Array<Int64>([2, 2])), "x")
    let output = reduceProd(x, 1, keepDims: true)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 1], dtype=Float32, value=
[[9.57498730e+03]
 [-3.37887656e+04]])

reduceScatter

public func reduceScatter(input: Tensor, op!: ReduceType = ReduceType.SUM, group!: String = "nccl_world_group"): Tensor

按照输入的 group 方式减少和发散 Tensor

输入：

名称含义
input输入，支持 Float32 和 Int32 类型
op规约类型，支持四种输入，分别是 ReduceType.SUM、ReduceType.MAX、ReduceType.MIN, ReduceType.PROD。默认为 ReduceType.SUM。 ReduceScatter 在微分时只支持 ReduceType.SUM 类型
group通信组类型，GPU 设备支持输入 “nccl_world_group”。

输出：

支持平台：Ascend, GPU

微分伴随函数：

public func adjointReduceScatter(input: Tensor, op!: ReduceType = ReduceType.SUM, group!: String = "nccl_world_group")

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*
from CangjieTB import context.*

main(): Int64
{
    g_context.setBackend("nccl")
    let x = onesTensor(Array<Int64>([3, 3]))
    let output = reduceScatter(x, op: ReduceType.SUM, group: "nccl_world_group")
    print(output)
    return 0
}

输出为(单 gpu):

Tensor(shape=[3, 3], dtype=Float32, value=
[[ 1.00000000e+00  1.00000000e+00  1.00000000e+00]
 [ 1.00000000e+00  1.00000000e+00  1.00000000e+00]
 [ 1.00000000e+00  1.00000000e+00  1.00000000e+00]])

reduceSum

public func reduceSum(input: Tensor, keepDims!: Bool = false): Tensor
public func reduceSum(input: Tensor, axis: Int64, keepDims!: Bool = false): Tensor
public func reduceSum(input: Tensor, axis: Array<Int64>, keepDims!: Bool = false): Tensor

函数 reduceSum 实现 ReduceSum 算子功能，用于在指定维度上对 Tensor 进行求和运算。

参数列表：

名称含义
input需要降维的 Tensor，GPU & CPU 接受 Float16\Float32\Float64 类型; Ascend 接受 Float16\Float32 类型。输入维度要求小于 8。
axis需要降维的维度，可以不输入，输入 Int64 类型或输入 Int64 类型数组，如果不输入表示对所有维度取和。必须在 [-rank(input)，rank(input)) 范围内。
keepDims降维后，维度是否保留为 1，true 表示保留，false 表示不保留，默认 false。

输出：

名称含义
output降维后的 Tensor，与 input dtype 相同。

支持平台：Ascend, GPU, CPU

【注意】：

  • 如果 axis 是空，且 keepDims 为 false，则输出为 0-D Tensor，表示输入 Tensor 中所有元素的和。
  • 如果 axis 是整型，设置为 2，而 keepDims 为 false，则输出的形状为（x1，x3，…，xR）。
  • 如果 axis 是数组，设置为 [2，3]，而 keepDims 为 false，则输出的形状为（x1，x4，…，xR）。

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]), shape: Array<Int64>([2, 4]))
    let output = reduceSum(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[], dtype=Float32, value= 3.60000000e+01)

relu

public func relu(input: Tensor): Tensor

函数 relu 实现 ReLU 激活函数功能，即实现 max(0, input) 运算，并返回计算结果。

参数列表：

名称含义
input接受 Float16\Float32 类型的 Tensor 输入。

输出：

名称含义
outputshape 与 input 一致的 Tensor。

支持平台：Ascend, GPU, CPU

反向函数：

public func reluGrad(gradOut: Tensor, out: Tensor): Tensor

微分伴随函数:

public func adjointRelu(input: Tensor)

二阶伴随函数：

public func adjointReluGrad(gradOut: Tensor, out: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, -4.0, 5.0, -6.0, 7.0, -8.0]), shape: Array<Int64>([2, 4]))
    let output = relu(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 4], dtype=Float32, value=
    [[ 1.00000000e+00  2.00000000e+00  3.00000000e+00  0.00000000e+00]
     [ 5.00000000e+00  0.00000000e+00  7.00000000e+00  0.00000000e+00]])

reshape

public func reshape(input: Tensor, shape: Array<Int64>): Tensor

函数 reshape 实现 Reshape 算子功能，基于给定的 shape，使用相同的值重新排布输入张量。

参数列表：

名称含义
input输入 Tensor，shape 是

x1,x2,…,xR

， dtype 支持 Float32\Float64\Int32\Bool, Ascend 支持 Float32\Int32\Bool。 | | shape | 调整后的 shape

y1,y2,…,yS

, 只能是常量。 如果它有几个 – 1；或者如果其元素的乘积小于或等于 0，或者不能被输入张量形状的乘积整除，或者它与输入的数组大小不匹配， 则报错。 |

输出：

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]), shape: Array<Int64>([2, 4]))
    let output = reshape(input, Array<Int64>([2, 2, 2]))
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 2, 2], dtype=Float32, value=
    [[[ 1.00000000e+00  2.00000000e+00]
      [ 3.00000000e+00  4.00000000e+00]]
     [[ 5.00000000e+00  6.00000000e+00]
      [ 7.00000000e+00  8.00000000e+00]]])

resizeNearestNeighbor

public func resizeNearestNeighbor(input: Tensor, size: Array<Int64>, alignCorners!: Bool = false): Tensor

根据最近邻算法调整输入 Tensor 大小

根据最近邻算法调整输入 Tensor 到指定的 size 大小。最近邻算法仅考虑最近的 point 的值，完全忽略其它的邻居 point，并生产一个分段的 interpolant。

输入：

名称含义
input输入 Tensor, shape 分别代表(N,C,H,W)(N: batch; C: channel; H: height; W: width),GPU 支持 Float32, Int32, Ascend 支持 Float32
alignCornersoutput 是否与 input 的角落元素对齐, 默认值:false （alignCorners 为 true 和 false 的具体差别可参考代码示例 1，代码示例 2）
size目标调整的大小，必须为 2 维数组

输出：

名称含义
output输出 Tensor, 类型与 input 相同，shape 为(N, C, size[0], size[1])

支持平台: Ascend, GPU, CPU

反向函数:

public func resizeNearestNeighborGrad(gradOut: Tensor, size: Array<Int64>, alignCorners!: Bool = false): Tensor

微分伴随函数:

public func adjointResizeNearestNeighbor(input: Tensor, size: Array<Int64>, alignCorners!: Bool = false)

代码示例：

代码示例 1：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Int32>([1, 2, 3, 4, 5, 6, 7, 8, 9]), shape: [1, 1, 3, 3])
    let output = resizeNearestNeighbor(input, Array<Int64>([2, 2]))
    print(output)
    return 0
}

输出为：

Tensor(shape=[1, 1, 2, 2], dtype=Int32, value=
[[[[ 1  2]
   [ 4  5]]]])

代码示例 2：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x = parameter(Tensor(Array<Int32>([1, 2, 3, 4, 5, 6, 7, 8, 9]), shape: Array<Int64>([1, 1, 3, 3])), "x")
    let output = resizeNearestNeighbor(x, Array<Int64>([2, 2]), alignCorners: true)
    print(output)
    return 0
}

输出为：

Tensor(shape=[1, 1, 2, 2], dtype=Int32, value=
[[[[ 1  3]
   [ 7  9]]]])

reverseSequence

public func reverseSequence(input: Tensor, seqLengths: Tensor, seqDim: Int64, batchDim!: Int64 = 0): Tensor

反转可变长度的切片

输入：

名称含义
inputTensor,被反转的 Tensor, 支持所有类型 Tensor
seqLengthsTensor, 必须是 Int32 或者 Int64 类型的一维向量。 最大值必须小于等于 input.shape[seqDim]
seqDim执行反转的维度，取值范围在[0, len(input))
batchDiminput 执行切片的维度。取值范围在[0, len(input)), 默认值：0

输出：

名称含义
output输出 Tensor, 与 input 的 shape 和 dtype 相同

支持平台: Ascend, GPU, CPU

微分伴随函数:

public func adjointReverseSequence(input: Tensor, seqLengths: Tensor, seqDim: Int64, batchDim!: Int64 = 0)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Int32>([1, 2, 3, 4, 5, 6, 7, 8, 9]), shape: [3, 3])
    let seqLengths = Tensor(Array<Int32>([1, 2, 3]), shape: [3])
    let output = reverseSequence(input, seqLengths, 1)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3, 3], dtype=Int32, value=
[[ 1  2  3]
 [ 5  4  6]
 [ 9  8  7]])

reciprocal

public func reciprocal(input: Tensor): Tensor

函数 reciprocal 实现 Reciprocal 算子功能，用于对输入 Tensor 进行 element-wise 取倒数计算。

输入：

名称含义
input正向计算的输入 Tensor，支持 Float16\Float32 类型。

输出：

名称含义
output正向计算的结果 Tensor，与输入 Tensor 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointReciprocal(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]), shape: Array<Int64>([2, 4]))
    let output = reciprocal(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 4], dtype=Float32, value=
    [[ 1.00000000e+00  5.00000000e-01  3.33333343e-01  2.50000000e-01]
     [ 2.00000003e-01  1.66666672e-01  1.42857149e-01  1.25000000e-01]])

round

public func round(input: Tensor): Tensor

函数 round 实现 Round 算子功能，用于对输入 Tensor 进行 element-wise 的取整计算，取整规则为四舍五入。

输入：

名称含义
input输入 Tensor，支持 Int32 和 Float32 类型。

输出：

名称含义
output结果 Tensor，与输入 Tensor 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU

微分伴随函数：

public func adjointRound(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*
main(): Int64 {
    let input = Tensor(Array<Float32>([-0.5889578462, 0.6572893858, 0.9656294584, 0.8302891254, -0.4508400559, 0.1614982486]), shape: Array<Int64>([3, 2]))
    let output = round(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3, 2], dtype=Float32, value=
[[-1.00000000e+00 1.00000000e+00]
 [1.00000000e+00 1.00000000e+00]
 [-0.00000000e+00 0.00000000e+00]])

rsqrt

public func rsqrt(input: Tensor): Tensor

函数 rsqrt 实现 Rsqrt 算子功能，用于对输入 Tensor 进行 element-wise 的开方，然后取倒数。

输入：

名称含义
input正向计算的输入 Tensor，每一个元素必须 >=0，支持 Float16\Float32 类型。

输出：

名称含义
output正向计算的结果 Tensor，与输入 Tensor 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU

反向函数：

public func rsqrtGrad(out: Tensor, gradOut: Tensor): Tensor

微分伴随函数：

public func adjointRsqrt(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]), shape: Array<Int64>([2, 4]))
    let output = rsqrt(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 4], dtype=Float32, value=
    [[ 1.00000000e+00  7.07106709e-01  5.77350259e-01  5.00000000e-01]
     [ 4.47213560e-01  4.08248276e-01  3.77964467e-01  3.53553355e-01]])

sameTypeShape

public func sameTypeShape(input0: Tensor, input1: Tensor): Tensor

检查输入 Tensor 的 dtype 与 shape 是否相同

输入：

名称含义
input0第一个输入 Tensor
input1第二个输入 Tensor，与第一个输入的 dtype 和 shape 相同

输出：

名称含义
output输出 Tensor, 与 input0 的类型和形状相同

支持平台: Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input0 = Tensor(Array<Float32>([10.0, 9.0, 8.0, 7.0]), shape: Array<Int64>([2, 2]))
    let input1 = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([2, 2]))
    let output = sameTypeShape(input0, input1)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[ 1.00000000e+01  9.00000000e+00]
 [ 8.00000000e+00  7.00000000e+00]])

scatterAdd

public func scatterAdd(input: Tensor, indices: Tensor, updates: Tensor, useLocking!: Bool = false): Tensor

通过加法运算更新输入 Tensor

使用给定值通过加法操作更新 Tensor 值以及输入索引。每一次运算结束后 input

input[indices[i,…,j],:]+=updates[i,…,j,:]

Note:

这是一个就地更新运算符。因此，input 将在操作完成后更新。

输入：

名称含义
input将要被更新的 Tensor，必须是 parameter，支持 Float32\Int32 类型, 不支持 scalar Tensor
indicesTensor, 指定要进行计算元素的索引， 必须是 Int32 类型
updates与 input 进行相加操作的 Tensor, updates_shape = indices_shape + input_shape[1:], 类型与 input 相同
useLocking是否使用锁保护运行任务。默认值：false

输出：

名称含义
output输出 Tensor, 更新后的 input，与 input 的 shape 和 dtype 相同

支持平台: Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = parameter(zerosTensor(Array<Int64>([2, 3])), "input")
    let indices = Tensor(Array<Int32>([0, 1, 1, 1]), shape: Array<Int64>([2, 2]))
    let updates = Tensor(Array<Float32>([1.0, 1.0, 1.0, 3.0, 3.0, 3.0, 7.0, 7.0, 7.0, 9.0, 9.0, 9.0]), shape: Array<Int64>([2, 2, 3]))
    let output = scatterAdd(input, indices, updates)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 3], dtype=Float32, value=
[[ 1.00000000e+00  1.00000000e+00  1.00000000e+00]
 [ 1.90000000e+01  1.90000000e+01  1.90000000e+01]])

scatterSub

func scatterSub(input: Tensor, indices: Tensor, updates: Tensor, useLocking!: Bool = false): Tensor

通过减法运算更新输入 Tensor

使用给定值通过减法操作更新 Tensor 值以及输入索引。每一次运算结束后 input

input[indices[i,…,j],:]−=updates[i,…,j,:]

Note:

这是一个就地更新运算符。因此，input 将在操作完成后更新。

输入：

名称含义
input将要被更新的 Tensor，必须是 parameter，支持 Float32\Int32 类型
indicesTensor, 指定要进行计算元素的索引， 必须是 Int32 类型
updates与 input 进行相减操作的 Tensor, updates_shape = indices_shape + input_shape[1:], 类型与 input 相同
useLocking是否使用锁保护运行任务。默认值：false

输出：

名称含义
output输出 Tensor, 更新后的 input，与 input 的 shape 和 dtype 相同

支持平台: GPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = parameter(Tensor(Array<Float32>([0.0000000000, 0.0000000000, 0.0000000000, 1.0000000000, 1.0000000000, 1.0000000000]), shape: Array<Int64>([2, 3])), "input")
    let indices = Tensor(Array<Int32>([0, 1]), shape: Array<Int64>([1, 2]))
    let updates = Tensor(Array<Float32>([1.0000000000, 1.0000000000, 1.0000000000, 2.0000000000, 2.0000000000, 2.0000000000]), shape: Array<Int64>([1, 2, 3]))
    let output = scatterSub(input, indices, updates)
    print("input:\n")
    print(input)
    print("\noutput:\n")
    print(output)
    return 0
}

输出为：

input:
Tensor(shape=[2, 3], dtype=Float32, value=
[[-1.00000000e+00 -1.00000000e+00 -1.00000000e+00]
 [-1.00000000e+00 -1.00000000e+00 -1.00000000e+00]])

output:
Tensor(shape=[2, 3], dtype=Float32, value=
[[-1.00000000e+00 -1.00000000e+00 -1.00000000e+00]
 [-1.00000000e+00 -1.00000000e+00 -1.00000000e+00]])

scatterUpdate

public func scatterUpdate(input: Tensor, indices: Tensor, updates: Tensor, useLocking!: Bool = true): Tensor

使用给定值以及输入索引更新输入 Tensor 值。

input[indices[i,…,j],:]=updates[i,…,j,:]

Note:

这是一个原址更新运算符。因此，input 将在操作完成后更新。

输入：

名称含义
input将要被更新的 Tensor，必须是 Parameter；GPU 平台支持 Float16，Float32，Int32, Int64 类型, Ascend 平台支持 Float16，Float32 类型
indicesTensor, 指定要进行计算元素的索引， 必须是 Int32 类型；注意，如果在索引中有重复项，则更新顺序未定义。
updates与 input 进行更新操作的 Tensor, updates_shape = indices_shape + input_shape[1:], 类型与 input 相同
useLocking是否使用锁保护运行任务。默认值：true

输出：

名称含义
output输出 Tensor, 更新后的 input，与 input 的 shape 和 dtype 相同

支持平台: GPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input_x = parameter(Tensor(Array<Float32>([-0.1000000015, 0.3000000119, 3.5999999046, 0.4000000060, 0.5000000000, -3.2000000477]), shape: [2, 3]), "input_x")
    let indices = Tensor(Array<Int32>([0, 1]), shape: [2])
    let updates = Tensor(Array<Float32>([2.0000000000, 1.2000000477, 1.0000000000, 3.0000000000, 1.2000000477, 1.0000000000]), shape: [2, 3])
    let output = scatterUpdate(input_x, indices, updates).evaluate()
    print("input:\n", input_x)
    print("\noutput:\n", output)
    return 0
}

输出为：

input:

Tensor(shape=[2, 3], dtype=Float32, value=
[[ 2.00000000e+00  1.20000005e+00  1.00000000e+00]
 [ 3.00000000e+00  1.20000005e+00  1.00000000e+00]])

output:

Tensor(shape=[2, 3], dtype=Float32, value=
[[ 2.00000000e+00  1.20000005e+00  1.00000000e+00]
 [ 3.00000000e+00  1.20000005e+00  1.00000000e+00]])

scatterNdAdd

public func scatterNdAdd(input: Tensor, indices: Tensor, updates: Tensor, useLocking!: Bool = false): Tensor

通过稀疏加法运算更新输入 Tensor

使用给定值通过加法操作更新 Tensor 值以及输入索引。每一次运算结束后输出更新后的值，使我们更方便使用更新后的值

输入：

名称含义
input将要被更新的 Tensor，必须是 parameter，支持 Float32\Float64\Int32 类型。昇腾平台不支持 Float64 类型
indicesTensor, 指定要进行计算元素的索引，假设 indices 的 rank 为 Q, Q 满足 Q >= 2。假设 input 的 rank 为 P，indices shape 的最后一个元素为 N， P 和 N 满足，N <= P。indices 只支持 Int32 类型
updates与 input 进行相加操作的 Tensor, updates 的 rank 为 Q-1+P-N，shape 为 indices_shape[:-1] + x_shape[indices_shape[-1]:] , 类型与 input 相同
useLocking是否使用锁保护运行任务。默认值：false

输出：

名称含义
output输出 Tensor, 更新后的 input，与 input 的 shape 和 dtype 相同

支持平台: Ascend, GPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = parameter(Tensor(Array<Int32>([1, 2, 3, 4, 5, 6]), shape: Array<Int64>([6])), "input")
    let indices = Tensor(Array<Int32>([2, 4, 1, 7]), shape: Array<Int64>([4, 1]))
    let updates = Tensor(Array<Int32>([6, 7, 8, 9]), shape: Array<Int64>([4]))
    let output = scatterNdAdd(input, indices, updates)
    print(output)
    return 0
}

输出为：

Tensor(shape=[6], dtype=Int32, value=
[1 10 9 4 12 6])

softplus

public func softplus(input: Tensor): Tensor

SoftPlus 激活函数

SoftPlus 是对 Relu 功能的平滑近似。它可用于限制机器的输出始终为正。计算公式如下所示：

output=log⁡(1+exp⁡(x)),

输入：

名称含义
input输入，支持 Float32 类型 Tensor

输出：

名称含义
output输出, 与 input 的 shape 和 dtype 相同

支持平台：Ascend, GPU, CPU

反向函数：

public func softplusGrad(x: Tensor, y: Tensor): Tensor

微分伴随函数:

public func adjointSoftplus(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x = parameter(Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0]), shape: [5]), "x")
    let output = softplus(x)
    print(output)
    return 0
}

输出为：

Tensor(shape=[5], dtype=Float32, value=
[1.31326163e+00 2.12692809e+00 3.04858732e+00 4.01814985e+00 5.00671530e+00])

spaceToBatch

public func spaceToBatch(input: Tensor, blockSize: Int64, paddings: Array<Array<Int64>>): Tensor

函数 spaceToBatch 实现 SpaceToBatch 算子功能。

将空间尺寸的（h，w）按 blockSize 划分为相应数量的块，输出 Tensor 的 h 和 w 尺寸是划分后的相应块数。在划分之前，如果需要，输入的空间尺寸根据镶嵌零填充。 注意：SpaceToBatch 算子反向现在仅支持 Float32 类型。

输入：

名称含义
input输入 Tensor。shape 为 (n,c,h,w)。GPU 平台支持 Float16，Float32，Int32, Int64 类型, Ascend 平台支持 Float16，Float32 类型。
blockSize划分块的大小，值大于或等于 2; 类型为 Int64。
paddings指定 h 和 w 填充值的位置；类型为数组，其中包含两个子数组，每个子数组包含两个整数，每个整数都必须大于 0，要求 input.shape[i+2]+padding[i][0]+padding[i][1]可被 blockSize 整除。

输出：

名称含义
output输出 Tensor, dtype 与 input 相同，shape 为 (n′,c′,h′,w′)。

n′=n∗(blockSize∗blockSize)

c′=c

h′=(h+paddings[0][0]+paddings[0][1])//blockSize

w′=(w+paddings[1][0]+paddings[1][1])//blockSize

支持平台：Ascend, GPU

微分伴随函数:

public func adjointSpaceToBatch(input: Tensor, blockSize: Int64, paddings: Array<Array<Int64>>)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = parameter(Tensor(Array<Float32>([1.0000000000, 2.0000000000, 3.0000000000, 4.0000000000]), shape: Array<Int64>([1, 1, 2, 2])), "input")
    let output = spaceToBatch(input, 2, [[0, 0], [0, 0]])
    print(output)
    return 0
}

输出为：

Tensor(shape=[4, 1, 1, 1], dtype=Float32, value=
[[[[ 1.00000000e+00]]]
 [[[ 2.00000000e+00]]]
 [[[ 3.00000000e+00]]]
 [[[ 4.00000000e+00]]]])

spaceToBatchND

public func spaceToBatchND(input: Tensor, blockShape: Array<Int64>, paddings: Array<Array<Int64>>): Tensor

函数 spaceToBatchND 实现 SpaceToBatchND 算子功能。

将空间尺寸的（h，w）按 blockSize 划分为相应数量的块，输出 Tensor 的 h 和 w 尺寸是划分后的相应块数。在划分之前，如果需要，输入的空间尺寸根据镶嵌零填充。

输入：

名称含义
input输入 Tensor。shape 为 (n,c,h,w)。支持 Float16，Float32 类型。
blockShapeInt64 类型的数组，分割批次维度的块的数量，取值需大于 1。长度必须等于 2 块形状描述空间维度为分割的个数，取值需大于 1。
paddingsArray<Array<Int64>>类型，2*2 大小 空间维度的填充大小。

输出：

名称含义
output输出 Tensor, dtype 与 input 相同，shape 为 (n′,c′,h′,w′)。

支持平台: Ascend, CPU

微分伴随函数:

public func adjointspaceToBatchND(input: Tensor, blockShape: Array<Int64>, paddings: Array<Array<Int64>>)

n′=n∗(blockShape[0]∗blockShape[1])

c′=c

h′=(h+paddings[0][0]+paddings[0][1])//blockShape

w′=(w+paddings[1][0]+paddings[1][1])//blockShape

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float16>([1.00000, 2.00000, 3.00000, 4.00000]), shape: Array<Int64>([1, 1, 2, 2]))
    let output = spaceToBatchND(input, Array<Int64>([2, 2]), Array<Array<Int64>>([[0, 0], [0, 0]]))
    print(output)
    return 0
}

输出为：

Tensor(shape=[4, 1, 1, 1], dtype=Float32, value=
[[[[ 1.00000000e+00]]]
 [[[ 2.00000000e+00]]]
 [[[ 3.00000000e+00]]]
 [[[ 4.00000000e+00]]]])

sparseGatherV2

public func sparseGatherV2(input: Tensor, indices: Tensor, axis: Int64): Tensor

函数 SparseGatherV2 实现 SparseGatherV2 算子功能，用于根据轴和索引获取 Tensor 中的某些值。 此算子暂不支持反向。

输入：

名称含义
input输入 Tensor, dtype 为 Float32。
indices索引 Tensor，dtype 为 Int32 必须在 [0,input.shape[axis]) 范围内，若不在范围内，返回值对应位置补 0。
axis指定轴, 类型为 Int64, 必须在 [-input.shape.size,input.shape.size) 范围内。
注：Ascend 平台不支持输出 shape 的 dimension 大于 8 的输出。

输出：

支持平台: GPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input_params = Tensor(Array<Float32>([1.0000000000, 2.0000000000, 7.0000000000, 42.0000000000, 3.0000000000, 4.0000000000, 54.0000000000, 22.0000000000, 2.0000000000, 2.0000000000, 55.0000000000, 3.0000000000]), shape: [3, 4])
    let input_indices = Tensor(Array<Int32>([1, 2]), shape: [2])
    let axis: Int64 = 1
    let output = sparseGatherV2(input_params, input_indices, axis)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3, 2], dtype=Float32, value=
[[ 2.00000000e+00  7.00000000e+00]
 [ 4.00000000e+00  5.40000000e+01]
 [ 2.00000000e+00  5.50000000e+01]])

spaceToDepth

public func spaceToDepth(input: Tensor, blockSize: Int64): Tensor

函数 spaceToDepth 实现 SpaceToDepth 算子功能。将空间数据块重新排列为深度。

输出张量的高度维度为 h / blockSize

输出张量的权重维度为 w / blockSize

输出张量的深度为 blockSize ∗ blockSize ∗ c

输入张量的高度和宽度必须能被 blockSize 整除。数据格式为“n,c,h,w”。

输入：

名称含义
input输入 Tensor。shape 为 (n,c,h,w)。dtype 为 Float32\Int32\Int64。
blockSize划分块的大小，值大于或等于到 2。类型为 Int64

输出：

名称含义
output输出 Tensor, dtype 与 input 相同，shape 为 (n, (c ∗ blockSize ∗ 2), h / blockSize, w / blockSize)。

支持平台: GPU

微分伴随函数:

public func adjointSpaceToDepth(input: Tensor, blockSize: Int64)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = parameter(Tensor(Array<Float32>([0.5003513098, -0.3798691332, -0.3341046572, 0.7740871310, 0.2986998260, 0.7112543583, -0.8665986061, 0.5443865657, -0.9524301291, -0.4871452749, 0.6529405713, 0.8801626563]), shape: Array<Int64>([1, 3, 2, 2])), "input")
    let output = spaceToDepth(input, 2)
    print(output)
    return 0
}

输出为：

Tensor(shape=[1, 12, 1, 1], dtype=Float32, value=
[[[[ 5.00351310e-01]]
  [[ 2.98699826e-01]]
  [[-9.52430129e-01]]
  ...
  [[ 7.74087131e-01]]
  [[ 5.44386566e-01]]
  [[ 8.80162656e-01]]]])

resizeBilinear

public func resizeBilinear(input: Tensor, size: (Int64, Int64), alignCorners!: Bool = false, halfPixelCenters!: Bool = false): Tensor
public func resizeBilinear(input: Tensor, size: Array<Int64>, alignCorners!: Bool = false, halfPixelCenters!: Bool = false): Tensor

函数 resizeBilinear 实现 ResizeBilinear 算子功能，使用双线性插值将图像调整为指定大小。。

输入：

名称含义
input正向计算的输入 Tensor，支持 Float32 类型，必须为 4-D tensor，shape 为 (batch,channels,height,width)。
size图像的新 size, 类型：由 2 个 Int64 元素组成的元组或 Array, 每一个元素必须 >=0。
alignCorners是否按比例调整图像大小，若为 true，则按比例调整 input，这将精确对齐图像的 4 个角并调整图像大小。
halfPixelCenters是否几何中心对齐。如果设置为 True, 那么 alignCorners 应该设置为 False。默认值：False。

输出：

名称含义
output输出的图像。shape 为 (batch,channels,new_height,new_width)，dtype 与 input 相同。

支持平台：Ascend, GPU

微分伴随函数:

public func adjointResizeBilinear(input: Tensor, size: Array<Int64>, alignCorners!: Bool = false, halfPixelCenters!: Bool = false)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input = parameter(Tensor(Array<Float32>([1.0000000000, 2.0000000000, 3.0000000000, 4.0000000000, 5.0000000000, 1.0000000000, 2.0000000000, 3.0000000000, 4.0000000000, 5.0000000000]), shape: [1, 1, 2, 5]), "input")
    let output = resizeBilinear(input, (5, 5))
    print(output)
    return 0
}

输出为：

Tensor(shape=[1, 1, 5, 5], dtype=Float32, value=
[[[[ 1.00000000e+00  2.00000000e+00  3.00000000e+00  4.00000000e+00  5.00000000e+00]
   [ 1.00000000e+00  2.00000000e+00  3.00000000e+00  4.00000000e+00  5.00000000e+00]
   [ 1.00000000e+00  2.00000000e+00  3.00000000e+00  4.00000000e+00  5.00000000e+00]
   [ 1.00000000e+00  2.00000000e+00  3.00000000e+00  4.00000000e+00  5.00000000e+00]
   [ 1.00000000e+00  2.00000000e+00  3.00000000e+00  4.00000000e+00  5.00000000e+00]]]])

relu6

public func relu6(input: Tensor): Tensor

函数 relu6 实现 ReLU6 算子功能，计算输入 Tensor 的 ReLU（修正线性单元），其上限为 6。公式如下：

ReLU6(x)=min(max(0,x),6)

输入：

名称含义
input输入 Tensor，支持 Float32，Float16 类型

输出：

名称含义
output输出 Tensor, 与 input 的类型和形状相同

支持平台: Ascend, GPU, CPU

反向函数：

public func relu6Grad(gradOut: Tensor, input: Tensor): Tensor

微分伴随函数:

public func adjointRelu6(input: Tensor)

二阶伴随函数：

public func adjointRelu6Grad(gradOut: Tensor, input: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]), shape: Array<Int64>([2, 4]))
    let output = relu6(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 4], dtype=Float32, value=
    [[ 1.00000000e+00  2.00000000e+00  3.00000000e+00  4.00000000e+00]
     [ 5.00000000e+00  6.00000000e+00  6.00000000e+00  6.00000000e+00]])

reverseV2

public func reverseV2(input: Tensor, axis: Array<Int64>): Tensor

反转给定 Tensor 指定维度的元素

输入：

名称含义
input输入 Tensor，支持 Float32，Int32，Int64 类型
axis被反转维度的索引。索引值在[-dims， dims-1]范围内，dims 表示 input 的维度

输出：

名称含义
output输出 Tensor, 与 input 的类型和形状相同

支持平台: Ascend, GPU

微分伴随函数:

public func adjointReverseV2(input: Tensor, axis: Array<Int64>)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Int32>([1, 2, 3, 4, 5, 6, 7, 8]), shape: Array<Int64>([2, 4]))
    let output = reverseV2(input, Array<Int64>([1, 0]))
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 4], dtype=Int32, value=
[[ 8  7  6  5]
 [ 4  3  2  1]])

rint

public func rint(input: Tensor): Tensor

对输入 Tensor 的每一个元素，返回最接近的整数。

输入：

名称含义
input输入 Tensor，支持 Float32 类型

输出：

名称含义
output输出 Tensor, 与 input 的类型和形状相同

支持平台: Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([-1.6, -0.1, 1.5, 2.0]), shape: Array<Int64>([4]))
    let output = rint(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[4], dtype=Float32, value=
[-2.00000000e+00 -0.00000000e+00 2.00000000e+00 2.00000000e+00])

roiAlign

public func roiAlign(features: Tensor, rois: Tensor, pooledHeight: Int64, pooledWidth: Int64, spatialScale: Float32, sampleNum!: Int64 = 2, roiEndMode!: Int64 = 1): Tensor

函数 roiAlign 实现 ROIAlign 算子功能，计算感兴趣区域 (RoI) 的 align 运算符。算子通过双线性插值从特征图上附近的网格点计算每个采样点的值。 不对任何涉及 RoI、其 bin 或采样点的坐标执行量化。

输入：

名称含义
features特征 Tensor，shape 必须为 (N,C,H,W)，支持 Float32 类型。
rois目标区域 Tensor，shape 为 (rois_n,5)。支持 Float32 类型。 rois_n 表示 RoI 的数量。第二维的大小必须为 5，5 列分别表示 (image_index,top_left_x,top_left_y,bottom_right_x,bottom_right_y)。
pooledHeight输出特征高度，类型为 Int64。
pooledWidth输出特征宽度，类型为 Int64。
spatialScale将原始图像坐标映射到输入特征图坐标的比例因子。假设 RoI 的高度在原始图像中为 ori_h，在输入特征图中为 fea_h，则 spatial_scale 为 fea_h / ori_h。类型为 Float32。
sampleNum默认值：2。采样点的数量。类型为 Int64。
roiEndMode默认值：1。值必须为 0 或 1。类型为 Int64。

输出：

名称含义
output正向计算结果 Tensor, shape 为 (rois_n,C,pooled_height,pooled_width).

支持平台: Ascend, GPU

微分伴随函数:

public func adjointRoiAlign(features: Tensor, rois: Tensor, pooledHeight: Int64, pooledWidth: Int64, spatialScale: Float32, sampleNum!: Int64 = 2, roiEndMode!: Int64 = 1)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let features = parameter(Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: [1, 1, 2, 2]), "features")
    let rois = parameter(Tensor(Array<Float32>([0.0, 0.2, 0.3, 0.2, 0.3]), shape: [1, 5]), "rois")
    let output = roiAlign(features, rois, 2, 2, 0.5, sampleNum: 2)
    print(output)
    return 0
}

输出为：

Tensor(shape=[1, 1, 2, 2], dtype=Float32, value=
[[[[ 1.77499998e+00  2.02499986e+00]
   [ 2.27499986e+00  2.52500010e+00]]]])

squaredDifference

public func squaredDifference(input1: Tensor, input2: Tensor): Tensor
public func squaredDifference(input1: Tensor, input2: Float32): Tensor
public func squaredDifference(input1: Float32, input2: Tensor): Tensor
public func squaredDifference(input1: Tensor, input2: Float16): Tensor
public func squaredDifference(input1: Float16, input2: Tensor): Tensor
public func squaredDifference(input1: Tensor, input2: Int32): Tensor
public func squaredDifference(input1: Int32, input2: Tensor): Tensor

函数 squaredDifference 实现 SquaredDifference 算子功能，用于计算第一个输入与第二个输入逐个元素相减并对结果求平方。输入可以是 Tensor 或者标量，但不能同时为标量。当输入为两个 Tensor 时，其 shape 必须可以进行 broadcast。

输入：

名称含义
input1第一个输入。支持 Float16\Float32\Int32 类型的 number 或 tensor，两个输入的 dtype 必须相同。
input2第二个输入。支持 Float16\Float32\Int32 类型的 number 或 tensor，两个输入的 dtype 必须相同。

输出：

名称含义
output输出 Tensor，数据类型和形状与 broadcast 后的输入相同。

支持平台: Ascend, GPU

微分伴随函数：

public func adjointSquaredDifference(input1: Tensor, input2: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input1 = Tensor(Array<Int32>([8, 9, 4, 3, 4]), shape: Array<Int64>([5]))
    let input2 = Tensor(Array<Int32>([6, 1, 2, 5, 8]), shape: Array<Int64>([5]))
    let output = squaredDifference(input1, input2)
    print(output)
    return 0
}

输出为：

Tensor(shape=[5], dtype=Int32, value=
[4 64 4 4 16])

sign

public func sign(x: Tensor): Tensor

函数 sign 实现 Sign 算子功能，用于对输入 Tensor 进行 element-wise 的求符号计算，x 的元素为正数时返回 1，负数时返回 -1，元素为 0 时返回 0。

输入：

名称含义
x输入 Tensor，支持 Int32 和 Float32 类型。

输出：

名称含义
output结果 Tensor，与输入 Tensor 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU

微分伴随函数：

public func adjointSign(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input = Tensor(Array<Float32>([-0.5889578462, 0.0, 0.9656294584, 0.8302891254, -0.4508400559, 0.1614982486]), shape: [6])
    let output = sign(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[6], dtype=Float32, value=
[-1.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 -1.00000000e+00 1.00000000e+00])

sub

public func sub(input1: Tensor, input2: Tensor): Tensor
public func sub(input1: Tensor, input2: Float16): Tensor
public func sub(input1: Float16, input2: Tensor): Tensor
public func sub(input1: Tensor, input2: Float32): Tensor
public func sub(input1: Float32, input2: Tensor): Tensor
public func sub(input1: Tensor, input2: Float64): Tensor
public func sub(input1: Float64, input2: Tensor): Tensor
public func sub(input1: Int32, input2: Tensor): Tensor
public func sub(input1: Tensor, input2: Int32): Tensor

函数 sub 实现 Sub 算子功能，用于对输入逐元素做减法运算。输入必须是两个 Tensor 或者一个 Tensor 和一个标量。当输入是两个 Tensor 时，它们的 dtype 必须一致，并且它们的 shape 可以被广播。当输入是一个 Tensor 和一个标量时，这个标量只能是一个常数。

输入：

名称含义
input0Tensor 或者 Number，GPU & CPU 支持 Float16\Float32\Float64\Int32, Ascend 支持 Float16\Float32\Int32 类型， dtype 或者类型要求与 input1 一致
input1Tensor 或者 Number，GPU & CPU 支持 Float16\Float32\Float64\Int32, Ascend 支持 Float16\Float32\Int32 类型， dtype 或者类型要求与 input0 一致

输出：

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointSub(input1: Tensor, input2: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input0 = Tensor(Array<Float32>([1.0, 5.0, 3.0]), shape: Array<Int64>([3]))
    let input1 = Tensor(Array<Float32>([4.0, 2.0, 6.0]), shape: Array<Int64>([3]))
    let output = sub(input0, input1)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Float32, value=
[-3.00000000e+00 3.00000000e+00 -3.00000000e+00])

stack

public func stack(input: Array<Tensor>, axis!: Int64 = 0): Tensor
public func stack(input: Tensor, axis!: Int64 = 0): Tensor

函数 stack 实现 Stack 算子功能，用于在指定轴上对 Tensor 进行数值堆叠。

给定具有相同秩 $R$ 的 Tensor 列表，输出一个秩为 $R+1$ 的 Tensor。假定输入的 Tensor 个数是 $N$，Tensor 的 shape 是 $(x_1, x_2, …, x_R)$ ，如果 $axis \ge 0$，那么输出 Tensor 的 shape 是 $(x1, x2, …,x_{axis}, N, x_{axis+1},…,x_R)$。

输入：

名称含义
input输入类型是 Array时, GPU & CPU 支持 Float32\Int32\Bool 类型的 tensor 数组, Ascend 支持 Float32\Int32 类型的 tensor 数组; 它们具有相同 shape 和 dtype；输入类型是 Tensor 时，其必须是 makeTuple 的输出。
axisstack 参考轴，默认是 0。范围

[−(R+1),R+1)

。 |

输出：

名称含义
output输出 Tensor，和 input 具有相同的 dtype。

支持平台：Ascend, GPU, CPU

微分伴随函数:

public func adjointStack(tupleInput: Tensor, axis!: Int64 = 0)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input0 = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([2, 2]))
    let input1 = Tensor(Array<Float32>([5.0, 6.0, 7.0, 8.0]), shape: Array<Int64>([2, 2]))
    let input: Array<Tensor> = [input0, input1]
    let output = stack(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 2, 2], dtype=Float32, value=
[[[1.00000000e+00 2.00000000e+00]
  [3.00000000e+00 4.00000000e+00]]
 [[5.00000000e+00 6.00000000e+00]
  [7.00000000e+00 8.00000000e+00]]])

stridedSlice

public func stridedSlice(input: Tensor, begin: Array<Int64>, end: Array<Int64>, strides: Array<Int64>, beginMask!: Int64 = 0, endMask!: Int64 = 0, ellipsisMask!: Int64 = 0, newAxisMask!: Int64 = 0, shrinkAxisMask!: Int64 = 0): Tensor

函数 stridedSlice 实现 StridedSlice 算子功能，用于提取 Tensor 的跨步切片。从给定的输入 Tensor 中，提取出 (end – begin)/ strides 大小的切片。此算子 Ascend 平台暂时仅静态图支持反向。

输入：

名称含义
input输入 tensor，GPU & CPU 支持 Float32\Float64\Int32\Bool 类型, Ascend 支持 Float32\Int32\Bool 类型,。
begin元素是常量的数组，代表切片开始的位置，begin，end，strides 的元素个数必须相等。
end元素是常量的数组，代表切片结束的位置，begin，end，strides 的元素个数必须相等。
strides元素是常量（非 0）的数组，代表切片步长，begin，end，strides 的元素个数必须相等。
beginMaskslice 起始索引的掩码，默认 0。
endMaskslice 结束索引的掩码，默认 0。
ellipsisMask省略掩码，默认 0，只有有 1bit 是 1。
newAxisMask新轴掩码，默认 0。
shrinkAxisMask收缩轴掩码，默认 0。

输出：

支持平台：Ascend, GPU, CPU

反向函数：

public func stridedSliceGrad(gradOut: Tensor, shape: Array<Int64>, begin: Array<Int64>, end: Array<Int64>, strides: Array<Int64>,
beginMask!: Int64 = 0, endMask!: Int64 = 0, ellipsisMask!: Int64 = 0, newAxisMask!: Int64 = 0, shrinkAxisMask!: Int64 = 0): Tensor

微分伴随函数:

public func adjointStridedSlice(input: Tensor, begin: Array<Int64>, end: Array<Int64>, strides: Array<Int64>, beginMask!: Int64 = 0, endMask!: Int64 = 0, ellipsisMask!: Int64 = 0, newAxisMask!: Int64 = 0, shrinkAxisMask!: Int64 = 0)

二阶伴随函数：

public func adjointStridedSliceGrad(gradOut: Tensor, shape: Array<Int64>, begin: Array<Int64>, end: Array<Int64>, strides: Array<Int64>, beginMask!: Int64 = 0, endMask!: Int64 = 0, ellipsisMask!: Int64 = 0, newAxisMask!: Int64 = 0, shrinkAxisMask!: Int64 = 0)

【注意】：

以下面示例中的数据为例

  • 在第 0 维中，begin 为 1，end 为 2，strides 为 Array([1, 1, 1])，因为 1 + 1 =2≥2，间隔为 [1,2] [1,2）。 因此，返回第 0 维的 index = 1 的元素，即 [[3，3，3]，[4，4，4]]。
  • 类似地，在第一维中，间隔为 [0,1）[0,1）。 根据第 0 维的返回值，返回 index = 0 的元素，即 [3，3，3]。
  • 类似地，在第二维中，间隔为 [0,3）[0,3）。 根据第 1 维的返回值，返回索引 = 0,1,2，即[3，3，3] 的元素。
  • 最终，输出为 [3, 3, 3]。

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let data: Array<Int32> = Array<Int32>([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6])
    let input = Tensor(data, shape: Array<Int64>([3, 2, 3]))
    let output = stridedSlice(input, Array<Int64>([1, 0, 0]), Array<Int64>([2, 1, 3]), Array<Int64>([1, 1, 1]))
    print(output)
    return 0
}

输出为：

Tensor(shape=[1, 1, 3], dtype=Int32, value=
[[[3 3 3]]])

standardNormal

public func standardNormal(shape: Array<Int64>, seed!: Int64 = 0,
                      seed2!: Int64 = 0): Tensor

函数 standardNormal 实现 StandardNormal 算子功能，用于生成符合标准正态分布的随机数。

输入：

名称含义
shape生成随机数的形状。
seed随机数种子。必须 >=0，默认值：0。
seed2随机数种子 2。必须 >=0，默认值：0。

输出：

名称含义
output输出 shape 跟输入的 shape 一致，dtype 为 Float32 的 Tensor。

支持平台：Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let shape = Array<Int64>([2, 3])
    let output = standardNormal(shape, seed: 2)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 3], dtype=Float32, value=
[[8.51138175e-01 -9.68754649e-01 -2.28183597e-01]
 [1.99522287e-01 4.66489911e-01 1.12157691e+00]])

squeeze

public func squeeze(input: Tensor, axis!: Array<Int64> = []): Tensor

函数 squeeze 实现 Squeeze 算子功能，输出一个 Tensor，其 dtype 跟输入 Tensor 相同，其 shape 等于输入 Tensor 的 shape 去除维度是 1 的轴。

【注意】：维度索引从 0 开始，并且必须在 [-input.ndim, input.ndim) 范围内。

输入：

名称含义
input输入 Tensor。
axis指定要删除的形状的维度索引，默认删除所有等于 1 的维度。

输出：

名称含义
output输出 Tensor，与原始变量的类型相同。

支持平台：Ascend, GPU, CPU

微分伴随函数:

public func adjointSqueeze(x: Tensor, axis: Array<Int64>)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let data = onesTensor(Array<Int64>([3, 2, 1]))
    let output = squeeze(data)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3, 2], dtype=Float32, value=
[[1.00000000e+00 1.00000000e+00]
 [1.00000000e+00 1.00000000e+00]
 [1.00000000e+00 1.00000000e+00]])

Switch

public func Switch(cond: Tensor, input1: Tensor, input2: Tensor): Tensor

仓颉 TensorBoost 尚不支持将仓颉原生的 if 语句转换成计算图中的控制流，如果用户需要在神经网络中使用 if 语句，可以使用仓颉 TensorBoost 提供的 Switch 算子实现该功能。函数 Switch 实现 Switch 算子功能，用于根据条件在计算图中创建控制流。

输入：

名称含义
cond输入条件 Tensor，cond 中只需要一个 Bool 类型元素，对应 if 语句 condition 判断逻辑。
input1控制流的 true 分支，对应 if 语句分支。
input2控制流的 false 分支，对应 else 语句分支。与 input1 具有相同的 shape 和 dtype

输出：

名称含义
output输出 Tensor, 跟输入 input1 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU

微分伴随函数：

public func adjointSwitch(cond: Tensor, input1: Tensor, input2: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input1 = Tensor(Array<Float32>([0.0, 1.0, 2.0, 3.0]), shape: Array<Int64>([2, 2]))
    let input2 = Tensor(Array<Float32>([5.0, 6.0, 7.0, 8.0]), shape: Array<Int64>([2, 2]))
    let cond = Tensor(true)
    let output = Switch(cond, input1, input2)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[0.00000000e+00 1.00000000e+00]
 [2.00000000e+00 3.00000000e+00]])

select

public func select(condition: Tensor, x: Tensor, y: Tensor): Tensor

函数 select 实现 Select 功能，用于根据 condition 中元素的符号来选择结果输出来自 x 还是来自 y。

输入：

名称含义
condition条件判断 Tensor，Bool 类型，其 shape 跟输入 x 和 y 相同。
x输入 Tensor x ，GPU & CPU 支持 Float16\Float32\Float64\Int32\Int64 类型, Ascend 支持 Float16\Float32\Int32 类型。
y输入 Tensor y，与 x 具有相同的 shape 和 dtype。

输出：

名称含义
output输出 Tensor，跟输入 x 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU, CPU

微分伴随函数:

public func adjointSelect(condition: Tensor, x: Tensor, y: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let condition = Tensor([true, false], shape: Array<Int64>([2]))
    let x = Tensor(Array<Float32>([2.0, 3.0]), shape: Array<Int64>([2]))
    let y = Tensor(Array<Float32>([1.0, 2.0]), shape: Array<Int64>([2]))
    let output = select(condition, x, y)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2], dtype=Float32, value=
[2.00000000e+00 2.00000000e+00])

softmax

public func softmax(input: Tensor, axis!: Int64 = -1): Tensor
public func softmax(input: Tensor, axis: Array<Int64>): Tensor

函数 softmax 实现 Softmax 算子功能，用于对输入 Tensor，在 axis 指定的轴上进行 softmax 计算。

输入：

名称含义
input输入 Tensor，dtype 是 Float32。
axis需要计算 softmax 的维度，其元素取值应在[-input.getShapeDims(), input.getShapeDims())之间，默认值为 – 1，即计算最后一维。

输出：

名称含义
outputsoftmax 之后的结果 Tensor。与输入 Tensor 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU, CPU

微分伴随函数:

public func adjointSoftmax(x: Tensor, axis: Array<Int64>)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0]), shape: Array<Int64>([5]))
    let output = softmax(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[5], dtype=Float32, value=
[1.16562294e-02 3.16849165e-02 8.61285329e-02 2.34121650e-01 6.36408567e-01])

sqrt

public func sqrt(input: Tensor): Tensor

函数 sqrt 实现 Sqrt 算子功能，用于对输入 Tensor 进行逐元素开方运算。

输入：

名称含义
input输入 Tensor，GPU & CPU 支持 Float16\Float32\Float64 类型, Ascend 支持 Float16\Float32 类型。

输出：

名称含义
output输出 Tensor，与输入 Tensor 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU, CPU

反向函数：

public func sqrtGrad(out: Tensor, gradOut: Tensor): Tensor

微分伴随函数：

public func adjointSqrt(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([9.0, 16.0]), shape: Array<Int64>([2]))
    let output = sqrt(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2], dtype=Float32, value=
[3.00000000e+00 4.00000000e+00])

square

public func square(input: Tensor): Tensor

函数 square 实现 Square 算子功能，用于对输入 Tensor 进行逐元素平方运算。

输入：

名称含义
input输入 Tensor，dtype 是 Float16\Float32。

输出：

名称含义
output输出 Tensor，与输入 Tensor 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointSquare(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([2.0, 3.0]), shape: Array<Int64>([2]))
    let output = square(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2], dtype=Float32, value=
[4.00000000e+00 9.00000000e+00])

squareSumAll

public func squareSumAll(x: Tensor, y: Tensor): (Tensor, Tensor)

函数 squareSumAll 实现 SquareSumAll 算子功能，返回输入 Tensor 的平方和。

输入：

名称含义
x输入 Tensor，dtype 是 Float32。
y输入 Tensor，shape 与 dtype 与 x 一致。

输出：

名称含义
output1输出 Tensor，与输入 x 具有相同的 dtype。
output2输出 Tensor，与输入 x 具有相同的 dtype。

支持平台：Ascend, GPU

微分伴随函数：

public func adjointSquareSumAll(x: Tensor, y: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x = parameter(Tensor(Array<Float32>([0.0, 0.0, 2.0, 0.0]), shape: Array<Int64>([2, 2])), "x")
    let y = parameter(Tensor(Array<Float32>([0.0, 0.0, 2.0, 4.0]), shape: Array<Int64>([2, 2])), "y")
    let res = squareSumAll(x, y)
    let tuple = makeTuple([res[0], res[1]])
    print(tuple)
    return 0
}

输出为：

Tensor(shape=[], dtype=Float32, value= 4.00000000e+00)
Tensor(shape=[], dtype=Float32, value= 2.00000000e+01)

sigmoid

public func sigmoid(input: Tensor): Tensor

函数 sigmoid 实现 Sigmoid 激活函数功能，Sigmoid 定义为：

sigmoid(xi)=11+exp⁡(−xi)

输入：

名称含义
input输入 Tensor，dtype 是 FLOAT32。

输出

名称含义
output输出 Tensor，shape 和 dtype 与 input 相同。

支持平台: GPU

反向函数：

public func sigmoidGrad(input: Tensor, gradOut: Tensor): Tensor

微分伴随函数:

public func adjointSigmoid(input: Tensor)

二阶伴随函数：

public func adjointSigmoidGrad(input: Tensor, gradOut: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = randomNormalTensor(Array<Int64>([32, 10]))
    let output = sigmoid(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[32, 10], dtype=Float32, value=
[[4.97435033e-01 4.95399296e-01 4.99560505e-01 ... 4.96425629e-01 5.00373304e-01 4.96130377e-01]
 [5.00792205e-01 5.02004087e-01 4.99814272e-01 ... 5.00120342e-01 4.99071419e-01 5.04202366e-01]
 [4.94585782e-01 5.01240373e-01 5.04908741e-01 ... 4.98411238e-01 5.00000536e-01 5.00362337e-01]
 ...
 [5.00727594e-01 4.98013198e-01 4.96974528e-01 ... 4.93593991e-01 5.01453340e-01 5.00634849e-01]
 [5.04909337e-01 5.02907217e-01 4.99907285e-01 ... 5.02277315e-01 4.97044623e-01 5.00786901e-01]
 [5.01355529e-01 5.00793278e-01 4.97799337e-01 ... 5.01390338e-01 5.02621114e-01 4.97769445e-01]])

sigmoidCrossEntropyWithLogits

public func sigmoidCrossEntropyWithLogits(x: Tensor, y: Tensor): Tensor

使用给定的 Logits 来计算 Logits 和 Label 之间的 Sigmoid 交叉熵。

在离散分类任务中测量分布误差，其中每个类是独立的，不使用跨熵损失相互排斥。

假设 logits 输入为 X ，lable 输入为 Y ，output 为 Loss，计算公式为：

pij=sigmoid(Xij)=11+e−Xijlossij=−[Yij∗ln(pij)+(1−Yij)ln(1−pij)]

输入：

名称含义
logits表示 logits 的输入，支持 Float32 类型 Tensor
label表示 label 的输入，支持 Float32 类型 Tensor

输出：

名称含义
output输出, 与 input 的 shape 和 dtype 相同

支持平台：Ascend, GPU, CPU

反向函数：

public func sigmoidCrossEntropyWithLogitsGrad(x: Tensor, y: Tensor, dout: Tensor): Tensor

微分伴随函数:

public func adjointSigmoidCrossEntropyWithLogits(x: Tensor, y: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let logits = Tensor(Array<Float32>([-0.8, 1.2, 0.7, -0.1, -0.4, 0.7]), shape: [2, 3])
    let label = Tensor(Array<Float32>([0.3, 0.8, 1.2, -0.6, 0.1, 2.2]), shape: [2, 3])
    let output = sigmoidCrossEntropyWithLogits(logits, label)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 3], dtype=Float32, value=
[[ 6.11100674e-01  5.03282428e-01  2.63186008e-01]
 [ 5.84396660e-01  5.53015292e-01 -4.36813980e-01]])

slice

public func slice(input: Tensor, begin: Array<Int64>, size: Array<Int64>): Tensor

函数 slice 实现 Slice 算子功能，用于从 input Tensor 中抽取一部分数据。

输入：

名称含义
input输入 Tensor。
beginInt64 的数组, 取值大于等于 0, 第 i 位元素值 begin[i] 表示 input 第 i 根轴上从 begin[i] 位开始抽取数据。
sizeInt64 的数组, 取值大于 0, 第 i 位元素值 size[i] 表示 input 第 i 根轴上抽取 size[i] 个数据。

输出：

名称含义
output输出 Tensor，与输入 Tensor 具有相同的 type，shape 为输入中的 size。

支持平台：Ascend, GPU, CPU

反向函数：

public func sliceGrad(dy: Tensor, x: Tensor, begin: Array<Int64>, size: Array<Int64>): Tensor

微分伴随函数:

public func adjointSlice(input: Tensor, begin: Array<Int64>, size: Array<Int64>)

二阶伴随函数：

public func adjointSliceGrad(dy: Tensor, x: Tensor, begin: Array<Int64>, size: Array<Int64>)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]), shape: Array<Int64>([2, 3]))
    let begin = Array<Int64>([0, 1])
    let size = Array<Int64>([2, 1])
    let output = slice(input, begin, size)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 1], dtype=Float32, value=
[[2.00000000e+00]
 [5.00000000e+00]])

split

public func split(input: Tensor, axis: Int64, outputNum: Int64): Tensor

函数 split 实现 Split 算子功能，用于把 input 沿 axis 指定的轴划分成 outputNum 个子 Tensor。input 在划分轴的维度必须能被 outputNum 整除。

输入：

名称含义
input输入 Tensor。
axis指定要切分的轴， 取值在 [-input.size, input.size) 之间。
outputNum表示将指定的轴切分成 outputNum 份。

输出：

名称含义
output输出 Tensor，与 input 具有相同的 dtype。

支持平台：Ascend, GPU, CPU

微分伴随函数:

public func adjointSplit(input: Tensor, axis: Int64, outputNum: Int64)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]), shape: Array<Int64>([6]))
    let axis = 0
    let outputNum = 3
    let output = split(input, axis, outputNum)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2], dtype=Float32, value=
[1.00000000e+00 2.00000000e+00])
Tensor(shape=[2], dtype=Float32, value=
[3.00000000e+00 4.00000000e+00])
Tensor(shape=[2], dtype=Float32, value=
[5.00000000e+00 6.00000000e+00])

sparseApplyProximalAdagrad

public func sparseApplyProximalAdagrad(x: Tensor, accum: Tensor, lr: Float32, l1: Float32, l2: Float32, grad1: Tensor, indices: Tensor, useLocking!: Bool = false): (Tensor, Tensor)
public func sparseApplyProximalAdagrad(x: Tensor, accum: Tensor, lr: Float32, l1: Float32, l2: Tensor, grad1: Tensor, indices: Tensor, useLocking!: Bool = false): (Tensor, Tensor)
public func sparseApplyProximalAdagrad(x: Tensor, accum: Tensor, lr: Float32, l1: Tensor, l2: Float32, grad1: Tensor, indices: Tensor, useLocking!: Bool = false): (Tensor, Tensor)
public func sparseApplyProximalAdagrad(x: Tensor, accum: Tensor, lr: Tensor, l1: Float32, l2: Float32, grad1: Tensor, indices: Tensor, useLocking!: Bool = false): (Tensor, Tensor)
public func sparseApplyProximalAdagrad(x: Tensor, accum: Tensor, lr: Float32, l1: Tensor, l2: Tensor, grad1: Tensor, indices: Tensor, useLocking!: Bool = false): (Tensor, Tensor)
public func sparseApplyProximalAdagrad(x: Tensor, accum: Tensor, lr: Tensor, l1: Tensor, l2: Float32, grad1: Tensor, indices: Tensor, useLocking!: Bool = false): (Tensor, Tensor)
public func sparseApplyProximalAdagrad(x: Tensor, accum: Tensor, lr: Tensor, l1: Float32, l2: Tensor, grad1: Tensor, indices: Tensor, useLocking!: Bool = false): (Tensor, Tensor)
public func sparseApplyProximalAdagrad(x: Tensor, accum: Tensor, lr: Tensor, l1: Tensor, l2: Tensor, grad1: Tensor, indices: Tensor, useLocking!: Bool = false): (Tensor, Tensor)

函数 sparseApplyProximalAdagrad 实现 SparseApplyProximalAdagrad 算子功能。根据 adagrad 算法更新张量，与 ApplyProximalAdagrad 算子相比，输入多了额外的索引张量。

accum+=grad1∗grad1

$$ prox_v=x-lr_grad1_\frac{1}{\sqrt{accum}} $$

$$ x=\frac{sign(prox_v)}{1+lr*l2}_max(|prox_v|-lr_l1, 0) $$

参数列表：

参数名称含义
useLocking如果为 true，x 和 accum 的更新将受到锁保护，默认为 false

输入：

名称含义
x要更新的 tensor，支持 Float32 类型，需设置为 parameter。
accum要更新的 tensor，shape 和 dtype 与 x 一致，需设置为 parameter。
lr学习率，支持 Float32 类型的 number 或 tensor。
l1正则化系数，支持 Float32 类型的 number 或 tensor。
l2正则化系数，支持 Float32 类型的 number 或 tensor。
grad1梯度，dtype 与 x 一致，且当 x shape 的维度大于 1 时，x 与 grad1 的 shape 除第 0 维外一致。
indicesx 和 accum 的第一个维度的索引向量，支持 Int32 与 Int64 类型，且 indices 与 grad1 的 shape 第 0 维相同。

输出：

名称含义
x输出 Tensor，与输入 x 具有相同的 dtype 与 shape。
accum输出 Tensor，与输入 accum 具有相同的 dtype 与 shape。

支持平台：Ascend, GPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x = parameter(Tensor(Array<Float32>([4.1, 7.2, 1.1, 3.0]), shape: Array<Int64>([2, 2])), "var")
    let accum = parameter(Tensor(Array<Float32>([0.0, 0.0 , 0.0, 0.0]), shape: Array<Int64>([2, 2])), "accum")
    let lr: Float32 = 1.0
    let l1: Float32 = 1.0
    let l2: Float32 = 0.0
    let gradient = parameter(Tensor(Array<Float32>([1.0, 1.0, 1.0, 1.0]), shape: Array<Int64>([2, 2])), "grad")
    let indices = Tensor(Array<Int32>([0, 1]), shape: Array<Int64>([2]))
    let tuple = sparseApplyProximalAdagrad(x, accum, lr, l1, l2, gradient, indices)
    let output = makeTuple([tuple[0], tuple[1]])
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[2.09999990e+00 5.19999981e+00]
 [0.00000000e+00 1.00000000e+00]])
Tensor(shape=[2, 2], dtype=Float32, value=
[[1.00000000e+00 1.00000000e+00]
 [1.00000000e+00 1.00000000e+00]])

sparseApplyFtrl

public func sparseApplyFtrl(x: Tensor, accum: Tensor, linear: Tensor, gradOut: Tensor, indices: Tensor, lr: Float32, l1: Float32, l2: Float32, lrPower: Float32, useLocking!: Bool = false): (Tensor, Tensor, Tensor)

根据 FTRL 方案更新输入，FTRL 表示一种在线凸优化算法，根据损失函数自适应选择正则化函数。可参考在线凸优化的自适应边界优化论文：a View from the Trenches for engineering document。其计算过程如下：

mt+1=mt+g2ut+1=ut+g−mt+1-p−mt-pα∗ωtωt+1={(sign(ut+1)∗l1−ut+1)mt+1-pα+2∗l2 if |ut+1|>l10.0 otherwise 

其中，$m$表示 accum，$g$表示 gradOut，$t$表示迭代步数，$u$表示 linear，$p$表示 lrPower，$α$表示学习率 lr，$w$表示待更新的输入 x。

输入：

名称含义
x要更新的变量。 支持 Float16\Float32 类型，需要设置为 parameter
accum梯度的均方值。shape 与 dtype 与 x 一致，需要设置为 parameter
linear线性增益。shape 与 dtype 与 x 一致，需要设置为 parameter
gradOut梯度 Tensor。shape 与 dtype 与 x 一致
indices表示 x 和 accum 的第一维中的索引 Tensor。dtype 为 Int32 或 Int64， indices.shape[0] = grad.shape[0]; 注意，如果在索引中有重复项，则更新顺序未定义。
lr学习率。类型为 Float32, 必须大于 0.0
l1L1 正则化强度。类型为 Float32，必须大于等于 0.0
l2L2 正则化强度。类型为 Float32，必须大于等于 0.0
lrPower学习率下降的速度控制参数。Float32 类型，必须小于等于 0.0
useLocking如果为 true，x 和有累加 tensor 的更新将受到锁保护，Bool 类型，默认为 false

输出：

名称含义
xTensor，更新后的 x 具有 与 输入的 x 相同的形状和数据类型
accumTensor，更新后的 accum 具有 与 输入的 accum 相同的形状和数据类型
linearTensor，更新后的 linear 具有 与 输入的 linear 相同的形状和数据类型

支持平台: GPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let x = parameter(Tensor(Array<Float32>([-0.6458890438, -0.5430433154, -0.4407467842, -0.4004685581, 0.6915576458]), shape: [5]), "x")
    let accum = parameter(Tensor(Array<Float32>([0.1707346588, 0.1966998577, -0.9218196869, 0.8483691812, 0.8923599124]), shape: [5]), "accum")
    let linear = parameter(Tensor(Array<Float32>([-0.4502078593, 0.2068482637, -0.2828353047, 0.6220275760, 0.3832996786]), shape: [5]), "linear")
    let gradOut = Tensor(Array<Float32>([0.5018641949, 0.5371343493, 0.8976003528, 0.6669725180, -0.7595016956]), shape: [5])
    let indices = Tensor(Array<Int32>([5, 7, 4, 1, 3]), shape: [5])
    let (res0, res1, res2) = sparseApplyFtrl(x, accum, linear, gradOut, indices, 3.01, 0.0, 0.0, -0.5)
    let res = makeTuple([res0, res1, res2]).evaluate()
    print(x)
    print("\n")
    print(accum)
    print("\n")
    print(linear)
    return 0
}

输出为：

Tensor(shape=[5], dtype=Float32, value=
[-6.45889044e-01 -3.52612305e+00 -4.40746784e-01 2.55120188e-01 -2.76851344e+00])

Tensor(shape=[5], dtype=Float32, value=
[1.70734659e-01 6.41552210e-01 -9.21819687e-01 1.42521203e+00 1.69804633e+00])

Tensor(shape=[5], dtype=Float32, value=
[-4.50207859e-01 9.38311398e-01 -2.82835305e-01 -1.01185441e-01 1.19854653e+00])

sin

public func sin(input: Tensor)

函数 sin 实现 Sin 算子功能，用于计算输入的正弦。

输入：

名称含义
input输入 Tensor。GPU & CPU 支持 Float16\Float32\Float64 支持, Ascend 支持 Float16\Float32。

输出：

支持平台：Ascend, GPU, CPU

微分伴随函数：

public func adjointSin(input: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([0.62, 0.28, 0.43, 0.62]), shape: Array<Int64>([4]))
    let output = sin(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[4], dtype=Float32, value=
[5.81035197e-01 2.76355654e-01 4.16870803e-01 5.81035197e-01])

scatterNd

public func scatterNd(indices: Tensor, update: Tensor, shape: Array<Int64>): Tensor

函数 scatterNd 实现 ScatterNd 算子功能，用于根据指定的 indices，将 update 分散到大小为 shape 的 ZeroTensor 中。

indices = [v1, v2, … vn], vm 是一个 k-vector，表示一个 index, k 是 shape 的维度。

update = [a1, a2, …, an]

则输出的 tensor 中 v1 的值为 a1，v2 的值为 a2…，其余值均为 0。

输入：

名称含义
indices要取数的 indice，dtype 是 Int32\Int64。indices shape 的 rank 至少为 2，且 indices shape 的最后一维必须小于 shape.size
update输入数据，dtype 是 Float32\Float64\Int32\Int64, Ascend 支持 Float32\Int32。update shape 需要满足： update shape = indices shape[:-1] + shape[indices_shape[-1]:]
shapeInt64 的数组，表示输出 Tensor 的 shape。

输出：

名称含义
output输出 Tensor。该 Tensor 的 shape 与 输入的 shape 相同，dtype 与 update 的 dtype 相同

注：Ascend 平台不支持 indices 为 Int64 类型

支持平台：Ascend, GPU, CPU

微分伴随函数:

public func adjointScatterNd(indices: Tensor, update: Tensor, shape: Array<Int64>)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let indices = Tensor(Array<Int32>([0, 0, 1, 2, 2, 0]), shape: Array<Int64>([3, 2]))
    let update = Tensor(Array<Int32>([1, 2, 3]), shape: Array<Int64>([3]))
    let shape = Array<Int64>([3, 3])
    let output = scatterNd(indices, update, shape)
    print(output)
    return 0
}

输出为：

Tensor(shape=[3, 3], dtype=Int32, value=
[[1 0 0]
 [0 0 2]
 [3 0 0]])

scatterNdSub

public func scatterNdSub(input: Tensor, indices: Tensor, updates: Tensor, useLocking!: Bool = false): Tensor

函数 scatterNdSub 实现 ScatterNdSub 算子功能，用于根据指定的 indices，对 input 中的单个值或切片应用稀疏减法，从 input 对应位置减去 update 的值。

输入：

名称含义
input将要被更新的 Tensor，必须是 Parameter，支持 Float32\Float64\Int32\Int64 类型, Ascend 平台支持 Float32 和 Int32 类型。
indices要取数的 indice，dtype 是 Int32。indices shape 的 rank 至少为 2，且 indicesShape 的最后一维必须小于 inputShape.size
updates要更新到 input 中的张量，dtype 与 input 相同。 shape 为 indicesShape[:-1] + inputShape[indicesShape[-1]:]
useLocking是否通过锁保护分配,类型为：Bool， 默认值：false。

输出：

名称含义
output输出 Tensor。 shape 与 dtype 和 input 相同。

支持平台: GPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = parameter(Tensor(Array<Float32>([1.0000000000, 2.0000000000, 3.0000000000, 4.0000000000, 5.0000000000, 6.0000000000, 7.0000000000, 8.0000000000]), shape: Array<Int64>([8])), "input_x")
    let indices = parameter(Tensor(Array<Int32>([2, 4, 1, 7]), shape: Array<Int64>([4, 1])), "indices")
    let updates = parameter(Tensor(Array<Float32>([6.0000000000, 7.0000000000, 8.0000000000, 9.0000000000]), shape: Array<Int64>([4])), "updates")
    let output = scatterNdSub(input, indices, updates)
    print(output)
    return 0
}

输出为：

Tensor(shape=[8], dtype=Float32, value=
[1.00000000e+00 -6.00000000e+00 -3.00000000e+00 ... 6.00000000e+00 7.00000000e+00 -1.00000000e+00])

scatterNdUpdate

public func scatterNdUpdate(input: Tensor, indices: Tensor, updates: Tensor, useLocking!: Bool = true): Tensor

函数 scatterNdUpdate 实现 ScatterNdUpdate 算子功能，用于根据指定的 indices，更新 input 中的值，将 input 对应位置更新为 update 的值。

输入：

名称含义
input将要被更新的 Tensor，必须是 parameter，支持 Float32\Float64\Int32\Int64 类型，Ascend 平台支持 Float32 类型。
indices要取数的 indice，dtype 是 Int32。indices shape 的 rank 至少为 2，且 indicesShape 的最后一维必须小于 inputShape.size; 注意，如果在索引中有重复项，则更新顺序未定义。
updates要更新到 input 中的张量，dtype 与 input 相同。 shape 为 indicesShape[:-1] + inputShape[indicesShape[-1]:]
useLocking是否通过锁保护分配,类型为：Bool， 默认值：true。

输出：

名称含义
output输出 Tensor。 shape 与 dtype 和 input 相同。

支持平台: GPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = parameter(Tensor(Array<Float32>([-0.1000000015, 0.3000000119, 3.5999999046, 0.4000000060, 0.5000000000, -3.2000000477]), shape: Array<Int64>([2, 3])), "input")
    let indices = parameter(Tensor(Array<Int32>([0, 0, 1, 1]), shape: Array<Int64>([2, 2])), "indices")
    let updates = parameter(Tensor(Array<Float32>([1.0000000000, 2.2000000477]), shape: Array<Int64>([2])), "updates")
    let output = scatterNdUpdate(input, indices, updates)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 3], dtype=Float32, value=
[[ 1.00000000e+00  3.00000012e-01  3.59999990e+00]
 [ 4.00000006e-01  2.20000005e+00 -3.20000005e+00]])

tanh

public func tanh(input: Tensor): Tensor

函数 tanh 实现 Tanh 算子功能，用于对输入 input 进行逐元素的 tanh 运算。

输入：

名称含义
input输入 Tensor，dtype 是 Float32。

输出：

名称含义
output输出 Tensor，与 input 具有相同的 shape 和 dtype。

支持平台：Ascend, GPU, CPU

反向函数：

public func tanhGrad(out: Tensor, gradOut: Tensor): Tensor

微分伴随函数:

public func adjointTanh(x: Tensor)

二阶伴随函数：

public func adjointTanhGrad(out: Tensor, gradOut: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0]), shape: Array<Int64>([5]))
    let output = tanh(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[5], dtype=Float32, value=
[7.61594176e-01 9.64027584e-01 9.95054781e-01 9.99329329e-01 9.99909222e-01])

tensorScatterUpdate

public func tensorScatterUpdate(input: Tensor, indices: Tensor, update: Tensor): Tensor

函数 tensorScatterUpdate 实现 TensorScatterUpdate 算子功能，把 input 中 indices 位置的数据更新为输入的 update, 返回为更新后的 tensor。 注：此算子暂不支持反向。

输入：

名称含义
input输入的 tensor, 数据类型 GPU 支持 Float16\Float32\Float64\Int32\Int64\Bool; Ascend 支持 Float32
indices需要更新的位置索引，数据类型 GPU 支持 Int32,Int64; Ascend 支持 Int32, Int64，维度不小于 2，并且最后一个维度长度不大于 input 的维度大小， 即 indices.shape[-1] <= input.shape.size
update需要更新的数据，数据类型必须和 input 一致，并且形状要满足 update.shape=indices.shape[:1]+input.shape[indices.shape[−1]:]

输出

名称含义
output输出 Tensor, 形状和数据类型和 input 一致，但 indices 位置的数据变为 update 提供的数据了

支持平台：Ascend, GPU

微分伴随函数:

public func adjointTensorScatterUpdate(input: Tensor, indices: Tensor, update: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([-0.1, 0.3, 3.6, 0.4, 0.5, -3.2]), shape: [2, 3])
    let indice = Tensor(Array<Int32>([0]), shape: [1, 1])
    let update = Tensor(Array<Float32>([6.0, 6.0, 6.0]), shape: [1, 3])
    let output = tensorScatterUpdate(input, indice, update)
    print(output)
    return 0
}

输出：

Tensor(shape=[2, 3], dtype=Float32, value=
[[ 6.00000000e+00  6.00000000e+00  6.00000000e+00]
 [ 4.00000006e-01  5.00000000e-01 -3.20000005e+00]])

tile

public func tile(x: Tensor, multiples: Array<Int64>): Tensor

函数 tile 实现 Tile 算子功能，函数按照给定的次数复制输入 Tensor。通过复制 multiples 次 x 来创建新的 Tensor。输出 Tensor 的第 i 维度有 x.getshape()[i] * multiples[i] 个元素，并且 x 的值沿第 i 维度被复制 multiples[i] 次。

输入：

名称含义
x输入的 Tensor, 支持 Float16, Float32, Float64, Int32, bool 类型；反向仅支持 Float16\Float32\Float64。
multiples指定复制的次数， 参数类型为 Array，数据类型为整数。如$[y_1, y_2, \cdots, y_S]$，multiples 的长度不能小于 x 的维度，反向暂时只支持最大维度为 4。

输出：

支持平台：Ascend, GPU, CPU

代码示例 1：

from CangjieTB import common.*
from CangjieTB import ops.*
main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([2, 2]))
    let multiples = Array<Int64>([2, 3])
    let output = tile(input, multiples)
    print(output)
    return 0
}

输出为：

Tensor(shape=[4, 6], dtype=Float32, value=
    [[ 1.00000000e+00  2.00000000e+00  1.00000000e+00  2.00000000e+00  1.00000000e+00  2.00000000e+00]
     [ 3.00000000e+00  4.00000000e+00  3.00000000e+00  4.00000000e+00  3.00000000e+00  4.00000000e+00]
     [ 1.00000000e+00  2.00000000e+00  1.00000000e+00  2.00000000e+00  1.00000000e+00  2.00000000e+00]
     [ 3.00000000e+00  4.00000000e+00  3.00000000e+00  4.00000000e+00  3.00000000e+00  4.00000000e+00]])

topk

public func topK(input: Tensor, k: Int32, sorted: Bool): (Tensor, Tensor)

函数 topK 实现 TopK 算子功能，用于在最后一个轴上查找 k 个最大项的值和索引。

输入：

名称含义
input要计算的输入，只支持 dtype 为 Float32 类型的 Tensor。
k要沿最后一个维度计算的顶层元素数，类型为 Int32 的常量；范围要求大于 0，小于等于 input 最后一个维度的 size。
sorted如果为 true，则结果元素将按值降序排序。

输出：

名称含义
values输出 Tensor，dtype 与 输入 input 一致。沿最后一个维度切片的 k 个最大元素。
indicesdtype 为 Int32 类型的 Tensor，输入的最后一个维度内的值的索引。

支持平台：Ascend, GPU, CPU

微分伴随函数:

public func adjointTopK(input: Tensor, k: Int32, sorted: Bool)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*
main(): Int64
{
    let input = Tensor(Array<Float32>([2.0, 4.0, 1.0, 5.0, 6.0]), shape: Array<Int64>([5]))
    let k = 3
    let sorted = true
    let (values, indices) = topK(input, k, sorted)
    print(values)
    print(indices)
    return 0
}

输出为：

Tensor(shape=[3], dtype=Float32, value=
[6.00000000e+00 5.00000000e+00 4.00000000e+00])
Tensor(shape=[3], dtype=Int32, value=
[4 3 1])

tensorScatterAdd

public func tensorScatterAdd(input: Tensor, indices: Tensor, updates: Tensor): Tensor

函数 tensorScatterAdd 实现 TensorScatterAdd 算子功能，通过将 input 中由 indices 指示的位置的值与 updates 的值相加来创建一个新的张量。当为同一个索引给出多个值时，更新的结果将是所有值的总和。对于每个 indices，updates 中必须有对应的值。updates 的 shape 应该等于 input_x[indices] 的 shape。 此算子反向暂不支持 4-D 以上的输入，且反向暂不支持 indices 为 Int64 类型。 此算子 indices 的值不可为负数；

输入：

名称含义
input输入 Tensor，dtype 为 Float16\Float32\Float64\Int32\Int64， input 的维度必须不小于 indices.shape[indices.shape.size -1]。
indices输入 Tensor 的索引，dtype 为 Int32 或 Int64。rank 必须至少为 2。
updates用于更新输入 Tensor 的 Tensor，dtype 与 input 相同，updates.shape 应该等于 indices.shape[:-1] + input_x.shape[indices.shape[-1]:]。

输出：

名称含义
output输出 Tensor，shape 和 dtype 与 输入 input 一致。

支持平台：Ascend, GPU

微分伴随函数:

public func adjointTensorScatterAdd(input: Tensor, indices: Tensor, updates: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*
main(): Int64
{
    let input_x = parameter(Tensor(Array<Float32>([-0.1000000015, 0.3000000119, 3.5999999046, 0.4000000060, 0.5000000000, -3.2000000477]), shape: Array<Int64>([2, 3])), "input_x")
    let indices = parameter(Tensor(Array<Int32>([0, 0, 0, 0]), shape: Array<Int64>([2, 2])), "indices")
    let updates = parameter(Tensor(Array<Float32>([1.0000000000, 2.2000000477]), shape: Array<Int64>([2])), "updates")
    let output = tensorScatterAdd(input_x, indices, updates)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 3], dtype=Float32, value=
[[ 3.09999990e+00  3.00000012e-01  3.59999990e+00]
 [ 4.00000006e-01  5.00000000e-01 -3.20000005e+00]])

tensorScatterSub

public func tensorScatterSub(input: Tensor, indices: Tensor, updates: Tensor): Tensor

函数 tensorScatterSub 实现 TensorScatterSub 算子功能，通过将 input 中由 indices 指示的位置的值与 updates 的值相减来创建一个新的张量。当为同一个索引给出多个值时，更新的结果将分别减去这些值。对于每个 indices，updates 中必须有对应的值。updates 的 shape 应该等于 input_x[indices] 的 shape。 此算子反向暂不支持 4-D 以上的输入，且反向暂不支持 indices 为 Int64 类型。 此算子 indices 的值不可为负数；

输入：

名称含义
input输入 Tensor，dtype 为 Float16\Float32\Float64\Int32\Int64，input 的维度必须不小于 indices.shape[indices.shape.size -1]。
indices输入 Tensor 的索引，dtype 为 Int32 或 Int64 。rank 必须至少为 2。
updates用于更新输入 Tensor 的 Tensor，dtype 与 input 相同，updates.shape 应该等于 indices.shape[:-1] + input_x.shape[indices.shape[-1]:]。

输出：

名称含义
output输出 Tensor，shape 和 dtype 与 输入 input 一致。

支持平台：Ascend, GPU

微分伴随函数:

public func adjointTensorScatterSub(input: Tensor, indices: Tensor, updates: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*
main(): Int64
{
    let input_x = parameter(Tensor(Array<Float32>([-0.1000000015, 0.3000000119, 3.5999999046, 0.4000000060, 0.5000000000, -3.2000000477]), shape: Array<Int64>([2, 3])), "input_x")
    let indices = parameter(Tensor(Array<Int32>([0, 0, 0, 0]), shape: Array<Int64>([2, 2])), "indices")
    let updates = parameter(Tensor(Array<Float32>([1.0000000000, 2.2000000477]), shape: Array<Int64>([2])), "updates")
    let output = tensorScatterSub(input_x, indices, updates)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 3], dtype=Float32, value=
[[-3.30000019e+00  3.00000012e-01  3.59999990e+00]
 [ 4.00000006e-01  5.00000000e-01 -3.20000005e+00]])

tensorScatterMax

public func tensorScatterMax(input: Tensor, indices: Tensor, updates: Tensor): Tensor

函数 tensorScatterMax 实现 TensorScatterMax 算子功能，通过将 input 中，indices 指示的位置的值与 updates 中的值进行比较，选择最大值更新到指定位置上。 对于每个 indices，updates 中必须有对应的值。updates 的 shape 应该等于 input_x[indices] 的 shape。 此算子反向暂不支持 5-D 以上的输入，且反向暂不支持 indices 为 Int64 类型。

输入：

名称含义
input输入 Tensor，dtype 为 Float16\Float32\Float64\Int32\Int64， input 的维度必须不小于 indices.shape[indices.shape.size -1]。
indices输入 Tensor 的索引，dtype 为 Int32 或 Int64 。rank 必须至少为 2。
updates用于更新输入 Tensor 的 Tensor，dtype 与 input 相同，updates.shape 应该等于 indices.shape[:-1] + input_x.shape[indices.shape[-1]:]。

输出：

名称含义
output输出 Tensor，shape 和 dtype 与 输入 input 一致。

注：反向暂不支持 Float16\Int64 类型

支持平台：GPU

微分伴随函数:

public func adjointTensorScatterMax(input: Tensor, indices: Tensor, updates: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*
main(): Int64
{
    let input_x = parameter(Tensor(Array<Float32>([-0.1000000015, 0.3000000119, 3.5999999046, 0.4000000060, 0.5000000000, -3.2000000477]), shape: Array<Int64>([2, 3])), "input_x")
    let indices = parameter(Tensor(Array<Int32>([0, 0, 0, 0]), shape: Array<Int64>([2, 2])), "indices")
    let updates = parameter(Tensor(Array<Float32>([1.0000000000, 2.2000000477]), shape: Array<Int64>([2])), "updates")
    let output = tensorScatterMax(input_x, indices, updates)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 3], dtype=Float32, value=
[[ 2.20000005e+00  3.00000012e-01  3.59999990e+00]
 [ 4.00000006e-01  5.00000000e-01 -3.20000005e+00]])

tensorScatterMin

public func tensorScatterMin(input: Tensor, indices: Tensor, updates: Tensor): Tensor

函数 tensorScatterMin 实现 TensorScatterMin 算子功能，函通过将 input 中，indices 指示的位置的值与 updates 中的值进行比较，选择最小值更新到指定位置上。 对于每个 indices，updates 中必须有对应的值。updates 的 shape 应该等于 input_x[indices] 的 shape。 此算子反向暂不支持 5-D 以上的输入，且反向暂不支持 indices 为 Int64 类型。

输入：

名称含义
input输入 Tensor，dtype 为 Float16\Float32\Float64\Int32\Int64， input 的维度必须不小于 indices.shape[indices.shape.size -1]。
indices输入 Tensor 的索引，dtype 为 Int32 或 Int64 。rank 必须至少为 2。
updates用于更新输入 Tensor 的 Tensor，dtype 与 input 相同，updates.shape 应该等于 indices.shape[:-1] + input_x.shape[indices.shape[-1]:]。

输出：

名称含义
output输出 Tensor，shape 和 dtype 与 输入 input 一致。

支持平台：GPU

微分伴随函数:

public func adjointTensorScatterMin(input: Tensor, indices: Tensor, updates: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*
main(): Int64
{
    let input_x = parameter(Tensor(Array<Float32>([-0.1000000015, 0.3000000119, 3.5999999046, 0.4000000060, 0.5000000000, -3.2000000477]), shape: Array<Int64>([2, 3])), "input_x")
    let indices = parameter(Tensor(Array<Int32>([0, 0, 0, 0]), shape: Array<Int64>([2, 2])), "indices")
    let updates = parameter(Tensor(Array<Float32>([1.0000000000, 2.2000000477]), shape: Array<Int64>([2])), "updates")
    let output = tensorScatterMin(input_x, indices, updates)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 3], dtype=Float32, value=
[[-1.00000001e-01  3.00000012e-01  3.59999990e+00]
 [ 4.00000006e-01  5.00000000e-01 -3.20000005e+00]])

transpose

public func transpose(input: Tensor, inputPerm: Array<Int64>): Tensor

函数 transpose 实现 Transpose 算子功能。

输入：

名称含义
input输入 Tensor, 支持所有类型的 Tensor。
inputPermInt64 的数组，表示调整规则。inputPerm 的长度和 input 的 shape 维度必须相同。 取值必须在 [0, rank(input)) 范围内。

输出：

名称含义
output输出 Tensor，dtype 与 input 相同，输出 Tensor 的 shape 由 input 的 shape 和 inputPerm 的值确定。

支持平台：Ascend, GPU, CPU

微分伴随函数:

public func adjointTranspose(x: Tensor, inputPerm: Array<Int64>)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([2, 2]))
    let intputPerm = Array<Int64>([1, 0])
    let output = transpose(input, intputPerm)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[1.00000000e+00 3.00000000e+00]
 [2.00000000e+00 4.00000000e+00]])

truncateDiv

public func truncateDiv(input1: Tensor, input2: Tensor): Tensor
public func truncateDiv(input1: Tensor, input2: Int32): Tensor
public func truncateDiv(input1: Int32, input2: Tensor): Tensor
public func truncateDiv(input1: Tensor, input2: Int64): Tensor
public func truncateDiv(input1: Int64, input2: Tensor): Tensor
public func truncateDiv(input1: Tensor, input2: Float16): Tensor
public func truncateDiv(input1: Float16, input2: Tensor): Tensor
public func truncateDiv(input1: Tensor, input2: Float32): Tensor
public func truncateDiv(input1: Float32, input2: Tensor): Tensor
public func truncateDiv(input1: Tensor, input2: Float64): Tensor
public func truncateDiv(input1: Float64, input2: Tensor): Tensor
public func truncateDiv(input1: Tensor, input2: Bool): Tensor
public func truncateDiv(input1: Bool, input2: Tensor): Tensor

函数 truncateDiv 实现 TruncateDiv 算子功能，用于计算第一个输入与第二个输入逐个元素相除，当输入为 Int32 类型的 Tensor 时，结果并向 0 取整。输入可以是 Tensor 或者标量，但不能同时为标量。当输入为两个 Tensor 时，其 shape 必须可以进行 broadcast。

输入：

名称含义
input1第一个输入 Tensor。GPU 支持 Float16\Float32\Float64\Int32\Int64\Bool 类型的 number 或 tensor, Ascend 支持 Float32\Int32 类型，两个输入的 dtype 必须相同。
input2第二个输入 Tensor。两个输入的 dtype 必须相同。

输出：

名称含义
output相除的 Tensor，数据类型和形状与 broadcast 后的输入相同。

支持平台：Ascend, GPU

微分伴随函数：

public func adjointTruncateDiv(input1: Tensor, input2: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let input1 = Tensor(Array<Int32>([1, 2, 3, -1, -2, -3]), shape: Array<Int64>([6]))
    let input2 = Tensor(Array<Int32>([3, 3, 3, 3, 3, 3]), shape: Array<Int64>([6]))
    let output = truncateDiv(input1, input2)
    print(output)
    return 0
}

输出为：

Tensor(shape=[6], dtype=Int32, value=
[0 0 1 0 0 -1])

truncateMod

public func truncateMod(input1: Tensor, input2: Tensor): Tensor
public func truncateMod(input1: Tensor, input2: Float16): Tensor
public func truncateMod(input1: Float16, input2: Tensor): Tensor
public func truncateMod(input1: Tensor, input2: Float32): Tensor
public func truncateMod(input1: Float32, input2: Tensor): Tensor
public func truncateMod(input1: Tensor, input2: Float64): Tensor
public func truncateMod(input1: Float64, input2: Tensor): Tensor
public func truncateMod(input1: Tensor, input2: Int32): Tensor
public func truncateMod(input1: Int32, input2: Tensor): Tensor

函数 truncateMod 实现 TruncateMod 算子功能，用于计算第一个输入与第二个输入逐个元素求模，支持 Float32 和 Int32 类型。当输入为 Float32 类型时，因为 Float32 的有效数字只有 6 位，计算结果打印出来 6 位之后的数据可能不准确。输入可以是 Tensor 或者标量，但不能同时为标量。当输入为两个 Tensor 时，其 shape 必须可以进行 broadcast。

输入：

名称含义
input1第一个输入。GPU 支持 Float16\Float32\Float64\Int32 类型的 number 或 tensor, Ascend 支持 Float32\Int32 类型。
input2第二个输入。类型必须和 input1 一致。

输出：

名称含义
output相除的 Tensor，数据类型和形状与输入相同。

支持平台：Ascend, GPU

微分伴随函数：

public func adjointTruncateMod(input1: Tensor, input2: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64 {
    let x1 = Tensor(Array<Float32>([0.0347052291, -0.6000000, 0.5798667073, -0.55000, 0.0335827433]), shape: [5])
    let y1 = Tensor(Array<Float32>([-0.2082750499, -0.250000, 0.7290703654, 0.050000, 0.2802773118]), shape: [5])
    let output1 = truncateMod(x1, y1)
    print(output1)
    let x2 = Tensor(Array<Int32>([1, 2, 3, -1, -2, -3]), shape: [6])
    let y2 = Tensor(Array<Int32>([3, 3, 3, 3, 3, 3]), shape: [6])
    let output2 = truncateMod(x2, y2)
    print(output2)
    return 0
}

输出为：

Tensor(shape=[5], dtype=Float32, value=
[3.47052291e-02 -1.00000024e-01 5.79866707e-01 -3.72529030e-09 3.35827433e-02])
Tensor(shape=[6], dtype=Int32, value=
[1 2 0 -1 -2 0])

uniformInt

public func uniformInt(shape: Array<Int64>, low: Tensor, high: Tensor, seed!: Int64 = 0, seed2!: Int64 = 0): Tensor

函数 uniformInt 实现 UniformInt 算子功能，用于生成整形均匀分布随机数。该整数值 i 均匀分布在闭合间隔 [low，high）上，即根据离散概率函数分布：

P(i|a,b)=1b−a+1,

输入：

名称含义
shape指定输出 Tensor 的 shape。
low均匀分布下界，dtype 是 Int32，仅支持 scaler tensor。
high均匀分布上界，dtype 是 Int32，仅支持 scaler tensor。
seed随机数种子。必须 >=0, 默认值：0。
seed2随机数种子 2。必须 >=0, 默认值：0。

输出：

名称含义
output输出 Tensor，dtype 是 Int32，shape 是输入的 shape。

支持平台：Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let shape = Array<Int64>([5])
    let low = Tensor(Int32(1))
    let high = Tensor(Int32(10))
    let seed = 2
    let output = uniformInt(shape, low, high, seed: seed)
    print(output)
    return 0
}

输出为：

Tensor(shape=[5], dtype=Int32, value=
[3 2 7 6 8])

uniformReal

public func uniformReal(shape: Array<Int64>, seed!: Int64 = 0, seed2!: Int64 = 0): Tensor

函数 uniformReal 实现 UniformReal 算子功能，用于生成实数型均匀分布随机数。

输入：

名称含义
shape指定输出 Tensor 的 shape。
seed随机数种子。必须 >=0, 默认值：0。
seed2随机数种子 2。必须 >=0, 默认值：0。

输出：

名称含义
output输出 Tensor，dtype 是 Float32，shape 根据输入的 shape。

支持平台：Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let shape = Array<Int64>([5])
    let seed = 2
    let output = uniformReal(Array<Int64>([5]), seed: seed)
    print(output)
    return 0
}

输出为：

Tensor(shape=[5], dtype=Float32, value=
[3.04325491e-01 1.38403744e-01 7.46221542e-01 5.87218642e-01 7.81347454e-01])

unsortedSegmentMax

public func unsortedSegmentMax(input: Tensor, segmentIds: Tensor, numSegments: Int64): Tensor

函数 unsortedSegmentMax 实现 UnsortedSegmentMax 算子功能，对比 input 中相同 segmentIds 的 segment, 取最大值，返回一个 Tensor

注：如果 input 中找不到 segmentIds 中对应的 segment, 则对应的输出为该数据类型下的最小值，见例 2。

输入：

名称含义
input输入的 Tensor，shape 为 [x1, x2, …, xR]， 数据类型 GPU 支持 Float32, Int32; Ascend 正向支持 Float32，Int32, 反向支持 Float32
segmentIds必须是 1 维 Tensor，且长度等于 input 第一个维度的长度，即 shape 为 [x1], 数据类型只能是 Int32。cpu 平台中 segmentIds 的值必须在 [0, numSegments) 范围内。
numSegmentssegmentIds 中不重复数据的个数, 数值非负。

输出：

名称含义
output输出 Tensor, shape 为 [N, x2, …, xR], N = numSegments

支持平台：Ascend, GPU, CPU 注：Ascend 平台时，numSegments 值过大时，可能因内存不足而运行失败。

反向函数：

public func unsortedSegmentMinorMaxGrad(input: Tensor, segmentIds: Tensor, numSegments: Int64, out: Tensor, dout: Tensor): Tensor

微分伴随函数:

public func adjointUnsortedSegmentMax(input: Tensor, segmentIds: Tensor, numSegments: Int64)

代码示例 1：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 4.0, 2.0, 1.0]), shape: [3, 3])
    let segmentIds = Tensor(Array<Int32>([0, 1, 1]), shape: [3])
    let numSegments = 2
    let output = unsortedSegmentMax(input, segmentIds, numSegments)
    print(output)
    return 0
}

输出：

Tensor(shape=[2, 3], dtype=Float32, value=
[[ 1.00000000e+00  2.00000000e+00  3.00000000e+00]
 [ 4.00000000e+00  5.00000000e+00  6.00000000e+00]])

代码示例 2：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Int32>([1, 2, 3, 4, 2, 0, 4, 5, 6, 4, 2, 1]), shape: [4, 3])
    let segmentIds = Tensor(Array<Int32>([0, 0, 0, 5]), shape: [4])
    let numSegments = 2
    let output = unsortedSegmentMax(input, segmentIds, numSegments)
    print(output)
    return 0
}

输出：

Tensor(shape=[2, 3], dtype=Int32, value=
[[          4           5           6]
 [-2147483648 -2147483648 -2147483648]])

unsortedSegmentMin

public func unsortedSegmentMin(input: Tensor, segmentIds: Tensor, numSegments: Int64): Tensor

函数 unsortedSegmentMin 实现 UnsortedSegmentMin 算子功能，对比 input 中相同 segmentIds 的 segment, 取最小值，返回一个 Tensor

注：如果 input 中找不到 segmentIds 中对应的 segment, 则对应的输出为该数据类型下的最大值，见例 2

输入：

名称含义
input输入的 Tensor，shape 为 [x1, x2, …, xR]， 数据类型 GPU 支持 Float32, Int32; Ascend 正向支持 Float32，Int32, 反向支持 Float32
segmentIds必须是 1 维 Tensor，且长度等于 input 第一个维度的长度，即 shape 为 [x1], 数据类型只能是 Int32
numSegmentssegmentIds 中不重复数据的个数, 数值非负

输出：

名称含义
output输出 Tensor, shape 为 [N, x2, …, xR], N = numSegments

支持平台：Ascend, GPU, CPU

注：Ascend 平台时，numSegments 值过大时，可能因内存不足而运行失败。

反向函数：

public func unsortedSegmentMinorMaxGrad(input: Tensor, segmentIds: Tensor, numSegments: Int64, out: Tensor, dout: Tensor): Tensor

微分伴随函数:

public func adjointUnsortedSegmentMin(input: Tensor, segmentIds: Tensor, numSegments: Int64)

代码示例 1：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 4.0, 2.0, 1.0]), shape: [3, 3])
    let segmentIds = Tensor(Array<Int32>([0, 1, 1]), shape: [3])
    let numSegments = 2
    let output = unsortedSegmentMin(input, segmentIds, numSegments)
    print(output)
    return 0
}

输出：

Tensor(shape=[2, 3], dtype=Float32, value=
[[ 1.00000000e+00  2.00000000e+00  3.00000000e+00]
 [ 4.00000000e+00  2.00000000e+00  1.00000000e+00]])

代码示例 2：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Int32>([1, 2, 3, 4, 2, 0, 4, 5, 6, 4, 2, 1]), shape: [4, 3])
    let segmentIds = Tensor(Array<Int32>([0, 0, 0, 0]), shape: [4])
    let numSegments = 2
    let output = unsortedSegmentMin(input, segmentIds, numSegments)
    print(output)
    return 0
}

输出：

Tensor(shape=[2, 3], dtype=Int32, value=
[[         1          2          0]
 [2147483647 2147483647 2147483647]])

unsortedSegmentSum

public func unsortedSegmentSum(input: Tensor, segmentIds: Tensor, numSegments: Int64): Tensor

函数 unsortedSegmentSum 实现 UnsortedSegmentSum 算子功能，用于对输入 input 按照 segmentIds 进行累加计算。

【备注】：如果输入的 numSegments 不在 segmentIds 中，将用 0 填充。

输入：

名称含义
input输入 Tensor，GPU & CPU 支持 Float32\Float64\Int32 类型，Ascend 支持 Float32\Int32 类型。
segmentIds指定累加的 segment，dtype 是 Int32，shape 的长度 > 0 小于等于 input 的长度。
numSegments设置累加的字段。

输出：

支持平台：Ascend, GPU, CPU

微分伴随函数:

public func adjointUnsortedSegmentSum(input: Tensor, segmentIds: Tensor, numSegments: Int64)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([4]))
    let value: Array<Int32> = Array<Int32>([0, 0, 1, 2])
    let segmentIds =Tensor(value, shape: Array<Int64>([4]))
    let numSegments = 4
    let output = unsortedSegmentSum(input, segmentIds, numSegments)
    print(output)
    return 0
}

输出为：

Tensor(shape=[4], dtype=Float32, value=
[3.00000000e+00 3.00000000e+00 4.00000000e+00 0.00000000e+00])

unstack

public func unstack(input: Tensor, axis!: Int64 = 0): Tensor

函数 unstack 实现 Unstack 算子功能，用于在指定轴上对 Tensor 进行拆分。和 Stack 的操作相反，两者互为反向算子。

输入：

名称含义
input输入 tensor, GPU & CPU 支持 Float32\Int32\Bool, Ascend 支持 Float32\Int32。
axisUnstack 参考轴，范围 [-R, R)，其中 R 是 input 的 rank，axis 默认取 0。

输出：

名称含义
output拆分后的 Tuple Tensor，和 input 具有相同的 dtype，rank 是（R – 1）。
支持平台：Ascend, GPU, CPU

微分伴随函数:

public func adjointUnstack(input: Tensor, axis!: Int64 = 0)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0]), shape: Array<Int64>([2, 2]))
    let axis = 1
    let output = unstack(input, axis: axis)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2], dtype=Float32, value=
[1.00000000e+00 3.00000000e+00])
Tensor(shape=[2], dtype=Float32, value=
[2.00000000e+00 4.00000000e+00])

While

public func While(cond: Tensor, body: Array<Tensor>, tail: Tensor, vars: Array<Tensor>): Tensor

函数 While 用于生成循环控制流。

条件与限制：

1）当前 While 仅可对接单 While，不支持 While 内部包含 While 和 If 的情况。

2）当前 While 不支持自动微分。

3）当前结果可以与 mindspore while 用例结果保持一致。

4）当前不支持 Eager 模式运行，使用时需要将环境变量 CANGJIETB_GRAPH_MODE=true 设置为静态图模式。

输入：

名称含义
cond循环终止条件，Tensor 类型，通常是比较运算的结果。
body循环体。
tail循环尾计算。
vars循环需要的变量。

输出

vars 是 while 所需要的初始变量的值，body 是进入 while 循环体后，返回的一组新的变量列表的值，与 vars 个数以及类型要保持一致，相当于更新了一遍 vars 的值。

解释说明：（与限制冲突无法得到正确的结果）

  1. vars 包含的初始变量和 body 返回的更新后变量必须一一对应。
  2. vars 要包含所有循环需要使用的变量，包含循环条件和循环体的变量。
  3. vars 不可以包含非 Parameter 的 Tensor
  4. 如果 while 循环需要的变量没有修改，也需要将变量写到 body 的 return 中。
  5. body 不可以捕获闭包外面的变量，body 的入参即是 vars 变量的值。
  6. 如果 z 使用 x 进行初始化，需要将 z 初始化为 x 的初始值，如示例 3。

下面提供 4 个示例代码：

运行下面的示例代码前，需要先导入依赖包，并将 context 设置为非 eager 模式。

from CangjieTB import common.*
from CangjieTB import ops.*
from CangjieTB import context.g_context

main(): Int64 {
    let ret = TestWhile()
    print(ret)
    return 0
}

示例 1：

仓颉 While：循环变量 x，y，循环体内 x 更新，y 不更新，返回 x。

func TestWhile(): Float32
{
    var x = 1.0
    var y = 10.0
    while (x < y) {
        x = x + 2.0
    }
    return x
}

对应的 While 实现:

func TestWhile(): Tensor
{
    var x = parameter(Tensor(Float32(1.0)), "x")
    var y = parameter(Tensor(Float32(10.0)), "y")
    var body = {x: Tensor, y: Tensor =>
        var x_new = x + Float32(2.0)
        return [x_new, y]
    }
    var whileRes = While(x < y, body(x, y), x, [x, y])
    return whileRes.evaluate()
}

输出为：

Tensor(shape=[1], dtype=Float32, value= [1.10000000e+01])

示例 2：

仓颉 While：循环变量 x，y，循环体内 x 更新，y 更新，返回 x + 5。

func TestWhile(): Float32
{
    var x = 1.0
    x = x + 2.0
    var y = 10.0
    while (x < y) {
        x = x + 3.0
        y = y + 1.0
    }
    return x + 5.0
}

对应的 While 实现:

func TestWhile(): Tensor
{
    var x = parameter(Tensor(Float32(1.0)), "x")
    x = x + Float32(2.0)
    var y = parameter(Tensor(Float32(10.0)), "y")
    var body = {x: Tensor, y: Tensor =>
        var x_new = x + Float32(3.0)
        var y_new = y + Float32(1.0)
        return [x_new, y_new]
    }
    var whileRes = While(x < y, body(x, y), x + Float32(5.0), [x, y])
    return whileRes.evaluate()
}

输出为：

Tensor(shape=[1], dtype=Float32, value= [2.00000000e+01])

示例 3：

仓颉 While：循环变量 x，y，z，循环体内 x 更新，y 不更新，z 更新，返回 x + z。

func TestWhile(): Float32
{
    var x = 1.0
    var y = 10.0
    var z = x
    while (x < y) {
        x = x + 2.0
        z = z + 1.0
    }
    return x + z
}

对应的 While 实现:

func TestWhile(): Tensor
{
    var x = parameter(Tensor(Float32(1.0)), "x")
    var y = parameter(Tensor(Float32(10.0)), "y")
    var z = parameter(Tensor(Float32(1.0)), "z")
    var body = {x: Tensor, y: Tensor, z: Tensor =>
        var x_new = x + Float32(2.0)
        var z_new = z + Float32(1.0)
        return [x_new, y, z_new]
    }
    var whileRes = While(x < y, body(x, y, z), x + z, [x, y, z])
    return whileRes.evaluate()
}

输出为：

Tensor(shape=[1], dtype=Float32, value= [1.70000000e+01])

示例 4：

仓颉 While：循环变量 x，y，循环体内 x 更新，y 更新，返回 x。

func TestWhile(): Float32
{
    var x = 1.0
    var y = 10.0
    while (x < y) {
        x = x + 2.0
        y = y + 1.0
        x = x + y
    }
    return x
}

对应的 While 实现:

func TestWhile(): Tensor
{
    var x = parameter(Tensor(Float32(1.0)), "x")
    var y = parameter(Tensor(Float32(10.0)), "y")
    var body = {x: Tensor, y: Tensor =>
        var x_new = x + Float32(2.0)
        var y_new = y + Float32(1.0)
        x_new = x_new + y_new
        return [x_new, y_new]
    }
    var whileRes = While(x < y, body(x, y), x, [x, y])
    return whileRes.evaluate()
}

输出为：

Tensor(shape=[1], dtype=Float32, value= [1.40000000e+01])

zeros

public func zeros(shape: Array<Int64>, dtype: Int32): Tensor

函数 zeros 用于根据输入的 shape 和 dtype 构造全 0 Tensor。

输入：

名称含义
shape输出 Tensor 的形状，必须是正整型数据
dtype输出 Tensor 的数据类型，可选类型 FLOAT16，FLOAT32, FLOAT64, INT32, INT64, BOOL

输出：

名称含义
output输出的 Tensor, 其 shape 和 dtype 和输入的一致

支持平台：Ascend, GPU, CPU

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let shape = Array<Int64>([2, 2])
    let dtype = Int32(FLOAT32)
    let output = zeros(shape, dtype)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 2], dtype=Float32, value=
[[0.00000000e+00 0.00000000e+00]
 [0.00000000e+00 0.00000000e+00]])

zerosLike

public func zerosLike(input: Tensor): Tensor

函数 zerosLike 用于根据输入 Tensor 的 shape 和 dtype 构造全 0 Tensor。

输入：

输出：

名称含义
output输出 Tensor，其 shape 和 dtype 跟 input 相同。

支持平台：Ascend, GPU, CPU

微分伴随函数:

public func adjointZerosLike(x: Tensor)

代码示例：

from CangjieTB import common.*
from CangjieTB import ops.*

main(): Int64
{
    let input = Tensor(Array<Float32>([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]), shape: Array<Int64>([2, 3]))
    let output = zerosLike(input)
    print(output)
    return 0
}

输出为：

Tensor(shape=[2, 3], dtype=Float32, value=
[[0.00000000e+00 0.00000000e+00 0.00000000e+00]
 [0.00000000e+00 0.00000000e+00 0.00000000e+00]])
Rate this post
阅读量: 176
发表回复 0