PYTORCH数据预处理的方法

在 PyTorch 中，内置的数据预处理API相对比较少，而且多数时候，预处理工作主要就是把原始数据转成Torch自己的Tensor格式张量，常见的数据预处理操作可以通过 torchvision.transforms 模块来实现。

ToTensor ：将 PIL 图像或 NumPy 数组转换为 PyTorch 张量，并将像素值归一化到 [0, 1] 范围内。

from torchvision import transforms
import torch
from PIL import Image

# 读取图像
image = Image.open('image.jpg')

# 定义转换操作
transform = transforms.ToTensor()

# 应用转换
tensor_image = transform(image)

print(tensor_image.shape)  # 控制台输出: torch.Size([3, H, W]) ，其中 3 表示通道数（RGB），H 和 W 是图像的高度和宽度

Resize ：调整图像的大小。

from torchvision import transforms
import torch
from PIL import Image

# 读取图像
image = Image.open('image.jpg')

# 定义转换操作
transform = transforms.Resize((224, 224))

# 应用转换
resized_image = transform(image)

print(resized_image.size)  # 控制台输出: (224, 224)

Normalize ：对张量进行标准化，通常用于图像数据。

from torchvision import transforms
import torch

# 假设已经有一个张量 data
data = torch.randn(3, 224, 224)

# 定义标准化参数
mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]

# 定义转换操作
transform = transforms.Normalize(mean, std)

# 应用转换
normalized_data = transform(data)

print(normalized_data.mean(), normalized_data.std())  # 控制台输出: 接近 0 的均值和 1 的标准差

Compose ：组合多个转换操作。

from torchvision import transforms
import torch
from PIL import Image

# 读取图像
image = Image.open('image.jpg')

# 定义转换操作
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

# 应用转换
processed_image = transform(image)

print(processed_image.shape)  # 控制台输出: torch.Size([3, 224, 224])

在 PyTorch 中，我们可以手动实现数据标准化的功能。以下是一个示例代码：

import torch

def standardize_data(data):
    mean = torch.mean(data)
    std = torch.std(data)
    standardized_data = (data - mean) / std
    return standardized_data

# 示例数据
data = torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0])

standardized_data = standardize_data(data)
print(standardized_data)  # 控制台输出: 经过标准化处理后的数据张量

在 PyTorch 中，实现数据归一化可以通过以下方式：

import torch

def normalize_data(data, min_val=0.0, max_val=1.0):
    data_min = torch.min(data)
    data_max = torch.max(data)
    normalized_data = (data - data_min) / (data_max - data_min) * (max_val - min_val) + min_val
    return normalized_data

# 示例数据
data = torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0])

normalized_data = normalize_data(data)
print(normalized_data)  # 控制台输出: 经过归一化处理后的数据张量

在 PyTorch 中没有直接处理缺失值的内置函数。但通常可以通过以下方式来处理缺失值：

如果缺失值较少，可以使用插值的方法来填充，例如线性插值。

import torch

def fill_missing_values(data, method='linear'):
    # 检查是否有缺失值（这里假设 NaN 表示缺失值）
    mask = torch.isnan(data)
    if torch.any(mask):
        indices = torch.nonzero(mask)
        for index in indices:
            row, col = index
            # 根据指定方法进行插值填充
            if method == 'linear':
                if col > 0 and col < data.shape[1] - 1:
                    prev_val = data[row, col - 1]
                    next_val = data[row, col + 1]
                    data[row, col] = (prev_val + next_val) / 2
    return data

# 示例数据
data = torch.tensor([[1.0, 2.0, torch.nan], [4.0, torch.nan, 6.0], [7.0, 8.0, 9.0]])

filled_data = fill_missing_values(data)
print(filled_data)  # 控制台输出: 填充缺失值后的张量

如果缺失值较多或者数据特征复杂，可以考虑使用专门的数据处理库，如 scikit-learn 来处理缺失值，然后再转换为 PyTorch 张量。

在 PyTorch 中，对于分类变量的编码，可以手动实现类似 OneHotEncoder 的功能。

import torch

def one_hot_encoding(labels, num_classes):
    one_hot_labels = torch.zeros(len(labels), num_classes)
    for i, label in enumerate(labels):
        one_hot_labels[i, label] = 1
    return one_hot_labels

# 示例分类标签
labels = torch.tensor([0, 1, 2, 0, 1])
num_classes = 3

encoded_labels = one_hot_encoding(labels, num_classes)
print(encoded_labels)  # 控制台输出: 独热编码后的张量

在 PyTorch 中，通常可以结合 torch.utils.data 中的一些类来实现数据集的划分。

import torch
from torch.utils.data import TensorDataset, random_split

# 示例数据
data = torch.randn(100, 2)  # 假设 100 个样本，每个样本 2 个特征
labels = torch.randint(0, 2, (100,))  # 假设二分类标签

# 创建数据集
dataset = TensorDataset(data, labels)

# 划分比例
train_ratio = 0.8
val_ratio = 0.1
test_ratio = 0.1

# 计算划分的长度
train_length = int(train_ratio * len(dataset))
val_length = int(val_ratio * len(dataset))
test_length = len(dataset) - train_length - val_length

# 随机划分数据集
train_dataset, val_dataset, test_dataset = random_split(dataset, [train_length, val_length, test_length])

print("训练集长度:", len(train_dataset))
print("验证集长度:", len(val_dataset))
print("测试集长度:", len(test_dataset))