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

Dear 丶 2024-02-17 13:21 6阅读 0赞

### 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`，表示要对数据进行随机打乱。在遍历每个小批量数据时，可以在循环体内执行训练或评估操作。