深度学习笔记1：数据操作和数据预处理

数据操作

理论部分：

机器学习和神经网络的主要数据结构——N维数组

n维数组也称为张量（tensor），张量表示由一个数值组成的数组，这个数组可能有多个维度。

• 具有一个轴的张量对应数学上的向量（vector）
• 具有两个轴的张量对应数学上的矩阵（matrix）
• 具有两个轴以上的张量没有特殊的数学名称

N维数组样例：

创建数据需要：

• 形状。如3 x 4矩阵
• 每个元素的数据类型。如32位浮点数
• 每个元素的值。如全是0或随机数

访问元素：

代码实现：

首先导入torch

import torch

创建张量，张量表示由一个数值组成的数组，这个数组可能有多个维度。

x = torch.arange(12)
x

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

通过shape属性来访问张量的形状和张量中元素的总数

x.shape

结果：torch.Size([12])

x.numel() #访问张量中元素的总数(标量)

结果：12

调用 reshape 函数改变一个张量的形状而不改变元素数量和元素值

X = x.reshape(3, 4)
X

结果：

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

创建张量：使用全0、全1、其他常量或者从特定分布中随机采样的数字

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

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

结果：

tensor([[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]],

​ [[1., 1., 1., 1.],
​ [1., 1., 1., 1.],
​ [1., 1., 1., 1.]]])

torch.randn(3, 4)

结果：

tensor([[ 0.2104, 1.4439, -1.3455, -0.8273],
[ 0.8009, 0.3585, -0.2690, 1.6183],
[-0.4611, 1.5744, -0.4882, -0.5317]])

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

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

常见的标准算术运算符（+、-、*、/ 和 **）都可以被升级为按元素运算

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)

结果：tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])

连结张量：
也可以把多个张量 连结（concatenate） 在一起

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:按行 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

结果：

tensor([[False, True, False, True],
[False, False, False, False],
[False, False, False, False]])

求和：
对张量中的所有元素进行求和会产生一个只有一个元素的张量

X.sum()

结果：tensor(66.)

广播机制：
即使形状不同，我们仍然可以通过调用广播机制（broadcasting mechanism） 来执行按元素操作

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

结果：

tensor([[0, 1],
[1, 2],
[2, 3]])

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

X[-1], X[1:3]

结果：

(tensor([ 8., 9., 10., 11.]),
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
X

结果：

tensor([[12., 12., 12., 12.],
[12., 12., 12., 12.],
[ 8., 9., 10., 11.]])

内存问题：
运行一些操作可能会导致为新结果分配内存

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

结果：False

执行原地操作

Z = torch.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))

结果：

id(Z): 140452400950336
id(Z): 140452400950336

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

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

结果：True

转为NumPy：
转换为 NumPy 张量

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

结果：(numpy.ndarray, torch.Tensor)

转为标量：
将大小为1的张量转换为 Python 标量

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

结果：(tensor([3.5000]), 3.5, 3.5, 3)

数据预处理

本节使用pandas预处理原始数据，并将原始数据转换为张量格式的步骤。

1、读取数据集

首先创建一个人工数据集，并存储在csv（逗号分隔值）文件 ../data/house_tiny.csv中。 以其他格式存储的数据也可以通过类似的方式进行处理。

import os

os.makedirs(os.path.join('..', 'data'), exist_ok=True) #创建文件夹data
data_file = os.path.join('..', 'data', 'house_tiny.csv') #创建一个house_tiny.csv文件
with open(data_file, 'w') as f:
    f.write('NumRooms,Alley,Price\n')  # 列名 描述了房间数量（“NumRooms”）、巷子类型（“Alley”）和房屋价格（“Price”）
    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文件中加载原始数据集

import pandas as pd

data = pd.read_csv(data_file) # 读取文件
print(data)
#或者data的形式输出
data

结果：

2、处理缺失值

注意，“NaN”项代表缺失值。处理缺失的数据，典型的方法有插值法、删除法

• 插值法用一个替代值弥补缺失值
• 删除法则直接忽略缺失值

在这里，将考虑插值法。

inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2] # 前三列作为输入、最后一列作为输出
inputs = inputs.fillna(inputs.mean()) #通过.fillna()填充空值，插入其他值的平均数，防止出现数据过大的波动。
print(inputs)

结果：

对于inputs中的类别值或离散值，我们将“NaN”视为一个类别。

由于“巷子类型”（“Alley”）列只接受两种类型的类别值“Pave”和“NaN”， pandas可以自动将此列转换为两列“Alley_Pave”和“Alley_nan”。 巷子类型为“Pave”的行会将“Alley_Pave”的值设置为1，“Alley_nan”的值设置为0。

inputs = pd.get_dummies(inputs, dummy_na=True)
print(inputs)

结果：

3、转换为张量格式

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

import torch

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

结果：

(tensor([[3., 1., 0.],
[2., 0., 1.],
[4., 0., 1.],
[3., 0., 1.]], dtype=torch.float64),
tensor([127500, 106000, 178100, 140000]))

4、小结：

• pandas软件包是Python中常用的数据分析工具中，pandas可以与张量兼容。
• 用pandas处理缺失的数据时，我们可根据情况选择用插值法和删除法。