# Classes de construtor

## Criadores[[datasets.DatasetBuilder]]

🤗 O Datasets depende de duas classes principais durante o processo de construção do dataset: [DatasetBuilder](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.DatasetBuilder) e [BuilderConfig](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.BuilderConfig).

#### datasets.DatasetBuilder[[datasets.DatasetBuilder]]

```python
datasets.DatasetBuilder(cache_dir: typing.Optional[str] = None, dataset_name: typing.Optional[str] = None, config_name: typing.Optional[str] = None, hash: typing.Optional[str] = None, base_path: typing.Optional[str] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, features: typing.Optional[datasets.features.features.Features] = None, token: typing.Union[bool, str, NoneType] = None, repo_id: typing.Optional[str] = None, data_files: typing.Union[str, list, dict, datasets.data_files.DataFilesDict, NoneType] = None, data_dir: typing.Optional[str] = None, storage_options: typing.Optional[dict] = None, writer_batch_size: typing.Optional[int] = None, config_id: typing.Optional[str] = None, **config_kwargs)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/builder.py#L214)

**Parâmetros:**

cache_dir (`str`, *opcional*) : Diretório para armazenar dados em cache. O padrão é `"~/.cache/huggingface/datasets"`.

dataset_name (`str`, *opcional*) : Nome do conjunto de dados, se for diferente do nome do builder. Útil para builders empacotados, como csv, imagefolder, audiofolder, etc., para refletir a diferença entre conjuntos de dados que usam o mesmo builder empacotado.

config_name (`str`, *opcional*) : Nome da configuração do conjunto de dados. Afeta os dados gerados no disco. Diferentes configurações terão seus próprios subdiretórios e versões. Se não for fornecido, a configuração padrão será usada (se existir).    O parâmetro `name` foi renomeado para `config_name`.

hash (`str`, *opcional*) : Hash específico para o código do construtor do dataset. Usado para atualizar o diretório de cache quando o código do construtor do dataset é atualizado (para evitar a reutilização de dados antigos). O diretório de cache típico (definido em `self._relative_data_dir`) é `name/version/hash/`.

base_path (`str`, *opcional*) : Caminho base para caminhos relativos usados para baixar arquivos. Isso pode ser uma URL remota.

features ([Features](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features), *opcional*) : Tipos de Features a serem usados com este conjunto de dados. Pode ser usado, por exemplo, para alterar os tipos de [Features](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features) de um conjunto de dados.

token (`str` ou `bool`, *opcional*) : String ou booleano para usar como token Bearer para arquivos remotos no Datasets Hub. Se `True`, o token será obtido de `"~/.huggingface"`.

repo_id (`str`, *opcional*) : ID do repositório do conjunto de dados. Usado para distinguir construtores com o mesmo nome, mas que não pertencem ao mesmo namespace, por exemplo, os IDs dos repositórios "rajpurkar/squad" e "lhoestq/squad". No segundo caso, o nome do construtor seria "lhoestq___squad".

data_files (`str` ou `Sequence` ou `Mapping`, *opcional*) : Caminho(s) para o(s) arquivo(s) de dados de origem. Para builders como "csv" ou "json" que exigem que o usuário especifique os arquivos de dados. Podem ser arquivos locais ou remotos. Para conveniência, você pode usar um `DataFilesDict`.

data_dir (`str`, *opcional*) : Caminho para o diretório contendo o(s) arquivo(s) de dados de origem. Use apenas se `data_files` não for passado, caso em que é equivalente a passar `os.path.join(data_dir, "**")` como `data_files`. Para builders que exigem download manual, deve ser o caminho para o diretório local contendo os dados baixados manualmente.

storage_options (`dict`, *opcional*) : Pares de chave/valor a serem passados para o backend de sistema de arquivos do dataset, se houver.

writer_batch_size (`int`, *opcional*) : Tamanho do lote usado pelo ArrowWriter. Ele define o número de amostras mantidas em memória antes de serem gravadas e também o comprimento dos blocos arrow. None significa que o ArrowWriter usará seu valor padrão.

- ****config_kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave a serem passados para a classe de configuração do builder correspondente, definida no atributo de classe [DatasetBuilder.BUILDER_CONFIG_CLASS](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.BuilderConfig). A classe de configuração do builder é [BuilderConfig](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.BuilderConfig) ou uma subclasse dela.

Classe base abstrata para todos os conjuntos de dados.

`DatasetBuilder` tem 3 métodos principais:

- `DatasetBuilder.info`: Documenta o conjunto de dados, incluindo nomes, tipos, formas, versão, divisões, citação, etc.
- [DatasetBuilder.download_and_prepare()](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.DatasetBuilder.download_and_prepare): Baixa os dados de origem e os grava no disco.
- [DatasetBuilder.as_dataset()](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.DatasetBuilder.as_dataset): Gera um [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset).

Alguns `DatasetBuilder`s expõem múltiplas variantes do dataset ao definir uma subclasse de [BuilderConfig](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.BuilderConfig) e aceitar um objeto de configuração (ou nome) na construção. Datasets configuráveis expõem um conjunto predefinido de configurações em `DatasetBuilder.builder_configs()`.

#### as_dataset[[datasets.DatasetBuilder.as_dataset]]

```python
as_dataset(split: typing.Union[str, datasets.splits.Split, list[str], list[datasets.splits.Split], NoneType] = None, in_memory = False)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/builder.py#L991)

**Parâmetros:**

split (`datasets.Split`) : Qual subconjunto dos dados deve ser retornado.

verification_mode ([VerificationMode](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.VerificationMode) ou `str`, padrão `BASIC_CHECKS`) : Modo de verificação que determina as verificações a serem executadas nas informações do dataset baixado/processado (checksums/tamanho/splits/...).

in_memory (`bool`, padrão `False`) : Se deve copiar os dados na memória.

**Retorna:**

datasets.Dataset

Retorne um Dataset para o split especificado.

Exemplo:

```py
>>> from datasets import load_dataset_builder
>>> builder = load_dataset_builder('cornell-movie-review-data/rotten_tomatoes')
>>> builder.download_and_prepare()
>>> ds = builder.as_dataset(split='train')
>>> ds
Dataset({
    features: ['text', 'label'],
    num_rows: 8530
})
```

#### download_and_prepare[[datasets.DatasetBuilder.download_and_prepare]]

```python
download_and_prepare(output_dir: typing.Optional[str] = None, download_config: typing.Optional[datasets.download.download_config.DownloadConfig] = None, download_mode: typing.Union[datasets.download.download_manager.DownloadMode, str, NoneType] = None, verification_mode: typing.Union[datasets.utils.info_utils.VerificationMode, str, NoneType] = None, dl_manager: typing.Optional[datasets.download.download_manager.DownloadManager] = None, base_path: typing.Optional[str] = None, file_format: str = 'arrow', max_shard_size: typing.Union[str, int, NoneType] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **download_and_prepare_kwargs)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/builder.py#L702)

**Parâmetros:**

output_dir (`str`, *opcional*) : Diretório de saída para o conjunto de dados. O padrão é o `cache_dir` deste builder, que por padrão fica dentro de `~/.cache/huggingface/datasets`.

download_config (`DownloadConfig`, *opcional*) : Parâmetros específicos de configuração de download.

download_mode ([DownloadMode](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.DownloadMode) ou `str`, *opcional*) : Selecione o modo de download/geração, padrão é `REUSE_DATASET_IF_EXISTS`.

verification_mode ([VerificationMode](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.VerificationMode) ou `str`, padrão `BASIC_CHECKS`) : Modo de verificação que determina as verificações a serem executadas nas informações do dataset baixado/processado (checksums/tamanho/splits/...).

dl_manager (`DownloadManager`, *opcional*) : `DownloadManger` específico a ser usado.

base_path (`str`, *opcional*) : Caminho base para caminhos relativos usados para baixar arquivos. Isso pode ser uma URL remota. Se não for especificado, o valor do atributo `base_path` (`self.base_path`) será usado em vez disso.

file_format (`str`, *opcional*) : Formato dos arquivos de dados nos quais o conjunto de dados será gravado. Formatos suportados: "arrow", "parquet". O padrão é o formato "arrow". Se o formato for "parquet", os dados de imagem e áudio serão incorporados nos arquivos Parquet em vez de apontar para arquivos locais.

max_shard_size (`Union[str, int]`, *opcional*) : Número máximo de bytes gravados por shard, o padrão é "500MB". O tamanho é baseado no tamanho dos dados descomprimidos, portanto, na prática, seus arquivos de shard podem ser menores que `max_shard_size` graças, por exemplo, à compressão Parquet.

num_proc (`int`, *opcional*, padrão `None`) : Número de processos ao baixar e gerar o dataset localmente. O multiprocessing é desabilitado por padrão.

storage_options (`dict`, *opcional*) : Pares de chave/valor a serem passados para o backend do sistema de arquivos em cache, se houver.

- ****download_and_prepare_kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave.

Baixa e prepara o conjunto de dados para leitura.

Exemplo:

Baixe e prepare o conjunto de dados como arquivos Arrow que podem ser carregados como um Dataset usando `builder.as_dataset()`:

```py
>>> from datasets import load_dataset_builder
>>> builder = load_dataset_builder("cornell-movie-review-data/rotten_tomatoes")
>>> builder.download_and_prepare()
```

Baixe e prepare o conjunto de dados como arquivos Parquet segmentados localmente:

```py
>>> from datasets import load_dataset_builder
>>> builder = load_dataset_builder("cornell-movie-review-data/rotten_tomatoes")
>>> builder.download_and_prepare("./output_dir", file_format="parquet")
```

Baixe e prepare o conjunto de dados como arquivos Parquet segmentados em um armazenamento em nuvem:

```py
>>> from datasets import load_dataset_builder
>>> storage_options = {"key": aws_access_key_id, "secret": aws_secret_access_key}
>>> builder = load_dataset_builder("cornell-movie-review-data/rotten_tomatoes")
>>> builder.download_and_prepare("s3://my-bucket/my_rotten_tomatoes", storage_options=storage_options, file_format="parquet")
```

#### get_imported_module_dir[[datasets.DatasetBuilder.get_imported_module_dir]]

```python
get_imported_module_dir()
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/builder.py#L694)

Retorna o caminho do módulo desta classe ou subclasse.

#### datasets.GeneratorBasedBuilder[[datasets.GeneratorBasedBuilder]]

```python
datasets.GeneratorBasedBuilder(cache_dir: typing.Optional[str] = None, dataset_name: typing.Optional[str] = None, config_name: typing.Optional[str] = None, hash: typing.Optional[str] = None, base_path: typing.Optional[str] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, features: typing.Optional[datasets.features.features.Features] = None, token: typing.Union[bool, str, NoneType] = None, repo_id: typing.Optional[str] = None, data_files: typing.Union[str, list, dict, datasets.data_files.DataFilesDict, NoneType] = None, data_dir: typing.Optional[str] = None, storage_options: typing.Optional[dict] = None, writer_batch_size: typing.Optional[int] = None, config_id: typing.Optional[str] = None, **config_kwargs)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/builder.py#L1292)

Classe base para conjuntos de dados com geração de dados baseada em geradores de dicionário.

`GeneratorBasedBuilder` é uma classe de conveniência que abstrai grande parte da escrita e leitura de dados de `DatasetBuilder`. Ela espera que as subclasses implementem geradores de dicionários de recursos para as divisões do conjunto de dados (`_split_generators`). Consulte as docstrings dos métodos para mais detalhes.

#### datasets.ArrowBasedBuilder[[datasets.ArrowBasedBuilder]]

```python
datasets.ArrowBasedBuilder(cache_dir: typing.Optional[str] = None, dataset_name: typing.Optional[str] = None, config_name: typing.Optional[str] = None, hash: typing.Optional[str] = None, base_path: typing.Optional[str] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, features: typing.Optional[datasets.features.features.Features] = None, token: typing.Union[bool, str, NoneType] = None, repo_id: typing.Optional[str] = None, data_files: typing.Union[str, list, dict, datasets.data_files.DataFilesDict, NoneType] = None, data_dir: typing.Optional[str] = None, storage_options: typing.Optional[dict] = None, writer_batch_size: typing.Optional[int] = None, config_id: typing.Optional[str] = None, **config_kwargs)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/builder.py#L1610)

Classe base para conjuntos de dados com geração de dados baseada em funções de carregamento do Arrow (CSV/JSON/Parquet).

#### datasets.BuilderConfig[[datasets.BuilderConfig]]

```python
datasets.BuilderConfig(name: str = 'default', version: typing.Union[datasets.utils.version.Version, str, NoneType] = 0.0.0, data_dir: typing.Optional[str] = None, data_files: typing.Union[datasets.data_files.DataFilesDict, datasets.data_files.DataFilesPatternsDict, NoneType] = None, description: typing.Optional[str] = None)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/builder.py#L101)

**Parâmetros:**

name (`str`, padrão é `default`) : O nome da configuração.

version (`Version` ou `str`, padrão `0.0.0`) : A versão da configuração.

data_dir (`str`, *opcional*) : Caminho para o diretório que contém os dados de origem.

data_files (`str` ou `Sequence` ou `Mapping`, *opcional*) : Caminho(s) para o(s) arquivo(s) de dados de origem.

description (`str`, *opcional*) : Uma descrição em linguagem natural da configuração.

Classe base para a configuração de dados do `DatasetBuilder`.

Subclasses de `DatasetBuilder` com opções de configuração de dados devem subclassar `BuilderConfig` e adicionar suas próprias propriedades.

#### create_config_id[[datasets.BuilderConfig.create_config_id]]

```python
create_config_id(config_kwargs: dict, custom_features: typing.Optional[datasets.features.features.Features] = None)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/builder.py#L144)

O id da config é usado para construir o diretório de cache. Por padrão, ele é igual ao nome da config. No entanto, o nome de uma config não é suficiente para ter um identificador único para o conjunto de dados sendo gerado, pois ele não leva em consideração:
- os kwargs de configuração que podem ser usados para sobrescrever atributos
- os recursos personalizados usados para escrever o conjunto de dados
- os data_files para conjuntos de dados json/texto/csv/pandas

Portanto, o id da config é apenas o nome da config com um sufixo opcional baseado nesses.

## Download[[datasets.DownloadManager]]

#### datasets.DownloadManager[[datasets.DownloadManager]]

```python
datasets.DownloadManager(dataset_name: typing.Optional[str] = None, data_dir: typing.Optional[str] = None, download_config: typing.Optional[datasets.download.download_config.DownloadConfig] = None, base_path: typing.Optional[str] = None, record_checksums = False)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/download_manager.py#L71)

#### download[[datasets.DownloadManager.download]]

```python
download(url_or_urls)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/download_manager.py#L131)

**Parâmetros:**

url_or_urls (`str` ou `list` ou `dict`) : URL ou `list` ou `dict` de URLs para download. Cada URL é um `str`.

**Retorna:** `str` ou `list` ou `dict`

Os caminhos baixados que correspondem à entrada `url_or_urls` fornecida.

Baixe o(s) URL(s) fornecido(s).

Por padrão, apenas um processo é usado para o download. Passe um `download_config.num_proc` personalizado para alterar esse comportamento.

Exemplo:

```py
>>> downloaded_files = dl_manager.download('https://storage.googleapis.com/seldon-datasets/sentence_polarity_v1/rt-polaritydata.tar.gz')
```

#### download_and_extract[[datasets.DownloadManager.download_and_extract]]

```python
download_and_extract(url_or_urls)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/download_manager.py#L310)

**Parâmetros:**

url_or_urls (`str` ou `list` ou `dict`) : URL ou `list` ou `dict` de URLs para baixar e extrair. Cada URL é um `str`.

**Retorna:** `extracted_path(s)`

`str`, caminhos extraídos das URL(s) fornecidas.

Baixe e extraia o(s) `url_or_urls` fornecido(s).

É aproximadamente equivalente a:

```
extracted_paths = dl_manager.extract(dl_manager.download(url_or_urls))
```

#### extract[[datasets.DownloadManager.extract]]

```python
extract(path_or_paths)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/download_manager.py#L278)

**Parâmetros:**

path_or_paths (caminho ou `list` ou `dict`) : Caminho do arquivo a ser extraído. Cada caminho é um `str`.

**Retorna:** `extracted_path(s)`

`str`, Os caminhos extraídos que correspondem ao caminho de entrada path_or_paths fornecido.

Extrai o(s) caminho(s) dado(s).

Exemplo:

```py
>>> downloaded_files = dl_manager.download('https://storage.googleapis.com/seldon-datasets/sentence_polarity_v1/rt-polaritydata.tar.gz')
>>> extracted_files = dl_manager.extract(downloaded_files)
```

#### iter_archive[[datasets.DownloadManager.iter_archive]]

```python
iter_archive(path_or_buf: typing.Union[str, _io.BufferedReader])
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/download_manager.py#L234)

**Parâmetros:**

path_or_buf (`str` ou `io.BufferedReader`) : Caminho do arquivo de arquivo ou objeto de arquivo binário de arquivo.

**Retorna:** `tuple[str, io.BufferedReader]`

2-tupla (path_within_archive, file_object). O objeto de arquivo é aberto em modo binário.

Iterar sobre os arquivos dentro de um arquivo compactado.

Exemplo:

```py
>>> archive = dl_manager.download('https://storage.googleapis.com/seldon-datasets/sentence_polarity_v1/rt-polaritydata.tar.gz')
>>> files = dl_manager.iter_archive(archive)
```

#### iter_files[[datasets.DownloadManager.iter_files]]

```python
iter_files(paths: typing.Union[str, list[str]])
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/download_manager.py#L259)

**Parâmetros:**

paths (`str` ou `list` de `str`) : Caminhos raiz.

**Retorna:** `str`

Caminho do arquivo.

Iterar sobre os caminhos dos arquivos.

Exemplo:

```py
>>> files = dl_manager.download_and_extract('https://huggingface.co/datasets/AI-Lab-Makerere/beans/resolve/main/data/train.zip')
>>> files = dl_manager.iter_files(files)
```

#### datasets.StreamingDownloadManager[[datasets.StreamingDownloadManager]]

```python
datasets.StreamingDownloadManager(dataset_name: typing.Optional[str] = None, data_dir: typing.Optional[str] = None, download_config: typing.Optional[datasets.download.download_config.DownloadConfig] = None, base_path: typing.Optional[str] = None)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/streaming_download_manager.py#L47)

Gerenciador de download que usa o separador "::" para navegar por arquivos compactados (possivelmente remotos). Diferentemente do `DownloadManager` regular, os métodos `download` e `extract` não baixam nem extraem dados de fato, mas retornam o caminho ou a URL que pode ser aberto usando a função `xopen`, que estende a função embutida `open` para transmitir dados de arquivos remotos.

#### download[[datasets.StreamingDownloadManager.download]]

```python
download(url_or_urls)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/streaming_download_manager.py#L75)

**Parâmetros:**

url_or_urls (`str` ou `list` ou `dict`) : URL(s) de arquivos para transmitir dados. Cada url é um `str`.

**Retorna:** `url(s)`

(`str` ou `list` ou `dict`), URL(s) para transmitir dados correspondentes à(s) url_or_urls de entrada fornecida(s).

Normaliza a URL ou as URLs dos arquivos de onde os dados serão transmitidos. Esta é a versão preguiçosa de `DownloadManager.download` para streaming.

Exemplo:

```py
>>> downloaded_files = dl_manager.download('https://storage.googleapis.com/seldon-datasets/sentence_polarity_v1/rt-polaritydata.tar.gz')
```

#### download_and_extract[[datasets.StreamingDownloadManager.download_and_extract]]

```python
download_and_extract(url_or_urls)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/streaming_download_manager.py#L151)

**Parâmetros:**

url_or_urls (`str` ou `list` ou `dict`) : URL(s) para transmitir dados. Cada url é um `str`.

**Retorna:** `url(s)`

(`str` ou `list` ou `dict`), URL(s) para transmitir dados correspondentes à entrada `url_or_urls` fornecida.

Prepara o `url_or_urls` fornecido para streaming (adiciona o protocolo de extração).

Esta é a versão preguiçosa de `DownloadManager.download_and_extract` para streaming.

É equivalente a:

```
urls = dl_manager.extract(dl_manager.download(url_or_urls))
```

#### extract[[datasets.StreamingDownloadManager.extract]]

```python
extract(url_or_urls)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/streaming_download_manager.py#L102)

**Parâmetros:**

url_or_urls (`str` ou `list` ou `dict`) : URL(s) de arquivos para transmitir dados. Cada url é um `str`.

**Retorna:** `url(s)`

(`str` ou `list` ou `dict`), URL(s) para transmitir dados correspondentes à entrada `url_or_urls` fornecida.

Adicione o protocolo de extração para a(s) URL(s) fornecida(s) para streaming.

Esta é a versão preguiçosa de `DownloadManager.extract` para streaming.

Exemplo:

```py
>>> downloaded_files = dl_manager.download('https://storage.googleapis.com/seldon-datasets/sentence_polarity_v1/rt-polaritydata.tar.gz')
>>> extracted_files = dl_manager.extract(downloaded_files)
```

#### iter_archive[[datasets.StreamingDownloadManager.iter_archive]]

```python
iter_archive(urlpath_or_buf: typing.Union[str, _io.BufferedReader])
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/streaming_download_manager.py#L171)

**Parâmetros:**

urlpath_or_buf (`str` ou `io.BufferedReader`) : Caminho do arquivo de arquivo ou objeto de arquivo binário de arquivo.

**Retorna:** `tuple[str, io.BufferedReader]`

2-tupla (path_within_archive, file_object). O objeto de arquivo é aberto em modo binário.

Iterar sobre os arquivos dentro de um arquivo compactado.

Exemplo:

```py
>>> archive = dl_manager.download('https://storage.googleapis.com/seldon-datasets/sentence_polarity_v1/rt-polaritydata.tar.gz')
>>> files = dl_manager.iter_archive(archive)
```

#### iter_files[[datasets.StreamingDownloadManager.iter_files]]

```python
iter_files(urlpaths: typing.Union[str, list[str]])
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/streaming_download_manager.py#L196)

**Parâmetros:**

urlpaths (`str` ou `list` de `str`) : Caminhos raiz.

**Retorna:** `str`

Caminho da URL do arquivo.

Iterar sobre os arquivos.

Exemplo:

```py
>>> files = dl_manager.download_and_extract('https://huggingface.co/datasets/AI-Lab-Makerere/beans/resolve/main/data/train.zip')
>>> files = dl_manager.iter_files(files)
```

#### datasets.DownloadConfig[[datasets.DownloadConfig]]

```python
datasets.DownloadConfig(cache_dir: typing.Union[str, pathlib.Path, NoneType] = None, force_download: bool = False, resume_download: bool = False, local_files_only: bool = False, proxies: typing.Optional[dict] = None, user_agent: typing.Optional[str] = None, extract_compressed_file: bool = False, force_extract: bool = False, delete_extracted: bool = False, extract_on_the_fly: bool = False, use_etag: bool = True, num_proc: typing.Optional[int] = None, max_retries: int = 1, token: typing.Union[str, bool, NoneType] = None, storage_options: dict = <factory>, download_desc: typing.Optional[str] = None, disable_tqdm: bool = False)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/download_config.py#L10)

**Parâmetros:**

cache_dir (`str` ou `Path`, *opcional*) : Especifique um diretório de cache para salvar o arquivo (sobrescreve o diretório de cache padrão).

force_download (`bool`, padrão `False`) : Se `True`, baixa o arquivo novamente, mesmo que ele já esteja em cache no diretório de cache.

resume_download (`bool`, padrão `False`) : Se `True`, retoma o download se um arquivo recebido de forma incompleta for encontrado.

proxies (`dict`, *opcional*) : Descontinuado e ignorado. Defina as variáveis de ambiente `HTTP_PROXY` / `HTTPS_PROXY` ou configure o cliente HTTP com [huggingface_hub.set_client_factory](https://huggingface.co/docs/huggingface_hub/v2.4.0/en/package_reference/utilities#huggingface_hub.set_client_factory) em vez disso.

user_agent (`str`, *opcional*) : String ou dicionário opcional que será adicionado ao user-agent em solicitações remotas.

extract_compressed_file (`bool`, padrão `False`) : Se `True` e o caminho apontar para um arquivo zip ou tar, extrai o arquivo compactado em uma pasta ao lado do arquivo compactado.

force_extract (`bool`, padrão `False`) : Se `True` quando `extract_compressed_file` é `True` e o arquivo compactado já foi extraído, extrai o arquivo novamente e substitui a pasta onde ele foi extraído.

delete_extracted (`bool`, padrão `False`) : Se deve excluir (ou manter) os arquivos extraídos.

extract_on_the_fly (`bool`, padrão `False`) : Se `True`, extrai os arquivos compactados enquanto estão sendo lidos.

use_etag (`bool`, padrão `True`) : Se deve usar o cabeçalho de resposta HTTP ETag para validar os arquivos em cache.

num_proc (`int`, *opcional*) : O número de processos a serem iniciados para baixar os arquivos em paralelo.

max_retries (`int`, padrão `1`) : O número de vezes para tentar novamente uma requisição HTTP caso ela falhe.

token (`str` ou `bool`, *opcional*) : String ou booleano opcional para usar como token Bearer para arquivos remotos no Datasets Hub. Se `True`, ou não especificado, obterá o token de `~/.huggingface`.

storage_options (`dict`, *opcional*) : Pares de chave/valor a serem passados para o backend de sistema de arquivos do dataset, se houver.

download_desc (`str`, *opcional*) : Uma descrição para ser exibida junto com a barra de progresso durante o download dos arquivos.

disable_tqdm (`bool`, padrão `False`) : Se deve desabilitar a barra de progresso de download dos arquivos individuais

Configuração para nosso gerenciador de caminhos em cache.

#### datasets.DownloadMode[[datasets.DownloadMode]]

```python
datasets.DownloadMode(value, names = None, module = None, qualname = None, type = None, start = 1)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/download/download_manager.py#L50)

`Enum` para definir como tratar downloads e dados existentes.

O modo padrão é `REUSE_DATASET_IF_EXISTS`, que reutiliza tanto os downloads brutos quanto o dataset preparado, caso existam.

Os modos de geração:

|                                     | Downloads | Conjunto de dados |
|-------------------------------------|-----------|---------|
| `REUSE_DATASET_IF_EXISTS` (padrão) | Reutilização     | Reutilização   |
| `REUSE_CACHE_IF_EXISTS`             | Reutilização     | Novo   |
| `FORCE_REDOWNLOAD`                  | Novo     | Novo   |

## Verificação[[datasets.VerificationMode]]

#### datasets.VerificationMode[[datasets.VerificationMode]]

```python
datasets.VerificationMode(value, names = None, module = None, qualname = None, type = None, start = 1)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/utils/info_utils.py#L22)

`Enum` que especifica quais verificações de verificação devem ser executadas.

O modo padrão é `BASIC_CHECKS`, que executa apenas verificações rudimentares para evitar lentidões ao gerar/baixar um dataset pela primeira vez.

Os modos de verificação:

|                           | Verificações                                                           |
|---------------------------|------------------------------------------------------------------------------ |
| `ALL_CHECKS`              | Verificação de integridade (número de arquivos, checksums) dos arquivos baixados    |
| `BASIC_CHECKS` (padrão)  | Igual a `ALL_CHECKS`, mas sem verificar os arquivos baixados                    |
| `NO_CHECKS`               | None                                                                          |

## Divisões[[datasets.SplitGenerator]]

#### datasets.SplitGenerator[[datasets.SplitGenerator]]

```python
datasets.SplitGenerator(name: str, gen_kwargs: dict = <factory>)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/splits.py#L624)

**Parâmetros:**

name (`str`) : Nome do `Split` para o qual o gerador criará os exemplos.

- ****gen_kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave para encaminhar ao método `DatasetBuilder._generate_examples` do builder.

Define as informações de divisão para o gerador.

Isso deve ser usado como valor de retorno de `GeneratorBasedBuilder._split_generators`. Consulte `GeneratorBasedBuilder._split_generators` para mais informações e um exemplo de uso.

Exemplo:

```py
>>> datasets.SplitGenerator(
...     name=datasets.Split.TRAIN,
...     gen_kwargs={"split_key": "train", "files": dl_manager.download_and_extract(url)},
... )
```

#### datasets.Split[[datasets.Split]]

```python
datasets.Split(name)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/splits.py#L417)

`Enum` para as divisões do conjunto de dados.

Os conjuntos de dados são tipicamente divididos em diferentes subconjuntos para serem usados em várias etapas de treinamento e avaliação.

- `TRAIN`: os dados de treinamento.
- `VALIDATION`: os dados de validação. Se presentes, são tipicamente usados como dados de avaliação durante a iteração em um modelo (por exemplo, ao alterar hiperparâmetros, arquitetura do modelo, etc.).
- `TEST`: os dados de teste. Este é o conjunto de dados sobre o qual as métricas são reportadas. Normalmente, você não deseja usá-lo durante a iteração do modelo, pois pode haver sobreajuste a ele.
- `ALL`: a união de todos os splits de dataset definidos.

Todos os splits, incluindo composições, herdam de `datasets.SplitBase`.

Consulte o [guia](../load_hub#splits) sobre splits para mais informações.

Exemplo:

```py
>>> datasets.SplitGenerator(
...     name=datasets.Split.TRAIN,
...     gen_kwargs={"split_key": "train", "files": dl_manager.download_and extract(url)},
... ),
... datasets.SplitGenerator(
...     name=datasets.Split.VALIDATION,
...     gen_kwargs={"split_key": "validation", "files": dl_manager.download_and extract(url)},
... ),
... datasets.SplitGenerator(
...     name=datasets.Split.TEST,
...     gen_kwargs={"split_key": "test", "files": dl_manager.download_and extract(url)},
... )
```

#### datasets.NamedSplit[[datasets.NamedSplit]]

```python
datasets.NamedSplit(name: str)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/splits.py#L325)

Descriptor correspondente a uma divisão nomeada (train, test, ...).

Exemplo:

Cada descritor pode ser composto com outros usando adição ou fatiamento:

```py
split = datasets.Split.TRAIN.subsplit(datasets.percent[0:25]) + datasets.Split.TEST
```

A divisão resultante corresponderá a 25% da divisão de treinamento mesclada com 100% da divisão de teste.

Não é possível adicionar uma divisão duas vezes, portanto o seguinte falhará:

```py
split = (
        datasets.Split.TRAIN.subsplit(datasets.percent[:25]) +
        datasets.Split.TRAIN.subsplit(datasets.percent[75:])
)  # Error
split = datasets.Split.TEST + datasets.Split.ALL  # Error
```

Os fatiamentos podem ser aplicados apenas uma vez. Portanto, os seguintes são válidos:

```py
split = (
        datasets.Split.TRAIN.subsplit(datasets.percent[:25]) +
        datasets.Split.TEST.subsplit(datasets.percent[:50])
)
split = (datasets.Split.TRAIN + datasets.Split.TEST).subsplit(datasets.percent[:50])
```

Mas isso não é válido:

```py
train = datasets.Split.TRAIN
test = datasets.Split.TEST
split = train.subsplit(datasets.percent[:25]).subsplit(datasets.percent[:25])
split = (train.subsplit(datasets.percent[:25]) + test).subsplit(datasets.percent[:50])
```

#### datasets.NamedSplitAll[[datasets.NamedSplitAll]]

```python
datasets.NamedSplitAll()
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/splits.py#L402)

Divisão correspondente à união de todas as divisões de conjunto de dados definidas.

#### datasets.ReadInstruction[[datasets.ReadInstruction]]

```python
datasets.ReadInstruction(split_name, rounding = None, from_ = None, to = None, unit = None)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_reader.py#L456)

Instrução de leitura para um conjunto de dados.

Exemplos:

```python
# The following lines are equivalent:
ds = datasets.load_dataset('ylecun/mnist', split='test[:33%]')
ds = datasets.load_dataset('ylecun/mnist', split=datasets.ReadInstruction.from_spec('test[:33%]'))
ds = datasets.load_dataset('ylecun/mnist', split=datasets.ReadInstruction('test', to=33, unit='%'))
ds = datasets.load_dataset('ylecun/mnist', split=datasets.ReadInstruction(
'test', from_=0, to=33, unit='%'))

# The following lines are equivalent:
ds = datasets.load_dataset('ylecun/mnist', split='test[:33%]+train[1:-1]')
ds = datasets.load_dataset('ylecun/mnist', split=datasets.ReadInstruction.from_spec(
'test[:33%]+train[1:-1]'))
ds = datasets.load_dataset('ylecun/mnist', split=(
datasets.ReadInstruction('test', to=33, unit='%') +
datasets.ReadInstruction('train', from_=1, to=-1, unit='abs')))

# The following lines are equivalent:
ds = datasets.load_dataset('ylecun/mnist', split='test[:33%](pct1_dropremainder)')
ds = datasets.load_dataset('ylecun/mnist', split=datasets.ReadInstruction.from_spec(
'test[:33%](pct1_dropremainder)'))
ds = datasets.load_dataset('ylecun/mnist', split=datasets.ReadInstruction(
'test', from_=0, to=33, unit='%', rounding="pct1_dropremainder"))

# 10-fold validation:
tests = datasets.load_dataset(
'ylecun/mnist',
[datasets.ReadInstruction('train', from_=k, to=k+10, unit='%')
for k in range(0, 100, 10)])
trains = datasets.load_dataset(
'ylecun/mnist',
[datasets.ReadInstruction('train', to=k, unit='%') + datasets.ReadInstruction('train', from_=k+10, unit='%')
for k in range(0, 100, 10)])
```

#### from_spec[[datasets.ReadInstruction.from_spec]]

```python
from_spec(spec)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_reader.py#L536)

**Parâmetros:**

spec (`str`) : Split(s) + slice(s) opcional(is) para leitura + arredondamento opcional, caso percentuais sejam usados como unidade de fatiamento. Uma fatia pode ser especificada usando números absolutos (`int`) ou percentuais (`int`).

**Retorna:**

Instância de ReadInstruction.

Cria uma instância de `ReadInstruction` a partir de uma especificação em string.

Exemplos:

```
test: test split.
test + validation: test split + validation split.
test[10:]: test split, minus its first 10 records.
test[:10%]: first 10% records of test split.
test[:20%](pct1_dropremainder): first 10% records, rounded with the pct1_dropremainder rounding.
test[:-5%]+train[40%:60%]: first 95% of test + middle 20% of train.
```

#### to_absolute[[datasets.ReadInstruction.to_absolute]]

```python
to_absolute(name2len)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_reader.py#L608)

**Parâmetros:**

name2len (`dict`) : Associa nomes de splits ao número de exemplos.

**Retorna:**

lista de instâncias de _AbsoluteInstruction (corresponde ao + na especificação).

Traduza a instrução em uma lista de instruções absolutas.

Essas instruções absolutas devem então ser somadas.

## Versão[[datasets.Version]]

#### datasets.Version[[datasets.Version]]

```python
datasets.Version(version_str: str, description: typing.Optional[str] = None, major: typing.Union[str, int, NoneType] = None, minor: typing.Union[str, int, NoneType] = None, patch: typing.Union[str, int, NoneType] = None)
```

[Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/utils/version.py#L30)

**Parâmetros:**

version_str (`str`) : A versão do conjunto de dados.

description (`str`) : Uma descrição do que há de novo nesta versão.

major (`str`) --

minor (`str`) --

patch (`str`) --

Versão do dataset `MAJOR.MINOR.PATCH`.

Exemplo:

```py
>>> VERSION = datasets.Version("1.0.0")
```