动手学深度学习李沐 —预备知识01

摘要

一是讲解深度学习存储和操作数据的主要接口是张量（ 𝑛 维数组）。它提供了各种功能，包括基本数学运算、广播、索引、切片、内存节省和转换其他 Python 对象。

二是讲解了创建及用pandas加载csv数据文件的方法，以及在数据缺失时的“删除”和“插值”两种操作。

1.数据操作

为了能够完成各种操作，我们需要某种⽅法来存储和操作数据。⼀般来说，我们需要做两件重要的事情：（1）获取数据；（2）在将数据读⼊计算机后对其进⾏处理。如果没有某种⽅法来存储数据，那么获取数据是没有意义的。我们先尝试⼀下合成数据。⾸先，我们介绍n维数组，也称为张量（tensor）。

N维数组是机器学习与神经网络的主要数据结构。

1.1 基本入门操作

⾸先，我们导⼊ torch。请注意，虽然它被称为PyTorch，但我们应该导⼊ torch 而不是 pytorch。

import torch

什么是张量？

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

• 标量—零维张量
• 矢量—一维张量
• 矩阵—二维张量

使⽤arange创建⾏向量

⾸先，可以使⽤arange创建⼀个⾏向量x。这个⾏向量包含从0开始的前12个整数，它们被默认创建为浮点数。张量中的每个值都称为张量的元素（element）。

x = torch.arange(12)
x

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

张量的 shape 属性

通过张量的 shape 属性来访问张量的形状（沿每个轴的⻓度）。

x.shape

torch.Size([12])

如果只想知道张量中元素的总数，需要调用numel()函数。

x.numel()

调⽤ reshape 函数

要改变⼀个张量的形状而不改变元素数量和元素值，可以调⽤ reshape 函数。例如，可以把张量x从形状为(12, )的⾏向量转换为形状为(3,4)的矩阵。

X = x.reshape(3, 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))

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

使用torch.randn（）函数随机生成张量

通过从某个特定的概率分布中随机采样来得到张量中每个元素的值。例如，当我们构造数组来作为神经⽹络中的参数时，我们通常会随机初始化参数的值。以下代码创建⼀个形状为 (3, 4) 的张量。其中的每个元素都从均值为0、标准差为1的标准⾼斯（正态）分布中随机采样。

使用torch.randn（）函数：
torch.randn(3, 4)

随机生成一个形状为（3，4）的张量：
tensor([[-0.9583, -0.4814, -1.1368,  0.6981],
        [ 2.6688,  0.0980,  0.6707, -0.3986],
        [ 0.4458,  0.7346, -1.4084, -1.2253]])

如何为所需张量赋值？

通过提供包含数值的 Python 列表（或嵌套列表）来为所需张量中的每个元素赋予确定值。

比如：
#直接赋值
torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

#最外层的列表对应于轴 0，内层的列表对应于轴 1。
tensor([[2, 1, 4, 3],
        [1, 2, 3, 4],
        [4, 3, 2, 1]])

1.2 运算

张量的运算

对于任意具有相同形状的张量，[常见的标准算术运算符（+、-、*、/ 和 ``）都可以被升级为按元素运算 ** ]。我们可以在同一形状的任意两个张量上调用按元素操作。

#相同形状的张量，运算操作
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.]))
#使用逗号来表示一个具有5个元素的元组，其中每个元素都是按元素操作的结果

除了按元素计算外，我们还可以执行线性代数运算，包括向量点积和矩阵乘法。

张量的连结

将多个张量 连结（concatenate）在一起，把它们端对端地叠起来形成一个更大的张量。 我们只需要提供张量列表，并给出沿哪个轴连结。

下面分别按行（轴-0，形状的第一个元素）和按列（轴-1，形状的第二个元素）连结两个矩阵时会发生什么情况。

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) # 合并


#dim=0是按行去叠加
(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.]])
,
#dim=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.3 广播机制

上面案例中有在相同形状的两个张量上执行按元素操作，在某些情况下，即使形状不同，我们仍然可以通过调用 广播机制 （broadcasting mechanism） 来执行按元素操作。

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

##举例//想要广播，每个轴必须至少有一个张量是1个元素的，否则无法复制！！！
a = torch.arange(3).reshape((3, 1))//a是三行一列
b = torch.arange(2).reshape((1, 2))//b是一行两列
a, b

##输出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.4 索引和切片

与任何 Python 数组一样：第一个元素的索引是 0；可以指定范围以包含第一个元素和最后一个之前的元素。与标准 Python 列表一样，我们可以通过使用负索引根据元素到列表尾部的相对位置访问元素。

用 [-1] 选择最后一个元素，可以用 [1:3] 选择第二个和第三个元素]

X = torch.arange(12, dtype=torch.float32).reshape((3,4))
X[-1], X[1:3]
## 输出结果
(tensor([ 8.,  9., 10., 11.]),//选择X的最后一行
 tensor([[ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.]]))//左闭右开，选择第一行到第二行

除读取外，我们还可以通过指定索引来将元素写入矩阵。

X[1, 2] = 9
X
## 第二行第三列元素值改变
tensor([[ 0,  1,  2,  3],
        [ 4,  5,  9,  7],
        [ 8,  9, 10, 11]])

为多个元素赋值相同的值，我们只需要索引所有元素，然后为它们赋值。

X[0:2, :] = 12  ## 0和1行全为12
X
##[0:2, :] 访问第1行和第2行
tensor([[12, 12, 12, 12],
        [12, 12, 12, 12],
        [ 8,  9, 10, 11]])

1.5 节省内存

运行一些操作可能会导致为新结果分配内存。例如，如果我们用 Y = X + Y，我们将取消引用 Y 指向的张量，而是指向新分配的内存处的张量。

print("Y.ID前：",id(Y))
before = id(Y) # Y的标识号存起来
Y = Y + X
id(Y) == before
print("Y.ID后：",id(Y))

##前后Y的地址发生改变
Y.ID前： 1903150737432
Y.ID后： 1903150735672

执行原地操作非常简单，可以使用切片表示法将操作的结果分配给先前分配的数组，例如 Y[:] = 。

Z = torch.zeros_like(Y)//创建一个新的矩阵 Z，其形状与另一个 Y 相同，使用 zeros_like 来分配一个全 0 的块。
print('id(Z):', id(Z))
Z[:] = X + Y   //对Z的所以元素进行改写
print('id(Z):', id(Z))

## 输出前后的地址
id(Z): 1903151110248
id(Z): 1903151110248

如果在后续计算中没有重复使用 X，我们也可以使用 X[:] = X + Y 或 X += Y 来减少操作的内存开销。比如：

before = id(X)
X[:] = X + Y   //X+=Y
id(X) == before//所以注意在运算太大的数组时，不要去过多的复制就好
## 输出结果
True

1.6 转换为其他 Python 对象

NumPy 在python中基础的多元数组的运算框架。
转换为 NumPy 张量

A = X.numpy()
B = torch.tensor(A)
type(A), type(B)

## 输出类型
(numpy.ndarray, torch.Tensor)

将大小为1的张量转换为 Python 标量，我们可以调用 item 函数或 Python 的内置函数。

a = torch.tensor([3.5])
a, a.item(), float(a), int(a)

##转换结果如下
(tensor([3.5000]), 3.5, 3.5, 3)

2. 数据预处理

简要介绍使用pandas（软件包）预处理原始数据并将原始数据转换为张量格式的步骤。

2.1 读取数据集

我们创建一个人工数据集，并存储在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')   #NA 表示为空值
    f.write('4,NA,178100\n')
    f.write('NA,NA,140000\n')

从创建的CSV文件中加载原始数据集，导入pandas包并调用read_csv函数。该数据集有四行三列。其中每行描述了房间数量（“NumRooms”）、巷子类型（“Alley”）和房屋价格（“Price”）。

# 如果没有安装pandas，只需取消对以下行的注释
#!pip install pandas
import pandas as p
data = p.read_csv(data_file)
print(data)

##加载出原始数据如下
  NumRooms Alley   Price
0       NaN  Pave  127500
1       2.0   NaN  106000
2       4.0   NaN  178100
3       NaN   NaN  140000

2.2 处理缺失值

“NaN”项代表缺失值。为了处理缺失的数据，典型的方法包括插值和删除。

通过位置索引iloc，我们将data分成inputs和outputs，其中前者为data的前两列，而后者为data的最后一列。对于inputs中缺少的数值，我们用同一列的均值替换“NaN”项。

inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2]//拆分数据
inputs = inputs.fillna(inputs.mean())//将inputs项数据中为空值NA 的填补上均值。
print(data)
print(inputs)

## 
  NumRooms Alley   Price
0       NaN  Pave  127500
1       2.0   NaN  106000
2       4.0   NaN  178100
3       NaN   NaN  140000
   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)//#处理string NA，一个特征拆成多个.
print(inputs)
## 填补好的数据集
   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

2.3删除缺失值

使用dropna(axis,subset,how,thresh,inplace)

axis: 删除行还是列，行是0或index,列是1或column，默认是行
subst: 删除某几列的缺失值，可选，默认为所有列
how: any or all，any表明只要出现1个就删除，all表示所有列均为na才删
thresh: 缺失值的数量标准，达到这个阈值才会删除
inplace: 是否替换

#比如删除缺失值最多的列
data=data.dropna(thresh=2,axis=1)//阈值是大于等于2，删除的是列
print(data)
##
   NumRooms   Price
0       NaN  127500
1       2.0  106000
2       4.0  178100
3       NaN  140000

2.4 转换为张量格式

现在inputs和outputs中的所有条目都是数值类型，它们可以转换为张量格式。

import torch

X, y = torch.tensor(inputs.values), torch.tensor(outputs.values)
X, y

##将一个csv文件转换成一个纯的张量
(tensor([[3., 1., 0.],
         [2., 0., 1.],
         [4., 0., 1.],
         [3., 0., 1.]], dtype=torch.float64),//默认时64位的
 tensor([127500, 106000, 178100, 140000]))