Créer un jeu de données d'images

Il existe deux méthodes pour créer et partager un jeu de données d'images. Ce guide vous montre comment :

• Créez un jeu de données d’images à partir de fichiers locaux en python avec Dataset.push_to_hub(). C’est une méthode simple qui ne nécessite que quelques étapes en python.

• Créez un jeu de données d’images avec ImageFolder et quelques métadonnées. Il s’agit d’une solution sans code pour créer rapidement un jeu de données d’images contenant plusieurs milliers d’images.

Vous pouvez contrôler l'accès à votre jeu de données en exigeant que les utilisateurs partagent d'abord leurs coordonnées. Consultez le guide Gated datasets pour plus d'informations sur la manière d'activer cette fonctionnalité sur le Hub.

ImageFolder

ImageFolder est un constructeur de jeu de données conçu pour charger rapidement un jeu de données d'images comptant plusieurs milliers d'images, sans qu'il soit nécessaire d'écrire du code.

💡 Consultez la hiérarchie des motifs de partitionnement pour en savoir plus sur la manière dont ImageFolder crée des partitions de jeu de données en fonction de la structure de votre dépôt de jeu de données.

ImageFolder infère automatiquement les étiquettes de classes de votre jeu de données en fonction du nom du répertoire. Stockez votre jeu de données dans une structure de répertoires de la forme :

folder/train/dog/golden_retriever.png
folder/train/dog/german_shepherd.png
folder/train/dog/chihuahua.png

folder/train/cat/maine_coon.png
folder/train/cat/bengal.png
folder/train/cat/birman.png

Si le jeu de données suit la structure ImageFolder, vous pouvez le charger directement avec load_dataset() :

>>> from datasets import load_dataset

>>> dataset = load_dataset("path/to/folder")

Cela équivaut à passer imagefolder manuellement dans load_dataset() et le répertoire dans data_dir :

>>> dataset = load_dataset("imagefolder", data_dir="/path/to/folder")

Vous pouvez également utiliser imagefolder pour charger des jeux de données impliquant plusieurs splits. Pour ce faire, le répertoire de votre jeu de données doit avoir la structure suivante :

folder/train/dog/golden_retriever.png
folder/train/cat/maine_coon.png
folder/test/dog/german_shepherd.png
folder/test/cat/bengal.png

Si tous les fichiers d’image sont contenus dans un seul répertoire ou s’ils ne sont pas au même niveau de la structure de répertoires, la colonne label ne sera pas ajoutée automatiquement. Si vous en avez besoin, définissez explicitement drop_labels=False.

Si vous souhaitez inclure des informations supplémentaires sur votre jeu de données, comme des légendes de texte ou des boîtes englobantes, ajoutez-les sous forme de fichier metadata.csv dans votre dossier. Cela vous permet de créer rapidement des jeux de données pour différentes tâches de vision par ordinateur, comme la légende de texte ou la détection d’objets. Vous pouvez également utiliser un fichier JSONL metadata.jsonl ou un fichier Parquet metadata.parquet.

folder/train/metadata.csv
folder/train/0001.png
folder/train/0002.png
folder/train/0003.png

Vous pouvez également compresser vos images en fichiers zip, auquel cas chaque archive zip doit contenir à la fois les images et les métadonnées

folder/train.zip
folder/test.zip
folder/validation.zip

Votre fichier metadata.csv doit contenir un champ file_name ou *_file_name qui associe les fichiers d’images à leurs métadonnées :

file_name,additional_feature
0001.png,This is a first value of a text feature you added to your images
0002.png,This is a second value of a text feature you added to your images
0003.png,This is a third value of a text feature you added to your images

ou en utilisant metadata.jsonl :

{"file_name": "0001.png", "additional_feature": "This is a first value of a text feature you added to your images"}
{"file_name": "0002.png", "additional_feature": "This is a second value of a text feature you added to your images"}
{"file_name": "0003.png", "additional_feature": "This is a third value of a text feature you added to your images"}

Ici, file_name doit être le nom du fichier image situé à côté du fichier de métadonnées. Plus généralement, il doit s’agir du chemin relatif depuis le répertoire contenant les métadonnées jusqu’au fichier image.

Il est possible de pointer vers plusieurs images dans chaque ligne de votre jeu de données, par exemple si vos entrées et vos sorties sont toutes deux des images :

{"input_file_name": "0001.png", "output_file_name": "0001_output.png"}
{"input_file_name": "0002.png", "output_file_name": "0002_output.png"}
{"input_file_name": "0003.png", "output_file_name": "0003_output.png"}

Vous pouvez également définir des listes d’images. Dans ce cas, vous devez nommer le champ file_names ou *_file_names. Voici un exemple :

{"frames_file_names": ["0001_t0.png", "0001_t1.png"], label: "moving_up"}
{"frames_file_names": ["0002_t0.png", "0002_t1.png"], label: "moving_down"}
{"frames_file_names": ["0003_t0.png", "0003_t1.png"], label: "moving_right"}

Légende d'image

Les jeux de données de légende d'images contiennent du texte décrivant une image. Un exemple de metadata.csv peut ressembler à ceci :

file_name,text
0001.png,This is a golden retriever playing with a ball
0002.png,A german shepherd
0003.png,One chihuahua

Chargez le jeu de données avec ImageFolder, et il créera une colonne text pour les légendes des images :

>>> dataset = load_dataset("imagefolder", data_dir="/path/to/folder", split="train")
>>> dataset[0]["text"]
"This is a golden retriever playing with a ball"

Détection d'objets

Les jeux de données de détection d'objets comportent des boîtes englobantes et des catégories identifiant les objets dans une image. Un exemple de metadata.jsonl peut ressembler à :

{"file_name": "0001.png", "objects": {"bbox": [[302.0, 109.0, 73.0, 52.0]], "categories": [0]}}
{"file_name": "0002.png", "objects": {"bbox": [[810.0, 100.0, 57.0, 28.0]], "categories": [1]}}
{"file_name": "0003.png", "objects": {"bbox": [[160.0, 31.0, 248.0, 616.0], [741.0, 68.0, 202.0, 401.0]], "categories": [2, 2]}}

Chargez le jeu de données avec ImageFolder, et il créera une colonne objects contenant les boîtes englobantes et les catégories :

>>> dataset = load_dataset("imagefolder", data_dir="/path/to/folder", split="train")
>>> dataset[0]["objects"]
{"bbox": [[302.0, 109.0, 73.0, 52.0]], "categories": [0]}

Téléverser le jeu de données sur le Hub

Une fois que vous avez créé un jeu de données, vous pouvez le partager sur le Hub à l’aide de la méthode push_to_hub(). Assurez-vous d’avoir installé la bibliothèque huggingface_hub et d’être connecté à votre compte Hugging Face (voir le tutoriel Upload with Python pour plus de détails).

Téléchargez votre jeu de données avec push_to_hub() :

>>> from datasets import load_dataset

>>> dataset = load_dataset("imagefolder", data_dir="/path/to/folder", split="train")
>>> dataset.push_to_hub("stevhliu/my-image-captioning-dataset")

WebDataset

Le format WebDataset est basé sur des archives TAR et convient aux grands jeux de données d’images. En effet, vous pouvez regrouper vos images dans des archives TAR (par exemple 1 Go d’images par archive TAR) et disposer de milliers d’archives TAR :

folder/train/00000.tar
folder/train/00001.tar
folder/train/00002.tar
...

Dans les archives, chaque exemple est constitué de fichiers partageant le même préfixe :

e39871fd9fd74f55.jpg
e39871fd9fd74f55.json
f18b91585c4d3f3e.jpg
f18b91585c4d3f3e.json
ede6e66b2fb59aab.jpg
ede6e66b2fb59aab.json
ed600d57fcee4f94.jpg
ed600d57fcee4f94.json
...

Vous pouvez placer vos étiquettes/légendes/cadres englobants d’images dans des fichiers JSON ou texte, par exemple.

Chargez votre WebDataset et il créera une colonne par suffixe de fichier (ici « jpg » et « json ») :

>>> from datasets import load_dataset

>>> dataset = load_dataset("webdataset", data_dir="/path/to/folder", split="train")
>>> dataset[0]["json"]
{"bbox": [[302.0, 109.0, 73.0, 52.0]], "categories": [0]}

Il est également possible d’avoir plusieurs images par exemple, comme ceci :

e39871fd9fd74f55.input.jpg
e39871fd9fd74f55.output.jpg
e39871fd9fd74f55.json
f18b91585c4d3f3e.input.jpg
f18b91585c4d3f3e.output.jpg
f18b91585c4d3f3e.json
...

Pour plus de détails sur le format WebDataset et la bibliothèque python, veuillez consulter la documentation WebDataset.

Lance

Lance est un format de table de lakehouse multimodal ouvert. Les tables Lance peuvent stocker nativement non seulement du texte et des valeurs scalaires, mais aussi de grands objets binaires (blobs) tels que des images, de l’audio et de la vidéo, aux côtés de vos données tabulaires.

À partir de fichiers image sur disque et des métadonnées associées (par exemple, légendes et dimensions), vous pouvez écrire un jeu de données Lance autonome dans un répertoire local *.lance. Le tableau résultant peut stocker vos colonnes de métadonnées aux côtés d'une colonne image contenant les octets encodés de l'image.

Par exemple, vous pourriez commencer avec des métadonnées comme :

{'caption': 'Cordelia and Dudley on their wedding  day last year', 'height': 315, 'width': 233}
{'caption': 'Statistics on challenges for automation in 2021', 'height': 299, 'width': 701}

Vous pouvez définir un schéma pyarrow pour vos métadonnées et les octets de vos images, construire un tableau, puis l'écrire en tant que jeu de données Lance :

import lance
import pyarrow as pa

schema = pa.schema(
    [
        pa.field("caption", pa.utf8()),
        pa.field("height", pa.int32()),
        pa.field("width", pa.int32()),
        # ... add any additional metadata columns you want here ...
        pa.field("image", pa.binary()),
    ]
)

# Provide image files alongside metadata
rows = [
    {
        "image_path": "/path/to/images/0001.jpg",
        "caption": "Cordelia and Dudley on their wedding  day last year",
        "height": 315,
        "width": 233,
    },
    {
        "image_path": "/path/to/images/0002.jpg",
        "caption": "Statistics on challenges for automation in 2021",
        "height": 299,
        "width": 701,
    },
]

image_bytes = []
for r in rows:
    with open(r["image_path"], "rb") as f:
        image_bytes.append(f.read())

table = pa.table(
    {
        "caption": [r["caption"] for r in rows],
        "height": [r["height"] for r in rows],
        "width": [r["width"] for r in rows],
        "image": image_bytes,
    },
    schema=schema,
)

ds = lance.write_dataset(
    table,
    "./images.lance",
    schema=schema,
    mode="create",
)

Voici un aperçu représentatif de ce à quoi pourrait ressembler une table Lance stockant des images (la colonne image contient des octets encodés) :

+-----------------------------------------------+--------+-------+-----+------------------------------+
| caption                                       | height | width | ... | image                        |
+-----------------------------------------------+--------+-------+-----+------------------------------+
| "Cordelia and Dudley on their wedding ..."    | 315    | 233   | ... | b"\\xff\\xd8\\xff...\\xd9"   |
| "Statistics on challenges for automation ..." | 299    | 701   | ... | b"\\xff\\xd8\\xff...\\xd9"   |
+-----------------------------------------------+--------+-------+-----+------------------------------+

En utilisant cette approche, vous pouvez stocker des jeux de données d’images de taille arbitrairement grande dans Lance. Le répertoire images.lance/ résultant, avec ses fichiers *.lance, peut être téléversé sur le Hugging Face Hub, tout comme les autres exemples ci-dessus. Consultez le jeu de données lance-format/laion-1m sur le Hub pour un exemple de jeu de données d’images Lance.

Pour plus de détails sur le travail avec les jeux de données Lance, consultez la documentation Lance.