（2-1）数据集的基本处理

如果你是AI零基础，请关注本专栏，将带你一起飞。

数据预处理是机器学习和数据分析中的一个重要步骤，旨在准备原始数据，使其适合用于模型训练和分析。原始数据通常包含噪音、缺失值、不一致性等问题，数据预处理的目标是清理、转换和准备数据，以便提高模型的性能和可靠性。

2.2.1  转换为Tensor格式

在PyTorch程序中，可以使用模块torchvision.transforms中的预定义函数将数据集转换为Tensor格式。这些函数提供了一系列常用的数据预处理操作，例如将图像转换为Tensor、归一化、裁剪等。以下是一些常用的数据预处理函数：

1. ToTensor()：将PIL图像或NumPy数组转换为Tensor格式。该函数会将图像数据的像素值缩放到[0, 1]之间，并将通道顺序从HWC转换为CHW。
2. Normalize(mean, std)：对Tensor进行标准化处理。需要指定每个通道的均值和标准差。该函数将每个通道的像素值减去均值并除以标准差。
3. Resize(size)：调整图像的大小。可以指定输出图像的目标尺寸。
4. CenterCrop(size)：对图像进行中心裁剪，保留指定尺寸的区域。
5. RandomCrop(size)：对图像进行随机裁剪，保留指定尺寸的区域。
6. RandomHorizontalFlip()：随机水平翻转图像。
7. RandomRotation(degrees)：随机旋转图像，可以指定旋转的角度范围。
8. RandomResizedCrop(size, scale, ratio)：随机裁剪和缩放图像，可以指定裁剪的目标尺寸、缩放范围和长宽比范围。

上述预定义函数可以通过Compose函数组合在一起，按照指定的顺序依次应用于数据集。请看下面的例子，展示了将数据集转换为Tensor格式的过程。

实例2-3：将数据集转换为Tensor格式（源码路径：daima\2\zhuan.py）

实例文件zhuan.py的具体实现代码如下所示。

import torchvision.transforms as transforms
from torchvision.datasets import CIFAR10
# 定义转换操作列表
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
])

# 创建CIFAR-10数据集实例并应用转换操作
dataset = CIFAR10(root='data/', train=True, download=True, transform=transform)
# 获取第一个样本
sample = dataset[0]
# 打印输出结果
print('图像Tensor大小:', sample[0].size())
print('标签:', sample[1])

在上述代码中，首先导入了transforms模块中的函数和Compose函数。然后，定义了一个转换操作列表，其中包括了将图像转换为Tensor格式和对Tensor进行标准化的操作。接下来，创建CIFAR-10数据集实例时，通过transform参数传入转换操作列表，从而将数据集转换为Tensor格式。最后，通过sample[0]来获取转换后的图像Tensor，并使用.size()方法查看其大小。同时，使用sample[1]来获取标签信息，并直接打印输出数据集信息。执行后会输出：

Files already downloaded and verified

图像Tensor大小: torch.Size([3, 32, 32])

标签: 6

通过这种方式，数据集中的每个样本将以Tensor格式进行表示，方便在PyTorch中进行进一步的处理和训练。

在 TensorFlow 中，将数据集转换为 Tensor 格式是一个常见的步骤，通常需要将原始数据进行适当的转换、标准化和处理，然后将其转换为张量形式以供模型使用。例如下面是一个典型的例子，展示了将数据集转换为 Tensor 格式的过程。

实例2-4：将数据集转换为Tensor格式（源码路径：daima\2\tzhuan.py）

实例文件tzhuan.py的具体实现代码如下所示。

import tensorflow as tf
from sklearn.model_selection import train_test_split
import numpy as np

# 假设有一组原始数据 features 和 labels
features = np.random.rand(100, 2)  # 生成随机输入特征
labels = np.random.randint(0, 2, size=100)  # 随机生成标签

# 将原始数据划分为训练集和测试集
train_features, test_features, train_labels, test_labels = train_test_split(features, labels, test_size=0.2, random_state=42)

# 将数据转换为张量
train_features_tensor = tf.convert_to_tensor(train_features, dtype=tf.float32)
train_labels_tensor = tf.convert_to_tensor(train_labels, dtype=tf.int64)
test_features_tensor = tf.convert_to_tensor(test_features, dtype=tf.float32)
test_labels_tensor = tf.convert_to_tensor(test_labels, dtype=tf.int64)

# 创建 TensorFlow 数据集对象
train_dataset = tf.data.Dataset.from_tensor_slices((train_features_tensor, train_labels_tensor))
test_dataset = tf.data.Dataset.from_tensor_slices((test_features_tensor, test_labels_tensor))

# 对数据集进行处理、批次化等操作
batch_size = 32
train_dataset = train_dataset.shuffle(buffer_size=len(train_features)).batch(batch_size)
test_dataset = test_dataset.batch(batch_size)

# 打印数据集信息
print("训练集样本数:", len(train_features))
print("测试集样本数:", len(test_features))

上述代码的实现流程如下：

1. 导入了需要使用的库，TensorFlow 用于创建数据集和张量，train_test_split 用于将数据划分为训练集和测试集，numpy 用于生成示意数据。
2. 使用 numpy 生成示意的输入特征和标签数据。features 是一个大小为 (100, 2) 的数组，每行表示一个输入样本的两个特征值，labels 是一个大小为 100 的数组，每个元素表示一个样本的标签。
3. 使用 train_test_split 将数据划分为训练集和测试集。train_features 和 train_labels 是训练集的输入特征和标签，test_features 和 test_labels 是测试集的输入特征和标签。
4. 使用 tf.convert_to_tensor 函数将 train_features、train_labels、test_features 和 test_labels 转换为 TensorFlow 张量。这将使得我们能够在 TensorFlow 中进行进一步的处理和操作。
5. 使用 tf.data.Dataset.from_tensor_slices 函数，我们创建了训练集和测试集的 TensorFlow 数据集对象。每个数据集对象包含了一组输入特征和标签的对应关系。
6. 使用 shuffle 函数对训练集进行随机重排，以确保数据的随机性。然后，我们使用 batch 函数将数据划分为大小为 batch_size 的批次。这些操作将为模型训练和测试提供适当的输入。
7. 最后，打印输出训练集和测试集的样本数，以便了解数据集的规模。

执行后会输出：

训练集样本数: 80

测试集样本数: 20

2.2.2  标准化处理

在PyTorch程序中，可以使用transforms模块中的类Normalize来对数据集进行标准化处理。类Normalize将输入的张量按元素进行归一化，计算公式为：

output = (input - mean) / std

其中，mean是均值，std是标准差。对于图像数据，通常对每个颜色通道分别进行归一化处理。请看下面的例子，演示了使用类Normalize对数据集进行标准化处理的过程。

实例2-4：使用类Normalize对数据集进行标准化处理（源码路径：daima\2\biao.py）

实例文件biao.py的具体实现代码如下所示。

import torchvision.transforms as transforms
from torchvision.datasets import CIFAR10
# 定义转换操作列表，包括ToTensor和Normalize
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
])

# 创建CIFAR-10数据集实例并应用转换操作
dataset = CIFAR10(root='data/', train=True, download=True, transform=transform)
# 获取第一个样本
sample = dataset[0]
# 打印转换后的图像张量
print('转换后的图像张量:', sample[0])

在上述代码中，定义了一个名为transform的转换操作列表，其中包括了ToTensor和Normalize操作。ToTensor操作将图像转换为张量格式，而Normalize操作对每个通道的像素值进行归一化处理，使其均值为0.5，标准差为0.5。然后，创建CIFAR-10数据集实例时应用了这个转换操作。最后，通过打印输出第一个样本的图像张量，可以观察到已经完成了标准化处理。执行后会输出：

Files already downloaded and verified

转换后的图像张量: tensor([[[-0.5373, -0.6627, -0.6078,  ...,  0.2392,  0.1922,  0.1608],

         [-0.8745, -1.0000, -0.8588,  ..., -0.0353, -0.0667, -0.0431],

         [-0.8039, -0.8745, -0.6157,  ..., -0.0745, -0.0588, -0.1451],

         ...,

         [ 0.6314,  0.5765,  0.5529,  ...,  0.2549, -0.5608, -0.5843],

         [ 0.4118,  0.3569,  0.4588,  ...,  0.4431, -0.2392, -0.3490],

         [ 0.3882,  0.3176,  0.4039,  ...,  0.6941,  0.1843, -0.0353]],



        [[-0.5137, -0.6392, -0.6235,  ...,  0.0353, -0.0196, -0.0275],

         [-0.8431, -1.0000, -0.9373,  ..., -0.3098, -0.3490, -0.3176],

         [-0.8118, -0.9451, -0.7882,  ..., -0.3412, -0.3412, -0.4275],

         ...,

         [ 0.3333,  0.2000,  0.2627,  ...,  0.0431, -0.7569, -0.7333],

         [ 0.0902, -0.0353,  0.1294,  ...,  0.1608, -0.5137, -0.5843],

         [ 0.1294,  0.0118,  0.1137,  ...,  0.4431, -0.0745, -0.2784]],



        [[-0.5059, -0.6471, -0.6627,  ..., -0.1529, -0.2000, -0.1922],

         [-0.8431, -1.0000, -1.0000,  ..., -0.5686, -0.6078, -0.5529],

         [-0.8353, -1.0000, -0.9373,  ..., -0.6078, -0.6078, -0.6706],

         ...,

         [-0.2471, -0.7333, -0.7961,  ..., -0.4510, -0.9451, -0.8431],

         [-0.2471, -0.6706, -0.7647,  ..., -0.2627, -0.7333, -0.7333],

         [-0.0902, -0.2627, -0.3176,  ...,  0.0980, -0.3412, -0.4353]]])

注意：通过使用Normalize类，可以对数据集进行标准化处理，以便更好地用于模型训练。注意，在应用标准化处理时，需要根据数据集的特点设置正确的均值和标准差。

在 TensorFlow 程序中，进行数据集标准化处理是为了将输入特征进行缩放，使其具有零均值和单位方差。这有助于加速模型训练，并且有时可以提高模型的收敛速度和性能。下面的实例演示了使用 TensorFlow 对数据集进行标准化处理的过程。

实例2-4：使用 TensorFlow对数据集进行标准化处理（源码路径：daima\2\tbiao.py）

实例文件tbiao.py的具体实现代码如下所示。

import tensorflow as tf
from sklearn.model_selection import train_test_split
import numpy as np
# 假设有一组原始数据 features 和 labels
features = np.random.rand(100, 2)  # 生成随机输入特征
labels = np.random.randint(0, 2, size=100)  # 随机生成标签

# 将原始数据划分为训练集和测试集
train_features, test_features, train_labels, test_labels = train_test_split(features, labels, test_size=0.2, random_state=42)

# 标准化处理：计算均值和标准差
mean = np.mean(train_features, axis=0)
std = np.std(train_features, axis=0)

# 标准化处理：应用均值和标准差进行缩放
train_features_normalized = (train_features - mean) / std
test_features_normalized = (test_features - mean) / std

# 将标准化后的数据转换为 TensorFlow 张量
train_features_tensor = tf.convert_to_tensor(train_features_normalized, dtype=tf.float32)
test_features_tensor = tf.convert_to_tensor(test_features_normalized, dtype=tf.float32)

# 创建 TensorFlow 数据集对象

train_dataset = tf.data.Dataset.from_tensor_slices((train_features_tensor, train_labels))
test_dataset = tf.data.Dataset.from_tensor_slices((test_features_tensor, test_labels))
# 对数据集进行处理、批次化等操作
batch_size = 32
train_dataset = train_dataset.shuffle(buffer_size=len(train_features)).batch(batch_size)
test_dataset = test_dataset.batch(batch_size)

在上述代码中，首先生成了示意的输入特征和标签数据。然后，计算训练集特征的均值和标准差，用于进行标准化处理。标准化处理通过减去均值并除以标准差来对特征进行缩放。最后，将标准化后的数据转换为 TensorFlow 张量，并创建了数据集对象。