红字是懵逼元素
1. 张量 Tensor
- 张量（Tensor）是一个可用来表示在一些矢量、标量和其他张量之间的线性关系的多线性函数，这些线性关系的基本例子有内积、外积、线性映射以及笛卡儿积。其坐标在 𝑛维空间内，有 𝑛𝑟个分量的一种量，其中每个分量都是坐标的函数，而在坐标变换时，这些分量也依照某些规则作线性变换。 𝑟称为该张量的秩或阶（与矩阵的秩和阶均无关系）。
- 张量是一种特殊的数据结构，与数组和矩阵非常相似。张量（Tensor）是MindSpore网络运算中的基本数据结构，本教程主要介绍张量和稀疏张量的属性及用法。
- 标量（Scalar）是只有大小没有方向的量（矢量有大小有方向），如温流、质量等。在张量中，标量可以被看作秩为0的张量。
- 线性函数（Multilinear function）是表示两个变量的变化关系是成比例的，在线性函数中，一个变量的增加或减少与另一个变量的增加或减少成正比。其一般形式可以表示为：f(x)=ax+b。其特点包括：
- 比例性：输入增加一个固定的量，输出也会增加一个固定的量乘以斜率a
- 叠加性：函数的输出是输入的叠加。f(x+y) = f(x) + f(y)
- 图形表示：线性函数的图形是一条直线，斜率a决定了直线的倾斜方向和程度，截距b决定了直线与y轴的交点
- 在机器学习中，线性函数常用于线性回归模型，其目标是通过最小化预测值和实际值之间的差异来找到最佳拟合直线。线性函数也是神经网络中的一层，称为线性层或全连接层，它对输入数据进行线性变换
- 多线性函数是映射多个向量（矢量、多维数组）空间到标量的函数，它对每个输入向量都是线性的。这意味着如果你固定其他输入向量，那么函数对任何一个输入向量的变化都是线性的。
- 内积（Inner product）也称为点积，是两个向量空间中的向量产生一个标量的操作。内积的结果是一个标量，它可以通过计算两个向量对应分量的乘积之和得到。
- 外积（Outer product）是两个向量产生一个矩阵的操作。外积的结果是一个矩阵，其中每个元素是两个向量对应分量的乘积。
- 线性映射（Linear map）是从一个向量空间到另一个向量空间的函数，它保持向量加法和标量乘法的运算。线性映射可以用矩阵表示。
- 笛卡尔积（Cartesian product）是多个集合中元素的所有可能组合的集合。在向量上下文中，两个向量的笛卡儿积是它们的外积。
- 张量是一个量，但它可以包含多个分量。在数学和物理学中，张量是一种几何对象，它可以通过一组坐标来描述，这些坐标在坐标变换下按照特定的规则变换。
- 秩或阶（Rank）是指张量维度的数量。向量是矢为1的张量，矩阵是秩为2的张量。
- 张量在机器学习中的应用非常广泛，尤其是在深度学习中。在深度学习框架中，张量用于存储和操作数据，包括权重、偏置、激活函数的输出等。张量的灵活性使得它可以表示从简单的标量到复杂的多元数据结构，如视频数据。
1.1 导入依赖
import numpy as np
import mindspore
from mindspore import ops
from mindspore import Tensor, CSRTensor, COOTensor
1.2 创建张量
张量的创建方式有多种，构造张量时，支持传入Tensor、float、int、bool、tuple、list和numpy.ndarray类型。
- 根据数据直接生成：可以根据数据创建张量，数据类型可以设置或者通过框架自动推断。
# 创建一个4个元素的数组
data = [1, 0, 1, 0]
# 将数组转化为张量
x_data = Tensor(data)
# 打印张量的内容、张量的形状（即他的维数和每个维的大小）、张量的数据类型
print(x_data, x_data.shape, x_data.dtype)
输出：
[1 0 1 0] (4,) Int64
- 从NumPy数组生成：可以从NumPy数组创建张量。
# 创建numpy数组
np_array = np.array(data)
# 将numpy数组转化为张量
x_np = Tensor(np_array)
# 打印张量的内容、形状和数据类型
print(x_np, x_np.shape, x_np.dtype)
输出：
[1 0 1 0] (4,) Int64
-
使用init初始化器构造张量：当使用init初始化器对张量进行初始化时，支持传入的参数有init、shape、dtype。
-
init: 支持传入initializer的子类。如：下方示例中的 One() 和 Normal()。
-
shape: 支持传入 list、tuple、 int。
-
dtype: 支持传入mindspore.dtype。
-
# 从mindspore的common模块中导入initializer子模块，并从中导入One和Normal类
from mindspore.common.initializer import One, Normal
# 使用One类初始化一个全为1的张量，张量的形状为2x2，数据类型为浮点32位
tensor1 = mindspore.Tensor(shape=(2, 2), dtype=mindspore.float32, init=One())
# 使用Normal类从正态分布中初始化一个张量，张量的形状为2x2，数据类型为浮点32位
tensor2 = mindspore.Tensor(shape=(2, 2), dtype=mindspore.float32, init=Normal())
# 打印输出tensor1的内容
print("tensor1:\n", tensor1)
# 打印输出tensor2的内容
print("tensor2:\n", tensor2)
输出：
tensor1:
[[1. 1.]
[1. 1.]]
tensor2:
[[-0.0043753 -0.02505442]
[ 0.00128717 -0.00913322]]
init主要用于并行模式下的延后初始化，在正常情况下不建议使用init对参数进行初始化。
- 继承另一个张量的属性，形成新的张量
# 从mindspore模块中导入ops子模块，该子模块包含了许多操作张量的函数
from mindspore import ops
# 使用ops子模块中的ones_like函数创建一个与x_data形状相同且元素全为1的张量
x_ones = ops.ones_like(x_data)
# 打印输出x_ones张量的内容，格式化字符串中的\n用于在打印时换行
print(f"Ones Tensor: \n {x_ones} \n")
# 使用ops子模块中的zeros_like函数创建一个与x_data形状相同且元素全为0的张量
x_zeros = ops.zeros_like(x_data)
# 打印输出x_zeros张量的内容，同样使用\n进行换行
print(f"Zeros Tensor: \n {x_zeros} \n")
输出：
Ones Tensor:
[1 1 1 1]
Zeros Tensor:
[0 0 0 0]
1.3 张量的属性
张量的属性包括形状、数据类型、转置张量、单个元素大小、占用字节数量、维数、元素个数和每一维步长。
- 形状（shape）：Tensor的shape，是一个tuple。
- 数据类型（dtype）：Tensor的dtype，是MindSpore的一个数据类型。
- 单个元素大小（itemsize）： Tensor中每一个元素占用字节数，是一个整数。
- 占用字节数量（nbytes）： Tensor占用的总字节数，是一个整数。
- 维数（ndim）： Tensor的秩，也就是len(tensor.shape)，是一个整数。
- 元素个数（size）： Tensor中所有元素的个数，是一个整数。
- 每一维步长（strides）： Tensor每一维所需要的字节数，是一个tuple。
# 创建一个Tensor对象x，其值为一个numpy数组，数组内容为[[1, 2], [3, 4]]，数据类型为mindspore.int32
x = Tensor(np.array([[1, 2], [3, 4]]), mindspore.int32)
# 打印输出张量x的形状
print("x_shape:", x.shape)
# 打印输出张量x的数据类型
print("x_dtype:", x.dtype)
# 打印输出张量x中每个元素的大小（以字节为单位）
print("x_itemsize:", x.itemsize)
# 打印输出张量x的总大小（以字节为单位）
print("x_nbytes:", x.nbytes)
# 打印输出张量x的维度
print("x_ndim:", x.ndim)
# 打印输出张量x中元素的总数
print("x_size:", x.size)
# 打印输出张量x的步长，即在每个维度上跨过一个元素所需的内存距离
print("x_strides:", x.strides)
输出：
x_shape: (2, 2)
x_dtype: Int32
x_itemsize: 4
x_nbytes: 16
x_ndim: 2
x_size: 4
x_strides: (8, 4)
1.4 张量索引
Tensor索引与Numpy索引类似，索引从0开始编制，负索引表示按倒序编制，冒号:和 ...用于对数据进行切片。
# 创建一个Tensor对象tensor，其值为一个numpy数组，数组内容为[[0, 1], [2, 3]]，并且数据类型转换为np.float32
tensor = Tensor(np.array([[0, 1], [2, 3]]).astype(np.float32))
# 打印输出张量tensor的第一行
print("First row: {}".format(tensor[0]))
# 打印输出张量tensor的右下角的值
print("value of bottom right corner: {}".format(tensor[1, 1]))
# 打印输出张量tensor的最后一列
print("Last column: {}".format(tensor[:, -1]))
# 打印输出张量tensor的第一列，使用...表示所有前面的维度
print("First column: {}".format(tensor[..., 0]))
输出：
First row: [0. 1.]
value of bottom right corner: 3.0
Last column: [1. 3.]
First column: [0. 2.]
1.5 张量运算
张量之间有很多运算，包括算术、线性代数、矩阵处理（转置、标引、切片）、采样等，张量运算和NumPy的使用方式类似，下面介绍其中几种操作。
普通算术运算有：加（+）、减（-）、乘（*）、除（/）、取模（%）、整除（//）。
# 创建两个Tensor对象x和y，分别使用numpy数组初始化，数据类型为mindspore.float32
x = Tensor(np.array([1, 2, 3]), mindspore.float32)
y = Tensor(np.array([4, 5, 6]), mindspore.float32)
# 计算x和y的元素级加法，并赋值给output_add
output_add = x + y
# 计算x和y的元素级减法，并赋值给output_sub
output_sub = x - y
# 计算x和y的元素级乘法，并赋值给output_mul
output_mul = x * y
# 计算y除以x的元素级除法，并赋值给output_div
output_div = y / x
# 计算y对x的元素级取模运算，并赋值给output_mod
output_mod = y % x
# 计算y对x的元素级整除运算，并赋值给output_floordiv
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)
输出：
add: [5. 7. 9.]
sub: [-3. -3. -3.]
mul: [ 4. 10. 18.]
div: [4. 2.5 2. ]
mod: [0. 1. 0.]
floordiv: [4. 2. 2.]
concat 将给定维度上的一系列张量连接起来。
# 创建两个Tensor对象data1和data2，分别使用numpy数组初始化，并且数据类型转换为np.float32
data1 = Tensor(np.array([[0, 1], [2, 3]]).astype(np.float32))
data2 = Tensor(np.array([[4, 5], [6, 7]]).astype(np.float32))
# 使用ops子模块中的concat函数沿着指定轴将data1和data2连接起来，axis=0表示沿着第0轴（行方向）连接
output = ops.concat((data1, data2), axis=0)
# 打印输出连接后的张量output
print(output)
# 打印输出连接后的张量output的形状
print("shape:\n", output.shape)
输出：
[[0. 1.]
[2. 3.]
[4. 5.]
[6. 7.]]
shape:
(4, 2)
stack则是从另一个维度上将两个张量合并起来。
# 创建两个Tensor对象data1和data2，分别使用numpy数组初始化，并且数据类型转换为np.float32
data1 = Tensor(np.array([[0, 1], [2, 3]]).astype(np.float32))
data2 = Tensor(np.array([[4, 5], [6, 7]]).astype(np.float32))
# 使用ops子模块中的stack函数沿着新的轴将data1和data2堆叠起来
output = ops.stack([data1, data2])
# 打印输出堆叠后的张量output
print(output)
# 打印输出堆叠后的张量output的形状
print("shape:\n", output.shape)
输出：
[[[0. 1.]
[2. 3.]]
[[4. 5.]
[6. 7.]]]
shape:
(2, 2, 2)
1.6 Tensor与NumPy转换
Tensor可以和NumPy进行互相转换。
1.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))
# 输出
t: [1. 1. 1. 1. 1.] <class 'mindspore.common.tensor.Tensor'>
n: [1. 1. 1. 1. 1.] <class 'numpy.ndarray'>
1.6.2 NumPy转换为Tensor
使用Tensor()将NumPy变量转换为Tensor变量。
# 创建一个numpy数组n，其中包含5个元素，每个元素都是1
n = np.ones(5)
# 创建一个Tensor对象t，其值是从numpy数组n转换而来
t = Tensor.from_numpy(n)
# 对numpy数组n中的每个元素加1，并且结果直接存回n中
np.add(n, 1, out=n)
# 打印输出numpy数组n的值和类型
print(f"n: {n}", type(n))
# 打印输出Tensor对象t的值和类型
print(f"t: {t}", type(t))
# 输出：
n: [2. 2. 2. 2. 2.] <class 'numpy.ndarray'>
t: [2. 2. 2. 2. 2.] <class 'mindspore.common.tensor.Tensor'>
1.7 稀疏张量
- 稀疏张量是一种特殊张量，其中绝大部分元素的值为零。
- 在某些应用场景中（比如推荐系统、分子动力学、图神经网络等），数据的特征是稀疏的，若使用普通张量表征这些数据会引入大量不必要的计算、存储和通讯开销。这时就可以使用稀疏张量来表征这些数据。
- MindSpore现在已经支持最常用的CSR和COO两种稀疏数据格式。
- 常用稀疏张量的表达形式是<indices:Tensor, values:Tensor, shape:Tensor>。其中，indices表示非零下标元素， values表示非零元素的值，shape表示的是被压缩的稀疏张量的形状。在这个结构下，定义了三种稀疏张量结构：CSRTensor、COOTensor和RowTensor。
1.7.1 CSRTensor
CSR（Compressed Sparse Row）压缩稀疏张量格式有着高效的存储与计算的优势。其中，非零元素的值存储在values中，非零元素的位置存储在indptr（行）和indices（列）中。各参数含义如下：
-
indptr: 一维整数张量, 表示稀疏数据每一行的非零元素在values中的起始位置和终止位置, 索引数据类型支持int16、int32、int64。
-
indices: 一维整数张量，表示稀疏张量非零元素在列中的位置, 与values长度相等，索引数据类型支持int16、int32、int64。
-
values: 一维张量，表示CSRTensor相对应的非零元素的值，与indices长度相等。
shape: 表示被压缩的稀疏张量的形状，数据类型为Tuple，目前仅支持二维CSRTensor。
CSRTensor的详细文档，请参考mindspore.CSRTensor。
# 创建一个indptr Tensor，表示CSR格式中的行指针
indptr = Tensor([0, 1, 2])
# 创建一个indices Tensor，表示CSR格式中的列索引
indices = Tensor([0, 1])
# 创建一个values Tensor，表示CSR格式中的非零值
values = Tensor([1, 2], dtype=mindspore.float32)
# 定义一个元组shape，表示CSR张量的形状
shape = (2, 4)
# 使用indptr, indices, values和shape创建一个CSRTensor对象
csr_tensor = CSRTensor(indptr, indices, values, shape)
# 打印输出将CSR张量转换为float64类型后的数据类型
print(csr_tensor.astype(mindspore.float64).dtype)
# 打印输出CSR张量
print(csr_tensor)
# 输出
Float64
CSRTensor(shape=[2, 4], dtype=Float32, indptr=Tensor(shape=[3], dtype=Int64, value=[0 1 2]), indices=Tensor(shape=[2], dtype=Int64, value=[0 1]), values=Tensor(shape=[2], dtype=Float32, value=[ 1.00000000e+00 2.00000000e+00]))
生成的张量表示如下：
1.7.2 COOTensor
COO（Coordinate Format）坐标格式稀疏张量格式用来表示某一张量在给定索引上非零元素的集合，若非零元素的个数为N，被压缩的张量的维数为ndims。各参数含义如下：
- indices: 二维整数张量，每行代表非零元素下标。形状：[N, ndims]， 索引数据类型支持int16、int32、int64。
- values: 一维张量，表示相对应的非零元素的值。形状：[N]。
- shape: 表示被压缩的稀疏张量的形状，目前仅支持二维COOTensor。
COOTensor的详细文档，请参考mindspore.COOTensor。
# 创建一个indices Tensor，表示COO格式中的坐标索引,[0,1]表示第一个元素在第1行，第2列；[1,2]代表第二个元素在第2行，第3列
indices = Tensor([[0, 1], [1, 2]], dtype=mindspore.int32)
# 创建一个values Tensor，表示COO格式中的非零值，[1,2]代表第1个元素是1，第2个元素是2
values = Tensor([1, 2], dtype=mindspore.float32)
# 定义一个元组shape，表示COO张量的形状
shape = (3, 4)
# 使用indices, values和shape创建一个COOTensor对象
coo_tensor = COOTensor(indices, values, shape)
# 打印输出COO张量的非零值
print(coo_tensor.values)
# 打印输出COO张量的坐标索引
print(coo_tensor.indices)
# 打印输出COO张量的形状
print(coo_tensor.shape)
# 打印输出将COO张量转换为float64类型后的数据类型
print(coo_tensor.astype(mindspore.float64).dtype)
# 打印输出coo张量
print(coo_tensor)
import time
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()),'loveisastory')
输出：
生成的张量如下：
更多张量见 RowTensor 和 SparseTensor
2. 总结
今天主要学习了张量（Tensor）的基本概念和用法。张量是多线性函数，用于表示矢量、标量和其他张量之间的线性关系。在机器学习中，张量用于存储和操作数据，如权重、偏置和激活函数输出。学习了张量的创建方式、属性、运算、与NumPy的转换以及稀疏张量
984
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
