mindspore.Tensor

class mindspore.Tensor(input_data=None, dtype=None, shape=None, init=None, internal=False, const_arg=False, device=None)[源代码]

张量,即存储多维数组(n-dimensional array)的数据结构。

说明

当使用 init 参数来初始化 Tensor 时,通常需要使用 Tensor.init_data 来加载 Tensor 的数据。

警告

当转换 Tensor 类型时,推荐使用 Tensor.astype() 而非 Tensor(sourceTensor, dtype=newDtype)

参数:
  • input_data (Union[Tensor, float, int, bool, tuple, list, numpy.ndarray]) - 被存储的数据,可以是其他Tensor,也可以是Python基本数据(如int,float,bool等),或是一个NumPy对象。默认值: None

  • dtype (mindspore.dtype) - 用于定义该Tensor的数据类型,必须是 mindspore.dtype 中定义的类型。如果该参数为 None ,则数据类型与 input_data 一致,默认值: None

  • shape (Union[tuple, list, int, mindspore.Symbol]) - 用于定义该Tensor的形状。如果指定了 input_data ,则无需设置该参数。如果 shape 中存在 NoneSymbol 类型数据,表示创建一个动态形状(dynamic shape)的Tensor,此时不需要设置 input_data 参数;如果 shape 中仅存在整数类型数据,表示创建一个静态形状(static shape)的Tensor,此时必须设置 input_datainit 参数。默认值: None

  • init (Initializer) - 用于在并行模式中延迟Tensor的数据的初始化,如果指定该参数,则 dtypeshape 也必须被指定。默认值: None

  • internal (bool) - Tensor是否由框架创建。如果为 True ,表示Tensor是由框架创建的,如果为 False ,表示Tensor是由用户创建的。默认值: False

  • const_arg (bool) - 指定该Tensor作为网络输入时是否为常量。默认值: False

  • device (str) - 该参数为保留参数,不需要用户配置。默认值: None

输出:

Tensor。

说明

input_data 的默认值 None 只作为一个占位符,并不意味着可以创建一个NoneType的Tensor。 当前对 shape 中包含0的Tensor支持的不完善。

样例:

>>> import numpy as np
>>> import mindspore as ms
>>> from mindspore import Tensor
>>> from mindspore.common.initializer import One
>>> # initialize a tensor with numpy.ndarray
>>> t1 = Tensor(np.zeros([1, 2, 3]), ms.float32)
>>> print(t1)
[[[0. 0. 0.]
[0. 0. 0.]]]
>>> print(type(t1))
<class 'mindspore.common.tensor.Tensor'>
>>> print(t1.shape)
(1, 2, 3)
>>> print(t1.dtype)
Float32
>>>
>>> # initialize a tensor with a float scalar
>>> t2 = Tensor(0.1)
>>> print(t2)
0.1
>>> print(type(t2))
<class 'mindspore.common.tensor.Tensor'>
>>> print(t2.shape)
()
>>> print(t2.dtype)
Float32
>>>
>>> # initialize a tensor with a tuple
>>> t3 = Tensor((1, 2))
>>> print(t3)
[1 2]
>>> print(type(t3))
<class 'mindspore.common.tensor.Tensor'>
>>> print(t3.shape)
(2,)
>>> print(t3.dtype)
Int64
...
>>> # initialize a tensor with init
>>> t4 = Tensor(shape = (1, 3), dtype=ms.float32, init=One())
>>> print(t4)
[[1. 1. 1.]]
>>> print(type(t4))
<class 'mindspore.common.tensor.Tensor'>
>>> print(t4.shape)
(1, 3)
>>> print(t4.dtype)
Float32

mindspore.Tensor.__abs__

mindspore.Tensor.abs() 的别名。

mindspore.Tensor.__add__

mindspore.Tensor.add() 的别名。

mindspore.Tensor.abs

逐元素计算 self 的绝对值。

mindspore.Tensor.absolute

mindspore.Tensor.abs() 的别名。

mindspore.Tensor.acos

详情请参考 mindspore.ops.acos()

mindspore.Tensor.acosh

详情请参考 mindspore.ops.acosh()

mindspore.Tensor.add

selfother 逐元素相加。

mindspore.Tensor.addbmm

详情请参考 mindspore.ops.addbmm()

mindspore.Tensor.addcdiv

详情请参考 mindspore.ops.addcdiv()

mindspore.Tensor.addcmul

详情请参考 mindspore.ops.addcmul()

mindspore.Tensor.addmm

详情请参考 mindspore.ops.addmm()

mindspore.Tensor.addmm_

详情请参考 mindspore.ops.addmm()

mindspore.Tensor.addmv

详情请参考 mindspore.ops.addmv()

mindspore.Tensor.addr

详情请参考 mindspore.ops.addr()

mindspore.Tensor.adjoint

详情请参考 mindspore.ops.adjoint()

mindspore.Tensor.all

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

mindspore.Tensor.amax

详情请参考 mindspore.ops.amax()

mindspore.Tensor.amin

详情请参考 mindspore.ops.amin()

mindspore.Tensor.aminmax

详情请参考 mindspore.ops.aminmax()

mindspore.Tensor.any

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

mindspore.Tensor.angle

详情请参考 mindspore.ops.angle()

mindspore.Tensor.approximate_equal

详情请参考 mindspore.ops.approximate_equal()

mindspore.Tensor.arccos

mindspore.Tensor.acos() 的别名。

mindspore.Tensor.arccosh

详情请参考 mindspore.ops.arccosh()

mindspore.Tensor.arcsin

详情请参考 mindspore.ops.arcsin()

mindspore.Tensor.arcsinh

mindspore.Tensor.asinh() 的别名。

mindspore.Tensor.arctan

详情请参考 mindspore.ops.arctan()

mindspore.Tensor.arctan2

mindspore.Tensor.atan2() 的别名。

mindspore.Tensor.arctanh

mindspore.Tensor.atanh() 的别名。

mindspore.Tensor.argmax

返回 self 在指定轴上的最大值索引。

mindspore.Tensor.argmax_with_value

根据指定的索引计算最大值,并返回索引和值。

mindspore.Tensor.argmin

返回 self 在指定轴上的最小值索引。

mindspore.Tensor.argmin_with_value

根据指定的索引计算最小值,并返回索引和值。

mindspore.Tensor.argsort

详情请参考 mindspore.ops.argsort()

mindspore.Tensor.argwhere

详情请参考 mindspore.ops.argwhere()

mindspore.Tensor.asin

详情请参考 mindspore.ops.asin()

mindspore.Tensor.asinh

详情请参考 mindspore.ops.asinh()

mindspore.Tensor.asnumpy

将张量转换为NumPy数组。

mindspore.Tensor.assign_value

将另一个Tensor的值赋给当前Tensor。

mindspore.Tensor.astype

将Tensor转为指定数据类型,可指定是否返回副本。

mindspore.Tensor.atan

详情请参考 mindspore.ops.atan()

mindspore.Tensor.atan2

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

mindspore.Tensor.atanh

详情请参考 mindspore.ops.atanh()

mindspore.Tensor.baddbmm

详情请参考 mindspore.ops.baddbmm()

mindspore.Tensor.bernoulli

详情请参考 mindspore.ops.bernoulli()

mindspore.Tensor.bincount

详情请参考 mindspore.ops.bincount()

mindspore.Tensor.bitwise_and

详情请参考 mindspore.ops.bitwise_and()

mindspore.Tensor.bitwise_left_shift

详情请参考 mindspore.ops.bitwise_left_shift()

mindspore.Tensor.bitwise_or

详情请参考 mindspore.ops.bitwise_or()

mindspore.Tensor.bitwise_right_shift

详情请参考 mindspore.ops.bitwise_right_shift()

mindspore.Tensor.bitwise_xor

详情请参考 mindspore.ops.bitwise_xor()

mindspore.Tensor.bmm

详情请参考 mindspore.ops.bmm()

mindspore.Tensor.bool

将输入Tensor转换为 bool 类型,其中Tensor中的值为0时,则为False;非0时,则为True。

mindspore.Tensor.broadcast_to

详情请参考 mindspore.ops.broadcast_to()

mindspore.Tensor.byte

将输入Tensor转换为 uint8 类型。

mindspore.Tensor.cauchy

使用柯西分布生成的数值填充当前Tensor。

mindspore.Tensor.ceil

向上取整函数。

mindspore.Tensor.cholesky

详情请参考 mindspore.ops.cholesky()

mindspore.Tensor.cholesky_solve

详情请参考 mindspore.ops.cholesky_solve()

mindspore.Tensor.choose

根据原始Tensor数组和一个索引数组构造一个新的Tensor。

mindspore.Tensor.chunk

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

mindspore.Tensor.clamp

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

mindspore.Tensor.clip

mindspore.Tensor.clamp() 的别名。

mindspore.Tensor.col2im

详情请参考 mindspore.ops.col2im()

mindspore.Tensor.conj

详情请参考 mindspore.ops.conj()

mindspore.Tensor.contiguous

将Tensor转成一个连续内存的Tensor,该Tensor包含与原Tensor相同的数据。

mindspore.Tensor.copy

复制一个Tensor并返回。

mindspore.Tensor.copysign

详情请参考 mindspore.ops.copysign()

mindspore.Tensor.cos

逐元素计算输入的余弦。

mindspore.Tensor.cosh

详情请参考 mindspore.ops.cosh()

mindspore.Tensor.count_nonzero

详情请参考 mindspore.ops.count_nonzero()

mindspore.Tensor.cov

详情请参考 mindspore.ops.cov()

mindspore.Tensor.cross

详情请参考 mindspore.ops.cross()

mindspore.Tensor.cummax

详情请参考 mindspore.ops.cummax()

mindspore.Tensor.cummin

详情请参考 mindspore.ops.cummin()

mindspore.Tensor.cumprod

详情请参考 mindspore.ops.cumprod()

mindspore.Tensor.cumsum

计算输入Tensor self 沿轴 dim 的累积和。

mindspore.Tensor.deg2rad

详情请参考 mindspore.ops.deg2rad()

mindspore.Tensor.diag

详情请参考 mindspore.ops.diag()

mindspore.Tensor.diagflat

详情请参考 mindspore.ops.diagflat()

mindspore.Tensor.diagonal

详情请参考 mindspore.ops.diagonal()

mindspore.Tensor.diagonal_scatter

详情请参考 mindspore.ops.diagonal_scatter()

mindspore.Tensor.diff

详情请参考 mindspore.ops.diff()

mindspore.Tensor.digamma

详情请参考 mindspore.ops.digamma()

mindspore.Tensor.div

逐元素计算当前Tensor除以输入的另一个Tensor的商。

mindspore.Tensor.divide

mindspore.Tensor.div() 的别名。

mindspore.Tensor.dot

详情请参考 mindspore.ops.dot()

mindspore.Tensor.dsplit

详情请参考 mindspore.ops.dsplit()

mindspore.Tensor.dtype

返回张量的数据类型(mindspore.dtype)。

mindspore.Tensor.eigvals

详情请参考 mindspore.ops.eigvals()

mindspore.Tensor.eq

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

mindspore.Tensor.equal

详情请参考 mindspore.ops.equal()

mindspore.Tensor.erf

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

mindspore.Tensor.erfc

详情请参考 mindspore.ops.erfc()

mindspore.Tensor.erfinv

详情请参考 mindspore.ops.erfinv()

mindspore.Tensor.exp

逐元素计算 self 的指数。

mindspore.Tensor.expand_as

将目标张量的维度扩展为输入张量的维度。

mindspore.Tensor.expand_dims

详情请参考 mindspore.ops.expand_dims()

mindspore.Tensor.expm1

详情请参考 mindspore.ops.expm1()

mindspore.Tensor.fill_diagonal

self Tensor的主对角线,填充成指定的值,并返回结果。

mindspore.Tensor.flatten

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

mindspore.Tensor.flip

详情请参考 mindspore.ops.flip()

mindspore.Tensor.fliplr

详情请参考 mindspore.ops.fliplr()

mindspore.Tensor.flipud

详情请参考 mindspore.ops.flipud()

mindspore.Tensor.float

将输入Tensor转换为 float32 类型。

mindspore.Tensor.float_power

详情请参考 mindspore.ops.float_power()

mindspore.Tensor.floor

逐元素向下取整函数。

mindspore.Tensor.floor_divide

详情请参考 mindspore.ops.floor_divide()

mindspore.Tensor.flush_from_cache

如果Tensor开启缓存作用,则将缓存数据刷新到host侧。

mindspore.Tensor.fmax

详情请参考 mindspore.ops.fmax()

mindspore.Tensor.fmod

详情请参考 mindspore.ops.fmod()

mindspore.Tensor.fold

详情请参考 mindspore.ops.fold()

mindspore.Tensor.frac

详情请参考 mindspore.ops.frac()

mindspore.Tensor.from_numpy

将Numpy数组转换为张量。

mindspore.Tensor.gather

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

mindspore.Tensor.gather_elements

详情请参考 mindspore.ops.gather_elements()

mindspore.Tensor.gather_nd

详情请参考 mindspore.ops.gather_nd()

mindspore.Tensor.ge

详情请参考 mindspore.ops.ge()

mindspore.Tensor.ger

详情请参考 mindspore.ops.ger()

mindspore.Tensor.geqrf

详情请参考 mindspore.ops.geqrf()

mindspore.Tensor.greater

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

mindspore.Tensor.greater_equal

详情请参考 mindspore.ops.greater_equal()

mindspore.Tensor.gt

详情请参考 mindspore.ops.gt()

mindspore.Tensor.H

返回共轭和转置的矩阵(2-D Tensor)的视图。

mindspore.Tensor.half

将输入Tensor转换为 float16 类型。

mindspore.Tensor.hardshrink

详情请参考 mindspore.ops.hardshrink()

mindspore.Tensor.has_init

Tensor是否已经初始化。

mindspore.Tensor.heaviside

详情请参考 mindspore.ops.heaviside()

mindspore.Tensor.histc

详情请参考 mindspore.ops.histc()

mindspore.Tensor.hsplit

详情请参考 mindspore.ops.hsplit()

mindspore.Tensor.hypot

详情请参考 mindspore.ops.hypot()

mindspore.Tensor.i0

详情请参考 mindspore.ops.i0()

mindspore.Tensor.igamma

详情请参考 mindspore.ops.igamma()

mindspore.Tensor.igammac

详情请参考 mindspore.ops.igammac()

mindspore.Tensor.imag

详情请参考 mindspore.ops.imag()

mindspore.Tensor.index_add

详情请参考 mindspore.ops.index_add()

mindspore.Tensor.index_fill

详情请参考 mindspore.ops.index_fill()

mindspore.Tensor.index_put

返回一个Tensor。

mindspore.Tensor.index_put_

返回一个Tensor。

mindspore.Tensor.index_select

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

mindspore.Tensor.init_data

获取此Tensor的数据。

mindspore.Tensor.inner

详情请参考 mindspore.ops.inner()

mindspore.Tensor.inplace_update

详情请参考 mindspore.ops.inplace_update()

mindspore.Tensor.int

将输入Tensor转换为 int32 类型,其中Tensor中的值为浮点数时,则会丢弃小数部分。

mindspore.Tensor.inv

详情请参考 mindspore.ops.inv()

mindspore.Tensor.inverse

详情请参考 mindspore.ops.inverse()

mindspore.Tensor.invert

详情请参考 mindspore.ops.invert()

mindspore.Tensor.isclose

详情请参考 mindspore.ops.isclose()

mindspore.Tensor.isfinite

详情请参考 mindspore.ops.isfinite()

mindspore.Tensor.is_complex

详情请参考 mindspore.ops.is_complex()

mindspore.Tensor.is_contiguous

判断Tensor的内存是否连续。

mindspore.Tensor.is_floating_point

详情请参考 mindspore.ops.is_floating_point()

mindspore.Tensor.isinf

详情请参考 mindspore.ops.isinf()

mindspore.Tensor.isnan

详情请参考 mindspore.ops.isnan()

mindspore.Tensor.isneginf

详情请参考 mindspore.ops.isneginf()

mindspore.Tensor.isposinf

详情请参考 mindspore.ops.isposinf()

mindspore.Tensor.isreal

详情请参考 mindspore.ops.isreal()

mindspore.Tensor.is_signed

判断输入Tensor的dtype是否是有符号数类型。

mindspore.Tensor.item

获取Tensor中指定索引的元素。

mindspore.Tensor.itemset

将标量插入到Tensor(并将标量转换为Tensor的数据类型)。

mindspore.Tensor.itemsize

返回一个Tensor元素的长度(以字节为单位)。

mindspore.Tensor.lcm

详情请参考 mindspore.ops.lcm()

mindspore.Tensor.ldexp

详情请参考 mindspore.ops.ldexp()

mindspore.Tensor.le

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

mindspore.Tensor.lerp

详情请参考 mindspore.ops.lerp()

mindspore.Tensor.less

逐元素计算 \(self < other\) ,返回为bool。

mindspore.Tensor.less_equal

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

mindspore.Tensor.log

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

mindspore.Tensor.log10

详情请参考 mindspore.ops.log10()

mindspore.Tensor.log1p

详情请参考 mindspore.ops.log1p()

mindspore.Tensor.log2

详情请参考 mindspore.ops.log2()

mindspore.Tensor.logaddexp

详情请参考 mindspore.ops.logaddexp()

mindspore.Tensor.logaddexp2

详情请参考 mindspore.ops.logaddexp2()

mindspore.Tensor.logcumsumexp

详情请参考 mindspore.ops.logcumsumexp()

mindspore.Tensor.logdet

详情请参考 mindspore.ops.logdet()

mindspore.Tensor.logical_and

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

mindspore.Tensor.logical_not

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

mindspore.Tensor.logical_or

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

mindspore.Tensor.logical_xor

详情请参考 mindspore.ops.logical_xor()

mindspore.Tensor.logit

详情请参考 mindspore.ops.logit()

mindspore.Tensor.logsumexp

详情请参考 mindspore.ops.logsumexp()

mindspore.Tensor.log_normal

使用给定均值 mean 和标准差 std 的对数正态分布的数值填充当前Tensor。

mindspore.Tensor.long

将输入Tensor转换为 int64 类型,其中Tensor中的值为浮点数时,则会丢弃小数部分。

mindspore.Tensor.lt

mindspore.Tensor.less() 的别名。

mindspore.Tensor.lu_solve

详情请参考 mindspore.ops.lu_solve()

mindspore.Tensor.masked_fill

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

mindspore.Tensor.masked_scatter

返回一个Tensor。

mindspore.Tensor.masked_select

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

mindspore.Tensor.matmul

计算两个数组的矩阵乘积。

mindspore.Tensor.max

返回Tensor的最大值或轴方向上的最大值。

mindspore.Tensor.maximum

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

mindspore.Tensor.mean

默认情况下,移除输入所有维度,返回 input 中所有元素的平均值,也可仅缩小指定维度 axis 大小至1。

mindspore.Tensor.median

详情请参考 mindspore.ops.median()

mindspore.Tensor.mH

访问此属性等价于调用self.adjoint()方法。

mindspore.Tensor.min

返回Tensor元素中的最小值或沿 axis 轴方向上的最小值。

mindspore.Tensor.minimum

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

mindspore.Tensor.mm

详情请参考 mindspore.ops.mm()

mindspore.Tensor.movedim

详情请参考 mindspore.ops.movedim()

mindspore.Tensor.moveaxis

详情请参考 mindspore.ops.moveaxis()

mindspore.Tensor.move_to

同步或异步的方式将Tensor拷贝到目标设备上,默认同步方式。

mindspore.Tensor.msort

详情请参考 mindspore.ops.msort()

mindspore.Tensor.mT

返回将最后两个维度交换的Tensor。

mindspore.Tensor.mul

两个Tensor逐元素相乘。

mindspore.Tensor.multinomial

详情请参考 mindspore.ops.multinomial()

mindspore.Tensor.multiply

详情请参考 mindspore.ops.multiply()

mindspore.Tensor.mvlgamma

详情请参考 mindspore.ops.mvlgamma()

mindspore.Tensor.nan_to_num

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

mindspore.Tensor.nanmean

详情请参考 mindspore.ops.nanmean()

mindspore.Tensor.nanmedian

详情请参考 mindspore.ops.nanmedian()

mindspore.Tensor.nansum

详情请参考 mindspore.ops.nansum()

mindspore.Tensor.narrow

详情请参考 mindspore.ops.narrow()

mindspore.Tensor.nbytes

返回Tensor占用的总字节数。

mindspore.Tensor.ndim

返回Tensor维度的数量。

mindspore.Tensor.ndimension

mindspore.Tensor.ndim() 的别名。

mindspore.Tensor.ne

计算两个Tensor是否不相等。

mindspore.Tensor.neg

计算 self 的相反数并返回。

mindspore.Tensor.negative

mindspore.Tensor.neg() 的别名。

mindspore.Tensor.nelement

mindspore.Tensor.numel() 的别名。

mindspore.Tensor.new_ones

返回一个大小为 size 的Tensor,填充值为1。

mindspore.Tensor.new_zeros

返回一个大小为 size 的Tensor,填充值为0。

mindspore.Tensor.nextafter

详情请参考 mindspore.ops.nextafter()

mindspore.Tensor.numel

详情请参考 mindspore.ops.numel()

mindspore.Tensor.numpy

mindspore.Tensor.asnumpy() 的别名。

mindspore.Tensor.nonzero

详情请参考 mindspore.ops.nonzero()

mindspore.Tensor.norm

详情请参考 mindspore.ops.norm()

mindspore.Tensor.not_equal

mindspore.Tensor.ne() 的别名。

mindspore.Tensor.outer

详情请参考 mindspore.ops.outer()

mindspore.Tensor.orgqr

详情请参考 mindspore.ops.orgqr()

mindspore.Tensor.ormqr

详情请参考 mindspore.ops.ormqr(),其中参数 input2input3 分别对应 mindspore.ops.ormqr() 的参数 tauother

mindspore.Tensor.permute

详情请参考 mindspore.ops.permute()

mindspore.Tensor.positive

详情请参考 mindspore.ops.positive()

mindspore.Tensor.pow

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

mindspore.Tensor.prod

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

mindspore.Tensor.ptp

该函数名称是"peak to peak"的缩写。

mindspore.Tensor.rad2deg

详情请参考 mindspore.ops.rad2deg()

mindspore.Tensor.random_categorical

详情请参考 mindspore.ops.random_categorical()

mindspore.Tensor.ravel

返回一个展开的一维Tensor。

mindspore.Tensor.real

详情请参考 mindspore.ops.real()

mindspore.Tensor.reciprocal

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

mindspore.Tensor.remainder

详情请参考 mindspore.ops.remainder()

mindspore.Tensor.renorm

详情请参考 mindspore.ops.renorm()

mindspore.Tensor.repeat

对数组中的元素进行重复复制。

mindspore.Tensor.repeat_interleave

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

mindspore.Tensor.reshape

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

mindspore.Tensor.reshape_as

不改变数据的情况下,将Tensor的shape改为 other 的shape。

mindspore.Tensor.resize

将Tensor改为输入的新shape,并将不足的元素补0。

mindspore.Tensor.reverse

详情请参考 mindspore.ops.flip()

mindspore.Tensor.reverse_sequence

详情请参考 mindspore.ops.reverse_sequence()

mindspore.Tensor.roll

详情请参考 mindspore.ops.roll()

mindspore.Tensor.round

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

mindspore.Tensor.rot90

详情请参考 mindspore.ops.rot90()

mindspore.Tensor.rsqrt

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

mindspore.Tensor.register_hook

设置Tensor对象的反向hook函数。

mindspore.Tensor.scatter

详情请参考 mindspore.ops.scatter()

mindspore.Tensor.scatter_add

详情请参考 mindspore.ops.scatter_add()

mindspore.Tensor.scatter_div

详情请参考 mindspore.ops.scatter_div()

mindspore.Tensor.scatter_max

详情请参考 mindspore.ops.scatter_max()

mindspore.Tensor.scatter_min

详情请参考 mindspore.ops.scatter_min()

mindspore.Tensor.scatter_mul

详情请参考 mindspore.ops.scatter_mul()

mindspore.Tensor.scatter_sub

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

mindspore.Tensor.searchsorted

查找应插入元素在有序数列中的位置索引。

mindspore.Tensor.select

沿着选定的维度在给定的索引处进行切片。

mindspore.Tensor.select_scatter

详情请参考 mindspore.ops.select_scatter()

mindspore.Tensor.set_const_arg

指定该Tensor在作为网络入参时是否是一个常量。

mindspore.Tensor.sgn

详情请参考 mindspore.ops.sgn()

mindspore.Tensor.shape

详情请参考 mindspore.ops.shape()

mindspore.Tensor.short

将输入Tensor转换为 int16 类型并返回一个拷贝,与 self.astype(mstype.int16) 等价,其中Tensor中的值为浮点数时,则会丢弃小数部分,具体请参考 mindspore.Tensor.astype()

mindspore.Tensor.sigmoid

详情请参考 mindspore.ops.sigmoid()

mindspore.Tensor.sign

详情请参考 mindspore.ops.sign()

mindspore.Tensor.signbit

详情请参考 mindspore.ops.signbit()

mindspore.Tensor.sin

逐元素计算 self 的正弦。

mindspore.Tensor.sinc

详情请参考 mindspore.ops.sinc()

mindspore.Tensor.sinh

详情请参考 mindspore.ops.sinh()

mindspore.Tensor.size

详情请参考 mindspore.ops.size()

mindspore.Tensor.slice_scatter

详情请参考 mindspore.ops.slice_scatter()

mindspore.Tensor.slogdet

详情请参考 mindspore.ops.slogdet()

mindspore.Tensor.softmax

详情请参考 mindspore.ops.softmax()

mindspore.Tensor.sort

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

mindspore.Tensor.split

详情请参考 mindspore.ops.split()

mindspore.Tensor.sqrt

逐元素计算 self 的平方根。

mindspore.Tensor.square

逐元素计算 self 的平方。

mindspore.Tensor.squeeze

详情请参考 mindspore.ops.squeeze()

mindspore.Tensor.std

详情请参考 mindspore.ops.std()

mindspore.Tensor.storage_offset

以储存元素的个数的形式返回Tensor在内存中的偏移量。

mindspore.Tensor.stride

在指定维度 dim中 从一个元素跳到下一个元素所必需的步长。

mindspore.Tensor.strides

Tensor上每个维度跨度的字节元组。

mindspore.Tensor.sub

从输入的Tensor中减去另外一个经过缩放的值。

mindspore.Tensor.subtract

详情请参考 mindspore.ops.subtract()

mindspore.Tensor.sum

返回指定维度上数组元素的总和。

mindspore.Tensor.sum_to_size

将原Tensor按照指定 size 进行求和。

mindspore.Tensor.svd

详情请参考 mindspore.ops.svd()

mindspore.Tensor.swapaxes

详情请参考 mindspore.ops.swapaxes()

mindspore.Tensor.swapdims

详情请参考 mindspore.ops.swapdims()

mindspore.Tensor.T

返回转置后的Tensor。

mindspore.Tensor.t

详情请参考 mindspore.ops.t()

mindspore.Tensor.take

在指定维度上获取Tensor中的元素。

mindspore.Tensor.tan

详情请参考 mindspore.ops.tan()

mindspore.Tensor.tanh

逐元素计算自身元素的双曲正切。

mindspore.Tensor.tensor_split

详情请参考 mindspore.ops.tensor_split()

mindspore.Tensor.tile

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

mindspore.Tensor.to

执行Tensor类型的转换。

mindspore.Tensor.to_coo

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

mindspore.Tensor.to_csr

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

mindspore.Tensor.tolist

将Tensor转为列表,如果输入是Tensor scalar,将会返回Python标量。

mindspore.Tensor.topk

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

mindspore.Tensor.trace

在Tensor的对角线方向上的总和。

mindspore.Tensor.transpose

详情请参考 mindspore.ops.transpose()

mindspore.Tensor.tril

详情请参考 mindspore.ops.tril()

mindspore.Tensor.triu

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

mindspore.Tensor.true_divide

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

mindspore.Tensor.trunc

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

mindspore.Tensor.type

将Tensor的dtype转换成 dtype

mindspore.Tensor.type_as

将Tensor的dtype转换成 other 的dtype。

mindspore.Tensor.unbind

详情请参考 mindspore.ops.unbind()

mindspore.Tensor.unfold

详情请参考 mindspore.ops.unfold()

mindspore.Tensor.uniform

在半开区间 [from_, to) 内生成随机数。

mindspore.Tensor.unique_consecutive

详情请参考 mindspore.ops.unique_consecutive()

mindspore.Tensor.unique_with_pad

详情请参考 mindspore.ops.unique_with_pad()

mindspore.Tensor.unsorted_segment_max

详情请参考 mindspore.ops.unsorted_segment_max()

mindspore.Tensor.unsorted_segment_min

详情请参考 mindspore.ops.unsorted_segment_min()

mindspore.Tensor.unsorted_segment_prod

详情请参考 mindspore.ops.unsorted_segment_prod()

mindspore.Tensor.unsqueeze

详情请参考 mindspore.ops.unsqueeze()

mindspore.Tensor.var

在指定维度上的方差。

mindspore.Tensor.view

根据输入shape重新创建一个Tensor,与原Tensor数据相同。

mindspore.Tensor.view_as

根据 other 的shape改变原Tensor的shape。

mindspore.Tensor.vsplit

详情请参考 mindspore.ops.vsplit()

mindspore.Tensor.where

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

mindspore.Tensor.xdivy

详情请参考 mindspore.ops.xdivy()

mindspore.Tensor.xlogy

详情请参考 mindspore.ops.xlogy()