Recherche de site Web

Un guide complet de la classe DataLoader et des abstractions dans PyTorch

Dans cet article, nous aborderons l’un des problèmes les plus difficiles dans les domaines du Machine Learning et du Deep Learning : la difficulté de charger et de gérer différents types de données.

Supposons que vous soyez déjà familier avec le codage des réseaux de neurones dans PyTorch et que vous travailliez maintenant à prédire un nombre à l'aide de l'ensemble de données MNIST avec un perceptron multicouche. Dans ce cas, vous avez probablement utilisé la classe torch DataLoader pour charger et convertir directement les images en tenseurs. Mais maintenant, dans cet article, nous allons apprendre comment aller au-delà de la classe DataLoader et suivre les meilleures pratiques qui peuvent être utilisées lors du traitement de diverses formes de données, telles que des fichiers CSV, des images, du texte. , etc. Vous trouverez ci-dessous les sujets que nous aborderons.

  • Travailler sur des ensembles de données
  • Chargement de données dans PyTorch
  • Examen approfondi de l'ensemble de données MNIST
  • Transformations et redimensionnement des données
  • Création d'ensembles de données personnalisés dans PyTorch
  • Résumé

Conditions préalables

Pour suivre ce tutoriel, vous aurez besoin d'un GPU NVIDIA suffisamment puissant avec au moins 8 Go de VRAM. Une compréhension de base des classes et des objets Python sera également cruciale pour comprendre l’intégralité de la discussion.

Travailler sur des ensembles de données

Si vous travaillez sur un projet en temps réel impliquant le Deep Learning, il est courant que la majeure partie de votre temps soit consacrée à la gestion des données plutôt qu'au réseau neuronal que vous construirez. En effet, les données sont comme du carburant pour votre réseau : plus elles sont appropriées, plus les résultats sont rapides et précis ! L'une des principales raisons pour lesquelles votre réseau neuronal est sous-performant peut être due à des données mauvaises ou mal comprises. Il est donc important de comprendre, prétraiter et charger vos données sur le réseau de manière plus intuitive.

Dans de nombreux cas, nous formons des réseaux de neurones sur des ensembles de données par défaut ou bien connus comme le MNIST ou le CIFAR. En travaillant dessus, nous pouvons facilement atteindre une précision supérieure à 90 % pour les problèmes de type prédiction et classification. La raison en est que ces ensembles de données sont soigneusement organisés et faciles à prétraiter. Mais lorsque vous travaillez sur votre propre ensemble de données, il est assez délicat et difficile d’obtenir une grande précision. Nous apprendrons à travailler sur des ensembles de données personnalisés dans les sections suivantes. Avant cela, nous examinerons rapidement les ensembles de données inclus dans la bibliothèque PyTorch.

PyTorch est livré avec plusieurs ensembles de données intégrés, tous préchargés dans la classe torch.datasets. Est-ce que ça vous dit quelque chose ? Dans l'exemple précédent, lorsque nous classions les images MNIST, nous avons utilisé la même classe pour télécharger nos images. Que contiennent les packages torch et torchvision ? Le package torch comprend toutes les classes et méthodes de base requises pour implémenter des réseaux de neurones, tandis que torchvision est un package de support composé d'ensembles de données populaires, d'architectures de modèles et de transformations d'images courantes pour vision par ordinateur. Il existe un autre package nommé torchtext qui contient tous les utilitaires de base du traitement du langage naturel PyTorch. Ce package comprend des ensembles de données liés au texte.

Voici un aperçu rapide des ensembles de données inclus dans les classes torchvision et torchtext.

Ensembles de données dans Torchvision

MNIST : MNIST est un ensemble de données composé d'images manuscrites normalisées et recadrées au centre. Il contient plus de 60 000 images de formation et 10 000 images de test. Il s’agit de l’un des ensembles de données les plus utilisés à des fins d’apprentissage et d’expérimentation. Pour charger et utiliser l'ensemble de données, vous pouvez l'importer en utilisant la syntaxe ci-dessous après l'installation du package torchvision.

  • torchvision.datasets.MNIST()

Mode MNIST : cet ensemble de données est similaire au MNIST, mais au lieu de chiffres manuscrits, cet ensemble de données comprend des vêtements tels que des T-shirts, des pantalons, des sacs, etc. Le nombre d'échantillons de formation et de test est de 60 000 et 10 000. respectivement. Vous trouverez ci-dessous l'emplacement de la classe FMNIST.

  • torchvision.datasets.FashionMNIST()

CIFAR : L'ensemble de données CIFAR comporte deux versions, CIFAR10 et CIFAR100. CIFAR10 se compose d'images de 10 étiquettes différentes, tandis que CIFAR100 comporte 100 classes différentes. Il s'agit notamment d'images courantes telles que des camions, des grenouilles, des bateaux, des voitures, des cerfs et autres. Cet ensemble de données est recommandé pour créer des CNN.

  • torchvision.datasets.CIFAR10()
  • torchvision.datasets.CIFAR100()

COCO : cet ensemble de données comprend plus de 100 000 objets du quotidien, tels que des personnes, des bouteilles, des articles de papeterie, des livres, etc. Cet ensemble de données d'images est largement utilisé pour les applications de détection d'objets et de sous-titrage d'images. Vous trouverez ci-dessous l'emplacement à partir duquel COCO peut être chargé :

  • torchvision.datasets.CocoCaptions()

EMNIST : cet ensemble de données est une version avancée de l'ensemble de données MNIST. Il se compose d’images comprenant à la fois des chiffres et des alphabets. Si vous travaillez sur un problème basé sur la reconnaissance de texte à partir d'images, c'est le bon ensemble de données avec lequel vous entraîner. Ci-dessous la classe :

  • torchvision.datasets.EMNIST()

IMAGE-NET : ImageNet est l'un des ensembles de données phares utilisés pour former des réseaux de neurones haut de gamme. Il se compose de plus de 1,2 million d’images réparties dans 10 000 classes. Habituellement, cet ensemble de données est chargé sur un système matériel haut de gamme, car un processeur seul ne peut pas gérer des ensembles de données de cette taille. Vous trouverez ci-dessous la classe pour charger l'ensemble de données ImageNet :

  • torchvision.datasets.ImageNet()

Voici quelques ensembles de données les plus fréquemment utilisés lors de la création de réseaux de neurones dans PyTorch. Quelques autres incluent KMNIST, QMNIST, LSUN, STL10, SVHN, PhotoTour, SBU, Cityscapes, SBD, USPS, Kinetics-400. Vous pouvez en savoir plus à ce sujet dans la documentation officielle de PyTorch.

Ensembles de données dans Torchtext

Comme indiqué précédemment, torchtext est un package de support qui comprend tous les utilitaires de base pour le traitement du langage naturel. Si vous débutez en PNL, il s'agit d'un sous-domaine de l'intelligence artificielle qui traite et analyse de grandes quantités de données en langage naturel (principalement liées au texte).

Jetons maintenant un coup d'œil à quelques ensembles de données textuelles populaires avec lesquels expérimenter et travailler.

IMDB : il s'agit d'un ensemble de données pour la classification des sentiments qui contient un ensemble de 25 000 critiques de films très polaires pour la formation et 25 000 autres pour les tests. Nous pouvons charger ces données en utilisant la classe suivante depuis torchtext :

  • torchtext.datasets.IMDB()

WikiText2 : cet ensemble de données de modélisation du langage est une collection de plus de 100 millions de jetons. Il est extrait de Wikipédia et conserve la ponctuation et la casse réelle des lettres. Il est largement utilisé dans les applications impliquant des dépendances à long terme. Ces données peuvent être chargées depuis torchtext comme suit :

  • torchtext.datasets.WikiText2()

Outre les deux ensembles de données populaires ci-dessus, il en existe encore de nombreux autres disponibles dans la bibliothèque torchtext, tels que SST, TREC, SNLI, MultiNLI, WikiText-2, WikiText103, PennTreebank, Multi30k, etc.

Jusqu’à présent, nous avons vu des ensembles de données basés sur un ensemble prédéfini d’images et de texte. Mais et si vous aviez le vôtre ? Comment le chargez-vous ? Pour l'instant, apprenons la classe ImageFolder, que vous pouvez utiliser pour charger vos propres ensembles de données d'images.

Classe ImageFolder

ImageFolder est une classe de chargeur de données générique dans torchvision qui vous aide à charger votre propre ensemble de données d'image. Imaginons que vous travailliez sur un problème de classification et que vous construisiez un réseau de neurones pour identifier si une image donnée est une pomme ou une orange. Pour ce faire dans PyTorch, la première étape consiste à organiser les images dans une structure de dossiers par défaut comme indiqué ci-dessous :

 root
├── orange
│   ├── orange_image1.png
│   └── orange_image1.png
├── apple
│   └── apple_image1.png
│   └── apple_image2.png
│   └── apple_image3.png

Après avoir organisé votre ensemble de données comme indiqué, vous pouvez utiliser la classe ImageLoader pour charger toutes ces images. Vous trouverez ci-dessous l'extrait de code que vous utiliseriez pour ce faire :

torchvision.datasets.ImageFolder(root, transform)

Dans la section suivante, voyons comment charger des données dans nos programmes.

Chargement de données dans PyTorch

Le chargement des données est l'une des premières étapes de la création d'un pipeline Deep Learning ou de la formation d'un modèle. Cette tâche devient plus difficile lorsque la complexité des données augmente. Dans cette section, nous découvrirons la classe DataLoader dans PyTorch qui nous aide à charger et parcourir les éléments d'un ensemble de données. Cette classe est disponible en tant que DataLoader dans le module torch.utils.data. DataLoader peut être importé comme suit :

from torch.utils.data import DataLoader

Discutons maintenant en détail des paramètres acceptés par la classe DataLoader, indiqués ci-dessous.

from torch.utils.data import DataLoader

DataLoader(
    dataset,
    batch_size=1,
    shuffle=False,
    num_workers=0,
    collate_fn=None,
    pin_memory=False,
 )

1. Dataset : Le premier paramètre de la classe DataLoader est le dataset. C'est de là que nous chargeons les données.

2. Regrouper les données : batch_size fait référence au nombre d'échantillons d'entraînement utilisés dans une itération. Habituellement, nous divisons nos données en ensembles de formation et de test, et nous pouvons avoir des tailles de lots différentes pour chacun.

3. Mélanger les données : shuffle est un autre argument passé à la classe DataLoader. L'argument prend une valeur booléenne (Vrai/Faux). Si shuffle est défini sur True, alors tous les échantillons sont mélangés et chargés par lots. Sinon, ils sont envoyés un par un sans aucun mélange.

4. Autoriser le multi-traitement : étant donné que l'apprentissage profond implique la formation de modèles avec beaucoup de données, l'exécution d'un seul processus finit par prendre beaucoup de temps. Dans PyTorch, vous pouvez augmenter le nombre de processus exécutés simultanément en autorisant le multitraitement avec l'argument num_workers. Cela dépend également de la taille du lot, mais je ne définirais pas num_workers sur le même nombre car chaque travailleur charge un seul lot et ne le renvoie qu'une fois qu'il est prêt.

  • num_workers=0 signifie que c'est le processus principal qui effectue le chargement des données en cas de besoin.
  • num_workers=1 signifie que vous n'avez qu'un seul travailleur, cela peut donc être lent.

5. Fusion d'ensembles de données : L'argument collate_fn est utilisé si nous souhaitons fusionner des ensembles de données. Cet argument est facultatif et est principalement utilisé lorsque des lots sont chargés à partir d'ensembles de données de style carte.

6. Chargement de données sur des tenseurs CUDA : Vous pouvez directement charger des ensembles de données en tant que tenseurs CUDA en utilisant l'argument pin_memory. Il s'agit d'un paramètre facultatif qui prend une valeur booléenne ; si elle est définie sur True, la classe DataLoader copie les Tensors dans la mémoire épinglée par CUDA avant de les renvoyer.

Jetons un coup d'œil à un exemple pour mieux comprendre le pipeline habituel de chargement de données.

Examen approfondi de l'ensemble de données MNIST

Le référentiel torchvision de PyTorch héberge une poignée d'ensembles de données standards, MNIST étant l'un des plus populaires. Nous allons maintenant voir comment PyTorch charge l'ensemble de données MNIST à partir du référentiel pytorch/vision. Téléchargeons d'abord l'ensemble de données et chargeons-le dans une variable nommée data_train. Ensuite, nous imprimerons un exemple d’image.

# Import MNIST
from torchvision.datasets import MNIST
Download and Save MNIST 
data_train = MNIST('~/mnist_data', train=True, download=True)
Print Data
print(data_train)
print(data_train[12])

Résultat :

Dataset MNIST Number of datapoints: 60000 Root location: /Users/viharkurama/mnist_data Split: Train (<PIL.Image.Image image mode=L size=28x28 at 0x11164A100>, 3)

Essayons maintenant d'extraire le tuple dans lequel la première valeur correspondrait à l'image et la deuxième valeur correspondrait à son étiquette respective. Ci-dessous l'extrait de code :

import matplotlib.pyplot as plt

random_image = data_train[0][0]
random_image_label = data_train[0][1]
Print the Image using Matplotlib
plt.imshow(random_image)
print("The label of the image is:", random_image_label)

La plupart du temps, vous n'accéderez pas à des images avec des indices, mais vous enverrez plutôt des matrices contenant les images à votre modèle. Cela s'avère pratique lorsque vous devez préparer des lots de données (et peut-être les mélanger avant chaque exécution). Voyons maintenant comment cela fonctionne en temps réel. Utilisons la classe DataLoader pour charger l'ensemble de données, comme indiqué ci-dessous.

import torch
from torchvision import transforms

data_train = torch.utils.data.DataLoader(
    MNIST(
          '~/mnist_data', train=True, download=True, 
          transform = transforms.Compose([
              transforms.ToTensor()
          ])),
          batch_size=64,
          shuffle=True
          )

for batch_idx, samples in enumerate(data_train):
      print(batch_idx, samples)

C'est ainsi que nous chargeons un ensemble de données simple à l'aide de DataLoader. Cependant, nous ne pouvons pas toujours compter sur DataLoader pour chaque ensemble de données. Nous avons souvent affaire à des ensembles de données volumineux ou irréguliers contenant des images de résolutions asymétriques, et c'est là que les GPU jouent un rôle important.

Chargement des données sur les GPU

Nous pouvons activer les GPU pour une formation plus rapide de nos modèles. Regardons maintenant la configuration de CUDA (support GPU pour PyTorch) qui peut être utilisée lors du chargement des données. Voici un exemple d'extrait de code :

device = "cuda" if torch.cuda.is_available() else "cpu"
kwargs = {'num_workers': 1, 'pin_memory': True} if device=='cuda' else {}

train_loader = torch.utils.data.DataLoader(
  torchvision.datasets.MNIST('/files/', train=True, download=True),
  batch_size=batch_size_train, **kwargs)

test_loader = torch.utils.data.DataLoader(
  torchvision.datasets.MNIST('files/', train=False, download=True),
  batch_size=batch_size, **kwargs)

Dans ce qui précède, nous avons déclaré une nouvelle variable nommée device. Ensuite, nous écrivons une simple condition if qui vérifie la configuration matérielle actuelle. S'il prend en charge GPU, il définira le périphérique sur cuda, sinon il le définira sur cpu. La variable num_workers désigne le nombre de processus qui génèrent des lots en parallèle. Pour le chargement des données, passer pin_memory=True à la classe DataLoader placera automatiquement les tenseurs de données récupérés dans la mémoire épinglée, et permettra ainsi un transfert de données plus rapide vers les GPU compatibles CUDA.

Dans la section suivante, nous découvrirons les transformations, qui définissent les étapes de prétraitement pour le chargement des données.

Transformations et redimensionnement des données

Les transformations PyTorch définissent des techniques simples de transformation d'image qui convertissent l'ensemble des données dans un format unique. Par exemple, considérons un ensemble de données contenant des images de différentes voitures dans différentes résolutions. Pendant l'entraînement, toutes les images de notre ensemble de données de train doivent avoir la même taille de résolution. Cela prend du temps si nous convertissons manuellement toutes les images dans la taille d'entrée requise, nous pouvons donc utiliser des transformations à la place ; avec quelques lignes de code PyTorch, toutes les images de notre ensemble de données peuvent être converties à la taille d'entrée et à la résolution souhaitées. Vous pouvez également les redimensionner à l'aide du module transforms. Les quelques opérations les plus couramment utilisées sont transforms.Resize() pour redimensionner les images, transforms.CenterCrop() pour recadrer les images à partir du centre et transforms.RandomResizedCrop() pour redimensionner aléatoirement toutes les images de l'ensemble de données.

Chargeons maintenant CIFAR10 depuis torchvision.datasets et appliquons les transformations suivantes :

  1. Redimensionner toutes les images en 32×32
  2. Application d'une transformation de recadrage central aux images
  3. Conversion des images recadrées en tenseurs
  4. Normaliser les images

Nous importons d'abord les modules nécessaires, ainsi que les transforms du module torchvision. Les bibliothèques NumPy et Matplotlib sont utilisées pour visualiser l'ensemble de données.

import torch
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

Ensuite, nous définirons une variable nommée transforms, dans laquelle nous écrivons toutes les étapes de prétraitement de manière séquentielle. Nous avons utilisé la classe Compose pour enchaîner toutes les opérations de transformation.

transform = transforms.Compose([
    # resize
    transforms.Resize(32),
    # center-crop
    transforms.CenterCrop(32),
    # to-tensor
    transforms.ToTensor(),
    # normalize
    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])
  • resize : Cette transformation Resize convertit toutes les images à la taille définie. Dans ce cas, nous souhaitons redimensionner toutes les images à 32×32. Par conséquent, nous passons 32 comme argument.
  • center-crop : Ensuite, nous recadrons les images en utilisant la transformation CenterCrop. L'argument que nous envoyons est également la résolution/taille, mais comme nous avons déjà redimensionné l'image à 32x32, les images seraient alignées au centre avec ce recadrage. Cela signifie que les images seraient recadrées de 32 unités à partir du centre (à la fois verticalement et horizontalement).
  • to-tensor : Nous avons utilisé la méthode ToTensor() pour convertir les images au type de données Tensor.
  • normalize : ceci normalise toutes les valeurs du tenseur afin qu'elles se situent entre 0,5 et 1.

Dans l'étape suivante, nous chargerons l'ensemble de données CIFAR dans trainset à l'aide de trainloader, après avoir effectué les transformations que nous venons de définir.

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=False)

Nous avons récupéré l'ensemble de données CIFAR à partir de torchvision.datasets, en définissant les arguments train et download sur True. Ensuite, nous définissons l'argument transform sur la variable transform définie. L'itérable DataLoader a été initialisé et nous lui avons passé trainset comme argument. Le batch_size a été défini sur 4 et mélangé sur False. Ensuite, nous pouvons visualiser les images à l'aide de l'extrait de code ci-dessous.

classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

def imshow(img):
     img = img / 2 + 0.5
     npimg = img.numpy()
     plt.imshow(np.transpose(npimg, (1, 2, 0)))
     plt.show()
    
dataiter = iter(trainloader)
images, labels = dataiter.next()    

imshow(torchvision.utils.make_grid(images))

print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

Outre Resize(), CenterCrop() et RandomResizedCrop(), il existe diverses autres classes Transform disponibles. Regardons les plus utilisés.

Transformer les classes

  1. RandomCrop : cette classe de PyTorch recadre l'image PIL donnée à un emplacement aléatoire. Voici les arguments acceptés par RandomCrop :
torchvision.transforms.RandomCrop(size, padding=None, pad_if_needed=False, fill=0)
  • size : cet argument prend un entier qui indique la taille de sortie souhaitée du recadrage aléatoire. Par exemple, si la taille est définie sur 32, le résultat sera une image recadrée aléatoirement de taille 32×32.
  • padding : Il s'agit d'un argument entier initialement défini sur Aucun. S'il est défini sur un nombre entier, il ajoute une bordure supplémentaire à l'image. Par exemple, si le remplissage est défini sur 4, il remplit les bordures gauche, supérieure, droite et inférieure de 4 unités chacune.
  • pad_if_needed : Il s'agit d'un paramètre facultatif qui prend une valeur booléenne. S'il est défini sur True, il remplit une zone plus petite autour de l'image pour éviter des erreurs de résolution minimales. Par défaut, ce paramètre est défini sur False.
  • fill : Cette valeur constante initialise les valeurs de tous les pixels remplis. La valeur de remplissage par défaut est 0.

2. RandomHorizontalFlip : Parfois, pour rendre le modèle robuste pendant l'entraînement, nous retournons les images de manière aléatoire. La classe RandomHorizontalFlip est utilisée pour obtenir de tels résultats. Il a un argument par défaut, p, qui indique la probabilité que l'image soit retournée (entre 0 et 1). La valeur par défaut est 0,5.

torchvision.transforms.RandomHorizontalFlip(p=0.5)

3. Normaliser : Ceci normalise les images, avec la moyenne et l'écart type donnés en arguments. Cette classe prend quatre arguments, indiqués ci-dessous :

torchvision.transforms.functional.normalize(tensor, mean, std, inplace=False)
  • L'argument tensor prend un Tensor avec trois valeurs : C, H et W. Elles représentent respectivement le nombre de canaux, la hauteur et la largeur. Sur la base de l'argument donné, toutes les valeurs de pixels des images d'entrée sont normalisées.
  • Les arguments mean et std prennent en compte une séquence de moyennes et d'écarts types par rapport à chaque canal.
  • L'argument inplace est une valeur booléenne. Si défini sur True, toutes les opérations doivent être calculées sur place.

4. ToTensor : cette classe convertit l'image PIL ou un tableau NumPy n dimensions en un tenseur.

torchvision.transforms.functional.to_tensor(img)

Comprenons maintenant les mécanismes derrière le chargement d'un ensemble de données personnalisé, plutôt que d'utiliser les ensembles de données intégrés.

Création d'ensembles de données personnalisés dans PyTorch

Jusqu'à présent, nous avons appris à charger des ensembles de données ainsi que différentes manières de prétraiter les données. Dans cette section, nous allons créer un simple ensemble de données personnalisé composé de chiffres et de texte. Nous parlerons de l'objet Dataset dans PyTorch qui aide à gérer les fichiers numériques et texte, et de la façon dont on pourrait optimiser le pipeline pour une certaine tâche. L'astuce ici est d'abstraire les méthodes __getitem__() et __len__() dans la classe Dataset.

  • La méthode __getitem__() renvoie l'échantillon sélectionné dans l'ensemble de données par indexation.
  • La méthode  __len__() renvoie la taille totale de l'ensemble de données. Par exemple, si votre ensemble de données contient 1 00 000 échantillons, la méthode len doit renvoyer 1 00 000.

Notez qu'à ce stade, les données ne sont pas encore chargées en mémoire.

Vous trouverez ci-dessous une vue abstraite expliquant les implémentations des méthodes __getitem__() et __len__() :

class Dataset(object):
    def __getitem__(self, index):
        raise NotImplementedError

    def __len__(self):
        raise NotImplementedError

Créer un jeu de données personnalisé n’est pas complexe, mais en plus de la procédure typique de chargement de données, il est nécessaire de construire une interface afin d’obtenir une belle abstraction (un joli sucre syntaxique pour le moins). Nous allons maintenant créer un nouvel ensemble de données contenant des nombres et leurs valeurs au carré. Appelons notre ensemble de données SquareDataset. Son but est de renvoyer des carrés de valeurs dans la plage [a,b]. Ci-dessous le code correspondant :

import torch
import torchvision
from torch.utils.data import Dataset, DataLoader
from torchvision import datasets, transforms

class SquareDataset(Dataset):
     def __init__(self, a=0, b=1):
         super(Dataset, self).__init__()
         assert a <= b
         self.a = a
         self.b = b
        
     def __len__(self):
         return self.b - self.a + 1
        
     def __getitem__(self, index):
        assert self.a <= index <= self.b
        return index, index**2

data_train = SquareDataset(a=1,b=64)
data_train_loader = DataLoader(data_train, batch_size=64, shuffle=True)
print(len(data_train))

Dans le bloc de code ci-dessus, nous avons créé une classe Python nommée SquareDataset qui hérite de la classe Dataset de PyTorch. Ensuite, nous avons appelé un constructeur __init__() où a et b ont été initialisés à 0 et 1. , respectivement. La classe super est utilisée pour accéder aux méthodes len et get_item de la classe Dataset héritée. Ensuite, nous avons utilisé l'instruction assert pour vérifier si a est inférieur ou égal à b, car nous voulons créer un ensemble de données dans lequel les valeurs seraient se situer entre a et b.

Nous avons ensuite créé un ensemble de données à l'aide de la classe SquareDataset, où les valeurs des données sont comprises entre 1 et 64. Nous l'avons chargé dans une variable nommée data_train. Enfin, la classe Dataloader a créé un itérateur sur les données stockées dans data_train_loader avec un batch_size initialisé à 64, et shuffle défini sur Vrai.

Les chargeurs de données exploitent les avantages de Python en employant des éléments de concepts de programmation orientée objet. Un bon exercice consisterait à parcourir une variété de chargeurs de données avec un certain nombre d'ensembles de données populaires, notamment CelebA, PIMA, COCO, ImageNet, CIFAR-10/100, etc.

Résumé

Dans cet article, nous avons découvert le chargement et l'abstraction des données. Nous avons commencé avec les ensembles de données disponibles dans les packages torchvision et torchtext, et avons examiné quelques ensembles de données populaires. Nous avons ensuite découvert la classe DataLoader et son importance dans la gestion soignée des données en les organisant conformément aux paramètres donnés. Plus tard, nous avons analysé l'ensemble de données MNIST en profondeur en examinant diverses techniques possibles pour l'appeler dans notre espace de travail. Des chargeurs de données et des transformations ont également été introduits, leur importance étant citée dans l'exemple MNIST. Un aperçu plus approfondi des transformations et de leurs classes a été proposé en l'expliquant à travers RandomCrop, RandomHorizontalFlip, Normalize, ToTensor. et RandomRotate. Par la suite, les raisons pour lesquelles les GPU ont le dessus sur les CPU ont été expliquées à travers des exemples avec PyTorch CUDA. La création d’un ensemble de données personnalisé n’est pas une tâche complexe, et cette affirmation a été justifiée à l’aide d’un court extrait de code. Les concepts et principes fondamentaux que vous avez appris dans ce didacticiel sont tous fondamentaux pour utiliser PyTorch.

Articles connexes: