当前位置：首页 > news >正文

【深度学习笔记】01 数据操作与预处理

news 2025/11/24 7:11:35

01 数据操作与预处理

- 一、数据操作
- - 1.1 基本数据操作
  - 1.2 广播机制
  - 1.3 索引和切片
  - 1.4 节省内存
  - 1.5 转换为其他Python对象
- 二、数据预处理
- - 读取数据集
  - 处理缺失值
  - 转换为张量格式
  - 练习

一、数据操作

1.1 基本数据操作

导入torch

import torch

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

张量中的每个值称为张量的元素（element）。

# 使用arange创建一个行向量x
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])

如果只想知道张量中元素的总数，即形状的所有元素乘积，可以检查它的大小（size）。因为这里处理的是一个向量，所以它的shape与size相同。

x.numel()

x.size()

torch.Size([12])

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

X = x.reshape(3, 4)
X

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

如果我们的目标形状是（高度，宽度），那么在知道宽度后，高度会被自动计算得出。我们可以通过-1来调用此自动计算出形状，即可以用x.reshape(-1, 4)获x.reshape(3, -1)来取代x.reshape(3, 4)。

使用全0、全1、其他常量或者从特定分布中随机采样的数字来初始化矩阵：

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

# 全1矩阵
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.]]])

# 每个元素都从均值为0、标准差为1的标准高斯分布（正态分布）中随机采样的矩阵
torch.randn(3, 4)

tensor([[-0.1503, -0.1886,  0.3691, -0.5482],[ 1.1731,  0.1596,  1.1706,  0.0437],[ 0.0513, -0.5481, -0.7855, -0.9853]])

运算符：

x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
x + y, x - y, x / y, x ** y  # **运算符表示求幂运算

(tensor([ 3.,  4.,  6., 10.]),tensor([-1.,  0.,  2.,  6.]),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)

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

1.2 广播机制

在某些情况下，即使张量形状不同，我们仍然可以通过调用广播机制（broadcasting mechanism）来执行按元素操作。这种机制的工作方式如下：

（1）通过适当复制元素来扩展一个获两个数组，以便在转换之后，两个张量具有相同的形状；

（2）对生成的数组执行按元素操作。

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.3 索引和切片

与任何python数组一样，第一个元素的索引是0，最后一个元素的索引是-1；可以指定范围以包含第一个元素和最后一个之前的元素。

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

其中，[0:2, :]访问第1行和第2行，其中“:”代表沿轴1（列）的所有元素

1.4 节省内存

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

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

False

运行Y = Y + X后，会发现id(Y)指向另一个位置。
这是因为Python首先计算Y + X，为结果分配新的内存，然后使Y指向内存中的这个新位置。

这可能是不可取的，原因有两个：

首先，我们不想总是不必要地分配内存。在机器学习中，我们可能有数百兆的参数，并且在一秒内多次更新所有参数。通常情况下，我们希望原地执行这些更新；
如果我们不原地更新，其他引用仍然会指向旧的内存位置，这样我们的某些代码可能会无意中引用旧的参数。

执行原地操作非常简单。
我们可以使用切片表示法将操作的结果分配给先前分配的数组，例如Y[:] = 。
为了说明这一点，我们首先创建一个新的矩阵Z，其形状与另一个Y相同，
使用zeros_like来分配一个全0的块。

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

id(Z): 1343601274288
id(Z): 1343601274288

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

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

True

1.5 转换为其他Python对象

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)

二、数据预处理

读取数据集

创建一个人工数据集，并存储在csv文件中

import osos.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')

导入pandas包并调用read_csv函数

import pandas as pddata = pd.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

处理缺失值

“NaN”项代表缺失值
处理缺失数据的典型方法包括插值法和删除法，其中插值法用一个替代值弥补缺失值，删除法则直接忽略缺失值

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

inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2]
inputs = inputs.fillna(inputs.select_dtypes(include = 'number').mean())  # 区别于书中的inputs.fillna(inputs.mean())
print(inputs)

   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”。 Alley列为“Pave”的行会将“Alley_Pave”的值设置为1，“Alley_nan”的值设置为0。缺少Alley列的行会将“Alley_Pave”和“Alley_nan”分别设置为0和1。

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

   NumRooms  Alley_Pave  Alley_nan
0       NaN        True      False
1       2.0       False       True
2       4.0       False       True
3       NaN       False       True

转换为张量格式

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

import torchX = torch.tensor(inputs.to_numpy(dtype = float))
y = torch.tensor(outputs.to_numpy(dtype = float))
X, y

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

练习

创建包含更多行和列的原始数据集
（1）删除缺失值最多的列
（2）将预处理后的数据集转换为张量格式

# 创建数据集
import osos.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,others\n')  # 列名f.write('NA,Pave,127500,Pave\n')  # 每行表示一个数据样本f.write('2,NA,106000,NA\n')f.write('4,NA,178100,Pave\n')f.write('NA,NA,140000,Pave\n')

import pandas as pddata = pd.read_csv(data_file)
print(data)

   NumRooms Alley   Price others
0       NaN  Pave  127500   Pave
1       2.0   NaN  106000    NaN
2       4.0   NaN  178100   Pave
3       NaN   NaN  140000   Pave

# 删除缺失值最多的列
count = 0
count_max = 0
labels = ['NumRooms','Alley','Price','others']
for label in labels:count = data[label].isna().sum()if count > count_max:count_max = countflag = label
data_new = data.drop(flag, axis = 1)
data_new

	NumRooms	Price	others
0	NaN	127500	Pave
1	2.0	106000	NaN
2	4.0	178100	Pave
3	NaN	140000	Pave

# 将data_new分成inputs和outputs，其中前者为data_new的前两列，后者为data_new的最后一列
inputs, outputs = data_new.iloc[:, 0:2], data_new.iloc[:, 2]
inputs = inputs.fillna(inputs.select_dtypes(include = 'number').mean())  # 对于inputs中的缺失值，用同一列的均值替换
print(inputs)
outputs = pd.get_dummies(outputs, dummy_na = True)
print(outputs)

   NumRooms   Price
0       3.0  127500
1       2.0  106000
2       4.0  178100
3       3.0  140000Pave    NaN
0   True  False
1  False   True
2   True  False
3   True  False

# 转换为张量格式
import torchX = torch.tensor(inputs.to_numpy(dtype = float))
y = torch.tensor(outputs.to_numpy(dtype = float))
X, y

(tensor([[3.0000e+00, 1.2750e+05],[2.0000e+00, 1.0600e+05],[4.0000e+00, 1.7810e+05],[3.0000e+00, 1.4000e+05]], dtype=torch.float64),tensor([[1., 0.],[0., 1.],[1., 0.],[1., 0.]], dtype=torch.float64))