附录 D 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 元素的绝对值。

输入：

输出：

支持平台：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 值。

输入：

输出：

支持平台：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

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

$$ out_i = cosh^{-1}(input_i) $$

输入：

输出：

支持平台：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

更新公式如下:

$$ \begin{split}\begin{array}{ll} \ m = \beta_1 * m + (1 - \beta_1) * g \ v = \beta_2 * v + (1 - \beta_2) * g * g \ update = \frac{m}{\sqrt{v} + \epsilon} \ update = \begin{cases} update + weight_decay * w & \text{ if } weight_decay > 0 \ update & \text{ otherwise } \end{cases} \ w = w - lr * update \end{array}\end{split}\ $$

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

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

输入：

输出：

支持平台：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 和一个标量时，这个标量只能是一个常数。

输入：

输出：

支持平台：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]。

计算公式如下所示：

$$ \begin{split}\begin{align} h_{start} &= floor(i * H_{in} / H_{out})\ h_{end} &= ceil((i + 1) * H_{in} / H_{out})\ w_{start} &= floor(j * W_{in} / W_{out})\ w_{end} &= ceil((j + 1) * W_{in} / W_{out})\ Output(i,j) &= \frac{\sum Input[h_{start}:h_{end}, w_{start}:w_{end}]}{(h_{end}- h_{start}) * (w_{end}- w_{start})} \end{align}\end{split} $$

输入：

输出：

支持平台：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 必须相同。

输入：

输出：

支持平台：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

输入：

输出：

支持平台：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 算子功能，用于归并所有设备的张量数据，以保证所有设备可以获得相同的结果，通常用在并行训练中。

输入：

输出：

支持平台：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 算法实现公式如下:

$$ g_{t} = \rho g_{t-1} + (1 - \rho)\nabla Q_{i}(w) \ s_{t} = \rho s_{t-1} + (1 - \rho)(\nabla Q_{i}(w))^2\ m_{t} = \beta m_{t-1} + \frac{\eta} {\sqrt{s_{t} - g_{t}^2 + \epsilon}} \nabla Q_{i}(w)\ w = w - m_{t}\ $$

其中：$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。

输入：

输出：

支持平台：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 方案更新相关实例

$$ \begin{array}\ accum += gradient * gradient \ input -= lr * gradient * \frac{1}{\sqrt{accum}} \end{array} $$

输入：

输出：

支持平台：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。其计算过程如下：

$$ \begin{aligned} m_{t+1} &= m_{t} + g^2 \ u_{t+1} &= u_{t} + g - \frac{m_{t+1}^\text{-p} - m_{t}^\text{-p}}{\alpha } * \omega_{t} \ \omega_{t+1} &= \begin{cases} \frac{(sign(u_{t+1}) * l1 - u_{t+1})}{\frac{m_{t+1}^\text{-p}}{\alpha } + 2 * l2 } & \text{ if } |u_{t+1}| > l1 \ 0.0 & \text{ otherwise } \end{cases}\ \end{aligned} $$

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

参数列表：

输入：

输出：

支持平台：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 $$

$$ \alpha 代表 alpha, \delta 代表 delta $$

输入：

输出：

支持平台：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)算法优化器，实现算法如下：

$$ s_{t+1} = \rho s_{t} + (1 - \rho)(\nabla Q_{i}(w))^2 \ m_{t+1} = \beta m_{t} + \frac{\eta} {\sqrt{s_{t+1} + \epsilon}} \nabla Q_{i}(w) \ w = w - m_{t+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。

参数列表：

输入：

输出：

支持平台：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 维。

输入：

输出：

支持平台：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 模式下，不能使用第一个输出索引。

参数列表：

输入：

输出：

支持平台：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 的维度。

参数列表：

输入：

输出：

支持平台：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 算子功能，用于计算输入的反正弦。

输入：

输出：

支持平台：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 算子功能，用于计算输入的反双曲正弦。

输入：

输出：

支持平台：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 算子功能，用于给参数赋值。

输入：

输出：

支持平台：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 算子功能，用于做参数的自增计算。

输入：

输出：

支持平台：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 的三角反正切值。

输入：

输出：

支持平台：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 类型的输入。

输入：

输出：

支持平台：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)={1\over hker∗wker}\sum_{m=0}^{hker−1}\sum_{n=0}^{wker−1}input(Ni,Cj,s0×h+m,s1×w+n) $$

参数列表：

输入：

输出：

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 个元素相等。

参数列表：

输入：

输出：

支持平台：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 = \frac{x - mean}{\sqrt{variance + \epsilon}} * \gamma + \beta $$

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

$$ new_running_mean = (1 - momentum) * running_mean + momentum * current_mean $$

参数列表：

输入：

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

支持平台：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//(blockSizeblockSize) \ cOut &= cIn \ hOut &= hInblockSize-crops[0][0]-crops[0][1] \ wOut &= wIn*blockSize-crops[1][0]-crops[1][1] \end{aligned}\end{split} $$

参数列表：

输入：

输出：

支持平台：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 &= hInblockShape[0]-crops[0][0]-crops[0][1] \ wOut &= wInblockShape[1]-crops[1][0]-crops[1][1] \end{aligned}\end{split} $$

输入：

输出：

支持平台：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 的第一维的长度相等。

参数列表：

输出：

支持平台：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

对边界框的位置解码。

参数列表：

输入：

输出：

支持平台：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

对边界框的位置编码。

参数列表：

输入：

输出：

支持平台：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 广播到整组

输入：

输出：

支持平台：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 的维度值不变。

参数列表：

输入：

输出：

支持平台：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 的数据类型。

输入：

输出：

支持平台：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）。

输入：

输出：

支持平台：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 维进行合并，则输出维度如下：

$$ (x_1, x_2, ..., \sum_{i=1}^Nx_{mi}, ..., x_R) $$

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

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

输入：

输出：

支持平台：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 卷积运算。

参数列表：

输出：

支持平台：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 卷积运算。

参数列表：

输入：

输出：

支持平台：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 算子功能，用于计算输入数据的余弦。

输入：

输出：

支持平台：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 进行裁剪，然后调整图片尺寸大小。

参数列表：

输入：

输出：

支持平台：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 和梯度。

参数列表：

输入：

输出：

输入要求：

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 沿轴的累积积。

参数列表：

输入：

输出：

支持平台：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 沿轴的累积总和。

参数列表：

输入：

输出：

支持平台：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//(blockSizeblockSize) \ hOut &= hInblockSize \ wOut &= wIn*blockSize \end{aligned}\end{split} $$

参数列表：

输入：

输出：

支持平台：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。

输入：

输出：

支持平台：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 计算得到的输出。

输入：

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

支持平台：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 从伯努利分布中随机将输入张量的一些通道归零。

输入：

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

支持平台：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 场景。

输入：

输出：

支持平台：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} $$

输入：

输出：

支持平台：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 平台只支持静态图模式。

输入：

输出：

支持平台：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。

输入：

输出：

支持平台：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 值。

输入：

输出：

支持平台：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 元素的个数。

输入：

输出：

支持平台：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 - \frac{2} {\sqrt{\pi}} \int\limits_0^{x} e^{-t^{2}} dt $$

输入：

输出：

支持平台：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}$。

输入：

输出：

支持平台：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 算子功能，用来对输入在指定维度扩维。

参数列表：

输出：

支持平台：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 维外的其他维度。

输入：

输出：

支持平台：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 进行判断，是否存在下溢或者上溢。

输入：

输出：

支持平台：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 向下舍入到最接近的整数元素。

输入：

输出：

支持平台：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。

输入：

输出：

支持平台：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。

输入：

输出：

支持平台：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 中的某些值。

输入：

输出：

支持平台：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])。

输入：

输出：

支持平台：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 的计算公式为：

$$ indices_shape[:-1] + x_shape[indices_shape[-1]:] $$

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

输入：

输出：

支持平台：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 是一种常见的激活函数。

输入：

输出：

支持平台：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。

输入：

输出：

支持平台：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。

输入：

输出：

支持平台：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。

输入：

输出：

支持平台：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 定义为：

$$ \text{hsigmoid}(x_{i}) = max(0, min(1, \frac{x_{i} + 3}{6})) $$

输入：

输出：

支持平台：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 定义为：

$$ \text{hardswish}(x_{i}) = x_{i} * \frac{ReLU6(x_{i} + 3)}{6} $$

输入：

输出：

支持平台：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

输入：

输出：

支持平台：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 代表两个矩阵的交集在正确的矩阵上的比例

$$ \begin{align}\begin{aligned}\text{IOU} = \frac{\text{Area of Overlap}}{\text{Area of Union}}\text{IOF} = \frac{\text{Area of Overlap}}{\text{Area of Ground Truth}}\end{aligned}\end{align} $$

输入：

输出：

支持平台：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。

输入：

输出：

支持平台：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。

输入：

输出：

支持平台：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。

输入：

输出：

支持平台：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。

输入：

输出

支持平台：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。

输入：

输出：

支持平台：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, \quad i \in [0, 1, \ldots, \text{len}(x)-1] $$

输入：

输出：

支持平台：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 = {l_1,\dots,l_N}^\top, \quad l_n = y_n \cdot (\log y_n - x_n)\ Then, \begin{split}\ell(x, y) = \begin{cases} L, & \text{if reduction} = \text{'none';}\ \operatorname{mean}(L), & \text{if reduction} = \text{'mean';}\ \operatorname{sum}(L), & \text{if reduction} = \text{'sum'.} \end{cases}\end{split}\ x 代表 logits. y 代表 labels. ℓ(x,y) 代表 output. $$

输入：

输出：

支持平台：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。

输入：

输出：

支持平台：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。

输入：

输出：

支持平台：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 算子功能，用于计算两个输入的 “逻辑与” 运算。

输入：

输出：

支持平台：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 的取反计算。

输入：

输出：

支持平台：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 算子功能，用于计算两个输入的 “逻辑或” 运算。

输入：

输出：

支持平台：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 计算。

输入：

输出：

支持平台：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 的计算。计算公式如下：

$$ out_i = {log_e}(x_i + 1) $$

输入：

输出：

支持平台: 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(x_i)=log({exp(x_i)\over \sum_{j=0}^{N−1}exp(x_j)}), $$

输入：

输出：

支持平台：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− \text{mean} \over \sqrt {\text{variance}+ϵ}}∗\gamma+\beta $$

输入：

输出：

支持平台：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 的等差数列。

输入：

输出：

支持平台：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 功能，用于数据的归一化。计算过程如下：

$$ b_{c} = a_{c}\left(k + \frac{\alpha}{n} \sum_{c'=\max(0, c-n/2)}^{\min(N-1,c+n/2)}a_{c'}^2\right)^{-\beta} $$

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

参数列表：

输入：

输出：

支持平台：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)

输入：

输出：

反向函数：

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 标准化。

参数列表：

输入：

输出：

支持平台：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 算子功能，完成两个二维矩阵相乘运算。

输入：

支持平台：Ascend, GPU, CPU

输出：

代码示例：

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 最大值池化操作。

输入：

输出：

支持平台：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 最大值池化操作。

输入：

输出：

支持平台：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 合并成一个元组。

输入：

输出：

支持平台：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 不可逆，将会报错或返回未知结果

输入：

输出:

支持平台: 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 算子功能，用于计算最大值池化运算。

输入：

【注意】：

• same：采用完成方式。 输出的高度和宽度将与输入的高度和宽度相同。 填充的总数将在水平和垂直方向上计算，并在可能的情况下均匀分布在顶部和底部，左侧和右侧。 否则，最后的额外填充将从底部和右侧开始。
• valid：采用丢弃方式。 可能的最大输出高度和宽度将返回，而不会填充。 多余的像素将被丢弃。

输出：

支持平台：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。

输入：

支持平台：Ascend, GPU, CPU

输出：

支持平台：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 网格上计算表达式

输入：

输出：

支持平台: 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。

输入：

输出：

支持平台：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 进行扩充

输入：

输出

支持平台：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。

输入：

输出：

支持平台：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 和一个标量，那么标量只能是一个常数。

输入：

输出：

支持平台：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 输出对输入张量的对应行进行采样的张量，采样的方式服从多项式概率分布。

参数列表：

输入：

输出：

支持平台：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 的取负值。

输入：

输出：

支持平台：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 计算公式为:

$$ \text{IOU} = \frac{\text{Area of Overlap}}{\text{Area of Union}} $$

参数列表：

输入：

输出：

支持平台：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 值。

输入：

输出：

支持平台：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 输出。

输入：

输出：

支持平台：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 张量

输入：

输出：

支持平台: 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。

输入：

输出：

支持平台：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 进行扩充

输入：

输出：

支持平台：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, y 的 shape 需要买满足可广播的要求；且 x, y 只能有一个为标量。

输出：

支持平台：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(x_i)= \max(0, x_i) + \min(0, w * x_i) $$

输入：

输出：

支持平台：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 输出对输入张量的对应行进行采样的张量，采样的方式服从分类分布。

参数列表：

输入：

输出：

支持平台：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 输出对输入张量的对应行进行采样的索引张量以及一个掩码张量。

参数列表：

输入：

输出：

支持平台：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，

输入：

输出：

支持平台: 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 代替

输入：

【注意】： UInt32 取值范围为[0,4294967295], 当 dtype 为 UInt32, pad 输入在取值范围外时, pad 被 UInt32 最大值(4294967295)代替。

支持平台: Ascend, GPU

输出：

代码示例：

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。两个输入的数据类型需一致。

输入：

输出：

支持平台：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 的规则进行降维操作。

输入：

输出：

【注意】：

• 如果 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 的规则进行降维操作。

输入：

输出：

【注意】：

• 如果 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 在指定维度上的最大值。

输入：

输出：

支持平台：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 进行取平均运算。

参数列表：

输出：

支持平台：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 在指定维度上的最小值。

输入：

输出：

【注意】：

• 如果 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 在指定维度上的乘积。

输入：

输出：

【注意】：

• 如果 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

输入：

输出：

支持平台：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 进行求和运算。

参数列表：

输出：

支持平台：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) 运算，并返回计算结果。

参数列表：

输出：

支持平台：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，使用相同的值重新排布输入张量。

参数列表：

输出：

代码示例：

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。

输入：

输出：

支持平台: 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

反转可变长度的切片

输入：

输出：

支持平台: 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 取倒数计算。

输入：

输出：

支持平台：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 的取整计算，取整规则为四舍五入。

输入：

输出：

支持平台：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 的开方，然后取倒数。

输入：

输出：

支持平台：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 是否相同

输入：

输出：

支持平台: 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

$$ \text{input}[\text{indices}[i, ..., j], :] \mathrel{+}= \text{updates}[i, ..., j, :] $$

Note:

这是一个就地更新运算符。因此，input 将在操作完成后更新。

输入：

输出：

支持平台: 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

$$ \text{input}[\text{indices}[i, ..., j], :] \mathrel{-}= \text{updates}[i, ..., j, :] $$

Note:

这是一个就地更新运算符。因此，input 将在操作完成后更新。

输入：

输出：

支持平台: 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 值。

$$ \text{input}[\text{indices}[i, ..., j], :] = \text{updates}[i, ..., j, :] $$

Note:

这是一个原址更新运算符。因此，input 将在操作完成后更新。

输入：

输出：

支持平台: 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 值以及输入索引。每一次运算结束后输出更新后的值，使我们更方便使用更新后的值

输入：

输出：

支持平台: 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 功能的平滑近似。它可用于限制机器的输出始终为正。计算公式如下所示：

$$ \text{output} = \log(1 + \exp(\text{x})), $$

输入：

输出：

支持平台：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 类型。

输入：

输出：

$$ 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 尺寸是划分后的相应块数。在划分之前，如果需要，输入的空间尺寸根据镶嵌零填充。

输入：

输出：

支持平台: 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 中的某些值。 此算子暂不支持反向。

输入：

输出：

支持平台: 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”。

输入：

输出：

支持平台: 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 算子功能，使用双线性插值将图像调整为指定大小。。

输入：

输出：

支持平台：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。公式如下： $$ \rm{ReLU6(x)} = \min{(\max{(0, x)},6)} $$

输入：

输出：

支持平台: 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 指定维度的元素

输入：

输出：

支持平台: 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 的每一个元素，返回最接近的整数。

输入：

输出：

支持平台: 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 或采样点的坐标执行量化。

输入：

输出：

支持平台: 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。

输入：

输出：

支持平台: 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。

输入：

输出：

支持平台：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 和一个标量时，这个标量只能是一个常数。

输入：

输出：

支持平台：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)$。

输入：

输出：

支持平台：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 平台暂时仅静态图支持反向。

输入：

输出：

支持平台：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<Int64>([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 算子功能，用于生成符合标准正态分布的随机数。

输入：

输出：

支持平台：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) 范围内。

输入：

输出：

支持平台：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 算子功能，用于根据条件在计算图中创建控制流。

输入：

输出：

支持平台：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。

输入：

输出：

支持平台：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 计算。

输入：

输出：

支持平台：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 进行逐元素开方运算。

输入：

输出：

支持平台：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 进行逐元素平方运算。

输入：

输出：

支持平台：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 的平方和。

输入：

输出：

支持平台：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}(x_i) = \frac{1}{1 + \exp(-x_i)}$$

输入：

输出

支持平台: 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，计算公式为：

$$ \begin{split}\begin{array}{ll} \ p_{ij} = sigmoid(X_{ij}) = \frac{1}{1 + e^{-X_{ij}}} \ loss_{ij} = -[Y_{ij} * ln(p_{ij}) + (1 - Y_{ij})ln(1 - p_{ij})] \end{array}\end{split} $$

输入：

输出：

支持平台：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 中抽取一部分数据。

输入：

输出：

支持平台：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 整除。

输入：

输出：

支持平台：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-lrgrad1\frac{1}{\sqrt{accum}} $$

$$ x=\frac{sign(prox_v)}{1+lr*l2}max(|prox_v|-lrl1, 0) $$

参数列表：

输入：

输出：

支持平台：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。其计算过程如下：

$$ \begin{aligned} m_{t+1} &= m_{t} + g^2 \ u_{t+1} &= u_{t} + g - \frac{m_{t+1}^\text{-p} - m_{t}^\text{-p}}{\alpha } * \omega_{t} \ \omega_{t+1} &= \begin{cases} \frac{(sign(u_{t+1}) * l1 - u_{t+1})}{\frac{m_{t+1}^\text{-p}}{\alpha } + 2 * l2 } & \text{ if } |u_{t+1}| > l1 \ 0.0 & \text{ otherwise } \end{cases}\ \end{aligned} $$

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

输入：

输出：

支持平台: 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 算子功能，用于计算输入的正弦。

输入：

输出：

支持平台：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 = [v₁, v₂, ... v_n], v_m 是一个 k-vector，表示一个 index, k 是 shape 的维度。

update = [a₁, a₂, ..., a_n]

则输出的 tensor 中 v₁ 的值为 a₁，v₂ 的值为 a₂...，其余值均为 0。

输入：

输出：

注：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 的值。

输入：

输出：

支持平台: 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 的值。

输入：

输出：

支持平台: 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 运算。

输入：

输出：

支持平台：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。 注：此算子暂不支持反向。

输入：

输出

支持平台：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] 次。

输入：

输出：

支持平台：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 个最大项的值和索引。

输入：