自学深度学习1：预备知识1数据操作-CSDN博客

本文链接：https://blog.csdn.net/Rumae/article/details/133777984

本章节主要学习深度学习的一些前序内容和必要的预备知识。

1.1数据操作

为了能够完成各种数据操作，我们需要某种方法来存储和操作数据。通常，我们需要做两件重要的事：（1）获取数据；（2）将数据读入计算机后对其进行处理。如果没有某种方法来存储数据，那么获取数据是没有意义的。

1.1.1入门

首先，我们导入torch。请注意，虽然它被称为PyTorch，但是代码中使用torch而不是pytorch。

import torch

张量表示一个由数值组成的数组，这个数组可能有多个维度。具有一个轴的张量对应数学上的向量（vector）；具有两个轴的张量对应数学上的矩阵（matrix）；具有两个轴以上的张量没有特殊的数学名称。

我们可以使用 arange 创建一个行向量 x,这个行向量包含以0开始的前12个整数，它们默认创建为整数。张量中的每个值都称为张量的元素（element）,除非额外指定，新的张量将存储在内存中，并采用基于CPU的计算。

x = torch.arange(12)#使用torch.arange 创建一个行向量 x
x
#tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

可以通过张量的shape属性来访问张量（沿每个轴的长度）的形状, 如果只想知道张量中元素的总数，即形状的所有元素乘积，可以检查它的大小（size）。因为这里在处理的是一个向量，所以它的shape与它的size相同。

x.shape #通过张量的shape属性来访问张量（沿每个轴的长度）的形状，相当于矩阵的列数。
#torch.Size([12])

x.size() #同上
#torch.Size([12])

x.numel()#访问元素总数，即矩阵列数*行数
#12

要想改变一个张量的形状而不改变元素数量和元素值，可以调用reshape函数。我们不需要通过手动指定每个维度来改变形状。也就是说，如果我们的目标形状是（高度,宽度），那么在知道宽度后，高度会被自动计算得出，不必我们自己做除法。我们可以通过-1来调用此自动计算出维度的功能。即我们可以用x.reshape(-1,4)或x.reshape(3,-1)来取代x.reshape(3,4)。

X = x.reshape(3, 4)#改变张量形状，转化为三行四列矩阵
#X = x.reshape(3, -1),X = x.reshape(-1, 4)
X
#tensor([[ 0,  1,  2,  3],
#       [ 4,  5,  6,  7],
#       [ 8,  9, 10, 11]])

有时，我们希望使用全0、全1、其他常量，或者从特定分布中随机采样的数字来初始化矩阵。我们可以创建一个形状为（2,3,4）的张量，其中所有元素都设置为0。代码如下：

torch.zeros((2, 3, 4))#2为矩阵个数，3为行数，4为列数
#tensor([[[0., 0., 0., 0.],
#        [0., 0., 0., 0.],
#         [0., 0., 0., 0.]],
#
#        [[0., 0., 0., 0.],
#         [0., 0., 0., 0.],
#        [0., 0., 0., 0.]]])

同样，我们可以创建一个形状为(2,3,4)的张量，其中所有元素都设置为1

torch.ones((2, 3, 4))

有时我们想通过从某个特定的概率分布中随机采样来得到张量中每个元素的值。其中的每个元素都从均值为0、标准差为1的标准高斯分布（正态分布）中随机采样。

torch.randn(3, 4)#随机生成三行四列矩阵，其中的每个元素都从均值为0、标准差为1的标准高斯分布（正态分布）中随机采样。
#tensor([[-1.0210, -0.4495,  2.4080,  0.1138],
#        [-0.9633, -0.6017,  1.5117, -0.3808],
#        [ 1.3949, -0.4883,  0.4522,  0.3671]])

1.1.2 运算符

在数学表示法中，我们将通过符号 $f:\mathbb{R}\rightarrow \mathbb{R}$ 来表示一元标量运算符（只接收一个输入）。这意味着该函数从任何实数映射到另一个实数。同样，我们通过符号 $f:\mathbb{R},\mathbb{R}\rightarrow \mathbb{R}$ 表示二元标量运算符，这意味着该函数接收两个输入，并产生一个输出。给定同一形状的任意两个向量 $u$ 和 $v$ 和二元运算符 $f$ ，我们可以得到向量 $c=F(u,v)$ 。在这里，我们通过将标量函数升级为按元素向量运算来生成向量值 $F:\mathbb{R}^{d},\mathbb{R}^{d}\rightarrow \mathbb{R}^{d}$ 。

对于任意具有相同形状的张量，常见的标准算术运算符（+、-、*、/和**）都可以被升级为按元素运算。我们可以在同一形状的任意两个张量上调用按元素操作。在下面的例子中，我们使用逗号来表示一个具有5个元素的元组，其中每个元素都是按元素操作的结果。

x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y  # **运算符是求幂运算

#(tensor([ 3.,  4.,  6., 10.]),
# tensor([-1.,  0.,  2.,  6.]),
# tensor([ 2.,  4.,  8., 16.]),
# tensor([0.5000, 1.0000, 2.0000, 4.0000]),
# tensor([ 1.,  4., 16., 64.]))

“按元素”方式可以应用更多的计算，包括像求幂这样的一元运算符。

torch.exp(x) #求e的x次幂，由于x为张量，所以输出也为一个张量
#tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])

我们也可以把多个张量连结（concatenate）在一起，把它们端对端地叠起来形成一个更大的张量。我们只需要提供张量列表，并给出沿哪个轴连结。下面的例子分别演示了当我们沿行（轴-0，形状的第一个元素）和按列（轴-1，形状的第二个元素）连结两个矩阵时，会发生什么情况。我们可以看到，第一个输出张量的轴-0长度（6）是两个输入张量轴-0长度的总和（3+3）；第二个输出张量的轴-1长度（8）是两个输入张量轴-1长度的总和（4+4）。

X = torch.arange(12, dtype=torch.float32).reshape((3,4))
Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
torch.cat((X, Y), dim=0), torch.cat((X, Y), dim=1)
#torch.cat((X, Y), dim=0)为沿行连结
#torch.cat((X, Y), dim=1)为沿列连结


# (tensor([[ 0.,  1.,  2.,  3.],
#          [ 4.,  5.,  6.,  7.],
#          [ 8.,  9., 10., 11.],
#          [ 2.,  1.,  4.,  3.],
#          [ 1.,  2.,  3.,  4.],
#          [ 4.,  3.,  2.,  1.]]),
#  tensor([[ 0.,  1.,  2.,  3.,  2.,  1.,  4.,  3.],
#          [ 4.,  5.,  6.,  7.,  1.,  2.,  3.,  4.],
#          [ 8.,  9., 10., 11.,  4.,  3.,  2.,  1.]]))

有时，我们想通过逻辑运算符构建二元张量。以X == Y为例：对于每个位置，如果X和Y在该位置相等，则新张量中相应项的值为1。这意味着逻辑语句X == Y在该位置处为真，否则该位置为0。

X == Y
# tensor([[False,  True, False,  True],
#         [False, False, False, False],
#         [False, False, False, False]])

对张量中的所有元素进行求和，会产生一个单元素张量。

X.sum()
#tensor(66.) 其中数字后的.是浮点数的意思

1.1.3 广播机制

在上面的部分中，我们看到了如何在相同形状的两个张量上执行按元素操作。在某些情况下，即使形状不同，我们仍然可以通过调用 广播机制（broadcasting mechanism）来执行按元素操作。这种机制的工作方式如下：

通过适当复制元素来扩展一个或两个数组，以便在转换之后，两个张量具有相同的形状；
对生成的数组执行按元素操作。

在大多数情况下，我们reshape方法进行广播

a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
a, b
#(tensor([[0],
#          [1],
#          [2]]),
#  tensor([[0, 1]]))

由于a和b分别是3×1和1×2矩阵，如果让它们相加，它们的形状不匹配。我们将两个矩阵广播为一个更大的3×2矩阵，如下所示：矩阵a将复制列，矩阵b将复制行，然后再按元素相加

a+b
#tensor([[0, 1],
#         [1, 2],
#         [2, 3]])

1.1.4 索引和切片

张量中的元素可以通过索引访问。与任何Python数组一样：第一个元素的索引是0，最后一个元素索引是-1；可以指定范围以包含第一个元素和最后一个之前的元素。

如下所示，我们可以用[-1]选择最后一个元素，可以用[1:3]选择第二个和第三个元素：

X
#tensor([[ 0.,  1.,  2.,  3.],
#        [ 4.,  5.,  6.,  7.],
#        [ 8.,  9., 10., 11.]])
X[-1], X[1:3]#注意区分：冒号和，逗号区别 冒号是指张量中的元素，指第一行和第三行，逗号是指索引，0为第一个索引
X[1, 2] = 9#除读取外，我们还可以通过指定索引来将元素写入矩阵。
X
#tensor([[ 0.,  1.,  2.,  3.],
#        [ 4.,  5.,  9.,  7.],
#        [ 8.,  9., 10., 11.]])

如果我们想为多个元素赋值相同的值，我们只需要索引所有元素，然后为它们赋值。 例如，[0:2, :]
访问第1行和第2行，其中“:”代表沿轴1（列）的所有元素。 虽然我们讨论的是矩阵的索引，但这也适用于向量和超过2个维度的张量。

X[0:2, :] = 12
X
#tensor([[12., 12., 12., 12.],
#        [12., 12., 12., 12.],
#        [ 8.,  9., 10., 11.]])

1.1.5 节省内存（重要）

运行一些操作可能会导致为新结果分配内存。例如，如果我们用Y = X + Y，我们将取消引用Y指向的张量，而是指向新分配的内存处的张量。在下面的例子中，我们用Python的id()函数演示了这一点，它给我们提供了内存中引用对象的确切地址。

before = id(Y)
Y = Y + X
id(Y) == before
#False

执行原地操作非常简单。我们可以使用切片表示法将操作的结果分配给先前分配的数组，例如Y[:] = <expression>。为了说明这一点，我们首先创建一个新的矩阵Z，其形状与另一个Y相同，使用zeros_like来分配一个全0的块。

Z = torch.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))
#id(Z): 23050896
#id(Z): 23050896
如果在后续计算中没有重复使用X，我们也可以使用X[:] = X + Y或X += Y来减少操作的内存开销。
before = id(X)
X += Y
id(X) == before
#True
1.1.6小结

笔者通过本小节内容，初步了解了数据操作的基本步骤。对本人而言，在之前的代码学习中确实从未考虑过内存开销的问题，像打开了新世界的大门~以后会尽量注意代码程序中的相关问题，努力让自己的代码变得规范和精简