PyTorch Dataset

Dans les tâches d'apprentissage profond, le chargement et le traitement des données constituent un élément crucial.

PyTorch fournit des outils puissants de chargement et de traitement des données, notamment :

torch.utils.data.Dataset: Une classe abstraite pour les jeux de données, qui doit être personnalisée et implémentée__len__(taille du jeu de données) et__getitem__(obtenir des échantillons par index).
torch.utils.data.TensorDataset: Un jeu de données basé sur des tenseurs, adapté au traitement de paires données-étiquettes, prend directement en charge le traitement par lots et l'itération.
torch.utils.data.DataLoader: Un itérateur qui encapsule Dataset, fournissant le traitement par lots, le mélange des données, le chargement multithread, etc., afin de faciliter l'entrée des données pour l'entraînement du modèle.
torchvision.datasets.ImageFolder: Charge des données d'images à partir de dossiers, chaque sous-dossier représente une classe, adapté aux tâches de classification d'images.

Jeux de données intégrés de PyTorch

PyTorch fournit de nombreux jeux de données couramment utilisés via le module torchvision.datasets, par exemple :

MNIST: Jeu de données d'images de chiffres manuscrits, utilisé pour les tâches de classification d'images.
CIFAR: Un jeu de données de 60,000 images couleur 32x32 en 10 classes, utilisé pour les tâches de classification d'images.
COCO: Un jeu de données à grande échelle pour la détection générale d'objets, la segmentation et la détection de points clés, contenant plus de 330k images et 2.5M instances d'objets.
ImageNet: Contient plus de 14 millions d'images, utilisé pour des tâches telles que la classification d'images et la détection d'objets.
STL-10: Un jeu de données contenant 100k images couleur 96x96, utilisé pour les tâches de classification d'images.
Cityscapes: Contient 5,000 images de scènes de rue urbaines finement annotées, utilisé pour les tâches de segmentation sémantique.
SQUAD: Un jeu de données utilisé pour les tâches de compréhension de lecture automatique.

Les jeux de données ci-dessus peuvent être chargés via les fonctions du module torchvision.datasets, et d'autres jeux de données peuvent également être chargés via des méthodes personnalisées.

torchvision et torchtext

torchvision: Une bibliothèque graphique qui fournit des API et des interfaces de jeux de données liées au traitement des données d'image, y compris des fonctions de chargement de jeux de données et des transformations d'images courantes.
torchtext: Une boîte à outils de traitement du langage naturel qui fournit des outils pour le traitement et la modélisation des données textuelles, y compris des méthodes de prétraitement et de chargement des données.

torch.utils.data.Dataset

Dataset est une classe de PyTorch utilisée pour l'abstraction des jeux de données.

Pour créer un jeu de données personnalisé, vous devez hériter de torch.utils.data.Dataset et redéfinir les deux méthodes suivantes :

__len__: Renvoie la taille du jeu de données.
__getitem__: Obtient un échantillon de données et son étiquette par index.

Exemple

import torch
from torch.utils.data import Dataset

# Jeu de données personnalisé
class MyDataset(Dataset):
def __init__(self, data, labels):
# Initialisation des données
self.data = data
self.labels = labels

def __len__(self):
# Renvoyer la taille du jeu de données
return len(self.data)

def __getitem__(self, idx):
# Renvoyer les données et l'étiquette par index
sample = self.data[idx]
label = self.labels[idx]
return sample, label

# Générer des données d'exemple
data = torch.randn(100, 5) # 100 échantillons, chacun avec 5 caractéristiques
labels = torch.randint(0, 2, (100,)) # 100 étiquettes, les valeurs sont 0 ou 1

# Instancier le jeu de données
dataset = MyDataset(data, labels)

# Jeu de données de test
print("Taille du jeu de données :", len(dataset))
print("Échantillon 0 :", dataset[0])

Le résultat de sortie est le suivant :

数据集大小: 100
第 0 个样本: (tensor([-0.2006,  0.7304, -1.3911, -0.4408,  1.1447]), tensor(0))

torch.utils.data.DataLoader

DataLoader est un chargeur de données fourni par PyTorch, utilisé pour charger des jeux de données par lots.

Il offre les fonctionnalités suivantes :

Chargement par lots: En définissantbatch_size。
Mélange des données: En définissantshuffle=True。
Accélération multithread: En définissantnum_workers。
Accès itératif: Accéder facilement aux données lot par lot.

Exemple

import torch
from torch.utils.data import Dataset
from torch.utils.data import DataLoader

# Jeu de données personnalisé
class MyDataset(Dataset):
def __init__(self, data, labels):
# Initialisation des données
self.data = data
self.labels = labels

def __len__(self):
# Renvoyer la taille du jeu de données
return len(self.data)

def __getitem__(self, idx):
# Renvoyer les données et l'étiquette par index
sample = self.data[idx]
label = self.labels[idx]
return sample, label

# Générer des données d'exemple
data = torch.randn(100, 5) # 100 échantillons, chacun avec 5 caractéristiques
labels = torch.randint(0, 2, (100,)) # 100 étiquettes, les valeurs sont 0 ou 1

# Instancier le jeu de données
dataset = MyDataset(data, labels)
# Instancier DataLoader
dataloader = DataLoader(dataset, batch_size=10, shuffle=True, num_workers=0)

# Itérer sur DataLoader
for batch_idx, (batch_data, batch_labels) in enumerate(dataloader):
print(f"Lot {batch_idx + 1}")
print("Données :", batch_data)
print("Étiquettes :", batch_labels)
if batch_idx == 2: # Afficher uniquement les 3 premiers lots
break

Le résultat de sortie est le suivant :

批次 1
数据: tensor([[ 0.4689,  0.6666, -1.0234,  0.8948,  0.4503],
        [ 0.0273, -0.4684, -0.7762,  0.7963,  0.2168],
        [ 1.0677, -0.3502, -0.9594, -1.1318, -0.2196],
        [-1.4989,  0.0267,  1.0405, -0.7284,  0.2335],
        [-0.5887, -0.4934,  1.6283,  1.4638,  0.0157],
        [-1.1047, -0.6550, -0.0381,  0.3617, -1.2792],
        [ 0.3592, -0.8264,  0.0231, -1.5508,  0.6833],
        [-0.6835,  0.6979,  0.9048, -0.4756,  0.3003],
        [ 1.1562, -0.4516, -1.2415,  0.2859,  0.5837],
        [ 0.7937,  1.5316, -0.6139,  0.7999,  0.5506]])
标签: tensor([0, 1, 1, 1, 1, 0, 1, 1, 0, 0])
批次 2
数据: tensor([[-0.0388, -0.3658,  0.8993, -1.5027,  1.0738],
        [-0.6182,  1.0684, -2.3049,  0.8338,  0.1363],
        [-0.5289,  0.1661, -0.0349,  0.2112,  1.4745],
        [-0.3304, -1.2114, -0.2982, -0.3006,  0.5252],
        [-1.4394, -0.3732,  1.0281,  0.5754,  1.0081],
        [ 0.8714, -0.1945, -0.2451, -0.2879, -2.0520],
        [ 0.0235,  0.4360,  0.1233,  0.0504,  0.5908],
        [ 0.5927,  0.1785, -0.9052, -0.9012,  0.8914],
        [ 0.4693,  0.5533, -0.1903,  0.0267,  0.4077],
        [-1.1683,  1.6699, -0.4846, -0.7404,  0.3370]])
标签: tensor([1, 1, 0, 1, 0, 1, 1, 0, 1, 1])
批次 3
数据: tensor([[ 0.2103, -0.7839,  1.4899,  2.2749, -0.7548],
        [-1.2836,  1.0025, -1.1162, -0.4261,  1.0690],
        [-0.7969,  1.0418, -0.7405,  0.8766,  0.2347],
        [-1.1071,  1.8560, -1.2979, -0.8364, -0.2925],
        [-1.0488,  0.4802, -0.6453,  0.2009,  0.5693],
        [ 0.8883,  0.4619, -0.2087,  0.2189, -0.3708],
        [-1.4578,  0.3629,  1.8282,  0.5353, -1.1783],
        [-1.2813,  0.5129, -0.4598, -0.2131, -1.2804],
        [ 1.7831,  1.1730, -0.2305, -0.6550,  0.1197],
        [-0.9384, -0.0483,  1.9626,  0.3342,  0.1700]])
标签: tensor([0, 0, 0, 1, 0, 1, 1, 1, 0, 1])

Utilisation des jeux de données intégrés

PyTorch fournit plusieurs jeux de données couramment utilisés dans torchvision, particulièrement adaptés aux tâches d'image.

Charger le jeu de données MNIST :

Exemple

import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader

# Définir le prétraitement des données
transform = transforms.Compose([
transforms.ToTensor(), # Convertir en tenseur
transforms.Normalize((0.5,), (0.5,)) # Standardiser
])

# Charger le jeu de données d'entraînement
train_dataset = torchvision.datasets.MNIST(
root='./data', train=True, transform=transform, download=True)

# Utiliser DataLoader pour charger les données
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

# Afficher un lot de données
data_iter = iter(train_loader)
images, labels = next(data_iter)
print(f"Taille des images du lot : {images.shape}") # La forme de sortie est [batch_size, 1, 28, 28]
print(f"Étiquettes du lot : {labels}")

Le résultat de sortie est:

批次图像大小: torch.Size([32, 1, 28, 28])
批次标签: tensor([0, 4, 9, 8, 1, 3, 8, 1, 7, 2, 1, 1, 1, 2, 6, 3, 9, 7, 6, 9, 4, 9, 7, 1,
        3, 7, 3, 0, 7, 7, 6, 7])

Application personnalisée de Dataset et DataLoader

Voici un exemple d'utilisation d'un fichier CSV comme source de données et de lecture des données via un Dataset et un DataLoader personnalisés.

Le contenu du fichier CSV est le suivant (téléchargerexample_pytorch_data.csv）：

Exemple

import torch
import pandas as pd
from torch.utils.data import Dataset, DataLoader

# Jeu de données CSV personnalisé
class CSVDataset(Dataset):
def __init__(self, file_path):
# Lire un fichier CSV
self.data = pd.read_csv(file_path)

def __len__(self):
# Renvoyer la taille du jeu de données
return len(self.data)

def __getitem__(self, idx):
# Utiliser .iloc pour utiliser explicitement l'indexation basée sur la position
row = self.data.iloc[idx]
# Séparer les caractéristiques et les étiquettes
features = torch.tensor(row.iloc[:-1].to_numpy(), dtype=torch.float32) # Caractéristiques
label = torch.tensor(row.iloc[-1], dtype=torch.float32) # Étiquettes
return features, label

# Instancier le jeu de données et le DataLoader
dataset = CSVDataset("example_pytorch_data.csv")
dataloader = DataLoader(dataset, batch_size=4, shuffle=True)

# Itérer sur DataLoader
for features, label in dataloader:
print("Caractéristiques :", features)
print("Étiquettes :", label)
break

Le résultat de sortie est:

特征: tensor([[ 1.2000,  2.1000, -3.0000],
        [ 1.0000,  1.1000, -2.0000],
        [ 0.5000, -1.2000,  3.3000],
        [-0.3000,  0.8000,  1.2000]])
标签: tensor([1., 0., 1., 0.])
tianqixin@Mac-mini example-test % python3 test.py
特征: tensor([[ 1.5000,  2.2000, -1.1000],
        [ 2.1000, -3.3000,  0.0000],
        [-2.3000,  0.4000,  0.7000],
        [-0.3000,  0.8000,  1.2000]])
标签: tensor([0., 1., 0., 0.])

Autres extensions