PyTorch（二）张量

#c 总结张量总结

该文档主要熟悉了「张量」的概念，理解了「张量」在深度学习中扮演的重要角色，如何判断代码中哪些属于张量。其次熟悉了张量的「四种初始化」，以及「张量属性」，「张量操作」

1 张量概念

#d 张量

「张量（Tensor）」是一个数学概念，在物理学和工程学中也有广泛应用。在计算机科学和深度学习领域，张量是一个「多维数组 」，用于表示数据的一种结构。它是标量、向量和矩阵的高维推广。在深度学习框架中，如TensorFlow和PyTorch，张量是基本的「数据结构」 ，用于「表示」和「处理数据」。张量作为深度学习和数值计算的基石，其引入极大地推动了这些领域的发展，使得模型的开发和训练变得更加高效和简化。

主要属性：

维度（Dimensionality）：张量具有一个或多个维度，这些维度决定了张量的形状。例如，一个标量（单个数字）是0维张量，一个向量（数字列表）是1维张量，一个矩阵（数字表格）是2维张量，以此类推。
形状（Shape） ：张量的形状由其各个维度的大小决定。形状可以表示为一个维度大小的列表，例如，一个3x3的矩阵的形状是(3, 3)，一个4x4x4的立方体张量的形状是(4, 4, 4)。
数据类型（Data Type）：张量中的元素通常具有相同的数据类型，如整数、浮点数等。在深度学习框架中，指定张量的数据类型是常见的做法，以确保计算的准确性和效率。
可操作性（Operability）：张量支持多种数学和科学运算，这些运算可以在其元素上并行执行。例如，可以对张量进行加法、乘法、矩阵乘法等操作。

张量的创造解决的问题：

统一数据表示：张量提供了一种统一的方法来表示不同维度的数据，包括标量（0维张量）、向量（1维张量）、矩阵（2维张量）以及更高维度的数组。这种统一性使得数据处理和算法实现更加标准化和简化。
高效的数据操作：深度学习和数值计算库针对张量操作进行了优化，包括在GPU和TPU等硬件加速器上的并行计算。这使得处理大规模数据和复杂模型变得更加高效。
支持复杂的数学运算：在深度学习中，需要进行大量的矩阵运算、微分运算等。张量及其操作提供了执行这些复杂运算的基础，支持自动微分等高级功能，简化了模型的开发和训练过程。

没有张量的影响：

数据表示不统一：在没有张量的情况下，不同维度的数据需要使用不同的数据结构来表示，如标量使用单个数字，向量使用数组，矩阵使用二维数组等。这会增加数据处理的复杂性，降低代码的通用性和可读性。
计算效率降低：缺乏统一且优化的数据结构和计算框架，意味着无法充分利用硬件加速器的能力，处理大规模数据和复杂模型的效率会大大降低。
模型开发和训练更加困难：没有张量和相应的操作，实现和训练深度学习模型将变得更加复杂和低效。特别是在进行梯度计算、反向传播等操作时，缺乏自动微分功能会使得开发者需要手动计算和实现这些复杂的数学运算。

#e 彩色图像数据集张量

假设我们有一个彩色图像数据集，每张图像的分辨率为28x28像素，且图像为RGB格式（即有红、绿、蓝三个颜色通道）。如果我们有100张这样的图像，我们可以使用一个4维张量来表示这个数据集，其形状为(100, 3, 28, 28)。

第一维表示图像的数量（100张图像）。
第二维表示颜色通道（3个通道：红、绿、蓝）。
第三维和第四维分别表示图像的高度和宽度（28x28像素）。

python 复制代码

import torch

# 假设images_data是一个形状为(100, 3, 28, 28)的4维数组，代表100张28x28像素的RGB图像
images_data = torch.rand(100, 3, 28, 28)

#e 一本书张量

我们可以把一本书视为一个三维张量。

第一维是页数，假设这本书有200页。
第二维是每页的行数，假设每页有30行。
第三维是每行的字符数，假设每行有60个字符。

这样，我们可以用一个形状为(200, 30, 60)的张量来表示这本书的结构。每个元素在这个张量中代表了书中的一个字符的位置（哪一页、哪一行、哪一个字符位置）。

#c 作用张量的作用

在PyTorch框架中，「张量」被用来表示「模型的输入输出」以及「模型的参数」。「张量」与「NumPy的多维数组（ndarray）」类似，不同之处在于张量可以运行在GPU或其他硬件加速器上。实际上，张量和NumPy数组往往可以共享相同的底层内存（CPU状态下），这消除了复制数据的需要）。张量还针对自动微分进行了优化。

2 张量初始化

#c 说明初始化多样

张量的初始化有许多的方式。

#e 四种创建例子初始化多样

python 复制代码

#1.数据直接创建
data = [[1, 2],[3, 4]]
x_data = torch.tensor(data)

#2.从numpy数组创建
np_array = np.array(data)
x_np = torch.from_numpy(np_array)

#3.从另一个张量创建
x_ones = torch.ones_like(x_data)#保留x_data的属性
print(f"Ones Tensor: \n {x_ones} \n")
'''
Ones Tensor: 
 tensor([[1, 1],
        [1, 1]]) 
'''

x_rand = torch.rand_like(x_data, dtype=torch.float)#覆盖数据类型
print(f"Random Tensor: \n {x_rand} \n")
'''
Random Tensor: 
 tensor([[0.3233, 0.8274],
        [0.6734, 0.7567]]) 
'''

#4.使用随机或常量值创建
shape = (2,3,)#2行3列
rand_tensor = torch.rand(shape)#随机张量
ones_tensor = torch.ones(shape)#全1张量
zeros_tensor = torch.zeros(shape)#全0张量
print(f"Random Tensor: \n {rand_tensor} \n")
print(f"Ones Tensor: \n {ones_tensor} \n")
print(f"Zeros Tensor: \n {zeros_tensor}")
'''
Random Tensor:
 tensor([[0.8509, 0.5273, 0.0969],
        [0.0020, 0.7490, 0.3388]])

Ones Tensor:
 tensor([[1., 1., 1.],
        [1., 1., 1.]])

Zeros Tensor:
 tensor([[0., 0., 0.],
        [0., 0., 0.]])
'''

3 张量属性

#c 说明属性说明

「张量」的属性描述了它们的「形状（shape）」、「数据类型（datatype）」以及它们「存储的设备（device）」。

#e 属性例子

python 复制代码

tensor = torch.rand(3,4)
print(f"Shape of tensor: {tensor.shape}")
print(f"Datatype of tensor: {tensor.dtype}")
print(f"Device tensor is stored on: {tensor.device}")
'''
Shape of tensor: torch.Size([3, 4])
Datatype of tensor: torch.float32
Device tensor is stored on: cpu
'''

4 张量操作

#c 说明张量操作

方法多 ：有100多种张量操作，包括算术运算、线性代数、矩阵操作（转置、索引、切片）、抽样等。torch --- PyTorch 2.3 documentation
GPU运行：这些操作都可以在GPU上运行（通常比在CPU上运行速度快）。
移动条件：默认情况下，张量是在CPU上创建的。我们需要使用.to方法显式地将张量移动到GPU上（在检查GPU可用性之后）。然而，将数据从CPU传输到GPU需要一定的时间和资源，因此在设计计算流程时，需要考虑到这一点，以避免频繁的数据传输，从而优化性能。

#e 移动到GPU 张量操作

python 复制代码

if torch.cuda.is_available():
    tensor = tensor.to("cuda")

#e 索引与切片张量操作

python 复制代码

tensor = torch.ones(4,4)
print('First row: ', tensor[0])#索引访问第一行
print('First column: ', tensor[:, 0])#切片和索引组合，:表示维度上的所有元素，0表示第二维度的第一个元素（第一列）
print('Last column:', tensor[..., -1])#...表示选取所有前面的维度，-1表示最后一个元素（最后一列）
tensor[:,1] = 0#切片和索引组合，将第二列的所有元素赋值为0
print(tensor)
'''
First row:  tensor([1., 1., 1., 1.])
First column:  tensor([1., 1., 1., 1.])
Last column: tensor([1., 1., 1., 1.])
tensor([[1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.]])

#e 张量连接张量操作

python 复制代码

t1 = torch.cat([tensor, tensor, tensor], dim=1)#按列连接,dim=0按行连接
print(t1)
'''
tensor([[1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.],
        [1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.],
        [1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.],
        [1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.]])
'''

#e 算数运算张量操作

python 复制代码

#1 矩阵乘法
y1 = tensor @ tensor.T#矩阵乘法,tensor.T表示转置
y2 = tensor.matmul(tensor.T)#矩阵乘法,等价于@
y3 = torch.rand_like(tensor)#随机张量
torch.matmul(tensor, tensor.T, out=y3)#矩阵乘法,指定输出,out=y3表示将结果存储在y3中
print(y3)
'''
tensor([[3., 3., 3., 3.],
        [3., 3., 3., 3.],
        [3., 3., 3., 3.],
        [3., 3., 3., 3.]])
'''
#2 元素级乘法
z1 = tensor * tensor#元素级乘法
z2 = torch.mul(tensor, tensor)#元素级乘法,等价于*
z3 = torch.rand_like(tensor)
torch.mul(tensor, tensor, out=z3)#元素级乘法,指定输出
print(z3)
'''
tensor([[1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.]])

#e 单元素张量张量操作

python 复制代码

'''
如果有一个单元素张量，例如通过将张量的所有值聚合为一个值，可以使用 item() 方法将其转换为Python数值。
'''
agg = tensor.sum()#聚合
agg_item = agg.item()
print(agg_item, type(agg_item))
'''
12.0 <class 'float'>
'''

#e 就地操作张量操作

python 复制代码

'''
就地操作 将结果存储到操作数中的操作称为就地操作。它们以 _ 后缀表示。例如：x.copy_(y), x.t_()，将会改变 x。
"就地操作可以节省一些内存，但在计算导数时可能会因为立即失去历史信息而出现问题。因此，不鼓励使用它们。"

在深度学习中，就地操作虽然可以减少内存的使用，但它们可能会对自动微分造成影响。
由于就地操作会改变张量的状态，这可能会导致梯度计算时无法追踪到之前的值，因为原始的输入状态已经被覆盖了。
这在需要计算梯度和进行反向传播的深度学习模型训练中是不利的，因此通常建议避免在这些情况下使用就地操作。

'''
print(tensor, "\n")
tensor.add_(5)#加5
print(tensor)
'''
tensor([[1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.]])

tensor([[6., 5., 6., 6.],
        [6., 5., 6., 6.],
        [6., 5., 6., 6.],
        [6., 5., 6., 6.]])
'''