张量

Ascend GPU CPU 入门

    

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

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

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")

初始化张量

张量的初始化方式有多种，构造张量时，支持传入Tensor、float、int、bool、tuple、list和NumPy.array类型。

• 根据数据直接生成

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

x = Tensor(0.1)

• 从NumPy数组生成

可以从NumPy数组创建张量。

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

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

• 使用init初始化器构造张量

当使用init初始化器对张量进行初始化时，支持传入的参数有init、shape、dtype。

• init: 支持传入initializer的子类。

• shape: 支持传入 list、tuple、 int。

• dtype: 支持传入mindspore.dtype。

from mindspore import Tensor
from mindspore import set_seed
from mindspore import dtype as mstype
from mindspore.common.initializer import One, Normal

set_seed(1)

tensor1 = Tensor(shape=(2, 2), dtype=mstype.float32, init=One())
tensor2 = Tensor(shape=(2, 2), dtype=mstype.float32, init=Normal())
print(tensor1)
print(tensor2)

[[1. 1.]
 [1. 1.]]
[[-0.00128023 -0.01392901]
 [ 0.0130886  -0.00107818]]

init是用在并行模式下用来进行延后初始化的，在正常情况下不建议使用init对参数进行初始化。

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

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是张量的尺寸元组，确定输出的张量的维度。

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.int32、mstype.float32、mstype.bool_等。

张量的属性

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

• 形状：Tensor的shape，是一个tuple。

• 数据类型：Tensor的dtype，是MindSpore的一个数据类型。

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的索引和切片操作：

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将给定维度上的一系列张量连接起来。

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则是从另一个维度上将两个张量合并起来。

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.]]]

普通运算：

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

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转换为张量

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'>