11 ensembles de données Torchvision pour la vision par ordinateur que vous devez connaître

La vision par ordinateur est un domaine en pleine croissance et a de nombreuses applications pratiques, allant des voitures autonomes aux systèmes de reconnaissance faciale. Cependant, l'un des principaux défis dans ce domaine est d'obtenir des ensembles de données de haute qualité pour former des modèles d'apprentissage automatique.

Pour relever ce défi, torchvision donne accès à des ensembles de données, des modèles et des transformations prédéfinis spécialement conçus pour les tâches de vision par ordinateur. Torchvision prend également en charge l'accélération CPU et GPU, ce qui en fait un outil flexible et puissant pour développer des applications de vision par ordinateur.

Que sont les « ensembles de données Torchvision » ?

Les ensembles de données Torchvision sont des collections d'ensembles de données populaires couramment utilisés en vision par ordinateur pour développer et tester des modèles d'apprentissage automatique. Avec les ensembles de données torchvision, les développeurs peuvent former et tester leurs modèles d'apprentissage automatique sur une gamme de tâches, telles que la classification d'images, la détection d'objets et la segmentation.

Les ensembles de données sont également prétraités, étiquetés et organisés dans des formats qui peuvent être facilement chargés et utilisés.

Liste des ensembles de données Torchvision

1. MNIST
2. CIFAR-10
3. CIFAR-100
4. ImageNet
5. COCO
6. Mode-MNIST
7. SVH
8. STL-10
9. CelebA
10. Pascal COV
11. Lieux365

1. MNIST

Cet ensemble de données torchvision est populaire et largement utilisé dans les domaines de l'apprentissage automatique et de la vision par ordinateur. Il se compose de 70 000 images en niveaux de gris de chiffres manuscrits de 0 à 9, avec 60 000 images pour la formation et 10 000 pour les tests. Chaque image a une taille de 28x28 pixels et a une étiquette correspondante indiquant les chiffres qu'elle représente.

Pour accéder à ce jeu de données, vous pouvez le télécharger directement depuis Kagglé ou chargez le jeu de données à l'aide de torchvision :

 import torchvision.datasets as datasets # Load the training dataset train_dataset = datasets.MNIST(root='data/', train=True, transform=None, download=True) # Load the testing dataset test_dataset = datasets.MNIST(root='data/', train=False, transform=None, download=True)

Code pour charger le jeu de données MNIST à l'aide du package PyTorch torchvision. Extrait de https://pytorch.org/vision/stable/generated/torchvision.datasets.MNIST.html#torchvision.datasets.MNIST le 20/3/2023 .

2. CIFAR-10

L'ensemble de données CIFAR-10 se compose de 60 000 images couleur 32x32 réparties en 10 classes, avec 6 000 images par classe. Il a un total de 50 000 images d'entraînement et 10 000 images de test qui sont ensuite divisées en cinq lots d'entraînement et un lot de test, chacun avec 10 000 images.

Ce jeu de données peut être téléchargé à partir de Kagglé , ou chargé ici avec torchvision :

 import torch import torchvision import torchvision.transforms as transforms transform = transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]) trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform) testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform) trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True, num_workers=2) testloader = torch.utils.data.DataLoader(testset, batch_size=4, shuffle=False, num_workers=2)

Notez que vous pouvez ajuster la taille du lot et le nombre de processus de travail pour les chargeurs de données selon vos besoins.

Code pour charger l'ensemble de données CIFAR-10 à l'aide du package PyTorch torchvision. Extrait de https://pytorch.org/vision/stable/generated/torchvision.datasets.CIFAR10.html#torchvision.datasets.CIFAR10 le 20/3/2023 .

3. CIFAR-100

L'ensemble de données CIFAR-100 contient 60 000 (50 000 images d'entraînement et 10 000 images de test) images couleur 32x32 dans 100 classes, avec 600 images par classe. Les 100 classes sont regroupées en 20 super-classes, avec une étiquette fine pour désigner sa classe et une étiquette grossière pour représenter la super-classe à laquelle elle appartient.

Pour télécharger l'ensemble de données torchvision de Kaggle, veuillez visiter le Kaggle site Internet et suivez les instructions qui y sont fournies. Alternativement, si vous préférez charger le jeu de données à l'aide de la bibliothèque torchvision, vous pouvez le faire :

 import torchvision.datasets as datasets import torchvision.transforms as transforms # Define transform to normalize data transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) ]) # Load CIFAR-100 train and test datasets trainset = datasets.CIFAR100(root='./data', train=True, download=True, transform=transform) testset = datasets.CIFAR100(root='./data', train=False, download=True, transform=transform) # Create data loaders for train and test datasets trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True) testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)

Code pour charger l'ensemble de données CIFAR-100 à l'aide du package PyTorch torchvision. Extrait de https://pytorch.org/vision/stable/generated/torchvision.datasets.CIFAR100.html#torchvision.datasets.CIFAR100 le 20/3/2023 .

4. ImageNet

L'ensemble de données ImageNet de torchvision contient environ 1,2 million d'images de formation, 50 000 images de validation et 100 000 images de test. Chaque image de l'ensemble de données est étiquetée avec l'une des 1 000 catégories telles que "chat", "chien", "voiture", "avion", etc.

Pour télécharger ce jeu de données torchvision, vous devez visiter le site Internet ou charger dans torchvision :

 import torchvision.datasets as datasets import torchvision.transforms as transforms # Set the path to the ImageNet dataset on your machine data_path = "/path/to/imagenet" # Create the ImageNet dataset object with custom options imagenet_train = datasets.ImageNet( root=data_path, split='train', transform=transforms.Compose([ transforms.Resize(256), transforms.RandomCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]), download=False ) imagenet_val = datasets.ImageNet( root=data_path, split='val', transform=transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]), download=False ) # Print the number of images in the training and validation sets print("Number of images in the training set:", len(imagenet_train)) print("Number of images in the validation set:", len(imagenet_val))

Code pour charger le jeu de données ImageNet à l'aide du package PyTorch torchvision. Extrait de https://pytorch.org/vision/stable/generated/torchvision.datasets.ImageNet.html#torchvision.datasets.ImageNet le 21/3/2023 .

5. Mme Coco

L'ensemble de données Microsoft Common Objects in Context (MS Coco) contient 328 000 images visuelles de haute qualité d'objets du quotidien et d'humains, souvent utilisées comme norme pour comparer les performances des algorithmes de détection d'objets en temps réel.

Pour télécharger cet ensemble de données torchvision, veuillez visiter le site Internet ou charger dans torchvision :

 import torch from torchvision import datasets, transforms # Define transformation transform = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) # Load training dataset train_dataset = datasets.CocoDetection(root='/path/to/dataset/train2017', annFile='/path/to/dataset/annotations/instances_train2017.json', transform=transform) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True) # Load validation dataset val_dataset = datasets.CocoDetection(root='/path/to/dataset/val2017', annFile='/path/to/dataset/annotations/instances_val2017.json', transform=transform) val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=32, shuffle=False)

Assurez-vous de remplacer les espaces réservés /path/to/dataset par le chemin d'accès réel au répertoire de votre ensemble de données. Ajustez également le paramètre batch_size en fonction de vos besoins.

Code pour charger le jeu de données MS Coco à l'aide du package PyTorch torchvision. Extrait de https://pytorch.org/vision/stable/generated/torchvision.datasets.CocoDetection.html#torchvision.datasets.CocoDetection le 21/3/2023 .

6. Mode-MNIST

L'ensemble de données Fashion MNIST a été créé par Zalando Research en remplacement de l'ensemble de données MNIST d'origine. L'ensemble de données Fashion MNIST se compose de 70 000 images en niveaux de gris (ensemble d'entraînement de 60 000 et un ensemble de test de 10 000) d'articles vestimentaires.

Les images ont une taille de 28 x 28 pixels et représentent 10 classes différentes de vêtements, notamment des t-shirts/hauts, des pantalons, des pulls, des robes, des manteaux, des sandales, des chemises, des baskets, des sacs et des bottines. Il est similaire à l'ensemble de données MNIST original, mais avec des tâches de classification plus difficiles en raison de la plus grande complexité et de la variété des vêtements.

Ce jeu de données torchvision peut être téléchargé à partir de Kagglé , ou chargé à l'aide de ce code :

 import torch import torchvision import torchvision.transforms as transforms # Define transformations transform = transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))]) # Load the dataset trainset = torchvision.datasets.FashionMNIST(root='./data', train=True, download=True, transform=transform) testset = torchvision.datasets.FashionMNIST(root='./data', train=False, download=True, transform=transform) # Create data loaders trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True, num_workers=2) testloader = torch.utils.data.DataLoader(testset, batch_size=4, shuffle=False, num_workers=2)

Code pour charger le jeu de données Fashion-MNIST à l'aide du package PyTorch torchvision. Extrait de https://pytorch.org/vision/stable/generated/torchvision.datasets.FashionMNIST.html#torchvision.datasets.FashionMNIST le 21/3/2023 .

7. SVH

L'ensemble de données SVHN (Street View House Numbers) est un ensemble de données d'images dérivé de l'imagerie Street View de Google, qui consiste en des images recadrées de numéros de maison tirées d'images au niveau de la rue. Il est disponible dans un format complet avec tous les numéros de maison et leurs cadres de délimitation et un format recadré avec uniquement les numéros de maison seuls. Le format complet est souvent utilisé pour les tâches de détection d'objets, tandis que le format recadré est couramment utilisé pour les tâches de classification.

L'ensemble de données SVHN est également inclus dans le package torchvision et contient 73 257 images pour la formation, 26 032 images pour les tests et 531 131 images supplémentaires pour des données de formation supplémentaires.

Pour télécharger ce jeu de données torchvision, vous pouvez vous rendre sur Kagglé ou vous pouvez le charger ici :

 import torchvision import torch # Load the train and test sets train_set = torchvision.datasets.SVHN(root='./data', split='train', download=True, transform=torchvision.transforms.ToTensor()) test_set = torchvision.datasets.SVHN(root='./data', split='test', download=True, transform=torchvision.transforms.ToTensor()) # Create data loaders train_loader = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True) test_loader = torch.utils.data.DataLoader(test_set, batch_size=64, shuffle=False)

Code pour charger le jeu de données SVHN à l'aide du package PyTorch torchvision. Extrait de https://pytorch.org/vision/stable/generated/torchvision.datasets.SVHN.html#torchvision.datasets.SVHN le 22/3/2023 .

8. STL-10

L'ensemble de données STL-10 est un ensemble de données de reconnaissance d'images composé de 10 classes, avec un total d'environ 6 000+ images. Le STL-10 signifie "Standard Training and Test Set for Image Recognition-10 classes" et les 10 classes de l'ensemble de données sont :

• Avion
• Oiseau
• Voiture
• Chat
• Cerf
• Chien
• Cheval
• Singe
• Bateau
• Camion

Pour accéder à ce jeu de données, vous pouvez le télécharger directement depuis Kagglé ou chargez le jeu de données à l'aide de torchvision :

 import torchvision.datasets as datasets import torchvision.transforms as transforms # Define the transformation to apply to the data transform = transforms.Compose([ transforms.ToTensor(), # Convert PIL image to PyTorch tensor transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) # Normalize the data ]) # Load the STL-10 dataset train_dataset = datasets.STL10(root='./data', split='train', download=True, transform=transform) test_dataset = datasets.STL10(root='./data', split='test', download=True, transform=transform)

Code pour charger le jeu de données STL-10 à l'aide du package PyTorch torchvision. Extrait de https://pytorch.org/vision/stable/generated/torchvision.datasets.STL10.html#torchvision.datasets.STL10 le 22/3/2023 .

9. CelebA

Cet ensemble de données torchvision est un ensemble de données d'attributs de visage à grande échelle populaire qui comprend plus de 200 000 images de célébrités. Il a été publié pour la première fois par des chercheurs de l'Université chinoise de Hong Kong en 2015. Une image dans CelebA se compose de 40 attributs faciaux tels que l'âge, la couleur des cheveux, l'expression faciale et le sexe. De plus, ces images ont été récupérées sur Internet et couvrent un large éventail d'apparences faciales, y compris différentes races, âges et sexes. Annotations de la boîte englobante pour l'emplacement du visage dans chaque image, ainsi que 5 points de repère pour les yeux, le nez et la bouche.

Vous pouvez télécharger ce jeu de données sur Kagglé ou chargez-le en utilisant ce code :

 import torchvision.datasets as datasets import torchvision.transforms as transforms transform = transforms.Compose([ transforms.CenterCrop(178), transforms.Resize(128), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) celeba_dataset = datasets.CelebA(root='./data', split='train', transform=transform, download=True)

Code pour charger l'ensemble de données CelebA à l'aide du package PyTorch torchvision. Extrait de https://pytorch.org/vision/stable/generated/torchvision.datasets.CelebA.html#torchvision.datasets.CelebA le 22/3/2023 .

dix. COV PASCAL

L'ensemble de données VOC (Visual Object Classes) a été introduit pour la première fois en 2005 dans le cadre du PASCAL VOC Challenge, qui visait à faire progresser l'état de l'art en matière de reconnaissance visuelle. Il se compose d'images de 20 catégories d'objets différentes, y compris des animaux, des véhicules et des objets ménagers courants. Chacune de ces images est annotée avec les emplacements et les classifications des objets dans l'image. Les annotations comprennent à la fois des cadres de délimitation et des masques de segmentation au niveau des pixels.

L'ensemble de données est divisé en deux ensembles principaux : les ensembles d'apprentissage et de validation. L'ensemble de formation contient environ 5 000 images avec annotations, tandis que l'ensemble de validation contient environ 5 000 images sans annotations. En outre, l'ensemble de données comprend également un ensemble de test avec environ 10 000 images, mais les annotations pour cet ensemble ne sont pas accessibles au public.

Pour accéder au jeu de données récent, vous pouvez télécharger à partir du site Internet , Kagglé ou chargez-le dans torchvision :

 import torch import torchvision from torchvision import transforms # Define transformations to apply to the images transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) # Load the train and validation datasets train_dataset = torchvision.datasets.VOCDetection(root='./data', year='2007', image_set='train', transform=transform) val_dataset = torchvision.datasets.VOCDetection(root='./data', year='2007', image_set='val', transform=transform) # Create data loaders train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True) val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=32, shuffle=False)

Code pour charger l'ensemble de données PASCAL VOC à l'aide du package PyTorch torchvision. Extrait de https://pytorch.org/vision/stable/generated/torchvision.datasets.VOCDetection.html#torchvision.datasets.VOCDetection le 22/3/2023 .

11. Lieux365

L'ensemble de données Places365 est un ensemble de données de reconnaissance de scène à grande échelle avec plus de 1,8 million d'images couvrant 365 catégories de scènes. L'ensemble de données Places365 Standard comprend environ 1,8 million d'images, tandis que l'ensemble de données Places365-Challenge contient 50 000 images de validation supplémentaires qui sont plus difficiles pour les modèles de reconnaissance.

Pour accéder à cet ensemble de données, vous pouvez utiliser Kagglé ou charger dans torchvision ici :

 import torch import torchvision from torchvision import transforms # Define transformations to apply to the images transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) # Load the train and validation datasets train_dataset = torchvision.datasets.Places365(root='./data', split='train-standard', transform=transform) val_dataset = torchvision.datasets.Places365(root='./data', split='val', transform=transform) # Create data loaders train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True) val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=32, shuffle=False)

Code pour charger l'ensemble de données Places365 à l'aide du package PyTorch torchvision. Extrait de https://pytorch.org/vision/stable/generated/torchvision.datasets.Places365.html#torchvision.datasets.Places365 le 22/3/2023 .

Cas d'utilisation courants pour les ensembles de données Torchvision

MNIST - Cet ensemble de données est couramment utilisé pour les tâches de classification d'images, en particulier pour la reconnaissance des chiffres manuscrits.

CIFAR-10 et CIFAR-100 - Ces ensembles de données sont couramment utilisés pour les tâches de classification d'images, en particulier pour la reconnaissance d'objets.

ImageNet - Cet ensemble de données torchvision contient des millions d'images de divers objets et animaux et est couramment utilisé pour les tâches de reconnaissance d'objets.

Mme COCO - Cet ensemble de données est couramment utilisé pour les tâches de détection, de segmentation et de sous-titrage d'objets.

Mode-MNIST - Semblable à MNIST, cet ensemble de données est couramment utilisé pour les tâches de classification d'images, en particulier pour la reconnaissance d'articles de mode.

SVH - Cet ensemble de données est couramment utilisé pour les tâches de reconnaissance de chiffres. Il est particulièrement utile pour développer et tester des algorithmes de reconnaissance de nombres dans des contextes réels.

STL-10 - Cet ensemble de données torchvision est couramment utilisé pour les tâches de classification d'images, en particulier pour la reconnaissance d'objets.

CelebA - Cet ensemble de données est couramment utilisé pour les tâches de reconnaissance faciale et de classification d'attributs. Il se compose d'images de diverses expressions faciales, poses et arrière-plans.

Pascal COV - Cet ensemble de données est couramment utilisé pour les tâches de détection et de segmentation d'objets.

Lieux365 - Cet ensemble de données est couramment utilisé pour les tâches de reconnaissance de scène. Il se compose d'images de diverses scènes intérieures et extérieures telles que des chambres, des plages et des bureaux.

Dernières pensées

Les ensembles de données Torchvision sont souvent utilisés pour former et évaluer des modèles d'apprentissage automatique tels que les réseaux de neurones convolutifs (CNN), qui sont couramment utilisés dans les applications de vision par ordinateur.

Ils sont également disponibles pour quiconque de les télécharger et de les utiliser librement.

L'image principale de cet article a été générée via le modèle AI Stable Diffusion de HackerNoon en utilisant l'invite "des milliers d'images organisées ensemble dans de petits cadres".

Plus de listes d'ensembles de données :

1. Ensembles de données Excel
2. Ensembles de données Keras
3. Jeux de données R
4. Ensembles de données PyTorch
5. Enlacer les ensembles de données