1、张量

        张量tensor表示的是一个多维的矩阵，比如零维就是一个点，一维就是向量，二维就是一般的矩阵，多维就相当于一个多维的数组，这和numpy是对应的，而且PyTorch的Tensor和numpy的ndarray可以相互转换，唯一不同的是PyTorch可以在GPU上运行，而numpy的ndarray只能在CPU上运行。

        调用mindspore网络进行张量的相关应用，需要安装相应版本的mindspore。这里的话，需要根据前面的安装方法，安装mindspore。之前安装过就不用管了。

# 实验环境已经预装了mindspore==2.2.14，如需更换mindspore版本，可更改下面mindspore的版本号
!pip uninstall mindspore -y
!pip install -i https://pypi.mirrors.ustc.edu.cn/simple mindspore==2.2.14

2、创建张量

        这里引入numpy、mindspore相应库。

import numpy as np
import mindspore
from mindspore import ops
from mindspore import Tensor, CSRTensor, COOTensor

2.1 直接创建

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

data = [1, 0, 1, 0]
x_data = Tensor(data)
#查看数据、形状、类型
print(x_data, x_data.shape, x_data.dtype)

运行结果

2.2 numpy数组生成

np_array = np.array(data)
x_np = Tensor(np_array)
print(x_np, x_np.shape, x_np.dtype)

运行结果

2.3 使用init初始化器构建

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

        init：支持传入initializer的子类，实际使用时会调用相应的类。 init 的值可以是“normal(生成一个服从正态分布 𝑁(sigma,mean) 的随机数组用于初始化Tensor)”、“noes(生成一个值全为1的常量数组用于初始化Tensor。)”或“zeros”等。

        shape：支持传入list、tuple、int。

        dtype：支持传入mindspore.dtype(int, uint, float数据类型）

from mindspore.common.initializer import One, Normal# Initialize a tensor with ones
tensor1 = mindspore.Tensor(shape=(2, 2), dtype=mindspore.float32, init=One())
# Initialize a tensor from normal distribution
tensor2 = mindspore.Tensor(shape=(2, 2), dtype=mindspore.float32, init=Normal())print("tensor1:\n", tensor1)
print("tensor2:\n", tensor2)

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

from mindspore import opsx_ones = ops.ones_like(x_data)
print(f"Ones Tensor: \n {x_ones} \n")x_zeros = ops.zeros_like(x_data)
print(f"Zeros Tensor: \n {x_zeros} \n")

        这里就是继承了前面x_data张量的属性，构造了一个全是1和全是0的张量。

3、张量的属性

        张量的属性包括形状、数据类型、转置张量、单个元素大小、占用字节数量、维数、元素个数和每一维步长。

- 形状（shape）：`Tensor`的shape，是一个tuple。

- 数据类型（dtype）：`Tensor`的dtype，是MindSpore的一个数据类型。

- 单个元素大小（itemsize）： `Tensor`中每一个元素占用字节数，是一个整数。

- 占用字节数量（nbytes）： `Tensor`占用的总字节数，是一个整数。

- 维数（ndim）： `Tensor`的秩，也就是len(tensor.shape)，是一个整数。

- 元素个数（size）： `Tensor`中所有元素的个数，是一个整数。

- 每一维步长（strides）： `Tensor`每一维所需要的字节数，是一个tuple。

x = Tensor(np.array([[1, 2], [3, 4]]), mindspore.int32)print("x_shape:", x.shape)
print("x_dtype:", x.dtype)
print("x_itemsize:", x.itemsize)
print("x_nbytes:", x.nbytes)
print("x_ndim:", x.ndim)
print("x_size:", x.size)
print("x_strides:", x.strides)

4、张量的索引

        Tensor索引与Numpy索引类似，索引从0开始编制，负索引表示按倒序编制，冒号`:`和 `...`用于对数据进行切片。

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

5、张量运算

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

5.1 普通算术运算有：加（+）、减（-）、乘（*）、除（/）、取模（%）、整除（//）。

x = Tensor(np.array([1, 2, 3]), mindspore.float32)
y = Tensor(np.array([4, 5, 6]), mindspore.float32)output_add = x + y
output_sub = x - y
output_mul = x * y
output_div = y / x
output_mod = y % x
output_floordiv = y // xprint("add:", output_add)
print("sub:", output_sub)
print("mul:", output_mul)
print("div:", output_div)
print("mod:", output_mod)
print("floordiv:", output_floordiv)

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

        concat是mindspore.ops.cat(tensors, axis=0)别名。在指定轴上拼接输入Tensor。

        输入的是一个tuple或list。其元素秩相同，即 𝑅 。将给定的轴设为 𝑚 ，并且 0≤𝑚<𝑅 。输入元素的数量设为 𝑁 。对于第 𝑖 个数据， 𝑡𝑖 的shape为 (𝑥1,𝑥2,...,𝑥𝑚𝑖,...,𝑥𝑅) 。 𝑥𝑚𝑖 是第 𝑡𝑖 个元素的第 𝑚 个维度。则，输出Tensor的shape为：

【参数】

• tensors (Union[tuple, list]) - 输入为Tensor组成的tuple或list。假设在这个tuple或list中有两个Tensor，即 t1 和 t2 。要在0轴方向上执行 Concat ，除 0 轴外，其他轴的shape都应相等，即 𝑡1.𝑠ℎ𝑎𝑝𝑒[1]=𝑡2.𝑠ℎ𝑎𝑝𝑒[1],𝑡1.𝑠ℎ𝑎𝑝𝑒[2]=𝑡2.𝑠ℎ𝑎𝑝𝑒[2],...,𝑡1.𝑠ℎ𝑎𝑝𝑒[𝑅−1]=𝑡2.𝑠ℎ𝑎𝑝𝑒[𝑅−1] ，其中 𝑅 是Tensor的秩。

• axis (int) - 表示指定的轴，取值范围是 [−𝑅,𝑅) 。默认值： 0 

data1 = Tensor(np.array([[0, 1], [2, 3]]).astype(np.float32))
data2 = Tensor(np.array([[4, 5], [6, 7]]).astype(np.float32))
output = ops.concat((data1, data2), axis=0)print(output)
print("shape:\n", output.shape)

5.3 stack 从另一个维度上将两个张量合并起来。

        mindspore.ops.stack(tensors, axis=0)

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

输入秩为 R 的Tensor序列，则输出秩为 (R+1) 的Tensor。给定输入Tensor的shape为 (𝑥1,𝑥2,...,𝑥𝑅) 。若输入Tensor的长度为 N 。如果存在 𝑎𝑥𝑖𝑠≥0 ，则输出Tensor的shape为 (𝑥1,𝑥2,...,𝑥𝑎𝑥𝑖𝑠,𝑁,𝑥𝑎𝑥𝑖𝑠+1,...,𝑥𝑅) 。

【参数】

• tensors (Union[tuple, list]) - 输入多个Tensor对象组成的tuple或list，每个Tensor具有相同shape和数据类型。

• axis (int) - 指定堆叠运算的轴。取值范围为[-(R+1), R+1)。默认值： 0 。

data1 = Tensor(np.array([[0, 1], [2, 3]]).astype(np.float32))
data2 = Tensor(np.array([[4, 5], [6, 7]]).astype(np.float32))
output = ops.stack([data1, data2])print(output)
print("shape:\n", output.shape)

6、tensor 与 numpy转换

6.1 tensor转换为numpy

        与张量创建相同，使用 Tensor.asnumpy() 将Tensor变量转换为NumPy变量。

t = Tensor([1., 1., 1., 1., 1.])
print(f"t: {t}", type(t))
n = t.asnumpy()
print(f"n: {n}", type(n))

6.2 numpy转换为tensor

        使用Tensor()将NumPy变量转换为Tensor变量。

n = np.ones(5)
t = Tensor.from_numpy(n)
np.add(n, 1, out=n)
print(f"n: {n}", type(n))
print(f"t: {t}", type(t))

7、稀疏张量

        稀疏张量跟稀疏矩阵相同，其中大部分元素的值为零。

        在某些应用场景中（比如推荐系统、分子动力学、图神经网络等），数据的特征是稀疏的，若使用普通张量表征这些数据会引入大量不必要的计算、存储和通讯开销。这时就可以使用稀疏张量来表征这些数据。

        MindSpore现在已经支持最常用的CSR和COO两种稀疏数据格式。

        常用稀疏张量的表达形式是<indices:Tensor, values:Tensor, shape:Tensor>。其中，indices表示非零下标元素， values表示非零元素的值，shape表示的是被压缩的稀疏张量的形状。在这个结构下，我们定义了三种稀疏张量结构：CSRTensor、COOTensor和RowTensor。

7.1 CSRTensor

         mindspore.CSRTensor(indptr=None, indices=None, values=None, shape=None, csr_tensor=None)

  CSR（Compressed Sparse Row）稀疏张量格式有着高效的存储与计算的优势。其中，非零元素的值存储在values中，非零元素的位置存储在indptr（行）和indices（列）中。各参数含义如下：

• indptr: 一维整数张量, 表示稀疏数据每一行的非零元素在values中的起始位置和终止位置, 索引数据类型支持int16、int32、int64。

• indices: 一维整数张量，表示稀疏张量非零元素在列中的位置, 与values长度相等，索引数据类型支持int16、int32、int64。

• values: 一维张量，表示CSRTensor相对应的非零元素的值，与indices长度相等。

• shape: 表示被压缩的稀疏张量的形状，数据类型为Tuple，目前仅支持二维CSRTensor。

        用来表示某一Tensor在给定索引上非零元素的集合，其中行索引由 indptr 表示，列索引由 indices 表示，非零值由 values 表示。

        如果 indptr 是[0, 1, 2, 2]， indices 是[1, 2]， values 是[1., 2.]， shape 是(3, 4)，那么它对应的稠密Tensor如下：

indptr = Tensor([0, 1, 2])
indices = Tensor([0, 1])
values = Tensor([1, 2], dtype=mindspore.float32)
shape = (2, 4)# Make a CSRTensor
csr_tensor = CSRTensor(indptr, indices, values, shape)print(csr_tensor.values)
print(csr_tensor.indices)
print(csr_tensor.shape)
print(csr_tensor.astype(mindspore.float64).dtype)pe)

7.2 COOTensor

        mindspore.COOTensor(indices=None, values=None, shape=None, coo_tensor=None)

• indices (Tensor) - shape为 (𝑁,𝑛𝑑𝑖𝑚𝑠) 的二维整数Tensor，其中N和ndims分别表示稀疏Tensor中 values 的数量和COOTensor维度的数量。目前 ndims 只能为2。请确保indices的值在所给shape范围内。支持的数据类型为int16， int32和int64。默认值： None 。

• values (Tensor) - shape为 (𝑁) 的一维Tensor，用来给 indices 中的每个元素提供数值。默认值： None 。

• shape (tuple(int)) - shape为 (𝑛𝑑𝑖𝑚𝑠) 的整数元组，用来指定稀疏矩阵的稠密shape。默认值： None 。

• coo_tensor (COOTensor) - COOTensor对象，用来初始化新的COOTensor。默认值： None 。

        对一个稠密Tensor dense 来说，它对应的COOTensor(indices, values, shape)，满足 dense[indices[i]] = values[i] 。

        如果 indices 是[[0, 1], [1, 2]]， values 是[1, 2]， shape 是(3, 4)，那么它对应的稠密Tensor如下：

indices = Tensor([[0, 1], [1, 2]], dtype=mindspore.int32)
values = Tensor([1, 2], dtype=mindspore.float32)
shape = (3, 4)# Make a COOTensor
coo_tensor = COOTensor(indices, values, shape)print(coo_tensor.values)
print(coo_tensor.indices)
print(coo_tensor.shape)
print(coo_tensor.astype(mindspore.float64).dtype)  # COOTensor to float64