深度学习入门到精通——数据集相关操作

小笨笨吃粑粑

于 2024-08-26 02:40:53 发布

阅读量41

点赞数

文章标签：深度学习人工智能

在PyTorch中，通常使用torchvision和torch.utils.data模块实现数据集的加载功能。在此模块中提供了用于加载和预处理常见数据集的工具，同时也支持自定义数据集的加载。

1. 数据集加载

在PyTorch程序中，模块torchvision.datasets提供了许多常见的预定义数据集，并提供了简单的API来加载这些数据集。以下是一些常用的数据集加载函数：

torchvision.datasets.ImageFolder：用于加载图像文件夹数据集，其中每个子文件夹表示一个类别，文件夹中的图像属于该类别。
torchvision.datasets.CIFAR10和torchvision.datasets.CIFAR100：用于加载CIFAR-10和CIFAR-100数据集，这是两个广泛使用的图像分类数据集。
torchvision.datasets.MNIST：用于加载MNIST手写数字数据集，其中包含了大量的手写数字图像及其对应的标签。
torchvision.datasets.ImageNet：用于加载ImageNet数据集，这是一个庞大的图像分类数据集，包含数百万个图像和数千个类别。
torchvision.datasets.VOCDetection：用于加载PASCAL VOC数据集，这是一个常用的目标检测数据集，包含了图像及其对应的物体边界框和类别标签。

上述数据集加载函数通常具有类似的参数，

如root（数据集的根目录）、train（是否加载训练集）、download（是否下载数据集）、transform（数据预处理操作）等。此

外，还可以使用torch.utils.data.DataLoader函数来创建一个数据加载器，用于批量加载数据。数据加载器可以方便地对数据进行批处理、洗牌、并行加载等操作，以提高数据加载的效率和灵活性。

PyTorch 提供了一些常用的数据集，封装在 torchvision.datasets 模块中，可以直接使用。以下是加载 CIFAR-10 数据集的示例：

import torchvision.transforms as transforms
from torchvision.datasets import CIFAR10
from torch.utils.data import DataLoader
# 定义数据预处理操作
transform = transforms.Compose([
    transforms.ToTensor(),   
 	transforms.Normalize(
	mean=[0.5, 0.5, 0.5],
 	std=[0.5, 0.5, 0.5]
	),
 
])
 
# 创建CIFAR-10数据集实例
 
train_dataset = CIFAR10(root='data/', train=True, download=True, transform=transform)
 
# 创建数据加载器
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
 
# 遍历数据加载器
for images, labels in train_loader:
    # 在此处进行模型训练或其他操作
    pass

在上述代码中，首先定义了一个transform变量，其中包含了一系列预处理操作。然后，使用CIFAR10函数创建一个CIFAR-10数据集实例，指定了数据集的根目录、训练集标志、下载标志和预处理操作。最后，使用DataLoader函数创建一个数据加载器，指定了数据集实例和批量大小等参数。通过这种方式，我们可以方便地加载数据集，并使用数据加载器进行高效的批处理数据加载。

2. 加载自定义数据集

对于自定义数据集，你可以继承 torch.utils.data.Dataset 并实现自己的数据加载逻辑。

自定义数据集：通过继承 torch.utils.data.Dataset 创建一个新的类，实现 __len__ 和 __getitem__ 方法，处理自己的数据。

下面是一个自定义图像数据集加载的示例：

import os
from PIL import Image
import torch
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms

# 自定义数据集类
class CustomImageDataset(Dataset):
    def __init__(self, img_dir, transform=None):
        self.img_dir = img_dir
        self.transform = transform
        self.img_labels = [(img, 0) for img in os.listdir(img_dir)]  # 假设标签全为0

    def __len__(self):
        return len(self.img_labels)

    def __getitem__(self, idx):
        img_name, label = self.img_labels[idx]
        img_path = os.path.join(self.img_dir, img_name)
        image = Image.open(img_path).convert("RGB")  # 加载图像并转换为RGB

        if self.transform:
            image = self.transform(image)

        return image, label

# 定义数据转换（预处理）
transform = transforms.Compose([
    transforms.Resize((32, 32)),  # 调整图像大小
    transforms.ToTensor(),        # 转换为 Tensor
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  # 归一化
])

# 加载自定义数据集
img_dir = './custom_data'
custom_dataset = CustomImageDataset(img_dir=img_dir, transform=transform)

# 创建数据加载器
custom_loader = DataLoader(custom_dataset, batch_size=64, shuffle=True)

# 打印部分数据集信息
for images, labels in custom_loader:
    print(f'Images batch shape: {images.size()}')
    print(f'Labels batch shape: {labels.size()}')
    break

2. TensorFlow加载数据集

从Tensorflow 2.0开始，提供了专门用于实现数据输入的接口tf.data.Dataset，能够以快速且可扩展的方式加载和预处理数据，帮助开发者高效的实现数据的读入、打乱（shuffle）、增强（augment）等功能。

例如在下面的实例文件中，演示了使用tf.data.Dataset加载MNIST 手写数字数据集的的过程。

import tensorflow as tf
 
# 加载 MNIST 数据集
(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.mnist.load_data()
 
# 将数据转换为张量并标准化
train_images = train_images.reshape(-1, 28, 28, 1).astype('float32') / 255.0
test_images = test_images.reshape(-1, 28, 28, 1).astype('float32') / 255.0
# 将标签转换为独热编码
train_labels = tf.keras.utils.to_categorical(train_labels, num_classes=10)
test_labels = tf.keras.utils.to_categorical(test_labels, num_classes=10)
# 创建训练集和测试集的 Dataset 对象
batch_size = 64
train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_labels))
test_dataset = tf.data.Dataset.from_tensor_slices((test_images, test_labels))
train_dataset = train_dataset.shuffle(buffer_size=60000).batch(batch_size).prefetch(buffer_size=tf.data.experimental.AUTOTUNE)
test_dataset = test_dataset.batch(batch_size)
# 打印数据集信息
print("训练集样本数:", len(train_images))
print("测试集样本数:", len(test_images))
print("图像形状:", train_images.shape[1:])
print("标签类别数:", train_labels.shape[1])

在 TensorFlow 中加载自定义数据集可以通过多种方式实现，最常用的是通过 tf.data.Dataset API 进行加载和预处理。下面是一个示例，展示了如何加载和预处理存储在本地文件系统中的图像数据集。

2.1 使用 `tf.data.Dataset` 加载图像数据集

import tensorflow as tf
import os

# 设置数据集路径
data_dir = './custom_data'

# 设置一些超参数
batch_size = 32
img_height = 180
img_width = 180

# 使用 tf.data.Dataset 从文件夹加载数据
train_ds = tf.keras.preprocessing.image_dataset_from_directory(
    data_dir,
    validation_split=0.2,
    subset="training",
    seed=123,
    image_size=(img_height, img_width),
    batch_size=batch_size)

val_ds = tf.keras.preprocessing.image_dataset_from_directory(
    data_dir,
    validation_split=0.2,
    subset="validation",
    seed=123,
    image_size=(img_height, img_width),
    batch_size=batch_size)

2.2 数据集增强和标准化

你可以在加载后对数据进行增强和标准化。以下是一些常用的数据增强技术：

AUTOTUNE = tf.data.AUTOTUNE

# 数据增强
data_augmentation = tf.keras.Sequential([
  tf.keras.layers.RandomFlip("horizontal"),
  tf.keras.layers.RandomRotation(0.1),
])

# 在数据集中应用数据增强
def augment(image, label):
    image = data_augmentation(image)
    return image, label

train_ds = train_ds.map(augment, num_parallel_calls=AUTOTUNE)

# 标准化数据
normalization_layer = tf.keras.layers.Rescaling(1./255)

def normalize(image, label):
    image = normalization_layer(image)
    return image, label

train_ds = train_ds.map(normalize, num_parallel_calls=AUTOTUNE)
val_ds = val_ds.map(normalize, num_parallel_calls=AUTOTUNE)

2.3 配置数据集以提高性能

可以配置数据集以提高模型的训练性能，例如使用预取和批处理：

train_ds = train_ds.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)
val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)

2.4 使用数据集进行模型训练

现在可以将数据集传递给模型进行训练：

model = tf.keras.Sequential([
  tf.keras.layers.Conv2D(32, 3, activation='relu', input_shape=(img_height, img_width, 3)),
  tf.keras.layers.MaxPooling2D(),
  tf.keras.layers.Conv2D(64, 3, activation='relu'),
  tf.keras.layers.MaxPooling2D(),
  tf.keras.layers.Conv2D(128, 3, activation='relu'),
  tf.keras.layers.MaxPooling2D(),
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dense(10)
])

model.compile(
  optimizer='adam',
  loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
  metrics=['accuracy'])

model.fit(
  train_ds,
  validation_data=val_ds,
  epochs=10
)

tf.data.Dataset API: 非常强大且灵活，可以用于处理各种数据格式，包括图像、文本、CSV 文件等。
数据增强: 可以通过 tf.keras.layers 来实现，以提高模型的泛化能力。
标准化: 对于图像数据，将像素值缩放到 [0, 1] 范围是常见的操作。
性能优化: 利用缓存、预取等技术可以加速数据加载过程，减少模型训练时的瓶颈。

如果需要进一步自定义数据集加载逻辑，tf.data.Dataset 还支持从生成器、列表等多种方式创建数据集，非常灵活。

2. 数据增强方式

1. Torchvision 数据增强简介

数据增强（Data Augmentation）是提升模型泛化能力的重要手段。PyTorch 中的 torchvision.transforms 模块提供了一系列常用的图像数据增强操作，能够方便地对数据集进行预处理和增强。

2. 常用数据增强方法及其参数详解

2.1 `ToTensor()`

作用: 将 PIL 图像或 NumPy 数组转换为 Tensor 格式，并将像素值缩放到 [0, 1] 之间，同时将图像通道从 HWC 格式转换为 CHW 格式。
参数: 无

2.2 `Normalize(mean, std)`

作用: 对 Tensor 格式的图像进行标准化处理。该函数将每个通道的像素值减去均值并除以标准差，使数据分布更加平滑，利于模型训练。
参数:

mean：序列或列表，指定每个通道的均值。例如 [0.485, 0.456, 0.406] 对应 RGB 三个通道。
std：序列或列表，指定每个通道的标准差。例如 [0.229, 0.224, 0.225]。

2.3 `Resize(size)`

作用: 调整图像的大小到指定尺寸。通常用于将输入图像缩放到模型所需的固定尺寸。
参数:

size：目标大小。可以是整数或二元元组 (h, w)。如果是整数，则将图像的短边缩放到该大小，长边按比例缩放。

transform = transforms.Resize(256)  # 将图像的短边调整为 256 像素，长边按比例缩放

2.4 `CenterCrop(size)`

作用: 对图像进行中心裁剪，保留指定尺寸的区域。这种方法常用于去除图像边缘可能的无关信息。
参数:

size：目标裁剪大小。可以是整数或二元元组 (h, w)。如果是整数，则裁剪为正方形。

2.5 `RandomCrop(size)`

作用: 对图像进行随机裁剪，保留指定尺寸的区域。用于生成多样性更强的训练样本。
参数:

size：目标裁剪大小。可以是整数或二元元组 (h, w)。

2.6 `RandomHorizontalFlip()`

作用: 随机水平翻转图像，增强模型对不同视角下物体的识别能力。
参数:

p：翻转的概率，默认值为 0.5。

2.7 `RandomRotation(degrees)`

作用: 随机旋转图像，可以指定旋转的角度范围。有效增加图像数据的多样性。
参数:

degrees：旋转角度的范围，可以是一个数字或二元元组 (min, max)，表示旋转角度范围。如果是一个数字，表示从 (-degrees, +degrees) 范围内随机选择。

transform = transforms.RandomRotation(degrees=30)  # 随机旋转图像，范围在 -30 到 +30 度之间

2.8 `RandomResizedCrop(size, scale, ratio)`

作用: 随机裁剪和缩放图像。可以指定裁剪的目标尺寸、缩放范围和长宽比范围，是一种更复杂的裁剪方式，常用于数据增强。
参数:

size：目标裁剪大小。可以是整数或二元元组 (h, w)。
scale：相对原始图像面积的缩放范围，二元元组 (min, max)。默认值为 (0.08, 1.0)。
ratio：裁剪区域的长宽比范围，二元元组 (min, max)。默认值为 (3/4, 4/3)。

transform = transforms.RandomResizedCrop(224, scale=(0.8, 1.0), ratio=(3/4, 4/3))  # 随机裁剪并缩放

3. 数据增强的组合使用

transforms.Compose() 可以将上述多种数据增强操作组合在一起，并按顺序依次应用于数据集。

3.1 示例组合

以下是一个示例，将多个数据增强操作组合在一起，应用于数据集：

from torchvision import transforms

transform = transforms.Compose([
    transforms.Resize(256),                # 调整图像大小
    transforms.RandomResizedCrop(224),     # 随机裁剪并调整大小
    transforms.RandomHorizontalFlip(),     # 随机水平翻转
    transforms.ToTensor(),                 # 转换为Tensor格式
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # 标准化
])

在这个组合中，图像首先被调整大小，然后随机裁剪到指定的尺寸，并进行水平翻转。随后，图像被转换为 Tensor 格式，最后进行标准化处理。

4. 数据增强的扩展使用

除了 torchvision.transforms 中预定义的增强方法，还可以自定义增强操作。以下是一个自定义数据增强的示例：

from torchvision import transforms
import torch

# 自定义数据增强操作：将图像颜色通道置换
class RandomChannelSwap:
    def __init__(self, p=0.5):
        self.p = p

    def __call__(self, img):
        if torch.rand(1).item() < self.p:
            img = img[[2, 1, 0], :, :]  # 交换 RGB 通道
        return img

transform = transforms.Compose([
    transforms.ToTensor(),
    RandomChannelSwap=0.3),
    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])

在这个例子中，自定义的 RandomChannelSwap 类被用来随机交换图像的颜色通道，从而增加训练数据的多样性。

PyTorch 的 torchvision.transforms 模块提供了丰富的数据增强方法，可以大大增强模型的泛化能力。通过合理组合这些操作，能有效地提升模型在不同数据集上的表现。同时，用户还可以根据需求自定义数据增强操作，以应对更加复杂的数据处理场景。

3. 数据清洗和处理

1. 数据清洗简介

数据清洗是数据预处理中至关重要的一步，确保数据的质量，帮助模型更好地学习。在实际数据集中，可能会遇到缺失值、错误值或异常值等问题。在 PyTorch 中，虽然 torch 本身没有专门的数据清洗模块，但可以结合 Python 的数据处理库（如 Pandas）和 torch 的 Tensor 操作来清洗和处理数据。

2. 数据清洗常见问题及解决方法

2.1 缺失值处理

缺失值是数据集中未被记录的值，可能导致模型的训练出现问题。常见的处理方法包括删除含缺失值的样本、用均值或中位数填充等。

方法 1: 删除含有缺失值的样本

实现: 可以使用 Pandas 删除含有缺失值的行或列。
参数说明:

axis：指定删除方向，0 表示删除行，1 表示删除列。默认为 0。
how：确定是否删除有 NaN 的行/列。'any' 表示只要有 NaN 就删除，'all' 表示全为 NaN 才删除。
thresh：保持的最少非空值的个数。如果一个行或列中的非空值少于这个数，则删除该行或列。
subset：要检查缺失值的行/列子集。
inplace：是否直接在原数据集上进行操作，True 表示是，False 表示创建新副本。默认值为 False。

示例:

import pandas as pd

# 假设数据是一个 Pandas DataFrame
df = pd.read_csv('data.csv')

# 删除含有任何缺失值的行
df_cleaned = df.dropna()

# 删除含有缺失值的列
df_cleaned_cols = df.dropna(axis=1)

方法 2: 用均值填充缺失值

实现: 对于数值类型的数据，可以使用均值、中位数等进行填充。
参数说明:

value：用于填充缺失值的值。可以是一个标量、字典、Series 或 DataFrame。
method：插值方法，'ffill' 表示前向填充，'bfill' 表示后向填充。
axis：指定填充方向，0 表示按列填充，1 表示按行填充。默认值为 0。
inplace：是否直接在原数据集上进行操作，True 表示是，False 表示创建新副本。默认值为 False。

示例:

# 用每列的均值填充缺失值
df_filled = df.fillna(df.mean())

# 用指定的值填充缺失值
df_filled_custom = df.fillna(value=0)

2.2 错误值处理

错误值通常是数据中的异常值或无效值，这些值可能是由于数据采集中的错误或输入错误造成的。

方法 1: 使用条件筛选

实现: 可以通过条件判断筛选出异常值，并将其替换为合理的值或删除。
参数说明:

condition：一个布尔条件，用于筛选数据。例如 df['age'] > 100。
None：可以用 None 来标记异常值，然后删除这些行。

示例:

# 假设 'age' 列中存在异常值，正常范围应该在 0 到 100 之间
df['age'] = df['age'].apply(lambda x: x if 0 <= x <= 100 else None)

# 删除含有 None 的行
df_cleaned = df.dropna(subset=['age'])

方法 2: 通过统计方法检测异常值

实现: 使用统计方法（如标准差）检测并处理异常值。
参数说明:

mean：指定要处理的列的均值。
std：指定要处理的列的标准差。
threshold：设置一个阈值，通常为 2 或 3 倍的标准差，用于判断数据是否为异常值。

示例:

# 使用标准差判断异常值
mean = df['age'].mean()
std = df['age'].std()

# 定义异常值为距离均值超过3个标准差的值
df['age'] = df['age'].apply(lambda x: x if (mean - 3*std <= x <= mean + 3*std) else None)

# 再次删除含有 None 的行
df_cleaned = df.dropna(subset=['age'])

2.3 数据类型转换

数据集中有时会出现数据类型不一致的问题（例如，数值类型的特征被存储为字符串），需要进行类型转换。

方法: 转换数据类型

实现: 使用 Pandas 提供的 astype() 方法将列转换为指定的类型。
参数说明:

dtype：目标数据类型，可以是 NumPy 类型或 Pandas 支持的类型，如 int, float, str 等。

示例:

# 将 'age' 列转换为整数类型
df['age'] = df['age'].astype(int)

# 将某一列转换为浮点数类型
df['salary'] = df['salary'].astype(float)

3. 使用 PyTorch 处理清洗后的数据

清洗后的数据可以通过 torch.Tensor 转换为 Tensor 格式，以便进行后续的模型训练。

3.1 将 Pandas DataFrame 转换为 Tensor

实现: 使用 torch.tensor() 函数将清洗后的数据转换为 Tensor 格式。
参数说明:

data：输入数据，通常是 NumPy 数组或列表。
dtype：指定 Tensor 的数据类型，如 torch.float32, torch.int64 等。
device：指定 Tensor 的设备位置，如 torch.device('cpu') 或 torch.device('cuda')。
requires_grad：布尔值，指定是否需要计算梯度。默认值为 False。

示例:

import torch

# 将 DataFrame 中的数据转换为 Tensor
data_tensor = torch.tensor(df_cleaned.values, dtype=torch.float32)

# 如果需要在 GPU 上处理数据，可以指定设备
data_tensor_gpu = torch.tensor(df_cleaned.values, dtype=torch.float32, device=torch.device('cuda'))

3.2 使用 Tensor 操作处理异常值

实现: 可以直接在 Tensor 上进行条件筛选或替换，以处理异常值。
参数说明:

input：输入的 Tensor。
condition：条件，torch.where() 函数根据这个条件来决定是选择 x 还是 y。
x：条件为 True 时选取的值。
y：条件为 False 时选取的值。

示例:

# 假设 data_tensor 是形状为 [n_samples, n_features] 的数据 Tensor
# 将 Tensor 中超过某个阈值的元素替换为指定值
threshold = 100
data_tensor = torch.where(data_tensor > threshold, torch.tensor(threshold, dtype=torch.float32), data_tensor)

数据清洗是保证数据质量的关键步骤。通过使用 Pandas 和 PyTorch，可以有效地处理缺失值、错误值和异常值问题，并将清洗后的数据转换为 Tensor 格式以用于模型训练。掌握这些技巧能够提升模型的准确性和鲁棒性，使其在实际应用中表现得更好。这部分内容涵盖了每个方法的参数细节，并提供了相应的示例，帮助理解这些操作在实际数据清洗过程中如何应用。

4. 数据预处理

4.1 数据标准化与归一化简介

数据标准化（Standardization）和归一化（Normalization）是数据预处理中常用的技术，主要用于将数据缩放到特定的范围或分布，从而提高模型的训练效果。标准化通常用于让数据符合标准正态分布，而归一化则是将数据缩放到指定的范围（如 [0, 1]）。

4.2 数据标准化

数据标准化是指将数据转换为均值为 0，标准差为 1 的分布。这有助于消除特征间的尺度差异，使模型能够更好地学习不同特征之间的关系。

4.2.1 标准化公式

标准化的公式如下：

深度学习入门到精通——数据集相关操作_深度学习

其中：

4.2.2 使用 `StandardScaler` 进行标准化

在 sklearn 中，StandardScaler 可以方便地进行数据标准化。

参数说明:

copy：布尔值，是否复制数据。默认值为 True。
with_mean：布尔值，是否将均值置为 0。默认值为 True。
with_std：布尔值，是否将数据缩放到单位标准差。默认值为 True。

示例:

from sklearn.preprocessing import StandardScaler
import pandas as pd

# 创建数据集
df = pd.DataFrame({
    'feature1': [1.0, 2.0, 3.0, 4.0, 5.0],
    'feature2': [10.0, 11.0, 12.0, 13.0, 14.0]
})

# 实例化 StandardScaler
scaler = StandardScaler()

# 对数据进行标准化
df_standardized = scaler.fit_transform(df)

print(df_standardized)

4.3 数据归一化

数据归一化是指将数据缩放到固定的范围内，通常是 [0, 1]。归一化可以避免某些特征因数值范围过大而主导模型学习过程。

4.3.1 归一化公式

最常见的归一化方法是最小-最大归一化，其公式如下：

深度学习入门到精通——数据集相关操作_深度学习_06

其中：

4.3.2 使用 `MinMaxScaler` 进行归一化

在 sklearn 中，MinMaxScaler 可以方便地将数据缩放到 [0, 1] 范围内。

参数说明:

feature_range：指定缩放的范围，默认为 (0, 1)。
copy：布尔值，是否复制数据。默认值为 True。

示例:

from sklearn.preprocessing import MinMaxScaler
import pandas as pd

# 创建数据集
df = pd.DataFrame({
    'feature1': [1.0, 2.0, 3.0, 4.0, 5.0],
    'feature2': [10.0, 11.0, 12.0, 13.0, 14.0]
})

# 实例化 MinMaxScaler
scaler = MinMaxScaler()

# 对数据进行归一化
df_normalized = scaler.fit_transform(df)

print(df_normalized)

4.4 在 PyTorch 中使用标准化与归一化

在 PyTorch 中，标准化与归一化通常在数据加载时进行，特别是处理图像数据时。这可以通过 torchvision.transforms.Normalize 来实现。

4.4.1 标准化图像数据

实现: 使用 Normalize 对图像数据进行标准化。
参数说明:

mean：序列或列表，指定每个通道的均值。例如 [0.485, 0.456, 0.406] 对应 RGB 三个通道。
std：序列或列表，指定每个通道的标准差。例如 [0.229, 0.224, 0.225]。

示例:

from torchvision import transforms

# 定义标准化过程
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

4.4.2 归一化张量数据

实现: 直接对张量进行操作，将数据缩放到 [0, 1]。
示例:

import torch

# 假设 data_tensor 是形状为 [n_samples, n_features] 的数据 Tensor
data_tensor = torch.rand(5, 3)  # 生成一个 5x3 的随机 Tensor

# 归一化到 [0, 1] 范围
data_tensor_min, _ = torch.min(data_tensor, dim=0, keepdim=True)
data_tensor_max, _ = torch.max(data_tensor, dim=0, keepdim=True)
data_tensor_normalized = (data_tensor - data_tensor_min) / (data_tensor_max - data_tensor_min)

print(data_tensor_normalized)

数据标准化和归一化是提升模型训练效果的重要步骤。标准化将数据转换为零均值单位方差的分布，而归一化则将数据缩放到固定的范围内。通过在 sklearn 和 torchvision 中的相应工具，可以方便地对数据进行这些操作，为后续模型训练做好准备。

原创作者: u_13859040 转载于: https://blog.51cto.com/u_13859040/11835850