Crie um conjunto de dados de imagens

Existem dois métodos para criar e compartilhar um conjunto de dados de imagens. Este guia mostrará como:

• Crie um conjunto de dados de imagens a partir de arquivos locais em python com Dataset.push_to_hub(). Esta é uma maneira fácil que requer apenas algumas etapas em python.

• Crie um conjunto de dados de imagens com ImageFolder e alguns metadados. Esta é uma solução sem código para criar rapidamente um conjunto de dados de imagens com vários milhares de imagens.

Você pode controlar o acesso ao seu conjunto de dados exigindo que os usuários compartilhem primeiro suas informações de contato. Consulte o guia Conjuntos de dados com controle de acesso para mais informações sobre como habilitar esse recurso no Hub.

ImageFolder

O ImageFolder é um construtor de dataset projetado para carregar rapidamente um conjunto de dados de imagens com vários milhares de imagens, sem exigir que você escreva qualquer código.

💡 Dê uma olhada na hierarquia de padrões de divisão para saber mais sobre como o ImageFolder cria as divisões do conjunto de dados com base na estrutura do repositório do seu conjunto de dados.

ImageFolder infere automaticamente os rótulos de classe do seu conjunto de dados com base no nome do diretório. Armazene seu conjunto de dados em uma estrutura de diretórios 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

Se o conjunto de dados seguir a estrutura ImageFolder, você pode carregá-lo diretamente com load_dataset():

>>> from datasets import load_dataset

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

Isso é equivalente a passar imagefolder manualmente em load_dataset() e o diretório em data_dir:

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

Você também pode usar imagefolder para carregar conjuntos de dados que envolvem múltiplos splits. Para isso, o diretório do seu conjunto de dados deve ter a seguinte estrutura:

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

Se todos os arquivos de imagem estiverem em um único diretório ou se não estiverem no mesmo nível da estrutura de diretórios, a coluna label não será adicionada automaticamente. Se você precisar dela, defina drop_labels=False explicitamente.

Se houver informações adicionais que você deseja incluir sobre seu conjunto de dados, como legendas de texto ou caixas delimitadoras, adicione-as como um arquivo metadata.csv na sua pasta. Isso permite criar rapidamente conjuntos de dados para diferentes tarefas de visão computacional, como legendagem de texto ou detecção de objetos. Você também pode usar um arquivo JSONL metadata.jsonl ou um arquivo Parquet metadata.parquet.

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

Você também pode compactar suas imagens em um arquivo zip, e, nesse caso, cada arquivo zip deve conter tanto as imagens quanto os metadados

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

O arquivo metadata.csv deve ter um campo file_name ou *_file_name que vincule os arquivos de imagem aos seus metadados:

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

Aqui, o file_name deve ser o nome do arquivo de imagem ao lado do arquivo de metadados. Mais geralmente, deve ser o caminho relativo do diretório que contém os metadados até o arquivo de imagem.

É possível apontar para mais de uma imagem em cada linha do seu conjunto de dados, por exemplo, se tanto a sua entrada quanto a sua saída forem imagens:

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

Você também pode definir listas de imagens. Nesse caso, é necessário nomear o campo file_names ou *_file_names. Aqui está um exemplo:

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

Legendação de imagens

Os conjuntos de dados de legendas de imagens possuem texto descrevendo uma imagem. Um exemplo de metadata.csv pode ser:

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

Carregue o conjunto de dados com ImageFolder e ele criará uma coluna text para as legendas das imagens:

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

Detecção de objetos

Os conjuntos de dados de detecção de objetos possuem caixas delimitadoras e categorias que identificam os objetos em uma imagem. Um exemplo de metadata.jsonl pode ser:

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

Carregue o conjunto de dados com ImageFolder e ele criará uma coluna objects com as caixas delimitadoras e as categorias:

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

Enviar o conjunto de dados para o Hub

Depois de criar um conjunto de dados, você pode compartilhá-lo no Hub com o método push_to_hub(). Certifique-se de que a biblioteca huggingface_hub está instalada e de que você está logado na sua conta do Hugging Face (veja o tutorial de upload com Python para mais detalhes).

Envie seu conjunto de dados com 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

O formato WebDataset é baseado em arquivos TAR e é adequado para grandes conjuntos de dados de imagens. De fato, você pode agrupar suas imagens em arquivos TAR (por exemplo, 1 GB de imagens por arquivo TAR) e ter milhares de arquivos TAR:

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

Nos arquivos, cada exemplo é composto por arquivos que compartilham o mesmo prefixo:

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

Você pode inserir os rótulos/legendas/caixas delimitadoras das suas imagens usando, por exemplo, arquivos JSON ou de texto.

Carregue seu WebDataset e ele criará uma coluna para cada sufixo de arquivo (aqui, “jpg” e “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]}

Também é possível ter várias imagens por exemplo, como este:

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

Para mais detalhes sobre o formato WebDataset e a biblioteca python, consulte a documentação do WebDataset.

Lance

Lance é um formato de tabela de lakehouse multimodal aberto. As tabelas Lance podem armazenar nativamente não apenas texto e valores escalares, mas também objetos binários grandes (blobs), como imagens, áudio e vídeo, junto com seus dados tabulares.

A partir de arquivos de imagem no disco e dos metadados associados (por exemplo, legendas e dimensões), você pode gravar um dataset Lance autossuficiente em um diretório local *.lance. A tabela resultante pode armazenar suas colunas de metadados junto a uma coluna image contendo os bytes da imagem codificada.

Por exemplo, você pode começar com metadados 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}

Você pode definir um esquema pyarrow para seus metadados e bytes de imagem, construir uma tabela e gravá-la como um dataset 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",
)

Aqui está uma visão representativa de como seria uma tabela Lance que armazena imagens (a coluna image contém 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"   |
+-----------------------------------------------+--------+-------+-----+------------------------------+

Usando essa abordagem, você pode armazenar conjuntos de dados de imagens de tamanho arbitrário no Lance. O diretório resultante images.lance/ com seus arquivos *.lance pode ser enviado ao Hugging Face Hub, assim como nos outros exemplos acima. Veja o conjunto de dados lance-format/laion-1m no Hub para um exemplo de um conjunto de dados de imagens em Lance.

Para mais detalhes sobre o trabalho com conjuntos de dados Lance, consulte a documentação do Lance.