Crear un conjunto de datos de imágenes

Existen dos métodos para crear y compartir un conjunto de datos de imágenes. Esta guía te mostrará cómo:

• Crea un conjunto de datos de imágenes a partir de archivos locales en python con Dataset.push_to_hub(). Esta es una forma sencilla que requiere solo unos pocos pasos en python.

• Crea un conjunto de datos de imágenes con ImageFolder y algunos metadatos. Esta es una solución sin código para crear rápidamente un conjunto de datos de imágenes con varios miles de imágenes.

Puedes controlar el acceso a tu conjunto de datos requiriendo que los usuarios compartan primero su información de contacto. Consulta la guía de Conjuntos de datos con acceso restringido para obtener más información sobre cómo habilitar esta función en el Hub.

ImageFolder

El ImageFolder es un constructor de conjuntos de datos diseñado para cargar rápidamente un conjunto de datos de imágenes con varios miles de imágenes sin necesidad de escribir código.

💡 Echa un vistazo a la Jerarquía del patrón Split para aprender más sobre cómo ImageFolder crea divisiones de datos basadas en la estructura de tu repositorio de datos.

ImageFolder infiere automáticamente las etiquetas de clase de tu conjunto de datos en función del nombre del directorio. Almacena tu conjunto de datos en una estructura de directorios como:

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 el conjunto de datos sigue la estructura ImageFolder, puedes cargarlo directamente con load_dataset():

>>> from datasets import load_dataset

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

Esto es equivalente a pasar imagefolder manualmente en load_dataset() y el directorio en data_dir:

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

También puede usar imagefolder para cargar conjuntos de datos que implican múltiples divisiones. Para ello, el directorio de su conjunto de datos debe tener la siguiente estructura:

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

Si todos los archivos de imagen están contenidos en un solo directorio o si no están en el mismo nivel de la estructura de directorios, la columna label no se añadirá automáticamente. Si la necesitas, establece drop_labels=False explícitamente.

Si hay información adicional que desees incluir sobre tu conjunto de datos, como descripciones de texto o cajas delimitadoras, añádela como un archivo metadata.csv en tu carpeta. Esto te permite crear rápidamente conjuntos de datos para diferentes tareas de visión por computadora, como la descripción de texto o la detección de objetos. También puedes usar un archivo JSONL metadata.jsonl o un archivo Parquet metadata.parquet.

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

También puedes comprimir tus imágenes en un archivo zip, y en este caso cada archivo zip debe contener tanto las imágenes como los metadatos

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

El archivo metadata.csv debe tener un campo file_name o *_file_name que vincule los archivos de imagen con sus metadatos:

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

o usando 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"}

Aquí, file_name debe ser el nombre del archivo de imagen situado junto al archivo de metadatos. De forma más general, debe ser la ruta relativa desde el directorio que contiene los metadatos hasta el archivo de imagen.

Es posible apuntar a más de una imagen en cada fila de su conjunto de datos, por ejemplo, si tanto la entrada como la salida son imágenes:

{"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"}

También puede definir listas de imágenes. En ese caso, debe nombrar el campo file_names o *_file_names. Aquí hay un ejemplo:

{"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"}

Descripción de imágenes

Los conjuntos de datos de descripción de imágenes tienen texto que describe una imagen. Un ejemplo de metadata.csv podría verse así:

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

Carga el conjunto de datos con ImageFolder y creará una columna text para las descripciones de las imágenes:

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

Detección de objetos

Los conjuntos de datos de detección de objetos tienen cajas delimitadoras y categorías que identifican los objetos en una imagen. Un ejemplo de metadata.jsonl podría verse así:

{"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]}}

Cargue el conjunto de datos con ImageFolder y creará una columna objects con las cajas delimitadoras y las categorías:

>>> 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]}

Subir el conjunto de datos al Hub

Una vez que hayas creado un conjunto de datos, puedes compartirlo en el Hub con el método push_to_hub(). Asegúrate de tener instalada la biblioteca huggingface_hub y de haber iniciado sesión en tu cuenta de Hugging Face (consulta el tutorial de carga con Python para más detalles).

Sube tu conjunto de datos con 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

El formato WebDataset se basa en archivos TAR y es adecuado para grandes conjuntos de datos de imágenes. De hecho, puede agrupar sus imágenes en archivos TAR (por ejemplo, 1 GB de imágenes por archivo TAR) y tener miles de archivos TAR:

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

En los archivos, cada ejemplo está compuesto por archivos que comparten el mismo prefijo:

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

Puedes incluir las etiquetas, descripciones o cajas delimitadoras de tus imágenes utilizando, por ejemplo, archivos JSON o de texto.

Carga tu WebDataset y creará una columna por cada sufijo de archivo (aquí, “jpg” y “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]}

También es posible tener varias imágenes por ejemplo, de esta manera:

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

Para más detalles sobre el formato WebDataset y la biblioteca de python, consulte la documentación de WebDataset.

Lance

Lance es un formato de tabla de lakehouse multimodal abierto. Las tablas Lance pueden almacenar de forma nativa no solo texto y valores escalares, sino también objetos binarios grandes (blobs) como imágenes, audio y video junto a sus datos tabulares.

A partir de archivos de imagen en el disco y sus metadatos asociados (por ejemplo, descripciones y dimensiones), puede escribir un conjunto de datos Lance autónomo en un directorio local *.lance. La tabla resultante puede almacenar sus columnas de metadatos junto a una columna image que contiene los bytes codificados de la imagen.

Por ejemplo, es posible que comience con metadatos como:

{'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}

Puedes definir un esquema de pyarrow para tus metadatos y bytes de imagen, construir una tabla y escribirla como un conjunto de datos 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",
)

A continuación se muestra una vista representativa de cómo podría ser una tabla Lance que almacena imágenes (la columna image contiene bytes codificados):

+-----------------------------------------------+--------+-------+-----+------------------------------+
| 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"   |
+-----------------------------------------------+--------+-------+-----+------------------------------+

Con este enfoque, puede almacenar conjuntos de datos de imágenes de tamaño arbitrariamente grande en Lance. El directorio resultante images.lance/ con sus archivos *.lance se puede subir al Hugging Face Hub, al igual que los otros ejemplos anteriores. Consulte el conjunto de datos lance-format/laion-1m en el Hub para ver un ejemplo de un conjunto de datos de imágenes en Lance.

Para más detalles sobre el trabajo con conjuntos de datos Lance, consulte la documentación de Lance.