如何将x和y利用torch转换成小批量数据，打乱数据、标准化或者归一化？

高山莫衣

于 2023-12-02 11:46:16 发布

阅读量972

点赞数 20

分类专栏： pytorch 文章标签：深度学习 pytorch 人工智能神经网络 python

原创作品，共同进步！

本文链接：https://blog.csdn.net/AdamCY888/article/details/134749862

版权

pytorch 专栏收录该内容

66 篇文章 3 订阅

订阅专栏

文章介绍了如何使用PyTorch的DataLoader和相关库如TensorDataset、sklearn对数据进行小批量划分、打乱顺序以及标准化处理。方法涉及使用DataLoader的shuffle选项，以及sklearn的StandardScaler和torchvision.transforms.Normalize进行数据预处理。

摘要由CSDN通过智能技术生成

1、如何将x和y利用torch转换成小批量数据，打乱数据、标准化或者归一化？

方法1

将数据转换为小批量数据可以使用PyTorch中的DataLoader类，该类可以自动将数据按照批次划分，并且支持对数据进行随机打乱。下面是一个示例：

from torch.utils.data import TensorDataset, DataLoader
from sklearn.preprocessing import StandardScaler
# 假设x_data和y_data是输入数据和标签数据
batch_size = 32
dataset = TensorDataset(x_data, y_data)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
# 数据标准化
scaler = StandardScaler()
x_data = scaler.fit_transform(x_data)

以上代码中，我们先通过TensorDataset类将输入数据和标签数据转换为PyTorch中的数据集对象，然后使用DataLoader类将数据集对象按照batch_size划分成小批量数据，并且设置shuffle参数为True来打乱数据顺序。

另外，如果需要对数据进行标准化或归一化，可以使用sklearn库中的StandardScaler或MinMaxScaler类，对输入数据进行相应的缩放处理。在上述代码中，我们使用了StandardScaler对输入数据进行标准化处理，即将数据按各自特征的均值中心化，再除以各自特征的标准差进行缩放。

方法2：使用pytorch相关库进行标准化,不要使用sklearn库进行标准化

PyTorch中提供了torchvision.transforms模块，其中包含了对数据进行预处理的函数。我们可以使用torchvision.transforms.Normalize函数对输入数据进行标准化。

下面是一个示例：

import torch
from torchvision import transforms
# 假设x_data是输入数据
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((x_data.mean(),), (x_data.std(),))
])
x_data_normalized = transform(x_data)

以上代码中，我们首先将输入数据转换为张量格式，然后使用transforms.Normalize对数据进行标准化处理，其中mean和std参数分别表示每个通道的均值和标准差，这里我们使用x_data的整体均值和标准差来进行标准化。

需要注意的是，这种标准化方法仅适用于单通道输入数据，如果输入数据是多通道（如RGB图像），则需要按通道计算均值和标准差，并将其传递给transforms.Normalize函数。

方法3：如何将x_data和y_data利用torch转换成小批量数据并要求对x_data, y_data 标准化？

可以通过PyTorch中的DataLoader和TensorDataset类将x_data和y_data转换为小批量数据，并在加载数据时进行标准化处理。具体实现如下：

import torch
from torch.utils.data import TensorDataset, DataLoader
# 假设x_data和y_data是输入数据和标签数据
batch_size = 32
# 将输入数据和标签数据合并为一个数据集对象
dataset = TensorDataset(torch.Tensor(x_data), torch.Tensor(y_data))
# 定义dataloader，设置batch_size和shuffle参数
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
# 计算均值和标准差
x_mean = x_data.mean()
x_std = x_data.std()
# 对x_data进行标准化
x_data_normalized = (x_data - x_mean) / x_std
# 将标准化后的x_data和y_data转换为torch张量
x_tensor = torch.Tensor(x_data_normalized)
y_tensor = torch.Tensor(y_data)
# 将x_tensor和y_tensor合并为一个数据集对象
dataset = TensorDataset(x_tensor, y_tensor)
# 重新定义dataloader，设置batch_size和shuffle参数
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

以上代码中，我们首先将输入数据和标签数据合并为一个TensorDataset对象，然后使用DataLoader类将数据集对象划分为小批量数据，并设置shuffle参数为True来打乱数据。

接着，我们计算输入数据x_data的均值和标准差，并对其进行标准化处理。最后，将标准化后的输入数据和标签数据转换为张量格式，并重新定义数据集对象和dataloader对象，以进行后续操作。

方法4：上述回答结合transforms.Compose和torchvision.transforms.Normalize 对x_data 和 y_data 进行归一化

可以使用transforms.Compose和torchvision.transforms.Normalize函数对x_data和y_data进行归一化处理，并在创建dataloader时将数据集对象转换为TensorDataset类型。具体

实现如下：

import torch
from torch.utils.data import TensorDataset, DataLoader
from torchvision import transforms
# 假设x_data和y_data是输入数据和标签数据
batch_size = 32
# 定义预处理操作，包括转换为张量和归一化操作
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((x_data.mean(),), (x_data.std(),)),
    transforms.Normalize((y_data.mean(),), (y_data.std(),))
])
# 对x_data和y_data进行预处理
x_data_normalized = transform(x_data)
y_data_normalized = transform(y_data)
# 将标准化后的x_data和y_data转换为torch张量
x_tensor = torch.Tensor(x_data_normalized)
y_tensor = torch.Tensor(y_data_normalized)
# 将x_tensor和y_tensor合并为一个数据集对象
dataset = TensorDataset(x_tensor, y_tensor)
# 定义dataloader，设置batch_size和shuffle参数
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

以上代码中，我们首先定义了一个预处理操作transform，其中包括ToTensor和Normalize等操作。然后使用transform对x_data和y_data进行标准化处理。

接着，将标准化后的x_data和y_data转换为张量格式，并将它们合并为一个TensorDataset对象。最后，定义dataloader对象，设置batch_size和shuffle参数，并使用上述数据集对象作为输入数据。

方法5：倘若只对x_data进行标准化，不需要对y_data标准化怎么输出？

如果只需要对x_data进行标准化而不需要对y_data进行标准化，可以将transforms.Normalize的第二个参数设为空元组。具体实现如下：

import torch
from torch.utils.data import TensorDataset, DataLoader
from torchvision import transforms
# 假设x_data和y_data是输入数据和标签数据
batch_size = 32
# 定义预处理操作，包括转换为张量和归一化操作
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((x_data.mean(),), (x_data.std(),))  # 只对x_data进行标准化
])
# 对x_data进行预处理
x_data_normalized = transform(x_data)
# 将标准化后的x_data和原始的y_data转换为torch张量
x_tensor = torch.Tensor(x_data_normalized)
y_tensor = torch.Tensor(y_data)
# 将x_tensor和y_tensor合并为一个数据集对象
dataset = TensorDataset(x_tensor, y_tensor)
# 定义dataloader，设置batch_size和shuffle参数
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

以上代码中，在定义预处理操作transform时，只在Normalize函数的第一个参数中传入x_data的均值和标准差，而在第二个参数中传入空元组，表示不对y_data进行标准化。

接着，将标准化后的x_data和原始的y_data转换为张量格式，并将它们合并为一个TensorDataset对象。最后，定义dataloader对象，设置batch_size和shuffle参数，并使用上述数据集对象作为输入数据。

2、如何将x_data和y_data利用torch转换成小批量数据，并要求打乱数据，如何处理？

为了将x_data和y_data转换成小批量数据并打乱数据，可以使用PyTorch中的DataLoader和random库。下面是一个示例代码：

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

x_data = torch.randn(10, 3)
y_data = torch.randn(10, 1)

for i, j in zip(x_data ,y_data):
    print(i, j)

输出

tensor([-1.3064, -1.1474, -0.4826]) tensor([-2.0181])
tensor([-0.7043,  0.4129, -0.7812]) tensor([0.2593])
tensor([ 0.8225,  0.4909, -0.9564]) tensor([0.1052])
tensor([ 0.8489,  0.7734, -0.5316]) tensor([-0.1681])
tensor([ 2.6069,  0.3360, -1.2510]) tensor([-1.5229])
tensor([-0.2588,  0.1903, -1.1847]) tensor([-0.1975])
tensor([-2.6685,  2.1388, -0.7719]) tensor([0.8189])
tensor([-0.4615, -1.3020,  0.9347]) tensor([0.1780])
tensor([-0.6927, -0.1758,  0.0818]) tensor([-0.4284])
tensor([-0.7713,  0.0360,  0.3797]) tensor([-0.4796])

# import random

# 创建TensorDataset对象
dataset = TensorDataset(x_data, y_data)

# 创建DataLoader对象，并指定batch_size和是否要进行打乱
dataloader = DataLoader(dataset, batch_size=2, shuffle=True)

# 遍历每个小批量数据
for batch_x, batch_y in dataloader:
    # 在这里执行训练或评估操作
    print(batch_x, batch_y)

输出

tensor([[ 0.8225,  0.4909, -0.9564],
        [-0.7043,  0.4129, -0.7812]]) tensor([[0.1052],
        [0.2593]])
tensor([[-0.7713,  0.0360,  0.3797],
        [-2.6685,  2.1388, -0.7719]]) tensor([[-0.4796],
        [ 0.8189]])
tensor([[-0.2588,  0.1903, -1.1847],
        [ 0.8489,  0.7734, -0.5316]]) tensor([[-0.1975],
        [-0.1681]])
tensor([[-0.4615, -1.3020,  0.9347],
        [-0.6927, -0.1758,  0.0818]]) tensor([[ 0.1780],
        [-0.4284]])
tensor([[ 2.6069,  0.3360, -1.2510],
        [-1.3064, -1.1474, -0.4826]]) tensor([[-1.5229],
        [-2.0181]])

使用TensorDataset将x_data和y_data合并到一个数据集中。然后，使用DataLoader创建一个迭代器，以便逐个处理每个小批量数据。在这里，batch_size设置为2，这意味着每个小批量将包含2个样本。shuffle参数设置为True，表示要对数据进行随机打乱。在遍历每个小批量数据时，可以在循环体内执行训练或评估操作。