深度学习_2 数据操作

数据操作

机器学习包括的核心组件有：

1. 可以用来学习的数据（data）；
2. 如何转换数据的模型（model）；
3. 一个目标函数（objective function），用来量化模型的有效性；
4. 调整模型参数以优化目标函数的算法（algorithm）。

我们要从数据中提取出特征，机器学习、深度学习通过特征来进一步计算得到模型。因此下面主要介绍的是对数据要做哪些操作。

基本操作

深度学习里最多操作的数据结构是N维的数组。

0维：一个数，一个标量，比如1.

1维：比如一个一维数组，他的数据是一个一维的向量（特征向量）。

2维：比如二维数组（特征矩阵）。

当然还有更多维度，比如视频的长，宽，时间，批量大小，通道……

如果我们想创建这样一个数组，需要明确的因素：

1. 数组结构，比如3*4.
2. 数组数据类型，浮点？整形？
3. 具体每个元素的值。

访问元素的方式：

1:3 是左闭右开，表示不包含第3行。

双冒号是跳着访问，后跟步长。比如 ::3 表示从第0行开始访问，每3行访问一次。

明白了这些，那接下来我们就创建一个数组。在机器学习中这种数据的容器一般被称作张量.

创建张量

这部分代码在 jupyter/pytorch/chapter_preliminaries/ndarray.ipynb 里。

在其中可以运行尝试代码部分，创建一维张量：

import torch
X = torch.arange(12) 	# 自动创建 0-11 的一维张量。输入 X 查看 X 内元素数据，输出：
# tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
X.shape					# 查看向量形状。输出 torch.Size([12])，指长12的一维向量
X.numel()				# 只获取长度，输出12
X = X.reshape(3, 4)		# 重新改成了3行4列形状。变成了0123 4567 891011
torch.zeros((2, 3, 4))	# 创建了一个形状为（2,3,4）的全0张量
# 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 同理，是全1的
# torch.randn 是取随机数，随机数是均值=0，方差=1的一个高斯分布中取
torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])	# 给定值创建
torch.exp(X)			# 求e^x中每个元素值得到的新张量

reshape 很有意思，它不是复制原数组后重新开辟了一片空间，而是还是对原数组元素的操作（只不过原来是连续12个数，现在我们把他们视作4个一行的3行元素。存储空间都是连续的）。因此如果我们对 reshape 后的数组赋值，原数组值也会改变。

算术运算

对于两个相同形状的向量可以进行+ - * / **（求幂运算）运算。

x = torch.tensor([1.0, 2, 4, 8])	# 1.0 为了让这个数组变成浮点数组
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.]))
x==y								# 每一项分别判断是否相等。我试了一下，数据类型不影响。2.0==2
x.sum()								# 所有元素求和

张量连接

X = torch.arange(12, dtype=torch.float32).reshape((3,4))	# 创建 float32 位的张量
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.]]))
# 这里我看到弹幕前辈的讲解，感觉很受用。行是样例，列是特征属性，这个类似 MySQL 的关系数据库理解

广播机制

即使两个张量形状不同，也有可能通过广播机制进行按元素操作。

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			# 把a按列复制2份，b按行复制3份，都变成3*2的张量进行操作
# Output:
tensor([[0, 1],
        [1, 2],
        [2, 3]])

索引

X[-1], X[1:3]						# 这里和前面介绍的概念一样。-1 是倒数第一个元素（一个n-1维度张量），1:3 是第2，第3个元素不包括第4个元素。
# Output:
(tensor([ 8.,  9., 10., 11.]),
 tensor([[ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.]]))
X[1,2]=9							# 写入
X[0:2, :] = 12						# 批量写入，给0-1行，所有列写成12
X
# Output:
tensor([[12., 12., 12., 12.],
        [12., 12., 12., 12.],
        [ 8.,  9., 10., 11.]])

节省内存

有一些操作会分配新内存。比如 Y=Y+X，并不是直接在 Y 的原地址上加了X，而是在新地址上计算得到 Y+X，让 Y 指向新地址。

可以通过 id(X) 函数来查看地址。

Y[:]=Y+X 或者 Y+=X 会在原地执行计算，Y 地址不变。

类型转换

转换为 numpy 张量：A=X.numpy()

张量转换为标量：

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

数据预处理

实际处理数据的时候我们并不是从张量数据类型开始的，我们可能得到一个 excel 文件，自己把它转换成 python 张量。以及在转换之前，我们可能对数据进行预处理，比如把其中的空值统一赋值为0之类的操作。以下是转换步骤。

首先我们创建一个 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')

三个属性分别是 room 数量，走廊状态（比如铺了地板），价格。

然后我们把这个数据读入 python，加载原始数据集。

# 如果没有安装pandas，只需取消对以下行的注释来安装pandas
# !pip install pandas
import pandas as pd

data = pd.read_csv(data_file)

这个数据集里还是有很多 NaN 项的，我们要对其进行修改替换。数值类典型处理方式是插值和删除。

首先最后一列数据是完整不需要修改的，那么我们只要处理前两列，我们把前两列数据单独拿出来做完处理最后进行张量拼接。

inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2]

然后我们把 NumEooms 中的 NaN 值用均值替代，

inputs = inputs.fillna(inputs.mean(numeric_only=True))
print(inputs)
# Output:
   NumRooms Alley
0       3.0  Pave
1       2.0   NaN
2       4.0   NaN
3       3.0   NaN

对于 Alley 列，只有两种状态：NaN 和 Pave。我们用 pandas 的方法，把 NaN 也视作一个类，自动拆成两列设置值。

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

最后，我们将前两列处理后得到的结果与最后一列转换为张量后进行拼接。

import torch

X = torch.tensor(inputs.to_numpy(dtype=float))
y = torch.tensor(outputs.to_numpy(dtype=float))
y=y.reshape(4,1)
torch.cat((X,y),dim=1)
# Output:
tensor([[3.0000e+00, 1.0000e+00, 0.0000e+00, 1.2750e+05],
        [2.0000e+00, 0.0000e+00, 1.0000e+00, 1.0600e+05],
        [4.0000e+00, 0.0000e+00, 1.0000e+00, 1.7810e+05],
        [3.0000e+00, 0.0000e+00, 1.0000e+00, 1.4000e+05]], dtype=torch.float64)