- 作者：老汪软件技巧
- 发表时间：2024-10-08 10:11
- 浏览量：
在深度学习中，原始数据往往不是以我们可以直接输入模型的形式存在的。无论是图像、文本还是表格数据，通常需要经过预处理才能为模型提供高质量的输入。因此，掌握数据预处理的技巧是深度学习中至关重要的一步。
本节将详细介绍数据预处理的相关知识，结合 PyTorch 框架演示如何从数据读取、格式转换、数据标准化到批量处理，构建一条完整的数据预处理流水线。
一、数据的加载与读取
在机器学习任务中，数据通常以不同的格式存储，如 .csv 文件、图像文件等。PyTorch 提供了强大的数据读取工具 torch.utils.data.Dataset 和 torch.utils.data.DataLoader，帮助我们高效地加载和处理数据。
1.1 示例：加载 CSV 数据
假设我们有一个包含多维特征的数据集，存储在一个 CSV 文件中。
Feature1,Feature2,Feature3,Label
5.1,3.5,1.4,0
4.9,3.0,1.4,0
4.7,3.2,1.3,0
4.6,3.1,1.5,0
5.0,3.6,1.4,0
7.0,3.2,4.7,1
6.4,3.2,4.5,1
6.9,3.1,4.9,1
5.5,2.3,4.0,1
6.5,2.8,4.6,1
我们可以使用 Pandas 来读取数据，并将其转换为 PyTorch 张量。
import torch
import pandas as pd
from torch.utils.data import Dataset, DataLoader
# 读取csv文件
data = pd.read_csv('data.csv')
# 打印前5条数据
print(data.head(5))
"""
Feature1 Feature2 Feature3 Label
0 5.1 3.5 1.4 0
1 4.9 3.0 1.4 0
2 4.7 3.2 1.3 0
3 4.6 3.1 1.5 0
4 5.0 3.6 1.4 0
"""
# 将 Pandas 数据框转换为 PyTorch 张量
features = torch.tensor(data.iloc[:, :-1].values, dtype=torch.float32)
print(features)
"""
tensor([[5.1000, 3.5000, 1.4000],
[4.9000, 3.0000, 1.4000],
[4.7000, 3.2000, 1.3000],
[4.6000, 3.1000, 1.5000],
[5.0000, 3.6000, 1.4000],
[7.0000, 3.2000, 4.7000],
[6.4000, 3.2000, 4.5000],
[6.9000, 3.1000, 4.9000],
[5.5000, 2.3000, 4.0000],
[6.5000, 2.8000, 4.6000]])
"""
labels = torch.tensor(data.iloc[:, -1].values, dtype=torch.float32)
print(labels)
"""
tensor([0., 0., 0., 0., 0., 1., 1., 1., 1., 1.])
"""
在上面的例子中，features 包含数据的输入特征，labels 则是对应的标签。在实际任务中，我们需要将这些数据划分为训练集和测试集，并进行批量化处理。
输入特征 就是你用来描述某个事物的各种信息。可以把它想象成描述一个事物的“属性”或“特点”。在机器学习中，模型通过这些特征来理解事物。
标签 是你想要预测的目标，通常也是你所知道的“答案”。它可以是任何你想通过数据得出的结果。在分类任务中，标签通常是类别（比如判断一张照片是猫还是狗）。
1.2 使用 Dataset 和 DataLoader
为了方便管理和处理数据，PyTorch 提供了 Dataset 和 DataLoader 类。我们可以自定义 Dataset 类来封装数据集，然后通过 DataLoader 来实现数据的自动批量化和打乱顺序。
class CustomDataset(Dataset):
def __init__(self, features, labels):
self.features = features
self.labels = labels
def __len__(self):
return len(self.features)
def __getitem__(self, idx):
return self.features[idx], self.labels[idx]
# 创建数据集
dataset = CustomDataset(features, labels)
# 使用 DataLoader 进行批量处理
dataloader = DataLoader(dataset, batch_size=5, shuffle=True)
# 打印一个批次的数据
for batch_features, batch_labels in dataloader:
print(batch_features)
print(batch_labels)
break # 只打印一个批次
"""
tensor([[5.1000, 3.5000, 1.4000],
[6.9000, 3.1000, 4.9000],
[4.6000, 3.1000, 1.5000],
[7.0000, 3.2000, 4.7000],
[4.7000, 3.2000, 1.3000]])
tensor([0., 1., 0., 1., 0.])
"""
二、数据标准化与归一化
在机器学习中，特征的尺度差异可能对模型的表现产生影响。为了解决这个问题，通常我们会对数据进行标准化或归一化操作。
2.1 标准化
标准化是指将数据的均值调整为 0，标准差调整为 1。常见的公式为：
Xstandard=X−μσX_{standard} = \frac{X - \mu}{\sigma}Xstandard=σX−μ
其中，μ\muμ 是特征的均值，σ\sigmaσ 是标准差。PyTorch 中可以手动计算这些统计量，并对数据进行标准化。
标准差的公式为：
σ=1N∑i=1N(xi−μ)2\sigma = \sqrt{\frac{1}{N} \sum_{i=1}^{N} (x_i - \mu)^2}σ=N1i=1∑N(xi−μ)2
# 计算特征的均值和标准差
mean = features.mean(dim=0)
print("mean =", mean)
"""
mean = tensor([5.6600, 3.1000, 2.9700])
"""
std = features.std(dim=0)
print("std =", std)
"""
std = tensor([0.9419, 0.3621, 1.6707])
"""
# 对特征进行标准化
features_standardized = (features - mean) / std
print(features_standardized[:5])
"""
tensor([[-5.9457e-01, 1.1047e+00, -9.3973e-01],
[-8.0691e-01, -2.7617e-01, -9.3973e-01],
[-1.0193e+00, 2.7617e-01, -9.9958e-01],
[-1.1254e+00, -6.5845e-07, -8.7987e-01],
[-7.0074e-01, 1.3809e+00, -9.3973e-01]])
"""
2.2 归一化
归一化是将数据缩放到特定的区间，例如 [0, 1]。常用公式为：
Xnormalized=X−XminXmax−XminX_{normalized} = \frac{X - X_{min}}{X_{max} - X_{min}}Xnormalized=Xmax−XminX−Xmin
在处理图像数据时，归一化操作尤为常见。假设我们处理的是像素值为 0 到 255 的图像数据，可以通过归一化将其缩放到 [0, 1] 区间。
# 创建一个随机张量，模拟图像数据
images = torch.randint(0, 256, (10, 3, 32, 32), dtype=torch.float32)
print(images[:1, :, :, :])
"""
tensor([[[[114., 64., 108., ..., 237., 99., 203.],
[168., 128., 189., ..., 11., 58., 93.],
[ 30., 45., 102., ..., 96., 83., 96.],
...,
[ 67., 110., 232., ..., 177., 0., 245.],
[ 62., 228., 7., ..., 121., 236., 143.],
[249., 108., 74., ..., 228., 91., 11.]],
[[ 61., 71., 204., ..., 216., 28., 93.],
[ 61., 76., 127., ..., 193., 246., 236.],
[ 10., 47., 244., ..., 142., 251., 56.],
...,
[211., 124., 202., ..., 242., 50., 82.],
[ 30., 246., 179., ..., 215., 111., 60.],
[ 61., 93., 232., ..., 225., 36., 99.]],
[[ 41., 32., 87., ..., 116., 136., 86.],
[ 15., 73., 152., ..., 191., 142., 42.],
[118., 255., 24., ..., 240., 223., 56.],
...,
[ 40., 6., 237., ..., 165., 179., 119.],
[ 96., 200., 148., ..., 131., 61., 17.],
[ 39., 111., 58., ..., 89., 81., 214.]]]])
"""
# 将图像数据归一化到 [0, 1] 范围
images_normalized = (images - 0) / 255.0
print(images_normalized[0])
"""
tensor([[[0.4471, 0.2510, 0.4235, ..., 0.9294, 0.3882, 0.7961],
[0.6588, 0.5020, 0.7412, ..., 0.0431, 0.2275, 0.3647],
[0.1176, 0.1765, 0.4000, ..., 0.3765, 0.3255, 0.3765],
...,
[0.2627, 0.4314, 0.9098, ..., 0.6941, 0.0000, 0.9608],
[0.2431, 0.8941, 0.0275, ..., 0.4745, 0.9255, 0.5608],
[0.9765, 0.4235, 0.2902, ..., 0.8941, 0.3569, 0.0431]],
[[0.2392, 0.2784, 0.8000, ..., 0.8471, 0.1098, 0.3647],
[0.2392, 0.2980, 0.4980, ..., 0.7569, 0.9647, 0.9255],
[0.0392, 0.1843, 0.9569, ..., 0.5569, 0.9843, 0.2196],
...,
[0.8275, 0.4863, 0.7922, ..., 0.9490, 0.1961, 0.3216],
[0.1176, 0.9647, 0.7020, ..., 0.8431, 0.4353, 0.2353],
[0.2392, 0.3647, 0.9098, ..., 0.8824, 0.1412, 0.3882]],
[[0.1608, 0.1255, 0.3412, ..., 0.4549, 0.5333, 0.3373],
[0.0588, 0.2863, 0.5961, ..., 0.7490, 0.5569, 0.1647],
[0.4627, 1.0000, 0.0941, ..., 0.9412, 0.8745, 0.2196],
...,
[0.1569, 0.0235, 0.9294, ..., 0.6471, 0.7020, 0.4667],
[0.3765, 0.7843, 0.5804, ..., 0.5137, 0.2392, 0.0667],
[0.1529, 0.4353, 0.2275, ..., 0.3490, 0.3176, 0.8392]]])
"""
三、批量化数据与小批量随机梯度下降
在训练深度学习模型时，我们通常不会使用整个数据集来更新模型参数，而是将数据分成小批量（mini-batch），在每个小批量上进行一次更新。这种技术称为小批量随机梯度下降（Mini-batch Stochastic Gradient Descent）。
批量处理示例
通过 DataLoader，我们可以轻松地实现批量化数据处理，并在模型训练中进行迭代。
# 定义简单的模型
model = torch.nn.Linear(3, 1)
print(f"model: {model}")
"""
model: Linear(in_features=3, out_features=1, bias=True)
"""
# 定义损失函数和优化器
criterion = torch.nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
# 训练模型
loss = None
for epoch in range(5):
for batch_features, batch_labels in dataloader:
# 前向传播
outputs = model(batch_features)
loss = criterion(outputs, batch_labels.view(-1, 1))
# 反向传播与优化
optimizer.zero_grad()
loss.backward()
optimizer.step()
print(f'Epoch [{epoch + 1}/5], Loss: {loss.item():.4f}')
"""
Epoch [1/5], Loss: 4.8706
Epoch [2/5], Loss: 0.0903
Epoch [3/5], Loss: 0.0662
Epoch [4/5], Loss: 0.0620
Epoch [5/5], Loss: 0.0581
"""
小批量随机梯度下降的优势四、数据增强与扩展
在一些数据较少的任务中，通过数据增强可以有效提升模型的泛化能力。PyTorch 的 torchvision 库提供了多种图像数据增强技术，如随机旋转、翻转、裁剪等。
pip install torchvision
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
# 定义数据增强操作
transform = transforms.Compose([
transforms.RandomHorizontalFlip(), # 随机水平翻转
transforms.RandomRotation(10), # 随机旋转10度
transforms.ToTensor() # 转换为张量
])
# 加载并增强图像数据
from torchvision.datasets import CIFAR10
"""
CIFAR-10 是计算机视觉领域中常用的数据集之一，主要用于图像分类任务。
它包含 10 类不同类型的彩色图像，数据集的总规模为 60,000 张 32x32 像素的彩色图像，
其中训练集包含 50,000 张图像，测试集包含 10,000 张图像。
"""
train_dataset = CIFAR10(root='./data', train=True, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
# 打印增强后的图像数据
data_iter = iter(train_loader)
images, labels = next(data_iter)
print(images.shape)
"""
torch.Size([32, 3, 32, 32])
"""
五、总结
数据预处理是深度学习任务中不可或缺的一部分。通过高效的数据加载、标准化、批量处理与数据增强，我们可以为模型训练提供高质量的输入，并提高模型的性能与泛化能力。使用 PyTorch 框架，数据预处理的实现变得直观且高效，结合 Dataset 和 DataLoader 可以轻松管理复杂的数据流水线。
掌握这些数据预处理技巧将有助于提升你在深度学习中的实践能力，并让你在面对不同类型的数据时更加游刃有余。
