# 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()](/docs/datasets/main/pt/package_reference/main_classes#datasets.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. > [!TIP] > 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](https://huggingface.co/docs/hub/datasets-gated) 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. > [!TIP] > 💡 Dê uma olhada na [hierarquia de padrões de divisão](repository_structure#split-pattern-hierarchy) 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()](/docs/datasets/main/pt/package_reference/loading_methods#datasets.load_dataset): ```py >>> from datasets import load_dataset >>> dataset = load_dataset("path/to/folder") ``` Isso é equivalente a passar `imagefolder` manualmente em [load_dataset()](/docs/datasets/main/pt/package_reference/loading_methods#datasets.load_dataset) e o diretório em `data_dir`: ```py >>> 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 ``` > [!WARNING] > 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: ```csv 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`: ```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: ```jsonl {"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: ```jsonl {"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: ```csv 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: ```py >>> 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: ```jsonl {"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: ```py >>> 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()](/docs/datasets/main/pt/package_reference/main_classes#datasets.DatasetDict.push_to_hub). Certifique-se de que a biblioteca [huggingface_hub](https://huggingface.co/docs/huggingface_hub/index) está instalada e de que você está conectado à sua conta do Hugging Face (veja o [tutorial de upload com Python](upload_dataset#upload-with-python) para mais detalhes). Envie seu conjunto de dados com [push_to_hub()](/docs/datasets/main/pt/package_reference/main_classes#datasets.DatasetDict.push_to_hub): ```py >>> 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](https://github.com/webdataset/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"): ```python >>> 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](https://webdataset.github.io/webdataset). ## Lance [Lance](https://lance.org) é 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: ```text {'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: ```python 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): ```text +-----------------------------------------------+--------+-------+-----+------------------------------+ | 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](https://huggingface.co/datasets/lance-format/laion-1m) 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](https://lance.org).