数据操作
import torch x=torch.arange(12) # x的output为 tensor([0,1,2,3,4,5,6,7,8,9,10,11]) # 可以通过张量的shape属性来访问张量的形状和张量中元素的总数 x.shape # output: torch.Size([12]) x.numel() # output: 12 # 如果只想知道张量中元素的总数,即形状的所有元素乘积,可以检查它的大小(size) x.size # output: 12 # 想改变一个张量的形状而不改变元素数量和元素值,可以调用reshape函数 X=x.reshape(3,4) # output: tensor([[0,1,2,3], [4,5,6,7], [8,9,10,11]]) ''' 我们不需要通过手动指定每个维度来改变形状。 也就是说,如果我们的目标形状是(高度,宽度), 那么在知道宽度后,高度会被自动计算得出,不必我们自己做除法。 在上面的例子中,为了获得一个3行的矩阵,我们手动指定了它有3行和4列。 幸运的是,我们可以通过-1来调用此自动计算出维度的功能。 即我们可以用x.reshape(-1,4)或x.reshape(3,-1)来取代x.reshape(3,4)。''' ''' 有时,我们希望[使用全0、全1、其他常量,或者从特定分布中随机采样的数字]来初始化矩阵。 我们可以创建一个形状为(2,3,4)的张量,其中所有元素都设置为0。''' torch.zeros((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)) ''' 我们还可以[通过提供包含数值的Python列表(或嵌套列表),来为所需张量中的每个元素赋予确定值]。 在这里,最外层的列表对应于轴0,内层的列表对应于轴1。 ''' torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]]) ''' tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]]) '''
运算符
我们的兴趣不仅限于读取数据和写入数据。 我们想在这些数据上执行数学运算,其中最简单且最有用的操作是按元素(elementwise)运算。 它们将标准标量运算符应用于数组的每个元素。 对于将两个数组作为输入的函数,按元素运算将二元运算符应用于两个数组中的每对位置对应的元素。 我们可以基于任何从标量到标量的函数来创建按元素函数。
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 # **运算符是求幂运算 ''' output: (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.])) ''' ''' [我们也可以把多个张量连结(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) ''' output: (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 ''' output: tensor([[False, True, False, True], [False, False, False, False], [False, False, False, False]]) ''' # 对张量中的所有元素进行求和,会产生一个单元素张量。 X.sum() # output: tensor(66.)
广播机制
在上面的部分中,我们看到了如何在相同形状的两个张量上执行按元素操作。 在某些情况下,即使形状不同,我们仍然可以通过调用 广播机制(broadcasting mechanism)来执行按元素操作。 这种机制的工作方式如下:
-
通过适当复制元素来扩展一个或两个数组,以便在转换之后,两个张量具有相同的形状;
-
对生成的数组执行按元素操作。
在大多数情况下,我们将沿着数组中长度为1的轴进行广播,如下例子:
a = torch.arange(3).reshape(3, 1) b = torch.arange(2).reshape(1, 2) a, b ''' output: (tensor([[0], [1], [2]]), tensor([[0, 1]])) ''' ''' 由于a和b分别是 3×1 和 1×2 矩阵,如果让它们相加,它们的形状不匹配。 我们将两个矩阵广播为一个更大的 3×2 矩阵,如下所示:矩阵a将复制列, 矩阵b将复制行,然后再按元素相加。 ''' a+b ''' output: array([[0., 1.], [1., 2.], [2., 3.]]) '''
索引和切片
就像在任何其他Python数组中一样,张量中的元素可以通过索引访问。 与任何Python数组一样:第一个元素的索引是0,最后一个元素索引是-1; 可以指定范围以包含第一个元素和最后一个之前的元素。
如下所示,我们可以用[-1]
选择最后一个元素,可以用[1:3]
选择第二个和第三个元素:
X, X[-1], X[1:3] ''' output: (tensor([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.]]), tensor([ 8., 9., 10., 11.]), tensor([[ 4., 5., 6., 7.], [ 8., 9., 10., 11.]])) ''' # 除读取外,我们还可以通过指定索引来将元素写入矩阵。 X[1, 2] = 9 X ''' output: array([[ 0., 1., 2., 3.], [ 4., 5., 9., 7.], [ 8., 9., 10., 11.]]) ''' ''' 如果我们想[为多个元素赋值相同的值,我们只需要索引所有元素,然后为它们赋值。] 例如,[0:2, :]访问第1行和第2行,其中“:”代表沿轴1(列)的所有元素。 虽然我们讨论的是矩阵的索引,但这也适用于向量和超过2个维度的张量。 ''' X[0:2, :] = 12 X ''' output: array([[12., 12., 12., 12.], [12., 12., 12., 12.], [ 8., 9., 10., 11.]]) '''
节省内存
[运行一些操作可能会导致为新结果分配内存]。 例如,如果我们用Y = X + Y
,我们将取消引用Y
指向的张量,而是指向新分配的内存处的张量。
在下面的例子中,我们用Python的id()
函数演示了这一点, 它给我们提供了内存中引用对象的确切地址。 运行Y = Y + X
后,我们会发现id(Y)
指向另一个位置。 这是因为Python首先计算Y + X
,为结果分配新的内存,然后使Y
指向内存中的这个新位置。
before = id(Y) Y = Y + X id(Y) == before # output: False
这可能是不可取的,原因有两个:
- 首先,我们不想总是不必要地分配内存。在机器学习中,我们可能有数百兆的参数,并且在一秒内多次更新所有参数。通常情况下,我们希望原地执行这些更新;
- 如果我们不原地更新,其他引用仍然会指向旧的内存位置,这样我们的某些代码可能会无意中引用旧的参数。
幸运的是,(执行原地操作)非常简单。 我们可以使用切片表示法将操作的结果分配给先前分配的数组,例如Y[:] = <expression>
。 为了说明这一点,我们首先创建一个新的矩阵Z
,其形状与另一个Y
相同, 使用zeros_like
来分配一个全&amp;lt;span id="MathJax-Span-163" class="mrow"&amp;gt;&amp;lt;span id="MathJax-Span-164" class="mn"&amp;gt;0的块。
# 执行原地操作 Z = torch.zeros_like(Y) print('id(Z):', id(Z)) Z[:] = X + Y print('id(Z):', id(Z))
[如果在后续计算中没有重复使用X
, 我们也可以使用X[:] = X + Y
或X += Y
来减少操作的内存开销。]
before = id(X) X[:] = X + Y id(X) == before # output: True, 写成X=X+Y就是False
转换成其他python对象
将深度学习框架定义的张量[转换为NumPy张量(ndarray
)]很容易,反之也同样容易。 转换后的结果不共享内存。 这个小的不便实际上是非常重要的:当在CPU或GPU上执行操作的时候, 如果Python的NumPy包也希望使用相同的内存块执行其他操作,人们不希望停下计算来等它。
A = X.numpy() B = torch.tensor(A) type(A), type(B) # output: (numpy.ndarray, torch.Tensor)
要(将大小为1的张量转换为Python标量),我们可以调用item
函数或Python的内置函数。
a = torch.tensor([3.5]) a, a.item(), float(a), int(a) # output: (tensor([3.5000]), 3.5, 3.5, 3)
小结
- 深度学习存储和操作数据的主要接口是张量(&amp;lt;span id="MathJax-Span-166" class="mrow"&amp;gt;&amp;lt;span id="MathJax-Span-167" class="mi"&amp;gt;n维数组)。它提供了各种功能,包括基本数学运算、广播、索引、切片、内存节省和转换其他Python对象。
数据预处理
为了能用深度学习来解决现实世界的问题,我们经常从预处理原始数据开始, 而不是从那些准备好的张量格式数据开始。 在Python中常用的数据分析工具中,我们通常使用pandas
软件包。 像庞大的Python生态系统中的许多其他扩展包一样,pandas
可以与张量兼容。 本节我们将简要介绍使用pandas
预处理原始数据,并将原始数据转换为张量格式的步骤。 后面的章节将介绍更多的数据预处理技术。
读取数据集
举一个例子,我们首先(创建一个人工数据集,并存储在CSV(逗号分隔值)文件) ../data/house_tiny.csv
中。 以其他格式存储的数据也可以通过类似的方式进行处理。 下面我们将数据集按行写入CSV文件中。
import os os.makedirs(os.path.join('..', 'data'), exist_ok=True) data_file = os.path.join('..', 'data', 'house_tiny.csv') with open(data_file, 'w') as f: f.write('NumRooms,Alley,Price\n') # 列名 f.write('NA,Pave,127500\n') # 每行表示一个数据样本 f.write('2,NA,106000\n') f.write('4,NA,178100\n') f.write('NA,NA,140000\n')
要[从创建的CSV文件中加载原始数据集],我们导入pandas
包并调用read_csv
函数。该数据集有四行三列。其中每行描述了房间数量(“NumRooms”)、巷子类型(“Alley”)和房屋价格(“Price”)。
import pandas as pd data = pd.read_csv(data_file) print(data) ''' output: NumRooms Alley Price 0 NaN Pave 127500 1 2.0 NaN 106000 2 4.0 NaN 178100 3 NaN NaN 140000 '''
处理缺失值
注意,“NaN”项代表缺失值。 [为了处理缺失的数据,典型的方法包括插值法和删除法,] 其中插值法用一个替代值弥补缺失值,而删除法则直接忽略缺失值。 在(这里,我们将考虑插值法)。
通过位置索引iloc
,我们将data
分成inputs
和outputs
, 其中前者为data
的前两列,而后者为data
的最后一列。 对于inputs
中缺少的数值,我们用同一列的均值替换“NaN”项。
inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2] inputs = inputs.fillna(inputs.mean()) print(inputs) ''' output: NumRooms Alley 0 3.0 Pave 1 2.0 NaN 2 4.0 NaN 3 3.0 NaN '''
[对于inputs
中的类别值或离散值,我们将“NaN”视为一个类别。] 由于“巷子类型”(“Alley”)列只接受两种类型的类别值“Pave”和“NaN”, pandas
可以自动将此列转换为两列“Alley_Pave”和“Alley_nan”。 巷子类型为“Pave”的行会将“Alley_Pave”的值设置为1,“Alley_nan”的值设置为0。 缺少巷子类型的行会将“Alley_Pave”和“Alley_nan”分别设置为0和1。
inputs = pd.get_dummies(inputs, dummy_na=True) print(inputs) ''' output: NumRooms Alley_Pave Alley_nan 0 3.0 1 0 1 2.0 0 1 2 4.0 0 1 3 3.0 0 1 '''
转换为张量格式
[现在inputs
和outputs
中的所有条目都是数值类型,它们可以转换为张量格式。] 当数据采用张量格式后,可以通过在 :numref:sec_ndarray
中引入的那些张量函数来进一步操作。
import torch X, y = torch.tensor(inputs.values), torch.tensor(outputs.values) X, y ''' output: (tensor([[3., 1., 0.], [2., 0., 1.], [4., 0., 1.], [3., 0., 1.]], dtype=torch.float64), tensor([127500, 106000, 178100, 140000])) '''
小结
pandas
软件包是Python中常用的数据分析工具中,pandas
可以与张量兼容。- 用
pandas
处理缺失的数据时,我们可根据情况选择用插值法和删除法。