mindspore.ops

动态shape的支持情况详见 ops接口动态shape支持情况

MindSpore中 mindspore.ops 接口与上一版本相比,新增、删除和支持平台的变化信息请参考 mindspore.ops API接口变更

神经网络层函数

神经网络

接口名

概述

支持平台

警告

mindspore.ops.adaptive_avg_pool1d

对可以看作是由一系列1D平面组成的输入Tensor,应用一维自适应平均池化操作。

Ascend GPU CPU

mindspore.ops.adaptive_avg_pool2d

对一个多平面输入信号执行二维自适应平均池化。

Ascend GPU CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.adaptive_avg_pool3d

对一个多平面输入信号执行三维自适应平均池化。

Ascend GPU CPU

mindspore.ops.adaptive_max_pool1d

对可以看作是由一系列1D平面组成的输入Tensor,应用一维自适应最大池化操作。

Ascend GPU CPU

mindspore.ops.adaptive_max_pool2d

对输入Tensor,提供二维自适应最大池化操作。

Ascend GPU CPU

mindspore.ops.avg_pool1d

在输入Tensor上应用1D平均池化,输入Tensor可以看作是由一系列1D平面组成的。

Ascend GPU CPU

kernel_size 取值为[1, 255]范围内的正整数,stride 的取值为[1, 63]范围内的正整数。

mindspore.ops.avg_pool2d

在输入Tensor上应用2D平均池化,输入Tensor可以看作是由一系列2D平面组成的。

Ascend GPU CPU

kernel_size 取值为[1, 255]范围内的正整数,stride 的取值为[1, 63]范围内的正整数。

mindspore.ops.avg_pool3d

在输入Tensor上应用3D平均池化,输入Tensor可以看作是由一系列3D平面组成的。

Ascend GPU CPU

kernel_size 取值为[1, 255]范围内的正整数,stride 的取值为[1, 63]范围内的正整数。

mindspore.ops.batch_norm

对输入数据进行批量归一化和更新参数。

Ascend GPU CPU

对于Ascend 310,由于平方根指令,结果精度未能达到1‰。

mindspore.ops.bias_add

返回输入Tensor input_x 与偏置Tensor bias 之和。

Ascend GPU CPU

mindspore.ops.bidense

对输入 input1input2 应用双线性全连接操作。

Ascend GPU CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.ctc_greedy_decoder

对输入中给定的logits执行贪婪解码。

Ascend GPU CPU

mindspore.ops.conv1d

对输入Tensor计算一维卷积。

Ascend GPU

mindspore.ops.conv2d

对输入Tensor计算二维卷积。

Ascend GPU

mindspore.ops.conv3d

对输入Tensor计算三维卷积。

Ascend GPU

mindspore.ops.deformable_conv2d

给定4D的Tensor输入 xweightoffsets ,计算一个2D的可变形卷积。

Ascend GPU CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.dense

对输入 input 应用全连接操作。

Ascend GPU CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.dropout

在训练期间,以服从伯努利分布的概率 p 随机将输入Tensor的某些值归零,起到减少神经元相关性的作用,避免过拟合。

Ascend GPU CPU

mindspore.ops.dropout1d

在训练期间,以服从伯努利分布的概率 p 随机将输入Tensor的某些通道归零(对于形状为 \(NCL\) 的三维Tensor,其通道特征图指的是后一维 \(L\) 的一维特征图)。

Ascend GPU CPU

mindspore.ops.dropout2d

在训练期间,以服从伯努利分布的概率 p 随机将输入Tensor的某些通道归零(对于形状为 \(NCHW\) 的四维Tensor,其通道特征图指的是后两维 \(HW\) 形状的二维特征图)。

Ascend GPU CPU

mindspore.ops.dropout3d

在训练期间,以服从伯努利分布的概率 p 随机将输入Tensor的某些通道归零(对于形状为 \(NCDHW\) 的五维Tensor,其通道特征图指的是后三维 \(DHW\) 形状的三维特征图)。

Ascend GPU CPU

mindspore.ops.flatten

沿着从 start_dimend_dim 的维度,对输入Tensor进行展平。

Ascend GPU CPU

mindspore.ops.fold

将提取出的滑动局部区域块还原成更大的输出Tensor。

Ascend GPU CPU

其输入则须为三维Tensor,其shape为 \((N, C \times H, W)\)

mindspore.ops.fractional_max_pool3d

在输入 input 上应用三维分数最大池化。

GPU CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.lp_pool1d

在输入Tensor上应用1D LP池化运算,可被视为组成一个1D输入平面。

Ascend GPU CPU

mindspore.ops.lp_pool2d

在输入Tensor上应用2D LP池化运算,可被视为组成一个2D输入平面。

Ascend GPU CPU

mindspore.ops.lrn

局部响应归一化操作LRN(Local Response Normalization)。

Ascend GPU CPU

mindspore.ops.max_pool2d

二维最大值池化。

Ascend GPU CPU

mindspore.ops.max_pool3d

三维最大值池化。

Ascend GPU CPU

mindspore.ops.max_unpool1d

max_pool1d 的逆过程。

Ascend GPU CPU

mindspore.ops.max_unpool2d

max_pool2d 的逆过程。

Ascend GPU CPU

mindspore.ops.max_unpool3d

mindspore.ops.max_pool3d() 的逆过程。

Ascend GPU CPU

mindspore.ops.unfold

从一个batch的输入Tensor中提取滑动局部块。

Ascend GPU CPU

在2.0rc1版本,该算子的输出为四维Tensor,其shape为 \((N, C, \prod(\text{kernel_size}), L)\) 。 在之后的版本中,其输出则为三维Tensor,其shape为 \((N, C \times \prod(\text{kernel_size}), L)\)

损失函数

接口名

概述

支持平台

警告

mindspore.ops.binary_cross_entropy

计算预测值 logits 和 目标值 labels 之间的二值交叉熵(度量两个概率分布间的差异性信息)损失。

Ascend GPU CPU

x 的值必须要在0-1范围内。

mindspore.ops.binary_cross_entropy_with_logits

输入经过sigmoid激活函数后作为预测值,binary_cross_entropy_with_logits 计算预测值和目标值之间的二值交叉熵损失。

Ascend GPU CPU

mindspore.ops.cosine_embedding_loss

余弦相似度损失函数,用于测量两个Tensor之间的相似性。

Ascend GPU CPU

mindspore.ops.cross_entropy

获取预测值和目标值之间的交叉熵损失。

Ascend GPU CPU

mindspore.ops.ctc_loss

计算CTC(Connectist Temporal Classification)损失和梯度。

Ascend GPU CPU

mindspore.ops.gaussian_nll_loss

服从高斯分布的负对数似然损失。

Ascend GPU CPU

mindspore.ops.hinge_embedding_loss

Hinge Embedding 损失函数,衡量输入 inputs 和标签 targets (包含1或-1)之间的损失值。

Ascend GPU CPU

mindspore.ops.huber_loss

计算预测值和目标值之间的误差,兼具 mindspore.ops.l1_loss()mindspore.ops.mse_loss() 的优点。

Ascend GPU CPU

mindspore.ops.kl_div

计算输入 logitslabels 的KL散度。

Ascend GPU CPU

mindspore.ops.l1_loss

用于计算预测值和目标值之间的平均绝对误差。

Ascend GPU CPU

mindspore.ops.margin_ranking_loss

排序损失函数,用于创建一个衡量给定损失的标准。

Ascend GPU CPU

mindspore.ops.mse_loss

计算预测值和标签值之间的均方误差。

Ascend GPU CPU

mindspore.ops.multi_margin_loss

用于优化多分类问题的合页损失。

Ascend GPU CPU

mindspore.ops.multilabel_margin_loss

用于优化多标签分类问题的合页损失。

Ascend GPU

mindspore.ops.multilabel_soft_margin_loss

基于最大熵计算用于多标签优化的损失。

Ascend GPU CPU

mindspore.ops.nll_loss

获取预测值和目标值之间的负对数似然损失。

Ascend GPU CPU

mindspore.ops.smooth_l1_loss

计算平滑L1损失,该L1损失函数有稳健性。

Ascend GPU CPU

mindspore.ops.soft_margin_loss

计算 inputtarget 之间的soft margin loss。

Ascend GPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.triplet_margin_loss

三元组损失函数。

GPU

激活函数

接口名

概述

支持平台

警告

mindspore.ops.celu

celu激活函数,逐元素计算输入Tensor的celu(Continuously differentiable exponential linear units)值。

Ascend GPU CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.elu

指数线性单元激活函数。

Ascend GPU CPU

mindspore.ops.fast_gelu

快速高斯误差线性单元激活函数。

Ascend GPU CPU

mindspore.ops.gelu

高斯误差线性单元激活函数。

Ascend GPU CPU

mindspore.ops.glu

门线性单元函数(Gated Linear Unit function)。

Ascend CPU

mindspore.ops.gumbel_softmax

返回Gumbel-Softmax分布的Tensor。

Ascend GPU CPU

mindspore.ops.hardshrink

Hard Shrink激活函数。

Ascend GPU CPU

mindspore.ops.hardsigmoid

Hard Sigmoid激活函数。

Ascend GPU CPU

mindspore.ops.hardswish

逐元素计算Hard Swish。

Ascend GPU CPU

mindspore.ops.hardtanh

逐元素元素计算hardtanh激活函数。

Ascend GPU CPU

mindspore.ops.leaky_relu

leaky_relu激活函数。

Ascend GPU CPU

mindspore.ops.log_softmax

在指定轴上对输入Tensor应用LogSoftmax函数。

Ascend GPU CPU

mindspore.ops.logsigmoid

按元素计算logsigmoid激活函数。

Ascend GPU CPU

mindspore.ops.mish

逐元素计算输入Tensor的MISH(Self Regularized Non-Monotonic Neural Activation Function 自正则化非单调神经激活函数)。

Ascend GPU CPU

mindspore.ops.prelu

带参数的线性修正单元激活函数(Parametric Rectified Linear Unit activation function)。

Ascend GPU CPU

mindspore.ops.relu

对输入Tensor逐元素计算线性修正单元激活函数(Rectified Linear Unit)值。

Ascend GPU CPU

mindspore.ops.relu6

计算输入Tensor的ReLU(修正线性单元),其上限为6。

Ascend GPU CPU

mindspore.ops.rrelu

Randomized Leaky ReLU激活函数。

Ascend GPU CPU

mindspore.ops.selu

激活函数selu(Scaled exponential Linear Unit)。

Ascend GPU CPU

mindspore.ops.sigmoid

逐元素计算Sigmoid激活函数。

Ascend GPU CPU

mindspore.ops.silu

按输入逐元素计算激活函数SiLU(Sigmoid Linear Unit)。

Ascend GPU CPU

mindspore.ops.softmax

在指定轴上对输入Tensor执行Softmax激活函数做归一化操作。

Ascend GPU CPU

mindspore.ops.softmin

在指定轴上对输入Tensor执行Softmin函数做归一化操作。

Ascend GPU CPU

mindspore.ops.softshrink

逐元素计算Soft Shrink激活函数。

Ascend GPU CPU

mindspore.ops.softsign

Softsign激活函数。

Ascend GPU CPU

mindspore.ops.tanh

逐元素计算输入元素的双曲正切。

Ascend GPU CPU

mindspore.ops.threshold

使用阈值 thr 参数对 input 逐元素阈值化,并将其结果作为Tensor返回。

Ascend GPU CPU

距离函数

接口名

概述

支持平台

警告

mindspore.ops.cdist

计算两个Tensor每对行向量之间的p-norm距离。

Ascend GPU CPU

mindspore.ops.dist

计算输入中每对行向量之间的 \(p\)-norm距离。

Ascend GPU CPU

mindspore.ops.pdist

计算输入中每对行向量之间的p-范数距离。

GPU CPU

采样函数

接口名

概述

支持平台

警告

mindspore.ops.choice_with_mask

对输入进行随机取样,返回取样索引和掩码。

Ascend GPU CPU

mindspore.ops.random_categorical

从一个分类分布中生成随机样本。

Ascend GPU CPU

mindspore.ops.log_uniform_candidate_sampler

使用log-uniform(Zipfian)分布对一组类别进行采样。

Ascend CPU

mindspore.ops.uniform_candidate_sampler

使用均匀分布对一组类别进行采样。

Ascend GPU CPU

图像函数

接口名

概述

支持平台

警告

mindspore.ops.affine_grid

基于输入的批量仿射矩阵 theta ,返回一个二维或三维的流场(采样网格)。

Ascend GPU CPU

mindspore.ops.bounding_box_decode

解码边界框位置信息,计算偏移量,此算子将偏移量转换为Bbox,用于在后续图像中标记目标等。

Ascend GPU CPU

mindspore.ops.bounding_box_encode

编码边界框位置信息,计算预测边界框和真实边界框之间的偏移,并将此偏移作为损失变量。

Ascend GPU CPU

mindspore.ops.col2im

将一组滑动局部块组合成一个大的Tensor。

Ascend GPU CPU

mindspore.ops.check_valid

检查边界框是否在图片内。

Ascend GPU CPU

bboxes 指定的边界框和由 img_metas 指定的图片信息需要是有效的,即: \(x0 <= x1\)\(y0 <= y1\)img_metas 中的信息 \((height, width, ratio)\) 均为正数。

mindspore.ops.crop_and_resize

对输入图像Tensor进行裁剪并调整其大小。

Ascend GPU CPU

mindspore.ops.grid_sample

给定一个输入和一个网格,使用网格中的输入值和像素位置计算输出。

Ascend GPU CPU

mindspore.ops.interpolate

按照给定的 sizescale_factor 根据 mode 设置的插值方式,对输入 input 调整大小。

Ascend GPU CPU

mindspore.ops.iou

计算矩形的IOU,即真实区域和预测区域的交并比。

Ascend GPU CPU

在Ascend中,仅支持计算float16数据。为避免溢出,输入长度和宽度在内部按0.2缩放。

mindspore.ops.pad

根据参数 padding 对输入进行填充。

Ascend GPU CPU

mindspore.ops.padding

通过填充0,将输入Tensor的最后一个维度从1扩展到指定大小。

Ascend GPU CPU

mindspore.ops.pixel_shuffle

对输入 input 应用像素重组操作,它实现了步长为 \(1/r\) 的子像素卷积。

Ascend GPU CPU

mindspore.ops.pixel_unshuffle

对输入 input 应用逆像素重组操作,这是像素重组的逆操作。

Ascend GPU CPU

mindspore.ops.upsample

mindspore.ops.interpolate() 的别名。

Ascend GPU CPU

数学运算函数

逐元素运算

接口名

概述

支持平台

警告

mindspore.ops.abs

逐元素计算输入Tensor的绝对值。

Ascend GPU CPU

mindspore.ops.absolute

mindspore.ops.abs() 的别名。

Ascend GPU CPU

mindspore.ops.accumulate_n

逐元素将所有输入的Tensor相加。

Ascend

mindspore.ops.acos

逐元素计算输入Tensor的反余弦。

Ascend GPU CPU

mindspore.ops.arccos

mindspore.ops.acos() 的别名。

Ascend GPU CPU

mindspore.ops.acosh

逐元素计算输入Tensor的反双曲余弦。

Ascend GPU CPU

给定一个输入Tensor input ,该函数计算每个元素的反双曲余弦。输入范围为[1, inf]。

mindspore.ops.add

把other的数值与input进行逐元素相加。

Ascend GPU CPU

mindspore.ops.addcdiv

执行Tensor tensor1 与Tensor tensor2 的逐元素除法,将结果乘以标量值 value ,并将其添加到 input 中。

Ascend GPU CPU

mindspore.ops.addcmul

执行Tensor tensor1 与Tensor tensor2 的逐元素乘积,将结果乘以标量值 value ,并将其添加到 input 中。

Ascend GPU CPU

mindspore.ops.addmv

matvec 相乘,且将输入向量 input 加到最终结果中。

Ascend GPU CPU

mindspore.ops.addn

逐元素将所有输入的Tensor相加。

Ascend GPU CPU

mindspore.ops.angle

逐元素计算复数Tensor的辐角。

Ascend GPU CPU

mindspore.ops.arccosh

mindspore.ops.acosh() 的别名。

Ascend GPU CPU

mindspore.ops.arcsin

mindspore.ops.asin() 的别名。

Ascend GPU CPU

mindspore.ops.arcsinh

mindspore.ops.asinh() 的别名。

Ascend GPU CPU

mindspore.ops.arctan

mindspore.ops.atan() 的别名。

Ascend GPU CPU

mindspore.ops.arctanh

mindspore.ops.atanh() 的别名。

Ascend GPU CPU

mindspore.ops.arctan2

mindspore.ops.atan2() 的别名。

Ascend GPU CPU

mindspore.ops.asin

逐元素计算输入Tensor的反正弦。

Ascend GPU CPU

mindspore.ops.asinh

计算输入元素的反双曲正弦。

Ascend GPU CPU

mindspore.ops.atan

逐元素计算输入Tensor的反正切值。

Ascend GPU CPU

mindspore.ops.atan2

逐元素计算input/other的反正切值。

Ascend GPU CPU

mindspore.ops.atanh

逐元素计算输入Tensor的反双曲正切值。

Ascend GPU CPU

mindspore.ops.atleast_1d

调整 inputs 中的Tensor维度,使输入中每个Tensor维度不低于1。

Ascend GPU CPU

mindspore.ops.atleast_2d

调整 inputs 中的Tensor维度,使输入中每个Tensor维度不低于2。

Ascend GPU CPU

mindspore.ops.atleast_3d

调整 inputs 中的Tensor维度,使输入中每个Tensor维度不低于3。

Ascend GPU CPU

mindspore.ops.bessel_i0

逐元素计算并返回输入Tensor的Bessel i0函数值。

GPU CPU

mindspore.ops.bessel_i0e

逐元素计算并返回输入Tensor的Bessel i0e函数值。

Ascend GPU CPU

mindspore.ops.bessel_i1

逐元素计算并返回输入Tensor的Bessel i1函数值。

GPU CPU

mindspore.ops.bessel_i1e

逐元素计算并返回输入Tensor的Bessel i1e函数值。

Ascend GPU CPU

mindspore.ops.bessel_j0

逐元素计算并返回输入Tensor的Bessel j0函数值。

GPU CPU

mindspore.ops.bessel_j1

逐元素计算并返回输入Tensor的Bessel j1函数值。

GPU CPU

mindspore.ops.bessel_k0

逐元素计算并返回输入Tensor的Bessel k0函数值。

GPU CPU

mindspore.ops.bessel_k0e

逐元素计算并返回输入Tensor的Bessel k0e函数值。

GPU CPU

mindspore.ops.bessel_k1

逐元素计算并返回输入Tensor的Bessel k1函数值。

GPU CPU

mindspore.ops.bessel_k1e

逐元素计算并返回输入Tensor的Bessel k1e函数值。

GPU CPU

mindspore.ops.bessel_y0

逐元素计算并返回输入Tensor的Bessel y0函数值。

GPU CPU

mindspore.ops.bessel_y1

逐元素计算并返回输入Tensor的Bessel y1函数值。

GPU CPU

mindspore.ops.bitwise_and

逐元素执行两个Tensor的与运算。

Ascend GPU CPU

mindspore.ops.bitwise_left_shift

逐元素对输入 input 进行左移位运算, 移动的位数由 other 指定。

Ascend GPU CPU

mindspore.ops.bitwise_or

逐元素执行两个Tensor的或运算。

Ascend GPU CPU

mindspore.ops.bitwise_right_shift

逐元素对输入 input 进行右移位运算, 移动的位数由 other 指定。

Ascend GPU CPU

mindspore.ops.bitwise_xor

逐元素执行两个Tensor的异或运算。

Ascend GPU CPU

mindspore.ops.ceil

向上取整函数。

Ascend GPU CPU

mindspore.ops.clamp

将输入Tensor的值裁剪到指定的最小值和最大值之间。

Ascend GPU CPU

mindspore.ops.clip

mindspore.ops.clamp() 的别名。

Ascend GPU CPU

mindspore.ops.combinations

返回输入Tensor中元素的所有长度为 r 的子序列。

Ascend GPU CPU

mindspore.ops.copysign

逐元素地创建一个新的浮点Tensor,其大小为 x,符号为 other 的符号。

Ascend GPU CPU

mindspore.ops.cos

逐元素计算输入的余弦。

Ascend GPU CPU

如果使用float64,可能会存在精度丢失的问题。

mindspore.ops.cosh

逐元素计算 input 的双曲余弦值。

Ascend GPU CPU

mindspore.ops.cosine_similarity

沿轴计算的x1和x2之间的余弦相似度。

Ascend GPU CPU

mindspore.ops.cov

给定输入 input 和权重,返回输入 input 的协方差矩阵(每对变量的协方差的方阵),其中输入行是变量,列是观察值。

Ascend GPU CPU

fweightsaweights 的值不能为负数,负数权重场景结果未定义。

mindspore.ops.diag_embed

生成一个Tensor,其对角线值由 input 中的值填充,其余位置置0。

Ascend GPU CPU

mindspore.ops.diff

沿着给定维度计算输入Tensor x 的n阶前向差分。

Ascend GPU CPU

mindspore.ops.deg2rad

逐元素地将 x 从度数制转换为弧度制。

Ascend GPU CPU

mindspore.ops.digamma

计算对数gamma函数在输入上的导数。

GPU CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.div

逐元素计算第一个输入Tensor除以第二输入Tensor的商。

Ascend GPU CPU

mindspore.ops.divide

mindspore.ops.div() 的别名。

Ascend GPU CPU

mindspore.ops.erf

逐元素计算 input 的高斯误差函数。

Ascend GPU CPU

mindspore.ops.erfc

逐元素计算 input 的互补误差函数。

Ascend GPU CPU

mindspore.ops.erfinv

计算输入的逆误差函数。

Ascend GPU CPU

mindspore.ops.exp

逐元素计算 input 的指数。

Ascend GPU CPU

mindspore.ops.exp2

逐元素计算Tensor input 以2为底的指数。

Ascend GPU CPU

mindspore.ops.expm1

逐元素计算输入Tensor的指数,然后减去1。

Ascend GPU CPU

mindspore.ops.floor

逐元素向下取整函数。

Ascend GPU CPU

mindspore.ops.floor_div

将第一个输入Tensor除以第二个输入Tensor,并向下取整。

Ascend GPU CPU

mindspore.ops.floor_divide

按元素将第一个输入Tensor除以第二个输入Tensor,并向下取整。

Ascend GPU CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.floor_mod

将第一个输入Tensor除以第二个输入Tensor,并向下取余。

Ascend GPU CPU

输入 y 的元素不能等于0,否则将返回当前数据类型的最大值。 当输入元素数量超过2048时,算子的精度不能保证千分之二的要求。 由于架构不同,该算子在NPU和CPU上的计算结果可能不一致。 如果shape表示为 \((D1, D2 ..., Dn)\) ,那么 D1*D2... *DN<=1000000,n<=8.

mindspore.ops.float_power

计算 input 的指数幂。

GPU CPU

mindspore.ops.fmod

计算除法运算 input/other 的浮点余数。

Ascend GPU CPU

mindspore.ops.frac

计算 x 中每个元素的小数部分。

Ascend GPU CPU

mindspore.ops.gcd

按元素计算输入Tensor的最大公约数。

Ascend GPU CPU

mindspore.ops.hypot

按元素计算以输入Tensor为直角边的三角形的斜边。

Ascend GPU CPU

mindspore.ops.igamma

计算正则化的下层不完全伽马函数。

Ascend GPU CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.igammac

计算正则化的上层不完全伽马函数。

Ascend GPU CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.imag

返回包含输入Tensor的虚部。

Ascend GPU CPU

mindspore.ops.i0

mindspore.ops.bessel_i0() 的别名。

GPU CPU

mindspore.ops.inv

逐元素计算输入Tensor的倒数。

Ascend GPU CPU

mindspore.ops.invert

对输入逐元素按位翻转。

Ascend GPU CPU

mindspore.ops.lcm

逐元素计算两个输入Tensor的最小公倍数。

Ascend GPU CPU

mindspore.ops.ldexp

逐元素将输入Tensor乘以 \(2^{other}\)

Ascend GPU CPU

mindspore.ops.lerp

基于权重参数计算两个Tensor之间的线性插值。

Ascend GPU CPU

mindspore.ops.log

逐元素返回Tensor的自然对数。

Ascend GPU CPU

如果算子Log的输入值在(0, 0.01]或[0.95, 1.05]范围内,则输出精度可能会存在误差。

mindspore.ops.log2

逐元素返回Tensor以2为底的对数。

Ascend GPU CPU

如果log2的输入值范围在(0, 0.01]或[0.95, 1.05]区间,输出精度可能会受影响。

mindspore.ops.log10

逐元素返回Tensor以10为底的对数。

Ascend GPU CPU

如果log10的输入值范围在(0, 0.01]或[0.95, 1.05]区间,输出精度可能会受影响。

mindspore.ops.log1p

对输入Tensor逐元素加一后计算自然对数。

Ascend GPU CPU

mindspore.ops.logaddexp

计算输入的指数和的对数。

Ascend GPU CPU

mindspore.ops.logaddexp2

计算以2为底的输入的指数和的对数。

Ascend GPU CPU

mindspore.ops.logical_and

逐元素计算两个Tensor的逻辑与运算。

Ascend GPU CPU

mindspore.ops.logical_not

逐元素计算一个Tensor的逻辑非运算。

Ascend GPU CPU

mindspore.ops.logical_or

逐元素计算两个Tensor的逻辑或运算。

Ascend GPU CPU

mindspore.ops.logical_xor

逐元素计算两个Tensor的逻辑异或运算。

Ascend CPU

mindspore.ops.logit

逐元素计算Tensor的logit值。

Ascend GPU CPU

mindspore.ops.mul

两个Tensor逐元素相乘。

Ascend GPU CPU

mindspore.ops.multiply

mindspore.ops.mul() 的别名。

Ascend GPU CPU

mindspore.ops.mvlgamma

逐元素计算 p 维多元对数伽马函数值。

Ascend GPU CPU

mindspore.ops.neg

计算输入input的相反数并返回。

Ascend GPU CPU

mindspore.ops.negative

mindspore.ops.neg() 的别名。

Ascend GPU CPU

mindspore.ops.nextafter

逐元素返回 input 指向 other 的下一个可表示值符点值。

Ascend GPU CPU

mindspore.ops.polar

将极坐标转化为笛卡尔坐标。

GPU CPU

mindspore.ops.polygamma

计算关于 input 的多伽马函数的 \(n\) 阶导数。

GPU CPU

mindspore.ops.positive

返回输入Tensor。

Ascend GPU CPU

mindspore.ops.pow

计算 input 中每个元素的 exponent 次幂。

Ascend GPU CPU

mindspore.ops.rad2deg

逐元素地将 x 从弧度制转换为度数制。

Ascend GPU CPU

mindspore.ops.ravel

沿着0轴方向,将多维Tensor展开成一维。

Ascend GPU CPU

mindspore.ops.real

返回输入Tensor的实数部分。

Ascend GPU CPU

mindspore.ops.reciprocal

返回输入Tensor每个元素的倒数。

Ascend GPU CPU

mindspore.ops.remainder

逐元素计算第一个元素除以第二个元素的余数。

Ascend GPU CPU

当输入元素超过2048时,可能会有精度问题。 在Ascend和CPU上的计算结果可能不一致。 如果shape表示为(D1,D2…Dn),那么D1 * D2……* DN <= 1000000,n <= 8。

mindspore.ops.rot90

沿轴指定的平面内将n-D Tensor旋转90度。

Ascend GPU CPU

mindspore.ops.round

对输入数据进行四舍五入到最接近的整数数值。

Ascend GPU CPU

mindspore.ops.rsqrt

逐元素计算输入Tensor元素的平方根倒数。

Ascend GPU CPU

mindspore.ops.sgn

mindspore.ops.sign() 在复数上的扩展。

Ascend GPU CPU

mindspore.ops.sign

按sign公式逐元素计算输入Tensor。

Ascend GPU CPU

mindspore.ops.signbit

判断每个元素的符号,如果元素值小于0则对应输出的位置为True,否则为False。

Ascend GPU CPU

mindspore.ops.sin

逐元素计算输入Tensor的正弦。

Ascend GPU CPU

mindspore.ops.sinc

计算输入的归一化正弦值。

Ascend GPU CPU

mindspore.ops.sinh

逐元素计算输入Tensor的双曲正弦。

Ascend GPU CPU

mindspore.ops.sqrt

逐元素返回当前Tensor的平方根。

Ascend GPU CPU

mindspore.ops.square

逐元素返回Tensor的平方。

Ascend GPU CPU

mindspore.ops.sub

逐元素用第一个输入Tensor减去第二个输入Tensor。

Ascend GPU CPU

mindspore.ops.subtract

对Tensor进行逐元素的减法。

Ascend GPU CPU

mindspore.ops.t

转置二维Tensor。

Ascend GPU CPU

mindspore.ops.tan

计算输入元素的正切值。

Ascend GPU CPU

mindspore.ops.tanhshrink

Tanhshrink激活函数, \(Tanhshrink(x)=x-Tanh(x)\) ,其中 \(x\) 即输入 input

Ascend GPU CPU

mindspore.ops.trapz

使用梯形法则沿给定轴 dimy(x) 进行积分。

Ascend GPU CPU

mindspore.ops.tril_indices

计算 row * col 行列矩阵的下三角元素的索引,并将它们作为一个 2xN 的Tensor返回。

Ascend GPU CPU

mindspore.ops.triu_indices

计算 row * col 行列矩阵的上三角元素的索引,并将它们作为一个 2xN 的Tensor返回。

Ascend GPU CPU

mindspore.ops.true_divide

mindspore.ops.div()\(rounding\_mode=None\) 时的别名。

Ascend GPU CPU

mindspore.ops.trunc

返回一个新的Tensor,该Tensor具有输入元素的截断整数值。

Ascend GPU CPU

mindspore.ops.truncate_div

将第一个输入Tensor与第二个输入Tensor逐元素相除,结果将向0取整。

Ascend GPU CPU

mindspore.ops.truncate_mod

逐元素取模。

Ascend GPU CPU

输入数值不能为0。 当输入含有超过2048个元素,该操作不能保证千分之二的精度要求。 由于架构不同,该算子在NPU和CPU上的计算结果可能不一致。 若shape为(D1、D2...、Dn),则D1*D2...*DN<=1000000,n<=8。

mindspore.ops.xdivy

将第一个输入Tensor除以第二个输入Tensor。

Ascend GPU CPU

mindspore.ops.xlogy

计算第一个输入Tensor乘以第二个输入Tensor的对数。

Ascend GPU CPU

在Ascend上, inputother 必须为float16或float32。

mindspore.ops.zeta

逐元素计算Hurwitz zeta的输出。

Ascend GPU CPU

这是一个实验性API,后续可能修改或删除。

Reduction函数

接口名

概述

支持平台

警告

mindspore.ops.all

默认情况下,通过对维度中所有元素进行“逻辑与”来减少 input 的维度。

Ascend GPU CPU

mindspore.ops.amax

默认情况下,移除输入所有维度,返回 input 中的最大值。

Ascend GPU CPU

mindspore.ops.amin

默认情况下,移除输入所有维度,返回 input 中的最小值。

Ascend GPU CPU

mindspore.ops.aminmax

返回输入Tensor在指定轴上的最小值和最大值。

Ascend GPU CPU

mindspore.ops.any

默认情况下,通过对维度中所有元素进行“逻辑或”来减少 input 的维度。

Ascend GPU CPU

mindspore.ops.argmax

返回输入Tensor在指定轴上的最大值索引。

Ascend GPU CPU

mindspore.ops.argmin

返回输入Tensor在指定轴上的最小值索引。

Ascend GPU CPU

mindspore.ops.cummax

返回一个元组(最值、索引),其中最值是输入Tensor input 沿维度 axis 的累积最大值,索引是每个最大值的索引位置。

GPU CPU

mindspore.ops.cummin

返回一个元组(最值、索引),其中最值是输入Tensor input 沿维度 axis 的累积最小值,索引是每个最小值的索引位置。

Ascend GPU CPU

mindspore.ops.cumprod

返回输入的元素在 dim 维度上的累积乘积。

Ascend GPU CPU

mindspore.ops.cumsum

计算输入Tensor x 沿轴 axis 的累积和。

Ascend GPU CPU

mindspore.ops.fmax

逐元素计算输入Tensor的最大值。

CPU

mindspore.ops.histc

计算Tensor的直方图。

Ascend CPU

mindspore.ops.logcumsumexp

计算输入Tensor input 元素的的指数沿轴 axis 的累积和的对数。

Ascend CPU GPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.logsumexp

求Tensor的对数指数和。

Ascend GPU CPU

mindspore.ops.max

在给定轴上计算输入Tensor的最大值。

Ascend GPU CPU

如果有多个最大值,则取第一个最大值的索引。

mindspore.ops.mean

默认情况下,移除输入所有维度,返回 x 中所有元素的平均值。

Ascend GPU CPU

mindspore.ops.median

输出Tensor指定维度上的中值与索引。

GPU CPU

如果 input 的中值不唯一,则 indices 不一定包含第一个出现的中值。该接口的具体实现方式和后端类型相关,CPU和GPU的返回值可能不相同。

mindspore.ops.min

在给定轴上计算输入Tensor的最小值。

Ascend GPU CPU

如果有多个最小值,则取第一个最小值的索引。

mindspore.ops.norm

返回给定Tensor的矩阵范数或向量范数。

Ascend GPU CPU

mindspore.ops.prod

默认情况下,使用指定维度的所有元素的乘积代替该维度的其他元素,以移除该维度。

Ascend GPU CPU

mindspore.ops.std

默认情况下,输出Tensor各维度上的标准差,也可以对指定维度求标准差。

Ascend GPU CPU

mindspore.ops.std_mean

默认情况下,输出Tensor各维度上的标准差和均值,也可以对指定维度求标准差和均值。

Ascend GPU CPU

mindspore.ops.var

默认情况下,输出Tensor各维度上的方差,也可以对指定维度求方差。

Ascend GPU CPU

mindspore.ops.var_mean

默认情况下,输出Tensor各维度上的方差和均值,也可以对指定维度求方差和均值。

Ascend GPU CPU

比较函数

接口名

概述

支持平台

警告

mindspore.ops.argsort

按指定顺序对输入Tensor沿给定维度进行排序,并返回排序后的索引。

Ascend GPU CPU

mindspore.ops.approximate_equal

逐元素计算abs(x-y),如果小于tolerance则为 True ,否则为 False

Ascend GPU CPU

mindspore.ops.bucketize

根据 boundariesinput 进行分桶。

Ascend GPU CPU

mindspore.ops.equal

逐元素比较两个输入Tensor是否相等。

Ascend GPU CPU

mindspore.ops.ge

输入两个数据,逐元素比较第一个数据是否大于等于第二个数据。

Ascend GPU CPU

mindspore.ops.greater

按元素比较输入参数 \(input > other\) 的值,输出结果为bool值。

Ascend GPU CPU

mindspore.ops.greater_equal

按元素比较输入参数 \(input \geq other\) 的值,输出结果为bool值。

Ascend GPU CPU

mindspore.ops.gt

按元素比较输入参数 \(x,y\) 的值,输出结果为bool值。

Ascend GPU CPU

mindspore.ops.intopk

判断目标标签是否在前 k 个预测中。

Ascend GPU CPU

mindspore.ops.isclose

返回一个布尔型Tensor,表示 x1 的每个元素与 x2 的对应元素在给定容忍度内是否“接近”。

Ascend GPU CPU

mindspore.ops.isfinite

判断输入数据每个位置上的元素是否是有限数。

Ascend GPU CPU

mindspore.ops.isinf

确定输入Tensor每个位置上的元素是否为无穷大或无穷小。

Ascend GPU CPU

mindspore.ops.isnan

判断输入数据每个位置上的值是否是Nan。

Ascend GPU CPU

mindspore.ops.isneginf

逐元素判断是否是负inf。

Ascend GPU CPU

mindspore.ops.isposinf

逐元素判断是否是正inf。

Ascend GPU CPU

mindspore.ops.isreal

逐元素判断是否为实数。

GPU CPU

mindspore.ops.is_complex

如果Tensor的数据类型是复数,则返回True,否则返回False。

Ascend GPU CPU

mindspore.ops.is_floating_point

判断 input 的dtype是否是浮点数据类型,包括mindspore.float64,mindspore.float32,mindspore.float16。

Ascend GPU CPU

mindspore.ops.le

逐元素计算 \(x <= y\) 的bool值。

Ascend GPU CPU

mindspore.ops.less

逐元素计算 \(x < y\) ,返回为bool。

Ascend GPU CPU

mindspore.ops.less_equal

逐元素计算 \(input <= other\) 的bool值。

Ascend GPU CPU

mindspore.ops.lt

mindspore.ops.less() 的别名。

Ascend GPU CPU

mindspore.ops.maximum

逐元素计算两个输入Tensor中的最大值。

Ascend GPU CPU

mindspore.ops.minimum

逐元素计算两个输入Tensor中的最小值。

Ascend GPU CPU

mindspore.ops.msort

将输入Tensor的元素沿其第一个维度按值升序排序。

Ascend GPU CPU

mindspore.ops.ne

计算两个Tensor是否不相等。

Ascend GPU CPU

mindspore.ops.not_equal

mindspore.ops.ne() 的别名。

Ascend GPU CPU

mindspore.ops.searchsorted

返回位置索引,根据这个索引将 values 插入 sorted_sequence 后,sorted_sequence 的最内维度的顺序保持不变。

Ascend GPU CPU

mindspore.ops.topk

沿给定维度查找 k 个最大或最小元素和对应的索引。

Ascend GPU CPU

如果 sorted 设置为False,它将使用aicpu运算符,性能可能会降低,另外,由于在不同平台上存在内存排布以及遍历方式不同等问题,sorted 设置为False时计算结果的显示顺序可能会出现不一致的情况。

线性代数函数

接口名

概述

支持平台

警告

mindspore.ops.bmm

基于batch维度的两个Tensor的矩阵乘法。

Ascend GPU CPU

mindspore.ops.addbmm

batch1batch2 应用批量矩阵乘法后进行reduced add, input 和最终的结果相加。

Ascend GPU CPU

mindspore.ops.addmm

mat1mat2 应用矩阵乘法。

Ascend GPU CPU

mindspore.ops.baddbmm

对输入的两个三维矩阵batch1与batch2相乘,并将结果与input相加。

Ascend GPU CPU

mindspore.ops.addr

计算 vec1vec2 的外积,并将其添加到 x 中。

Ascend GPU CPU

mindspore.ops.adjoint

逐元素计算Tensor的共轭,并转置最后两个维度。

Ascend GPU CPU

mindspore.ops.cholesky

计算对称正定矩阵或一批对称正定矩阵的Cholesky分解。

GPU CPU

mindspore.ops.cholesky_solve

根据Cholesky分解因子 input2 计算一组具有正定矩阵的线性方程组的解。

Ascend GPU CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.cond

返回给定Tensor的矩阵范数或向量范数。

GPU CPU

mindspore.ops.batch_dot

当输入的两个Tensor是批量数据时,对其进行批量点积操作。

Ascend GPU CPU

mindspore.ops.dot

两个Tensor之间的点积。

Ascend GPU CPU

mindspore.ops.eigvals

计算输入方阵(batch方阵)的特征值。

Ascend CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.inner

计算两个1D Tensor的点积。

Ascend GPU CPU

mindspore.ops.inverse

计算输入矩阵的逆。

GPU CPU

mindspore.ops.geqrf

将矩阵分解为正交矩阵 Q 和上三角矩阵 R 的乘积。

Ascend GPU CPU

mindspore.ops.ger

计算输入一维Tensor inputvec2 的外积。

Ascend GPU CPU

mindspore.ops.kron

计算 inputother 的Kronecker积:\(input ⊗ other\)

Ascend GPU CPU

mindspore.ops.lu_solve

给定LU分解结果 \(A\) 和列向量 \(b\),求解线性方程组的解y \(Ay = b\)

Ascend GPU CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.lu_unpack

LU_dataLU_pivots 还原为P、L、U矩阵,其中P为置换矩阵,L为下三角矩阵,U为上三角矩阵。

GPU CPU

mindspore.ops.matmul

计算两个数组的乘积。

Ascend GPU CPU

mindspore.ops.matrix_band_part

将矩阵的每个中心带外的所有位置设置为0。

Ascend GPU CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.matrix_solve

求解线性方程组。

Ascend CPU

当平台为GPU时,如果 matrix 中的矩阵不可逆,将产生错误或者返回一个未知结果。

mindspore.ops.matrix_band_part

将矩阵的每个中心带外的所有位置设置为0。

Ascend GPU CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.matrix_diag

返回一个Tensor,其k[0]到k[1]的对角线特定为给定对角线Tensor,其余值均填充为 padding_value

Ascend GPU CPU

mindspore.ops.matrix_diag_part

返回输入Tensor的对角线部分。

Ascend GPU CPU

mindspore.ops.matrix_set_diag

返回具有新的对角线值的批处理矩阵Tensor。

Ascend GPU CPU

mindspore.ops.mm

计算两个矩阵的乘积。

Ascend GPU CPU

mindspore.ops.mv

实现矩阵 mat 和向量 vec 相乘。

Ascend GPU CPU

mindspore.ops.outer

计算 inputvec2 的外积。

Ascend GPU CPU

mindspore.ops.ormqr

计算一个普通矩阵与Householder矩阵的乘积。

GPU

mindspore.ops.orgqr

计算 mindspore.ops.Geqrf 返回的正交矩阵 \(Q\) 的显式表示。

Ascend GPU CPU

mindspore.ops.ormqr

计算一个普通矩阵与Householder矩阵的乘积。

GPU

mindspore.ops.pinv

计算矩阵的(Moore-Penrose)伪逆。

CPU

mindspore.ops.svd

计算单个或多个矩阵的奇异值分解。

GPU CPU

mindspore.ops.tensor_dot

在指定轴上对Tensor ab 进行点乘操作。

Ascend GPU CPU

mindspore.ops.vecdot

在指定维度上,计算两批向量的点积。

Ascend GPU CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.logdet

计算方块矩阵或批量方块矩阵的对数行列式。

CPU

mindspore.ops.slogdet

对一个或多个方阵行列式的绝对值取对数,返回其符号和值。

Ascend GPU CPU

mindspore.ops.trace

返回 input 的主对角线方向上的总和。

Ascend GPU CPU

mindspore.ops.vander

生成一个范德蒙矩阵。

Ascend GPU CPU

谱函数

接口名

概述

支持平台

警告

mindspore.ops.bartlett_window

Bartlett窗口函数是一种三角形状的加权函数,通常用于平滑处理或频域分析信号。

Ascend GPU CPU

mindspore.ops.blackman_window

布莱克曼窗口函数,常用来为FFT截取有限长的信号片段。

Ascend GPU CPU

mindspore.ops.hamming_window

返回一个Hamming window。

Ascend GPU CPU

mindspore.ops.hann_window

生成一个Hann window。

Ascend GPU CPU

mindspore.ops.kaiser_window

生成一个Kaiser window,也叫做Kaiser-Bessel window。

Ascend GPU CPU

Tensor操作函数

Tensor创建

接口名

概述

支持平台

警告

mindspore.ops.eye

创建一个主对角线上元素为1,其余元素为0的Tensor。

Ascend GPU CPU

mindspore.ops.fill

创建一个指定shape的Tensor,并用指定值填充。

Ascend GPU CPU

mindspore.ops.full

创建一个指定shape的Tensor,并用指定值填充。

Ascend GPU CPU

mindspore.ops.full_like

返回一个shape与 input 相同并且使用 fill_value 填充的Tensor。

Ascend GPU CPU

mindspore.ops.linspace

返回一个在区间 startend (包括 startend )内均匀分布的,包含 steps 个值的一维Tensor。

Ascend GPU CPU

mindspore.ops.logspace

返回一个大小为 steps 的1-D Tensor,其值从 \(base^{start}\)\(base^{end}\) ,以 base 为底数。

Ascend GPU CPU

mindspore.ops.one_hot

返回一个one-hot类型的Tensor。

Ascend GPU CPU

mindspore.ops.ones

创建一个值全为1的Tensor。

Ascend GPU CPU

mindspore.ops.ones_like

返回值为1的Tensor,shape与输入相同。

Ascend GPU CPU

mindspore.ops.arange

返回从 start 开始,步长为 step ,且不超过 end (不包括 end )的序列。

Ascend GPU CPU

mindspore.ops.range

返回从 start 开始,步长为 step ,且不超过 end (不包括 end )的序列。

GPU CPU

mindspore.ops.zeros

创建一个填满0的Tensor,shape由 size 决定, dtype由 dtype 决定。

Ascend GPU CPU

mindspore.ops.zeros_like

创建一个填满0的Tensor,shape由 input 决定,dtype由 dtype 决定。

Ascend GPU CPU

mindspore.ops.heaviside

计算输入中每个元素的 Heaviside 阶跃函数。

Ascend GPU CPU

随机生成函数

接口名

概述

支持平台

警告

mindspore.ops.bernoulli

p 的概率随机将输出的元素设置为0或1,服从伯努利分布。

GPU CPU

mindspore.ops.gamma

根据伽马分布生成随机数。

Ascend

mindspore.ops.laplace

根据拉普拉斯分布生成随机数。

Ascend GPU CPU

mindspore.ops.multinomial

根据输入生成一个多项式分布的Tensor。

Ascend GPU CPU

mindspore.ops.multinomial_with_replacement

返回一个Tensor,其中每行包含从重复采样的多项式分布中抽取的 numsamples 个索引。

CPU

mindspore.ops.rand

返回一个Tensor,shape和dtype由输入决定,其元素为服从均匀分布的 \([0, 1)\) 区间的数字。

Ascend GPU CPU

mindspore.ops.rand_like

返回一个Tensor,shape和dtype由输入决定,其元素为服从均匀分布的 \([0, 1)\) 区间的数字。

Ascend GPU CPU

mindspore.ops.randint

返回一个Tensor,其元素为 [ low , high ) 区间的随机整数。

Ascend GPU CPU

mindspore.ops.randint_like

返回一个Tensor,其元素为 [ low , high ) 区间的随机整数,根据 input 决定shape和dtype。

Ascend GPU CPU

mindspore.ops.randn

返回一个Tensor,shape和dtype由输入决定,其元素为服从标准正态分布的数字。

Ascend GPU CPU

mindspore.ops.randn_like

返回一个Tensor,shape和dtype由输入决定,其元素为服从标准正态分布的数字。

Ascend GPU CPU

mindspore.ops.random_gamma

根据伽马分布产生成随机数。

CPU

mindspore.ops.random_poisson

从一个指定均值为 rate 的泊松分布中,随机生成形状为 shape 的随机数Tensor。

GPU CPU

mindspore.ops.randperm

生成从 0 到 n-1 的整数随机排列。

CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.standard_laplace

生成符合标准Laplace(mean=0, lambda=1)分布的随机数。

Ascend GPU CPU

mindspore.ops.standard_normal

根据标准正态(高斯)随机数分布生成随机数。

Ascend GPU CPU

mindspore.ops.uniform

生成服从均匀分布的随机数。

GPU CPU

Array操作

接口名

概述

支持平台

警告

mindspore.ops.argwhere

返回一个Tensor,包含所有输入Tensor非零数值的位置。

Ascend GPU CPU

mindspore.ops.batch_to_space_nd

用块划分批次维度,并将这些块交错回空间维度。

Ascend GPU CPU

mindspore.ops.bincount

统计 input 中每个值的出现次数。

Ascend GPU CPU

mindspore.ops.block_diag

基于输入Tensor创建块对角矩阵。

Ascend GPU CPU

mindspore.ops.broadcast_to

将输入shape广播到目标shape。

Ascend GPU CPU

mindspore.ops.cat

在指定轴上拼接输入Tensor。

Ascend GPU CPU

mindspore.ops.channel_shuffle

将shape为 \((*, C, H, W)\) 的Tensor的通道划分成 \(g\) 组,并按如下方式重新排列 \((*, \frac{C}{g}, g, H*W)\) ,同时保持原始Tensor的shape不变。

Ascend CPU

mindspore.ops.chunk

沿着指定轴 axis 将输入Tensor切分成 chunks 个sub-tensor。

Ascend GPU CPU

mindspore.ops.column_stack

将多个Tensor沿着水平方向维度堆叠成一个Tensor,即按列拼接。

Ascend GPU CPU

mindspore.ops.concat

在指定轴上拼接输入Tensor。

Ascend GPU CPU

mindspore.ops.conj

逐元素计算输入Tensor的共轭。

Ascend GPU CPU

mindspore.ops.count_nonzero

计算输入Tensor指定轴上的非零元素的数量。

Ascend GPU CPU

mindspore.ops.deepcopy

返回输入Tensor的深拷贝。

Ascend GPU CPU

mindspore.ops.diag

用给定的对角线值构造对角线Tensor。

Ascend GPU CPU

mindspore.ops.diagflat

创建一个二维Tensor,用展开后的 input 作为它的对角线。

Ascend GPU CPU

mindspore.ops.diagonal

返回 input 特定的对角线视图。

Ascend GPU CPU

mindspore.ops.diagonal_scatter

dim1dim2 指定 input 的两个维度,这两个维度上的元素将被视为矩阵的元素,并且将 src 嵌入到该矩阵的对角线上。

Ascend GPU CPU

mindspore.ops.dyn_shape

返回输入Tensor的shape。

Ascend GPU CPU

mindspore.ops.dsplit

沿着第三轴将输入Tensor分割成多个子Tensor。

Ascend GPU CPU

mindspore.ops.dstack

将多个Tensor沿着第三维度进行堆叠。

Ascend GPU CPU

mindspore.ops.einsum

基于爱因斯坦求和约定(Einsum)符号,沿着指定维度对输入Tensor元素的乘积求和。

GPU

mindspore.ops.expand_dims

对输入 input_x 在给定的轴上添加额外维度。

Ascend GPU CPU

mindspore.ops.flip

沿给定轴翻转Tensor中元素的顺序。

Ascend GPU CPU

mindspore.ops.fliplr

将输入Tensor中每一行的元素沿左右进行翻转,但保持矩阵的列不变。

Ascend GPU CPU

mindspore.ops.flipud

将输入Tensor中每一列的元素沿上下进行翻转,但保持矩阵的行不变。

Ascend GPU CPU

mindspore.ops.gather

返回输入Tensor在指定 axisinput_indices 索引对应的元素组成的切片。

Ascend GPU CPU

mindspore.ops.gather_d

获取指定轴的元素。

Ascend GPU CPU

mindspore.ops.gather_elements

获取指定轴的元素。

Ascend GPU CPU

mindspore.ops.gather_nd

根据索引获取输入Tensor指定位置上的元素。

Ascend GPU CPU

mindspore.ops.hsplit

水平地将输入Tensor分割成多个子Tensor。

Ascend GPU CPU

mindspore.ops.hstack

将多个Tensor沿着水平方向进行堆叠。

Ascend GPU CPU

mindspore.ops.index_add

将Tensor y 加到Parameter x 的指定 axis 轴的指定 indices 位置。

Ascend GPU CPU

mindspore.ops.index_fill

index 中给定的顺序选择索引,将输入 value 值填充到输入Tensor x 的所有 axis 维元素。

Ascend GPU CPU

mindspore.ops.index_select

返回一个新的Tensor,该Tensor沿维度 axisindex 中给定的索引对 input 进行选择。

Ascend GPU CPU

mindspore.ops.inplace_add

根据 indices,将 x 中的对应位置加上 v

Ascend GPU CPU

mindspore.ops.inplace_index_add

逐元素将一个Tensor updates 添加到原Tensor var 的指定轴和索引处。

Ascend CPU

mindspore.ops.inplace_sub

v 依照索引 indicesx 中减去。

Ascend GPU CPU

mindspore.ops.inplace_update

根据 indices,将 x 中的某些值更新为 v

GPU CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.is_nonzero

判断输入Tensor是否包含0或False,输入只能是单元素。

Ascend GPU CPU

mindspore.ops.masked_fill

将掩码位置为True的位置填充指定的值。

Ascend GPU CPU

mindspore.ops.masked_select

返回一个一维Tensor,其中的内容是 input 中对应于 mask 中True位置的值。

Ascend GPU CPU

mindspore.ops.meshgrid

从给定的Tensor生成网格矩阵。

Ascend GPU CPU

mindspore.ops.moveaxis

xsource 中位置的维度移动到 destination 中的位置。

Ascend GPU CPU

mindspore.ops.movedim

调换 xsourcedestination 两个维度的位置。

Ascend GPU CPU

mindspore.ops.narrow

沿着指定的轴,指定起始位置获取指定长度的Tensor。

Ascend GPU CPU

mindspore.ops.nan_to_num

input 中的 NaN 、正无穷大和负无穷大值分别替换为 nanposinfneginf 指定的值。

Ascend CPU

mindspore.ops.nanmean

计算 input 指定维度元素的平均值,忽略NaN。

Ascend GPU CPU

mindspore.ops.nanmedian

计算 input 指定维度元素的中值和索引,忽略NaN。

CPU

如果 input 的中值不唯一,则 indices 不一定包含第一个出现的中值。

mindspore.ops.nansum

计算 input 指定维度元素的和,将非数字(NaNs)处理为零。

Ascend GPU CPU

mindspore.ops.normal

根据正态(高斯)随机数分布生成随机数。

Ascend GPU CPU

mindspore.ops.nonzero

计算x中非零元素的下标。

Ascend GPU CPU

mindspore.ops.numel

返回Tensor的元素的总数量。

Ascend GPU CPU

mindspore.ops.permute

按照输入 axis 的维度顺序排列输入Tensor。

Ascend GPU CPU

mindspore.ops.population_count

逐元素计算population count(又称bitsum, bitcount)。

Ascend GPU CPU

mindspore.ops.rank

返回输入Tensor的秩,是一个零维的,数据类型为int32。

Ascend GPU CPU

mindspore.ops.repeat_elements

在指定轴上复制输入Tensor的元素,类似 np.repeat 的功能。

Ascend GPU CPU

mindspore.ops.repeat_interleave

沿着轴重复Tensor的元素,类似 numpy.Repeat

Ascend GPU CPU

mindspore.ops.reshape

基于给定的shape,对输入Tensor进行重新排列。

Ascend GPU CPU

mindspore.ops.reverse

对输入Tensor按指定维度反转。

Ascend GPU CPU

"axis"的取值范围为[-dims, dims - 1],"dims"表示"x"的维度长度。

mindspore.ops.reverse_sequence

对输入序列进行部分反转。

Ascend GPU CPU

mindspore.ops.roll

沿轴移动Tensor的元素。

GPU

mindspore.ops.row_stack

mindspore.ops.vstack() 的别名。

Ascend GPU CPU

mindspore.ops.scatter

根据指定索引将 src 中的值更新到 input 中返回输出。

Ascend GPU CPU

mindspore.ops.scatter_nd

根据指定的索引将更新值散布到新Tensor上。

Ascend GPU CPU

mindspore.ops.select

根据条件判断Tensor中的元素的值,来决定输出中的相应元素是从 x (如果元素值为True)还是从 y (如果元素值为False)中选择。

Ascend GPU CPU

mindspore.ops.select_scatter

src 中的值散布到 input 指定维度 axis 的指定位置 index 上。

Ascend GPU CPU

mindspore.ops.sequence_mask

返回一个表示每个单元的前N个位置的掩码Tensor,内部元素数据类型为bool。

GPU CPU

mindspore.ops.shape

返回输入Tensor的shape。

Ascend GPU CPU

mindspore.ops.shuffle

沿着Tensor第一维随机打乱数据。

Ascend GPU CPU

mindspore.ops.size

返回一个Scalar,类型为整数,表示输入Tensor的大小,即Tensor中元素的总数。

Ascend GPU CPU

mindspore.ops.slice

根据指定shape对输入Tensor进行切片。

Ascend GPU CPU

mindspore.ops.slice_scatter

指定维度上对输入Tensor进行切片并将源Tensor覆盖切片结果。

Ascend GPU CPU

mindspore.ops.sort

按指定顺序对输入Tensor的指定维上的元素进行排序。

Ascend GPU CPU

目前能良好支持的数据类型有:Float16、UInt8、Int8、Int16、Int32、Int64。如果使用Float32,可能产生精度误差。

mindspore.ops.space_to_batch_nd

将空间维度划分为对应大小的块,然后在批次维度重排Tensor。

Ascend GPU CPU

mindspore.ops.sparse_segment_mean

计算输出Tensor \(output_i = \frac{\sum_j x_{indices[j]}}{N}\) ,其中平均是对所有 \(j\) 满足 \(segment\_ids[j] == i\) 的元素, \(N\) 表示相加的元素个数。

GPU CPU

mindspore.ops.split

根据指定的轴将输入Tensor切分成块。

Ascend GPU CPU

mindspore.ops.squeeze

返回删除指定 axis 中大小为1的维度后的Tensor。

Ascend GPU CPU

mindspore.ops.stack

在指定轴上对输入Tensor序列进行堆叠。

Ascend GPU CPU

mindspore.ops.strided_slice

对输入Tensor根据步长和索引进行切片提取。

Ascend GPU CPU

mindspore.ops.sum

计算Tensor指定维度元素的和。

Ascend GPU CPU

mindspore.ops.swapaxes

交换Tensor的两个维度。

Ascend GPU CPU

mindspore.ops.swapdims

交换Tensor的两个维度。

Ascend GPU CPU

mindspore.ops.tensor_scatter_add

根据指定的更新值 updates 和输入索引 indices ,通过相加运算更新输入Tensor的值。

Ascend GPU CPU

mindspore.ops.tensor_scatter_div

根据指定的更新值 updates 和输入索引 indices ,使用除法运算更新 input_x,返回新的Tensor。

GPU CPU

mindspore.ops.tensor_scatter_max

根据指定的更新值 updates 和输入索引 indices ,使用最大值运算更新 input_x,返回一个新的Tensor。

GPU CPU

mindspore.ops.tensor_scatter_min

根据指定的更新值 updates 和输入索引 indices ,使用最小值运算更新 input_x,输出结果通过新的输出Tensor返回。

Ascend GPU CPU

mindspore.ops.tensor_scatter_mul

根据索引,通过乘法运算得到输出Tensor的值。

GPU CPU

mindspore.ops.tensor_scatter_sub

根据指定的更新值和输入索引,通过减法进行运算,将结果赋值到输出Tensor中。

Ascend GPU CPU

mindspore.ops.tensor_scatter_elements

updates 中所有的元素按照 reduction 指定的归约操作写入 input_xindices 指定的索引处。

Ascend GPU CPU

如果 indices 中有多个索引向量对应于同一位置,则输出中该位置值是不确定的。 在Ascend平台上,目前仅支持 reduction 设置为 "none" 的实现。 在Ascend平台上,input_x 仅支持float16和float32两种数据类型。

mindspore.ops.tensor_split

根据指定的轴将输入Tensor进行分割成多个子Tensor。

Ascend GPU CPU

mindspore.ops.tile

按照给定的次数复制输入Tensor。

Ascend GPU CPU

mindspore.ops.tril

返回输入Tensor input 的下三角形部分(包含对角线和下面的元素),并将其他元素设置为0。

Ascend GPU CPU

mindspore.ops.triu

返回输入Tensor input 的上三角形部分(包含对角线和下面的元素),并将其他元素设置为0。

Ascend GPU CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.transpose

根据指定的排列对输入的Tensor进行数据重排。

Ascend GPU CPU

mindspore.ops.unbind

根据指定轴对输入矩阵进行分解。

Ascend GPU CPU

mindspore.ops.unfold

从一个batch的输入Tensor中提取滑动局部块。

Ascend GPU CPU

在2.0rc1版本,该算子的输出为四维Tensor,其shape为 \((N, C, \prod(\text{kernel_size}), L)\) 。 在之后的版本中,其输出则为三维Tensor,其shape为 \((N, C \times \prod(\text{kernel_size}), L)\)

mindspore.ops.unique

对输入Tensor中元素去重,并返回一个索引Tensor,包含输入Tensor中的元素在输出Tensor中的索引。

Ascend GPU CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.unique_consecutive

对输入Tensor中连续且重复的元素去重。

Ascend GPU CPU

mindspore.ops.unique_with_pad

对输入一维Tensor中元素去重,返回一维Tensor中的唯一元素(使用pad_num填充)和相对索引。

Ascend GPU CPU

mindspore.ops.unsorted_segment_max

沿分段计算输入Tensor的最大值。

Ascend GPU CPU

mindspore.ops.unsorted_segment_min

沿分段计算输入Tensor的最小值。

Ascend GPU CPU

mindspore.ops.unsorted_segment_prod

沿分段计算输入Tensor元素的乘积。

Ascend GPU CPU

mindspore.ops.unsorted_segment_sum

沿分段计算输入Tensor元素的和。

Ascend GPU CPU

mindspore.ops.unsqueeze

对输入 input 在给定维上添加额外维度。

Ascend GPU CPU

mindspore.ops.unstack

根据指定轴对输入矩阵进行分解,与 mindspore.ops.stack() 函数操作相反。

Ascend GPU CPU

mindspore.ops.view_as_real

将复数Tensor看作实数Tensor。

GPU CPU

mindspore.ops.vsplit

根据 indices_or_sections 将输入Tensor input 垂直分割成多个子Tensor。

Ascend GPU CPU

mindspore.ops.vstack

将多个Tensor沿着竖直方向进行堆叠。

Ascend GPU CPU

mindspore.ops.where

返回一个Tensor,Tensor的元素从 xy 中根据 condition 选择。

Ascend GPU CPU

mindspore.ops.cross

返回沿着维度 dim 上,inputother 的向量积(叉积)。

Ascend CPU

mindspore.ops.renorm

对Tensor沿着指定维度 dim 进行重新规范化,要求每个子Tensor的 p 范数不超过 maxnorm

Ascend GPU CPU

类型转换

接口名

概述

支持平台

警告

mindspore.ops.is_tensor

判断输入对象是否为 mindspore.Tensor

Ascend GPU CPU

mindspore.ops.scalar_cast

将输入Scalar转换为其他类型。

Ascend GPU CPU

mindspore.ops.scalar_to_tensor

将Scalar转换为指定数据类型的Tensor。

Ascend GPU CPU

mindspore.ops.tuple_to_array

将tuple转换为Tensor。

Ascend GPU CPU

梯度剪裁

接口名

概述

支持平台

警告

mindspore.ops.clip_by_global_norm

通过权重梯度总和的比率来裁剪多个Tensor的值。

Ascend GPU CPU

mindspore.ops.clip_by_value

将输入Tensor值裁剪到指定的最小值和最大值之间。

Ascend GPU CPU

Parameter操作函数

接口名

概述

支持平台

警告

mindspore.ops.assign

为网络参数赋值。

Ascend GPU CPU

mindspore.ops.assign_add

通过加法运算更新网络参数。

Ascend GPU CPU

mindspore.ops.assign_sub

从网络参数减去特定数值来更新网络参数。

Ascend GPU CPU

mindspore.ops.scatter_add

根据指定的更新值和输入索引,进行加法运算更新输入Tensor的值,返回更新后的Tensor。

Ascend GPU CPU

mindspore.ops.scatter_div

根据指定更新值和输入索引通过除法操作更新输入数据的值。

Ascend GPU CPU

mindspore.ops.scatter_max

根据指定更新值和输入索引通过最大值操作更新输入数据的值。

Ascend GPU CPU

mindspore.ops.scatter_min

根据指定更新值和输入索引通过最小值操作更新输入数据的值。

Ascend GPU CPU

mindspore.ops.scatter_mul

根据指定更新值和输入索引通过乘法运算更新输入数据的值。

Ascend GPU CPU

mindspore.ops.scatter_nd_add

将sparse addition应用于Tensor中的单个值或切片。

Ascend GPU CPU

mindspore.ops.scatter_nd_div

将sparse division应用于Tensor中的单个值或切片。

GPU CPU

mindspore.ops.scatter_nd_max

对Tensor中的单个值或切片应用sparse maximum。

Ascend GPU CPU

mindspore.ops.scatter_nd_min

对Tensor中的单个值或切片应用sparse minimum。

Ascend GPU CPU

mindspore.ops.scatter_nd_mul

使用给定值通过乘法运算和输入索引更新Parameter值。

GPU CPU

mindspore.ops.scatter_nd_sub

使用给定值通过减法运算和输入索引更新Tensor值。

Ascend GPU CPU

mindspore.ops.scatter_update

使用给定的更新值和输入索引更新输入Tensor的值。

Ascend GPU CPU

微分函数

接口名

概述

支持平台

警告

mindspore.ops.derivative

计算函数或网络输出对输入的高阶微分。

Ascend GPU CPU

mindspore.ops.jet

计算函数或网络输出对输入的高阶微分。

Ascend GPU CPU

mindspore.ops.stop_gradient

用于消除某个值对梯度的影响,例如截断来自于函数输出的梯度传播。

Ascend GPU CPU

调试函数

接口名

概述

支持平台

警告

mindspore.ops.print_

将输入数据进行打印输出。

Ascend GPU CPU

稀疏函数

警告

这些是实验性API,后续可能修改或删除。

接口名

概述

支持平台

警告

mindspore.ops.dense_to_sparse_coo

将常规Tensor转为稀疏化的COOTensor。

GPU

mindspore.ops.dense_to_sparse_csr

将常规Tensor转为稀疏化的CSRTensor。

GPU

mindspore.ops.csr_to_coo

将一个CSRTensor转化成一个COOTensor。

Ascend GPU CPU

COO函数

警告

这些是实验性API,后续可能修改或删除。

接口名

概述

支持平台

警告

mindspore.ops.coo_abs

逐元素计算输入COOTensor的绝对值。

Ascend GPU CPU

mindspore.ops.coo_acos

逐元素计算输入COOTensor的反余弦。

Ascend GPU CPU

mindspore.ops.coo_acosh

逐元素计算输入COOTensor的反双曲余弦。

Ascend GPU CPU

给定一个输入COOTensor x ,该函数计算每个元素的反双曲余弦。输入范围为[1, inf]。

mindspore.ops.coo_add

两个COOTensor相加,根据相加的结果与 thresh 返回新的COOTensor。

GPU CPU

mindspore.ops.coo_asin

逐元素计算输入COOTensor的反正弦。

Ascend GPU CPU

mindspore.ops.coo_asinh

计算COOTensor输入元素的反双曲正弦。

Ascend GPU CPU

mindspore.ops.coo_atan

逐元素计算输入COOTensor的反正切值。

Ascend GPU CPU

mindspore.ops.coo_atanh

逐元素计算输入COOTensor的反双曲正切值。

Ascend GPU CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.coo_ceil

COOTensor向上取整函数。

Ascend GPU CPU

mindspore.ops.coo_concat

根据指定的轴concat_dim对输入的COO Tensor(sp_input)进行合并操作。

CPU

这是一个实验性API,后续可能修改或删除。目前只支持CPU。

mindspore.ops.coo_cos

逐元素计算COOTensor输入的余弦。

Ascend GPU CPU

目前支持float16、float32数据类型。如果使用float64,可能会存在精度丢失的问题。

mindspore.ops.coo_cosh

逐元素计算COOTensor x 的双曲余弦值。

Ascend GPU CPU

mindspore.ops.coo_exp

逐元素计算COOTensor x 的指数。

Ascend GPU CPU

mindspore.ops.coo_expm1

逐元素计算输入COOTensor的指数,然后减去1。

Ascend GPU CPU

mindspore.ops.coo_floor

COOTensor逐元素向下取整函数。

Ascend GPU CPU

mindspore.ops.coo_inv

逐元素计算输入COOTensor的倒数。

Ascend GPU CPU

mindspore.ops.coo_isfinite

判断COOTensor输入数据每个位置上的值是否是有限数。

Ascend GPU CPU

mindspore.ops.coo_isinf

确定输入COOTensor每个位置上的元素是否为正负无穷大。

GPU CPU

mindspore.ops.coo_isnan

判断COOTensor输入数据每个位置上的值是否是Nan。

Ascend GPU CPU

mindspore.ops.coo_log

逐元素返回COOTensor的自然对数。

Ascend GPU CPU

如果算子Log的输入值在(0, 0.01]或[0.95, 1.05]范围内,则输出精度可能会存在误差。

mindspore.ops.coo_log1p

对输入COOTensor逐元素加一后计算自然对数。

Ascend GPU CPU

mindspore.ops.coo_neg

计算输入COOTensor的相反数并返回。

Ascend GPU CPU

mindspore.ops.coo_relu

对输入的COOTensor逐元素计算其应用ReLU激活函数后的值。

Ascend GPU CPU

mindspore.ops.coo_relu6

对输入的COOTensor计算其应用ReLU激活函数后的值,上限为6。

Ascend GPU CPU

mindspore.ops.coo_round

对COOTensor输入数据进行四舍五入到最接近的整数数值。

Ascend GPU CPU

mindspore.ops.coo_sigmoid

Sigmoid激活函数,COOTensor逐元素计算Sigmoid激活函数。

Ascend GPU CPU

mindspore.ops.coo_sin

逐元素计算输入COOTensor的正弦。

Ascend GPU CPU

mindspore.ops.coo_sinh

逐元素计算输入COOTensor的双曲正弦。

Ascend GPU CPU

mindspore.ops.coo_softsign

COOTensor Softsign激活函数。

Ascend GPU CPU

mindspore.ops.coo_sqrt

逐元素返回当前COOTensor的平方根。

Ascend GPU CPU

mindspore.ops.coo_square

逐元素返回COOTensor的平方。

Ascend GPU CPU

mindspore.ops.coo_tan

计算COOTensor输入元素的正切值。

Ascend GPU CPU

mindspore.ops.coo_tanh

按元素计算COOTensor输入元素的双曲正切。

Ascend GPU CPU

CSR函数

警告

这些是实验性API,后续可能修改或删除。

接口名

概述

支持平台

警告

mindspore.ops.csr_abs

逐元素计算输入CSRTensor的绝对值。

Ascend GPU CPU

mindspore.ops.csr_acos

逐元素计算输入CSRTensor的反余弦。

Ascend GPU CPU

mindspore.ops.csr_acosh

逐元素计算输入CSRTensor的反双曲余弦。

Ascend GPU CPU

mindspore.ops.csr_add

\(a\)\(b\) 是CSRTensor,\(alpha\)\(beta\) 是Tensor。

GPU CPU

mindspore.ops.csr_asin

逐元素计算输入CSRTensor的反正弦。

Ascend GPU CPU

mindspore.ops.csr_asinh

计算CSRTensor输入元素的反双曲正弦。

Ascend GPU CPU

mindspore.ops.csr_atan

逐元素计算输入CSRTensor的反正切值。

Ascend GPU CPU

mindspore.ops.csr_atanh

逐元素计算输入CSRTensor的反双曲正切值。

Ascend GPU CPU

这是一个实验性API,后续可能修改或删除。

mindspore.ops.csr_ceil

CSRTensor向上取整函数。

Ascend GPU CPU

mindspore.ops.csr_cos

逐元素计算CSRTensor输入的余弦。

Ascend GPU CPU

目前支持float16、float32数据类型。如果使用float64,可能会存在精度丢失的问题。

mindspore.ops.csr_cosh

逐元素计算CSRTensor x 的双曲余弦值。

Ascend GPU CPU

mindspore.ops.csr_exp

逐元素计算CSRTensor x 的指数。

Ascend GPU CPU

mindspore.ops.csr_expm1

逐元素计算输入CSRTensor的指数,然后减去1。

Ascend GPU CPU

mindspore.ops.csr_floor

CSRTensor逐元素向下取整函数。

Ascend GPU CPU

mindspore.ops.csr_inv

逐元素计算输入CSRTensor的倒数。

Ascend GPU CPU

mindspore.ops.csr_isfinite

判断CSRTensor输入数据每个位置上的值是否是有限数。

Ascend GPU CPU

mindspore.ops.csr_isinf

确定输入CSRTensor每个位置上的元素是否为无穷大或无穷小。

GPU CPU

mindspore.ops.csr_isnan

判断CSRTensor输入数据每个位置上的值是否是Nan。

Ascend GPU CPU

mindspore.ops.csr_log

逐元素返回CSRTensor的自然对数。

Ascend GPU CPU

如果算子Log的输入值在(0, 0.01]或[0.95, 1.05]范围内,则输出精度可能会存在误差。

mindspore.ops.csr_log1p

对输入CSRTensor逐元素加一后计算自然对数。

Ascend GPU CPU

mindspore.ops.csr_mm

返回稀疏矩阵a与稀疏矩阵或稠密矩阵b的矩阵乘法结果。

GPU

mindspore.ops.csr_neg

计算输入CSRTensor的相反数并返回。

Ascend GPU CPU

mindspore.ops.csr_relu

逐元素计算CSRTensor的ReLU(Rectified Linear Unit)激活值。

Ascend GPU CPU

mindspore.ops.csr_relu6

逐元素计算CSRTensor的ReLU值,其上限为6。

Ascend GPU CPU

mindspore.ops.csr_round

对CSRTensor输入数据进行四舍五入到最接近的整数数值。

Ascend GPU CPU

mindspore.ops.csr_sigmoid

Sigmoid激活函数,CSRTensor逐元素计算Sigmoid激活函数。

Ascend GPU CPU

mindspore.ops.csr_sin

逐元素计算输入CSRTensor的正弦。

Ascend GPU CPU

mindspore.ops.csr_sinh

逐元素计算输入CSRTensor的双曲正弦。

Ascend GPU CPU

mindspore.ops.csr_softmax

计算 CSRTensorMatrix 的 softmax 。

GPU CPU

mindspore.ops.csr_softsign

CSRTensor Softsign激活函数。

Ascend GPU CPU

mindspore.ops.csr_sqrt

逐元素返回当前CSRTensor的平方根。

Ascend GPU CPU

mindspore.ops.csr_square

逐元素返回CSRTensor的平方。

Ascend GPU CPU

mindspore.ops.csr_tan

逐元素计算CSRTensor的正切值。

Ascend GPU CPU

mindspore.ops.csr_tanh

逐元素计算CSRTensor输入元素的双曲正切。

Ascend GPU CPU