# Carregar dados de imagem

Os conjuntos de dados de imagens possuem colunas do tipo [Image](/docs/datasets/main/pt/package_reference/main_classes#datasets.Image), que contêm objetos PIL.

> [!TIP]
> Para trabalhar com conjuntos de dados de imagens, você precisa ter a dependência `vision` instalada. Consulte o guia de [instalação](./installation#vision) para aprender como instalá-la.

Ao carregar um conjunto de dados de imagens e chamar a coluna de imagens, as imagens são decodificadas como Imagens PIL:

```py
>>> from datasets import load_dataset, Image

>>> dataset = load_dataset("AI-Lab-Makerere/beans", split="train")
>>> dataset[0]["image"]
```

> [!WARNING]
> Acesse um conjunto de dados de imagens usando primeiro o índice da linha e, em seguida, a coluna `image` - `dataset[0]["image"]` - para evitar decodificar e reamostrar todos os objetos de imagem no conjunto de dados. Caso contrário, isso pode ser um processo lento e demorado se você tiver um conjunto de dados grande.

Para um guia sobre como carregar qualquer tipo de conjunto de dados, consulte o guia de carregamento geral.

## Arquivos locais

Você pode carregar um conjunto de dados a partir do caminho da imagem. Use a função [cast_column()](/docs/datasets/main/pt/package_reference/main_classes#datasets.Dataset.cast_column) para aceitar uma coluna de caminhos de arquivos de imagem e decodificá-la em uma imagem PIL com o recurso [Image](/docs/datasets/main/pt/package_reference/main_classes#datasets.Image):
```py
>>> from datasets import Dataset, Image

>>> dataset = Dataset.from_dict({"image": ["path/to/image_1", "path/to/image_2", ..., "path/to/image_n"]}).cast_column("image", Image())
>>> dataset[0]["image"]
<PIL.PngImagePlugin.PngImageFile image mode=RGBA size=1200x215 at 0x15E6D7160>]
```

Se você deseja apenas carregar o caminho subjacente do conjunto de dados de imagens sem decodificar o objeto de imagem, defina `decode=False` no recurso [Image](/docs/datasets/main/pt/package_reference/main_classes#datasets.Image):

```py
>>> dataset = load_dataset("AI-Lab-Makerere/beans", split="train").cast_column("image", Image(decode=False))
>>> dataset[0]["image"]
{'bytes': None,
 'path': '/root/.cache/huggingface/datasets/downloads/extracted/b0a21163f78769a2cf11f58dfc767fb458fc7cea5c05dccc0144a2c0f0bc1292/train/bean_rust/bean_rust_train.29.jpg'}
```

## ImageFolder

Você também pode carregar um conjunto de dados com um construtor de conjunto de dados `ImageFolder`, que não exige a criação de um dataloader personalizado. Isso torna o `ImageFolder` ideal para criar e carregar rapidamente conjuntos de dados de imagem com vários milhares de imagens para diferentes tarefas de visão computacional. A estrutura do seu conjunto de dados de imagem deve ser assim:

```
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
```

Alternativamente, ele deve ter metadados, por exemplo:

```
folder/train/metadata.csv
folder/train/0001.png
folder/train/0002.png
folder/train/0003.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("username/dataset_name")
>>> # OR locally:
>>> dataset = load_dataset("/path/to/folder")
```

Para conjuntos de dados locais, 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")
```

Em seguida, você pode acessar os vídeos como objetos `PIL.Image`:

```
>>> dataset["train"][0]
{"image": <PIL.PngImagePlugin.PngImageFile image mode=RGBA size=1200x215 at 0x15E6D7160>, "label": 0}

>>> dataset["train"][-1]
{"image": <PIL.PngImagePlugin.PngImageFile image mode=RGBA size=1200x215 at 0x15E8DAD30>, "label": 1}
```

Para ignorar as informações no arquivo de metadados, defina `drop_metadata=True` em [load_dataset()](/docs/datasets/main/pt/package_reference/loading_methods#datasets.load_dataset):

```py
>>> from datasets import load_dataset

>>> dataset = load_dataset("username/dataset_with_metadata", drop_metadata=True)
```

Se você não tiver um arquivo de metadados, o `ImageFolder` infere automaticamente o nome do rótulo a partir do nome do diretório. Se você quiser descartar os rótulos criados automaticamente, defina `drop_labels=True`. Nesse caso, seu conjunto de dados conterá apenas uma coluna de imagem:

```py
>>> from datasets import load_dataset

>>> dataset = load_dataset("username/dataset_without_metadata", drop_labels=True)
```

Por fim, o argumento `filters` permite carregar apenas um subconjunto do conjunto de dados, com base em uma condição sobre o rótulo ou os metadados. Isso é especialmente útil se os metadados estiverem em formato Parquet, pois esse formato permite filtragem rápida. Também é recomendado usar este argumento com `streaming=True`, porque, por padrão, o conjunto de dados é totalmente baixado antes da filtragem.

```python
>>> filters = [("label", "=", 0)]
>>> dataset = load_dataset("username/dataset_name", streaming=True, filters=filters)
```

> [!TIP]
> Para mais informações sobre a criação do seu próprio conjunto de dados `ImageFolder`, consulte o guia [Criar um conjunto de dados de imagens](./image_dataset).

## WebDataset

O formato [WebDataset](https://github.com/webdataset/webdataset) é baseado em uma pasta de arquivos TAR e é adequado para grandes conjuntos de dados de imagens. Devido ao seu tamanho, os WebDatasets geralmente são carregados em modo de streaming (usando `streaming=True`).

Você pode carregar um WebDataset da seguinte forma:

```python
>>> from datasets import load_dataset

>>> dataset = load_dataset("webdataset", data_dir="/path/to/folder", streaming=True)
```

## 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.

O Lance mantém seus metadados e blobs de imagem juntos em um único local, ao mesmo tempo em que permite escanear eficientemente apenas as colunas de metadados que você se importa, sem carregar os bytes da imagem. Quando estiver pronto, você pode buscar um pequeno subconjunto de linhas (incluindo os blobs de imagem) e gravá-los diretamente em arquivos no seu sistema de arquivos local.

```python
from datasets import load_dataset

# Return as a Hugging Face dataset
ds = load_dataset(
    "lance-format/laion-1m",
    split="train",
    streaming=True
)

dir_name = "laion_samples"
Path(dir_name).mkdir(exist_ok=True)

for idx, row in enumerate(ds.take(3)):
    with open(f"{dir_name}/{idx}.jpg", "wb") as f:
        f.write(row["image"])
```

Neste exemplo, a coluna `image` contém os bytes da imagem codificados, então você pode gravá-los diretamente em arquivos `.jpg`.

> [!NOTE] A API do `datasets` não empurra operações para a tabela Lance no momento, então pode ser lenta para conjuntos de dados maiores. Por enquanto, você terá muito melhor desempenho usando o pacote Python `lance` diretamente. Consulte a documentação em [the Hub](https://huggingface.co/docs/datasets-lance) para exemplos de uso.

## Decodificação de imagem

Por padrão, as imagens são decodificadas sequencialmente como `PIL.Images` ao iterar sobre um conjunto de dados. No entanto, é possível acelerar significativamente o conjunto de dados usando decodificação multithreaded:

```python
>>> import os
>>> num_threads = num_threads = min(32, (os.cpu_count() or 1) + 4)
>>> dataset = dataset.decode(num_threads=num_threads)
>>> for example in dataset:  # up to 20 times faster !
...     ...
```

Você pode habilitar a multithreading usando `num_threads`. Isso é especialmente útil para acelerar o streaming de dados remotos. No entanto, pode ser mais lento que `num_threads=0` para dados locais em discos rápidos.

Se você não se interessa pelas imagens decodificadas como `PIL.Images` e deseja acessar o caminho/bytes em vez disso, você pode desabilitar a decodificação:

```python
>>> dataset = dataset.decode(False)
```

Observação: [IterableDataset.decode()](/docs/datasets/main/pt/package_reference/main_classes#datasets.IterableDataset.decode) está disponível apenas para datasets em streaming no momento.

