mindspore.Tensor

class mindspore.Tensor(input_data=None, dtype=None, shape=None, init=None, const_arg=False, device=None)

张量，即存储多维数组（n-dimensional array）的数据结构。

说明

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

• CPU、GPU 的所有模式，以及 Atlas 训练系列产品的 图模式(mode=mindspore.GRAPH_MODE) 尚不支持in-place操作。

• input_data 的默认值 None 只作为一个占位符，并不意味着可以创建一个 NoneType 的 Tensor 。

• 当前对 shape 中包含0的 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 中存在 None 或 Symbol 类型数据，表示创建一个动态形状（dynamic shape）的Tensor，此时不需要设置 input_data 参数；如果 shape 中仅存在整数类型数据，表示创建一个静态形状（static shape）的Tensor，此时必须设置 input_data 或 init 参数。默认值： None 。

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

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

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

输出：

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())
>>> t4.init_data()
>>> 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.ops.abs()。
mindspore.Tensor.absolute	mindspore.Tensor.abs() 的别名。
mindspore.Tensor.acos	详情请参考 mindspore.ops.acos()。
mindspore.Tensor.acosh	详情请参考 mindspore.ops.acosh()。
mindspore.Tensor.add_	mindspore.Tensor.add() 的in-place版本。
mindspore.Tensor.add	对 other 缩放后与 self 相加。
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.Tensor.addmm() 的in-place版本。
mindspore.Tensor.addmv	详情请参考 mindspore.ops.addmv()。
mindspore.Tensor.addr	详情请参考 mindspore.ops.addr()。
mindspore.Tensor.adjoint	详情请参考 mindspore.ops.adjoint()。
mindspore.Tensor.all	检查指定维度上是否所有元素均为 True。
mindspore.Tensor.allclose	返回一个布尔型标量，表示 self 的每个元素均与 other 的对应元素在给定容忍度内“接近”。
mindspore.Tensor.amax	详情请参考 mindspore.ops.amax()。
mindspore.Tensor.amin	详情请参考 mindspore.ops.amin()。
mindspore.Tensor.aminmax	详情请参考 mindspore.ops.aminmax()。
mindspore.Tensor.any	详情请参考 mindspore.mint.any()。
mindspore.Tensor.angle	详情请参考 mindspore.ops.angle()。
mindspore.Tensor.approximate_equal	详情请参考 mindspore.ops.approximate_equal()， 当前接口参数 other 和参考接口中的参数 y 实际为同一参数。
mindspore.Tensor.arccos	mindspore.Tensor.acos() 的别名。
mindspore.Tensor.arccosh	mindspore.Tensor.acosh() 的别名。
mindspore.Tensor.arcsin	mindspore.Tensor.asin() 的别名。
mindspore.Tensor.arcsinh	mindspore.Tensor.asinh() 的别名。
mindspore.Tensor.arctan	mindspore.Tensor.atan() 的别名。
mindspore.Tensor.arctan2	mindspore.Tensor.atan2() 的别名。
mindspore.Tensor.arctanh	mindspore.Tensor.atanh() 的别名。
mindspore.Tensor.argmax	返回tensor在指定轴上的最大值索引。
mindspore.Tensor.argmax_with_value	返回tensor在指定轴上的最大值及其索引。
mindspore.Tensor.argmin	返回tensor在指定轴上的最小值索引。
mindspore.Tensor.argmin_with_value	返回tensor在指定轴上的最小值及其索引。
mindspore.Tensor.argsort	按指定顺序对 self 沿给定维度进行排序，并返回排序后的索引。
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	详情请参考 mindspore.ops.atan2()。
mindspore.Tensor.atanh	详情请参考 mindspore.ops.atanh()。
mindspore.Tensor.baddbmm	详情请参考 mindspore.ops.baddbmm()。
mindspore.Tensor.bernoulli_	用来自Bernoulli(p)的独立样本填充输入的每个元素。
mindspore.Tensor.bernoulli	详情请参考 mindspore.mint.bernoulli()。
mindspore.Tensor.bfloat16	将输入Tensor转换为 bfloat16 类型。
mindspore.Tensor.bincount	详情请参考 mindspore.ops.bincount()。
mindspore.Tensor.bitwise_and	逐元素执行两个Tensor的与运算。
mindspore.Tensor.bitwise_not	逐元素对当前Tensor进行位取反。
mindspore.Tensor.bitwise_left_shift	详情请参考 mindspore.ops.bitwise_left_shift()。
mindspore.Tensor.bitwise_or	逐元素执行两个Tensor的或运算。
mindspore.Tensor.bitwise_right_shift	详情请参考 mindspore.ops.bitwise_right_shift()。
mindspore.Tensor.bitwise_xor	逐元素执行两个Tensor的异或运算。
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.ops.ceil()。
mindspore.Tensor.cholesky	详情请参考 mindspore.ops.cholesky()。
mindspore.Tensor.cholesky_solve	详情请参考 mindspore.ops.cholesky_solve()。
mindspore.Tensor.choose	根据原始Tensor数组和一个索引数组构造一个新的Tensor。
mindspore.Tensor.chunk	沿着指定轴 axis 将输入Tensor切分成 chunks 个sub-tensor。
mindspore.Tensor.clamp	详情请参考 mindspore.ops.clamp()。
mindspore.Tensor.clamp_	mindspore.Tensor.clamp() 的in-place版本。
mindspore.Tensor.clip	mindspore.Tensor.clamp() 的别名。
mindspore.Tensor.clone	返回一个当前Tensor的副本。
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.copy_	将 src 中的元素复制到Tensor中并返回这个Tensor。
mindspore.Tensor.copysign	详情请参考 mindspore.ops.copysign()。
mindspore.Tensor.cos	详情请参考 mindspore.ops.cos()。
mindspore.Tensor.cosh	详情请参考 mindspore.ops.cosh()。
mindspore.Tensor.count_nonzero	计算输入Tensor指定轴上的非零元素的数量。
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 沿轴 axis 的累积和。
mindspore.Tensor.deg2rad	详情请参考 mindspore.ops.deg2rad()。
mindspore.Tensor.diag	如果 input 是向量（1-D 张量），则返回一个二维张量，其中 input 的元素作为对角线。
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	详情请参考 mindspore.ops.div()。
mindspore.Tensor.div_	mindspore.Tensor.div() 的in-place版本。
mindspore.Tensor.divide	mindspore.Tensor.div() 的别名。
mindspore.Tensor.dot	计算两个1DTensor的点积。
mindspore.Tensor.double	将输入Tensor转换为 float64 类型。
mindspore.Tensor.dsplit	详情请参考 mindspore.ops.dsplit()。
mindspore.Tensor.dtype	返回Tensor的数据类型（mindspore.dtype）。
mindspore.Tensor.eigvals	详情请参考 mindspore.ops.eigvals()。
mindspore.Tensor.eq	详情请参考 mindspore.ops.eq()。
mindspore.Tensor.equal	详情请参考 mindspore.ops.equal()。
mindspore.Tensor.erf	详情请参考 mindspore.ops.erf()。
mindspore.Tensor.erfc	详情请参考 mindspore.ops.erfc()。
mindspore.Tensor.erfinv	详情请参考 mindspore.ops.erfinv()。
mindspore.Tensor.exp	详情请参考 mindspore.ops.exp()。
mindspore.Tensor.exp_	原地更新版本的 mindspore.Tensor.exp()。
mindspore.Tensor.expand	详情请参考 mindspore.ops.broadcast_to()，当前接口的参数 size 和参考接口中的参数 shape 实际为同一参数。
mindspore.Tensor.expand_as	将输入张量的维度扩展为目标张量的维度。
mindspore.Tensor.expand_dims	详情请参考 mindspore.ops.expand_dims()。
mindspore.Tensor.expm1	详情请参考 mindspore.ops.expm1()。
mindspore.Tensor.exponential_	根据指数分布生成随机数填充Tensor。
mindspore.Tensor.fill_	用指定的值填充 self 。
mindspore.Tensor.fill_diagonal	将 self Tensor的主对角线，填充成指定的值，并返回结果。
mindspore.Tensor.flatten	沿着从 start_dim 到 end_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.mint.float_power()。
mindspore.Tensor.floor	详情请参考 mindspore.ops.floor()。
mindspore.Tensor.floor_	mindspore.Tensor.floor() 的in-place版本。
mindspore.Tensor.floor_divide	按元素将 self Tensor除以输入Tensor，并向下取整。
mindspore.Tensor.floor_divide_	按元素将 self Tensor除以 other Tensor，并向下取整。
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在指定 axis 上 input_indices 索引对应的元素组成的切片。
mindspore.Tensor.gather_elements	详情请参考 mindspore.ops.gather_elements()。
mindspore.Tensor.gather_nd	详情请参考 mindspore.ops.gather_nd()。
mindspore.Tensor.gcd	详情请参考 mindspore.ops.gcd()。
mindspore.Tensor.ge	mindspore.Tensor.greater_equal() 的别名。
mindspore.Tensor.geqrf	详情请参考 mindspore.ops.geqrf()。
mindspore.Tensor.ger	详情请参考 mindspore.ops.ger()。
mindspore.Tensor.greater	详情请参考 mindspore.ops.greater()。
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.bessel_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_add_	根据 index 中的索引顺序，将 alpha 乘以 source 的元素累加到 self 中。
mindspore.Tensor.index_copy_	根据 index 中的索引顺序，将 tensor 的元素复制到 self 中。
mindspore.Tensor.index_fill	详情请参考 mindspore.ops.index_fill()。
mindspore.Tensor.index_fill_	按 index 中给定的顺序选择索引，将输入 value 的值填充到 self Tensor的所有 dim 维元素。
mindspore.Tensor.index_put	根据 indices 中的下标值，使用 values 中的数值替换Tensor self 中的相应元素的值。
mindspore.Tensor.index_put_	根据 indices 中的下标值，使用 values 中的数值替换Tensor self 中相应元素的值。
mindspore.Tensor.index_select	返回一个新的Tensor，该Tensor沿维度 dim 按 index 中给定的索引对 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	返回一个bool类型的Tensor，表示 input 的每个元素与 x2 的对应元素在给定容忍度内是否“接近”。
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_pinned	判断当前Tensor是否位于锁页内存。
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	详情请参考 mindspore.ops.le()。
mindspore.Tensor.lerp	详情请参考 mindspore.ops.lerp()。
mindspore.Tensor.less	详情请参考 mindspore.ops.less()。
mindspore.Tensor.less_equal	详情请参考 mindspore.ops.less_equal()。
mindspore.Tensor.log	详情请参考 mindspore.ops.log()。
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	详情请参考 mindspore.ops.logical_and()。
mindspore.Tensor.logical_not	详情请参考 mindspore.ops.logical_not()。
mindspore.Tensor.logical_or	详情请参考 mindspore.ops.logical_or()。
mindspore.Tensor.logical_xor	逐元素计算两个Tensor的逻辑异或运算。
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	详情请参考 mindspore.ops.masked_fill()。
mindspore.Tensor.masked_fill_	mindspore.Tensor.masked_fill() 的in-place版本。
mindspore.Tensor.masked_scatter	根据mask，使用 tensor 中的值，更新Tensor本身的值，返回一个Tensor。
mindspore.Tensor.masked_scatter_	根据 mask ，使用 source 中的值，更新 self 的值，返回一个Tensor。
mindspore.Tensor.masked_select	详情请参考 mindspore.ops.masked_select()。
mindspore.Tensor.matmul	计算两个数组的矩阵乘积。
mindspore.Tensor.max	在给定轴上计算输入Tensor的最大值，并返回最大值和索引值。
mindspore.Tensor.maximum	详情请参考 mindspore.ops.maximum()。
mindspore.Tensor.mean	详情请参考 mindspore.ops.mean()。
mindspore.Tensor.median	返回输入的中位数。
mindspore.Tensor.mH	访问此属性等价于调用self.adjoint()方法。
mindspore.Tensor.min	在给定轴上计算输入Tensor的最小值，并返回最小值和索引值。
mindspore.Tensor.minimum	详情请参考 mindspore.ops.minimum()。
mindspore.Tensor.mm	计算两个矩阵的乘积。
mindspore.Tensor.moveaxis	详情请参考 mindspore.ops.moveaxis()。
mindspore.Tensor.movedim	详情请参考 mindspore.ops.movedim()。
mindspore.Tensor.move_to	同步或异步的方式将Tensor拷贝到目标设备上，默认同步方式。
mindspore.Tensor.msort	详情请参考 mindspore.ops.msort()。
mindspore.Tensor.mT	返回将最后两个维度交换的Tensor。
mindspore.Tensor.mul	详情请参考 mindspore.ops.mul()。
mindspore.Tensor.mul_	两个Tensor逐元素相乘。
mindspore.Tensor.multinomial	详情请参考 mindspore.ops.multinomial()。
mindspore.Tensor.multiply	详情请参考 mindspore.ops.mul()。
mindspore.Tensor.mvlgamma	详情请参考 mindspore.ops.mvlgamma()。
mindspore.Tensor.nan_to_num	详情请参考 mindspore.ops.nan_to_num()。
mindspore.Tensor.nanmean	详情请参考 mindspore.ops.nanmean()。
mindspore.Tensor.nanmedian	详情请参考 mindspore.ops.nanmedian()。
mindspore.Tensor.nansum	计算输入Tensor指定维度元素的和，将非数字(NaNs)处理为零。
mindspore.Tensor.narrow	沿着指定的轴，从指定的起始位置获取指定长度的Tensor。
mindspore.Tensor.nbytes	返回Tensor占用的总字节数。
mindspore.Tensor.ndim	返回Tensor维度的数量。
mindspore.Tensor.ndimension	mindspore.Tensor.ndim 的别名。
mindspore.Tensor.ne	mindspore.Tensor.not_equal() 的别名。
mindspore.Tensor.neg	详情请参考 mindspore.ops.neg()。
mindspore.Tensor.negative	mindspore.Tensor.neg() 的别名。
mindspore.Tensor.nelement	mindspore.Tensor.numel() 的别名。
mindspore.Tensor.new_empty	创建一个数据没有初始化的Tensor。
mindspore.Tensor.new_ones	返回一个大小为 size 的Tensor，填充值为1。
mindspore.Tensor.new_zeros	返回一个大小为 size 的Tensor，填充值为0。
mindspore.Tensor.new_full	返回一个大小为 size 的Tensor，填充值为 fill_value。
mindspore.Tensor.nextafter	详情请参考 mindspore.ops.nextafter()。
mindspore.Tensor.nonzero	返回所有非零元素下标位置。
mindspore.Tensor.norm	详情请参考 mindspore.ops.norm()。
mindspore.Tensor.normal_	使用随机数原地更新Tensor，且随机数的采样服从由参数 mean 和 std 所构成的正态分布。
mindspore.Tensor.not_equal	详情请参考 mindspore.ops.ne()。
mindspore.Tensor.numel	详情请参考 mindspore.ops.numel()。
mindspore.Tensor.numpy	mindspore.Tensor.asnumpy() 的别名。
mindspore.Tensor.orgqr	详情请参考 mindspore.ops.orgqr()。
mindspore.Tensor.ormqr	详情请参考 mindspore.ops.ormqr()，其中参数 input2 和 input3 分别对应 mindspore.ops.ormqr() 的参数 tau 和 other。
mindspore.Tensor.outer	详情请参考 mindspore.ops.outer()。
mindspore.Tensor.permute	详情请参考 mindspore.ops.permute()。
mindspore.Tensor.pin_memory	将当前Tensor的数据拷贝到锁页内存中，并返回一个新的Tensor。
mindspore.Tensor.positive	详情请参考 mindspore.ops.positive()。
mindspore.Tensor.pow	详情请参考 mindspore.ops.pow()。
mindspore.Tensor.prod	详情请参考 mindspore.ops.prod()。
mindspore.Tensor.ptp	该函数名称是"peak to peak"的缩写。
mindspore.Tensor.rad2deg	详情请参考 mindspore.ops.rad2deg()。
mindspore.Tensor.random_	在区间 \([from\_, to-1]\) 内生成服从均匀分布的离散均匀分布随机数，原地更新输入Tensor。
mindspore.Tensor.random_categorical	详情请参考 mindspore.ops.random_categorical()。
mindspore.Tensor.ravel	返回一个展开的一维Tensor。
mindspore.Tensor.real	详情请参考 mindspore.ops.real()。
mindspore.Tensor.reciprocal	详情请参考 mindspore.ops.reciprocal()。
mindspore.Tensor.register_hook	设置Tensor对象的反向hook函数。
mindspore.Tensor.remainder	逐元素计算第一个元素除以第二个元素的余数。
mindspore.Tensor.remainder_	逐元素计算 self 除以 other 后的余数。
mindspore.Tensor.renorm	详情请参考 mindspore.ops.renorm()。
mindspore.Tensor.repeat	对张量的每一维度按照指定的重复次数复制其中的元素。
mindspore.Tensor.repeat_interleave	沿着轴重复Tensor的元素，类似 mindspore.numpy.repeat()。
mindspore.Tensor.reshape	详情请参考 mindspore.ops.reshape()。
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.rot90	详情请参考 mindspore.ops.rot90()。
mindspore.Tensor.round	详情请参考 mindspore.ops.round()。
mindspore.Tensor.rsqrt	详情请参考 mindspore.ops.rsqrt()。
mindspore.Tensor.scatter	根据指定索引将 src 中的值更新到 self 中，并返回输出。
mindspore.Tensor.scatter_	根据 index 使用 src 中的值更新当前张量 self 。
mindspore.Tensor.scatter_add	根据指定的更新值 updates 和输入索引 indices ，通过相加运算更新输入Tensor的值。
mindspore.Tensor.scatter_add_	将 src 中所有的元素添加到 self 中 index 指定的索引处（属于原地更新操作）。
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	详情请参考 mindspore.ops.tensor_scatter_sub()。
mindspore.Tensor.searchsorted	详情请参考 mindspore.ops.searchsorted()。
mindspore.Tensor.select	根据条件判断Tensor中的元素的值，来决定输出中的相应元素是从 self （如果元素值为True）还是从 y （如果元素值为False）中选择。
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.sigmoid_	mindspore.Tensor.sigmoid() 的in-place版本。
mindspore.Tensor.sign	详情请参考 mindspore.ops.sign()。
mindspore.Tensor.sign_	mindspore.mint.sign() 的in-place版本。
mindspore.Tensor.signbit	详情请参考 mindspore.ops.signbit()。
mindspore.Tensor.sin	详情请参考 mindspore.ops.sin()。
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	根据指定的轴将输入Tensor切分成块。
mindspore.Tensor.sqrt	详情请参考 mindspore.ops.sqrt()。
mindspore.Tensor.square	详情请参考 mindspore.ops.square()。
mindspore.Tensor.squeeze	详情请参考 mindspore.ops.squeeze()。
mindspore.Tensor.std	计算指定维度 dim 上的标准差。
mindspore.Tensor.storage	返回Tensor的存储，该存储不区分dtype，支持CPU/GPU/Ascend平台。
mindspore.Tensor.storage_offset	以储存元素的个数的形式返回Tensor在内存中的偏移量。
mindspore.Tensor.stride	在指定维度 dim中 从一个元素跳到下一个元素所必需的步长。
mindspore.Tensor.strides	Tensor上每个维度跨度的字节元组。
mindspore.Tensor.sub	详情请参考 mindspore.ops.sub() 。
mindspore.Tensor.sub_	详情请参考 mindspore.mint.sub()。
mindspore.Tensor.subtract	此接口从2.4版本开始已被弃用，并将在未来版本中被移除。
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	选取给定索引 index 处的 self 元素。
mindspore.Tensor.tan	详情请参考 mindspore.ops.tan()。
mindspore.Tensor.tanh	详情请参考 mindspore.ops.tanh()。
mindspore.Tensor.tensor_split	详情请参考 mindspore.ops.tensor_split()。
mindspore.Tensor.tile	详情请参考 mindspore.ops.tile()，当前接口的参数 reps 和详情参考接口中的参数 dims 实际为同一参数。
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	详情请参考 mindspore.ops.topk() 。
mindspore.Tensor.trace	在Tensor的对角线方向上的总和。
mindspore.Tensor.transpose	根据指定的排列对输入的Tensor进行数据重排。
mindspore.Tensor.triangular_solve	详情请参考 mindspore.mint.triangular_solve()。
mindspore.Tensor.tril	详情请参考 mindspore.ops.tril()。
mindspore.Tensor.triu	详情请参考 mindspore.ops.triu()。
mindspore.Tensor.true_divide	mindspore.Tensor.div() 中 \(rounding\_mode=None\) 的别名。
mindspore.Tensor.trunc	详情请参考 mindspore.ops.trunc()。
mindspore.Tensor.type	将Tensor的dtype转换成 dtype 。
mindspore.Tensor.type_as	将第一个输入的Tensor的数据类型转换为第二个输入的Tensor的数据类型。
mindspore.Tensor.unbind	详情请参考 mindspore.ops.unbind()。
mindspore.Tensor.unfold	详情请参考 mindspore.ops.unfold()。
mindspore.Tensor.uniform	在半开区间 \([from\_, to)\) 内生成服从均匀分布的随机数。
mindspore.Tensor.uniform_	通过在半开区间 \([from\_, to)\) 内生成服从均匀分布的随机数来原地更新输入Tensor。
mindspore.Tensor.unique	对 self 中的元素去重。
mindspore.Tensor.unique_consecutive	详情请参考 mindspore.ops.unique_consecutive()。
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.untyped_storage	返回Tensor的存储，该存储不区分dtype，支持CPU/GPU/Ascend平台。
mindspore.Tensor.var	计算指定维度 dim 上的方差。
mindspore.Tensor.view	根据输入shape重新创建一个Tensor，与原Tensor数据相同。
mindspore.Tensor.view_as	根据 other 的shape改变原 self Tensor的shape。
mindspore.Tensor.vsplit	详情请参考 mindspore.ops.vsplit()。
mindspore.Tensor.where	详情请参考 mindspore.ops.where()。
mindspore.Tensor.xdivy	详情请参考 mindspore.ops.xdivy()。
mindspore.Tensor.xlogy	详情请参考 mindspore.ops.xlogy()。
mindspore.Tensor.zero_	返回填充0的Tensor。