# Clases de constructor

## Constructores[[datasets.DatasetBuilder]]

🤗 Datasets se basa en dos clases principales durante el proceso de construcción del conjunto de datos: [DatasetBuilder](/docs/datasets/main/es/package_reference/builder_classes#datasets.DatasetBuilder) y [BuilderConfig](/docs/datasets/main/es/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)
```

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

**Parámetros:**

cache_dir (`str`, *opcional*) : Directorio para almacenar los datos en caché. El valor predeterminado es `"~/.cache/huggingface/datasets"`.

dataset_name (`str`, *opcional*) : Nombre del conjunto de datos, si es diferente del nombre del constructor. Útil para los empaquetados como csv, imagefolder, audiofolder, etc. para reflejar la diferencia entre conjuntos de datos que utilizan el mismo empaquetado.

config_name (`str`, *opcional*) : Nombre de la configuración del conjunto de datos. Afecta a los datos generados en el disco. Las distintas configuraciones tendrán sus propios subdirectorios y versiones. Si no se proporciona, se utiliza la configuración predeterminada (si existe).    El parámetro `name` se renombró a `config_name`.

hash (`str`, *opcional*) : Hash específico del código del constructor del conjunto de datos. Se utiliza para actualizar el directorio de caché cuando el código del constructor del conjunto de datos se actualiza (para evitar reutilizar datos antiguos). El directorio de caché típico (definido en `self._relative_data_dir`) es `name/version/hash/`.

base_path (`str`, *opcional*) : Ruta base para las rutas relativas que se utilizan para descargar archivos. Puede ser una URL remota.

features ([Características](/docs/datasets/main/es/package_reference/main_classes#datasets.Features), *opcional*) : Tipos de características para usar con este conjunto de datos. Se puede usar, por ejemplo, para cambiar los tipos de [Características](/docs/datasets/main/es/package_reference/main_classes#datasets.Features) de un conjunto de datos.

token (`str` o `bool`, *opcional*) : Cadena o booleano para usar como token Bearer para archivos remotos en el Datasets Hub. Si es `True`, se obtendrá el token de `"~/.huggingface"`.

repo_id (`str`, *opcional*) : ID del repositorio del conjunto de datos. Se utiliza para distinguir constructores con el mismo nombre pero que no provienen del mismo espacio de nombres, por ejemplo, los IDs de repositorio "rajpurkar/squad" y "lhoestq/squad". En el segundo caso, el nombre del constructor sería "lhoestq___squad".

data_files (`str` o `Sequence` o `Mapping`, *opcional*) : Ruta(s) al archivo(s) de datos de origen. Para constructores como "csv" o "json" que requieren que el usuario especifique los archivos de datos. Pueden ser archivos locales o remotos. Por comodidad, puede usar un `DataFilesDict`.

data_dir (`str`, *opcional*) : Ruta al directorio que contiene el archivo o los archivos de datos de origen. Úsalo solo si no se pasa `data_files`, en cuyo caso es equivalente a pasar `os.path.join(data_dir, "**")` como `data_files`. Para los constructores que requieren una descarga manual, debe ser la ruta al directorio local que contiene los datos descargados manualmente.

storage_options (`dict`, *opcional*) : Pares clave/valor que se pasarán al backend del sistema de archivos del conjunto de datos, si lo hay.

writer_batch_size (`int`, *opcional*) : Tamaño del lote utilizado por el ArrowWriter. Define el número de muestras que se mantienen en memoria antes de escribirlas y también la longitud de los fragmentos de arrow. None significa que el ArrowWriter utilizará su valor predeterminado.

- ****config_kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave que se pasarán a la clase de configuración del constructor correspondiente, definida en el atributo de clase [DatasetBuilder.BUILDER_CONFIG_CLASS](/docs/datasets/main/es/package_reference/builder_classes#datasets.BuilderConfig). La clase de configuración del constructor es [BuilderConfig](/docs/datasets/main/es/package_reference/builder_classes#datasets.BuilderConfig) o una subclase de esta.

Clase base abstracta para todos los conjuntos de datos.

`DatasetBuilder` tiene 3 métodos clave:

- `DatasetBuilder.info`: Documenta el conjunto de datos, incluidos los nombres, tipos, formas, versión, divisiones, citación, etc.
- [DatasetBuilder.download_and_prepare()](/docs/datasets/main/es/package_reference/builder_classes#datasets.DatasetBuilder.download_and_prepare): Descarga los datos de origen y los escribe en el disco.
- [DatasetBuilder.as_dataset()](/docs/datasets/main/es/package_reference/builder_classes#datasets.DatasetBuilder.as_dataset): Genera un [Dataset](/docs/datasets/main/es/package_reference/main_classes#datasets.Dataset).

Algunos `DatasetBuilder` exponen múltiples variantes del conjunto de datos definiendo una subclase de [BuilderConfig](/docs/datasets/main/es/package_reference/builder_classes#datasets.BuilderConfig) y aceptando un objeto de configuración (o nombre) en la construcción. Los conjuntos de datos configurables exponen un conjunto predefinido de configuraciones en `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)
```

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

**Parámetros:**

split (`datasets.Split`) : Subconjunto de los datos que se debe devolver.

verification_mode ([VerificationMode](/docs/datasets/main/es/package_reference/builder_classes#datasets.VerificationMode) o `str`, por defecto `BASIC_CHECKS`) : Modo de verificación que determina las comprobaciones a ejecutar sobre la información del dataset descargado/procesado (sumas de verificación/tamaño/divisiones/...).

in_memory (`bool`, por defecto `False`) : Si se debe copiar los datos en memoria.

**Devuelve:**

datasets.Dataset

Devuelve un Dataset para la división especificada.

Ejemplo:

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

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

**Parámetros:**

output_dir (`str`, *opcional*) : Directorio de salida para el conjunto de datos. Por defecto, se usa `cache_dir` de este constructor, que por defecto está dentro de `~/.cache/huggingface/datasets`.

download_config (`DownloadConfig`, *opcional*) : Parámetros específicos de configuración de descarga.

download_mode ([DownloadMode](/docs/datasets/main/es/package_reference/builder_classes#datasets.DownloadMode) o `str`, *opcional*) : Selecciona el modo de descarga/generación, por defecto `REUSE_DATASET_IF_EXISTS`.

verification_mode ([VerificationMode](/docs/datasets/main/es/package_reference/builder_classes#datasets.VerificationMode) o `str`, por defecto `BASIC_CHECKS`) : Modo de verificación que determina las comprobaciones a ejecutar sobre la información del dataset descargado/procesado (sumas de verificación/tamaño/divisiones/...).

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

base_path (`str`, *opcional*) : Ruta base para las rutas relativas que se utilizan para descargar archivos. Puede ser una URL remota. Si no se especifica, se utilizará en su lugar el valor del atributo `base_path` (`self.base_path`).

file_format (`str`, *opcional*) : Formato de los archivos de datos en los que se escribirá el conjunto de datos. Formatos admitidos: "arrow", "parquet". El valor predeterminado es el formato "arrow". Si el formato es "parquet", los datos de imagen y audio se incrustan en los archivos Parquet en lugar de apuntar a archivos locales.

max_shard_size (`Union[str, int]`, *opcional*) : Número máximo de bytes escritos por fragmento, el valor predeterminado es "500MB". El tamaño se basa en el tamaño de los datos sin comprimir, por lo que en la práctica sus archivos de fragmento pueden ser más pequeños que `max_shard_size` gracias, por ejemplo, a la compresión de Parquet.

num_proc (`int`, *opcional*, valor predeterminado `None`) : Número de procesos al descargar y generar el conjunto de datos localmente. El procesamiento multiproceso está deshabilitado de forma predeterminada.

storage_options (`dict`, *opcional*) : Pares clave/valor que se pasarán al backend del sistema de archivos de caché, si lo hay.

- ****download_and_prepare_kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave.

Descarga y prepara el conjunto de datos para su lectura.

Ejemplo:

Descargue y prepare el conjunto de datos como archivos Arrow que se pueden cargar como un 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()
```

Descargue y prepare el conjunto de datos como archivos Parquet fragmentados 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")
```

Descargue y prepare el conjunto de datos como archivos Parquet segmentados en un almacenamiento en la nube:

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

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

Devuelve la ruta del módulo de esta clase o subclase.

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

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

Clase base para conjuntos de datos con generación de datos basada en generadores de diccionarios.

`GeneratorBasedBuilder` es una clase de conveniencia que abstrae gran parte de la escritura y lectura de datos de `DatasetBuilder`. Espera que las subclases implementen generadores de diccionarios de características a través de las divisiones del conjunto de datos (`_split_generators`). Consulte las docstrings de los métodos para obtener más detalles.

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

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

Clase base para conjuntos de datos con generación de datos basada en funciones de carga de 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)
```

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

**Parámetros:**

name (`str`, por defecto `default`) : El nombre de la configuración.

version (`Version` o `str`, por defecto `0.0.0`) : La versión de la configuración.

data_dir (`str`, *opcional*) : Ruta al directorio que contiene los datos de origen.

data_files (`str` o `Sequence` o `Mapping`, *opcional*) : Ruta(s) al archivo(s) de datos de origen.

description (`str`, *opcional*) : Una descripción en lenguaje humano de la configuración.

Clase base para la configuración de datos de `DatasetBuilder`.

Los subclases de `DatasetBuilder` con opciones de configuración de datos deben subclasear `BuilderConfig` y añadir sus propias propiedades.

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

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

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

El id de la configuración se utiliza para construir el directorio de caché. Por defecto, es igual al nombre de la configuración. Sin embargo, el nombre de una configuración no es suficiente para tener un identificador único del conjunto de datos que se está generando, ya que no tiene en cuenta:
- los kwargs de configuración que se pueden usar para sobrescribir atributos
- las características personalizadas utilizadas para escribir el conjunto de datos
- los data_files para conjuntos de datos json/texto/csv/pandas

Por lo tanto, el id de la configuración es simplemente el nombre de la configuración con un sufijo opcional basado en estos.

## Descargar[[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)
```

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

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

```python
download(url_or_urls)
```

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

**Parámetros:**

url_or_urls (`str` o `list` o `dict`) : URL o `list` o `dict` de URLs para descargar. Cada URL es un `str`.

**Devuelve:** `str` o `list` o `dict`

Las rutas descargadas que coinciden con la entrada `url_or_urls` dada.

Descarga las URL(s) indicadas.

Por defecto, solo se utiliza un proceso para la descarga. Pasa un `download_config.num_proc` personalizado para cambiar este comportamiento.

Ejemplo:

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

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

**Parámetros:**

url_or_urls (`str` o `list` o `dict`) : URL o `list` o `dict` de URLs para descargar y extraer. Cada URL es un `str`.

**Devuelve:** `extracted_path(s)`

`str`, rutas extraídas de la(s) URL(s) indicada(s).

Descargue y extraiga la `url_or_urls` indicada.

Es aproximadamente equivalente a:

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

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

```python
extract(path_or_paths)
```

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

**Parámetros:**

path_or_paths (ruta o `list` o `dict`) : Ruta del archivo a extraer. Cada ruta es un `str`.

**Devuelve:** `extracted_path(s)`

`str`, Las rutas extraídas que coinciden con la ruta o rutas de entrada dadas.

Extraer la(s) ruta(s) indicada(s).

Ejemplo:

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

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

**Parámetros:**

path_or_buf (`str` o `io.BufferedReader`) : Ruta del archivo o objeto de archivo binario del archivo.

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

2-tupla (path_within_archive, file_object). El objeto de archivo se abre en modo binario.

Iterar sobre los archivos dentro de un archivo.

Ejemplo:

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

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

**Parámetros:**

paths (`str` o `list` de `str`) : Rutas raíz.

**Devuelve:** `str`

Ruta del archivo.

Iterar sobre las rutas de los archivos.

Ejemplo:

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

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

Gestor de descargas que utiliza el separador "::" para navegar por archivos comprimidos (posiblemente remotos). A diferencia del `DownloadManager` regular, los métodos `download` y `extract` no descargan ni extraen datos, sino que devuelven la ruta o la URL que se puede abrir con la función `xopen`, que extiende la función integrada `open` para transmitir datos desde archivos remotos.

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

```python
download(url_or_urls)
```

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

**Parámetros:**

url_or_urls (`str` o `list` o `dict`) : URL(s) de archivos de los que transmitir datos. Cada url es un `str`.

**Devuelve:** `url(s)`

(`str` o `list` o `dict`), URL(s) para transmitir datos desde las URL(s) de entrada url_or_urls proporcionadas.

Normaliza la URL de los archivos desde los que se va a transmitir los datos. Esta es la versión perezosa de `DownloadManager.download` para la transmisión.

Ejemplo:

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

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

**Parámetros:**

url_or_urls (`str` o `list` o `dict`) : URL(s) de las que transmitir los datos. Cada url es un `str`.

**Devuelve:** `url(s)`

(`str` o `list` o `dict`), URL(s) para transmitir datos desde las URL(s) que coincidan con la entrada `url_or_urls` dada.

Prepara la `url_or_urls` dada para streaming (añade el protocolo de extracción).

Esta es la versión perezosa de `DownloadManager.download_and_extract` para streaming.

Es equivalente a:

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

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

```python
extract(url_or_urls)
```

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

**Parámetros:**

url_or_urls (`str` o `list` o `dict`) : URL(s) de archivos de los que transmitir datos. Cada url es un `str`.

**Devuelve:** `url(s)`

(`str` o `list` o `dict`), URL(s) para transmitir datos desde las URL(s) que coincidan con la entrada `url_or_urls` dada.

Agregue el protocolo de extracción para la(s) URL(s) indicada(s) para el streaming.

Esta es la versión perezosa de `DownloadManager.extract` para streaming.

Ejemplo:

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

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

**Parámetros:**

urlpath_or_buf (`str` o `io.BufferedReader`) : Ruta del archivo o objeto de archivo binario del archivo.

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

2-tupla (path_within_archive, file_object). El objeto de archivo se abre en modo binario.

Iterar sobre los archivos dentro de un archivo.

Ejemplo:

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

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

**Parámetros:**

urlpaths (`str` o `list` de `str`) : Rutas raíz.

**Devuelve:** `str`

Ruta de URL del archivo.

Iterar sobre los archivos.

Ejemplo:

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

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

**Parámetros:**

cache_dir (`str` o `Path`, *opcional*) : Especifica un directorio de caché para guardar el archivo (sobrescribe el directorio de caché predeterminado).

force_download (`bool`, por defecto `False`) : Si es `True`, vuelve a descargar el archivo aunque ya esté en caché en el directorio de caché.

resume_download (`bool`, por defecto `False`) : Si es `True`, reanuda la descarga si se encuentra un archivo recibido de forma incompleta.

proxies (`dict`, *opcional*) : Obsoleto e ignorado. En su lugar, establezca las variables de entorno `HTTP_PROXY` / `HTTPS_PROXY` o configure el cliente HTTP con [huggingface_hub.set_client_factory](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/utilities#huggingface_hub.set_client_factory).

user_agent (`str`, *opcional*) : String o diccionario opcional que se añadirá al user-agent en las solicitudes remotas.

extract_compressed_file (`bool`, por defecto `False`) : Si `True` y la ruta apunta a un archivo zip o tar, extrae el archivo comprimido en una carpeta junto al archivo.

force_extract (`bool`, por defecto `False`) : Si `True` cuando `extract_compressed_file` es `True` y el archivo ya se había extraído, vuelve a extraer el archivo y sobrescribe la carpeta donde se extrajo.

delete_extracted (`bool`, por defecto `False`) : Si se deben eliminar (o conservar) los archivos extraídos.

extract_on_the_fly (`bool`, por defecto `False`) : Si `True`, extrae los archivos comprimidos mientras se están leyendo.

use_etag (`bool`, por defecto `True`) : Si se debe usar la cabecera de respuesta HTTP ETag para validar los archivos en caché.

num_proc (`int`, *opcional*) : El número de procesos que se iniciarán para descargar los archivos en paralelo.

max_retries (`int`, por defecto `1`) : El número de veces que se reintentará una solicitud HTTP si falla.

token (`str` o `bool`, *opcional*) : Cadena o booleano opcional para usar como token Bearer para archivos remotos en el Datasets Hub. Si es `True`, o no se especifica, se obtendrá el token de `~/.huggingface`.

storage_options (`dict`, *opcional*) : Pares clave/valor que se pasarán al backend del sistema de archivos del conjunto de datos, si lo hay.

download_desc (`str`, *opcional*) : Una descripción que se mostrará junto con la barra de progreso mientras se descargan los archivos.

disable_tqdm (`bool`, por defecto `False`) : Si se debe deshabilitar la barra de progreso de descarga de archivos individuales

Configuración para nuestro gestor de rutas en caché.

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

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

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

`Enum` para definir cómo tratar las descargas y los datos existentes.

El modo predeterminado es `REUSE_DATASET_IF_EXISTS`, que reutilizará tanto las descargas crudas como el dataset preparado si existen.

Los modos de generación:

|                                     | Descargas | Dataset |
|-------------------------------------|-----------|---------|
| `REUSE_DATASET_IF_EXISTS` (predeterminado) | Reutilización     | Reutilización   |
| `REUSE_CACHE_IF_EXISTS`             | Reutilización     | Nuevo   |
| `FORCE_REDOWNLOAD`                  | Nuevo     | Nuevo   |

## Verificación[[datasets.VerificationMode]]

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

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

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

`Enum` que especifica qué comprobaciones de verificación ejecutar.

El modo predeterminado es `BASIC_CHECKS`, que realiza solo comprobaciones básicas para evitar ralentizaciones al generar o descargar un conjunto de datos por primera vez.

Los modos de verificación:

|                           | Comprobaciones de verificación                                                           |
|---------------------------|------------------------------------------------------------------------------ |
| `ALL_CHECKS`              | Comprobaciones de división y validez (número de archivos, sumas de verificación) de los archivos descargados    |
| `BASIC_CHECKS` (predeterminado)  | Igual que `ALL_CHECKS` pero sin comprobar los archivos descargados                    |
| `NO_CHECKS`               | Ninguno                                                                          |

## Divisiones[[datasets.SplitGenerator]]

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

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

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

**Parámetros:**

name (`str`) : Nombre de la `Split` para la que el generador creará los ejemplos.

- ****gen_kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave para reenviar al método `DatasetBuilder._generate_examples` del builder.

Define la información de división para el generador.

Esto debe usarse como valor devuelto de `GeneratorBasedBuilder._split_generators`. Consulte `GeneratorBasedBuilder._split_generators` para obtener más información y un ejemplo de uso.

Ejemplo:

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

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

`Enum` para las divisiones de los conjuntos de datos.

Los conjuntos de datos suelen dividirse en diferentes subconjuntos para utilizarse en las distintas etapas de entrenamiento y evaluación.

- `TRAIN`: los datos de entrenamiento.
- `VALIDATION`: los datos de validación. Si están presentes, suelen usarse como datos de evaluación mientras se itera sobre un modelo (p. ej., cambiando hiperparámetros, arquitectura del modelo, etc.).
- `TEST`: los datos de prueba. Son los datos sobre los que se reportan las métricas. Por lo general, no se desea utilizarlos durante la iteración del modelo, ya que es posible que se sobreajuste a ellos.
- `ALL`: la unión de todas las divisiones de datos definidas.

Todas las divisiones, incluidas las composiciones, heredan de `datasets.SplitBase`.

Consulte la [guía](../load_hub#splits) sobre divisiones para obtener más información.

Ejemplo:

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

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

Descriptor correspondiente a una división nombrada (train, test, ...).

Ejemplo:

Cada descriptor puede componerse con otros mediante la adición o el corte:

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

La división resultante corresponderá al 25% de la división de entrenamiento fusionado con el 100% de la división de prueba.

No se puede añadir una división dos veces, por lo que lo siguiente fallará:

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

Las rebanadas solo se pueden aplicar una vez. Por lo tanto, los siguientes son 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])
```

Pero esto no es 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()
```

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

División correspondiente a la unión de todas las divisiones de datos definidas.

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

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

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

Instrucción de lectura para un conjunto de datos.

Ejemplos:

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

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

**Parámetros:**

spec (`str`) : Split(s) + slice(s) opcionales para leer + redondeo opcional si se usan porcentajes como unidad de segmentación. Se puede especificar un slice, usando números absolutos (`int`) o porcentajes (`int`).

**Devuelve:**

Instancia de ReadInstruction.

Crea una instancia de `ReadInstruction` a partir de una especificación en cadena.

Ejemplos:

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

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

**Parámetros:**

name2len (`dict`) : Asocia los nombres de las divisiones al número de ejemplos.

**Devuelve:**

lista de instancias de _AbsoluteInstruction (corresponde al + en la especificación).

Traducir la instrucción a una lista de instrucciones absolutas.

Esas instrucciones absolutas deben sumarse a continuación.

## Versión[[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)
```

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

**Parámetros:**

version_str (`str`) : La versión del conjunto de datos.

description (`str`) : Una descripción de lo que es nuevo en esta versión.

major (`str`) --

minor (`str`) --

patch (`str`) --

Versión del conjunto de datos `MAJOR.MINOR.PATCH`.

Ejemplo:

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