张量

image0image1image2

张量(Tensor)是MindSpore网络运算中的基本数据结构。

首先导入本文档需要的模块和接口,如下所示:

[1]:
import numpy as np
from mindspore import Tensor, context
from mindspore import dtype as mstype
context.set_context(mode=context.GRAPH_MODE, device_target="CPU")

初始化张量

张量的初始化方式有多种,构造张量时,支持传入TensorfloatintbooltuplelistNumPy.array类型。

  • 根据数据直接生成

可以根据数据创建张量,数据类型可以设置或者自动推断。

[2]:
x = Tensor(0.1)
  • 从NumPy数组生成

可以从NumPy数组创建张量。

[3]:
arr = np.array([1, 0, 1, 0])
x_np = Tensor(arr)

初始值是NumPy.array,则生成的Tensor数据类型与之对应。

  • 继承另一个张量的属性,形成新的张量

[4]:
from mindspore import ops
oneslike = ops.OnesLike()
x = Tensor(np.array([[0, 1], [2, 1]]).astype(np.int32))
output = oneslike(x)
print(output)
[[1 1]
 [1 1]]
  • 输出指定大小的恒定值张量

shape是张量的尺寸元组,确定输出的张量的维度。

[5]:
import mindspore.ops as ops

shape = (2, 2)
ones = ops.Ones()
output = ones(shape, mstype.float32)
print(output)

zeros = ops.Zeros()
output = zeros(shape, mstype.float32)
print(output)
[[1. 1.]
 [1. 1.]]
[[0. 0.]
 [0. 0.]]

Tensor初始化时,可指定dtype,如mstype.int32mstype.float32mstype.bool_等。

张量的属性

张量的属性包括形状(shape)和数据类型(dtype)。

  • 形状:Tensor的shape,是一个tuple。

  • 数据类型:Tensor的dtype,是MindSpore的一个数据类型。

[6]:
t1 = Tensor(np.zeros([1,2,3]), mstype.float32)
print("Datatype of tensor: {}".format(t1.dtype))
print("Shape of tensor: {}".format(t1.shape))
Datatype of tensor: Float32
Shape of tensor: (1, 2, 3)

张量运算

张量之间有很多运算,包括算术、线性代数、矩阵处理(转置、标引、切片)、采样等,下面介绍其中几种操作,张量运算和NumPy的使用方式类似。

类似NumPy的索引和切片操作:

[7]:
tensor = Tensor(np.array([[0, 1], [2, 3]]).astype(np.float32))
print("First row: {}".format(tensor[0]))
print("First column: {}".format(tensor[:, 0]))
print("Last column: {}".format(tensor[..., -1]))
First row: [0. 1.]
First column: [0. 2.]
Last column: [1. 3.]

Concat将给定维度上的一系列张量连接起来。

[8]:
data1 = Tensor(np.array([[0, 1], [2, 3]]).astype(np.float32))
data2 = Tensor(np.array([[4, 5], [6, 7]]).astype(np.float32))
op = ops.Concat()
output = op((data1, data2))
print(output)
[[0. 1.]
 [2. 3.]
 [4. 5.]
 [6. 7.]]

Stack则是从另一个维度上将两个张量合并起来。

[9]:
data1 = Tensor(np.array([[0, 1], [2, 3]]).astype(np.float32))
data2 = Tensor(np.array([[4, 5], [6, 7]]).astype(np.float32))
op = ops.Stack()
output = op([data1, data2])
print(output)
[[[0. 1.]
  [2. 3.]]

 [[4. 5.]
  [6. 7.]]]

普通运算:

[10]:
input_x = Tensor(np.array([1.0, 2.0, 3.0]), mstype.float32)
input_y = Tensor(np.array([4.0, 5.0, 6.0]), mstype.float32)
mul = ops.Mul()
output = mul(input_x, input_y)
print(output)
[ 4. 10. 18.]

与NumPy转换

张量可以和NumPy进行互相转换。

张量转换为NumPy

[11]:
zeros = ops.Zeros()
output = zeros((2,2), mstype.float32)
print("output: {}".format(type(output)))
n_output = output.asnumpy()
print("n_output: {}".format(type(n_output)))
output: <class 'mindspore.common.tensor.Tensor'>
n_output: <class 'numpy.ndarray'>

NumPy转换为张量

[12]:
output = np.array([1, 0, 1, 0])
print("output: {}".format(type(output)))
t_output = Tensor(output)
print("t_output: {}".format(type(t_output)))
output: <class 'numpy.ndarray'>
t_output: <class 'mindspore.common.tensor.Tensor'>