文章目录
摘要
一是讲解深度学习存储和操作数据的主要接口是张量（ 𝑛 维数组）。它提供了各种功能，包括基本数学运算、广播、索引、切片、内存节省和转换其他 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]))