【MindSpore学习打卡】初学教程-03张量Tensor-理解MindSpore中的张量(Tensor)操作

标签：Tensor 张量 np mindspore print output MindSpore

03张量Tensor-理解MindSpore中的张量(Tensor)操作

在深度学习领域，张量（Tensor）是最基本的数据结构之一。它不仅可以表示标量、向量和矩阵，还可以表示更高维度的数据。张量在神经网络的构建和训练中扮演着至关重要的角色。在MindSpore中，张量是网络运算的基本单位。本篇博客将详细介绍如何在MindSpore中创建和操作张量，并探讨稀疏张量的使用。通过本文，你将深入了解张量的各种操作方法和应用场景，从而更好地掌握MindSpore的使用。

什么是张量？

张量是一种多维数组，可以表示标量、向量、矩阵以及更高维度的数据结构。张量的秩（rank）表示其维度的数量。例如，标量是0阶张量，向量是1阶张量，矩阵是2阶张量。张量（Tensor）是深度学习中最基本的数据结构之一，它可以表示标量、向量、矩阵甚至更高维度的数据。在MindSpore中，张量是网络运算的基本单位。

创建张量

在MindSpore中，可以通过多种方式创建张量：
展示了如何从不同的数据源创建张量。比如，直接从数据列表或NumPy数组创建张量。这些方法非常实用，因为在实际应用中，我们的数据可能来自不同的源，能够灵活地创建张量将使数据处理更加方便。

根据数据直接生成

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

import numpy as np
import mindspore
from mindspore import Tensor

data = [1, 0, 1, 0]
x_data = Tensor(data)
print(x_data, x_data.shape, x_data.dtype)

从NumPy数组生成

可以从NumPy数组创建张量。

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

使用初始化器构造张量

使用init初始化器对张量进行初始化。

from mindspore.common.initializer import One, Normal

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

print("tensor1:\n", tensor1)
print("tensor2:\n", tensor2)

继承另一个张量的属性

可以通过继承已有张量的属性创建新的张量。

from mindspore import ops

x_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 = 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)

张量索引

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

张量运算

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

普通算术运算

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 // x

print("add:", output_add)
print("sub:", output_sub)
print("mul:", output_mul)
print("div:", output_div)
print("mod:", output_mod)
print("floordiv:", output_floordiv)

张量连接与堆叠

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

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)

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

output = ops.stack([data1, data2])

print(output)
print("shape:\n", output.shape)

Tensor与NumPy转换

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

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

稀疏张量

稀疏张量是一种特殊张量，其中绝大部分元素的值为零。MindSpore支持CSR和COO两种稀疏数据格式。

CSRTensor

CSR（Compressed Sparse Row）稀疏张量格式有着高效的存储与计算的优势。

from mindspore import CSRTensor

indptr = Tensor([0, 1, 2])
indices = Tensor([0, 1])
values = Tensor([1, 2], dtype=mindspore.float32)
shape = (2, 4)

csr_tensor = CSRTensor(indptr, indices, values, shape)

print(csr_tensor.astype(mindspore.float64).dtype)

生成的CSRTensor如下所示：
[ 1 0 0 0 0 2 0 0 ] \left[ \begin{matrix} 1 & 0 & 0 & 0 \\ 0 & 2 & 0 & 0 \end{matrix} \right] [10020000]

COOTensor

COO（Coordinate Format）稀疏张量格式用来表示某一张量在给定索引上非零元素的集合。

from mindspore import COOTensor

indices = Tensor([[0, 1], [1, 2]], dtype=mindspore.int32)
values = Tensor([1, 2], dtype=mindspore.float32)
shape = (3, 4)

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如下所示：
[ 0 1 0 0 0 0 2 0 0 0 0 0 ] \left[ \begin{matrix} 0 & 1 & 0 & 0 \\ 0 & 0 & 2 & 0 \\ 0 & 0 & 0 & 0 \end{matrix} \right] 000100020000
在这里插入图片描述
通过本篇博客的介绍，相信大家对MindSpore中的张量操作有了更加深入的理解。在实际应用中，掌握这些基本操作将极大地帮助我们构建和优化深度学习模型。无论是创建张量、进行张量运算，还是处理稀疏张量，这些技能都是必不可少的。希望这篇博客对你有所帮助，助你在深度学习的道路上走得更远。

标签：Tensor,张量,np,mindspore,print,output,MindSpore
From： https://blog.csdn.net/weixin_43427267/article/details/139834959