# Clases principales ## DatasetInfo[[datasets.DatasetInfo]] #### datasets.DatasetInfo[[datasets.DatasetInfo]] ```python datasets.DatasetInfo(description: str = , citation: str = , homepage: str = , license: str = , features: typing.Optional[datasets.features.features.Features] = None, post_processed: typing.Optional[datasets.info.PostProcessedInfo] = None, supervised_keys: typing.Optional[datasets.info.SupervisedKeysData] = None, builder_name: typing.Optional[str] = None, dataset_name: typing.Optional[str] = None, config_name: typing.Optional[str] = None, version: typing.Union[str, datasets.utils.version.Version, NoneType] = None, splits: typing.Optional[datasets.splits.SplitDict] = None, download_checksums: typing.Optional[dict] = None, download_size: typing.Optional[int] = None, post_processing_size: typing.Optional[int] = None, dataset_size: typing.Optional[int] = None, size_in_bytes: typing.Optional[int] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/info.py#L92) **Parámetros:** description (`str`) : Una descripción del conjunto de datos. citation (`str`) : Una cita BibTeX del conjunto de datos. homepage (`str`) : Una URL para la página de inicio oficial del conjunto de datos. license (`str`) : La licencia del conjunto de datos. Puede ser el nombre de la licencia o un párrafo que contiene los términos de la licencia. features ([Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features), *opcional*) : Las características utilizadas para especificar los tipos de columnas del conjunto de datos. post_processed (`PostProcessedInfo`, *opcional*) : Obsoleto. Información sobre los recursos de un posible posprocesamiento de un conjunto de datos. Por ejemplo, puede contener la información de un índice. supervised_keys (`SupervisedKeysData`, *opcional*) : Especifica la característica de entrada y la etiqueta para el aprendizaje supervisado, si es aplicable al conjunto de datos (herencia de TFDS). builder_name (`str`, *opcional*) : El nombre de la subclase de `GeneratorBasedBuilder` utilizada para crear el conjunto de datos. También es la versión snake_case del nombre de la clase del constructor del conjunto de datos. config_name (`str`, *opcional*) : El nombre de la configuración derivada de [BuilderConfig](/docs/datasets/v5.2.0/es/package_reference/builder_classes#datasets.BuilderConfig). version (`str` o [Version](/docs/datasets/v5.2.0/es/package_reference/builder_classes#datasets.Version), *opcional*) : La versión del conjunto de datos. splits (`dict`, *opcional*) : El mapeo entre el nombre de la división y los metadatos. download_checksums (`dict`, *opcional*) : El mapeo entre la URL para descargar los sumarios de verificación del conjunto de datos y los metadatos correspondientes. download_size (`int`, *opcional*) : El tamaño de los archivos a descargar para generar el conjunto de datos, en bytes. post_processing_size (`int`, *opcional*) : Obsoleto. Tamaño del conjunto de datos en bytes después del posprocesamiento, si lo hay. dataset_size (`int`, *opcional*) : El tamaño combinado en bytes de las tablas Arrow para todas las divisiones. size_in_bytes (`int`, *opcional*) : El tamaño combinado en bytes de todos los archivos asociados con el conjunto de datos (archivos descargados + archivos Arrow). - ****config_kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave que se pasarán al [BuilderConfig](/docs/datasets/v5.2.0/es/package_reference/builder_classes#datasets.BuilderConfig) y se usarán en el [DatasetBuilder](/docs/datasets/v5.2.0/es/package_reference/builder_classes#datasets.DatasetBuilder). Información sobre un conjunto de datos. `DatasetInfo` documenta los conjuntos de datos, incluyendo su nombre, versión y características. Consulta los argumentos del constructor y las propiedades para obtener una lista completa. No todos los campos se conocen en el momento de la construcción y pueden actualizarse más adelante. #### from_directory[[datasets.DatasetInfo.from_directory]] ```python from_directory(dataset_info_dir: str, storage_options: typing.Optional[dict] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/info.py#L247) **Parámetros:** dataset_info_dir (`str`) : El directorio que contiene el archivo de metadatos. Debe ser el directorio raíz de una versión específica del conjunto de datos. storage_options (`dict`, *opcional*) : Pares clave/valor que se pasarán al backend del sistema de archivos, si lo hay. Crea [DatasetInfo](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetInfo) a partir del archivo JSON en `dataset_info_dir`. Esta función actualiza todos los campos generados dinámicamente (num_examples, hash, time of creation,...) de [DatasetInfo](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetInfo). Esto sobrescribirá todos los metadatos anteriores. Ejemplo: ```py >>> from datasets import DatasetInfo >>> ds_info = DatasetInfo.from_directory("/path/to/directory/") ``` #### write_to_directory[[datasets.DatasetInfo.write_to_directory]] ```python write_to_directory(dataset_info_dir, pretty_print = False, storage_options: typing.Optional[dict] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/info.py#L186) **Parámetros:** dataset_info_dir (`str`) : Directorio de destino. pretty_print (`bool`, por defecto `False`) : Si `True`, el JSON se formateará con un nivel de indentación de 4. storage_options (`dict`, *opcional*) : Pares clave/valor que se pasarán al backend del sistema de archivos, si lo hay. Escribe `DatasetInfo` y la licencia (si existe) como archivos JSON en `dataset_info_dir`. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.info.write_to_directory("/path/to/directory/") ``` ## Dataset[[datasets.Dataset]] La clase base [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) implementa un Dataset respaldado por una tabla de Apache Arrow. #### datasets.Dataset[[datasets.Dataset]] ```python datasets.Dataset(arrow_table: Table, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, indices_table: typing.Optional[datasets.table.Table] = None, fingerprint: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L709) Un Dataset respaldado por una tabla Arrow. #### add_column[[datasets.Dataset.add_column]] ```python add_column(name: str, column: typing.Union[list, numpy.ndarray], new_fingerprint: typing.Optional[str] = None, feature: typing.Union[dict, list, tuple, datasets.features.features.Value, datasets.features.features.ClassLabel, datasets.features.translation.Translation, datasets.features.translation.TranslationVariableLanguages, datasets.features.features.LargeList, datasets.features.features.List, datasets.features.features.Array2D, datasets.features.features.Array3D, datasets.features.features.Array4D, datasets.features.features.Array5D, datasets.features.audio.Audio, datasets.features.image.Image, datasets.features.mesh.Mesh, datasets.features.video.Video, datasets.features.pdf.Pdf, datasets.features.nifti.Nifti, datasets.features.bio_sequence.BioSequence, datasets.features.bio_structure.BioStructure, NoneType] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6284) **Parámetros:** name (`str`) : Nombre de la columna. column (`list` o `np.array`) : Datos de la columna a añadir. feature (`FeatureType` o `None`, por defecto `None`) : Tipo de datos de la columna. **Devuelve:** [Conjunto de datos](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) Agregar columna a Dataset. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> more_text = ds["text"] >>> ds = ds.add_column(name="text_2", column=more_text) >>> ds Dataset({ features: ['text', 'label', 'text_2'], num_rows: 1066 }) ``` #### add_item[[datasets.Dataset.add_item]] ```python add_item(item: dict, new_fingerprint: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6546) **Parámetros:** item (`dict`) : Datos del elemento a añadir. **Devuelve:** [Conjunto de datos](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) Añadir elemento al Dataset. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> new_review = {'label': 0, 'text': 'this movie is the absolute worst thing I have ever seen'} >>> ds = ds.add_item(new_review) >>> ds[-1] {'label': 0, 'text': 'this movie is the absolute worst thing I have ever seen'} ``` #### from_file[[datasets.Dataset.from_file]] ```python from_file(filename: str, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, indices_filename: typing.Optional[str] = None, in_memory: bool = False) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L792) **Parámetros:** filename (`str`) : Nombre del archivo del conjunto de datos. info (`DatasetInfo`, *opcional*) : Información del conjunto de datos, como la descripción, la cita, etc. split (`NamedSplit`, *opcional*) : Nombre de la división del conjunto de datos. indices_filename (`str`, *opcional*) : Nombres de los archivos de los índices. in_memory (`bool`, por defecto `False`) : Si se debe copiar los datos en memoria. **Devuelve:** [Conjunto de datos](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) Instancia un Dataset respaldado por una tabla Arrow en filename. #### from_buffer[[datasets.Dataset.from_buffer]] ```python from_buffer(buffer: Buffer, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, indices_buffer: typing.Optional[pyarrow.lib.Buffer] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L832) **Parámetros:** buffer (`pyarrow.Buffer`) : búfer de Arrow. info (`DatasetInfo`, *opcional*) : Información del conjunto de datos, como la descripción, la cita, etc. split (`NamedSplit`, *opcional*) : Nombre de la división del conjunto de datos. indices_buffer (`pyarrow.Buffer`, *opcional*) : Índices del búfer de Arrow. **Devuelve:** [Conjunto de datos](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) Instanciar un Dataset respaldado por un búfer de Arrow. #### from_pandas[[datasets.Dataset.from_pandas]] ```python from_pandas(df: DataFrame, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, preserve_index: typing.Optional[bool] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L864) **Parámetros:** df (`pandas.DataFrame`) : Dataframe que contiene el conjunto de datos. features ([Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features), *opcional*) : Características del conjunto de datos. info (`DatasetInfo`, *opcional*) : Información del conjunto de datos, como la descripción, la cita, etc. split (`NamedSplit`, *opcional*) : Nombre de la división del conjunto de datos. preserve_index (`bool`, *opcional*) : Si se debe almacenar el índice como una columna adicional en el Dataset resultante. El valor predeterminado de `None` almacenará el índice como una columna, excepto para `RangeIndex`, que se almacena solo como metadatos. Use `preserve_index=True` para forzar que se almacene como una columna. **Devuelve:** [Conjunto de datos](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) Convierta `pandas.DataFrame` en una `pyarrow.Table` para crear un [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset). Los tipos de columna en la Tabla Arrow resultante se infieren a partir de los dtypes de las `pandas.Series` en el DataFrame. En el caso de Series que no son de objeto, el dtype de NumPy se traduce a su equivalente en Arrow. En el caso de `object`, es necesario inferir el tipo de datos examinando los objetos Python presentes en esta Series. Tenga en cuenta que las Series de tipo `object` no contienen suficiente información para derivar siempre un tipo Arrow significativo. En el caso de que no podamos inferir un tipo, por ejemplo, porque el DataFrame tiene longitud 0 o la Series solo contiene objetos `None/nan`, el tipo se establece como `null`. Este comportamiento se puede evitar construyendo características explícitas y pasándolas a esta función. Importante: un dataset creado con from_pandas() reside en memoria y, por lo tanto, no tiene un directorio de caché asociado. Esto podría cambiar en el futuro, pero mientras tanto, si deseas reducir el uso de memoria, debes escribirlo de nuevo en el disco y recargarlo, por ejemplo, usando save_to_disk / load_from_disk. Ejemplo: ```py >>> ds = Dataset.from_pandas(df) ``` #### from_dict[[datasets.Dataset.from_dict]] ```python from_dict(mapping: dict, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, on_mixed_types: typing.Optional[typing.Literal['use_json']] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L982) **Parámetros:** mapping (`Mapping`) : Mapeo de cadenas de texto a Arrays o listas de Python. features ([Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features), *opcional*) : Características del conjunto de datos. info (`DatasetInfo`, *opcional*) : Información del conjunto de datos, como la descripción, la cita, etc. split (`NamedSplit`, *opcional*) : Nombre de la división del conjunto de datos. on_mixed_types (`Literal["use_json"]`, *opcional*, valor predeterminado `None`) : Si es "use_json", se utiliza el tipo Json() para campos de tipos mixtos, es decir, campos no estructurados que contienen datos sin un esquema predefinido. En este caso, un campo de tipo mixto se establece como Json(). Esto permite cargar listas con una mezcla de strings/integers/floats, por ejemplo, o diccionarios con tipos de valores arbitrarios. **Devuelve:** [Conjunto de datos](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) Convierta `dict` en una `pyarrow.Table` para crear un [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset). Importante: un dataset creado con from_dict() vive en memoria y, por lo tanto, no tiene un directorio de caché asociado. Esto podría cambiar en el futuro, pero mientras tanto, si deseas reducir el uso de memoria, debes escribirlo de nuevo en el disco y recargarlo usando, por ejemplo, save_to_disk / load_from_disk. Ejemplos: Obtén un Dataset a partir de un diccionario que contiene una lista por columna: ```py >>> ds = Dataset.from_dict({"text": ["hello there !", "general kenobi !"]}) ``` Pasa features para establecer los tipos de columnas, por ejemplo, para un conjunto de datos de imágenes: ```py >>> features = Features({"image": Image()}) >>> ds = Dataset.from_dict({"image": ["path/to/image.png"]}, features=features) ``` Los datasets se basan en Arrow, un formato columnar, y por lo tanto esperan que cada ejemplo tenga el mismo tipo y subtipos, y que los diccionarios tengan las mismas claves y tipos de valores. Al cargar un dataset, se produce un error si los campos tienen tipos que no coinciden, y se rellenan los campos faltantes en los diccionarios con None para que todos los diccionarios tengan las mismas claves y tipos de valores. Para evitar esto y permitir tipos mixtos sin errores, puede usar `on_mixed_types="use_json"` o especificar `features=` con un tipo [Json](/docs/datasets/v5.2.0/es/package_reference/loading_methods#datasets.Json): ```py >>> ds = Dataset.from_dict({"a": [0, "foo", {"subfield": "bar"}]}) Traceback (most recent call last): ... File "pyarrow/error.pxi", line 92, in pyarrow.lib.check_status pyarrow.lib.ArrowInvalid: Could not convert 'foo' with type str: tried to convert to int64 >>> ds = Dataset.from_dict({"a": [0, "foo", {"subfield": "bar"}]}, on_mixed_types="use_json") >>> ds.features {'a': Json()} >>> list(ds["a"]) [0, "foo", {"subfield": "bar"}] >>> features = Features({"a": Json()}) >>> ds = Dataset.from_dict({"a": [0, "foo", {"subfield": "bar"}]}, features=features) >>> ds.features {'a': Json()} >>> list(ds["a"]) [0, "foo", {"subfield": "bar"}] ``` También es útil para listas de diccionarios con claves y valores arbitrarios, para evitar rellenar los campos que faltan con None: ```py >>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}) >>> ds.features {'a': List({'b': Value('int64'), 'c': Value('int64')})} >>> list(ds["a"]) [[{'b': 0, 'c': None}, {'b': None, 'c': 0}]] # missing fields are filled with None >>> features = Features({"a": List(Json())}) >>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}, features=features) >>> ds.features {'a': List(Json())} >>> list(ds["a"]) [[{'b': 0}, {'c': 0}]] # OK >>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}, on_mixed_types="use_json") >>> ds.features {'a': List(Json())} >>> list(ds["a"]) [[{'b': 0}, {'c': 0}]] # OK ``` Otro ejemplo con datos de llamadas a herramientas: ```py >>> messages = [ ... {"role": "user", "content": "Turn on the living room lights and play my electronic music playlist."}, ... {"role": "assistant", "tool_calls": [ ... {"type": "function", "function": { ... "name": "control_light", ... "arguments": {"room": "living room", "state": "on"} ... }}, ... {"type": "function", "function": { ... "name": "play_music", ... "arguments": {"playlist": "electronic"} # mixed-type here since keys ["playlist"] and ["room", "state"] are different ... }}] ... }, ... {"role": "tool", "name": "control_light", "content": "The lights in the living room are now on."}, ... {"role": "tool", "name": "play_music", "content": "The music is now playing."}, ... {"role": "assistant", "content": "Done!"} ... ] >>> ds = Dataset.from_dict({"messages": [messages]}, on_mixed_types="use_json") >>> ds.features {'messages': List({'role': Value('string'), 'content': Value('string'), 'tool_calls': List(Json()), 'name': Value('string')})} >>> ds[0]["messages"][1]["tool_calls"][0]["function"]["arguments"] {"room": "living room", "state": "on"} ``` #### from_list[[datasets.Dataset.from_list]] ```python from_list(mapping: list, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, on_mixed_types: typing.Optional[typing.Literal['use_json']] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1148) **Parámetros:** mapping (`List[dict]`) : Una lista de mapeos de cadenas a valores de fila. features (`Features`, opcional) : Características del conjunto de datos. info (`DatasetInfo`, opcional) : Información del conjunto de datos, como la descripción, la cita, etc. split (`NamedSplit`, opcional) : Nombre de la división del conjunto de datos. on_mixed_types (`Literal["use_json"]`, *opcional*, valor predeterminado `None`) : Si es "use_json", se utiliza el tipo Json() para campos de tipos mixtos, es decir, campos no estructurados que contienen datos sin un esquema predefinido. En este caso, un campo de tipo mixto se establece como Json(). Esto permite cargar listas con una mezcla de strings/integers/floats, por ejemplo, o diccionarios con tipos de valores arbitrarios. **Devuelve:** [Conjunto de datos](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) Convierta una lista de diccionarios en una `pyarrow.Table` para crear un [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset)`. Tenga en cuenta que las claves de la primera entrada se usarán para determinar las columnas del conjunto de datos, independientemente de lo que se pase a features. Importante: un dataset creado con from_list() reside en memoria y, por lo tanto, no tiene un directorio de caché asociado. Esto podría cambiar en el futuro, pero mientras tanto, si deseas reducir el uso de memoria, debes escribirlo de nuevo en el disco y recargarlo, por ejemplo, usando save_to_disk / load_from_disk. Ejemplos: Obtén un Dataset a partir de una lista que contiene los ejemplos: ```py >>> ds = Dataset.from_list([{"text": "hello there !"}, {"text": "general kenobi !"}]}) ``` Pasa features para establecer los tipos de columnas, por ejemplo, para un conjunto de datos de imágenes: ```py >>> features = Features({"image": Image()}) >>> ds = Dataset.from_list([{"image": "path/to/image.png"}], features=features) ``` Los datasets se basan en Arrow, un formato columnar, y por lo tanto esperan que cada ejemplo tenga el mismo tipo y subtipos, y que los diccionarios tengan las mismas claves y tipos de valores. Al cargar un dataset, se produce un error si los campos tienen tipos que no coinciden, y se rellenan los campos faltantes en los diccionarios con None para que todos los diccionarios tengan las mismas claves y tipos de valores. Para evitar esto y permitir tipos mixtos sin errores, puede usar `on_mixed_types="use_json"` o especificar `features=` con un tipo [Json](/docs/datasets/v5.2.0/es/package_reference/loading_methods#datasets.Json): ```py >>> ds = Dataset.from_list([{"a": 0}, {"a": "foo"}, {"a": {"subfield": "bar"}}]) Traceback (most recent call last): ... File "pyarrow/error.pxi", line 92, in pyarrow.lib.check_status pyarrow.lib.ArrowInvalid: Could not convert 'foo' with type str: tried to convert to int64 >>> ds = Dataset.from_list([{"a": 0}, {"a": "foo"}, {"a": {"subfield": "bar"}}], on_mixed_types="use_json") >>> ds.features {'a': Json()} >>> list(ds["a"]) [0, "foo", {"subfield": "bar"}] >>> features = Features({"a": Json()}) >>> ds = Dataset.from_list([{"a": 0}, {"a": "foo"}, {"a": {"subfield": "bar"}}], features=features) >>> ds.features {'a': Json()} >>> list(ds["a"]) [0, "foo", {"subfield": "bar"}] ``` También es útil para listas de diccionarios con claves y valores arbitrarios, para evitar rellenar los campos que faltan con None: ```py >>> ds = Dataset.from_list([{"a": [{"b": 0}, {"c": 0}]}]) >>> ds.features {'a': List({'b': Value('int64'), 'c': Value('int64')})} >>> list(ds["a"]) [[{'b': 0, 'c': None}, {'b': None, 'c': 0}]] # missing fields are filled with None >>> features = Features({"a": List(Json())}) >>> ds = Dataset.from_list([{"a": [{"b": 0}, {"c": 0}]}], features=features) >>> ds.features {'a': List(Json())} >>> list(ds["a"]) [[{'b': 0}, {'c': 0}]] # OK >>> ds = Dataset.from_list([{"a": [{"b": 0}, {"c": 0}]}], on_mixed_types="use_json") >>> ds.features {'a': List(Json())} >>> list(ds["a"]) [[{'b': 0}, {'c': 0}]] # OK ``` Otro ejemplo con datos de llamadas a herramientas: ```py >>> messages = [ ... {"role": "user", "content": "Turn on the living room lights and play my electronic music playlist."}, ... {"role": "assistant", "tool_calls": [ ... {"type": "function", "function": { ... "name": "control_light", ... "arguments": {"room": "living room", "state": "on"} ... }}, ... {"type": "function", "function": { ... "name": "play_music", ... "arguments": {"playlist": "electronic"} # mixed-type here since keys ["playlist"] and ["room", "state"] are different ... }}] ... }, ... {"role": "tool", "name": "control_light", "content": "The lights in the living room are now on."}, ... {"role": "tool", "name": "play_music", "content": "The music is now playing."}, ... {"role": "assistant", "content": "Done!"} ... ] >>> ds = Dataset.from_list([{"messages": messages}], on_mixed_types="use_json") >>> ds.features {'messages': List({'role': Value('string'), 'content': Value('string'), 'tool_calls': List(Json()), 'name': Value('string')})} >>> ds[0]["messages"][1]["tool_calls"][0]["function"]["arguments"] {"room": "living room", "state": "on"} ``` #### from_generator[[datasets.Dataset.from_generator]] ```python from_generator(generator: typing.Callable, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, gen_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, split: NamedSplit = NamedSplit('train'), fingerprint: typing.Optional[str] = None, **kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1337) **Parámetros:** generator ( --`Callable`): una función generadora que `yields` ejemplos. features ([Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features), *opcional*) : Características del conjunto de datos. cache_dir (`str`, *opcional*, por defecto `"~/.cache/huggingface/datasets"`) : Directorio para cachear datos. keep_in_memory (`bool`, por defecto `False`) : Si se debe copiar los datos en memoria. gen_kwargs(`dict`, *opcional*) : Argumentos de palabra clave que se pasarán al objeto invocable `generator`. Puede definir un conjunto de datos fragmentado pasando la lista de fragmentos en `gen_kwargs` y estableciendo `num_proc` en un valor mayor que 1. num_proc (`int`, *opcional*, valor predeterminado `None`) : Número de procesos al descargar y generar el conjunto de datos localmente. Esto es útil si el conjunto de datos está compuesto por varios archivos. El procesamiento multiproceso está deshabilitado de forma predeterminada. Si `num_proc` es mayor que uno, todos los valores de lista en `gen_kwargs` deben tener la misma longitud. Estos valores se dividirán entre las llamadas al generador. El número de fragmentos será el mínimo entre la lista más corta en `gen_kwargs` y `num_proc`. split ([NamedSplit](/docs/datasets/v5.2.0/es/package_reference/builder_classes#datasets.NamedSplit), por defecto `Split.TRAIN`) : Nombre de la división que se asignará al conjunto de datos. fingerprint (`str`, *opcional*) : Huella digital que se utilizará para generar el ID del conjunto de datos. De forma predeterminada, `fingerprint` se genera mediante el hash de la función generadora y todos los argumentos, lo cual puede ser lento si utiliza objetos grandes como modelos de IA. - ****kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave que se pasarán a :`GeneratorConfig`. **Devuelve:** [Conjunto de datos](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) Crear un Dataset a partir de un generador. Carga los datos del generador, almacena los datos en caché en formato Arrow en el disco y devuelve el Dataset desde los datos Arrow mapeados en memoria en el disco. Ejemplo: ```py >>> def gen(): ... yield {"text": "Good", "label": 0} ... yield {"text": "Bad", "label": 1} ... >>> ds = Dataset.from_generator(gen) ``` ```py >>> def gen(shards): ... for shard in shards: ... with open(shard) as f: ... for line in f: ... yield {"line": line} ... >>> shards = [f"data{i}.txt" for i in range(32)] >>> ds = Dataset.from_generator(gen, gen_kwargs={"shards": shards}) ``` #### data[[datasets.Dataset.data]] ```python data() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2110) La tabla Apache Arrow que respalda el conjunto de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.data MemoryMappedTable text: string label: int64 ---- text: [["compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .","the soundtrack alone is worth the price of admission .","rodriguez does a splendid job of racial profiling hollywood style--casting excellent latin actors of all ages--a trend long overdue .","beneath the film's obvious determination to shock at any cost lies considerable skill and determination , backed by sheer nerve .","bielinsky is a filmmaker of impressive talent .","so beautifully acted and directed , it's clear that washington most certainly has a new career ahead of him if he so chooses .","a visual spectacle full of stunning images and effects .","a gentle and engrossing character study .","it's enough to watch huppert scheming , with her small , intelligent eyes as steady as any noir villain , and to enjoy the perfectly pitched web of tension that chabrol spins .","an engrossing portrait of uncompromising artists trying to create something original against the backdrop of a corporate music industry that only seems to care about the bottom line .",...,"ultimately , jane learns her place as a girl , softens up and loses some of the intensity that made her an interesting character to begin with .","ah-nuld's action hero days might be over .","it's clear why deuces wild , which was shot two years ago , has been gathering dust on mgm's shelf .","feels like nothing quite so much as a middle-aged moviemaker's attempt to surround himself with beautiful , half-naked women .","when the precise nature of matthew's predicament finally comes into sharp focus , the revelation fails to justify the build-up .","this picture is murder by numbers , and as easy to be bored by as your abc's , despite a few whopping shootouts .","hilarious musical comedy though stymied by accents thick as mud .","if you are into splatter movies , then you will probably have a reasonably good time with the salton sea .","a dull , simple-minded and stereotypical tale of drugs , death and mind-numbing indifference on the inner-city streets .","the feature-length stretch . . . strains the show's concept ."]] label: [[1,1,1,1,1,1,1,1,1,1,...,0,0,0,0,0,0,0,0,0,0]] ``` #### cache_files[[datasets.Dataset.cache_files]] ```python cache_files() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2130) Los archivos de caché que contienen la tabla Apache Arrow que respalda el conjunto de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.cache_files [{'filename': '/root/.cache/huggingface/datasets/rotten_tomatoes_movie_review/default/1.0.0/40d411e45a6ce3484deed7cc15b82a53dad9a72aafd9f86f8f227134bec5ca46/rotten_tomatoes_movie_review-validation.arrow'}] ``` #### num_columns[[datasets.Dataset.num_columns]] ```python num_columns() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2148) Número de columnas en el conjunto de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.num_columns 2 ``` #### num_rows[[datasets.Dataset.num_rows]] ```python num_rows() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2163) Número de filas en el conjunto de datos (igual que [Dataset.__len__()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.__len__)). Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.num_rows 1066 ``` #### column_names[[datasets.Dataset.column_names]] ```python column_names() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2180) Nombres de las columnas en el conjunto de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.column_names ['text', 'label'] ``` #### shape[[datasets.Dataset.shape]] ```python shape() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2195) Forma del conjunto de datos (número de columnas, número de filas). Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.shape (1066, 2) ``` #### único[[datasets.Dataset.unique]] ```python unique(column: str) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2212) **Parámetros:** column (`str`) : Nombre de la columna (lista todos los nombres de columnas con [column_names](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.column_names)). **Devuelve:** `list` Lista de elementos únicos en la columna indicada. Devuelve una lista de los elementos únicos de una columna. Esto se implementa en el backend de bajo nivel y, por lo tanto, es muy rápido. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.unique('label') [1, 0] ``` #### flatten[[datasets.Dataset.flatten]] ```python flatten(new_fingerprint: typing.Optional[str] = None, max_depth = 16) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2318) **Parámetros:** new_fingerprint (`str`, *opcional*) : La nueva huella digital del conjunto de datos después de la transformación. Si es `None`, la nueva huella digital se calcula utilizando un hash de la huella digital anterior y de los argumentos de la transformación. **Devuelve:** [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) Una copia del conjunto de datos con columnas aplanadas. Aplana la tabla. Cada columna con un tipo de estructura se aplana en una columna por cada campo de la estructura. Las demás columnas se mantienen sin cambios. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rajpurkar/squad", split="train") >>> ds.features {'id': Value('string'), 'title': Value('string'), 'context': Value('string'), 'question': Value('string'), 'answers': {'text': List(Value('string')), 'answer_start': List(Value('int32'))}} >>> ds = ds.flatten() >>> ds Dataset({ features: ['id', 'title', 'context', 'question', 'answers.text', 'answers.answer_start'], num_rows: 87599 }) ``` #### cast[[datasets.Dataset.cast]] ```python cast(features: Features, batch_size: typing.Optional[int] = 1000, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, num_proc: typing.Optional[int] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2365) **Parámetros:** features ([Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features)) : Nuevas características a las que se debe convertir el conjunto de datos. El nombre de los campos en las características debe coincidir con los nombres actuales de las columnas. El tipo de los datos también debe ser convertible de un tipo a otro. Para conversiones no triviales, p. ej. `str` <-> `ClassLabel`, debe usar [map()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.map) para actualizar el Dataset. batch_size (`int`, por defecto `1000`) : Número de ejemplos por lote proporcionados a cast. Si `batch_size <= 0` o `batch_size == None`, se proporciona el conjunto de datos completo como un único lote a cast. keep_in_memory (`bool`, por defecto `False`) : Si se debe copiar los datos en memoria. load_from_cache_file (`bool`, por defecto `True` si la caché está habilitada) : Si se puede identificar un archivo de caché que almacene el cálculo actual de `function`, úsalo en lugar de recalcular. cache_file_name (`str`, *opcional*, valor predeterminado `None`) : Proporcione el nombre de una ruta para el archivo de caché. Se utiliza para almacenar los resultados del cálculo en lugar del nombre de archivo de caché generado automáticamente. writer_batch_size (`int`, por defecto `1000`) : Número de filas por operación de escritura para el escritor de archivos de caché. Este valor es un buen equilibrio entre el uso de memoria durante el procesamiento y la velocidad de procesamiento. Un valor más alto hace que el procesamiento realice menos búsquedas, mientras que un valor más bajo consume menos memoria temporal durante la ejecución de [map()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.map). num_proc (`int`, *opcional*, valor predeterminado `None`) : Número de procesos para la multiprocesación. De forma predeterminada, no utiliza multiprocesación. **Devuelve:** [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) Una copia del conjunto de datos con las características convertidas. Castea el conjunto de datos a un nuevo conjunto de características. Ejemplo: ```py >>> from datasets import load_dataset, ClassLabel, Value >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> new_features = ds.features.copy() >>> new_features['label'] = ClassLabel(names=['bad', 'good']) >>> new_features['text'] = Value('large_string') >>> ds = ds.cast(new_features) >>> ds.features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('large_string')} ``` #### cast_column[[datasets.Dataset.cast_column]] ```python cast_column(column: str, feature: typing.Union[dict, list, tuple, datasets.features.features.Value, datasets.features.features.ClassLabel, datasets.features.translation.Translation, datasets.features.translation.TranslationVariableLanguages, datasets.features.features.LargeList, datasets.features.features.List, datasets.features.features.Array2D, datasets.features.features.Array3D, datasets.features.features.Array4D, datasets.features.features.Array5D, datasets.features.audio.Audio, datasets.features.image.Image, datasets.features.mesh.Mesh, datasets.features.video.Video, datasets.features.pdf.Pdf, datasets.features.nifti.Nifti, datasets.features.bio_sequence.BioSequence, datasets.features.bio_structure.BioStructure], new_fingerprint: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2449) **Parámetros:** column (`str`) : Nombre de la columna. feature (`FeatureType`) : Característica objetivo. new_fingerprint (`str`, *opcional*) : La nueva huella digital del conjunto de datos después de la transformación. Si es `None`, la nueva huella digital se calcula utilizando un hash de la huella digital anterior y de los argumentos de la transformación. **Devuelve:** [Conjunto de datos](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) Castea la columna a característica para la decodificación. Ejemplo: ```py >>> from datasets import load_dataset, ClassLabel >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> ds = ds.cast_column('label', ClassLabel(names=['bad', 'good'])) >>> ds.features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('string')} ``` #### remove_columns[[datasets.Dataset.remove_columns]] ```python remove_columns(column_names: typing.Union[str, list[str]], new_fingerprint: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2492) **Parámetros:** column_names (`Union[str, List[str]]`) : Nombre de la(s) columna(s) a eliminar. new_fingerprint (`str`, *opcional*) : La nueva huella digital del conjunto de datos después de la transformación. Si es `None`, la nueva huella digital se calcula utilizando un hash de la huella digital anterior y de los argumentos de la transformación. **Devuelve:** [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) Una copia del objeto de datos sin las columnas a eliminar. Elimina una o varias columnas del conjunto de datos y las características asociadas a ellas. También puede eliminar una columna usando [map()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.map) con `remove_columns`, pero el método presente no copia los datos de las columnas restantes y, por lo tanto, es más rápido. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.remove_columns('label') Dataset({ features: ['text'], num_rows: 1066 }) >>> ds = ds.remove_columns(column_names=ds.column_names) # Removing all the columns returns an empty dataset with the `num_rows` property set to 0 Dataset({ features: [], num_rows: 0 }) ``` #### rename_column[[datasets.Dataset.rename_column]] ```python rename_column(original_column_name: str, new_column_name: str, new_fingerprint: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2547) **Parámetros:** original_column_name (`str`) : Nombre de la columna a renombrar. new_column_name (`str`) : Nuevo nombre para la columna. new_fingerprint (`str`, *opcional*) : La nueva huella digital del conjunto de datos después de la transformación. Si es `None`, la nueva huella digital se calcula utilizando un hash de la huella digital anterior y de los argumentos de la transformación. **Devuelve:** [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) Una copia del conjunto de datos con una columna renombrada. Renombrar una columna en el conjunto de datos y mover las características asociadas a la columna original bajo el nuevo nombre de columna. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.rename_column('label', 'label_new') Dataset({ features: ['text', 'label_new'], num_rows: 1066 }) ``` #### rename_columns[[datasets.Dataset.rename_columns]] ```python rename_columns(column_mapping: dict, new_fingerprint: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2613) **Parámetros:** column_mapping (`Dict[str, str]`) : Un mapeo de columnas a renombrar a sus nuevos nombres new_fingerprint (`str`, *opcional*) : La nueva huella digital del conjunto de datos después de la transformación. Si es `None`, la nueva huella digital se calcula utilizando un hash de la huella digital anterior y de los argumentos de la transformación. **Devuelve:** [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) Una copia del conjunto de datos con columnas renombradas Renombrar varias columnas en el conjunto de datos y mover las características asociadas a las columnas originales bajo los nuevos nombres de columna. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.rename_columns({'text': 'text_new', 'label': 'label_new'}) Dataset({ features: ['text_new', 'label_new'], num_rows: 1066 }) ``` #### select_columns[[datasets.Dataset.select_columns]] ```python select_columns(column_names: typing.Union[str, list[str]], new_fingerprint: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2680) **Parámetros:** column_names (`Union[str, List[str]]`) : Nombre de la(s) columna(s) a conservar. new_fingerprint (`str`, *opcional*) : La nueva huella digital del conjunto de datos después de la transformación. Si es `None`, la nueva huella digital se calcula utilizando un hash de la huella digital anterior y de los argumentos de la transformación. **Devuelve:** [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) Una copia del objeto de conjunto de datos que solo consiste en las columnas seleccionadas. Seleccione una o varias columnas del conjunto de datos y las características asociadas a ellas. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.select_columns(['text']) >>> ds Dataset({ features: ['text'], num_rows: 1066 }) ``` #### class_encode_column[[datasets.Dataset.class_encode_column]] ```python class_encode_column(column: str, include_nulls: bool = False) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2243) **Parámetros:** column (`str`) : El nombre de la columna a convertir (lista todos los nombres de columnas con [column_names](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.column_names)) include_nulls (`bool`, por defecto `False`) : Si se incluyen valores nulos en las etiquetas de clase. Si es `True`, los valores nulos se codificarán como la etiqueta de clase `"None"`. Convierte la columna indicada en [ClassLabel](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.ClassLabel) y actualiza la tabla. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("google/boolq", split="validation") >>> ds.features {'answer': Value('bool'), 'passage': Value('string'), 'question': Value('string')} >>> ds = ds.class_encode_column('answer') >>> ds.features {'answer': ClassLabel(num_classes=2, names=['False', 'True']), 'passage': Value('string'), 'question': Value('string')} ``` #### __len__[[datasets.Dataset.__len__]] ```python __len__() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2736) Número de filas en el conjunto de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.__len__ ``` #### __iter__[[datasets.Dataset.__iter__]] ```python __iter__() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2753) Itera sobre los ejemplos. Si se establece un formato con [Dataset.set_format()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.set_format), las filas se devolverán con el formato seleccionado. #### iter[[datasets.Dataset.iter]] ```python iter(batch_size: int, drop_last_batch: bool = False) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2782) **Parámetros:** batch_size (`int`) : tamaño de cada lote que se generará. drop_last_batch (`bool`, por defecto *False*) : Si un último lote más pequeño que batch_size debe descartarse Itera sobre los lotes de tamaño *batch_size*. Si se establece un formato con [*~datasets.Dataset.set_format*], las filas se devolverán con el formato seleccionado. #### formatted_as[[datasets.Dataset.formatted_as]] ```python formatted_as(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2826) **Parámetros:** type (`str`, *opcional*) : Tipo de salida seleccionado en `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` significa que `__getitem__`` devuelve objetos de python (predeterminado). columns (`List[str]`, *opcional*) : Columnas para formatear en la salida. `None` significa que `__getitem__` devuelve todas las columnas (predeterminado). output_all_columns (`bool`, por defecto `False`) : Mantener también las columnas sin formato en la salida (como objetos de Python). - ****format_kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave pasados a la función de conversión, como `np.array`, `torch.tensor` o `tensorflow.ragged.constant`. Para usarse en una declaración `with`. Establece el formato de retorno de `__getitem__` (tipo y columnas). #### set_format[[datasets.Dataset.set_format]] ```python set_format(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2858) **Parámetros:** type (`str`, *opcional*) : Tipo de salida seleccionado en `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` significa que `__getitem__` devuelve objetos de python (predeterminado). columns (`List[str]`, *opcional*) : Columnas para formatear en la salida. `None` significa que `__getitem__` devuelve todas las columnas (predeterminado). output_all_columns (`bool`, por defecto `False`) : Mantener también las columnas sin formato en la salida (como objetos de Python). - ****format_kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave pasados a la función de conversión, como `np.array`, `torch.tensor` o `tensorflow.ragged.constant`. Establece el formato de retorno de `__getitem__` (tipo y columnas). El formato de los datos se aplica sobre la marcha. El formato `type` (por ejemplo, "numpy") se utiliza para formatear los lotes al usar `__getitem__`. También es posible usar transformaciones personalizadas para el formato mediante [set_transform()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.set_transform). Es posible llamar a [map()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.map) después de llamar a `set_format`. Dado que `map` puede añadir nuevas columnas, la lista de columnas formateadas se actualiza. En este caso, si aplicas `map` a un conjunto de datos para añadir una nueva columna, esta columna se formateará de la siguiente manera: ``` new formatted columns = (all columns - previously unformatted columns) ``` Ejemplo: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True) >>> ds.set_format(type='numpy', columns=['text', 'label']) >>> ds.format {'type': 'numpy', 'format_kwargs': {}, 'columns': ['text', 'label'], 'output_all_columns': False} ``` #### set_transform[[datasets.Dataset.set_transform]] ```python set_transform(transform: typing.Optional[typing.Callable], columns: typing.Optional[list] = None, output_all_columns: bool = False) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2966) **Parámetros:** transform (`Callable`, *opcional*) : Transformación de formato definida por el usuario, reemplaza el formato definido por [set_format()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.set_format). Una función de formato es un objeto invocable que toma un lote (como un `dict`) como entrada y devuelve un lote. Esta función se aplica justo antes de devolver los objetos en `__getitem__`. columns (`List[str]`, *opcional*) : Columnas para formatear en la salida. Si se especifica, el lote de entrada de la transformación solo contiene esas columnas. output_all_columns (`bool`, por defecto `False`) : Mantener también las columnas sin formato en la salida (como objetos de Python). Si se establece en True, las demás columnas sin formato se conservan junto con la salida de la transformación. Establece el formato de retorno de `__getitem__` usando esta transformación. La transformación se aplica al vuelo en los lotes cuando se llama a `__getitem__`. Al igual que [set_format()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.set_format), esto se puede restablecer usando [reset_format()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.reset_format). Ejemplo: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased') >>> def encode(batch): ... return tokenizer(batch['text'], padding=True, truncation=True, return_tensors='pt') >>> ds.set_transform(encode) >>> ds[0] {'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), 'input_ids': tensor([ 101, 29353, 2135, 15102, 1996, 9428, 20868, 2890, 8663, 6895, 20470, 2571, 3663, 2090, 4603, 3017, 3008, 1998, 2037, 24211, 5637, 1998, 11690, 2336, 1012, 102]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])} ``` #### reset_format[[datasets.Dataset.reset_format]] ```python reset_format() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2937) Restablecer el formato de retorno de `__getitem__` a objetos de Python y todas las columnas. Igual que `self.set_format()` Ejemplo: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True) >>> ds.set_format(type='numpy', columns=['input_ids', 'token_type_ids', 'attention_mask', 'label']) >>> ds.format {'columns': ['input_ids', 'token_type_ids', 'attention_mask', 'label'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'numpy'} >>> ds.reset_format() >>> ds.format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': None} ``` #### with_format[[datasets.Dataset.with_format]] ```python with_format(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L3009) **Parámetros:** type (`str`, *opcional*) : Tipo de salida seleccionado en `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` significa que `__getitem__` devuelve objetos de python (predeterminado). columns (`List[str]`, *opcional*) : Columnas para formatear en la salida. `None` significa que `__getitem__` devuelve todas las columnas (predeterminado). output_all_columns (`bool`, por defecto `False`) : Mantener también las columnas sin formato en la salida (como objetos de Python). - ****format_kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave pasados a la función de conversión, como `np.array`, `torch.tensor` o `tensorflow.ragged.constant`. Establece el formato de retorno de `__getitem__` (tipo y columnas). El formato de los datos se aplica sobre la marcha. El formato `type` (por ejemplo, "numpy") se utiliza para formatear los lotes al usar `__getitem__`. También es posible usar transformaciones personalizadas para el formato mediante [with_transform()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.with_transform). A diferencia de [set_format()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.set_format), `with_format` devuelve un nuevo objeto [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset). Ejemplo: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True) >>> ds.format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': None} >>> ds = ds.with_format("torch") >>> ds.format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'torch'} >>> ds[0] {'text': 'compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .', 'label': tensor(1), 'input_ids': tensor([ 101, 18027, 16310, 16001, 1103, 9321, 178, 11604, 7235, 6617, 1742, 2165, 2820, 1206, 6588, 22572, 12937, 1811, 2153, 1105, 1147, 12890, 19587, 6463, 1105, 15026, 1482, 119, 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])} ``` #### with_transform[[datasets.Dataset.with_transform]] ```python with_transform(transform: typing.Optional[typing.Callable], columns: typing.Optional[list] = None, output_all_columns: bool = False) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L3080) **Parámetros:** transform (`Callable`, `optional`) : Transformación de formato definida por el usuario, reemplaza el formato definido por [set_format()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.set_format). Una función de formato es un objeto invocable que toma un lote (como un `dict`) como entrada y devuelve un lote. Esta función se aplica justo antes de devolver los objetos en `__getitem__`. columns (`List[str]`, `optional`) : Columnas que se formatearán en la salida. Si se especifica, el lote de entrada de la transformación solo contiene esas columnas. output_all_columns (`bool`, por defecto `False`) : Mantener también las columnas sin formato en la salida (como objetos de Python). Si se establece en `True`, las demás columnas sin formato se conservan junto con la salida de la transformación. Establezca el formato de retorno de `__getitem__` usando esta transformación. La transformación se aplica al vuelo en los lotes cuando se llama a `__getitem__`. Al igual que [set_format()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.set_format), esto se puede restablecer usando [reset_format()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.reset_format). A diferencia de [set_transform()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.set_transform), `with_transform` devuelve un nuevo objeto [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset). Ejemplo: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> def encode(example): ... return tokenizer(example["text"], padding=True, truncation=True, return_tensors='pt') >>> ds = ds.with_transform(encode) >>> ds[0] {'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), 'input_ids': tensor([ 101, 18027, 16310, 16001, 1103, 9321, 178, 11604, 7235, 6617, 1742, 2165, 2820, 1206, 6588, 22572, 12937, 1811, 2153, 1105, 1147, 12890, 19587, 6463, 1105, 15026, 1482, 119, 102]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])} ``` #### __getitem__[[datasets.Dataset.__getitem__]] ```python __getitem__(key) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L3156) Se puede usar para indexar columnas (por nombres de cadena) o filas (por índice entero o iterable de índices o booleanos). #### cleanup_cache_files[[datasets.Dataset.cleanup_cache_files]] ```python cleanup_cache_files() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L3169) **Devuelve:** `int` Número de archivos eliminados. Limpia todos los archivos de caché en el directorio de caché del conjunto de datos, excepto el archivo de caché actualmente en uso, si lo hay. Tenga cuidado al ejecutar este comando para asegurarse de que ningún otro proceso esté utilizando actualmente otros archivos de caché. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.cleanup_cache_files() 10 ``` #### map[[datasets.Dataset.map]] ```python map(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_rank: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, drop_last_batch: bool = False, remove_columns: typing.Union[str, list[str], NoneType] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, features: typing.Optional[datasets.features.features.Features] = None, disable_nullable: bool = False, fn_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, suffix_template: str = '_{rank:05d}_of_{num_proc:05d}', new_fingerprint: typing.Optional[str] = None, desc: typing.Optional[str] = None, try_original_type: typing.Optional[bool] = True, on_mixed_types: typing.Optional[typing.Literal['use_json']] = 'use_json') ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L3216) **Parámetros:** function (`Callable`) : Función con una de las siguientes firmas: - `function(example: Dict[str, Any]) -> Dict[str, Any]` si `batched=False` y `with_indices=False` y `with_rank=False` - `function(example: Dict[str, Any], *extra_args) -> Dict[str, Any]` si `batched=False` y `with_indices=True` y/o `with_rank=True` (un argumento adicional por cada uno) - `function(batch: Dict[str, List]) -> Dict[str, List]` si `batched=True` y `with_indices=False` y `with_rank=False` - `function(batch: Dict[str, List], *extra_args) -> Dict[str, List]` si `batched=True` y `with_indices=True` y/o `with_rank=True` (un argumento adicional por cada uno) Para un uso avanzado, la función también puede devolver una `pyarrow.Table`. Si la función es asíncrona, `map` ejecutará su función en paralelo. Además, si su función no devuelve nada (`None`), `map` ejecutará su función y devolverá el conjunto de datos sin cambios. Si no se proporciona ninguna función, se usa la función identidad por defecto: `lambda x: x`. with_indices (`bool`, por defecto `False`) : Proporciona índices de ejemplos a `function`. Ten en cuenta que, en este caso, la firma de `function` debe ser `def function(example, idx[, rank]): ...`. with_rank (`bool`, por defecto `False`) : Proporciona el rango del proceso a `function`. Tenga en cuenta que, en este caso, la firma de `function` debe ser `def function(example[, idx], rank): ...`. input_columns (`Optional[Union[str, List[str]]]`, por defecto `None`) : Las columnas que se pasarán a `function` como argumentos posicionales. Si es `None`, se pasa un `dict` que mapea todas las columnas formateadas como un solo argumento. batched (`bool`, por defecto `False`) : Proporcionar un lote de ejemplos a `function`. batch_size (`int`, *opcional*, valor predeterminado `1000`) : Número de ejemplos por lote que se proporcionan a `function` si `batched=True`. Si `batch_size <= 0` o `batch_size == None`, se proporciona el conjunto de datos completo como un único lote a `function`. drop_last_batch (`bool`, por defecto `False`) : Si un último lote más pequeño que batch_size debe descartarse en lugar de ser procesado por la función. remove_columns (`Optional[Union[str, List[str]]]`, por defecto `None`) : Elimina una selección de columnas durante el mapeo. Las columnas se eliminarán antes de actualizar los ejemplos con la salida de `function`, es decir, si `function` está añadiendo columnas con nombres en `remove_columns`, estas columnas se conservarán. keep_in_memory (`bool`, por defecto `False`) : Mantener el conjunto de datos en memoria en lugar de escribirlo en un archivo de caché. load_from_cache_file (`Optional[bool]`, por defecto `True` si la caché está habilitada) : Si se puede identificar un archivo de caché que almacene el cálculo actual de `function`, úsese en lugar de recalcular. cache_file_name (`str`, *opcional*, valor predeterminado `None`) : Proporcione el nombre de una ruta para el archivo de caché. Se utiliza para almacenar los resultados del cálculo en lugar del nombre de archivo de caché generado automáticamente. writer_batch_size (`int`, por defecto `1000`) : Número de filas por operación de escritura para el escritor de archivos de caché. Este valor es un buen equilibrio entre el uso de memoria durante el procesamiento y la velocidad de procesamiento. Un valor más alto hace que el procesamiento realice menos búsquedas, mientras que un valor más bajo consume menos memoria temporal durante la ejecución de `map`. features (`Optional[datasets.Features]`, por defecto `None`) : Utilice un Features específico para almacenar el archivo de caché en lugar del generado automáticamente. disable_nullable (`bool`, por defecto `False`) : No permite valores nulos en la tabla. fn_kwargs (`Dict`, *opcional*, valor predeterminado `None`) : Argumentos de palabra clave que se pasarán a `function`. num_proc (`int`, *opcional*, valor predeterminado `None`) : El número de procesos a utilizar para la multiprocesación. - Si es `None` o `0`, no se utiliza multiprocesación y la operación se ejecuta en el proceso principal. - Si es mayor que `1`, se utiliza uno o varios procesos de trabajo para procesar los datos en paralelo. Nota: la función pasada a `map()` debe ser serializable (picklable) para que la multiprocesación funcione correctamente (es decir, se prefieren las funciones definidas en el nivel superior de un módulo, no dentro de otra función o clase). suffix_template (`str`): Si se especifica `cache_file_name`, se añadirá este sufijo al final del nombre base de cada uno. El valor predeterminado es `"_{rank:05d}_of_{num_proc:05d}"`. Por ejemplo, si `cache_file_name` es "processed.arrow", entonces para `rank=1` y `num_proc=4`, el archivo resultante sería `"processed_00001_of_00004.arrow"` para el sufijo predeterminado. new_fingerprint (`str`, *opcional*, por defecto `None`) : La nueva huella digital del conjunto de datos después de la transformación. Si es `None`, la nueva huella digital se calcula usando un hash de la huella digital anterior y los argumentos de la transformación. desc (`str`, *opcional*, valor predeterminado `None`) : Descripción significativa que se mostrará junto con la barra de progreso mientras se mapean los ejemplos. try_original_type (`Optional[bool]`, por defecto `True`) : Intenta mantener los tipos de las columnas originales (p. ej. int32 -> int32). Establece False si deseas inferir siempre nuevos tipos. on_mixed_types (`Literal["use_json"]`, *opcional*, valor predeterminado `None`) : Si es "use_json", se utiliza el tipo Json() para campos de tipos mixtos, es decir, campos no estructurados que contienen datos sin un esquema predefinido. En este caso, un campo de tipo mixto se establece como Json(). Esto permite cargar listas con una mezcla de strings/integers/floats, por ejemplo, o diccionarios con tipos de valores arbitrarios. Aplica una función a todos los ejemplos de la tabla (individualmente o en lotes) y actualiza la tabla. Si tu función devuelve una columna que ya existe, la sobrescribe. Puede especificar si la función debe agruparse o no con el parámetro `batched`: - Si `False`, la función toma 1 ejemplo como entrada y debe devolver 1 ejemplo. Un ejemplo es un diccionario, p. ej. `{"text": "Hello there !"}`. - Si `True` y `batch_size` es 1, la función toma un lote de 1 ejemplo como entrada y puede devolver un lote con 1 o más ejemplos. Un lote es un diccionario, por ejemplo, un lote de 1 ejemplo es `{"text": ["Hello there !"]}`. - Si `True` y `batch_size` es `n > 1`, la función toma como entrada un lote de `n` ejemplos y puede devolver un lote con `n` ejemplos, o con un número arbitrario de ejemplos. Tenga en cuenta que el último lote puede tener menos de `n` ejemplos. Un lote es un diccionario, por ejemplo, un lote de `n` ejemplos es `{"text": ["Hello there !"] * n}`. Si la función es asíncrona, `map` ejecutará tu función en paralelo, con hasta mil llamadas simultáneas. Se recomienda usar un `asyncio.Semaphore` en tu función si deseas establecer un número máximo de operaciones que pueden ejecutarse al mismo tiempo. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> def add_prefix(example): ... example["text"] = "Review: " + example["text"] ... return example >>> ds = ds.map(add_prefix) >>> ds[0:3]["text"] ['Review: compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .', 'Review: the soundtrack alone is worth the price of admission .', 'Review: rodriguez does a splendid job of racial profiling hollywood style--casting excellent latin actors of all ages--a trend long overdue .'] # process a batch of examples >>> ds = ds.map(lambda example: tokenizer(example["text"]), batched=True) # set number of processors >>> ds = ds.map(add_prefix, num_proc=4) ``` #### filtro[[datasets.Dataset.filter]] ```python filter(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_rank: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, fn_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, suffix_template: str = '_{rank:05d}_of_{num_proc:05d}', new_fingerprint: typing.Optional[str] = None, desc: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4149) **Parámetros:** function (`Callable`) : Llamable con una de las siguientes firmas: - `function(example: Dict[str, Any]) -> bool` si `batched=False` y `with_indices=False` y `with_rank=False` - `function(example: Dict[str, Any], *extra_args) -> bool` si `batched=False` y `with_indices=True` y/o `with_rank=True` (un argumento extra por cada uno) - `function(batch: Dict[str, List]) -> List[bool]` si `batched=True` y `with_indices=False` y `with_rank=False` - `function(batch: Dict[str, List], *extra_args) -> List[bool]` si `batched=True` y `with_indices=True` y/o `with_rank=True` (un argumento extra por cada uno) Si la función es asíncrona, `filter` ejecutará su función en paralelo. Si no se proporciona ninguna función, el valor predeterminado es una función que siempre devuelve `True`: `lambda x: True`. with_indices (`bool`, por defecto `False`) : Proporciona índices de ejemplos a `function`. Ten en cuenta que, en este caso, la firma de `function` debe ser `def function(example, idx[, rank]): ...`. with_rank (`bool`, por defecto `False`) : Proporciona el rango del proceso a `function`. Tenga en cuenta que, en este caso, la firma de `function` debe ser `def function(example[, idx], rank): ...`. input_columns (`str` o `List[str]`, *opcional*) : Las columnas que se pasarán a `function` como argumentos posicionales. Si es `None`, se pasa un `dict` que mapea todas las columnas formateadas como un solo argumento. batched (`bool`, por defecto `False`) : Proporcionar un lote de ejemplos a `function`. batch_size (`int`, *opcional*, valor predeterminado `1000`) : Número de ejemplos por lote que se proporcionan a `function` si `batched = True`. Si `batched = False`, se pasa un ejemplo por lote a `function`. Si `batch_size <= 0` o `batch_size == None`, se proporciona el conjunto de datos completo como un único lote a `function`. keep_in_memory (`bool`, por defecto `False`) : Mantener el conjunto de datos en memoria en lugar de escribirlo en un archivo de caché. load_from_cache_file (`Optional[bool]`, por defecto `True` si la caché está habilitada) : Si se puede identificar un archivo de caché que almacene el cálculo actual de `function`, úsese en lugar de recalcular. cache_file_name (`str`, *opcional*) : Proporcione el nombre de una ruta para el archivo de caché. Se utiliza para almacenar los resultados del cálculo en lugar del nombre de archivo de caché generado automáticamente. writer_batch_size (`int`, por defecto `1000`) : Número de filas por operación de escritura para el escritor de archivos de caché. Este valor es un buen equilibrio entre el uso de memoria durante el procesamiento y la velocidad de procesamiento. Un valor más alto hace que el procesamiento realice menos búsquedas, mientras que un valor más bajo consume menos memoria temporal durante la ejecución de `map`. fn_kwargs (`dict`, *opcional*) : Argumentos de palabra clave que se pasarán a `function`. num_proc (`int`, *opcional*, valor predeterminado `None`) : El número de procesos a utilizar para la multiprocesación. - Si es `None` o `0`, no se utiliza multiprocesación y la operación se ejecuta en el proceso principal. - Si es mayor que `1`, se utiliza uno o varios procesos de trabajo para procesar los datos en paralelo. Nota: La función pasada a `map()` debe ser serializable (picklable) para que la multiprocesación funcione correctamente (es decir, se prefieren las funciones definidas en el nivel superior de un módulo, no dentro de otra función o clase). suffix_template (`str`) : Si se especifica `cache_file_name`, este sufijo se añadirá al final del nombre base de cada archivo. Por ejemplo, si `cache_file_name` es `"processed.arrow"`, entonces para `rank = 1` y `num_proc = 4`, el archivo resultante sería `"processed_00001_of_00004.arrow"` para el sufijo predeterminado (predeterminado `_{rank:05d}_of_{num_proc:05d}`). new_fingerprint (`str`, *opcional*) : La nueva huella digital del conjunto de datos después de la transformación. Si es `None`, la nueva huella digital se calcula utilizando un hash de la huella digital anterior y de los argumentos de la transformación. desc (`str`, *opcional*, valor predeterminado `None`) : Descripción significativa que se mostrará junto con la barra de progreso mientras se filtran los ejemplos. Aplicar una función de filtro a todos los elementos de la tabla por lotes y actualizar la tabla para que el conjunto de datos solo incluya ejemplos según la función de filtro. Si la función es asíncrona, `filter` ejecutará tu función en paralelo, con un máximo de mil llamadas simultáneas (configurable). Se recomienda usar un `asyncio.Semaphore` en tu función si deseas establecer un número máximo de operaciones que pueden ejecutarse al mismo tiempo. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.filter(lambda x: x["label"] == 1) >>> ds Dataset({ features: ['text', 'label'], num_rows: 533 }) ``` #### seleccionar[[datasets.Dataset.select]] ```python select(indices: Iterable, keep_in_memory: bool = False, indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, new_fingerprint: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4376) **Parámetros:** indices (`range`, `list`, `iterable`, `ndarray` o `Series`) : Rango, lista o matriz unidimensional de índices enteros para el indexado. Si los índices corresponden a un rango contiguo, la tabla Arrow se corta simplemente. Sin embargo, pasar una lista de índices que no son contiguos crea un mapeo de índices, lo cual es mucho menos eficiente, pero aún así más rápido que recrear una tabla Arrow compuesta por las filas solicitadas. keep_in_memory (`bool`, por defecto `False`) : Mantener el mapeo de índices en memoria en lugar de escribirlo en un archivo de caché. indices_cache_file_name (`str`, *opcional*, valor predeterminado `None`) : Proporcione el nombre de una ruta para el archivo de caché. Se utiliza para almacenar el mapeo de índices en lugar del nombre de archivo de caché generado automáticamente. writer_batch_size (`int`, por defecto `1000`) : Número de filas por operación de escritura para el escritor de archivos de caché. Este valor es un buen equilibrio entre el uso de memoria durante el procesamiento y la velocidad de procesamiento. Un valor más alto hace que el procesamiento realice menos búsquedas, mientras que un valor más bajo consume menos memoria temporal durante la ejecución de `map`. new_fingerprint (`str`, *opcional*, por defecto `None`) : La nueva huella digital del conjunto de datos después de la transformación. Si es `None`, la nueva huella digital se calcula usando un hash de la huella digital anterior y los argumentos de la transformación. Cree un nuevo conjunto de datos con las filas seleccionadas según la lista/matriz de índices. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.select(range(4)) >>> ds Dataset({ features: ['text', 'label'], num_rows: 4 }) ``` #### sort[[datasets.Dataset.sort]] ```python sort(column_names: typing.Union[str, collections.abc.Sequence[str]], reverse: typing.Union[bool, collections.abc.Sequence[bool]] = False, null_placement: str = 'at_end', keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, new_fingerprint: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4717) **Parámetros:** column_names (`Union[str, Sequence[str]]`) : Nombre(s) de columna(s) para ordenar. reverse (`Union[bool, Sequence[bool]]`, por defecto `False`) : Si es `True`, ordena en orden descendente en lugar de ascendente. Si se proporciona un solo bool, el valor se aplica al ordenamiento de todos los nombres de columnas. En caso contrario, se debe proporcionar una lista de bools con la misma longitud y orden que column_names. null_placement (`str`, por defecto `at_end`) : Coloca los valores `None` al principio si es `at_start` o `first`, o al final si es `at_end` o `last` keep_in_memory (`bool`, por defecto `False`) : Mantener los índices ordenados en memoria en lugar de escribirlos en un archivo de caché. load_from_cache_file (`Optional[bool]`, por defecto `True` si la caché está habilitada) : Si se puede identificar un archivo de caché que almacene los índices ordenados, úsalo en lugar de recalcularlos. indices_cache_file_name (`str`, *opcional*, valor predeterminado `None`) : Proporcione el nombre de una ruta para el archivo de caché. Se utiliza para almacenar los índices ordenados en lugar del nombre de archivo de caché generado automáticamente. writer_batch_size (`int`, por defecto `1000`) : Número de filas por operación de escritura para el escritor de archivos de caché. Un valor más alto genera archivos de caché más pequeños, mientras que un valor más bajo consume menos memoria temporal. new_fingerprint (`str`, *opcional*, por defecto `None`) : La nueva huella digital del conjunto de datos después de la transformación. Si es `None`, la nueva huella digital se calcula usando un hash de la huella digital anterior y los argumentos de la transformación Crea un nuevo conjunto de datos ordenado según una o varias columnas. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset('cornell-movie-review-data/rotten_tomatoes', split='validation') >>> ds['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] >>> sorted_ds = ds.sort('label') >>> sorted_ds['label'][:10] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] >>> another_sorted_ds = ds.sort(['label', 'text'], reverse=[True, False]) >>> another_sorted_ds['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ``` #### shuffle[[datasets.Dataset.shuffle]] ```python shuffle(seed: typing.Optional[int] = None, generator: typing.Optional[numpy.random._generator.Generator] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, new_fingerprint: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4845) **Parámetros:** seed (`int`, *opcional*) : Una semilla para inicializar el BitGenerator predeterminado si `generator=None`. Si es `None`, se extraerá entropía fresca e impredecible del sistema operativo. Si se pasa un `int` o un `array_like[ints]`, se pasará a SeedSequence para derivar el estado inicial del BitGenerator. generator (`numpy.random.Generator`, *opcional*) : Generador aleatorio de Numpy para calcular la permutación de las filas del conjunto de datos. Si `generator=None` (predeterminado), se utiliza `np.random.default_rng` (el BitGenerator predeterminado (PCG64) de NumPy). keep_in_memory (`bool`, por defecto `False`) : Mantener los índices barajados en memoria en lugar de escribirlos en un archivo de caché. load_from_cache_file (`Optional[bool]`, por defecto `True` si la caché está habilitada) : Si se puede identificar un archivo de caché que almacene los índices barajados, úsalo en lugar de recalcularlos. indices_cache_file_name (`str`, *opcional*) : Proporcione el nombre de una ruta para el archivo de caché. Se utiliza para almacenar los índices barajados en lugar del nombre de archivo de caché generado automáticamente. writer_batch_size (`int`, por defecto `1000`) : Número de filas por operación de escritura para el escritor de archivos de caché. Este valor es un buen equilibrio entre el uso de memoria durante el procesamiento y la velocidad de procesamiento. Un valor más alto hace que el procesamiento realice menos búsquedas, mientras que un valor más bajo consume menos memoria temporal durante la ejecución de `map`. new_fingerprint (`str`, *opcional*, por defecto `None`) : La nueva huella digital del conjunto de datos después de la transformación. Si es `None`, la nueva huella digital se calcula usando un hash de la huella digital anterior y los argumentos de la transformación. Crea un nuevo Dataset donde las filas estén barajadas. Actualmente, shuffling utiliza generadores aleatorios de numpy. Puede proporcionar un BitGenerator de NumPy para usar, o una semilla para iniciar el generador aleatorio predeterminado de NumPy (PCG64). Shuffling toma la lista de índices `[0:len(my_dataset)]` y la baraja para crear un mapeo de índices. Sin embargo, en cuanto tu [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) tiene un mapeo de índices, la velocidad puede ser 10 veces más lenta. Esto se debe a que hay un paso adicional para obtener el índice de la fila a leer usando el mapeo de índices y, lo más importante, ya no estás leyendo fragmentos de datos contiguos. Para restaurar la velocidad, necesitarías reescribir todo el dataset en tu disco de nuevo usando [Dataset.flatten_indices()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.flatten_indices), que elimina el mapeo de índices. Sin embargo, esto puede llevar mucho tiempo dependiendo del tamaño de su conjunto de datos: ```python my_dataset[0] # fast my_dataset = my_dataset.shuffle(seed=42) my_dataset[0] # up to 10x slower my_dataset = my_dataset.flatten_indices() # rewrite the shuffled dataset on disk as contiguous chunks of data my_dataset[0] # fast again ``` En este caso, recomendamos cambiar a un [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset) y aprovechar su rápido método de barajado aproximado [IterableDataset.shuffle()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset.shuffle). Solo reordena los fragmentos y añade un búfer de barajado a tu conjunto de datos, lo que mantiene la velocidad de tu conjunto de datos óptima: ```python my_iterable_dataset = my_dataset.to_iterable_dataset(num_shards=128) for example in enumerate(my_iterable_dataset): # fast pass shuffled_iterable_dataset = my_iterable_dataset.shuffle(seed=42, buffer_size=100) for example in enumerate(shuffled_iterable_dataset): # as fast as before pass ``` Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] # set a seed >>> shuffled_ds = ds.shuffle(seed=42) >>> shuffled_ds['label'][:10] [1, 0, 1, 1, 0, 0, 0, 0, 0, 0] ``` #### omitir[[datasets.Dataset.skip]] ```python skip(n: int) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4629) **Parámetros:** n (`int`) : Número de elementos a omitir. Crea un nuevo [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) que omita los primeros `n` elementos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> list(ds.take(3)) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}] >>> ds = ds.skip(1) >>> list(ds.take(3)) [{'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}, {'label': 1, 'text': 'if you sometimes like to go to the movies to have fun , wasabi is a good place to start .'}] ``` #### tomar[[datasets.Dataset.take]] ```python take(n: int) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4691) **Parámetros:** n (`int`) : Número de elementos a tomar. Cree un nuevo [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) con solo los primeros `n` elementos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> small_ds = ds.take(2) >>> list(small_ds) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}] ``` #### train_test_split[[datasets.Dataset.train_test_split]] ```python train_test_split(test_size: typing.Union[float, int, NoneType] = None, train_size: typing.Union[float, int, NoneType] = None, shuffle: bool = True, stratify_by_column: typing.Optional[str] = None, seed: typing.Optional[int] = None, generator: typing.Optional[numpy.random._generator.Generator] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, train_indices_cache_file_name: typing.Optional[str] = None, test_indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, train_new_fingerprint: typing.Optional[str] = None, test_new_fingerprint: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4982) **Parámetros:** test_size (`Union[float, int, None]`, *opcional*) : Tamaño de la división de prueba. Si es `float`, debe estar entre `0.0` y `1.0` y representar la proporción del conjunto de datos que se incluirá en la división de prueba. Si es `int`, representa el número absoluto de muestras de prueba. Si es `None`, el valor se establece como el complemento del tamaño de entrenamiento. Si `train_size` también es `None`, se establecerá en `0.25`. train_size (`Union[float, int, None]`, *opcional*) : Tamaño de la división de entrenamiento. Si es `float`, debe estar entre `0.0` y `1.0` y representar la proporción del conjunto de datos que se incluirá en la división de entrenamiento. Si es `int`, representa el número absoluto de muestras de entrenamiento. Si es `None`, el valor se establece automáticamente como el complemento del tamaño de la división de prueba. shuffle (`bool`, *opcional*, por defecto `True`) : Si se debe o no barajar los datos antes de dividirlos. stratify_by_column (`str`, *opcional*, valor predeterminado `None`) : El nombre de la columna de etiquetas que se usará para realizar una división estratificada de los datos. seed (`int`, *opcional*) : Una semilla para inicializar el BitGenerator predeterminado si `generator=None`. Si es `None`, se extraerá entropía fresca e impredecible del sistema operativo. Si se pasa un `int` o un `array_like[ints]`, se pasará a SeedSequence para derivar el estado inicial del BitGenerator. generator (`numpy.random.Generator`, *opcional*) : Generador aleatorio de Numpy para calcular la permutación de las filas del conjunto de datos. Si `generator=None` (predeterminado), se utiliza `np.random.default_rng` (el BitGenerator predeterminado (PCG64) de NumPy). keep_in_memory (`bool`, por defecto `False`) : Mantener los índices de las divisiones en memoria en lugar de escribirlos en un archivo de caché. load_from_cache_file (`Optional[bool]`, por defecto `True` si la caché está habilitada) : Si se puede identificar un archivo de caché que almacena los índices de las divisiones, úsalo en lugar de recalcularlos. train_cache_file_name (`str`, *opcional*) : Proporcione el nombre de una ruta para el archivo de caché. Se utiliza para almacenar los índices de la división de entrenamiento en lugar del nombre de archivo de caché generado automáticamente. test_cache_file_name (`str`, *opcional*) : Proporcione el nombre de una ruta para el archivo de caché. Se utiliza para almacenar los índices de la división de prueba en lugar del nombre de archivo de caché generado automáticamente. writer_batch_size (`int`, por defecto `1000`) : Número de filas por operación de escritura para el escritor de archivos de caché. Este valor es un buen equilibrio entre el uso de memoria durante el procesamiento y la velocidad de procesamiento. Un valor más alto hace que el procesamiento realice menos búsquedas, mientras que un valor más bajo consume menos memoria temporal durante la ejecución de `map`. train_new_fingerprint (`str`, *opcional*, por defecto `None`) : La nueva huella digital del conjunto de entrenamiento tras la transformación. Si es `None`, la nueva huella digital se calcula usando un hash de la huella digital anterior y los argumentos de la transformación test_new_fingerprint (`str`, *opcional*, valor predeterminado `None`) : La nueva huella digital del conjunto de pruebas tras la transformación. Si es `None`, la nueva huella digital se calcula mediante un hash de la huella digital anterior y los argumentos de la transformación Devuelve un diccionario ([datasets.DatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict)) con dos subconjuntos aleatorios de entrenamiento y prueba (`train` y `test`, divisiones `Dataset`). Las divisiones se crean a partir del conjunto de datos según `test_size`, `train_size` y `shuffle`. Este método es similar a `train_test_split` de scikit-learn. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds = ds.train_test_split(test_size=0.2, shuffle=True) DatasetDict({ train: Dataset({ features: ['text', 'label'], num_rows: 852 }) test: Dataset({ features: ['text', 'label'], num_rows: 214 }) }) # set a seed >>> ds = ds.train_test_split(test_size=0.2, seed=42) # stratified split >>> ds = load_dataset("stanfordnlp/imdb",split="train") Dataset({ features: ['text', 'label'], num_rows: 25000 }) >>> ds = ds.train_test_split(test_size=0.2, stratify_by_column="label") DatasetDict({ train: Dataset({ features: ['text', 'label'], num_rows: 20000 }) test: Dataset({ features: ['text', 'label'], num_rows: 5000 }) }) ``` #### shard[[datasets.Dataset.shard]] ```python shard(num_shards: int, index: int, contiguous: bool = True, keep_in_memory: bool = False, indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5265) **Parámetros:** num_shards (`int`) : Número de fragmentos en los que dividir el conjunto de datos. index (`int`) : Qué fragmento seleccionar y devolver. contiguous : (`bool`, por defecto `True`): Si se deben seleccionar bloques contiguos de índices para los fragmentos. keep_in_memory (`bool`, por defecto `False`) : Mantener el conjunto de datos en memoria en lugar de escribirlo en un archivo de caché. indices_cache_file_name (`str`, *opcional*) : Proporcione el nombre de una ruta para el archivo de caché. Se utiliza para almacenar los índices de cada fragmento en lugar del nombre de archivo de caché generado automáticamente. writer_batch_size (`int`, por defecto `1000`) : Esto solo afecta al mapeo de índices. Número de índices por operación de escritura para el escritor de archivos de caché. Este valor es un buen equilibrio entre el uso de memoria durante el procesamiento y la velocidad de procesamiento. Un valor más alto hace que el procesamiento realice menos búsquedas, mientras que un valor más bajo consume menos memoria temporal durante la ejecución de `map`. Devuelve el fragmento `index`-ésimo del conjunto de datos dividido en `num_shards` piezas. Esto realiza la partición de forma determinista. `dataset.shard(n, i)` divide el conjunto de datos en fragmentos contiguos, por lo que puede concatenarse fácilmente de nuevo después del procesamiento. Si `len(dataset) % n == l`, entonces los primeros `l` conjuntos de datos tienen longitud `(len(dataset) // n) + 1`, y los conjuntos de datos restantes tienen longitud `(len(dataset) // n)`. `datasets.concatenate_datasets([dset.shard(n, i) for i in range(n)])` devuelve un conjunto de datos con el mismo orden que el original. Nota: n debe ser menor o igual al número de elementos del conjunto de datos `len(dataset)`. Por otro lado, `dataset.shard(n, i, contiguous=False)` contiene todos los elementos del conjunto de datos cuyo índice mod `n = i`. Asegúrese de aplicar el particionado antes de usar cualquier operador de aleatorización (como `shuffle`). Lo ideal es que el operador de particionado se utilice al principio de la tubería de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds Dataset({ features: ['text', 'label'], num_rows: 1066 }) >>> ds = ds.shard(num_shards=2, index=0) >>> ds Dataset({ features: ['text', 'label'], num_rows: 533 }) ``` #### repetir[[datasets.Dataset.repeat]] ```python repeat(num_times: int) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4659) **Parámetros:** num_times (`int`) : Número de veces que se repite el conjunto de datos. Crea un nuevo [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) que repita el subyacente `num_times` veces. Al igual que itertools.repeat, repetir una sola vez devuelve el conjunto de datos completo. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> ds = ds.take(2).repeat(2) >>> list(ds) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}, {'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}] ``` #### to_tf_dataset[[datasets.Dataset.to_tf_dataset]] ```python to_tf_dataset(batch_size: typing.Optional[int] = None, columns: typing.Union[str, list[str], NoneType] = None, shuffle: bool = False, collate_fn: typing.Optional[typing.Callable] = None, drop_remainder: bool = False, collate_fn_args: typing.Optional[dict[str, typing.Any]] = None, label_cols: typing.Union[str, list[str], NoneType] = None, prefetch: bool = True, num_workers: int = 0, num_test_batches: int = 20) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L336) **Parámetros:** batch_size (`int`, *opcional*) : Tamaño de los lotes que se cargarán desde el conjunto de datos. El valor predeterminado es `None`, lo que implica que el conjunto de datos no se agrupará en lotes, pero el conjunto de datos devuelto puede agruparse en lotes más adelante con `tf_dataset.batch(batch_size)`. columns (`List[str]` o `str`, *opcional*) : Columna(s) del dataset que se cargarán en el `tf.data.Dataset`. Se pueden utilizar nombres de columnas creados por `collate_fn` que no existan en el dataset original. shuffle(`bool`, por defecto `False`) : Baraja el orden del conjunto de datos al cargarlo. Se recomienda `True` para el entrenamiento y `False` para la validación/evaluación. drop_remainder(`bool`, por defecto `False`) : Descarta el último lote incompleto al cargar. Garantiza que todos los lotes generados por el conjunto de datos tengan la misma longitud en la dimensión del lote. collate_fn(`Callable`, *opcional*) : Una función u objeto invocable (como un `DataCollator`) que agrupará listas de muestras en un lote. collate_fn_args (`Dict`, *opcional*) : Un `dict` opcional de argumentos de palabra clave para pasar a `collate_fn`. label_cols (`List[str]` o `str`, por defecto `None`) : Columna(s) del dataset que se cargarán como etiquetas. Tenga en cuenta que muchos modelos calculan la pérdida internamente en lugar de dejar que Keras lo haga, en cuyo caso pasar las etiquetas aquí es opcional, siempre que estén en las `columns` de entrada. prefetch (`bool`, por defecto `True`) : Si se ejecuta el dataloader en un hilo separado y se mantiene un pequeño búfer de lotes para el entrenamiento. Mejora el rendimiento al permitir que los datos se carguen en segundo plano mientras el modelo se está entrenando. num_workers (`int`, por defecto `0`) : Número de workers para usar al cargar el dataset. num_test_batches (`int`, por defecto `20`) : Número de lotes que se usarán para inferir la firma de salida del conjunto de datos. A mayor sea este número, más precisa será la firma, pero más tiempo tardará en crearse el conjunto de datos. **Devuelve:** `tf.data.Dataset` Cree un `tf.data.Dataset` a partir del Dataset subyacente. Este `tf.data.Dataset` cargará y agrupará lotes desde el Dataset, y es adecuado para pasar a métodos como `model.fit()` o `model.predict()`. El dataset generará `dicts` tanto para las entradas como para las etiquetas, a menos que el `dict` contenga una sola clave, en cuyo caso se generará un `tf.Tensor` en bruto. Ejemplo: ```py >>> ds_train = ds["train"].to_tf_dataset( ... columns=['input_ids', 'token_type_ids', 'attention_mask', 'label'], ... shuffle=True, ... batch_size=16, ... collate_fn=data_collator, ... ) ``` #### push_to_hub[[datasets.Dataset.push_to_hub]] ```python push_to_hub(repo_id: str, config_name: str = 'default', set_default: typing.Optional[bool] = None, split: typing.Optional[str] = None, data_dir: typing.Optional[str] = None, commit_message: typing.Optional[str] = None, commit_description: typing.Optional[str] = None, private: typing.Optional[bool] = None, token: typing.Optional[str] = None, revision: typing.Optional[str] = None, create_pr: typing.Optional[bool] = False, max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[int] = None, embed_external_files: bool = True, num_proc: typing.Optional[int] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6092) **Parámetros:** repo_id (`str`) : El ID del repositorio al que se enviarán los datos, en el siguiente formato: `/` o `/`. También acepta ``, que por defecto usará el espacio de nombres del usuario conectado. También puede ser una ubicación dentro de un bucket, por ejemplo `buckets///...` config_name (`str`, por defecto "default") : El nombre de la configuración (o subconjunto) de un conjunto de datos. Por defecto, "default". set_default (`bool`, *opcional*) : Si se establece esta configuración como la predeterminada. De lo contrario, la configuración predeterminada es la denominada "default". split (`str`, *opcional*) : El nombre de la división que se asignará a ese conjunto de datos. El valor predeterminado es `self.split`. data_dir (`str`, *opcional*) : Nombre del directorio que contendrá los archivos de datos subidos. El valor predeterminado es `config_name` si es diferente de "default"; en caso contrario, es "data". commit_message (`str`, *opcional*) : Mensaje a confirmar al hacer push. El valor predeterminado será `"Upload dataset"`. commit_description (`str`, *opcional*) : Descripción del commit que se creará. Además, descripción de la PR si se crea una PR (`create_pr` es True). private (`bool`, *opcional*) : Si se debe hacer el repositorio privado. Si es `None` (predeterminado), el repositorio será público a menos que el valor predeterminado de la organización sea privado. Este valor se ignora si el repositorio ya existe. token (`str`, *opcional*) : Un token de autenticación opcional para Hugging Face Hub. Si no se pasa ningún token, se usará por defecto el token guardado localmente al iniciar sesión con `hf auth login`. Se generará un error si no se pasa ningún token y el usuario no ha iniciado sesión. revision (`str`, *opcional*) : Rama a la que se enviarán los archivos subidos. Por defecto, la rama `"main"`. create_pr (`bool`, *opcional*, por defecto `False`) : Si se debe crear una PR con los archivos subidos o realizar el commit directamente. max_shard_size (`int` o `str`, *opcional*, valor predeterminado `"500MB"`) : El tamaño máximo de los fragmentos del conjunto de datos que se subirán al hub. Si se expresa como una cadena, debe consistir en dígitos seguidos de una unidad (como `"5MB"`). num_shards (`int`, *opcional*) : Número de fragmentos a escribir. Por defecto, el número de fragmentos depende de `max_shard_size`. embed_external_files (`bool`, por defecto `True`) : Si se deben incrustar los bytes de los archivos en los fragmentos. En particular, esto hará lo siguiente antes de la publicación para los campos de tipo: - [Audio](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Audio) y [Image](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Image): eliminar la información de la ruta local e incrustar el contenido del archivo en los archivos Parquet. num_proc (`int`, *opcional*, valor predeterminado `None`) : Número de procesos al preparar y subir el conjunto de datos. Esto es útil si el conjunto de datos está compuesto por muchas muestras o archivos multimedia para incrustar. Usa el contexto "spawn" para funcionar con hf_xet, el cliente de rust para subidas rápidas a HF. La multiprocesación está deshabilitada de forma predeterminada. **Devuelve:** huggingface_hub.CommitInfo Sube el conjunto de datos al hub como un conjunto de datos Parquet. El conjunto de datos se sube mediante solicitudes HTTP y no requiere tener instalados ni git ni git-lfs. Los archivos Parquet resultantes son autosuficientes por defecto. Si su conjunto de datos contiene datos de [Image](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Audio) o [Video](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Video), los archivos Parquet almacenarán los bytes de sus imágenes o archivos de audio. Puede desactivar esto estableciendo `embed_external_files` en `False`. Ejemplo: ```python >>> dataset.push_to_hub("/") >>> dataset_dict.push_to_hub("/", private=True) >>> dataset.push_to_hub("/", max_shard_size="1GB") >>> dataset.push_to_hub("/", num_shards=1024) ``` Si su conjunto de datos tiene varias divisiones (p. ej., entrenamiento/validación/prueba): ```python >>> train_dataset.push_to_hub("/", split="train") >>> val_dataset.push_to_hub("/", split="validation") >>> # later >>> dataset = load_dataset("/") >>> train_dataset = dataset["train"] >>> val_dataset = dataset["validation"] ``` Si desea agregar una nueva configuración (o subconjunto) a un conjunto de datos (por ejemplo, si el conjunto de datos tiene múltiples tareas/versiones/idiomas): ```python >>> english_dataset.push_to_hub("/", "en") >>> french_dataset.push_to_hub("/", "fr") >>> # later >>> english_dataset = load_dataset("/", "en") >>> french_dataset = load_dataset("/", "fr") ``` #### save_to_disk[[datasets.Dataset.save_to_disk]] ```python save_to_disk(dataset_path: typing.Union[str, bytes, os.PathLike], max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[int] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1781) **Parámetros:** dataset_path (`path-like`) : Path (p. ej. `dataset/train`) o URI remoto (p. ej. `s3://my-bucket/dataset/train`) del directorio del conjunto de datos donde se guardará el conjunto de datos. max_shard_size (`int` o `str`, *opcional*, valor predeterminado `"500MB"`) : El tamaño máximo de los fragmentos del conjunto de datos que se guardarán en el sistema de archivos. Si se expresa como una cadena, debe consistir en dígitos seguidos de una unidad (como `"50MB"`). num_shards (`int`, *opcional*) : Número de fragmentos a escribir. Por defecto, el número de fragmentos depende de `max_shard_size` y `num_proc`. num_proc (`int`, *opcional*) : Número de procesos al descargar y generar el dataset 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, si lo hay. Guarda un conjunto de datos en un directorio de conjuntos de datos o en un sistema de archivos mediante cualquier implementación de `fsspec.spec.AbstractFileSystem`. Para datos de [Image](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Audio) y [Video](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Video): Todos los datos de Image(), Audio() y Video() se almacenan en los archivos arrow. Si desea almacenar rutas o urls, use el tipo Value("string"). Ejemplo: ```py >>> ds.save_to_disk("path/to/dataset/directory") >>> ds.save_to_disk("path/to/dataset/directory", max_shard_size="1GB") >>> ds.save_to_disk("path/to/dataset/directory", num_shards=1024) ``` #### load_from_disk[[datasets.Dataset.load_from_disk]] ```python load_from_disk(dataset_path: typing.Union[str, bytes, os.PathLike], keep_in_memory: typing.Optional[bool] = None, storage_options: typing.Optional[dict] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1989) **Parámetros:** dataset_path (`path-like`) : Path (p. ej. `"dataset/train"`) o URI remoto (p. ej. `"s3//my-bucket/dataset/train"`) del directorio del dataset desde el que se cargará. keep_in_memory (`bool`, por defecto `None`) : Si se debe copiar el conjunto de datos en memoria. Si es `None`, el conjunto de datos no se copiará en memoria a menos que se habilite explícitamente estableciendo `datasets.config.IN_MEMORY_MAX_SIZE` en un valor distinto de cero. Consulte más detalles en la sección [mejorar el rendimiento](../cache#improve-performance). storage_options (`dict`, *opcional*) : Pares clave/valor que se pasarán al backend del sistema de archivos, si lo hay. **Devuelve:** [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) o [DatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict) - Si `dataset_path` es la ruta de un directorio de datos, el conjunto de datos solicitado. - Si `dataset_path` es la ruta de un directorio de diccionario de datos, un `datasets.DatasetDict` con cada división. Carga un conjunto de datos que se guardó previamente con `save_to_disk` desde un directorio de datos, o desde un sistema de archivos mediante cualquier implementación de `fsspec.spec.AbstractFileSystem`. Ejemplo: ```py >>> ds = load_from_disk("path/to/dataset/directory") ``` #### flatten_indices[[datasets.Dataset.flatten_indices]] ```python flatten_indices(keep_in_memory: bool = False, cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, features: typing.Optional[datasets.features.features.Features] = None, disable_nullable: bool = False, num_proc: typing.Optional[int] = None, new_fingerprint: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4297) **Parámetros:** keep_in_memory (`bool`, por defecto `False`) : Mantener el conjunto de datos en memoria en lugar de escribirlo en un archivo de caché. cache_file_name (`str`, *opcional*, valor predeterminado `None`) : Proporcione el nombre de una ruta para el archivo de caché. Se utiliza para almacenar los resultados del cálculo en lugar del nombre de archivo de caché generado automáticamente. writer_batch_size (`int`, por defecto `1000`) : Número de filas por operación de escritura para el escritor de archivos de caché. Este valor es un buen equilibrio entre el uso de memoria durante el procesamiento y la velocidad de procesamiento. Un valor más alto hace que el procesamiento realice menos búsquedas, mientras que un valor más bajo consume menos memoria temporal durante la ejecución de `map`. features (`Optional[datasets.Features]`, por defecto `None`) : Use un [Features](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features) específico para almacenar el archivo de caché en lugar del generado automáticamente. disable_nullable (`bool`, por defecto `False`) : Permite valores nulos en la tabla. num_proc (`int`, opcional, valor predeterminado `None`) : Número máximo de procesos al generar la caché. Los fragmentos ya en caché se cargan de forma secuencial new_fingerprint (`str`, *opcional*, por defecto `None`) : La nueva huella digital del conjunto de datos después de la transformación. Si es `None`, la nueva huella digital se calcula usando un hash de la huella digital anterior y los argumentos de la transformación Crea y almacena en caché un nuevo Dataset aplanando el mapeo de índices. #### to_csv[[datasets.Dataset.to_csv]] ```python to_csv(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **to_csv_kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5342) **Parámetros:** path_or_buf (`PathLike` o `FileOrBuffer`) : Ya sea una ruta a un archivo (p. ej. `file.csv`), un URI remoto (p. ej. `hf://datasets/username/my_dataset_name/data.csv`) o un BinaryIO, donde se guardará el conjunto de datos en el formato especificado. batch_size (`int`, *opcional*) : Tamaño del lote para cargar en memoria y escribir de una vez. El valor predeterminado es `datasets.config.DEFAULT_MAX_BATCH_SIZE`. num_proc (`int`, *opcional*) : Número de procesos para la multiprocesación. Por defecto, no utiliza multiprocesación. En este caso, `batch_size` toma por defecto el valor de `datasets.config.DEFAULT_MAX_BATCH_SIZE`, pero puedes aumentarlo a 5 o 10 veces el valor predeterminado si dispones de suficiente capacidad de cálculo. storage_options (`dict`, *opcional*) : Pares clave/valor que se pasarán al backend del sistema de archivos, si lo hay. - ****to_csv_kwargs** (argumentos de palabra clave adicionales): Parámetros para pasar a [`pandas.DataFrame.to_csv`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_csv.html) de pandas. Ahora, `index` tiene un valor predeterminado de `False` si no se especifica. Si desea escribir el índice, pase `index=True` y también establezca un nombre para la columna de índice pasando `index_label`. **Devuelve:** `int` El número de caracteres o bytes escritos. Exporta el conjunto de datos a csv Ejemplo: ```py >>> ds.to_csv("path/to/dataset/directory") ``` #### to_pandas[[datasets.Dataset.to_pandas]] ```python to_pandas(batch_size: typing.Optional[int] = None, batched: bool = False) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5541) **Parámetros:** batch_size (`int`, *opcional*) : El tamaño (número de filas) de los lotes si `batched` es `True`. El valor predeterminado es `datasets.config.DEFAULT_MAX_BATCH_SIZE`. batched (`bool`) : Establezca en `True` para devolver un generador que produce el conjunto de datos en lotes de `batch_size` filas. El valor predeterminado es `False` (devuelve todo el conjunto de datos una sola vez). **Devuelve:** `pandas.DataFrame` o `Iterator[pandas.DataFrame]` Devuelve el conjunto de datos como un `pandas.DataFrame`. También puede devolver un generador para conjuntos de datos grandes. Ejemplo: ```py >>> ds.to_pandas() ``` #### to_dict[[datasets.Dataset.to_dict]] ```python to_dict(batch_size: typing.Optional[int] = None, batched: bool = False) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5401) **Parámetros:** batch_size (`int`, *opcional*) : El tamaño (número de filas) de los lotes si `batched` es `True`. El valor predeterminado es `datasets.config.DEFAULT_MAX_BATCH_SIZE`. batched (`bool`) : Establezca en `True` para devolver un generador que produce el conjunto de datos en lotes de `batch_size` filas. El valor predeterminado es `False` (devuelve todo el conjunto de datos una sola vez). **Devuelve:** `dict` o `Iterator[dict]` Devuelve el conjunto de datos como un diccionario de Python. También puede devolver un generador para conjuntos de datos grandes. Ejemplo: ```py >>> ds.to_dict() ``` #### to_json[[datasets.Dataset.to_json]] ```python to_json(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **to_json_kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5466) **Parámetros:** path_or_buf (`PathLike` o `FileOrBuffer`) : Ya sea una ruta a un archivo (p. ej. `file.json`), un URI remoto (p. ej. `hf://datasets/username/my_dataset_name/data.json`) o un BinaryIO, donde se guardará el conjunto de datos en el formato especificado. batch_size (`int`, *opcional*) : Tamaño del lote para cargar en memoria y escribir de una vez. El valor predeterminado es `datasets.config.DEFAULT_MAX_BATCH_SIZE`. num_proc (`int`, *opcional*) : Número de procesos para la multiprocesación. Por defecto, no utiliza multiprocesación. En este caso, `batch_size` toma por defecto el valor `datasets.config.DEFAULT_MAX_BATCH_SIZE`, pero puedes aumentarlo a 5 o 10 veces el valor predeterminado si dispones de suficiente capacidad de cálculo. storage_options (`dict`, *opcional*) : Pares clave/valor que se pasarán al backend del sistema de archivos, si lo hay. - ****to_json_kwargs** (additional keyword arguments) : Parameters to pass to pandas's [`pandas.DataFrame.to_json`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_json.html). Default arguments are `lines=True` and `orient="records". The parameter `index` defaults to `False` if `orient` is `"split"` or `"table"`. If you would like to write the index, pass `index=True`. **Devuelve:** `int` El número de caracteres o bytes escritos. Exporta el conjunto de datos a JSON Lines o JSON. El formato de salida predeterminado es [JSON Lines](https://jsonlines.org/). Para exportar a [JSON](https://www.json.org), pase el argumento `lines=False` y el `orient` deseado. Ejemplo: ```py >>> ds.to_json("path/to/dataset/directory/filename.jsonl") ``` #### to_parquet[[datasets.Dataset.to_parquet]] ```python to_parquet(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **parquet_writer_kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5643) **Parámetros:** path_or_buf (`PathLike` o `FileOrBuffer`) : Ya sea una ruta a un archivo (p. ej. `file.parquet`), un URI remoto (p. ej. `hf://datasets/username/my_dataset_name/data.parquet`) o un BinaryIO, donde se guardará el conjunto de datos en el formato especificado. batch_size (`int`, *opcional*) : Tamaño del lote para cargar en memoria y escribir de una vez. Por defecto, apunta a grupos de filas con un tamaño máximo de bytes sin comprimir de "100MB", definido por `datasets.config.MAX_ROW_GROUP_SIZE`. storage_options (`dict`, *opcional*) : Pares clave/valor que se pasarán al backend del sistema de archivos, si lo hay. - ****parquet_writer_kwargs**** (argumentos de palabra clave adicionales) : Parámetros para pasar a `pyarrow.parquet.ParquetWriter` de PyArrow. **Devuelve:** `int` El número de caracteres o bytes escritos. Exporta el conjunto de datos a parquet Ejemplo: ```py >>> ds.to_parquet("path/to/dataset/directory") ``` #### to_sql[[datasets.Dataset.to_sql]] ```python to_sql(name: str, con: typing.Union[str, ForwardRef('sqlalchemy.engine.Connection'), ForwardRef('sqlalchemy.engine.Engine'), ForwardRef('sqlite3.Connection')], batch_size: typing.Optional[int] = None, num_proc: typing.Optional[int] = None, **sql_writer_kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5683) **Parámetros:** name (`str`) : Nombre de la tabla SQL. con (`str` o `sqlite3.Connection` o `sqlalchemy.engine.Connection` o `sqlalchemy.engine.Connection`) : Una [cadena URI](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) o un objeto de conexión SQLite3/SQLAlchemy utilizado para escribir en una base de datos. batch_size (`int`, *opcional*) : Tamaño del lote para cargar en memoria y escribir de una vez. El valor predeterminado es `datasets.config.DEFAULT_MAX_BATCH_SIZE`. num_proc (`int`, *opcional*) : Número de procesos para la multiprocesación. Por defecto, no utiliza multiprocesación. En este caso, `batch_size` toma por defecto el valor `datasets.config.DEFAULT_MAX_BATCH_SIZE`, pero puedes aumentarlo a 5 o 10 veces el valor predeterminado si dispones de suficiente capacidad de cálculo. - ****sql_writer_kwargs** (argumentos de palabra clave adicionales): Parámetros para pasar a [`pandas.DataFrame.to_sql`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_sql.html) de pandas. Ahora, `index` tiene un valor predeterminado de `False` si no se especifica. Si desea escribir el índice, pase `index=True` y también establezca un nombre para la columna de índice pasando `index_label`. **Devuelve:** `int` El número de registros escritos. Exporta el conjunto de datos a una base de datos SQL. Ejemplo: ```py >>> # con provided as a connection URI string >>> ds.to_sql("data", "sqlite:///my_own_db.sql") >>> # con provided as a sqlite3 connection object >>> import sqlite3 >>> con = sqlite3.connect("my_own_db.sql") >>> with con: ... ds.to_sql("data", con) ``` #### to_iterable_dataset[[datasets.Dataset.to_iterable_dataset]] ```python to_iterable_dataset(num_shards: typing.Optional[int] = 1) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5781) **Parámetros:** num_shards (`int`, por defecto `1`) : Número de shards que se definen al instanciar el dataset iterable. Esto es especialmente útil para datasets grandes, ya que permite barajar los datos correctamente y también habilita la carga paralela rápida mediante un PyTorch DataLoader o en configuraciones distribuidas, por ejemplo. Los shards se definen usando [datasets.Dataset.shard()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.shard): simplemente segmenta los datos sin escribir nada en disco. **Devuelve:** [datasets.IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset) Obtén un [datasets.IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset) a partir de un [datasets.Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) de estilo mapa. Esto es equivalente a cargar un conjunto de datos en modo de transmisión con [datasets.load_dataset()](/docs/datasets/v5.2.0/es/package_reference/loading_methods#datasets.load_dataset), pero mucho más rápido, ya que los datos se transmiten desde archivos locales. A diferencia de los conjuntos de datos de estilo mapa, los conjuntos de datos iterables son perezosos y solo se pueden iterar (por ejemplo, usando un bucle for). Dado que se leen de forma secuencial en los bucles de entrenamiento, los conjuntos de datos iterables son mucho más rápidos que los de estilo mapa. Todas las transformaciones aplicadas a los conjuntos de datos iterables, como el filtrado o el procesamiento, se realizan al vuelo cuando se comienza a iterar sobre el conjunto de datos. Aun así, es posible barajar un dataset iterable usando [datasets.IterableDataset.shuffle()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset.shuffle). Se trata de un barajado aproximado y rápido que funciona mejor si se tienen múltiples shards y se especifica un tamaño de buffer lo suficientemente grande. Para obtener el mejor rendimiento de velocidad, asegúrate de que tu conjunto de datos no tenga un mapeo de índices. Si es así, los datos no se leen de forma contigua, lo que puede ser lento en algunos casos. Puedes usar `ds = ds.flatten_indices()` para escribir tu conjunto de datos en bloques de datos contiguos y tener una velocidad óptima antes de cambiar a un conjunto de datos iterable. Ejemplo: Uso básico: ```python >>> ids = ds.to_iterable_dataset() >>> for example in ids: ... pass ``` Con filtrado y procesamiento perezosos: ```python >>> ids = ds.to_iterable_dataset() >>> ids = ids.filter(filter_fn).map(process_fn) # will filter and process on-the-fly when you start iterating over the iterable dataset >>> for example in ids: ... pass ``` Con el particionamiento para habilitar un barajado eficiente: ```python >>> ids = ds.to_iterable_dataset(num_shards=64) # the dataset is split into 64 shards to be iterated over >>> ids = ids.shuffle(buffer_size=10_000) # will shuffle the shards order and use a shuffle buffer for fast approximate shuffling when you start iterating >>> for example in ids: ... pass ``` Con un DataLoader de PyTorch: ```python >>> import torch >>> ids = ds.to_iterable_dataset(num_shards=64) >>> ids = ids.filter(filter_fn).map(process_fn) >>> dataloader = torch.utils.data.DataLoader(ids, num_workers=4) # will assign 64 / 4 = 16 shards to each worker to load, filter and process when you start iterating >>> for example in ids: ... pass ``` Con un DataLoader de PyTorch y barajado: ```python >>> import torch >>> ids = ds.to_iterable_dataset(num_shards=64) >>> ids = ids.shuffle(buffer_size=10_000) # will shuffle the shards order and use a shuffle buffer when you start iterating >>> dataloader = torch.utils.data.DataLoader(ids, num_workers=4) # will assign 64 / 4 = 16 shards from the shuffled list of shards to each worker when you start iterating >>> for example in ids: ... pass ``` En una configuración distribuida como PyTorch DDP con un PyTorch DataLoader y barajado ```python >>> from datasets.distributed import split_dataset_by_node >>> ids = ds.to_iterable_dataset(num_shards=512) >>> ids = ids.shuffle(buffer_size=10_000, seed=42) # will shuffle the shards order and use a shuffle buffer when you start iterating >>> ids = split_dataset_by_node(ds, world_size=8, rank=0) # will keep only 512 / 8 = 64 shards from the shuffled lists of shards when you start iterating >>> dataloader = torch.utils.data.DataLoader(ids, num_workers=4) # will assign 64 / 4 = 16 shards from this node's list of shards to each worker when you start iterating >>> for example in ids: ... pass ``` Con barajado y múltiples épocas: ```python >>> ids = ds.to_iterable_dataset(num_shards=64) >>> ids = ids.shuffle(buffer_size=10_000, seed=42) # will shuffle the shards order and use a shuffle buffer when you start iterating >>> for epoch in range(n_epochs): ... ids.set_epoch(epoch) # will use effective_seed = seed + epoch to shuffle the shards and for the shuffle buffer when you start iterating ... for example in ids: ... pass ``` Puede utilizar también `IterableDataset.set_epoch()` al usar un DataLoader de PyTorch o en configuraciones distribuidas. #### add_faiss_index[[datasets.Dataset.add_faiss_index]] ```python add_faiss_index(column: str, index_name: typing.Optional[str] = None, device: typing.Optional[int] = None, string_factory: typing.Optional[str] = None, metric_type: typing.Optional[int] = None, custom_index: typing.Optional[ForwardRef('faiss.Index')] = None, batch_size: int = 1000, train_size: typing.Optional[int] = None, faiss_verbose: bool = False, dtype = ) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6339) **Parámetros:** column (`str`) : La columna de los vectores que se añadirán al índice. index_name (`str`, *opcional*) : El `index_name`/identificador del índice. Este es el `index_name` que se utiliza para llamar a [get_nearest_examples()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.get_nearest_examples) o [search()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.search). Por defecto, corresponde a `column`. device (`Union[int, List[int]]`, *opcional*) : Si es un entero positivo, este es el índice de la GPU a utilizar. Si es un entero negativo, se utilizan todas las GPUs. Si se pasa una lista de enteros positivos, se ejecuta solo en esas GPUs. De forma predeterminada, utiliza la CPU. string_factory (`str`, *opcional*) : Se pasa a la fábrica de índices de Faiss para crear el índice. La clase de índice predeterminada es `IndexFlat`. metric_type (`int`, *opcional*) : Tipo de métrica. Ej: `faiss.METRIC_INNER_PRODUCT` o `faiss.METRIC_L2`. custom_index (`faiss.Index`, *opcional*) : Índice de Faiss personalizado que ya has instanciado y configurado para tus necesidades. batch_size (`int`) : Tamaño del lote a utilizar al añadir vectores al `FaissIndex`. El valor predeterminado es `1000`. train_size (`int`, *opcional*) : Si el índice necesita un paso de entrenamiento, especifica cuántos vectores se usarán para entrenar el índice. faiss_verbose (`bool`, por defecto `False`) : Habilita la verbosidad del índice Faiss. dtype (`data-type`) : El dtype de los arrays de numpy que se indexan. El valor predeterminado es `np.float32`. Agregue un índice denso usando Faiss para una recuperación rápida. De forma predeterminada, el índice se realiza sobre los vectores de la columna especificada. Puede especificar `device` si desea ejecutarlo en GPU (`device` debe ser el índice de la GPU). Puede encontrar más información sobre Faiss aquí: - Para [fábrica de cadenas](https://github.com/facebookresearch/faiss/wiki/The-index-factory) Ejemplo: ```python >>> ds = datasets.load_dataset('community-datasets/crime_and_punish', split='train') >>> ds_with_embeddings = ds.map(lambda example: {'embeddings': embed(example['line']})) >>> ds_with_embeddings.add_faiss_index(column='embeddings') >>> # query >>> scores, retrieved_examples = ds_with_embeddings.get_nearest_examples('embeddings', embed('my new query'), k=10) >>> # save index >>> ds_with_embeddings.save_faiss_index('embeddings', 'my_index.faiss') >>> ds = datasets.load_dataset('community-datasets/crime_and_punish', split='train') >>> # load index >>> ds.load_faiss_index('embeddings', 'my_index.faiss') >>> # query >>> scores, retrieved_examples = ds.get_nearest_examples('embeddings', embed('my new query'), k=10) ``` #### add_faiss_index_from_external_arrays[[datasets.Dataset.add_faiss_index_from_external_arrays]] ```python add_faiss_index_from_external_arrays(external_arrays: array, index_name: str, device: typing.Optional[int] = None, string_factory: typing.Optional[str] = None, metric_type: typing.Optional[int] = None, custom_index: typing.Optional[ForwardRef('faiss.Index')] = None, batch_size: int = 1000, train_size: typing.Optional[int] = None, faiss_verbose: bool = False, dtype = ) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6419) **Parámetros:** external_arrays (`np.array`) : Si desea usar matrices externas a la librería para el índice, puede establecer `external_arrays`. Usará `external_arrays` para crear el índice Faiss en lugar de las matrices de la `column` indicada. index_name (`str`) : El `index_name`/identificador del índice. Este es el `index_name` que se utiliza para llamar a [get_nearest_examples()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.get_nearest_examples) o [search()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.search). device (Opcional `Union[int, List[int]]`, *opcional*) : Si es un entero positivo, este es el índice de la GPU a utilizar. Si es un entero negativo, se utilizan todas las GPUs. Si se pasa una lista de enteros positivos, se ejecuta solo en esas GPUs. De forma predeterminada, utiliza la CPU. string_factory (`str`, *opcional*) : Se pasa a la fábrica de índices de Faiss para crear el índice. La clase de índice predeterminada es `IndexFlat`. metric_type (`int`, *opcional*) : Tipo de métrica. Ej: `faiss.faiss.METRIC_INNER_PRODUCT` o `faiss.METRIC_L2`. custom_index (`faiss.Index`, *opcional*) : Índice de Faiss personalizado que ya has instanciado y configurado para tus necesidades. batch_size (`int`, *opcional*) : Tamaño del lote a utilizar al añadir vectores al FaissIndex. El valor predeterminado es 1000. train_size (`int`, *opcional*) : Si el índice necesita un paso de entrenamiento, especifica cuántos vectores se usarán para entrenar el índice. faiss_verbose (`bool`, por defecto False) : Habilita la verbosidad del índice Faiss. dtype (`numpy.dtype`) : El dtype de los arrays de numpy que se indexan. El valor predeterminado es np.float32. Agregue un índice denso usando Faiss para una recuperación rápida. El índice se crea usando los vectores de `external_arrays`. Puede especificar `device` si desea ejecutarlo en GPU (`device` debe ser el índice de la GPU). Puede encontrar más información sobre Faiss aquí: - Para [fábrica de cadenas](https://github.com/facebookresearch/faiss/wiki/The-index-factory) #### save_faiss_index[[datasets.Dataset.save_faiss_index]] ```python save_faiss_index(index_name: str, file: typing.Union[str, pathlib.PurePath], storage_options: typing.Optional[dict] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L535) **Parámetros:** index_name (`str`) : El index_name/identificador del índice. Este es el index_name que se utiliza para llamar a `.get_nearest` o `.search`. file (`str`) : La ruta al índice faiss serializado en el disco o la URI remota (p. ej. `"s3://my-bucket/index.faiss"`). storage_options (`dict`, *opcional*) : Pares clave/valor que se pasarán al backend del sistema de archivos, si lo hay. Guardar un FaissIndex en disco. #### load_faiss_index[[datasets.Dataset.load_faiss_index]] ```python load_faiss_index(index_name: str, file: typing.Union[str, pathlib.PurePath], device: typing.Union[int, list[int], NoneType] = None, storage_options: typing.Optional[dict] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L553) **Parámetros:** index_name (`str`) : El index_name/identificador del índice. Este es el index_name que se utiliza para llamar a `.get_nearest` o `.search`. file (`str`) : La ruta al índice faiss serializado en el disco o la URI remota (p. ej. `"s3://my-bucket/index.faiss"`). device (Opcional `Union[int, List[int]]`) : Si es un entero positivo, este es el índice de la GPU a utilizar. Si es un entero negativo, se utilizan todas las GPUs. Si se pasa una lista de enteros positivos, se ejecuta solo en esas GPUs. De forma predeterminada, utiliza la CPU. storage_options (`dict`, *opcional*) : Pares clave/valor que se pasarán al backend del sistema de archivos, si lo hay. Cargar un FaissIndex desde el disco. Si deseas realizar configuraciones adicionales, puedes acceder al objeto de índice faiss mediante `.get_index(index_name).faiss_index` para adaptarlo a tus necesidades. #### add_elasticsearch_index[[datasets.Dataset.add_elasticsearch_index]] ```python add_elasticsearch_index(column: str, index_name: typing.Optional[str] = None, host: typing.Optional[str] = None, port: typing.Optional[int] = None, es_client: typing.Optional[ForwardRef('elasticsearch.Elasticsearch')] = None, es_index_name: typing.Optional[str] = None, es_index_config: typing.Optional[dict] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6478) **Parámetros:** column (`str`) : La columna de los documentos que se añadirán al índice. index_name (`str`, *opcional*) : El `index_name`/identificador del índice. Este es el nombre del índice que se utiliza para llamar a [get_nearest_examples()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.get_nearest_examples) o [search()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.search). Por defecto, corresponde a `column`. host (`str`, *opcional*, valor predeterminado `localhost`) : Host donde se ejecuta ElasticSearch. port (`str`, *opcional*, valor predeterminado `9200`) : Puerto donde se está ejecutando ElasticSearch. es_client (`elasticsearch.Elasticsearch`, *opcional*) : El cliente de elasticsearch utilizado para crear el índice si host y port son `None`. es_index_name (`str`, *opcional*) : El nombre del índice de elasticsearch utilizado para crear el índice. es_index_config (`dict`, *opcional*) : La configuración del índice de elasticsearch. La configuración predeterminada es: ``` { "settings": { "number_of_shards": 1, "analysis": {"analyzer": {"stop_standard": {"type": "standard", " stopwords": "_english_"}}}, }, "mappings": { "properties": { "text": { "type": "text", "analyzer": "standard", "similarity": "BM25" }, } }, } ``` Agregue un índice de texto usando ElasticSearch para una recuperación rápida. Esto se realiza in situ. Ejemplo: ```python >>> es_client = elasticsearch.Elasticsearch() >>> ds = datasets.load_dataset('community-datasets/crime_and_punish', split='train') >>> ds.add_elasticsearch_index(column='line', es_client=es_client, es_index_name="my_es_index") >>> scores, retrieved_examples = ds.get_nearest_examples('line', 'my new query', k=10) ``` #### load_elasticsearch_index[[datasets.Dataset.load_elasticsearch_index]] ```python load_elasticsearch_index(index_name: str, es_index_name: str, host: typing.Optional[str] = None, port: typing.Optional[int] = None, es_client: typing.Optional[ForwardRef('Elasticsearch')] = None, es_index_config: typing.Optional[dict] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L637) **Parámetros:** index_name (`str`) : El `index_name`/identificador del índice. Este es el nombre del índice que se utiliza para llamar a `get_nearest` o `search`. es_index_name (`str`) : El nombre del índice de elasticsearch que se va a cargar. host (`str`, *opcional*, valor predeterminado `localhost`) : Host donde se ejecuta ElasticSearch. port (`str`, *opcional*, valor predeterminado `9200`) : Puerto donde se está ejecutando ElasticSearch. es_client (`elasticsearch.Elasticsearch`, *opcional*) : El cliente de elasticsearch utilizado para crear el índice si host y port son `None`. es_index_config (`dict`, *opcional*) : La configuración del índice de elasticsearch. La configuración predeterminada es: ``` { "settings": { "number_of_shards": 1, "analysis": {"analyzer": {"stop_standard": {"type": "standard", " stopwords": "_english_"}}}, }, "mappings": { "properties": { "text": { "type": "text", "analyzer": "standard", "similarity": "BM25" }, } }, } ``` Cargue un índice de texto existente usando ElasticSearch para una recuperación rápida. #### list_indexes[[datasets.Dataset.list_indexes]] ```python list_indexes() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L438) Muestra los `colindex_nameumns`/identificadores de todos los índices adjuntos. #### get_index[[datasets.Dataset.get_index]] ```python get_index(index_name: str) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L442) **Parámetros:** index_name (`str`) : Nombre del índice. **Devuelve:** `BaseIndex` Muestra los `index_name`/identificadores de todos los índices adjuntos. #### drop_index[[datasets.Dataset.drop_index]] ```python drop_index(index_name: str) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L684) **Parámetros:** index_name (`str`) : El `index_name`/identificador del índice. Descarta el índice con la columna especificada. #### buscar[[datasets.Dataset.search]] ```python search(index_name: str, query: typing.Union[str, ], k: int = 10, **kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L693) **Parámetros:** index_name (`str`) : El nombre/identificador del índice. query (`Union[str, np.ndarray]`) : La consulta como una cadena de texto si `index_name` es un índice de texto o como un array de numpy si `index_name` es un índice de vectores. k (`int`) : El número de ejemplos a recuperar. **Devuelve:** `(scores, indices)` Una tupla de `(scores, indices)` donde: - **scores** (`List[List[float]`): las puntuaciones de recuperación de los ejemplos recuperados, obtenidas de FAISS (`IndexFlatL2` por defecto) o de ElasticSearch - **indices** (`List[List[int]]`): los índices de los ejemplos recuperados Encuentra los índices de los ejemplos más cercanos en el conjunto de datos a la consulta. #### search_batch[[datasets.Dataset.search_batch]] ```python search_batch(index_name: str, queries: typing.Union[list[str], ], k: int = 10, **kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L713) **Parámetros:** index_name (`str`) : El `index_name`/identificador del índice. queries (`Union[List[str], np.ndarray]`) : Las consultas como una lista de cadenas si `index_name` es un índice de texto o como un array de numpy si `index_name` es un índice de vectores. k (`int`) : El número de ejemplos a recuperar por consulta. **Devuelve:** `(total_scores, total_indices)` Una tupla de `(total_scores, total_indices)` donde: - **total_scores** (`List[List[float]`): las puntuaciones de recuperación de los ejemplos recuperados por consulta, obtenidas de FAISS (`IndexFlatL2` por defecto) o ElasticSearch - **total_indices** (`List[List[int]]`): los índices de los ejemplos recuperados por consulta Encuentra los índices de los ejemplos más cercanos en el conjunto de datos a la consulta. #### get_nearest_examples[[datasets.Dataset.get_nearest_examples]] ```python get_nearest_examples(index_name: str, query: typing.Union[str, ], k: int = 10, **kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L735) **Parámetros:** index_name (`str`) : El index_name/identificador del índice. query (`Union[str, np.ndarray]`) : La consulta como una cadena de texto si `index_name` es un índice de texto o como un array de numpy si `index_name` es un índice de vectores. k (`int`) : El número de ejemplos a recuperar. **Devuelve:** `(scores, examples)` Una tupla de `(scores, examples)` donde: - **scores** (`List[float]`): las puntuaciones de recuperación de los ejemplos recuperados, obtenidas de FAISS (`IndexFlatL2` por defecto) o de ElasticSearch - **examples** (`dict`): los ejemplos recuperados Encuentra los ejemplos más cercanos en el conjunto de datos a la consulta. #### get_nearest_examples_batch[[datasets.Dataset.get_nearest_examples_batch]] ```python get_nearest_examples_batch(index_name: str, queries: typing.Union[list[str], ], k: int = 10, **kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L759) **Parámetros:** index_name (`str`) : El `index_name`/identificador del índice. queries (`Union[List[str], np.ndarray]`) : Las consultas como una lista de cadenas si `index_name` es un índice de texto o como un array de numpy si `index_name` es un índice de vectores. k (`int`) : El número de ejemplos a recuperar por consulta. **Devuelve:** `(total_scores, total_examples)` Una tupla de `(total_scores, total_examples)` donde: - **total_scores** (`List[List[float]`): las puntuaciones de recuperación de los ejemplos recuperados por consulta, obtenidas de FAISS (`IndexFlatL2` por defecto) o ElasticSearch - **total_examples** (`List[dict]`): los ejemplos recuperados por consulta Encuentra los ejemplos más cercanos en el conjunto de datos a la consulta. #### info[[datasets.Dataset.info]] ```python info() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L172) Objeto [DatasetInfo](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetInfo) que contiene todos los metadatos del conjunto de datos. #### split[[datasets.Dataset.split]] ```python split() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L177) objeto [NamedSplit](/docs/datasets/v5.2.0/es/package_reference/builder_classes#datasets.NamedSplit) correspondiente a una división de datos con nombre. #### builder_name[[datasets.Dataset.builder_name]] ```python builder_name() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L182) #### citación[[datasets.Dataset.citation]] ```python citation() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L186) #### config_name[[datasets.Dataset.config_name]] ```python config_name() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L190) #### dataset_size[[datasets.Dataset.dataset_size]] ```python dataset_size() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L194) #### descripción[[datasets.Dataset.description]] ```python description() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L198) #### download_checksums[[datasets.Dataset.download_checksums]] ```python download_checksums() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L202) #### download_size[[datasets.Dataset.download_size]] ```python download_size() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L206) #### características[[datasets.Dataset.features]] ```python features() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L785) #### página de inicio[[datasets.Dataset.homepage]] ```python homepage() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L214) #### licencia[[datasets.Dataset.license]] ```python license() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L218) #### size_in_bytes[[datasets.Dataset.size_in_bytes]] ```python size_in_bytes() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L222) #### supervised_keys[[datasets.Dataset.supervised_keys]] ```python supervised_keys() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L226) #### versión[[datasets.Dataset.version]] ```python version() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L230) #### from_csv[[datasets.Dataset.from_csv]] ```python from_csv(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, num_proc: typing.Optional[int] = None, **kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1282) **Parámetros:** path_or_paths (`path-like` o lista de `path-like`) : Ruta(s) del archivo(s) CSV. split ([NamedSplit](/docs/datasets/v5.2.0/es/package_reference/builder_classes#datasets.NamedSplit), *opcional*) : Nombre de la división que se asignará al conjunto de datos. features ([Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features), *opcional*) : Características del conjunto de datos. cache_dir (`str`, *opcional*, por defecto `"~/.cache/huggingface/datasets"`) : Directorio para cachear datos. keep_in_memory (`bool`, por defecto `False`) : Si se debe copiar los datos en memoria. num_proc (`int`, *opcional*, valor predeterminado `None`) : Número de procesos al descargar y generar el dataset localmente. Esto es útil si el dataset está compuesto por varios archivos. El procesamiento multiproceso está deshabilitado de forma predeterminada. - ****kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave que se pasarán a `pandas.read_csv`. **Devuelve:** [Conjunto de datos](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) Crear un Dataset a partir de archivo(s) CSV. Lee los archivos CSV, almacena los datos en caché en formato Arrow en el disco y devuelve el Dataset desde los datos Arrow mapeados en memoria en el disco. Ejemplo: ```py >>> ds = Dataset.from_csv('path/to/dataset.csv') ``` #### from_json[[datasets.Dataset.from_json]] ```python from_json(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, field: typing.Optional[str] = None, num_proc: typing.Optional[int] = None, **kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1422) **Parámetros:** path_or_paths (`path-like` o lista de `path-like`) : Ruta(s) del archivo o archivos JSON o JSON Lines. split ([NamedSplit](/docs/datasets/v5.2.0/es/package_reference/builder_classes#datasets.NamedSplit), *opcional*) : Nombre de la división que se asignará al conjunto de datos. features ([Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features), *opcional*) : Características del conjunto de datos. cache_dir (`str`, *opcional*, por defecto `"~/.cache/huggingface/datasets"`) : Directorio para cachear datos. keep_in_memory (`bool`, por defecto `False`) : Si se debe copiar los datos en memoria. field (`str`, *opcional*) : Nombre del campo del archivo JSON donde se contiene el conjunto de datos. num_proc (`int`, *opcional* por defecto `None`) : Número de procesos al descargar y generar el dataset localmente. Esto es útil si el dataset está compuesto por varios archivos. El procesamiento multiproceso está deshabilitado por defecto. - ****kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave que se pasarán a `JsonConfig`. **Devuelve:** [Conjunto de datos](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) Crear un Dataset a partir de archivo(s) JSON o JSON Lines. Lee los archivos JSON, almacena los datos en caché en formato Arrow en el disco y devuelve el Dataset desde los datos Arrow mapeados en memoria en el disco. Ejemplo: ```py >>> ds = Dataset.from_json('path/to/dataset.json') ``` #### from_parquet[[datasets.Dataset.from_parquet]] ```python from_parquet(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, columns: typing.Optional[list[str]] = None, num_proc: typing.Optional[int] = None, filters: typing.Union[pyarrow._compute.Expression, list[tuple], list[list[tuple]], NoneType] = None, fragment_scan_options: typing.Optional[pyarrow._dataset_parquet.ParquetFragmentScanOptions] = None, on_bad_files: typing.Literal['error', 'warn', 'skip'] = 'error', **kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1481) **Parámetros:** path_or_paths (`path-like` o lista de `path-like`) : Ruta(s) del archivo(s) Parquet. split (`NamedSplit`, *opcional*) : Nombre de la división que se asignará al conjunto de datos. features (`Features`, *opcional*) : Características del conjunto de datos. cache_dir (`str`, *opcional*, por defecto `"~/.cache/huggingface/datasets"`) : Directorio para cachear datos. keep_in_memory (`bool`, por defecto `False`) : Si se debe copiar los datos en memoria. columns (`List[str]`, *opcional*) : Si no es `None`, solo se leerán estas columnas del archivo. El nombre de una columna puede ser un prefijo de un campo anidado, p. ej. 'a' seleccionará 'a.b', 'a.c' y 'a.d.e'. num_proc (`int`, *opcional*, valor predeterminado `None`) : Número de procesos al descargar y generar el dataset localmente. Esto es útil si el dataset está compuesto por varios archivos. El procesamiento multiproceso está deshabilitado de forma predeterminada. filters (`Union[pyarrow.dataset.Expression, list[tuple], list[list[tuple]]]`, *opcional*) : Devuelve solo las filas que coinciden con el filtro. Si es posible, el predicado se empujará hacia abajo para aprovechar la información de partición o los metadatos internos encontrados en la fuente de datos, p. ej., las estadísticas de Parquet. De lo contrario, filtra los RecordBatches cargados antes de devolverlos. fragment_scan_options (`pyarrow.dataset.ParquetFragmentScanOptions`, *opcional*) : Opciones específicas de escaneo para fragmentos Parquet. Esto resulta especialmente útil para configurar el almacenamiento en búfer y la caché. on_bad_files (`Literal["error", "warn", "skip"]`, *opcional*, valor predeterminado "error") : Especifica qué hacer al encontrar un archivo defectuoso (un archivo que no se puede leer). Los valores permitidos son: * 'error', lanza una Exception cuando se encuentra un archivo defectuoso. * 'warn', lanza una advertencia cuando se encuentra un archivo defectuoso y omite ese archivo. * 'skip', omite los archivos defectuosos sin lanzar excepciones ni advertencias cuando se encuentran. - ****kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave que se pasarán a `ParquetConfig`. **Devuelve:** [Conjunto de datos](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) Crear un Dataset a partir de archivo(s) Parquet. Lee los archivos Parquet, almacena en caché los datos en formato Arrow en el disco y devuelve el Dataset desde los datos Arrow mapeados en memoria en el disco. Ejemplo: ```py >>> ds = Dataset.from_parquet('path/to/dataset.parquet') ``` Cargar un subconjunto de columnas: ```python >>> ds = Dataset.from_parquet('path/to/dataset.parquet', columns=["col_0", "col_1"]) ``` Filtre los datos de manera eficiente, posiblemente omitiendo archivos completos o grupos de filas: ```python >>> filters = [("col_0", "==", 0)] >>> ds = Dataset.from_parquet(parquet_files_list, filters=filters) ``` #### from_text[[datasets.Dataset.from_text]] ```python from_text(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, num_proc: typing.Optional[int] = None, keep_linebreaks: bool = False, sample_by: typing.Literal['line', 'paragraph', 'document'] = 'line', **kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1578) **Parámetros:** path_or_paths (`path-like` o lista de `path-like`) : Ruta(s) del archivo(s) de texto. split (`NamedSplit`, *opcional*) : Nombre de la división que se asignará al conjunto de datos. features (`Features`, *opcional*) : Características del conjunto de datos. cache_dir (`str`, *opcional*, por defecto `"~/.cache/huggingface/datasets"`) : Directorio para cachear datos. keep_in_memory (`bool`, por defecto `False`) : Si se debe copiar los datos en memoria. num_proc (`int`, *opcional*, valor predeterminado `None`) : Número de procesos al descargar y generar el dataset localmente. Esto es útil si el dataset está compuesto por varios archivos. El procesamiento multiproceso está deshabilitado de forma predeterminada. keep_linebreaks : (`bool`, por defecto False): Si se conservan los saltos de línea. sample_by (`Literal["line", "paragraph", "document"]`, por defecto "line") : Si se cargan los datos por línea, párrafo o documento. Por defecto, una fila en el conjunto de datos = una línea. - ****kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave que se pasarán a `TextConfig`. **Devuelve:** [Conjunto de datos](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) Crear un Dataset a partir de archivo(s) de texto. Lee los archivos de texto, almacena los datos en caché en formato Arrow en el disco y devuelve el Dataset desde los datos Arrow mapeados en memoria en el disco. Ejemplo: ```py >>> ds = Dataset.from_text('path/to/dataset.txt') ``` #### from_sql[[datasets.Dataset.from_sql]] ```python from_sql(sql: typing.Union[str, ForwardRef('sqlalchemy.sql.Selectable')], con: typing.Union[str, ForwardRef('sqlalchemy.engine.Connection'), ForwardRef('sqlalchemy.engine.Engine'), ForwardRef('sqlite3.Connection')], features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, **kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1706) **Parámetros:** sql (`str` o `sqlalchemy.sql.Selectable`) : consulta SQL a ejecutar o nombre de una tabla. con (`str` o `sqlite3.Connection` o `sqlalchemy.engine.Connection` o `sqlalchemy.engine.Connection`) : Una [cadena URI](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) utilizada para instanciar una conexión a la base de datos o un objeto de conexión SQLite3/SQLAlchemy. features ([Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features), *opcional*) : Características del conjunto de datos. cache_dir (`str`, *opcional*, por defecto `"~/.cache/huggingface/datasets"`) : Directorio para cachear datos. keep_in_memory (`bool`, por defecto `False`) : Si se debe copiar los datos en memoria. - ****kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave que se pasarán a `SqlConfig`. **Devuelve:** [Conjunto de datos](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) Crear un Dataset a partir de una consulta SQL o una tabla de base de datos. Consultar la base de datos SQL, cachear los datos en formato Arrow en el disco y devolver el Dataset desde los datos Arrow mapeados en memoria en el disco. Ejemplo: ```py >>> # Fetch a database table >>> ds = Dataset.from_sql("test_data", "postgres:///db_name") >>> # Execute a SQL query on the table >>> ds = Dataset.from_sql("SELECT sentence FROM test_data", "postgres:///db_name") >>> # Use a Selectable object to specify the query >>> from sqlalchemy import select, text >>> stmt = select([text("sentence")]).select_from(text("test_data")) >>> ds = Dataset.from_sql(stmt, "postgres:///db_name") ``` > [!TIP] > El conjunto de datos devuelto solo se puede cachear si `con` se especifica como una cadena URI. #### align_labels_with_mapping[[datasets.Dataset.align_labels_with_mapping]] ```python align_labels_with_mapping(label2id: dict, label_column: str) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6600) **Parámetros:** label2id (`dict`) : Mapeo de nombres de etiquetas a ID para alinear el conjunto de datos. label_column (`str`) : El nombre de la columna de etiquetas sobre la que alinear. Alinea la correspondencia entre los ID de etiquetas y los nombres de etiquetas del conjunto de datos para que coincida con una entrada de correspondencia `label2id`. Esto es útil cuando se desea garantizar que las etiquetas predichas por un modelo estén alineadas con el conjunto de datos. La alineación se realiza utilizando los nombres de etiquetas en minúsculas. Ejemplo: ```python >>> # dataset with mapping {'entailment': 0, 'neutral': 1, 'contradiction': 2} >>> ds = load_dataset("nyu-mll/glue", "mnli", split="train") >>> # mapping to align with >>> label2id = {'CONTRADICTION': 0, 'NEUTRAL': 1, 'ENTAILMENT': 2} >>> ds_aligned = ds.align_labels_with_mapping(label2id, "label") ``` #### datasets.concatenate_datasets[[datasets.concatenate_datasets]] ```python datasets.concatenate_datasets(dsets: list, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, axis: int = 0) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/combine.py#L168) **Parámetros:** dsets (`List[datasets.Dataset]` o `List[datasets.IterableDataset]`) : Lista de Datasets para concatenar. info (`DatasetInfo`, *opcional*) : Información del conjunto de datos, como la descripción, la cita, etc. split (`NamedSplit`, *opcional*) : Nombre de la división del conjunto de datos. axis (`{0, 1}`, por defecto `0`) : Eje sobre el que concatenar, donde `0` significa sobre filas (verticalmente) y `1` significa sobre columnas (horizontalmente). Concatenar varios conjuntos de datos (fuentes) en un único conjunto de datos. Use axis=0 para concatenar verticalmente (valor predeterminado) o axis=1 para concatenar horizontalmente. Nota para conjuntos de datos iterables: * si axis=0, el `num_shards` del conjunto de datos resultante es la suma de los `num_shards` de cada conjunto de datos. * si axis=1, el conjunto de datos resultante tiene un (1) fragmento para no desalinear los datos. * si los conjuntos de datos se dividieron con [datasets.distributed.split_dataset_by_node()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.distributed.split_dataset_by_node), todos deben dividirse de la misma manera y el conjunto de datos resultante conserva esa división. Ejemplo: ```py >>> ds3 = concatenate_datasets([ds1, ds2]) ``` #### datasets.interleave_datasets[[datasets.interleave_datasets]] ```python datasets.interleave_datasets(datasets: list, probabilities: typing.Optional[list[float]] = None, seed: typing.Optional[int] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, stopping_strategy: typing.Literal['first_exhausted', 'all_exhausted', 'all_exhausted_without_replacement'] = 'first_exhausted') ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/combine.py#L18) **Parámetros:** datasets (`List[Dataset]` o `List[IterableDataset]`) : Lista de conjuntos de datos para intercalar. probabilities (`List[float]`, *opcional*, valor predeterminado `None`) : Si se especifica, el nuevo conjunto de datos se construye muestreando ejemplos de una fuente a la vez según estas probabilidades. seed (`int`, *opcional*, valor predeterminado `None`) : La semilla aleatoria utilizada para elegir una fuente para cada ejemplo. info ([DatasetInfo](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetInfo), *opcional*) : Información del conjunto de datos, como la descripción, la cita, etc. split ([NamedSplit](/docs/datasets/v5.2.0/es/package_reference/builder_classes#datasets.NamedSplit), *opcional*) : Nombre de la división del conjunto de datos. stopping_strategy (`str`, por defecto `first_exhausted`) : Actualmente se proponen tres estrategias, `first_exhausted`, `all_exhausted` y `all_exhausted_without_replacement`. Por defecto, `first_exhausted` es una estrategia de muestreo insuficiente, es decir, la construcción del conjunto de datos se detiene en cuanto uno de los conjuntos de datos se queda sin muestras. Si la estrategia es `all_exhausted`, utilizamos una estrategia de muestreo excesivo, es decir, la construcción del conjunto de datos se detiene en cuanto cada muestra de cada conjunto de datos se ha añadido al menos una vez. Cuando la estrategia es `all_exhausted_without_replacement`, nos aseguramos de que cada muestra en cada conjunto de datos se muestree solo una vez. Tenga en cuenta que si la estrategia es `all_exhausted`, el tamaño del conjunto de datos intercalado puede llegar a ser enorme: - sin probabilidades, el conjunto de datos resultante tendrá `max_length_datasets*nb_dataset` muestras. - con probabilidades dadas, el conjunto de datos resultante tendrá más muestras si algunos conjuntos de datos tienen una probabilidad de visita realmente baja. **Devuelve:** [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) o [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset) El tipo de retorno depende del parámetro de entrada `datasets`. `Dataset` si la entrada es una lista de `Dataset`, `IterableDataset` si la entrada es una lista de `IterableDataset`. Intercale varios conjuntos de datos (fuentes) en un único conjunto de datos. El nuevo conjunto de datos se construye alternando entre las fuentes para obtener los ejemplos. Puede usar esta función en una lista de objetos [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) o en una lista de objetos [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset). - Si `probabilities` es `None` (valor predeterminado), el nuevo conjunto de datos se construye alternando entre cada fuente para obtener los ejemplos. - Si `probabilities` no es `None`, el nuevo conjunto de datos se construye obteniendo ejemplos de una fuente aleatoria a la vez, según las probabilidades proporcionadas. El conjunto de datos resultante termina cuando uno de los conjuntos de datos de origen se agota, excepto cuando `oversampling` es `True`, en cuyo caso el conjunto de datos resultante termina cuando todos los conjuntos de datos se han agotado al menos una vez. Nota para conjuntos de datos iterables: * El `num_shards` del dataset resultante es el mínimo de los `num_shards` de cada dataset para garantizar un buen paralelismo. Si algunos de tus datasets tienen un número muy bajo de shards, puedes usar [IterableDataset.reshard()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset.reshard). * En una configuración distribuida o en los workers de PyTorch DataLoader, la estrategia de detención se aplica por proceso. Por lo tanto, la estrategia "first_exhausted" en un dataset iterable fragmentado puede generar menos muestras en total (hasta 1 muestra faltante por subdataset por worker). Ejemplo: Para conjuntos de datos regulares (estilo mapa): ```python >>> from datasets import Dataset, interleave_datasets >>> d1 = Dataset.from_dict({"a": [0, 1, 2]}) >>> d2 = Dataset.from_dict({"a": [10, 11, 12]}) >>> d3 = Dataset.from_dict({"a": [20, 21, 22]}) >>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42, stopping_strategy="all_exhausted") >>> dataset["a"] [10, 0, 11, 1, 2, 20, 12, 10, 0, 1, 2, 21, 0, 11, 1, 2, 0, 1, 12, 2, 10, 0, 22] >>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42) >>> dataset["a"] [10, 0, 11, 1, 2] >>> dataset = interleave_datasets([d1, d2, d3]) >>> dataset["a"] [0, 10, 20, 1, 11, 21, 2, 12, 22] >>> dataset = interleave_datasets([d1, d2, d3], stopping_strategy="all_exhausted") >>> dataset["a"] [0, 10, 20, 1, 11, 21, 2, 12, 22] >>> d1 = Dataset.from_dict({"a": [0, 1, 2]}) >>> d2 = Dataset.from_dict({"a": [10, 11, 12, 13]}) >>> d3 = Dataset.from_dict({"a": [20, 21, 22, 23, 24]}) >>> dataset = interleave_datasets([d1, d2, d3]) >>> dataset["a"] [0, 10, 20, 1, 11, 21, 2, 12, 22] >>> dataset = interleave_datasets([d1, d2, d3], stopping_strategy="all_exhausted") >>> dataset["a"] [0, 10, 20, 1, 11, 21, 2, 12, 22, 0, 13, 23, 1, 10, 24] >>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42) >>> dataset["a"] [10, 0, 11, 1, 2] >>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42, stopping_strategy="all_exhausted") >>> dataset["a"] [10, 0, 11, 1, 2, 20, 12, 13, ..., 0, 1, 2, 0, 24] For datasets in streaming mode (iterable): >>> from datasets import interleave_datasets >>> d1 = load_dataset('allenai/c4', 'es', split='train', streaming=True) >>> d2 = load_dataset('allenai/c4', 'fr', split='train', streaming=True) >>> dataset = interleave_datasets([d1, d2]) >>> iterator = iter(dataset) >>> next(iterator) {'text': 'Comprar Zapatillas para niña en chancla con goma por...'} >>> next(iterator) {'text': 'Le sacre de philippe ier, 23 mai 1059 - Compte Rendu...' ``` #### datasets.distributed.split_dataset_by_node[[datasets.distributed.split_dataset_by_node]] ```python datasets.distributed.split_dataset_by_node(dataset: ~DatasetType, rank: int, world_size: int, strategy: typing.Literal['auto', 'shards', 'examples'] = 'auto') ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/distributed.py#L10) **Parámetros:** dataset ([Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) o [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset)) : El conjunto de datos que se dividirá por nodo. rank (`int`) : Rango del nodo actual. world_size (`int`) : Número total de nodos. strategy (`str`, por defecto `"auto"`) : Cómo dividir un dataset iterable. Debe ser uno de `"auto"`, `"shards"` o `"examples"`. Los datasets de estilo mapa solo admiten `"auto"`. **Devuelve:** [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) o [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset) El conjunto de datos que se usará en el nodo con el rango `rank`. Divide un conjunto de datos para el nodo con rango `rank` en un grupo de nodos de tamaño `world_size`. Para conjuntos de datos de estilo mapa: A cada nodo se le asigna un fragmento de datos, por ejemplo, al rank 0 se le asigna el primer fragmento del conjunto de datos. Para maximizar el rendimiento de carga de datos, los fragmentos se componen de datos contiguos en el disco cuando es posible. Para conjuntos de datos iterables: La `strategy` de división puede ser `"auto"`, `"shards"` o `"examples"`: * `"shards"`: los shards se asignan de manera uniforme entre los nodos * `"examples"`: cada nodo conserva 1 ejemplo de `world_size`, omitiendo los demás ejemplos * `"auto"` (predeterminado): usa `"shards"` si el conjunto de datos tiene un número de fragmentos que es un factor de `world_size` (es decir, si `dataset.num_shards % world_size == 0`), que es la opción más optimizada. En caso contrario, utiliza `"examples"`. > [!WARNING] > Si barajas tu conjunto de datos iterable en una configuración distribuida, asegúrate de establecer una `seed` fija en [IterableDataset.shuffle()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset.shuffle) de modo que la misma lista de fragmentos barajados se utiliza en cada nodo para saber qué fragmentos debe omitir el nodo. #### datasets.enable_caching[[datasets.enable_caching]] ```python datasets.enable_caching() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/fingerprint.py#L120) Al aplicar transformaciones en un conjunto de datos, los datos se almacenan en archivos de caché. El mecanismo de caché permite recargar un archivo de caché existente si ya se ha calculado. Es posible recargar un conjunto de datos, ya que los archivos de caché se nombran utilizando la huella digital del conjunto de datos, que se actualiza después de cada transformación. Si se desactiva, la biblioteca ya no volverá a cargar los archivos de conjuntos de datos en caché al aplicar transformaciones a los conjuntos de datos. Más precisamente, si la caché está desactivada: - los archivos de caché siempre se recrean - los archivos de caché se escriben en un directorio temporal que se elimina al cerrar la sesión - los archivos de caché se nombran usando un hash aleatorio en lugar de la huella digital del conjunto de datos - use [save_to_disk()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.save_to_disk) para guardar un dataset transformado o se eliminará al cerrar la sesión - La caché no afecta a [load_dataset()](/docs/datasets/v5.2.0/es/package_reference/loading_methods#datasets.load_dataset). Si desea regenerar un conjunto de datos desde cero, debe usar el parámetro `download_mode` en [load_dataset()](/docs/datasets/v5.2.0/es/package_reference/loading_methods#datasets.load_dataset). #### datasets.disable_caching[[datasets.disable_caching]] ```python datasets.disable_caching() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/fingerprint.py#L141) Al aplicar transformaciones en un conjunto de datos, los datos se almacenan en archivos de caché. El mecanismo de caché permite recargar un archivo de caché existente si ya se ha calculado. Es posible recargar un conjunto de datos, ya que los archivos de caché se nombran utilizando la huella digital del conjunto de datos, que se actualiza después de cada transformación. Si se desactiva, la biblioteca ya no volverá a cargar los archivos de conjuntos de datos en caché al aplicar transformaciones a los conjuntos de datos. Más precisamente, si la caché está desactivada: - los archivos de caché siempre se recrean - los archivos de caché se escriben en un directorio temporal que se elimina al cerrar la sesión - los archivos de caché se nombran usando un hash aleatorio en lugar de la huella digital del conjunto de datos - use [save_to_disk()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.save_to_disk) para guardar un dataset transformado o se eliminará al cerrar la sesión - La caché no afecta a [load_dataset()](/docs/datasets/v5.2.0/es/package_reference/loading_methods#datasets.load_dataset). Si desea regenerar un conjunto de datos desde cero, debe usar el parámetro `download_mode` en [load_dataset()](/docs/datasets/v5.2.0/es/package_reference/loading_methods#datasets.load_dataset). #### datasets.is_caching_enabled[[datasets.is_caching_enabled]] ```python datasets.is_caching_enabled() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/fingerprint.py#L162) Al aplicar transformaciones en un conjunto de datos, los datos se almacenan en archivos de caché. El mecanismo de caché permite recargar un archivo de caché existente si ya se ha calculado. Es posible recargar un conjunto de datos, ya que los archivos de caché se nombran utilizando la huella digital del conjunto de datos, que se actualiza después de cada transformación. Si se desactiva, la biblioteca ya no volverá a cargar los archivos de conjuntos de datos en caché al aplicar transformaciones a los conjuntos de datos. Más precisamente, si la caché está desactivada: - los archivos de caché siempre se recrean - los archivos de caché se escriben en un directorio temporal que se elimina al cerrar la sesión - los archivos de caché se nombran usando un hash aleatorio en lugar de la huella digital del conjunto de datos - use [save_to_disk()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.save_to_disk)] para guardar un dataset transformado, ya que se eliminará al cerrar la sesión - La caché no afecta a [load_dataset()](/docs/datasets/v5.2.0/es/package_reference/loading_methods#datasets.load_dataset). Si desea regenerar un conjunto de datos desde cero, debe usar el parámetro `download_mode` en [load_dataset()](/docs/datasets/v5.2.0/es/package_reference/loading_methods#datasets.load_dataset). #### datasets.Column[[datasets.Column]] ```python datasets.Column(source: typing.Union[ForwardRef('Dataset'), ForwardRef('Column')], column_name: str) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L638) Un iterable para una columna específica de un [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset). Ejemplo: Iterar sobre los textos de la columna "text" de un conjunto de datos: ```python for text in dataset["text"]: ... ``` También funciona con columnas anidadas: ```python for source in dataset["metadata"]["source"]: ... ``` ## DatasetDict[[datasets.DatasetDict]] Diccionario con los nombres de las divisiones como claves (por ejemplo, 'train', 'test') y objetos `Dataset` como valores. También tiene métodos de transformación de conjuntos de datos como map o filter, para procesar todas las divisiones a la vez. #### datasets.DatasetDict[[datasets.DatasetDict]] [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L53) Un diccionario (dict de str: datasets.Dataset) con los métodos de transformación de conjuntos de datos (map, filter, etc.) #### data[[datasets.DatasetDict.data]] ```python data() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L94) Las tablas Apache Arrow que respaldan cada división. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.data ``` #### cache_files[[datasets.DatasetDict.cache_files]] ```python cache_files() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L109) Los archivos de caché que contienen la tabla Apache Arrow que respalda cada división. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.cache_files {'test': [{'filename': '/root/.cache/huggingface/datasets/rotten_tomatoes_movie_review/default/1.0.0/40d411e45a6ce3484deed7cc15b82a53dad9a72aafd9f86f8f227134bec5ca46/rotten_tomatoes_movie_review-test.arrow'}], 'train': [{'filename': '/root/.cache/huggingface/datasets/rotten_tomatoes_movie_review/default/1.0.0/40d411e45a6ce3484deed7cc15b82a53dad9a72aafd9f86f8f227134bec5ca46/rotten_tomatoes_movie_review-train.arrow'}], 'validation': [{'filename': '/root/.cache/huggingface/datasets/rotten_tomatoes_movie_review/default/1.0.0/40d411e45a6ce3484deed7cc15b82a53dad9a72aafd9f86f8f227134bec5ca46/rotten_tomatoes_movie_review-validation.arrow'}]} ``` #### num_columns[[datasets.DatasetDict.num_columns]] ```python num_columns() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L127) Número de columnas en cada división del conjunto de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.num_columns {'test': 2, 'train': 2, 'validation': 2} ``` #### num_rows[[datasets.DatasetDict.num_rows]] ```python num_rows() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L143) Número de filas en cada división del conjunto de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.num_rows {'test': 1066, 'train': 8530, 'validation': 1066} ``` #### column_names[[datasets.DatasetDict.column_names]] ```python column_names() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L159) Nombres de las columnas en cada división del conjunto de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.column_names {'test': ['text', 'label'], 'train': ['text', 'label'], 'validation': ['text', 'label']} ``` #### shape[[datasets.DatasetDict.shape]] ```python shape() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L177) Forma de cada división del conjunto de datos (número de filas, número de columnas). Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.shape {'test': (1066, 2), 'train': (8530, 2), 'validation': (1066, 2)} ``` #### único[[datasets.DatasetDict.unique]] ```python unique(column: str) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L226) **Parámetros:** column (`str`) : nombre de la columna (lista todos los nombres de columnas con [column_names](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict.column_names)) **Devuelve:** Dict[`str`, `list`] Diccionario de elementos únicos en la columna indicada. Devuelve una lista de los elementos únicos de una columna para cada división. Esto se implementa en el backend de bajo nivel y, por lo tanto, es muy rápido. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.unique("label") {'test': [1, 0], 'train': [1, 0], 'validation': [1, 0]} ``` #### cleanup_cache_files[[datasets.DatasetDict.cleanup_cache_files]] ```python cleanup_cache_files() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L250) **Devuelve:** `Dict` con el número de archivos eliminados para cada split Limpia todos los archivos de caché en el directorio de caché del conjunto de datos, excepto el archivo de caché actualmente en uso, si lo hay. Ten cuidado al ejecutar este comando para que ningún otro proceso esté utilizando otros archivos de caché. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.cleanup_cache_files() {'test': 0, 'train': 0, 'validation': 0} ``` #### map[[datasets.DatasetDict.map]] ```python map(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_rank: bool = False, with_split: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, drop_last_batch: bool = False, remove_columns: typing.Union[str, list[str], NoneType] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = None, writer_batch_size: typing.Optional[int] = 1000, features: typing.Optional[datasets.features.features.Features] = None, disable_nullable: bool = False, fn_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, desc: typing.Optional[str] = None, try_original_type: typing.Optional[bool] = True, on_mixed_types: typing.Optional[typing.Literal['use_json']] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L814) **Parámetros:** function (`callable`) : con una de las siguientes firmas: - `function(example: Dict[str, Any]) -> Dict[str, Any]` si `batched=False` y `with_indices=False` - `function(example: Dict[str, Any], indices: int) -> Dict[str, Any]` si `batched=False` y `with_indices=True` - `function(batch: Dict[str, list]) -> Dict[str, list]` si `batched=True` y `with_indices=False` - `function(batch: Dict[str, list], indices: list[int]) -> Dict[str, list]` si `batched=True` y `with_indices=True` Para un uso avanzado, la función también puede devolver una `pyarrow.Table`. Si la función es asíncrona, `map` ejecutará tu función en paralelo. Además, si tu función no devuelve nada (`None`), `map` ejecutará tu función y devolverá el dataset sin cambios. Si no se proporciona ninguna función, se usa la función identidad por defecto: `lambda x: x`. with_indices (`bool`, por defecto `False`) : Proporciona índices de ejemplos a `function`. Ten en cuenta que, en este caso, la firma de `function` debe ser `def function(example, idx): ...`. with_rank (`bool`, por defecto `False`) : Proporciona el rango del proceso a `function`. Tenga en cuenta que, en este caso, la firma de `function` debe ser `def function(example[, idx], rank): ...`. with_split (`bool`, por defecto `False`) : Proporciona la división del proceso a `function`. Tenga en cuenta que, en este caso, la firma de `function` debe ser `def function(example[, idx], split): ...`. input_columns (`[Union[str, list[str]]]`, *opcional*, valor predeterminado `None`) : Las columnas que se pasarán a `function` como argumentos posicionales. Si es `None`, se pasa un diccionario con todas las columnas formateadas como un solo argumento. batched (`bool`, por defecto `False`) : Proporcionar un lote de ejemplos a `function`. batch_size (`int`, *opcional*, valor predeterminado `1000`) : Número de ejemplos por lote proporcionados a `function` si `batched=True`, `batch_size <= 0` o `batch_size == None`, se proporciona el conjunto de datos completo como un único lote a `function`. drop_last_batch (`bool`, por defecto `False`) : Si un último lote más pequeño que batch_size debe descartarse en lugar de ser procesado por la función. remove_columns (`[Union[str, list[str]]]`, *opcional*, valor predeterminado `None`) : Elimina una selección de columnas durante el mapeo. Las columnas se eliminarán antes de actualizar los ejemplos con la salida de `function`, es decir, si `function` está añadiendo columnas con nombres en `remove_columns`, estas columnas se conservarán. keep_in_memory (`bool`, por defecto `False`) : Mantener el conjunto de datos en memoria en lugar de escribirlo en un archivo de caché. load_from_cache_file (`Optional[bool]`, por defecto `True` si la caché está habilitada) : Si se puede identificar un archivo de caché que almacene el cálculo actual de `function`, úsese en lugar de recalcular. cache_file_names (`[Dict[str, str]]`, *opcional*, valor predeterminado `None`) : Proporcione el nombre de una ruta para el archivo de caché. Se utiliza para almacenar los resultados del cálculo en lugar del nombre de archivo de caché generado automáticamente. Debe proporcionar un `cache_file_name` por cada conjunto de datos en el diccionario de conjuntos de datos. writer_batch_size (`int`, por defecto `1000`) : Número de filas por operación de escritura para el escritor de archivos de caché. Este valor es un buen equilibrio entre el uso de memoria durante el procesamiento y la velocidad de procesamiento. Un valor más alto hace que el procesamiento realice menos búsquedas, mientras que un valor más bajo consume menos memoria temporal durante la ejecución de `map`. features (`[datasets.Features]`, *opcional*, valor predeterminado `None`) : Use un [Features](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features) específico para almacenar el archivo de caché en lugar del generado automáticamente. disable_nullable (`bool`, por defecto `False`) : No permite valores nulos en la tabla. fn_kwargs (`Dict`, *opcional*, valor predeterminado `None`) : Argumentos de palabra clave que se pasarán a `function` num_proc (`int`, *opcional*, valor predeterminado `None`) : El número de procesos a utilizar para la multiprocesación. - Si es `None` o `0`, no se utiliza multiprocesación y la operación se ejecuta en el proceso principal. - Si es mayor que `1`, se utiliza uno o varios procesos de trabajo para procesar los datos en paralelo. Nota: La función pasada a `map()` debe ser serializable (picklable) para que la multiprocesación funcione correctamente (es decir, se prefieren las funciones definidas en el nivel superior de un módulo, no dentro de otra función o clase). desc (`str`, *opcional*, valor predeterminado `None`) : Descripción significativa que se mostrará junto con la barra de progreso mientras se mapean los ejemplos. try_original_type (`Optional[bool]`, por defecto `True`) : Intenta mantener los tipos de las columnas originales (p. ej. int32 -> int32). Establece False si deseas inferir siempre nuevos tipos. on_mixed_types (`Literal["use_json"]`, *opcional*, valor predeterminado `None`) : Si es "use_json", se utiliza el tipo Json() para campos de tipos mixtos, es decir, campos no estructurados que contienen datos sin un esquema predefinido. En este caso, un campo de tipo mixto se establece como Json(). Esto permite cargar listas con una mezcla de strings/integers/floats, por ejemplo, o diccionarios con tipos de valores arbitrarios. Aplica una función a todos los ejemplos de la tabla (individualmente o en lotes) y actualiza la tabla. Si la función devuelve una columna que ya existe, la sobrescribe. La transformación se aplica a todos los conjuntos de datos del diccionario de conjuntos de datos. Puede especificar si la función debe agruparse o no con el parámetro `batched`: - Si `False`, la función toma 1 ejemplo como entrada y debe devolver 1 ejemplo. Un ejemplo es un diccionario, p. ej. `{"text": "Hello there !"}`. - Si `True` y `batch_size` es 1, la función toma un lote de 1 ejemplo como entrada y puede devolver un lote con 1 o más ejemplos. Un lote es un diccionario, por ejemplo, un lote de 1 ejemplo es `{"text": ["Hello there !"]}`. - Si `True` y `batch_size` es `n > 1`, la función toma como entrada un lote de `n` ejemplos y puede devolver un lote con `n` ejemplos, o con un número arbitrario de ejemplos. Tenga en cuenta que el último lote puede tener menos de `n` ejemplos. Un lote es un diccionario, por ejemplo, un lote de `n` ejemplos es `{"text": ["Hello there !"] * n}`. Si la función es asíncrona, `map` ejecutará tu función en paralelo, con hasta mil llamadas simultáneas. Se recomienda usar un `asyncio.Semaphore` en tu función si deseas establecer un número máximo de operaciones que pueden ejecutarse al mismo tiempo. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> def add_prefix(example): ... example["text"] = "Review: " + example["text"] ... return example >>> ds = ds.map(add_prefix) >>> ds["train"][0:3]["text"] ['Review: the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'Review: the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .', 'Review: effective but too-tepid biopic'] # process a batch of examples >>> ds = ds.map(lambda example: tokenizer(example["text"]), batched=True) # set number of processors >>> ds = ds.map(add_prefix, num_proc=4) ``` #### filtro[[datasets.DatasetDict.filter]] ```python filter(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_rank: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = None, writer_batch_size: typing.Optional[int] = 1000, fn_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, desc: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L986) **Parámetros:** function (`Callable`) : Callable con una de las siguientes firmas: - `function(example: Dict[str, Any]) -> bool` si `batched=False` y `with_indices=False` y `with_rank=False` - `function(example: Dict[str, Any], *extra_args) -> bool` si `batched=False` y `with_indices=True` y/o `with_rank=True` (un argumento extra por cada uno) - `function(batch: Dict[str, list]) -> list[bool]` si `batched=True` y `with_indices=False` y `with_rank=False` - `function(batch: Dict[str, list], *extra_args) -> list[bool]` si `batched=True` y `with_indices=True` y/o `with_rank=True` (un argumento extra por cada uno) Si no se proporciona ninguna función, el valor predeterminado es una función que siempre devuelve `True`: `lambda x: True`. with_indices (`bool`, por defecto `False`) : Proporciona índices de ejemplos a `function`. Ten en cuenta que, en este caso, la firma de `function` debe ser `def function(example, idx[, rank]): ...`. with_rank (`bool`, por defecto `False`) : Proporciona el rango del proceso a `function`. Tenga en cuenta que, en este caso, la firma de `function` debe ser `def function(example[, idx], rank): ...`. input_columns (`[Union[str, list[str]]]`, *opcional*, valor predeterminado `None`) : Las columnas que se pasarán a `function` como argumentos posicionales. Si es `None`, se pasa un diccionario con todas las columnas formateadas como un solo argumento. batched (`bool`, por defecto `False`) : Proporcionar un lote de ejemplos a `function`. batch_size (`int`, *opcional*, valor predeterminado `1000`) : Número de ejemplos por lote que se proporcionan a `function` si `batched=True` `batch_size <= 0` o `batch_size == None`, se proporciona el conjunto de datos completo como un único lote a `function`. keep_in_memory (`bool`, por defecto `False`) : Mantener el conjunto de datos en memoria en lugar de escribirlo en un archivo de caché. load_from_cache_file (`Optional[bool]`, por defecto `True` si la caché está habilitada) : Si se puede identificar un archivo de caché que almacene el cálculo actual de `function`, úsese en lugar de recalcular. cache_file_names (`[Dict[str, str]]`, *opcional*, valor predeterminado `None`) : Proporcione el nombre de una ruta para el archivo de caché. Se utiliza para almacenar los resultados del cálculo en lugar del nombre de archivo de caché generado automáticamente. Debe proporcionar un `cache_file_name` por cada conjunto de datos en el diccionario de conjuntos de datos. writer_batch_size (`int`, por defecto `1000`) : Número de filas por operación de escritura para el escritor de archivos de caché. Este valor es un buen equilibrio entre el uso de memoria durante el procesamiento y la velocidad de procesamiento. Un valor más alto hace que el procesamiento realice menos búsquedas, mientras que un valor más bajo consume menos memoria temporal durante la ejecución de `map`. fn_kwargs (`Dict`, *opcional*, valor predeterminado `None`) : Argumentos de palabra clave que se pasarán a `function` num_proc (`int`, *opcional*, valor predeterminado `None`) : El número de procesos a utilizar para la multiprocesación. - Si es `None` o `0`, no se utiliza multiprocesación y la operación se ejecuta en el proceso principal. - Si es mayor que `1`, se utiliza uno o varios procesos de trabajo para procesar los datos en paralelo. Nota: La función pasada a `map()` debe ser serializable (picklable) para que la multiprocesación funcione correctamente (es decir, se prefieren las funciones definidas en el nivel superior de un módulo, no dentro de otra función o clase). desc (`str`, *opcional*, valor predeterminado `None`) : Descripción significativa que se mostrará junto con la barra de progreso mientras se filtran los ejemplos. Aplica una función de filtro a todos los elementos de la tabla por lotes y actualiza la tabla para que el conjunto de datos solo incluya ejemplos según la función de filtro. La transformación se aplica a todos los conjuntos de datos del diccionario de conjuntos de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.filter(lambda x: x["label"] == 1) DatasetDict({ train: Dataset({ features: ['text', 'label'], num_rows: 4265 }) validation: Dataset({ features: ['text', 'label'], num_rows: 533 }) test: Dataset({ features: ['text', 'label'], num_rows: 533 }) }) ``` #### sort[[datasets.DatasetDict.sort]] ```python sort(column_names: typing.Union[str, collections.abc.Sequence[str]], reverse: typing.Union[bool, collections.abc.Sequence[bool]] = False, null_placement: str = 'at_end', keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, indices_cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = None, writer_batch_size: typing.Optional[int] = 1000) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1151) **Parámetros:** column_names (`Union[str, Sequence[str]]`) : Nombre(s) de columna(s) para ordenar. reverse (`Union[bool, Sequence[bool]]`, por defecto `False`) : Si es `True`, ordena en orden descendente en lugar de ascendente. Si se proporciona un solo bool, el valor se aplica al ordenamiento de todos los nombres de columnas. En caso contrario, se debe proporcionar una lista de bools con la misma longitud y orden que column_names. null_placement (`str`, por defecto `at_end`) : Coloca los valores `None` al principio si es `at_start` o `first`, o al final si es `at_end` o `last` keep_in_memory (`bool`, por defecto `False`) : Mantener los índices ordenados en memoria en lugar de escribirlos en un archivo de caché. load_from_cache_file (`Optional[bool]`, por defecto `True` si la caché está habilitada) : Si se puede identificar un archivo de caché que almacene los índices ordenados, úsalo en lugar de recalcularlos. indices_cache_file_names (`[Dict[str, str]]`, *opcional*, valor predeterminado `None`) : Proporcione el nombre de una ruta para el archivo de caché. Se utiliza para almacenar el mapeo de índices en lugar del nombre de archivo de caché generado automáticamente. Debe proporcionar un `cache_file_name` por cada conjunto de datos en el diccionario de conjuntos de datos. writer_batch_size (`int`, por defecto `1000`) : Número de filas por operación de escritura para el escritor de archivos de caché. Un valor más alto genera archivos de caché más pequeños, mientras que un valor más bajo consume menos memoria temporal. Crea un nuevo conjunto de datos ordenado según una o varias columnas. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset('cornell-movie-review-data/rotten_tomatoes') >>> ds['train']['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] >>> sorted_ds = ds.sort('label') >>> sorted_ds['train']['label'][:10] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] >>> another_sorted_ds = ds.sort(['label', 'text'], reverse=[True, False]) >>> another_sorted_ds['train']['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ``` #### shuffle[[datasets.DatasetDict.shuffle]] ```python shuffle(seeds: typing.Union[int, dict[str, typing.Optional[int]], NoneType] = None, seed: typing.Optional[int] = None, generators: typing.Optional[dict[str, numpy.random._generator.Generator]] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, indices_cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = None, writer_batch_size: typing.Optional[int] = 1000) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1218) **Parámetros:** seeds (`Dict[str, int]` o `int`, *opcional*) : Una semilla para inicializar el BitGenerator predeterminado si `generator=None`. Si es `None`, se extraerá entropía fresca e impredecible del sistema operativo. Si se pasa un `int` o un `array_like[ints]`, se pasará a SeedSequence para derivar el estado inicial del BitGenerator. Puede proporcionar una `seed` por conjunto de datos en el diccionario de conjuntos de datos. seed (`int`, *opcional*) : Una semilla para inicializar el BitGenerator predeterminado si `generator=None`. Alias de seeds (se lanza un `ValueError` si se proporcionan ambos). generators (`Dict[str, *optional*, np.random.Generator]`) : Generador aleatorio de Numpy para calcular la permutación de las filas del conjunto de datos. Si `generator=None` (predeterminado), se utiliza `np.random.default_rng` (el BitGenerator predeterminado (PCG64) de NumPy). Debes proporcionar un `generator` por cada conjunto de datos en el diccionario de conjuntos de datos. keep_in_memory (`bool`, por defecto `False`) : Mantener el conjunto de datos en memoria en lugar de escribirlo en un archivo de caché. load_from_cache_file (`Optional[bool]`, por defecto `True` si la caché está habilitada) : Si se puede identificar un archivo de caché que almacene el cálculo actual de `function`, úsese en lugar de recalcular. indices_cache_file_names (`Dict[str, str]`, *opcional*) : Proporcione el nombre de una ruta para el archivo de caché. Se utiliza para almacenar los mapeos de índices en lugar del nombre de archivo de caché generado automáticamente. Debe proporcionar un `cache_file_name` por conjunto de datos en el diccionario de conjuntos de datos. writer_batch_size (`int`, por defecto `1000`) : Número de filas por operación de escritura para el escritor de archivos de caché. Este valor es un buen equilibrio entre el uso de memoria durante el procesamiento y la velocidad de procesamiento. Un valor más alto hace que el procesamiento realice menos búsquedas, mientras que un valor más bajo consume menos memoria temporal durante la ejecución de `map`. Crea un nuevo Dataset donde las filas estén barajadas. La transformación se aplica a todos los conjuntos de datos del diccionario de conjuntos de datos. Actualmente, shuffling utiliza generadores aleatorios de numpy. Puede proporcionar un BitGenerator de NumPy para usar, o una semilla para iniciar el generador aleatorio predeterminado de NumPy (PCG64). Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds["train"]["label"][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] # set a seed >>> shuffled_ds = ds.shuffle(seed=42) >>> shuffled_ds["train"]["label"][:10] [0, 1, 0, 1, 0, 0, 0, 0, 0, 0] ``` #### set_format[[datasets.DatasetDict.set_format]] ```python set_format(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L571) **Parámetros:** type (`str`, *opcional*) : Tipo de salida seleccionado en `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` significa que `__getitem__` devuelve objetos de python (predeterminado). columns (`list[str]`, *opcional*) : Columnas para formatear en la salida. `None` significa que `__getitem__` devuelve todas las columnas (predeterminado). output_all_columns (`bool`, predeterminado en False) : Mantener también las columnas sin formato en la salida (como objetos de python), - ****format_kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave pasados a la función de conversión, como `np.array`, `torch.tensor` o `tensorflow.ragged.constant`. Establece el formato de retorno de `__getitem__` (tipo y columnas). El formato se establece para cada conjunto de datos en el diccionario de conjuntos de datos. Es posible llamar a `map` después de llamar a `set_format`. Dado que `map` puede añadir nuevas columnas, la lista de columnas formateadas se actualiza. En este caso, si aplicas `map` a un conjunto de datos para añadir una nueva columna, esta columna se formateará: `new formatted columns = (all columns - previously unformatted columns)` Ejemplo: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x["text"], truncation=True, padding=True), batched=True) >>> ds.set_format(type="numpy", columns=['input_ids', 'token_type_ids', 'attention_mask', 'label']) >>> ds["train"].format {'columns': ['input_ids', 'token_type_ids', 'attention_mask', 'label'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'numpy'} ``` #### reset_format[[datasets.DatasetDict.reset_format]] ```python reset_format() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L622) Restablece el formato de retorno de `__getitem__` a objetos de Python y todas las columnas. La transformación se aplica a todos los datasets del diccionario de datasets. Igual que `self.set_format()` Ejemplo: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x["text"], truncation=True, padding=True), batched=True) >>> ds.set_format(type="numpy", columns=['input_ids', 'token_type_ids', 'attention_mask', 'label']) >>> ds["train"].format {'columns': ['input_ids', 'token_type_ids', 'attention_mask', 'label'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'numpy'} >>> ds.reset_format() >>> ds["train"].format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': None} ``` #### formatted_as[[datasets.DatasetDict.formatted_as]] ```python formatted_as(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L531) **Parámetros:** type (`str`, *opcional*) : Tipo de salida seleccionado en `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` significa que `__getitem__` devuelve objetos de python (predeterminado). columns (`list[str]`, *opcional*) : Columnas para formatear en la salida. `None` significa que `__getitem__` devuelve todas las columnas (predeterminado). output_all_columns (`bool`, predeterminado en False) : Mantener también las columnas sin formato en la salida (como objetos de python). - ****format_kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave pasados a la función de conversión, como `np.array`, `torch.tensor` o `tensorflow.ragged.constant`. Para usarse en una declaración `with`. Establece el formato de retorno de `__getitem__` (tipo y columnas). La transformación se aplica a todos los conjuntos de datos del diccionario de conjuntos de datos. #### with_format[[datasets.DatasetDict.with_format]] ```python with_format(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L683) **Parámetros:** type (`str`, *opcional*) : Tipo de salida seleccionado en `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` significa que `__getitem__` devuelve objetos de python (predeterminado). columns (`list[str]`, *opcional*) : Columnas para formatear en la salida. `None` significa que `__getitem__` devuelve todas las columnas (predeterminado). output_all_columns (`bool`, por defecto `False`) : Mantener también las columnas sin formato en la salida (como objetos de Python). - ****format_kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave pasados a la función de conversión, como `np.array`, `torch.tensor` o `tensorflow.ragged.constant`. Establece el formato de retorno de `__getitem__` (tipo y columnas). El formato de los datos se aplica sobre la marcha. El tipo de formato `type` (por ejemplo, "numpy") se utiliza para formatear los lotes al usar `__getitem__`. El formato se establece para cada conjunto de datos en el diccionario de conjuntos de datos. También es posible usar transformaciones personalizadas para el formato mediante [with_transform()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.with_transform). A diferencia de [set_format()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict.set_format), `with_format` devuelve un nuevo objeto [DatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict) con nuevos objetos [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset). Ejemplo: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True) >>> ds["train"].format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': None} >>> ds = ds.with_format("torch") >>> ds["train"].format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'torch'} >>> ds["train"][0] {'text': 'compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .', 'label': tensor(1), 'input_ids': tensor([ 101, 18027, 16310, 16001, 1103, 9321, 178, 11604, 7235, 6617, 1742, 2165, 2820, 1206, 6588, 22572, 12937, 1811, 2153, 1105, 1147, 12890, 19587, 6463, 1105, 15026, 1482, 119, 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])} ``` #### with_transform[[datasets.DatasetDict.with_transform]] ```python with_transform(transform: typing.Optional[typing.Callable], columns: typing.Optional[list] = None, output_all_columns: bool = False) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L760) **Parámetros:** transform (`Callable`, *opcional*) : Transformación de formato definida por el usuario, reemplaza el formato definido por [set_format()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.set_format). Una función de formato es un objeto invocable que toma un lote (como un diccionario) como entrada y devuelve un lote. Esta función se aplica justo antes de devolver los objetos en `__getitem__`. columns (`list[str]`, *opcional*) : Columnas para formatear en la salida. Si se especifica, el lote de entrada de la transformación solo contiene esas columnas. output_all_columns (`bool`, por defecto False) : Mantener también las columnas sin formato en la salida (como objetos de Python). Si se establece en `True`, las demás columnas sin formato se conservan junto con la salida de la transformación. Establece el formato de retorno de `__getitem__` usando esta transformación. La transformación se aplica al vuelo en los lotes cuando se llama a `__getitem__`. La transformación se establece para cada conjunto de datos en el diccionario de conjuntos de datos Al igual que [set_format()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.set_format), esto se puede restablecer usando [reset_format()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.reset_format). A diferencia de `set_transform()`, `with_transform` devuelve un nuevo objeto [DatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict) con nuevos objetos [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset). Ejemplo: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> def encode(example): ... return tokenizer(example['text'], truncation=True, padding=True, return_tensors="pt") >>> ds = ds.with_transform(encode) >>> ds["train"][0] {'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), 'input_ids': tensor([ 101, 1103, 2067, 1110, 17348, 1106, 1129, 1103, 6880, 1432, 112, 188, 1207, 107, 14255, 1389, 107, 1105, 1115, 1119, 112, 188, 1280, 1106, 1294, 170, 24194, 1256, 3407, 1190, 170, 11791, 5253, 188, 1732, 7200, 10947, 12606, 2895, 117, 179, 7766, 118, 172, 15554, 1181, 3498, 6961, 3263, 1137, 188, 1566, 7912, 14516, 6997, 119, 102]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])} ``` #### flatten[[datasets.DatasetDict.flatten]] ```python flatten(max_depth = 16) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L193) Aplana la tabla Apache Arrow de cada split (las características anidadas se aplanan). Cada columna con tipo struct se aplanó en una columna por cada campo del struct. Las demás columnas se mantienen sin cambios. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rajpurkar/squad") >>> ds["train"].features {'id': Value('string'), 'title': Value('string'), 'context': Value('string'), 'question': Value('string'), 'answers.text': List(Value('string')), 'answers.answer_start': List(Value('int32'))} >>> ds.flatten() DatasetDict({ train: Dataset({ features: ['id', 'title', 'context', 'question', 'answers.text', 'answers.answer_start'], num_rows: 87599 }) validation: Dataset({ features: ['id', 'title', 'context', 'question', 'answers.text', 'answers.answer_start'], num_rows: 10570 }) }) ``` #### cast[[datasets.DatasetDict.cast]] ```python cast(features: Features) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L274) **Parámetros:** features ([Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features)) : Nuevas características a las que se debe convertir el conjunto de datos. El nombre y el orden de los campos en las características deben coincidir con los nombres actuales de las columnas. El tipo de los datos también debe ser convertible de un tipo a otro. Para conversiones no triviales, p. ej. `string` <-> `ClassLabel`, debe usar [map()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict.map) para actualizar el conjunto de datos. Castea el conjunto de datos a un nuevo conjunto de características. La transformación se aplica a todos los conjuntos de datos del diccionario de conjuntos de datos. Ejemplo: ```py >>> from datasets import load_dataset, ClassLabel, Value >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds["train"].features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> new_features = ds["train"].features.copy() >>> new_features['label'] = ClassLabel(names=['bad', 'good']) >>> new_features['text'] = Value('large_string') >>> ds = ds.cast(new_features) >>> ds["train"].features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('large_string')} ``` #### cast_column[[datasets.DatasetDict.cast_column]] ```python cast_column(column: str, feature) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L306) **Parámetros:** column (`str`) : Nombre de la columna. feature (`Feature`) : Característica objetivo. **Devuelve:** [DatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict) Castea la columna a característica para la decodificación. Ejemplo: ```py >>> from datasets import load_dataset, ClassLabel >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds["train"].features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> ds = ds.cast_column('label', ClassLabel(names=['bad', 'good'])) >>> ds["train"].features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('string')} ``` #### remove_columns[[datasets.DatasetDict.remove_columns]] ```python remove_columns(column_names: typing.Union[str, list[str]]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L335) **Parámetros:** column_names (`Union[str, list[str]]`) : Nombre de la(s) columna(s) a eliminar. **Devuelve:** [DatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict) Una copia del objeto de datos sin las columnas a eliminar. Elimina una o varias columnas de cada división del conjunto de datos y las características asociadas a las columnas. La transformación se aplica a todas las divisiones del diccionario de datos. También puede eliminar una columna usando [map()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict.map) con `remove_columns`, pero el método presente no copia los datos de las columnas restantes y, por lo tanto, es más rápido. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds = ds.remove_columns("label") DatasetDict({ train: Dataset({ features: ['text'], num_rows: 8530 }) validation: Dataset({ features: ['text'], num_rows: 1066 }) test: Dataset({ features: ['text'], num_rows: 1066 }) }) ``` #### rename_column[[datasets.DatasetDict.rename_column]] ```python rename_column(original_column_name: str, new_column_name: str) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L377) **Parámetros:** original_column_name (`str`) : Nombre de la columna a renombrar. new_column_name (`str`) : Nuevo nombre para la columna. Renombrar una columna en el conjunto de datos y mover las características asociadas a la columna original bajo el nuevo nombre de columna. La transformación se aplica a todos los conjuntos de datos del diccionario de conjuntos de datos. También puede renombrar una columna usando [map()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict.map) con `remove_columns`, pero el método presente: - se encarga de mover las características originales bajo el nuevo nombre de columna. - no copia los datos a un nuevo conjunto de datos y, por lo tanto, es mucho más rápido. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds = ds.rename_column("label", "label_new") DatasetDict({ train: Dataset({ features: ['text', 'label_new'], num_rows: 8530 }) validation: Dataset({ features: ['text', 'label_new'], num_rows: 1066 }) test: Dataset({ features: ['text', 'label_new'], num_rows: 1066 }) }) ``` #### rename_columns[[datasets.DatasetDict.rename_columns]] ```python rename_columns(column_mapping: dict) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L425) **Parámetros:** column_mapping (`Dict[str, str]`) : Un mapeo de columnas a renombrar a sus nuevos nombres. **Devuelve:** [DatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict) Una copia del conjunto de datos con las columnas renombradas. Renombra varias columnas en el conjunto de datos y mueve las características asociadas a las columnas originales bajo los nuevos nombres de columna. La transformación se aplica a todos los conjuntos de datos del diccionario de conjuntos de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.rename_columns({'text': 'text_new', 'label': 'label_new'}) DatasetDict({ train: Dataset({ features: ['text_new', 'label_new'], num_rows: 8530 }) validation: Dataset({ features: ['text_new', 'label_new'], num_rows: 1066 }) test: Dataset({ features: ['text_new', 'label_new'], num_rows: 1066 }) }) ``` #### select_columns[[datasets.DatasetDict.select_columns]] ```python select_columns(column_names: typing.Union[str, list[str]]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L463) **Parámetros:** column_names (`Union[str, list[str]]`) : Nombre de la(s) columna(s) a conservar. Seleccione una o varias columnas de cada división del conjunto de datos y las características asociadas a la(s) columna(s). La transformación se aplica a todas las divisiones del diccionario de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes") >>> ds.select_columns("text") DatasetDict({ train: Dataset({ features: ['text'], num_rows: 8530 }) validation: Dataset({ features: ['text'], num_rows: 1066 }) test: Dataset({ features: ['text'], num_rows: 1066 }) }) ``` #### class_encode_column[[datasets.DatasetDict.class_encode_column]] ```python class_encode_column(column: str, include_nulls: bool = False) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L499) **Parámetros:** column (`str`) : El nombre de la columna a convertir. include_nulls (`bool`, por defecto `False`) : Si se incluyen valores nulos en las etiquetas de clase. Si es `True`, los valores nulos se codificarán como la etiqueta de clase `"None"`. Convierte la columna indicada en [ClassLabel](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.ClassLabel) y actualiza las tablas. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("google/boolq") >>> ds["train"].features {'answer': Value('bool'), 'passage': Value('string'), 'question': Value('string')} >>> ds = ds.class_encode_column("answer") >>> ds["train"].features {'answer': ClassLabel(num_classes=2, names=['False', 'True']), 'passage': Value('string'), 'question': Value('string')} ``` #### push_to_hub[[datasets.DatasetDict.push_to_hub]] ```python push_to_hub(repo_id: str, config_name: str = 'default', set_default: typing.Optional[bool] = None, data_dir: typing.Optional[str] = None, commit_message: typing.Optional[str] = None, commit_description: typing.Optional[str] = None, private: typing.Optional[bool] = None, token: typing.Optional[str] = None, revision: typing.Optional[str] = None, create_pr: typing.Optional[bool] = False, max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[dict[str, int]] = None, embed_external_files: bool = True, num_proc: typing.Optional[int] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1623) **Parámetros:** repo_id (`str`) : El ID del repositorio al que se enviarán los datos, en el siguiente formato: `/` o `/`. También acepta ``, que por defecto usará el espacio de nombres del usuario conectado. También puede ser una ubicación dentro de un bucket, por ejemplo `buckets///...` config_name (`str`) : Nombre de configuración de un conjunto de datos. El valor predeterminado es "default". set_default (`bool`, *opcional*) : Si se establece esta configuración como la predeterminada. De lo contrario, la configuración predeterminada es la denominada "default". data_dir (`str`, *opcional*) : Nombre del directorio que contendrá los archivos de datos subidos. El valor predeterminado es `config_name` si es diferente de "default"; en caso contrario, es "data". commit_message (`str`, *opcional*) : Mensaje a confirmar al hacer push. El valor predeterminado será `"Upload dataset"`. commit_description (`str`, *opcional*) : Descripción del commit que se creará. Además, descripción de la PR si se crea una PR (`create_pr` es True). private (`bool`, *opcional*) : Si se debe hacer el repositorio privado. Si es `None` (predeterminado), el repositorio será público a menos que el valor predeterminado de la organización sea privado. Este valor se ignora si el repositorio ya existe. token (`str`, *opcional*) : Un token de autenticación opcional para Hugging Face Hub. Si no se pasa ningún token, se usará por defecto el token guardado localmente al iniciar sesión con `hf auth login`. Se generará un error si no se pasa ningún token y el usuario no ha iniciado sesión. revision (`str`, *opcional*) : Rama a la que se enviarán los archivos subidos. Por defecto, la rama `"main"`. create_pr (`bool`, *opcional*, por defecto `False`) : Si se debe crear una PR con los archivos subidos o realizar el commit directamente. max_shard_size (`int` o `str`, *opcional*, valor predeterminado `"500MB"`) : El tamaño máximo de los fragmentos del conjunto de datos que se subirán al hub. Si se expresa como una cadena, debe consistir en dígitos seguidos de una unidad (como `"500MB"` o `"1GB"`). num_shards (`Dict[str, int]`, *opcional*) : Número de fragmentos a escribir. Por defecto, el número de fragmentos depende de `max_shard_size`. Utilice un diccionario para definir un num_shards diferente para cada split. embed_external_files (`bool`, por defecto `True`) : Si se deben incrustar los bytes de los archivos en los fragmentos. En particular, esto hará lo siguiente antes de la publicación para los campos de tipo: - [Audio](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Audio) y [Image](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Image) elimina la información de la ruta local e incrusta el contenido del archivo en los archivos Parquet. num_proc (`int`, *opcional*, valor predeterminado `None`) : Número de procesos al preparar y subir el conjunto de datos. Esto es útil si el conjunto de datos está compuesto por muchas muestras o archivos multimedia para incrustar. Usa el contexto "spawn" para funcionar con hf_xet, el cliente de rust para subidas rápidas a HF. La multiprocesación está deshabilitada de forma predeterminada. **Devuelve:** huggingface_hub.CommitInfo Envía el [DatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict) al hub como un dataset Parquet. El [DatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict) se envía mediante solicitudes HTTP y no requiere tener instalados ni git ni git-lfs. Cada división del conjunto de datos se subirá de forma independiente. El conjunto de datos subido mantendrá los nombres originales de las divisiones. Los archivos Parquet resultantes son autosuficientes por defecto: si su conjunto de datos contiene datos de [Image](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Image) o [Audio](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Audio), los archivos Parquet almacenarán los bytes de sus imágenes o archivos de audio. Puede desactivar esto estableciendo `embed_external_files` en False. Ejemplo: ```python >>> dataset_dict.push_to_hub("/") >>> dataset_dict.push_to_hub("/", private=True) >>> dataset_dict.push_to_hub("/", max_shard_size="1GB") >>> dataset_dict.push_to_hub("/", num_shards={"train": 1024, "test": 8}) ``` Si desea agregar una nueva configuración (o subconjunto) a un conjunto de datos (por ejemplo, si el conjunto de datos tiene múltiples tareas/versiones/idiomas): ```python >>> english_dataset.push_to_hub("/", "en") >>> french_dataset.push_to_hub("/", "fr") >>> # later >>> english_dataset = load_dataset("/", "en") >>> french_dataset = load_dataset("/", "fr") ``` #### save_to_disk[[datasets.DatasetDict.save_to_disk]] ```python save_to_disk(dataset_dict_path: typing.Union[str, bytes, os.PathLike], max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[dict[str, int]] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1301) **Parámetros:** dataset_dict_path (`path-like`) : Path (p. ej. `dataset/train`) o URI remoto (p. ej. `s3://my-bucket/dataset/train`) del directorio del diccionario de datos donde se guardará el diccionario de datos. max_shard_size (`int` o `str`, *opcional*, valor predeterminado `"500MB"`) : El tamaño máximo de los fragmentos del conjunto de datos que se guardarán en el sistema de archivos. Si se expresa como una cadena, debe consistir en dígitos seguidos de una unidad (como `"50MB"`). num_shards (`Dict[str, int]`, *opcional*) : Número de fragmentos a escribir. Por defecto, el número de fragmentos depende de `max_shard_size` y `num_proc`. Debes proporcionar el número de fragmentos para cada conjunto de datos en el diccionario de conjuntos de datos. Usa un diccionario para definir un num_shards diferente para cada split. num_proc (`int`, *opcional*, valor predeterminado `None`) : Número de procesos al descargar y generar el dataset 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, si lo hay. Guarda un diccionario de datos en un sistema de archivos usando `fsspec.spec.AbstractFileSystem`. Para datos de [Image](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Audio) y [Video](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Video): Todos los datos de Image(), Audio() y Video() se almacenan en los archivos arrow. Si desea almacenar rutas o urls, use el tipo Value("string"). Ejemplo: ```python >>> dataset_dict.save_to_disk("path/to/dataset/directory") >>> dataset_dict.save_to_disk("path/to/dataset/directory", max_shard_size="1GB") >>> dataset_dict.save_to_disk("path/to/dataset/directory", num_shards={"train": 1024, "test": 8}) ``` #### load_from_disk[[datasets.DatasetDict.load_from_disk]] ```python load_from_disk(dataset_dict_path: typing.Union[str, bytes, os.PathLike], keep_in_memory: typing.Optional[bool] = None, storage_options: typing.Optional[dict] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1375) **Parámetros:** dataset_dict_path (`path-like`) : Path (p. ej. `"dataset/train"`) o URI remoto (p. ej. `"s3//my-bucket/dataset/train"`) del directorio del diccionario de datos desde el que se cargará el diccionario de datos. keep_in_memory (`bool`, por defecto `None`) : Si se debe copiar el conjunto de datos en memoria. Si es `None`, el conjunto de datos no se copiará en memoria a menos que se habilite explícitamente estableciendo `datasets.config.IN_MEMORY_MAX_SIZE` en un valor distinto de cero. Consulte más detalles en la sección [mejorar el rendimiento](../cache#improve-performance). storage_options (`dict`, *opcional*) : Pares clave/valor que se pasarán al backend del sistema de archivos, si lo hay. **Devuelve:** [DatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict) Cargue un conjunto de datos que se guardó previamente en un sistema de archivos con `save_to_disk` usando `fsspec.spec.AbstractFileSystem`. Ejemplo: ```py >>> ds = load_from_disk('path/to/dataset/directory') ``` #### from_csv[[datasets.DatasetDict.from_csv]] ```python from_csv(path_or_paths: dict, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, **kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1435) **Parámetros:** path_or_paths (`dict` de rutas tipo path) : Ruta(s) del archivo(s) CSV. features ([Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features), *opcional*) : Características del conjunto de datos. cache_dir (str, *opcional*, por defecto `"~/.cache/huggingface/datasets"`) : Directorio para almacenar los datos en caché. keep_in_memory (`bool`, por defecto `False`) : Si se debe copiar los datos en memoria. - ****kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave que se pasarán a `pandas.read_csv`. **Devuelve:** [DatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict) Crea un [DatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict) a partir de archivo(s) CSV. Ejemplo: ```py >>> from datasets import DatasetDict >>> ds = DatasetDict.from_csv({'train': 'path/to/dataset.csv'}) ``` #### from_json[[datasets.DatasetDict.from_json]] ```python from_json(path_or_paths: dict, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, **kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1478) **Parámetros:** path_or_paths (`path-like` o lista de `path-like`) : Ruta(s) del archivo(s) JSON Lines. features ([Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features), *opcional*) : Características del conjunto de datos. cache_dir (str, *opcional*, por defecto `"~/.cache/huggingface/datasets"`) : Directorio para almacenar los datos en caché. keep_in_memory (`bool`, por defecto `False`) : Si se debe copiar los datos en memoria. - ****kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave que se pasarán a `JsonConfig`. **Devuelve:** [DatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict) Crea [DatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict) a partir de archivo(s) JSON Lines. Ejemplo: ```py >>> from datasets import DatasetDict >>> ds = DatasetDict.from_json({'train': 'path/to/dataset.json'}) ``` #### from_parquet[[datasets.DatasetDict.from_parquet]] ```python from_parquet(path_or_paths: dict, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, columns: typing.Optional[list[str]] = None, **kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1521) **Parámetros:** path_or_paths (`dict` de rutas tipo path) : Ruta(s) del archivo(s) CSV. features ([Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features), *opcional*) : Características del conjunto de datos. cache_dir (`str`, *opcional*, por defecto `"~/.cache/huggingface/datasets"`) : Directorio para cachear datos. keep_in_memory (`bool`, por defecto `False`) : Si se debe copiar los datos en memoria. columns (`list[str]`, *opcional*) : Si no es `None`, solo se leerán estas columnas del archivo. El nombre de una columna puede ser un prefijo de un campo anidado, p. ej. 'a' seleccionará 'a.b', 'a.c' y 'a.d.e'. - ****kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave que se pasarán a `ParquetConfig`. **Devuelve:** [DatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict) Crea un [DatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict) a partir de archivo(s) Parquet. Ejemplo: ```py >>> from datasets import DatasetDict >>> ds = DatasetDict.from_parquet({'train': 'path/to/dataset/parquet'}) ``` #### from_text[[datasets.DatasetDict.from_text]] ```python from_text(path_or_paths: dict, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, **kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1570) **Parámetros:** path_or_paths (`dict` de rutas tipo path) : Ruta(s) del archivo(s) de texto. features ([Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features), *opcional*) : Características del conjunto de datos. cache_dir (`str`, *opcional*, por defecto `"~/.cache/huggingface/datasets"`) : Directorio para cachear datos. keep_in_memory (`bool`, por defecto `False`) : Si se debe copiar los datos en memoria. - ****kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave que se pasarán a `TextConfig`. **Devuelve:** [DatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict) Crea un [DatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetDict) a partir de archivo(s) de texto. Ejemplo: ```py >>> from datasets import DatasetDict >>> ds = DatasetDict.from_text({'train': 'path/to/dataset.txt'}) ``` ## IterableDataset[[datasets.IterableDataset]] La clase base [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset) implementa un Dataset iterable basado en generadores de python. #### datasets.IterableDataset[[datasets.IterableDataset]] ```python datasets.IterableDataset(ex_iterable: _BaseExamplesIterable, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, formatting: typing.Optional[datasets.iterable_dataset.FormattingConfig] = None, distributed: typing.Optional[datasets.iterable_dataset.DistributedConfig] = None, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L2690) Un Dataset respaldado por un iterable. #### from_file[[datasets.IterableDataset.from_file]] ```python from_file(filename: str) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3188) **Parámetros:** filename (`str`) : Nombre del archivo del conjunto de datos. **Devuelve:** [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset) Instancia un IterableDataset desde una tabla Arrow en el archivo con el nombre especificado. #### from_pandas[[datasets.IterableDataset.from_pandas]] ```python from_pandas(df: DataFrame, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, preserve_index: typing.Optional[bool] = None, num_shards: typing.Optional[int] = 1) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3204) **Parámetros:** df (`pandas.DataFrame`) : Dataframe que contiene el conjunto de datos. features ([Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features), *opcional*) : Características del conjunto de datos. info (`DatasetInfo`, *opcional*) : Información del conjunto de datos, como la descripción, la cita, etc. split (`NamedSplit`, *opcional*) : Nombre de la división del conjunto de datos. preserve_index (`bool`, *opcional*) : Si se debe almacenar el índice como una columna adicional en el Dataset resultante. El valor predeterminado de `None` almacenará el índice como una columna, excepto para `RangeIndex`, que se almacena solo como metadatos. Use `preserve_index=True` para forzar que se almacene como una columna. num_shards (`int`, por defecto `1`) : Número de fragmentos a definir al instanciar el dataset iterable. Esto es especialmente útil para datasets grandes para poder barajar correctamente, y también para habilitar la carga paralela rápida usando un PyTorch DataLoader o en configuraciones distribuidas, por ejemplo. **Devuelve:** [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset) Convierta `pandas.DataFrame` en una `pyarrow.Table` para crear un [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset). Los tipos de columna en la Tabla Arrow resultante se infieren a partir de los dtypes de las `pandas.Series` en el DataFrame. En el caso de Series que no son de objeto, el dtype de NumPy se traduce a su equivalente en Arrow. En el caso de `object`, es necesario inferir el tipo de datos examinando los objetos Python presentes en esta Series. Tenga en cuenta que las Series de tipo `object` no contienen suficiente información para derivar siempre un tipo Arrow significativo. En el caso de que no podamos inferir un tipo, por ejemplo, porque el DataFrame tiene longitud 0 o la Series solo contiene objetos `None/nan`, el tipo se establece como `null`. Este comportamiento se puede evitar construyendo características explícitas y pasándolas a esta función. Importante: un dataset creado con from_pandas() se almacena en memoria. Esto podría cambiar en el futuro, pero mientras tanto, si deseas reducir el uso de memoria, debes escribirlo en disco y recargarlo usando, por ejemplo, to_parquet / from_parquet. Ejemplo: ```py >>> ds = IterableDataset.from_pandas(df) ``` #### from_dict[[datasets.IterableDataset.from_dict]] ```python from_dict(mapping: dict, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, num_shards: typing.Optional[int] = 1) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3316) **Parámetros:** mapping (`Mapping`) : Mapeo de cadenas de texto a Arrays o listas de Python. features ([Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features), *opcional*) : Características del conjunto de datos. info (`DatasetInfo`, *opcional*) : Información del conjunto de datos, como la descripción, la cita, etc. split (`NamedSplit`, *opcional*) : Nombre de la división del conjunto de datos. num_shards (`int`, por defecto `1`) : Número de fragmentos a definir al instanciar el dataset iterable. Esto es especialmente útil para datasets grandes para poder barajar correctamente, y también para habilitar la carga paralela rápida usando un PyTorch DataLoader o en configuraciones distribuidas, por ejemplo. **Devuelve:** [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset) Convierta `dict` en una `pyarrow.Table` para crear un [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset). Importante: un dataset creado con from_dict() se almacena en memoria. Esto podría cambiar en el futuro, pero mientras tanto, si deseas reducir el uso de memoria, debes escribirlo de nuevo en el disco y recargarlo, por ejemplo, usando to_parquet / from_parquet. #### from_list[[datasets.IterableDataset.from_list]] ```python from_list(mapping: list, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, num_shards: typing.Optional[int] = 1) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3353) **Parámetros:** mapping (`List[dict]`) : Una lista de mapeos de cadenas a valores de fila. features (`Features`, opcional) : Características del conjunto de datos. info (`DatasetInfo`, opcional) : Información del conjunto de datos, como la descripción, la cita, etc. split (`NamedSplit`, opcional) : Nombre de la división del conjunto de datos. num_shards (`int`, por defecto `1`) : Número de fragmentos a definir al instanciar el dataset iterable. Esto es especialmente útil para datasets grandes para poder barajar correctamente, y también para habilitar la carga paralela rápida usando un PyTorch DataLoader o en configuraciones distribuidas, por ejemplo. **Devuelve:** [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset) Convierta una lista de diccionarios en una `pyarrow.Table` para crear un [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset)`. Tenga en cuenta que las claves de la primera entrada se usarán para determinar las columnas del conjunto de datos, independientemente de lo que se pase a features. Importante: un dataset creado con from_list() se almacena en memoria. Esto podría cambiar en el futuro, pero mientras tanto, si deseas reducir el uso de memoria, debes escribirlo de nuevo en el disco y recargarlo usando, por ejemplo, from_parquet / to_parquet. #### from_generator[[datasets.IterableDataset.from_generator]] ```python from_generator(generator: typing.Callable, features: typing.Optional[datasets.features.features.Features] = None, gen_kwargs: typing.Optional[dict] = None, split: NamedSplit = NamedSplit('train')) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3090) **Parámetros:** generator (`Callable`) : Una función generadora que `yields` ejemplos. features (`Features`, *opcional*) : Características del conjunto de datos. gen_kwargs(`dict`, *opcional*) : Argumentos de palabra clave que se pasarán al objeto invocable `generator`. Puede definir un conjunto de datos iterable fragmentado pasando la lista de fragmentos en `gen_kwargs`. Esto se puede usar para mejorar el barajado y al iterar sobre el conjunto de datos con múltiples trabajadores. split ([NamedSplit](/docs/datasets/v5.2.0/es/package_reference/builder_classes#datasets.NamedSplit), por defecto `Split.TRAIN`) : Nombre de la división que se asignará al conjunto de datos. **Devuelve:** [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset) Crea un Iterable Dataset a partir de un generador. Ejemplo: ```py >>> def gen(): ... yield {"text": "Good", "label": 0} ... yield {"text": "Bad", "label": 1} ... >>> ds = IterableDataset.from_generator(gen) ``` ```py >>> def gen(shards): ... for shard in shards: ... with open(shard) as f: ... for line in f: ... yield {"line": line} ... >>> shards = [f"data{i}.txt" for i in range(32)] >>> ds = IterableDataset.from_generator(gen, gen_kwargs={"shards": shards}) >>> ds = ds.shuffle(seed=42, buffer_size=10_000) # shuffles the shards order + uses a shuffle buffer >>> from torch.utils.data import DataLoader >>> dataloader = DataLoader(ds.with_format("torch"), num_workers=4) # give each worker a subset of 32/4=8 shards ``` #### remove_columns[[datasets.IterableDataset.remove_columns]] ```python remove_columns(column_names: typing.Union[str, list[str]]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4343) **Parámetros:** column_names (`Union[str, List[str]]`) : Nombre de la(s) columna(s) a eliminar. **Devuelve:** `IterableDataset` Una copia del objeto de datos sin las columnas a eliminar. Elimina una o varias columnas del conjunto de datos y las características asociadas a ellas. La eliminación se realiza sobre la marcha en los ejemplos al iterar sobre el conjunto de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> next(iter(ds)) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'label': 1} >>> ds = ds.remove_columns("label") >>> next(iter(ds)) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### select_columns[[datasets.IterableDataset.select_columns]] ```python select_columns(column_names: typing.Union[str, list[str]]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4378) **Parámetros:** column_names (`Union[str, List[str]]`) : Nombre de la(s) columna(s) a seleccionar. **Devuelve:** `IterableDataset` Una copia del objeto de conjunto de datos con las columnas seleccionadas. Seleccione una o varias columnas del conjunto de datos y las características asociadas a ellas. La selección se realiza sobre la marcha en los ejemplos al iterar sobre el conjunto de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> next(iter(ds)) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'label': 1} >>> ds = ds.select_columns("text") >>> next(iter(ds)) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### cast_column[[datasets.IterableDataset.cast_column]] ```python cast_column(column: str, feature: typing.Union[dict, list, tuple, datasets.features.features.Value, datasets.features.features.ClassLabel, datasets.features.translation.Translation, datasets.features.translation.TranslationVariableLanguages, datasets.features.features.LargeList, datasets.features.features.List, datasets.features.features.Array2D, datasets.features.features.Array3D, datasets.features.features.Array4D, datasets.features.features.Array5D, datasets.features.audio.Audio, datasets.features.image.Image, datasets.features.mesh.Mesh, datasets.features.video.Video, datasets.features.pdf.Pdf, datasets.features.nifti.Nifti, datasets.features.bio_sequence.BioSequence, datasets.features.bio_structure.BioStructure]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4428) **Parámetros:** column (`str`) : Nombre de la columna. feature (`Feature`) : Característica objetivo. **Devuelve:** `IterableDataset` Castea la columna a característica para la decodificación. Ejemplo: ```py >>> from datasets import load_dataset, Audio >>> ds = load_dataset("PolyAI/minds14", name="en-US", split="train", streaming=True) >>> ds.features {'audio': Audio(sampling_rate=8000, mono=True, decode=True, id=None), 'english_transcription': Value('string'), 'intent_class': ClassLabel(num_classes=14, names=['abroad', 'address', 'app_error', 'atm_limit', 'balance', 'business_loan', 'card_issues', 'cash_deposit', 'direct_debit', 'freeze', 'high_value_payment', 'joint_account', 'latest_transactions', 'pay_bill']), 'lang_id': ClassLabel(num_classes=14, names=['cs-CZ', 'de-DE', 'en-AU', 'en-GB', 'en-US', 'es-ES', 'fr-FR', 'it-IT', 'ko-KR', 'nl-NL', 'pl-PL', 'pt-PT', 'ru-RU', 'zh-CN']), 'path': Value('string'), 'transcription': Value('string')} >>> ds = ds.cast_column("audio", Audio(sampling_rate=16000)) >>> ds.features {'audio': Audio(sampling_rate=16000, mono=True, decode=True, id=None), 'english_transcription': Value('string'), 'intent_class': ClassLabel(num_classes=14, names=['abroad', 'address', 'app_error', 'atm_limit', 'balance', 'business_loan', 'card_issues', 'cash_deposit', 'direct_debit', 'freeze', 'high_value_payment', 'joint_account', 'latest_transactions', 'pay_bill']), 'lang_id': ClassLabel(num_classes=14, names=['cs-CZ', 'de-DE', 'en-AU', 'en-GB', 'en-US', 'es-ES', 'fr-FR', 'it-IT', 'ko-KR', 'nl-NL', 'pl-PL', 'pt-PT', 'ru-RU', 'zh-CN']), 'path': Value('string'), 'transcription': Value('string')} ``` #### cast[[datasets.IterableDataset.cast]] ```python cast(features: Features) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4474) **Parámetros:** features ([Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features)) : Nuevas características a las que se debe convertir el conjunto de datos. El nombre de los campos en las características debe coincidir con los nombres actuales de las columnas. El tipo de los datos también debe ser convertible de un tipo a otro. Para conversiones no triviales, p. ej. `string` <-> `ClassLabel`, debe usar [map()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.map) para actualizar el Dataset. **Devuelve:** `IterableDataset` Una copia del conjunto de datos con las características convertidas. Castea el conjunto de datos a un nuevo conjunto de características. Ejemplo: ```py >>> from datasets import load_dataset, ClassLabel, Value >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> ds.features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> new_features = ds.features.copy() >>> new_features["label"] = ClassLabel(names=["bad", "good"]) >>> new_features["text"] = Value("large_string") >>> ds = ds.cast(new_features) >>> ds.features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('large_string')} ``` #### decode[[datasets.IterableDataset.decode]] ```python decode(enable: bool = True, num_threads: typing.Optional[int] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4520) **Parámetros:** enable (`bool`, por defecto `True`) : Habilita o deshabilita la decodificación de características. num_threads (`int`, *opcional*, valor predeterminado `None`) : Habilita la multihilo para la decodificación de características. Tenga en cuenta que [load_dataset()](/docs/datasets/v5.2.0/es/package_reference/loading_methods#datasets.load_dataset) ya utiliza algunos hilos de forma predeterminada al transmitir un conjunto de datos en HF con características decodificables. De forma predeterminada, `num_threads` se establece en 32 si al menos una característica requiere decodificación, y en 0 en caso contrario. **Devuelve:** `IterableDataset` Una copia del conjunto de datos con las características convertidas. Activar o desactivar la decodificación de las características del conjunto de datos para audio, imagen y vídeo. Cuando está habilitado (valor predeterminado), los tipos de medios se decodifican: * audio -> diccionario de "array" y "sampling_rate" y "path" * image -> PIL.Image * video -> torchcodec.decoders.VideoDecoder La multihilo se puede habilitar con `num_threads`: cada archivo multimedia se lee y decodifica entonces en un hilo de trabajo, de modo que los viajes de red de los ejemplos consecutivos se solapan. Esto es especialmente útil para acelerar la transmisión de datos remotos, y [load_dataset()](/docs/datasets/v5.2.0/es/package_reference/loading_methods#datasets.load_dataset) ya lo habilita de forma predeterminada al transmitir un conjunto de datos remoto que tiene características decodificables (ver `HF_DATASETS_DECODE_NUM_THREADS`). Los conjuntos de datos leídos del disco local se transmiten con `num_threads=0`, ya que la multihilo puede ser más lenta que la decodificación en el hilo principal para datos locales en discos rápidos. Dado que los ejemplos se decodifican con antelación, cada hilo en vuelo puede mantener un ejemplo en memoria: reduzca `num_threads` para usar menos memoria. Desactivar la decodificación es útil si desea iterar sobre las rutas o los bytes de los archivos multimedia sin decodificar realmente su contenido. Para desactivar la decodificación, puede usar `.decode(False)`, que es equivalente a llamar a `.cast()` o `.cast_column()` con todos los tipos Audio, Image y Video configurados en `decode=False`. Ejemplos: Desactivar la decodificación: ```py >>> from datasets import load_dataset >>> ds = load_dataset("sshh12/planet-textures", split="train", streaming=True) >>> next(iter(ds)) {'image': , 'text': 'A distant celestial object with an icy crust, displaying a light blue shade, covered with round pits and rugged terrains.'} >>> ds = ds.decode(False) >>> ds.features {'image': Image(mode=None, decode=False, id=None), 'text': Value('string')} >>> next(iter(ds)) { 'image': { 'path': 'hf://datasets/sshh12/planet-textures@69dc4cef7a5c4b2cfe387727ec8ea73d4bff7302/train/textures/0000.png', 'bytes': None }, 'text': 'A distant celestial object with an icy crust, displaying a light blue shade, covered with round pits and rugged terrains.' } ``` Acelera el streaming con multihilo: ```py >>> import os >>> from datasets import load_dataset >>> from tqdm import tqdm >>> ds = load_dataset("sshh12/planet-textures", split="train", streaming=True) >>> # already threaded by default with 32 threads, but more threads can help going even faster >>> ds = ds.decode(num_threads=64) >>> for _ in tqdm(ds): # 2 times faster ! ... ... ``` #### __iter__[[datasets.IterableDataset.__iter__]] ```python __iter__() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3035) #### iter[[datasets.IterableDataset.iter]] ```python iter(batch_size: int, drop_last_batch: bool = False) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3056) **Parámetros:** batch_size (`int`) : tamaño de cada lote que se generará. drop_last_batch (`bool`, por defecto *False*) : Si un último lote más pequeño que batch_size debe descartarse Itera sobre los lotes de tamaño *batch_size*. #### map[[datasets.IterableDataset.map]] ```python map(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, drop_last_batch: bool = False, remove_columns: typing.Union[str, list[str], NoneType] = None, features: typing.Optional[datasets.features.features.Features] = None, fn_kwargs: typing.Optional[dict] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3676) **Parámetros:** function (`Callable`, *opcional*, valor predeterminado `None`) : Función aplicada al vuelo en los ejemplos al iterar sobre el conjunto de datos. Debe tener una de las siguientes firmas: - `function(example: Dict[str, Any]) -> Dict[str, Any]` si `batched=False` y `with_indices=False` - `function(example: Dict[str, Any], idx: int) -> Dict[str, Any]` si `batched=False` y `with_indices=True` - `function(batch: Dict[str, List]) -> Dict[str, List]` si `batched=True` y `with_indices=False` - `function(batch: Dict[str, List], indices: List[int]) -> Dict[str, List]` si `batched=True` y `with_indices=True` Para un uso avanzado, la función también puede devolver una `pyarrow.Table`. Si la función es asíncrona, `map` ejecutará su función en paralelo. Además, si su función no devuelve nada (`None`), `map` ejecutará su función y devolverá el conjunto de datos sin cambios. Si no se proporciona ninguna función, se usa la función identidad por defecto: `lambda x: x`. with_indices (`bool`, por defecto `False`) : Proporciona índices de ejemplos a `function`. Ten en cuenta que, en este caso, la firma de `function` debe ser `def function(example, idx[, rank]): ...`. input_columns (`Optional[Union[str, List[str]]]`, por defecto `None`) : Las columnas que se pasarán a `function` como argumentos posicionales. Si es `None`, se pasa un diccionario con todas las columnas formateadas como un solo argumento. batched (`bool`, por defecto `False`) : Proporcionar un lote de ejemplos a `function`. batch_size (`int`, *opcional*, valor predeterminado `1000`) : Número de ejemplos por lote proporcionados a `function` si `batched=True`. Si `batch_size <= 0` o `batch_size == None`, se proporciona el conjunto de datos completo como un único lote a `function`. drop_last_batch (`bool`, por defecto `False`) : Si un último lote más pequeño que batch_size debe descartarse en lugar de ser procesado por la función. remove_columns (`[List[str]]`, *opcional*, valor predeterminado `None`) : Elimina una selección de columnas durante el mapeo. Las columnas se eliminarán antes de actualizar los ejemplos con la salida de `function`, es decir, si `function` está añadiendo columnas con nombres en `remove_columns`, estas columnas se conservarán. features (`[Features]`, *opcional*, valor predeterminado `None`) : Tipos de características del conjunto de datos resultante. fn_kwargs (`Dict`, *opcional*, valor predeterminado `None`) : Argumentos de palabra clave que se pasarán a `function`. Aplica una función a todos los ejemplos del dataset iterable (individualmente o en lotes) y los actualiza. Si la función devuelve una columna que ya existe, la sobrescribe. La función se aplica sobre la marcha a los ejemplos al iterar sobre el dataset. Puede especificar si la función debe agruparse o no con el parámetro `batched`: - Si `False`, la función toma 1 ejemplo como entrada y debe devolver 1 ejemplo. Un ejemplo es un diccionario, p. ej. `{"text": "Hello there !"}`. - Si `True` es `batch_size` y `batch_size` es 1, la función toma como entrada un lote de 1 ejemplo y puede devolver un lote con 1 o más ejemplos. Un lote es un diccionario, por ejemplo, un lote de 1 ejemplo es {"text": ["Hello there !"]}. - Si `True` y `batch_size` es `n` > 1, la función toma como entrada un lote de `n` ejemplos y puede devolver un lote con `n` ejemplos, o con un número arbitrario de ejemplos. Tenga en cuenta que el último lote puede tener menos de `n` ejemplos. Un lote es un diccionario, por ejemplo, un lote de `n` ejemplos es `{"text": ["Hello there !"] * n}`. Si la función es asíncrona, `map` ejecutará tu función en paralelo, con hasta mil llamadas simultáneas. Se recomienda usar un `asyncio.Semaphore` en tu función si deseas establecer un número máximo de operaciones que pueden ejecutarse al mismo tiempo. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> def add_prefix(example): ... example["text"] = "Review: " + example["text"] ... return example >>> ds = ds.map(add_prefix) >>> list(ds.take(3)) [{'label': 1, 'text': 'Review: the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'Review: the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'Review: effective but too-tepid biopic'}] ``` #### rename_column[[datasets.IterableDataset.rename_column]] ```python rename_column(original_column_name: str, new_column_name: str) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4288) **Parámetros:** original_column_name (`str`) : Nombre de la columna a renombrar. new_column_name (`str`) : Nuevo nombre para la columna. **Devuelve:** `IterableDataset` Una copia del conjunto de datos con una columna renombrada. Renombrar una columna en el conjunto de datos y mover las características asociadas a la columna original bajo el nuevo nombre de columna. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> next(iter(ds)) {'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} >>> ds = ds.rename_column("text", "movie_review") >>> next(iter(ds)) {'label': 1, 'movie_review': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### filtro[[datasets.IterableDataset.filter]] ```python filter(function: typing.Optional[typing.Callable] = None, with_indices = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, fn_kwargs: typing.Optional[dict] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3858) **Parámetros:** function (`Callable`) : Llamable con una de las siguientes firmas: - `function(example: Dict[str, Any]) -> bool` si `with_indices=False, batched=False` - `function(example: Dict[str, Any], indices: int) -> bool` si `with_indices=True, batched=False` - `function(example: Dict[str, List]) -> List[bool]` si `with_indices=False, batched=True` - `function(example: Dict[str, List], indices: List[int]) -> List[bool]` si `with_indices=True, batched=True` Si la función es asíncrona, `filter` ejecutará su función en paralelo. Si no se proporciona ninguna función, se usa por defecto una función que siempre devuelve True: `lambda x: True`. with_indices (`bool`, por defecto `False`) : Proporciona índices de ejemplos a `function`. Ten en cuenta que, en este caso, la firma de `function` debe ser `def function(example, idx): ...`. input_columns (`str` o `List[str]`, *opcional*) : Las columnas que se pasarán a `function` como argumentos posicionales. Si es `None`, se pasa un diccionario con todas las columnas formateadas como un solo argumento. batched (`bool`, por defecto `False`) : Proporcionar un lote de ejemplos a `function`. batch_size (`int`, *opcional*, valor predeterminado `1000`) : Número de ejemplos por lote proporcionados a `function` si `batched=True`. fn_kwargs (`Dict`, *opcional*, valor predeterminado `None`) : Argumentos de palabra clave que se pasarán a `function`. Aplica una función de filtro a todos los elementos para que el conjunto de datos solo incluya ejemplos según la función de filtro. El filtrado se realiza sobre la marcha al iterar sobre el conjunto de datos. Si la función es asíncrona, `filter` ejecutará tu función en paralelo, con un máximo de mil llamadas simultáneas (configurable). Se recomienda usar un `asyncio.Semaphore` en tu función si deseas establecer un número máximo de operaciones que pueden ejecutarse al mismo tiempo. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> ds = ds.filter(lambda x: x["label"] == 0) >>> list(ds.take(3)) [{'label': 0, 'movie_review': 'simplistic , silly and tedious .'}, {'label': 0, 'movie_review': "it's so laddish and juvenile , only teenage boys could possibly find it funny ."}, {'label': 0, 'movie_review': 'exploitative and largely devoid of the depth or sophistication that would make watching such a graphic treatment of the crimes bearable .'}] ``` #### shuffle[[datasets.IterableDataset.shuffle]] ```python shuffle(seed = None, generator: typing.Optional[numpy.random._generator.Generator] = None, buffer_size: int = 1000, max_buffer_input_shards: int = 10) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3961) **Parámetros:** seed (`int`, *opcional*, valor predeterminado `None`) : Semilla aleatoria que se utilizará para barajar el conjunto de datos. Se usa para muestrear del búfer de barajado y también para barajar los fragmentos de datos. generator (`numpy.random.Generator`, *opcional*) : Generador aleatorio de Numpy para calcular la permutación de las filas del conjunto de datos. Si `generator=None` (predeterminado), se utiliza `np.random.default_rng` (el BitGenerator predeterminado (PCG64) de NumPy). buffer_size (`int`, por defecto `1000`) : Tamaño del búfer. max_buffer_input_shards (`int`, por defecto `10`) : Número máximo de fragmentos para alimentar el búfer a la vez. Baraja aleatoriamente los elementos de este conjunto de datos. Este conjunto de datos llena un búfer con `buffer_size` elementos y luego muestrea aleatoriamente elementos de este búfer, reemplazando los elementos seleccionados con nuevos elementos. Para un barajado perfecto, se requiere un tamaño de búfer mayor o igual al tamaño total del conjunto de datos. Por ejemplo, si tu conjunto de datos contiene 10.000 elementos pero `buffer_size` está establecido en 1000, entonces `shuffle` seleccionará inicialmente un elemento aleatorio solo de los primeros 1000 elementos del búfer. Una vez que se selecciona un elemento, su espacio en el búfer es reemplazado por el siguiente (es decir, el elemento 1001), manteniendo así el búfer de 1000 elementos. Si el conjunto de datos está compuesto por varios fragmentos, rellena el búfer utilizando hasta `max_buffer_input_shards` fragmentos a la vez y también baraja el orden de los fragmentos. Esto mejora considerablemente la calidad de la barajación. Los fragmentos de entrada se intercalan dentro de cada nodo y trabajador, preservando el número de fragmentos disponibles para la carga de datos en paralelo. Sin embargo, si el orden se ha fijado mediante [skip()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset.skip) o [take()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset.take), el orden de los fragmentos se mantiene sin cambios y solo se utiliza un fragmento a la vez para llenar el búfer. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> list(ds.take(3)) [{'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'label': 1}, {'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .', 'label': 1}, {'text': 'effective but too-tepid biopic', 'label': 1}] >>> shuffled_ds = ds.shuffle(seed=42) >>> list(shuffled_ds.take(3)) [{'text': "a sports movie with action that's exciting on the field and a story you care about off it .", 'label': 1}, {'text': 'at its best , the good girl is a refreshingly adult take on adultery . . .', 'label': 1}, {'text': "sam jones became a very lucky filmmaker the day wilco got dropped from their record label , proving that one man's ruin may be another's fortune .", 'label': 1}] >>> resharded_ds = ds.reshard() # useful to shard Parquet datasets by row group instead of by file, improving shuffling quality on dataset with one or few files. >>> shuffled_resharded_ds = resharded_ds.shuffle(seed=42) >>> list(shuffled_resharded_ds.take(3)) [{'text': 'this mistaken-identity picture is so film-culture referential that the final product is a ghost .', 'label': 0}, {'text': 'woody allen used to ridicule movies like hollywood ending . now he makes them .', 'label': 0}, {'text': "not only is undercover brother as funny , if not more so , than both austin powers films , but it's also one of the smarter , savvier spoofs to come along in some time .", 'label': 1}] ``` #### batch[[datasets.IterableDataset.batch]] ```python batch(batch_size: typing.Optional[int] = None, by_column: typing.Union[str, list[str], NoneType] = None, drop_last_batch: bool = False) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4657) **Parámetros:** batch_size (`int`, opcional) : El número de muestras en cada lote. by_column (`Union[str, list[str]`, opcional) : La columna utilizada para agrupar los ejemplos en lotes. Los ejemplos sucesivos con el mismo valor para esa columna se agrupan en el mismo lote. También puede ser una lista de columnas si desea agrupar por varias columnas. Si se agrupa por columna, batch_size solo se utiliza para controlar el tamaño de los lotes que se agrupan o se dividen durante la acumulación. drop_last_batch (`bool`, por defecto `False`) : Si se debe descartar el último lote incompleto. Agrupa las muestras del conjunto de datos en lotes. Ejemplo: Tamaño de lote fijo: ```py >>> ds = load_dataset("some_dataset", streaming=True, split="train") >>> batched_ds = ds.batch(batch_size=32) ``` Lotes de muestras sucesivas con un valor idéntico para "my_column": ```py >>> ds = load_dataset("some_dataset", streaming=True, split="train") >>> batched_ds = ds.batch(by_column="my_column") ``` #### omitir[[datasets.IterableDataset.skip]] ```python skip(n: int) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4058) **Parámetros:** n (`int`) : Número de elementos a omitir. Cree un nuevo [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset) que omita los primeros `n` elementos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> list(ds.take(3)) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}] >>> ds = ds.skip(1) >>> list(ds.take(3)) [{'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}, {'label': 1, 'text': 'if you sometimes like to go to the movies to have fun , wasabi is a good place to start .'}] ``` #### tomar[[datasets.IterableDataset.take]] ```python take(n: int) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4144) **Parámetros:** n (`int`) : Número de elementos a tomar. Cree un nuevo [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset) con solo los primeros `n` elementos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True) >>> small_ds = ds.take(2) >>> list(small_ds) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}] ``` #### shard[[datasets.IterableDataset.shard]] ```python shard(num_shards: int, index: int, contiguous: bool = True) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4179) **Parámetros:** num_shards (`int`) : Número de fragmentos en los que dividir el conjunto de datos. index (`int`) : Qué fragmento seleccionar y devolver. contiguous : (`bool`, por defecto `True`): Si se deben seleccionar bloques contiguos de índices para los fragmentos. Devuelve el fragmento `index`-ésimo del conjunto de datos dividido en `num_shards` piezas. Esto realiza la división en fragmentos de forma determinista. `dataset.shard(n, i)` divide el conjunto de datos en fragmentos contiguos, por lo que puede concatenarse fácilmente de nuevo después del procesamiento. Si `dataset.num_shards % n == l`, entonces los primeros `l` conjuntos de datos tienen cada uno `(dataset.num_shards // n) + 1` fragmentos, y los conjuntos de datos restantes tienen `(dataset.num_shards // n)` fragmentos. `datasets.concatenate_datasets([dset.shard(n, i) for i in range(n)])` devuelve un conjunto de datos con el mismo orden que el original. En particular, `dataset.shard(dataset.num_shards, i)` devuelve un conjunto de datos con 1 fragmento. Nota: n debe ser menor o igual al número de fragmentos en el conjunto de datos `dataset.num_shards`. Por otro lado, `dataset.shard(n, i, contiguous=False)` contiene todos los fragmentos del conjunto de datos cuyo índice mod `n = i`. Asegúrese de aplicar el particionado antes de usar cualquier operador de aleatorización (como `shuffle`). Lo ideal es que el operador de particionado se utilice al principio de la tubería de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("fancyzhx/amazon_polarity", split="train", streaming=True) >>> ds IterableDataset({ features: ['label', 'title', 'content'], num_shards: 4 }) >>> ds.shard(num_shards=2, index=0) IterableDataset({ features: ['label', 'title', 'content'], num_shards: 2 }) ``` #### reshard[[datasets.IterableDataset.reshard]] ```python reshard() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4235) Repartir el conjunto de datos si es posible, es decir, dividir las particiones actuales en más particiones. Esto aumenta el número de particiones y el conjunto de datos resultante tiene num_shards >= previous_num_shards. La igualdad puede ocurrir si ninguna partición puede dividirse más. El mecanismo de re-particionado depende del formato de archivo del conjunto de datos: * Parquet: dividir en fragmentos por grupo de filas en lugar de por archivo * Vortex: fragmento por rango de fragmentos consecutivos (aproximadamente 64 MB de datos de archivo cada uno) en lugar de por archivo * Otros: aún no implementado (¡se aceptan contribuciones!) Asegúrese de redividir/dividir antes de usar cualquier operador aleatorio (como `shuffle`). Lo ideal es que el operador de división se use al principio de la tubería de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("fancyzhx/amazon_polarity", split="train", streaming=True) >>> ds IterableDataset({ features: ['label', 'title', 'content'], num_shards: 4 }) >>> ds.reshard() IterableDataset({ features: ['label', 'title', 'content'], num_shards: 3600 }) ``` #### repetir[[datasets.IterableDataset.repeat]] ```python repeat(num_times: typing.Optional[int]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4100) **Parámetros:** num_times (`int`) o (`None`) : Número de veces para repetir el conjunto de datos. Si es `None`, el conjunto de datos se repetirá indefinidamente. Cree un nuevo [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset) que repite el subyacente `num_times` veces. Una entrada vacía termina incluso cuando `num_times` es `None`. N.B. El efecto de llamar a shuffle después de repeat depende significativamente del tamaño del buffer. Con buffer_size 1, los datos duplicados nunca se ven en la misma iteración, incluso después de barajar: ds.repeat(n).shuffle(seed=42, buffer_size=1) es equivalente a ds.shuffle(seed=42, buffer_size=1).repeat(n), y solo baraja el orden de los fragmentos dentro de cada iteración. Con un tamaño de buffer >= (número de muestras en el conjunto de datos * num_times), obtenemos un barajado completo de los datos repetidos, es decir, podemos observar duplicados en la misma iteración. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> ds = ds.take(2).repeat(2) >>> list(ds) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}, {'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}] ``` #### to_csv[[datasets.IterableDataset.to_csv]] ```python to_csv(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **to_csv_kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4856) **Parámetros:** path_or_buf (`PathLike` o `FileOrBuffer`) : Ya sea una ruta a un archivo (p. ej. `file.csv`), un URI remoto (p. ej. `hf://datasets/username/my_dataset_name/data.csv`) o un BinaryIO, donde se guardará el conjunto de datos en el formato especificado. batch_size (`int`, *opcional*) : Tamaño del lote para cargar en memoria y escribir de una vez. El valor predeterminado es `datasets.config.DEFAULT_MAX_BATCH_SIZE`. storage_options (`dict`, *opcional*) : Pares clave/valor que se pasarán al backend del sistema de archivos, si lo hay. - ****to_csv_kwargs** (argumentos de palabra clave adicionales): Parámetros para pasar a [`pandas.DataFrame.to_csv`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_csv.html) de pandas. El parámetro `index` tiene un valor predeterminado de `False` si no se especifica. Si desea escribir el índice, pase `index=True` y también establezca un nombre para la columna de índice pasando `index_label`. **Devuelve:** `int` El número de caracteres o bytes escritos. Exporta el conjunto de datos a csv. Esto itera sobre el conjunto de datos y lo carga por completo en memoria antes de escribirlo. Ejemplo: ```py >>> ds.to_csv("path/to/dataset/directory") ``` #### to_pandas[[datasets.IterableDataset.to_pandas]] ```python to_pandas(batch_size: typing.Optional[int] = None, batched: bool = False) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4777) **Parámetros:** batch_size (`int`, *opcional*) : El tamaño (número de filas) de los lotes si `batched` es `True`. El valor predeterminado es `datasets.config.DEFAULT_MAX_BATCH_SIZE`. batched (`bool`) : Establezca en `True` para devolver un generador que produce el conjunto de datos en lotes de `batch_size` filas. El valor predeterminado es `False` (devuelve todo el conjunto de datos una sola vez). **Devuelve:** `pandas.DataFrame` o `Iterator[pandas.DataFrame]` Devuelve el conjunto de datos como un `pandas.DataFrame`. También puede devolver un generador para conjuntos de datos grandes. Ejemplo: ```py >>> ds.to_pandas() ``` #### to_dict[[datasets.IterableDataset.to_dict]] ```python to_dict(batch_size: typing.Optional[int] = None, batched: bool = False) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4737) **Parámetros:** batch_size (`int`, *opcional*) : El tamaño (número de filas) de los lotes si `batched` es `True`. El valor predeterminado es `datasets.config.DEFAULT_MAX_BATCH_SIZE`. **Devuelve:** `dict` o `Iterator[dict]` Devuelve el conjunto de datos como un diccionario de Python. También puede devolver un generador para conjuntos de datos grandes. Ejemplo: ```py >>> ds.to_dict() ``` #### to_json[[datasets.IterableDataset.to_json]] ```python to_json(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **to_json_kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4899) **Parámetros:** path_or_buf (`PathLike` o `FileOrBuffer`) : Ya sea una ruta a un archivo (p. ej. `file.json`), un URI remoto (p. ej. `hf://datasets/username/my_dataset_name/data.json`) o un BinaryIO, donde se guardará el conjunto de datos en el formato especificado. batch_size (`int`, *opcional*) : Tamaño del lote para cargar en memoria y escribir de una vez. El valor predeterminado es `datasets.config.DEFAULT_MAX_BATCH_SIZE`. storage_options (`dict`, *opcional*) : Pares clave/valor que se pasarán al backend del sistema de archivos, si lo hay. - ****to_json_kwargs** (additional keyword arguments) : Parameters to pass to pandas's [`pandas.DataFrame.to_json`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_json.html). Default arguments are `lines=True` and `orient="records". The parameter `index` defaults to `False` if `orient` is `"split"` or `"table"`. If you would like to write the index, pass `index=True`. **Devuelve:** `int` El número de caracteres o bytes escritos. Exporta el conjunto de datos a JSON Lines o JSON. Esto itera sobre el conjunto de datos y lo carga por completo en memoria antes de escribirlo. El formato de salida predeterminado es [JSON Lines](https://jsonlines.org/). Para exportar a [JSON](https://www.json.org), pase el argumento `lines=False` y el `orient` deseado. Ejemplo: ```py >>> ds.to_json("path/to/dataset/directory/filename.jsonl") ``` ```py >>> num_shards = dataset.num_shards >>> for index in range(num_shards): ... shard = dataset.shard(index, num_shards) ... shard.to_json(f"path/of/my/dataset/data-{index:05d}.jsonl") ``` #### to_parquet[[datasets.IterableDataset.to_parquet]] ```python to_parquet(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **parquet_writer_kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4995) **Parámetros:** path_or_buf (`PathLike` o `FileOrBuffer`) : Ya sea una ruta a un archivo (p. ej. `file.parquet`), un URI remoto (p. ej. `hf://datasets/username/my_dataset_name/data.parquet`) o un BinaryIO, donde se guardará el conjunto de datos en el formato especificado. batch_size (`int`, *opcional*) : Tamaño del lote para cargar en memoria y escribir de una vez. El valor predeterminado es `datasets.config.DEFAULT_MAX_BATCH_SIZE`. storage_options (`dict`, *opcional*) : Pares clave/valor que se pasarán al backend del sistema de archivos, si lo hay. - ****parquet_writer_kwargs**** (argumentos de palabra clave adicionales) : Parámetros para pasar a `pyarrow.parquet.ParquetWriter` de PyArrow. **Devuelve:** `int` El número de caracteres o bytes escritos. Exporta el conjunto de datos a parquet Ejemplo: ```py >>> ds.to_parquet("path/to/dataset/directory") ``` ```py >>> num_shards = dataset.num_shards >>> for index in range(num_shards): ... shard = dataset.shard(index, num_shards) ... shard.to_parquet(f"path/of/my/dataset/data-{index:05d}.parquet") ``` #### to_sql[[datasets.IterableDataset.to_sql]] ```python to_sql(name: str, con: typing.Union[str, ForwardRef('sqlalchemy.engine.Connection'), ForwardRef('sqlalchemy.engine.Engine'), ForwardRef('sqlite3.Connection')], batch_size: typing.Optional[int] = None, **sql_writer_kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4953) **Parámetros:** name (`str`) : Nombre de la tabla SQL. con (`str` o `sqlite3.Connection` o `sqlalchemy.engine.Connection` o `sqlalchemy.engine.Connection`) : Una [cadena URI](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) o un objeto de conexión SQLite3/SQLAlchemy utilizado para escribir en una base de datos. batch_size (`int`, *opcional*) : Tamaño del lote para cargar en memoria y escribir de una vez. El valor predeterminado es `datasets.config.DEFAULT_MAX_BATCH_SIZE`. - ****sql_writer_kwargs** (argumentos de palabra clave adicionales) : Parámetros para pasar a [`pandas.DataFrame.to_sql`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_sql.html) de pandas. El parámetro `index` tiene un valor predeterminado de `False` si no se especifica. Si desea escribir el índice, pase `index=True` y también establezca un nombre para la columna de índice pasando `index_label`. **Devuelve:** `int` El número de registros escritos. Exporta el conjunto de datos a una base de datos SQL. Ejemplo: ```py >>> # con provided as a connection URI string >>> ds.to_sql("data", "sqlite:///my_own_db.sql") >>> # con provided as a sqlite3 connection object >>> import sqlite3 >>> con = sqlite3.connect("my_own_db.sql") >>> with con: ... ds.to_sql("data", con) ``` #### push_to_hub[[datasets.IterableDataset.push_to_hub]] ```python push_to_hub(repo_id: str, config_name: str = 'default', set_default: typing.Optional[bool] = None, split: typing.Optional[str] = None, data_dir: typing.Optional[str] = None, commit_message: typing.Optional[str] = None, commit_description: typing.Optional[str] = None, private: typing.Optional[bool] = None, token: typing.Optional[str] = None, revision: typing.Optional[str] = None, create_pr: typing.Optional[bool] = False, max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[int] = None, embed_external_files: bool = True, num_proc: typing.Optional[int] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L5330) **Parámetros:** repo_id (`str`) : El ID del repositorio al que se enviarán los datos, en el siguiente formato: `/` o `/`. También acepta ``, que por defecto usará el espacio de nombres del usuario conectado. También puede ser una ubicación dentro de un bucket, por ejemplo `buckets///...` config_name (`str`, por defecto "default") : El nombre de la configuración (o subconjunto) de un conjunto de datos. Por defecto, "default". set_default (`bool`, *opcional*) : Si se establece esta configuración como la predeterminada. De lo contrario, la configuración predeterminada es la denominada "default". split (`str`, *opcional*) : El nombre de la división que se asignará a ese conjunto de datos. El valor predeterminado es `self.split`. data_dir (`str`, *opcional*) : Nombre del directorio que contendrá los archivos de datos subidos. El valor predeterminado es `config_name` si es diferente de "default"; en caso contrario, es "data". commit_message (`str`, *opcional*) : Mensaje a confirmar al hacer push. El valor predeterminado será `"Upload dataset"`. commit_description (`str`, *opcional*) : Descripción del commit que se creará. Además, descripción de la PR si se crea una PR (`create_pr` es True). private (`bool`, *opcional*) : Si se debe hacer el repositorio privado. Si es `None` (predeterminado), el repositorio será público a menos que el valor predeterminado de la organización sea privado. Este valor se ignora si el repositorio ya existe. token (`str`, *opcional*) : Un token de autenticación opcional para Hugging Face Hub. Si no se pasa ningún token, se usará por defecto el token guardado localmente al iniciar sesión con `hf auth login`. Se generará un error si no se pasa ningún token y el usuario no ha iniciado sesión. revision (`str`, *opcional*) : Rama a la que se enviarán los archivos subidos. Por defecto, la rama `"main"`. create_pr (`bool`, *opcional*, por defecto `False`) : Si se debe crear una PR con los archivos subidos o realizar el commit directamente. max_shard_size (`int` o `str`, *opcional*) : Tamaño máximo opcional de los fragmentos del conjunto de datos que se subirán al hub. Si se expresa como una cadena, debe consistir en dígitos seguidos de una unidad (como `"5MB"`). Si no se proporciona, el número de fragmentos predeterminado es el `.num_shards` de este conjunto de datos. num_shards (`int`, *opcional*) : Número de fragmentos a escribir. Si se proporciona `max_shard_size` y no se proporciona `num_shards`, el número de fragmentos se estima a partir de `max_shard_size`. Puede ser mayor que `.num_shards` de este conjunto de datos: en ese caso, cada fragmento de entrada se distribuye en varios fragmentos de salida escribiendo sus ejemplos en ellos de forma intercalada. embed_external_files (`bool`, por defecto `True`) : Si se deben incrustar los bytes de los archivos en los fragmentos. En particular, esto hará lo siguiente antes de la publicación para los campos de tipo: - [Audio](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Audio) y [Image](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Image): eliminar la información de la ruta local e incrustar el contenido del archivo en los archivos Parquet. num_proc (`int`, *opcional*, valor predeterminado `None`) : Número de procesos al preparar y subir el conjunto de datos. Esto resulta útil si el conjunto de datos está compuesto por muchas muestras y transformaciones. Utiliza el contexto "spawn" para funcionar con hf_xet, el cliente de rust para subidas rápidas a HF. La multiprocesación está deshabilitada de forma predeterminada. **Devuelve:** huggingface_hub.CommitInfo Sube el conjunto de datos al hub como un conjunto de datos Parquet. El conjunto de datos se sube mediante solicitudes HTTP y no requiere tener instalados ni git ni git-lfs. Los archivos Parquet resultantes son autosuficientes por defecto. Si su conjunto de datos contiene datos de [Image](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Audio) o [Video](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Video), los archivos Parquet almacenarán los bytes de sus imágenes o archivos de audio. Puede desactivar esto estableciendo `embed_external_files` en `False`. Ejemplo: ```python >>> dataset.push_to_hub("/") >>> dataset_dict.push_to_hub("/", private=True) >>> dataset.push_to_hub("/", max_shard_size="1GB") >>> dataset.push_to_hub("/", num_shards=1024) ``` Si su conjunto de datos tiene varias divisiones (p. ej., entrenamiento/validación/prueba): ```python >>> train_dataset.push_to_hub("/", split="train") >>> val_dataset.push_to_hub("/", split="validation") >>> # later >>> dataset = load_dataset("/") >>> train_dataset = dataset["train"] >>> val_dataset = dataset["validation"] ``` Si desea agregar una nueva configuración (o subconjunto) a un conjunto de datos (por ejemplo, si el conjunto de datos tiene múltiples tareas/versiones/idiomas): ```python >>> english_dataset.push_to_hub("/", "en") >>> french_dataset.push_to_hub("/", "fr") >>> # later >>> english_dataset = load_dataset("/", "en") >>> french_dataset = load_dataset("/", "fr") ``` #### load_state_dict[[datasets.IterableDataset.load_state_dict]] ```python load_state_dict(state_dict: dict) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L2800) Cargue el state_dict del conjunto de datos. La iteración se reanudará en el siguiente ejemplo a partir del momento en que se guardó el estado. Reanudar continúa exactamente desde donde se guardó el punto de control, excepto en dos casos: 1. los ejemplos de los búferes de barajado se pierden al reanudar y los búferes se rellenan con nuevos datos 2. Las combinaciones de `.with_format(arrow)` y `.map()` por lotes pueden omitir un lote. Ejemplo: ```py >>> from datasets import Dataset, concatenate_datasets >>> ds = Dataset.from_dict({"a": range(6)}).to_iterable_dataset(num_shards=3) >>> for idx, example in enumerate(ds): ... print(example) ... if idx == 2: ... state_dict = ds.state_dict() ... print("checkpoint") ... break >>> ds.load_state_dict(state_dict) >>> print(f"restart from checkpoint") >>> for example in ds: ... print(example) ``` que devuelve: ``` {'a': 0} {'a': 1} {'a': 2} checkpoint restart from checkpoint {'a': 3} {'a': 4} {'a': 5} ``` ```py >>> from torchdata.stateful_dataloader import StatefulDataLoader >>> ds = load_dataset("deepmind/code_contests", streaming=True, split="train") >>> dataloader = StatefulDataLoader(ds, batch_size=32, num_workers=4) >>> # checkpoint >>> state_dict = dataloader.state_dict() # uses ds.state_dict() under the hood >>> # resume from checkpoint >>> dataloader.load_state_dict(state_dict) # uses ds.load_state_dict() under the hood ``` #### state_dict[[datasets.IterableDataset.state_dict]] ```python state_dict() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L2747) **Devuelve:** `dict` Obtiene el state_dict actual del dataset. Corresponde al estado en el último ejemplo que devolvió. Reanudar continúa exactamente desde donde se guardó el punto de control, excepto en dos casos: 1. los ejemplos de los búferes de barajado se pierden al reanudar y los búferes se rellenan con nuevos datos 2. Las combinaciones de `.with_format(arrow)` y `.map()` por lotes pueden omitir un lote. Ejemplo: ```py >>> from datasets import Dataset, concatenate_datasets >>> ds = Dataset.from_dict({"a": range(6)}).to_iterable_dataset(num_shards=3) >>> for idx, example in enumerate(ds): ... print(example) ... if idx == 2: ... state_dict = ds.state_dict() ... print("checkpoint") ... break >>> ds.load_state_dict(state_dict) >>> print(f"restart from checkpoint") >>> for example in ds: ... print(example) ``` que devuelve: ``` {'a': 0} {'a': 1} {'a': 2} checkpoint restart from checkpoint {'a': 3} {'a': 4} {'a': 5} ``` ```py >>> from torchdata.stateful_dataloader import StatefulDataLoader >>> ds = load_dataset("deepmind/code_contests", streaming=True, split="train") >>> dataloader = StatefulDataLoader(ds, batch_size=32, num_workers=4) >>> # checkpoint >>> state_dict = dataloader.state_dict() # uses ds.state_dict() under the hood >>> # resume from checkpoint >>> dataloader.load_state_dict(state_dict) # uses ds.load_state_dict() under the hood ``` #### info[[datasets.IterableDataset.info]] ```python info() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L172) Objeto [DatasetInfo](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.DatasetInfo) que contiene todos los metadatos del conjunto de datos. #### split[[datasets.IterableDataset.split]] ```python split() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L177) objeto [NamedSplit](/docs/datasets/v5.2.0/es/package_reference/builder_classes#datasets.NamedSplit) correspondiente a una división de datos con nombre. #### builder_name[[datasets.IterableDataset.builder_name]] ```python builder_name() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L182) #### citación[[datasets.IterableDataset.citation]] ```python citation() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L186) #### config_name[[datasets.IterableDataset.config_name]] ```python config_name() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L190) #### dataset_size[[datasets.IterableDataset.dataset_size]] ```python dataset_size() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L194) #### descripción[[datasets.IterableDataset.description]] ```python description() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L198) #### download_checksums[[datasets.IterableDataset.download_checksums]] ```python download_checksums() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L202) #### download_size[[datasets.IterableDataset.download_size]] ```python download_size() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L206) #### características[[datasets.IterableDataset.features]] ```python features() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L210) #### página de inicio[[datasets.IterableDataset.homepage]] ```python homepage() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L214) #### licencia[[datasets.IterableDataset.license]] ```python license() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L218) #### size_in_bytes[[datasets.IterableDataset.size_in_bytes]] ```python size_in_bytes() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L222) #### supervised_keys[[datasets.IterableDataset.supervised_keys]] ```python supervised_keys() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L226) #### versión[[datasets.IterableDataset.version]] ```python version() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L230) #### from_csv[[datasets.IterableDataset.from_csv]] ```python from_csv(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, keep_in_memory: bool = False, **kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3392) **Parámetros:** path_or_paths (`path-like` o lista de `path-like`) : Ruta(s) del archivo(s) CSV. split ([NamedSplit](/docs/datasets/v5.2.0/es/package_reference/builder_classes#datasets.NamedSplit), *opcional*) : Nombre de la división que se asignará al conjunto de datos. features ([Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features), *opcional*) : Características del conjunto de datos. keep_in_memory (`bool`, por defecto `False`) : Si se debe copiar los datos en memoria. - ****kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave que se pasarán a `pandas.read_csv`. **Devuelve:** [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset) Crea un IterableDataset a partir de archivo(s) CSV. Ejemplo: ```py >>> ds = IterableDataset.from_csv('path/to/dataset.csv') ``` #### from_json[[datasets.IterableDataset.from_json]] ```python from_json(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, keep_in_memory: bool = False, field: typing.Optional[str] = None, **kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3435) **Parámetros:** path_or_paths (`path-like` o lista de `path-like`) : Ruta(s) del archivo o archivos JSON o JSON Lines. split ([NamedSplit](/docs/datasets/v5.2.0/es/package_reference/builder_classes#datasets.NamedSplit), *opcional*) : Nombre de la división que se asignará al conjunto de datos. features ([Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features), *opcional*) : Características del conjunto de datos. keep_in_memory (`bool`, por defecto `False`) : Si se debe copiar los datos en memoria. field (`str`, *opcional*) : Nombre del campo del archivo JSON donde se contiene el conjunto de datos. - ****kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave que se pasarán a `JsonConfig`. **Devuelve:** [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset) Crea un IterableDataset a partir de uno o varios archivos JSON o JSON Lines. Ejemplo: ```py >>> ds = IterableDataset.from_json('path/to/dataset.json') ``` #### from_parquet[[datasets.IterableDataset.from_parquet]] ```python from_parquet(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, keep_in_memory: bool = False, columns: typing.Optional[list[str]] = None, filters: typing.Union[pyarrow._compute.Expression, list[tuple], list[list[tuple]], NoneType] = None, fragment_scan_options: typing.Optional[pyarrow._dataset_parquet.ParquetFragmentScanOptions] = None, on_bad_files: typing.Literal['error', 'warn', 'skip'] = 'error', **kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3482) **Parámetros:** path_or_paths (`path-like` o lista de `path-like`) : Ruta(s) del archivo(s) Parquet. split (`NamedSplit`, *opcional*) : Nombre de la división que se asignará al conjunto de datos. features (`Features`, *opcional*) : Características del conjunto de datos. keep_in_memory (`bool`, por defecto `False`) : Si se debe copiar los datos en memoria. columns (`List[str]`, *opcional*) : Si no es `None`, solo se leerán estas columnas del archivo. El nombre de una columna puede ser un prefijo de un campo anidado, p. ej. 'a' seleccionará 'a.b', 'a.c' y 'a.d.e'. filters (`Union[pyarrow.dataset.Expression, list[tuple], list[list[tuple]]]`, *opcional*) : Devuelve solo las filas que coinciden con el filtro. Si es posible, el predicado se empujará hacia abajo para aprovechar la información de partición o los metadatos internos encontrados en la fuente de datos, p. ej., las estadísticas de Parquet. De lo contrario, filtra los RecordBatches cargados antes de devolverlos. fragment_scan_options (`pyarrow.dataset.ParquetFragmentScanOptions`, *opcional*) : Opciones específicas de escaneo para fragmentos Parquet. Esto resulta especialmente útil para configurar el almacenamiento en búfer y la caché. on_bad_files (`Literal["error", "warn", "skip"]`, *opcional*, valor predeterminado "error") : Especifica qué hacer al encontrar un archivo defectuoso (un archivo que no se puede leer). Los valores permitidos son: * 'error', lanza una Exception cuando se encuentra un archivo defectuoso. * 'warn', lanza una advertencia cuando se encuentra un archivo defectuoso y omite ese archivo. * 'skip', omite los archivos defectuosos sin lanzar excepciones ni advertencias cuando se encuentran. - ****kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave que se pasarán a `ParquetConfig`. **Devuelve:** [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset) Crea un IterableDataset a partir de archivo(s) Parquet. Ejemplo: ```py >>> ds = IterableDataset.from_parquet('path/to/dataset.parquet') ``` Cargar un subconjunto de columnas: ```python >>> ds = IterableDataset.from_parquet('path/to/dataset.parquet', columns=["col_0", "col_1"]) ``` Filtre los datos de manera eficiente, posiblemente omitiendo archivos completos o grupos de filas: ```python >>> filters = [("col_0", "==", 0)] >>> ds = IterableDataset.from_parquet(parquet_files_list, filters=filters) ``` #### from_text[[datasets.IterableDataset.from_text]] ```python from_text(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, keep_in_memory: bool = False, keep_linebreaks: bool = False, sample_by: typing.Literal['line', 'paragraph', 'document'] = 'line', **kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3567) **Parámetros:** path_or_paths (`path-like` o lista de `path-like`) : Ruta(s) del archivo(s) de texto. split (`NamedSplit`, *opcional*) : Nombre de la división que se asignará al conjunto de datos. features (`Features`, *opcional*) : Características del conjunto de datos. keep_in_memory (`bool`, por defecto `False`) : Si se debe copiar los datos en memoria. keep_linebreaks : (`bool`, por defecto False): Si se conservan los saltos de línea. sample_by (`Literal["line", "paragraph", "document"]`, por defecto "line") : Si se cargan los datos por línea, párrafo o documento. Por defecto, una fila en el conjunto de datos = una línea. - ****kwargs** (argumentos de palabra clave adicionales) : Argumentos de palabra clave que se pasarán a `TextConfig`. **Devuelve:** [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset) Crea un IterableDataset a partir de archivo(s) de texto. Ejemplo: ```py >>> ds = IterableDataset.from_text('path/to/dataset.txt') ``` #### datasets.IterableColumn[[datasets.IterableColumn]] ```python datasets.IterableColumn(source: typing.Union[ForwardRef('IterableDataset'), ForwardRef('IterableColumn')], column_name: str) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L2657) Un iterable para una columna específica de un [IterableDataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset). Ejemplo: Iterar sobre los textos de la columna "text" de un conjunto de datos: ```python for text in dataset["text"]: ... ``` También funciona con columnas anidadas: ```python for source in dataset["metadata"]["source"]: ... ``` ## IterableDatasetDict[[datasets.IterableDatasetDict]] Diccionario con los nombres de las divisiones como claves (por ejemplo, 'train', 'test') y objetos `IterableDataset` como valores. #### datasets.IterableDatasetDict[[datasets.IterableDatasetDict]] [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1810) #### map[[datasets.IterableDatasetDict.map]] ```python map(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_split: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: int = 1000, drop_last_batch: bool = False, remove_columns: typing.Union[str, list[str], NoneType] = None, fn_kwargs: typing.Optional[dict] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1911) **Parámetros:** function (`Callable`, *opcional*, valor predeterminado `None`) : Función aplicada al vuelo en los ejemplos al iterar sobre el conjunto de datos. Debe tener una de las siguientes firmas: - `function(example: Dict[str, Any]) -> Dict[str, Any]` si `batched=False` y `with_indices=False` - `function(example: Dict[str, Any], idx: int) -> Dict[str, Any]` si `batched=False` y `with_indices=True` - `function(batch: Dict[str, list]) -> Dict[str, list]` si `batched=True` y `with_indices=False` - `function(batch: Dict[str, list], indices: list[int]) -> Dict[str, list]` si `batched=True` y `with_indices=True` Para un uso avanzado, la función también puede devolver una `pyarrow.Table`. Si la función es asíncrona, `map` ejecutará su función en paralelo. Además, si su función no devuelve nada (`None`), `map` ejecutará su función y devolverá el conjunto de datos sin cambios. Si no se proporciona ninguna función, se usa la función identidad por defecto: `lambda x: x`. with_indices (`bool`, por defecto `False`) : Proporciona índices de ejemplos a `function`. Ten en cuenta que, en este caso, la firma de `function` debe ser `def function(example, idx[, rank]): ...`. input_columns (`[Union[str, list[str]]]`, *opcional*, valor predeterminado `None`) : Las columnas que se pasarán a `function` como argumentos posicionales. Si es `None`, se pasa un diccionario con todas las columnas formateadas como un solo argumento. batched (`bool`, por defecto `False`) : Proporcionar un lote de ejemplos a `function`. batch_size (`int`, *opcional*, valor predeterminado `1000`) : Número de ejemplos por lote proporcionados a `function` si `batched=True`. drop_last_batch (`bool`, por defecto `False`) : Si un último lote más pequeño que `batch_size` debe descartarse en lugar de ser procesado por la función. remove_columns (`[list[str]]`, *opcional*, valor predeterminado `None`) : Elimina una selección de columnas durante el mapeo. Las columnas se eliminarán antes de actualizar los ejemplos con la salida de `function`, es decir, si `function` está añadiendo columnas con nombres en `remove_columns`, estas columnas se conservarán. fn_kwargs (`Dict`, *opcional*, valor predeterminado `None`) : Argumentos de palabra clave que se pasarán a `function` Aplica una función a todos los ejemplos del dataset iterable (individualmente o en lotes) y los actualiza. Si la función devuelve una columna que ya existe, la sobrescribe. La función se aplica al vuelo a los ejemplos al iterar sobre el dataset. La transformación se aplica a todos los datasets del diccionario de datasets. Puede especificar si la función debe agruparse o no con el parámetro `batched`: - Si `False`, la función toma 1 ejemplo como entrada y debe devolver 1 ejemplo. Un ejemplo es un diccionario, p. ej. `{"text": "Hello there !"}`. - Si `True` y `batch_size` es 1, la función toma un lote de 1 ejemplo como entrada y puede devolver un lote con 1 o más ejemplos. Un lote es un diccionario, por ejemplo, un lote de 1 ejemplo es `{"text": ["Hello there !"]}`. - Si `True` y `batch_size` es `n` > 1, la función toma como entrada un lote de `n` ejemplos y puede devolver un lote con `n` ejemplos, o con un número arbitrario de ejemplos. Tenga en cuenta que el último lote puede tener menos de `n` ejemplos. Un lote es un diccionario, por ejemplo, un lote de `n` ejemplos es `{"text": ["Hello there !"] * n}`. Si la función es asíncrona, `map` ejecutará tu función en paralelo, con hasta mil llamadas simultáneas. Se recomienda usar un `asyncio.Semaphore` en tu función si deseas establecer un número máximo de operaciones que pueden ejecutarse al mismo tiempo. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> def add_prefix(example): ... example["text"] = "Review: " + example["text"] ... return example >>> ds = ds.map(add_prefix) >>> next(iter(ds["train"])) {'label': 1, 'text': 'Review: the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### filtro[[datasets.IterableDatasetDict.filter]] ```python filter(function: typing.Optional[typing.Callable] = None, with_indices = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, fn_kwargs: typing.Optional[dict] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2011) **Parámetros:** function (`Callable`) : Llamable con una de las siguientes firmas: - `function(example: Dict[str, Any]) -> bool` si `with_indices=False, batched=False` - `function(example: Dict[str, Any], indices: int) -> bool` si `with_indices=True, batched=False` - `function(example: Dict[str, list]) -> list[bool]` si `with_indices=False, batched=True` - `function(example: Dict[str, list], indices: list[int]) -> list[bool]` si `with_indices=True, batched=True` Si no se proporciona ninguna función, el valor predeterminado es una función que siempre devuelve True: `lambda x: True`. with_indices (`bool`, por defecto `False`) : Proporciona índices de ejemplos a `function`. Ten en cuenta que, en este caso, la firma de `function` debe ser `def function(example, idx): ...`. input_columns (`str` o `list[str]`, *opcional*) : Las columnas que se pasarán a `function` como argumentos posicionales. Si es `None`, se pasa un diccionario con todas las columnas formateadas como un solo argumento. batched (`bool`, por defecto `False`) : Proporcionar un lote de ejemplos a `function` batch_size (`int`, *opcional*, valor predeterminado `1000`) : Número de ejemplos por lote proporcionados a `function` si `batched=True`. fn_kwargs (`Dict`, *opcional*, valor predeterminado `None`) : Argumentos de palabra clave que se pasarán a `function` Aplica una función de filtro a todos los elementos para que el conjunto de datos solo incluya ejemplos según la función de filtro. El filtrado se realiza sobre la marcha al iterar sobre el conjunto de datos. El filtrado se aplica a todos los conjuntos de datos del diccionario de conjuntos de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds = ds.filter(lambda x: x["label"] == 0) >>> list(ds["train"].take(3)) [{'label': 0, 'text': 'Review: simplistic , silly and tedious .'}, {'label': 0, 'text': "Review: it's so laddish and juvenile , only teenage boys could possibly find it funny ."}, {'label': 0, 'text': 'Review: exploitative and largely devoid of the depth or sophistication that would make watching such a graphic treatment of the crimes bearable .'}] ``` #### shuffle[[datasets.IterableDatasetDict.shuffle]] ```python shuffle(seed = None, generator: typing.Optional[numpy.random._generator.Generator] = None, buffer_size: int = 1000, max_buffer_input_shards: int = 10) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2074) **Parámetros:** seed (`int`, *opcional*, valor predeterminado `None`) : Semilla aleatoria que se utilizará para barajar el conjunto de datos. Se usa para muestrear del búfer de barajado y también para barajar los fragmentos de datos. generator (`numpy.random.Generator`, *opcional*) : Generador aleatorio de Numpy para calcular la permutación de las filas del conjunto de datos. Si `generator=None` (predeterminado), se utiliza `np.random.default_rng` (el BitGenerator predeterminado (PCG64) de NumPy). buffer_size (`int`, por defecto `1000`) : Tamaño del búfer. max_buffer_input_shards (`int`, por defecto `10`) : Número máximo de fragmentos para alimentar el búfer a la vez. Baraja aleatoriamente los elementos de este conjunto de datos. La barajada se aplica a todos los conjuntos de datos del diccionario de conjuntos de datos. Este conjunto de datos llena un búfer con buffer_size elementos y luego muestrea aleatoriamente elementos de este búfer, reemplazando los elementos seleccionados con nuevos elementos. Para un barajado perfecto, se requiere un tamaño de búfer mayor o igual al tamaño total del conjunto de datos. Por ejemplo, si tu conjunto de datos contiene 10.000 elementos pero `buffer_size` está establecido en 1000, entonces `shuffle` seleccionará inicialmente un elemento aleatorio solo de los primeros 1000 elementos del búfer. Una vez que se selecciona un elemento, su espacio en el búfer es reemplazado por el siguiente (es decir, el elemento 1001), manteniendo así el búfer de 1000 elementos. Si el conjunto de datos está compuesto por varios fragmentos, también realiza `shuffle` del orden de los fragmentos. Sin embargo, si el orden se ha fijado mediante [skip()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset.skip) o [take()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDataset.take), el orden de los fragmentos se mantiene sin cambios. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> list(ds["train"].take(3)) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}] >>> ds = ds.shuffle(seed=42) >>> list(ds["train"].take(3)) [{'label': 1, 'text': "a sports movie with action that's exciting on the field and a story you care about off it ."}, {'label': 1, 'text': 'at its best , the good girl is a refreshingly adult take on adultery . . .'}, {'label': 1, 'text': "sam jones became a very lucky filmmaker the day wilco got dropped from their record label , proving that one man's ruin may be another's fortune ."}] ``` #### with_format[[datasets.IterableDatasetDict.with_format]] ```python with_format(type: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1865) **Parámetros:** type (`str`, *opcional*) : Tipo de salida seleccionado en `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` significa que devuelve objetos de python (predeterminado). Devuelve un conjunto de datos con el formato especificado. Ejemplo: ```py >>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation", streaming=True) >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True) >>> ds = ds.with_format("torch") >>> next(iter(ds)) {'text': 'compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .', 'label': tensor(1), 'input_ids': tensor([ 101, 18027, 16310, 16001, 1103, 9321, 178, 11604, 7235, 6617, 1742, 2165, 2820, 1206, 6588, 22572, 12937, 1811, 2153, 1105, 1147, 12890, 19587, 6463, 1105, 15026, 1482, 119, 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])} ``` #### cast[[datasets.IterableDatasetDict.cast]] ```python cast(features: Features) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2290) **Parámetros:** features (`Features`) : Nuevas características a las que se debe convertir el conjunto de datos. El nombre de los campos en las características debe coincidir con los nombres actuales de las columnas. El tipo de los datos también debe ser convertible de un tipo a otro. Para conversiones no triviales, p. ej. `string` <-> `ClassLabel`, se debe usar `map` para actualizar el Dataset. **Devuelve:** [IterableDatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDatasetDict) Una copia del conjunto de datos con las características convertidas. Castea el conjunto de datos a un nuevo conjunto de características. El casteo de tipos se aplica a todos los conjuntos de datos del diccionario de conjuntos de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds["train"].features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> new_features = ds["train"].features.copy() >>> new_features['label'] = ClassLabel(names=['bad', 'good']) >>> new_features['text'] = Value('large_string') >>> ds = ds.cast(new_features) >>> ds["train"].features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('large_string')} ``` #### cast_column[[datasets.IterableDatasetDict.cast_column]] ```python cast_column(column: str, feature: typing.Union[dict, list, tuple, datasets.features.features.Value, datasets.features.features.ClassLabel, datasets.features.translation.Translation, datasets.features.translation.TranslationVariableLanguages, datasets.features.features.LargeList, datasets.features.features.List, datasets.features.features.Array2D, datasets.features.features.Array3D, datasets.features.features.Array4D, datasets.features.features.Array5D, datasets.features.audio.Audio, datasets.features.image.Image, datasets.features.mesh.Mesh, datasets.features.video.Video, datasets.features.pdf.Pdf, datasets.features.nifti.Nifti, datasets.features.bio_sequence.BioSequence, datasets.features.bio_structure.BioStructure]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2259) **Parámetros:** column (`str`) : Nombre de la columna. feature (`Feature`) : Característica objetivo. **Devuelve:** [IterableDatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDatasetDict) Castea la columna a característica para la decodificación. El casteo de tipo se aplica a todos los conjuntos de datos del diccionario de conjuntos de datos. Ejemplo: ```py >>> from datasets import load_dataset, ClassLabel >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds["train"].features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} >>> ds = ds.cast_column('label', ClassLabel(names=['bad', 'good'])) >>> ds["train"].features {'label': ClassLabel(names=['bad', 'good']), 'text': Value('string')} ``` #### remove_columns[[datasets.IterableDatasetDict.remove_columns]] ```python remove_columns(column_names: typing.Union[str, list[str]]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2207) **Parámetros:** column_names (`Union[str, list[str]]`) : Nombre de la(s) columna(s) a eliminar. **Devuelve:** [IterableDatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDatasetDict) Una copia del objeto de datos sin las columnas a eliminar. Elimina una o varias columnas del conjunto de datos y las características asociadas a ellas. La eliminación se realiza sobre la marcha en los ejemplos al iterar sobre el conjunto de datos. La eliminación se aplica a todos los conjuntos de datos del diccionario de conjuntos de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds = ds.remove_columns("label") >>> next(iter(ds["train"])) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### rename_column[[datasets.IterableDatasetDict.rename_column]] ```python rename_column(original_column_name: str, new_column_name: str) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2143) **Parámetros:** original_column_name (`str`) : Nombre de la columna a renombrar. new_column_name (`str`) : Nuevo nombre para la columna. **Devuelve:** [IterableDatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDatasetDict) Una copia del conjunto de datos con una columna renombrada. Renombra una columna en el conjunto de datos y mueve las características asociadas a la columna original bajo el nuevo nombre de columna. El renombrado se aplica a todos los conjuntos de datos del diccionario de conjuntos de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds = ds.rename_column("text", "movie_review") >>> next(iter(ds["train"])) {'label': 1, 'movie_review': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### rename_columns[[datasets.IterableDatasetDict.rename_columns]] ```python rename_columns(column_mapping: dict) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2179) **Parámetros:** column_mapping (`Dict[str, str]`) : Un mapeo de columnas a renombrar a sus nuevos nombres. **Devuelve:** [IterableDatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDatasetDict) Una copia del conjunto de datos con columnas renombradas Renombra varias columnas en el conjunto de datos y mueve las características asociadas a las columnas originales bajo los nuevos nombres de columna. El renombrado se aplica a todos los conjuntos de datos del diccionario de conjuntos de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds = ds.rename_columns({"text": "movie_review", "label": "rating"}) >>> next(iter(ds["train"])) {'movie_review': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'rating': 1} ``` #### select_columns[[datasets.IterableDatasetDict.select_columns]] ```python select_columns(column_names: typing.Union[str, list[str]]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2233) **Parámetros:** column_names (`Union[str, list[str]]`) : Nombre de la(s) columna(s) a conservar. **Devuelve:** [IterableDatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDatasetDict) Una copia del objeto de conjunto de datos con solo las columnas seleccionadas. Seleccione una o varias columnas del conjunto de datos y las características asociadas a ellas. La selección se realiza sobre la marcha en los ejemplos al iterar sobre el conjunto de datos. La selección se aplica a todos los conjuntos de datos del diccionario de conjuntos de datos. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True) >>> ds = ds.select("text") >>> next(iter(ds["train"])) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} ``` #### push_to_hub[[datasets.IterableDatasetDict.push_to_hub]] ```python push_to_hub(repo_id: str, config_name: str = 'default', set_default: typing.Optional[bool] = None, data_dir: typing.Optional[str] = None, commit_message: typing.Optional[str] = None, commit_description: typing.Optional[str] = None, private: typing.Optional[bool] = None, token: typing.Optional[str] = None, revision: typing.Optional[str] = None, create_pr: typing.Optional[bool] = False, max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[dict[str, int]] = None, embed_external_files: bool = True, num_proc: typing.Optional[int] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2327) **Parámetros:** repo_id (`str`) : El ID del repositorio al que se enviarán los datos, en el siguiente formato: `/` o `/`. También acepta ``, que por defecto usará el espacio de nombres del usuario conectado. También puede ser una ubicación dentro de un bucket, por ejemplo `buckets///...` config_name (`str`) : Nombre de configuración de un conjunto de datos. El valor predeterminado es "default". set_default (`bool`, *opcional*) : Si se establece esta configuración como la predeterminada. De lo contrario, la configuración predeterminada es la denominada "default". data_dir (`str`, *opcional*) : Nombre del directorio que contendrá los archivos de datos subidos. El valor predeterminado es `config_name` si es diferente de "default"; en caso contrario, es "data". commit_message (`str`, *opcional*) : Mensaje a confirmar al hacer push. El valor predeterminado será `"Upload dataset"`. commit_description (`str`, *opcional*) : Descripción del commit que se creará. Además, descripción de la PR si se crea una PR (`create_pr` es True). private (`bool`, *opcional*) : Si se debe hacer el repositorio privado. Si es `None` (predeterminado), el repositorio será público a menos que el valor predeterminado de la organización sea privado. Este valor se ignora si el repositorio ya existe. token (`str`, *opcional*) : Un token de autenticación opcional para Hugging Face Hub. Si no se pasa ningún token, se usará por defecto el token guardado localmente al iniciar sesión con `hf auth login`. Se generará un error si no se pasa ningún token y el usuario no ha iniciado sesión. revision (`str`, *opcional*) : Rama a la que se enviarán los archivos subidos. Por defecto, la rama `"main"`. create_pr (`bool`, *opcional*, por defecto `False`) : Si se debe crear una PR con los archivos subidos o realizar el commit directamente. max_shard_size (`int` o `str`, *opcional*) : Tamaño máximo opcional de los fragmentos del conjunto de datos que se subirán al hub. Si se expresa como una cadena, debe consistir en dígitos seguidos de una unidad (como `"500MB"` o `"1GB"`). Si no se proporciona, cada división mantiene su número de fragmentos nativo del conjunto de datos. num_shards (`Dict[str, int]`, *opcional*) : Número de fragmentos a escribir. Use un diccionario para definir un `num_shards` diferente para cada división. Si se proporciona `max_shard_size` y no se proporciona `num_shards` para una división, el número de fragmentos para esa división se estima a partir de `max_shard_size`. embed_external_files (`bool`, por defecto `True`) : Si se deben incrustar los bytes de los archivos en los fragmentos. En particular, esto hará lo siguiente antes de la publicación para los campos de tipo: - [Audio](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Audio) y [Image](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Image) elimina la información de la ruta local e incrusta el contenido del archivo en los archivos Parquet. num_proc (`int`, *opcional*, valor predeterminado `None`) : Número de procesos al preparar y subir el conjunto de datos. Esto es útil si el conjunto de datos está compuesto por muchas muestras o archivos multimedia para incrustar. Usa el contexto "spawn" para funcionar con hf_xet, el cliente de rust para subidas rápidas a HF. La multiprocesación está deshabilitada de forma predeterminada. **Devuelve:** huggingface_hub.CommitInfo Envía el [IterableDatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDatasetDict) al hub como un dataset Parquet. El [IterableDatasetDict](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.IterableDatasetDict) se envía mediante solicitudes HTTP y no requiere tener instalados ni git ni git-lfs. Cada división del conjunto de datos se subirá de forma independiente. El conjunto de datos subido mantendrá los nombres originales de las divisiones. Los archivos Parquet resultantes son autosuficientes por defecto: si su conjunto de datos contiene datos de [Image](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Image) o [Audio](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Audio), los archivos Parquet almacenarán los bytes de sus imágenes o archivos de audio. Puede desactivar esto estableciendo `embed_external_files` en False. Ejemplo: ```python >>> dataset_dict.push_to_hub("/") >>> dataset_dict.push_to_hub("/", private=True) >>> dataset_dict.push_to_hub("/", max_shard_size="1GB") >>> dataset_dict.push_to_hub("/", num_shards={"train": 1024, "test": 8}) ``` Si desea agregar una nueva configuración (o subconjunto) a un conjunto de datos (por ejemplo, si el conjunto de datos tiene múltiples tareas/versiones/idiomas): ```python >>> english_dataset.push_to_hub("/", "en") >>> french_dataset.push_to_hub("/", "fr") >>> # later >>> english_dataset = load_dataset("/", "en") >>> french_dataset = load_dataset("/", "fr") ``` ## Características[[datasets.Features]] #### datasets.Features[[datasets.Features]] ```python datasets.Features(*args, **kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1931) Un diccionario especial que define la estructura interna de un conjunto de datos. Instanciado con un diccionario de tipo `dict[str, FieldType]`, donde las claves son los nombres de columna deseados y los valores son el tipo de esa columna. `FieldType` puede ser uno de los siguientes: - La característica [Value](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Value) especifica un valor de un solo tipo de datos, por ejemplo, `int64` o `string`. - La característica [ClassLabel](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.ClassLabel) especifica un conjunto predefinido de clases que pueden tener etiquetas asociadas y que se almacenarán como enteros en el conjunto de datos. - Un `dict` de Python especifica una característica compuesta que contiene un mapeo de subcampos a subcaracterísticas. Es posible tener campos anidados de campos anidados de manera arbitraria. - [List](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.List) o [LargeList](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.LargeList) especifica una característica compuesta que contiene una secuencia de subcaracterísticas, todas del mismo tipo de característica. - Característica [Array2D](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Array2D), [Array3D](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Array3D), [Array4D](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Array4D) o [Array5D](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Array5D) para matrices multidimensionales. - Característica [Audio](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Audio) para almacenar la ruta absoluta a un archivo de audio o un diccionario con la ruta relativa a un archivo de audio (clave "path") y su contenido en bytes (clave "bytes"). Esta característica carga el audio de forma diferida mediante un decodificador. - Característica [Image](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Image) para almacenar la ruta absoluta a un archivo de imagen, un objeto `np.ndarray`, un objeto `PIL.Image.Image` o un diccionario con la ruta relativa a un archivo de imagen (clave "path") y su contenido en bytes (clave "bytes"). Esta característica extrae los datos de la imagen. - Característica [Video](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Video) para almacenar la ruta absoluta a un archivo de video, un objeto `torchcodec.decoders.VideoDecoder` o un diccionario con la ruta relativa a un archivo de video (clave "path") y su contenido en bytes (clave "bytes"). Esta característica carga el video de forma diferida mediante un decodificador. - Característica [Pdf](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Pdf) para almacenar la ruta absoluta a un archivo PDF, un objeto `pdfplumber.pdf.PDF` o un diccionario con la ruta relativa a un archivo PDF (clave "path") y su contenido en bytes (clave "bytes"). Esta característica carga el PDF de forma diferida mediante un lector de PDF. - [Nifti](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Nifti) característica para almacenar la ruta absoluta a un archivo de neuroimagen NIfTI, un objeto `nibabel.Nifti1Image` o un diccionario con la ruta relativa a un archivo NIfTI (clave "path") y su contenido en bytes (clave "bytes"). Esta característica carga el archivo NIfTI de forma perezosa con nibabel. - Función [Translation](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Translation) o [TranslationVariableLanguages](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.TranslationVariableLanguages) específica de la traducción automática. - Característica [Json](/docs/datasets/v5.2.0/es/package_reference/loading_methods#datasets.Json) para almacenar datos no estructurados, por ejemplo, que contienen tipos mixtos o arbitrarios. Internamente #### copiar[[datasets.Features.copy]] ```python copy() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2364) **Devuelve:** [Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features) Realiza una copia profunda de [Features](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features). Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> copy_of_features = ds.features.copy() >>> copy_of_features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} ``` #### decode_batch[[datasets.Features.decode_batch]] ```python decode_batch(batch: dict, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2337) **Parámetros:** batch (`dict[str, list[Any]]`) : Datos del lote del dataset. token_per_repo_id (`dict`, *opcional*) : Para acceder y decodificar archivos de audio o imagen desde repositorios privados en el Hub, puede pasar un diccionario repo_id (str) -> token (bool o str) **Devuelve:** `dict[str, list[Any]]` Decodificar el lote con decodificación de características personalizada. #### decode_column[[datasets.Features.decode_column]] ```python decode_column(column: list, column_name: str, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2312) **Parámetros:** column (`list[Any]`) : datos de la columna del Dataset. column_name (`str`) : Nombre de la columna del dataset. **Devuelve:** `list[Any]` Decodificar columna con decodificación de características personalizada. #### decode_example[[datasets.Features.decode_example]] ```python decode_example(example: dict, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2289) **Parámetros:** example (`dict[str, Any]`) : Datos de la fila del dataset. token_per_repo_id (`dict`, *opcional*) : Para acceder y decodificar archivos de audio o imagen desde repositorios privados en el Hub, puede pasar un diccionario `repo_id (str) -> token (bool or str)`. **Devuelve:** `dict[str, Any]` Ejemplo de decodificación con decodificación de características personalizada. #### encode_batch[[datasets.Features.encode_batch]] ```python encode_batch(batch) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2270) **Parámetros:** batch (`dict[str, list[Any]]`) : Datos de un lote de Dataset. **Devuelve:** `dict[str, list[Any]]` Codificar el lote en un formato para Arrow. #### encode_column[[datasets.Features.encode_column]] ```python encode_column(column, column_name: str) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2254) **Parámetros:** column (`list[Any]`) : Datos en una columna de un Dataset. column_name (`str`) : Nombre de la columna del dataset. **Devuelve:** `list[Any]` Codifica la columna en un formato para Arrow. #### encode_example[[datasets.Features.encode_example]] ```python encode_example(example) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2240) **Parámetros:** example (`dict[str, Any]`) : Datos de una fila de un Dataset. **Devuelve:** `dict[str, Any]` Codifica el ejemplo en un formato para Arrow. #### flatten[[datasets.Features.flatten]] ```python flatten(max_depth = 16) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2437) **Devuelve:** [Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features) Las características aplanadas. Aplanar las características. Cada columna de diccionario se elimina y se reemplaza por todos los subcampos que contiene. Los nuevos campos se nombran concatenando el nombre de la columna original y el nombre del subcampo de la siguiente manera: `.`. Si una columna contiene diccionarios anidados, los nombres de todos los subcampos de niveles inferiores también se concatenan para formar nuevas columnas: `..`, etc. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rajpurkar/squad", split="train") >>> ds.features.flatten() {'answers.answer_start': List(Value('int32'), id=None), 'answers.text': List(Value('string'), id=None), 'context': Value('string'), 'id': Value('string'), 'question': Value('string'), 'title': Value('string')} ``` #### from_arrow_schema[[datasets.Features.from_arrow_schema]] ```python from_arrow_schema(pa_schema: Schema) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2023) **Parámetros:** pa_schema (`pyarrow.Schema`) : Esquema de Arrow. **Devuelve:** [Características](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features) Construye [Features](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Features) a partir de un esquema Arrow. También comprueba los metadatos del esquema para las características de Hugging Face Datasets. Los campos no anulables no son compatibles y se establecen como anulables. Además, pa.dictionary no está soportado y se utiliza su tipo subyacente en su lugar. Por lo tanto, los datasets convierten los objetos DictionaryArray a sus valores reales. #### from_dict[[datasets.Features.from_dict]] ```python from_dict(dic) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2057) **Parámetros:** dic (*dict[str, Any]*) : Diccionario de Python. **Devuelve:** `*Features*` Construir [*Features*] a partir de un diccionario. Regenera el objeto de característica anidado desde un diccionario deserializado. Usamos la clave *_type* para inferir el nombre del dataclass de la característica *FieldType*. Permite una sintaxis de constructor conveniente para definir características a partir de diccionarios JSON deserializados. Esta función se utiliza en particular al deserializar un [*DatasetInfo*] que se volcó en un objeto JSON. Actúa como un análogo de [*Features.from_arrow_schema*] y maneja la instanciación recursiva campo por campo, pero no requiere ningún mapeo a/desde pyarrow, excepto por el hecho de que aprovecha el mapeo de los tipos de datos primitivos de pyarrow que [*Value*] realiza automáticamente. Ejemplo: ```python >>> Features.from_dict(&lcub;'_type': &lcub;'dtype': 'string', 'id': None, '_type': 'Value'}}) &lcub;'_type': Value('string')} ``` #### reorder_fields_as[[datasets.Features.reorder_fields_as]] ```python reorder_fields_as(other: Features) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2384) **Parámetros:** other ([*Características*]) : Las otras [*Características*] con las que alinearse. **Devuelve:** [*Características*] Reordena los campos de Features para que coincidan con el orden de los campos de otros [*Features*]. El orden de los campos es importante, ya que afecta a los datos subyacentes de arrow. Reordenar los campos permite que el tipo de datos subyacentes de arrow coincida. Ejemplo: ```python >>> from datasets import Features, List, Value >>> # let's say we have two features with a different order of nested fields (for a and b for example) >>> f1 = Features(&lcub;"root": &lcub;"a": Value("string"), "b": Value("string")}}) >>> f2 = Features(&lcub;"root": &lcub;"b": Value("string"), "a": Value("string")}}) >>> assert f1.type != f2.type >>> # re-ordering keeps the base structure (here List is defined at the root level), but makes the fields order match >>> f1.reorder_fields_as(f2) &lcub;'root': List(&lcub;'b': Value('string'), 'a': Value('string')})} >>> assert f1.reorder_fields_as(f2).type == f2.type ``` ### Scalar[[datasets.Value]] #### datasets.Value[[datasets.Value]] ```python datasets.Value(dtype: str, id: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L511) **Parámetros:** dtype (`str`) : Nombre del tipo de datos. Valor de característica escalar de un tipo de datos particular. Los posibles dtypes de `Value` son los siguientes: - `null` - `bool` - `int8` - `int16` - `int32` - `int64` - `uint8` - `uint16` - `uint32` - `uint64` - `float16` - `float32` (alias float) - `float64` (alias double) - `time32[(s|ms)]` - `time64[(us|ns)]` - `timestamp[(s|ms|us|ns)]` - `timestamp[(s|ms|us|ns), tz=(tzstring)]` - `date32` - `date64` - `duration[(s|ms|us|ns)]` - `decimal128(precision, scale)` - `decimal256(precision, scale)` - `binary` - `large_binary` - `binary_view` - `string` - `large_string` - `string_view` Ejemplo: ```py >>> from datasets import Features >>> features = Features({'stars': Value('int32')}) >>> features {'stars': Value('int32')} ``` #### datasets.ClassLabel[[datasets.ClassLabel]] ```python datasets.ClassLabel(num_classes: dataclasses.InitVar[typing.Optional[int]] = None, names: list = None, names_file: dataclasses.InitVar[typing.Optional[str]] = None, id: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1052) **Parámetros:** num_classes (`int`, *opcional*) : Número de clases. Todas las etiquetas deben ser < `num_classes`. names (`list` de `str`, *opcional*) : Nombres de cadena para las clases enteras. Se mantiene el orden en el que se proporcionan los nombres. names_file (`str`, *opcional*) : Ruta a un archivo con los nombres de las clases enteras, uno por línea. Tipo de característica para etiquetas de clase enteras. Hay 3 formas de definir una `ClassLabel`, que corresponden a los 3 argumentos: * `num_classes`: Crea etiquetas de 0 a (num_classes-1). * `names`: Lista de cadenas de etiquetas. * `names_file`: Archivo que contiene la lista de etiquetas. Por debajo, las etiquetas se almacenan como enteros. Puede usar -1 para representar etiquetas desconocidas o faltantes. Ejemplo: ```py >>> from datasets import Features, ClassLabel >>> features = Features({'label': ClassLabel(num_classes=3, names=['bad', 'ok', 'good'])}) >>> features {'label': ClassLabel(names=['bad', 'ok', 'good'])} ``` #### cast_storage[[datasets.ClassLabel.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.IntegerArray]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1217) **Parámetros:** storage (`Union[pa.StringArray, pa.IntegerArray]`) : array de PyArrow para convertir. **Devuelve:** `pa.Int64Array` Array en el tipo de almacenamiento arrow de `ClassLabel`. Convierte un array de Arrow al tipo de almacenamiento arrow de `ClassLabel`. Los tipos de Arrow que se pueden convertir al tipo de almacenamiento pyarrow de `ClassLabel` son: - `pa.string()` - `pa.int()` #### int2str[[datasets.ClassLabel.int2str]] ```python int2str(values: typing.Union[int, collections.abc.Iterable]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1171) Conversión de `integer` => cadena de nombre de clase `string`. En cuanto a las etiquetas desconocidas o faltantes: pasar enteros negativos provoca `ValueError`. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> ds.features["label"].int2str(0) 'neg' ``` #### str2int[[datasets.ClassLabel.str2int]] ```python str2int(values: typing.Union[str, collections.abc.Iterable]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1126) Nombre de la clase de conversión `string` => `integer`. Ejemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> ds.features["label"].str2int('neg') 0 ``` ### Compuesto[[datasets.LargeList]] #### datasets.LargeList[[datasets.LargeList]] ```python datasets.LargeList(feature: typing.Any, id: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1414) **Parámetros:** feature (`FeatureType`) : Tipo de datos de la característica secundaria de cada elemento dentro de la lista grande. Tipo de característica para datos de listas grandes compuestos por el tipo de datos de características secundarias. Se basa en `pyarrow.LargeListType`, que es similar a `pyarrow.ListType` pero con desplazamientos de 64 bits en lugar de 32 bits. #### datasets.List[[datasets.List]] ```python datasets.List(feature: typing.Any, length: int = -1, id: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1386) **Parámetros:** feature (`FeatureType`) : Tipo de datos de la característica secundaria de cada elemento dentro de la lista grande. length (opcional `int`, por defecto -1) : Longitud de la lista si es fija. El valor por defecto es -1, lo que significa una longitud arbitraria. Tipo de característica para datos de listas grandes compuestos por el tipo de datos de características secundarias. Está respaldado por `pyarrow.ListType`, que utiliza desplazamientos de 32 bits o una longitud fija. #### datasets.Sequence[[datasets.Sequence]] ```python datasets.Sequence(feature = None, length = -1, **kwargs) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1352) **Parámetros:** feature (`FeatureType`) : Tipo de datos de la característica secundaria de cada elemento dentro de la lista grande. length (opcional `int`, por defecto -1) : Longitud de la lista si es fija. El valor por defecto es -1, lo que significa una longitud arbitraria. **Devuelve:** [Lista](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.List) de la característica especificada, excepto el `dict` de subcaracterísticas, que se convierte en un `dict` de listas de subcaracterísticas para garantizar la compatibilidad con TFDS. Una `Sequence` es una utilidad que convierte automáticamente las características de diccionario internas en un diccionario de listas. Este comportamiento se implementa para tener una capa de compatibilidad con la biblioteca TensorFlow Datasets, pero puede no ser deseado en algunos casos. Si no desea este comportamiento, puede usar una [List](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.List) o una [LargeList](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.LargeList) en lugar de la [Sequence](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Sequence). ### Traducción[[datasets.Translation]] #### datasets.Translation[[datasets.Translation]] ```python datasets.Translation(languages: list, id: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/translation.py#L12) **Parámetros:** languages (`dict`) : Un diccionario para cada ejemplo que mapea códigos de idioma en formato de cadena a traducciones en formato de cadena. `Feature` para traducciones con idiomas fijos por ejemplo. Aquí para compatibilidad con tfds. Ejemplo: ```python >>> # At construction time: >>> datasets.features.Translation(languages=['en', 'fr', 'de']) >>> # During data generation: >>> yield { ... 'en': 'the cat', ... 'fr': 'le chat', ... 'de': 'die katze' ... } ``` #### flatten[[datasets.Translation.flatten]] ```python flatten() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/translation.py#L44) Aplana la función Translation en un diccionario. #### datasets.TranslationVariableLanguages[[datasets.TranslationVariableLanguages]] ```python datasets.TranslationVariableLanguages(languages: typing.Optional[list] = None, num_languages: typing.Optional[int] = None, id: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/translation.py#L52) **Parámetros:** languages (`dict`) : Un diccionario para cada ejemplo que mapea códigos de idioma de cadena a una o más traducciones de cadena. Los idiomas presentes pueden variar de un ejemplo a otro. **Devuelve:** - `language` o `translation` (`tf.Tensor` unidimensional de longitud variable de `tf.string`) Códigos de idioma ordenados en orden ascendente o traducciones en texto plano, ordenados para alinearse con los códigos de idioma. `Feature` para traducciones con idiomas variables por ejemplo. Aquí para compatibilidad con tfds. Ejemplo: ```python >>> # At construction time: >>> datasets.features.TranslationVariableLanguages(languages=['en', 'fr', 'de']) >>> # During data generation: >>> yield { ... 'en': 'the cat', ... 'fr': ['le chat', 'la chatte,'] ... 'de': 'die katze' ... } >>> # Tensor returned : >>> { ... 'language': ['en', 'de', 'fr', 'fr'], ... 'translation': ['the cat', 'die katze', 'la chatte', 'le chat'], ... } ``` #### flatten[[datasets.TranslationVariableLanguages.flatten]] ```python flatten() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/translation.py#L122) Aplana la función TranslationVariableLanguages en un diccionario. ### Arrays[[datasets.Array2D]] #### datasets.Array2D[[datasets.Array2D]] ```python datasets.Array2D(shape: tuple, dtype: str, id: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L608) **Parámetros:** shape (`tuple`) : Tamaño de cada dimensión. dtype (`str`) : Nombre del tipo de datos. Crea un array bidimensional. Ejemplo: ```py >>> from datasets import Features >>> features = Features({'x': Array2D(shape=(1, 3), dtype='int32')}) ``` #### datasets.Array3D[[datasets.Array3D]] ```python datasets.Array3D(shape: tuple, dtype: str, id: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L633) **Parámetros:** shape (`tuple`) : Tamaño de cada dimensión. dtype (`str`) : Nombre del tipo de datos. Crea un array tridimensional. Ejemplo: ```py >>> from datasets import Features >>> features = Features({'x': Array3D(shape=(1, 2, 3), dtype='int32')}) ``` #### datasets.Array4D[[datasets.Array4D]] ```python datasets.Array4D(shape: tuple, dtype: str, id: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L658) **Parámetros:** shape (`tuple`) : Tamaño de cada dimensión. dtype (`str`) : Nombre del tipo de datos. Crea un array de cuatro dimensiones. Ejemplo: ```py >>> from datasets import Features >>> features = Features({'x': Array4D(shape=(1, 2, 2, 3), dtype='int32')}) ``` #### datasets.Array5D[[datasets.Array5D]] ```python datasets.Array5D(shape: tuple, dtype: str, id: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L683) **Parámetros:** shape (`tuple`) : Tamaño de cada dimensión. dtype (`str`) : Nombre del tipo de datos. Crea un array de cinco dimensiones. Ejemplo: ```py >>> from datasets import Features >>> features = Features({'x': Array5D(shape=(1, 2, 2, 3, 3), dtype='int32')}) ``` ### Audio[[datasets.Audio]] #### datasets.Audio[[datasets.Audio]] ```python datasets.Audio(sampling_rate: typing.Optional[int] = None, decode: bool = True, num_channels: typing.Optional[int] = None, stream_index: typing.Optional[int] = None, id: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L24) **Parámetros:** sampling_rate (`int`, *opcional*) : Tasa de muestreo objetivo. Si es `None`, se utiliza la tasa de muestreo nativa. num_channels (`int`, *opcional*) : El número de canales deseado de las muestras. De forma predeterminada, se utiliza el número de canales de la fuente. La decodificación de audio devolverá muestras con forma (num_channels, num_samples) Actualmente se admiten `None` (número de canales de la fuente, predeterminado), `1` (mono) o `2` (estéreo) canales. El argumento `num_channels` se pasa a `torchcodec.decoders.AudioDecoder`. decode (`bool`, por defecto `True`) : Si se debe decodificar los datos de audio. Si es `False`, devuelve el diccionario subyacente en el formato `{"path": audio_path, "bytes": audio_bytes}`. stream_index (`int`, *opcional*) : El índice de streaming a usar del archivo. Si es `None`, se usa por defecto el índice "óptimo". Audio `Feature` para extraer datos de audio de un archivo de audio. Entrada: La función Audio acepta como entrada: - Un `str`: Ruta absoluta al archivo de audio (es decir, se permite el acceso aleatorio). - Un `pathlib.Path`: ruta al archivo de audio (es decir, se permite el acceso aleatorio). - Un `dict` con las claves: - `path`: String con la ruta relativa del archivo de audio al archivo de archivo. - `bytes`: Bytes content of the audio file. Esto es útil para archivos parquet o webdataset que incrustan archivos de audio. - Un `dict` con las claves: - `array`: Matriz que contiene la muestra de audio - `sampling_rate`: Entero que corresponde a la tasa de muestreo de la muestra de audio. - Un `torchcodec.decoders.AudioDecoder`: objeto decodificador de audio de torchcodec. Salida: Los datos de salida de las características de audio se devuelven como objetos `torchcodec.decoders.AudioDecoder`, con claves adicionales: - `array`: Matriz que contiene la muestra de audio - `sampling_rate`: Entero que corresponde a la tasa de muestreo de la muestra de audio. Ejemplo: ```py >>> from datasets import load_dataset, Audio >>> ds = load_dataset("PolyAI/minds14", name="en-US", split="train") >>> ds = ds.cast_column("audio", Audio(sampling_rate=44100, num_channels=2)) >>> ds[0]["audio"] >>> audio = ds[0]["audio"] >>> audio.get_samples_played_in_range(0, 10) AudioSamples: data (shape): torch.Size([2, 110592]) pts_seconds: 0.0 duration_seconds: 2.507755102040816 sample_rate: 44100 ``` #### cast_storage[[datasets.Audio.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L237) **Parámetros:** storage (`Union[pa.StringArray, pa.StructArray]`) : Matriz de PyArrow para convertir. **Devuelve:** `pa.StructArray` Array en el tipo de almacenamiento de flecha de Audio, es decir, `pa.struct({"bytes": pa.binary(), "path": pa.string()})` Convierte un array de Arrow al tipo de almacenamiento de flecha Audio. Los tipos de Arrow que se pueden convertir al tipo de almacenamiento pyarrow Audio son: - `pa.string()` - debe contener los datos "path" - `pa.binary()` - debe contener los bytes de audio - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - el orden no importa #### decode_example[[datasets.Audio.decode_example]] ```python decode_example(value: dict, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L164) **Parámetros:** value (`dict`) : Un diccionario con las claves: - `path`: Cadena con la ruta relativa del archivo de audio. - `bytes`: Bytes del archivo de audio. token_per_repo_id (`dict`, *opcional*) : Para acceder y decodificar archivos de audio de repositorios privados en el Hub, puede pasar un diccionario repo_id (`str`) -> token (`bool` o `str`) **Devuelve:** `torchcodec.decoders.AudioDecoder` Decodificar un archivo de audio de ejemplo en datos de audio. #### embed_storage[[datasets.Audio.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L283) **Parámetros:** storage (`pa.StructArray`) : Matriz de PyArrow para incrustar. token_per_repo_id (`dict`, opcional) : Diccionario repo_id -> token para obtener los bytes de los archivos. local_files (`bool`, por defecto `True`) : Si se debe incrustar los datos de archivos locales en el array remote_files (`bool`, por defecto `True`) : Si se debe incrustar los datos de archivos remotos en el array. Por ejemplo, archivos con rutas que comienzan con hf:// o https:// **Devuelve:** `pa.StructArray` Array en el tipo de almacenamiento de flecha de Audio, es decir, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Incrustar archivos de audio en el array de Arrow. #### encode_example[[datasets.Audio.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('AudioDecoder')]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L96) **Parámetros:** value (`str`, `bytes`,`bytearray`,`dict`, `AudioDecoder`) : Datos pasados como entrada a la función de audio. **Devuelve:** `dict` Codifica el ejemplo en un formato para Arrow. #### flatten[[datasets.Audio.flatten]] ```python flatten() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L226) Si se encuentra en el estado decodificable, se lanza un error; de lo contrario, se aplanan las características en un diccionario. ### Imagen[[datasets.Image]] #### datasets.Image[[datasets.Image]] ```python datasets.Image(mode: typing.Optional[str] = None, decode: bool = True, id: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L47) **Parámetros:** mode (`str`, *opcional*) : El modo al que se debe convertir la imagen. Si es `None`, se utiliza el modo nativo de la imagen. decode (`bool`, por defecto `True`) : Si se debe decodificar los datos de la imagen. Si es `False`, devuelve el diccionario subyacente en el formato `{"path": image_path, "bytes": image_bytes}`. Imagen `Feature` para leer datos de imagen desde un archivo de imagen. Entrada: La función Image acepta como entrada: - Un `str`: Ruta absoluta al archivo de imagen (es decir, se permite el acceso aleatorio). - Un `pathlib.Path`: ruta al archivo de imagen (es decir, se permite el acceso aleatorio). - Un `dict` con las claves: - `path`: String con la ruta relativa del archivo de imagen al archivo de archivo. - `bytes`: Bytes del archivo de imagen. Esto es útil para archivos parquet o webdataset que incrustan archivos de imagen. - Un `np.ndarray`: un array de NumPy que representa una imagen. - Un objeto de imagen PIL: `PIL.Image.Image`. Salida: Los datos de salida de las características de imagen se devuelven como objetos `PIL.Image.Image`. Ejemplos: ```py >>> from datasets import load_dataset, Image >>> ds = load_dataset("AI-Lab-Makerere/beans", split="train") >>> ds.features["image"] Image(decode=True, id=None) >>> ds[0]["image"] >>> ds = ds.cast_column('image', Image(decode=False)) {'bytes': None, 'path': '/root/.cache/huggingface/datasets/downloads/extracted/b0a21163f78769a2cf11f58dfc767fb458fc7cea5c05dccc0144a2c0f0bc1292/train/healthy/healthy_train.85.jpg'} ``` #### cast_storage[[datasets.Image.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L216) **Parámetros:** storage (`Union[pa.StringArray, pa.StructArray, pa.ListArray]`) : Matriz de PyArrow para convertir. **Devuelve:** `pa.StructArray` Array en el tipo de almacenamiento Image arrow, es decir, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Convierte un array de Arrow al tipo de almacenamiento de Arrow Image. Los tipos de Arrow que se pueden convertir al tipo de almacenamiento pyarrow Image son: - `pa.string()` - debe contener los datos "path" - `pa.large_string()` - debe contener los datos de "path" (se convertirá a string si es posible) - `pa.binary()` - debe contener los bytes de la imagen - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - el orden no importa - `pa.list(*)` - debe contener los datos del array de imágenes #### decode_example[[datasets.Image.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L139) **Parámetros:** value (`str` o `dict`) : Una cadena con la ruta absoluta del archivo de imagen, o un diccionario con las claves: - `path`: Cadena con la ruta absoluta o relativa del archivo de imagen. - `bytes`: Los bytes del archivo de imagen. token_per_repo_id (`dict`, *opcional*) : Para acceder y decodificar archivos de imagen de repositorios privados en el Hub, puede pasar un diccionario repo_id (`str`) -> token (`bool` o `str`). **Devuelve:** `PIL.Image.Image` Decodificar el archivo de imagen de ejemplo en datos de imagen. #### embed_storage[[datasets.Image.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L278) **Parámetros:** storage (`pa.StructArray`) : Matriz de PyArrow para incrustar. token_per_repo_id (`dict`, opcional) : Diccionario repo_id -> token para obtener los bytes de los archivos. local_files (`bool`, por defecto `True`) : Si se debe incrustar los datos de archivos locales en el array remote_files (`bool`, por defecto `True`) : Si se debe incrustar los datos de archivos remotos en el array. Por ejemplo, archivos con rutas que comienzan con hf:// o https:// **Devuelve:** `pa.StructArray` Array en el tipo de almacenamiento Image arrow, es decir, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Incrustar archivos de imagen en el array de Arrow. #### encode_example[[datasets.Image.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, numpy.ndarray, ForwardRef('PIL.Image.Image')]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L98) **Parámetros:** value (`str`, `np.ndarray`, `PIL.Image.Image` o `dict`) : Datos pasados como entrada a la función de imagen. **Devuelve:** `dict` con los campos "path" y "bytes" Codifica el ejemplo en un formato para Arrow. #### flatten[[datasets.Image.flatten]] ```python flatten() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L203) Si está en el estado decodificable, devuelve la característica en sí; de lo contrario, aplana la característica en un diccionario. ### Video[[datasets.Video]] #### datasets.Video[[datasets.Video]] ```python datasets.Video(decode: bool = True, stream_index: typing.Optional[int] = None, dimension_order: typing.Literal['NCHW', 'NHWC'] = 'NCHW', num_ffmpeg_threads: int = 1, device: typing.Union[str, ForwardRef('torch.device'), NoneType] = 'cpu', seek_mode: typing.Literal['exact', 'approximate'] = 'exact', id: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L29) **Parámetros:** decode (`bool`, por defecto `True`) : Si se debe decodificar los datos del vídeo. Si es `False`, devuelve el diccionario subyacente en el formato `{"path": video_path, "bytes": video_bytes}`. stream_index (`int`, *opcional*) : El índice de streaming a usar del archivo. Si es `None`, se usa por defecto el índice "óptimo". dimension_order (`str`, por defecto `NCHW`) : El orden de las dimensiones de los fotogramas decodificados, donde N es el tamaño del lote, C es el número de canales, H es la altura y W es el ancho de los fotogramas. num_ffmpeg_threads (`int`, por defecto `1`) : El número de hilos a utilizar para decodificar el video. (Se recomienda mantenerlo en 1) device (`str` o `torch.device`, por defecto `cpu`) : El dispositivo a utilizar para decodificar el video. seek_mode (`str`, por defecto `exact`) : Determina si el acceso a los fotogramas será “exact” o “approximate”. Exact garantiza que solicitar el fotograma i devolverá siempre el fotograma i, pero para ello se requiere un escaneo inicial del archivo. Approximate es más rápido, ya que evita el escaneo del archivo, pero es menos preciso, ya que utiliza los metadatos del archivo para calcular dónde probablemente se encuentra i. Lea más [aquí](https://docs.pytorch.org/torchcodec/stable/generated_examples/approximate_mode.html#sphx-glr-generated-examples-approximate-mode-py) Video `Feature` para leer datos de video desde un archivo de video. Entrada: La función de video acepta como entrada: - Un `str`: Ruta absoluta al archivo de video (es decir, se permite el acceso aleatorio). - Un `pathlib.Path`: ruta al archivo de video (es decir, se permite el acceso aleatorio). - Un `dict` con las claves: - `path`: String con la ruta relativa del archivo de video en un repositorio de datos. - `bytes`: Bytes del archivo de video. Esto es útil para archivos parquet o webdataset que incrustan archivos de video. - Un `torchcodec.decoders.VideoDecoder`: objeto decodificador de video de torchcodec. Salida: La función Video features devuelve los datos como objetos `torchcodec.decoders.VideoDecoder`. Ejemplos: ```py >>> from datasets import Dataset, Video >>> ds = Dataset.from_dict({"video":["path/to/Screen Recording.mov"]}).cast_column("video", Video()) >>> ds.features["video"] Video(decode=True, id=None) >>> ds[0]["video"] >>> video = ds[0]["video"] >>> video.get_frames_in_range(0, 10) FrameBatch: data (shape): torch.Size([10, 3, 50, 66]) pts_seconds: tensor([0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333], dtype=torch.float64) duration_seconds: tensor([0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167], dtype=torch.float64) >>> ds.cast_column('video', Video(decode=False))[0]["video] {'bytes': None, 'path': 'path/to/Screen Recording.mov'} ``` #### cast_storage[[datasets.Video.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L242) **Parámetros:** storage (`Union[pa.StringArray, pa.StructArray, pa.ListArray]`) : Matriz de PyArrow para convertir. **Devuelve:** `pa.StructArray` Array en el tipo de almacenamiento de Video arrow, es decir, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Convierte un array de Arrow al tipo de almacenamiento de Arrow para Video. Los tipos de Arrow que se pueden convertir al tipo de almacenamiento de pyarrow para Video son: - `pa.string()` - debe contener los datos "path" - `pa.binary()` - debe contener los bytes del video - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - el orden no importa - `pa.list(*)` - debe contener los datos del array de video #### decode_example[[datasets.Video.decode_example]] ```python decode_example(value: typing.Union[str, datasets.features.video.Example], token_per_repo_id: typing.Optional[dict[str, typing.Union[bool, str]]] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L153) **Parámetros:** value (`str` o `dict`) : Una cadena con la ruta absoluta del archivo de video, un diccionario con las claves: - `path`: Cadena con la ruta absoluta o relativa del archivo de video. - `bytes`: Los bytes del archivo de video. token_per_repo_id (`dict`, *opcional*) : Para acceder y decodificar archivos de vídeo de repositorios privados en el Hub, puede pasar un diccionario repo_id (`str`) -> token (`bool` o `str`). **Devuelve:** `torchcodec.decoders.VideoDecoder` Decodificar un archivo de video de ejemplo en datos de video. #### embed_storage[[datasets.Video.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L294) **Parámetros:** storage (`pa.StructArray`) : Matriz de PyArrow para incrustar. token_per_repo_id (`dict`, opcional) : Diccionario repo_id -> token para obtener los bytes de los archivos. local_files (`bool`, por defecto `True`) : Si se debe incrustar los datos de archivos locales en el array remote_files (`bool`, por defecto `True`) : Si se debe incrustar los datos de archivos remotos en el array. Por ejemplo, archivos con rutas que comienzan con hf:// o https:// **Devuelve:** `pa.StructArray` Array en el tipo de almacenamiento de Video arrow, es decir, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Incrustar archivos de imagen en el array de Arrow. #### encode_example[[datasets.Video.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, datasets.features.video.Example, numpy.ndarray, ForwardRef('VideoDecoder')]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L105) **Parámetros:** value (`str`, `np.ndarray`, `bytes`, `bytearray`, `VideoDecoder` o `dict`) : Datos pasados como entrada a la función Video. **Devuelve:** `dict` con los campos "path" y "bytes" Codifica el ejemplo en un formato para Arrow. #### flatten[[datasets.Video.flatten]] ```python flatten() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L229) Si está en el estado decodificable, devuelve la característica en sí; de lo contrario, aplana la característica en un diccionario. ### Mesh[[datasets.Mesh]] #### datasets.Mesh[[datasets.Mesh]] ```python datasets.Mesh(decode: bool = True, id: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L23) **Parámetros:** decode (`bool`, por defecto `True`) : Si se debe decodificar los datos de la malla. Si es `False`, devuelve el diccionario subyacente en el formato `{"path": mesh_path, "bytes": mesh_bytes}`. La decodificación de mallas utiliza `trimesh` y admite archivos `.glb`, `.gltf`, `.ply` y `.stl`. Mesh `Feature` para leer datos de malla 3D desde un archivo. Entrada: La función Mesh acepta como entrada: - Un `str`: Ruta absoluta al archivo de malla (es decir, se permite el acceso aleatorio). - Un `pathlib.Path`: ruta al archivo de malla (es decir, se permite el acceso aleatorio). - Un `dict` con las claves: - `path`: String con la ruta relativa del archivo de malla respecto al archivo de archivo. - `bytes`: Bytes del archivo de malla. Esto es útil para archivos parquet o webdataset que incrustan archivos de malla. - Un `trimesh.Trimesh` o `trimesh.Scene`: objeto de malla o escena 3D. Salida: La función Mesh genera datos como objetos `trimesh.Trimesh` o `trimesh.Scene`. #### cast_storage[[datasets.Mesh.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L162) **Parámetros:** storage (`Union[pa.StringArray, pa.StructArray]`) : Matriz de PyArrow para convertir. **Devuelve:** `pa.StructArray` Array en el tipo de almacenamiento Mesh arrow, es decir, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Convierte un array de Arrow al tipo de almacenamiento de arrow de Mesh. Los tipos de Arrow que se pueden convertir al tipo de almacenamiento pyarrow de Mesh son: - `pa.string()` - debe contener los datos "path" - `pa.large_string()` - debe contener los datos de "path" (se convertirá a string si es posible) - `pa.binary()` - debe contener los bytes de la malla - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - el orden no importa #### decode_example[[datasets.Mesh.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L91) **Parámetros:** value (`dict`) : Un diccionario con las claves: - `path`: Cadena con la ruta absoluta o relativa del archivo de malla. - `bytes`: Los bytes del archivo de malla. token_per_repo_id (`dict`, *opcional*) : Para acceder y decodificar archivos de malla desde repositorios privados en el Hub, puede pasar un diccionario repo_id (`str`) -> token (`bool` o `str`). **Devuelve:** `trimesh.Trimesh` o `trimesh.Scene` Decodificar un archivo de malla de ejemplo. #### embed_storage[[datasets.Mesh.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L215) **Parámetros:** storage (`pa.StructArray`) : Matriz de PyArrow para incrustar. token_per_repo_id (`dict`, opcional) : Diccionario repo_id -> token para obtener los bytes de los archivos. local_files (`bool`, por defecto `True`) : Si se debe incrustar los datos de archivos locales en el array. remote_files (`bool`, por defecto `True`) : Si se debe incrustar los datos de archivos remotos en el array. **Devuelve:** `pa.StructArray` Array en el tipo de almacenamiento Mesh arrow, es decir, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Incrustar archivos mesh en el array de Arrow. #### encode_example[[datasets.Mesh.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('trimesh.Trimesh'), ForwardRef('trimesh.Scene')]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L57) **Parámetros:** value (`str`, `bytes`, `dict`, `trimesh.Trimesh` o `trimesh.Scene`) : Datos pasados como entrada a la función Mesh. **Devuelve:** `dict` con los campos "path" y "bytes" Codifica el ejemplo en un formato para Arrow. #### flatten[[datasets.Mesh.flatten]] ```python flatten() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L149) Si está en el estado decodificable, devuelve la característica en sí; de lo contrario, aplana la característica en un diccionario. ### Json[[datasets.Json]] #### datasets.Json[[datasets.Json]] ```python datasets.Json(decode: bool = True, id: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1258) Tipo de característica para objetos JSON. Por debajo, los objetos se almacenan como cadenas codificadas en JSON. Ejemplo: ```py >>> from datasets import Features, Json >>> features = Features({'json': Json()}) >>> features {'json': Json()} ``` ```py >>> from datasets import Dataset, Features, Json, List >>> features = Features({"a": List(Json())}) >>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}, features=features) >>> # OR >>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}, on_mixed_types="use_json") >>> ds.features {'a': List(Json())} >>> ds[0] {'a': [{'b': 0}, {'c': 0}]} >>> def f(x): ... for y in x["a"]: ... y["d"] = "foo" ... return x >>> ds = ds.map(f) >>> ds.features >>> ds[0] {'a': [{'b': 0, 'd': 'foo'}, {'c': 0, 'd': 'foo'}]} ``` #### cast_storage[[datasets.Json.cast_storage]] ```python cast_storage(storage: Array) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1321) **Parámetros:** storage (`Union[pa.StringArray, pa.IntegerArray]`) : array de PyArrow para convertir. **Devuelve:** `pa.JsonArray` Array en el tipo de almacenamiento arrow `Json`. Convierte un array de Arrow al tipo de almacenamiento de Arrow `Json`. ### Pdf[[datasets.Pdf]] #### datasets.Pdf[[datasets.Pdf]] ```python datasets.Pdf(decode: bool = True, id: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L31) **Parámetros:** decode (`bool`, por defecto `True`) : Si se debe decodificar los datos del pdf. Si es `False`, devuelve el diccionario subyacente en el formato `{"path": pdf_path, "bytes": pdf_bytes}`. **Experimental.** La función `Feature` de Pdf para leer documentos PDF desde un archivo PDF. Entrada: La función Pdf acepta como entrada: - Un `str`: Ruta absoluta al archivo pdf (es decir, se permite el acceso aleatorio). - Un `pathlib.Path`: ruta al archivo pdf (es decir, se permite el acceso aleatorio). - Un `dict` con las claves: - `path`: String con la ruta relativa del archivo pdf en un repositorio de datos. - `bytes`: Bytes del archivo pdf. Esto es útil para archivos archivados con acceso secuencial. - Un `pdfplumber.pdf.PDF`: objeto pdf de pdfplumber. Ejemplos: ```py >>> from datasets import Dataset, Pdf >>> ds = Dataset.from_dict({"pdf": ["path/to/pdf/file.pdf"]}).cast_column("pdf", Pdf()) >>> ds.features["pdf"] Pdf(decode=True, id=None) >>> ds[0]["pdf"] >>> ds = ds.cast_column("pdf", Pdf(decode=False)) >>> ds[0]["pdf"] {'bytes': None, 'path': 'path/to/pdf/file.pdf'} ``` #### cast_storage[[datasets.Pdf.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L183) **Parámetros:** storage (`Union[pa.StringArray, pa.StructArray, pa.ListArray]`) : Matriz de PyArrow para convertir. **Devuelve:** `pa.StructArray` Array en el tipo de almacenamiento de flecha de Pdf, es decir, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Convierte un array de Arrow al tipo de almacenamiento de arrow Pdf. Los tipos de Arrow que se pueden convertir al tipo de almacenamiento pyarrow Pdf son: - `pa.string()` - debe contener los datos "path" - `pa.binary()` - debe contener los bytes de la imagen - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - el orden no importa - `pa.list(*)` - debe contener los datos del array pdf #### decode_example[[datasets.Pdf.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L113) **Parámetros:** value (`str` o `dict`) : Una cadena con la ruta absoluta del archivo pdf, un diccionario con las claves: - `path`: Cadena con la ruta absoluta o relativa del archivo pdf. - `bytes`: Los bytes del archivo pdf. token_per_repo_id (`dict`, *opcional*) : Para acceder y decodificar archivos pdf de repositorios privados en el Hub, puede pasar un diccionario repo_id (`str`) -> token (`bool` o `str`). **Devuelve:** `pdfplumber.pdf.PDF` Decodifica un archivo pdf de ejemplo en datos pdf. #### embed_storage[[datasets.Pdf.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L220) **Parámetros:** storage (`pa.StructArray`) : Matriz de PyArrow para incrustar. token_per_repo_id (`dict`, opcional) : Diccionario repo_id -> token para obtener los bytes de los archivos. local_files (`bool`, por defecto `True`) : Si se debe incrustar los datos de archivos locales en el array remote_files (`bool`, por defecto `True`) : Si se debe incrustar los datos de archivos remotos en el array. Por ejemplo, archivos con rutas que comienzan con hf:// o https:// **Devuelve:** `pa.StructArray` Array en el tipo de almacenamiento PDF arrow, es decir, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Incrustar archivos PDF en el array de Arrow. #### encode_example[[datasets.Pdf.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('pdfplumber.pdf.PDF')]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L78) **Parámetros:** value (`str`, `bytes`, `pdfplumber.pdf.PDF` o `dict`) : Datos pasados como entrada a la función Pdf. **Devuelve:** `dict` con los campos "path" y "bytes" Codifica el ejemplo en un formato para Arrow. #### flatten[[datasets.Pdf.flatten]] ```python flatten() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L170) Si está en el estado decodificable, devuelve la característica en sí; de lo contrario, aplana la característica en un diccionario. ### Nifti[[datasets.Nifti]] #### datasets.Nifti[[datasets.Nifti]] ```python datasets.Nifti(decode: bool = True, id: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L64) **Parámetros:** decode (`bool`, por defecto `True`) : Si se debe decodificar los datos NIfTI. Si es `False`, se devuelve una cadena con los bytes. `decode=False` no se admite al decodificar ejemplos. **Experimental.** `Feature` de Nifti para leer archivos de neuroimagen NIfTI. Input: La función Nifti acepta como entrada: - Un `str`: Ruta absoluta al archivo NIfTI (es decir, se permite el acceso aleatorio). - Un `pathlib.Path`: ruta al archivo NIfTI (es decir, se permite el acceso aleatorio). - Un `dict` con las claves: - `path`: String con la ruta relativa del archivo NIfTI en un repositorio de datos. - `bytes`: Bytes del archivo NIfTI. Esto es útil para archivos archivados con acceso secuencial. - Un objeto de imagen de `nibabel` (p. ej., `nibabel.nifti1.Nifti1Image`). Ejemplos: ```py >>> from datasets import Dataset, Nifti >>> ds = Dataset.from_dict({"nifti": ["path/to/file.nii.gz"]}).cast_column("nifti", Nifti()) >>> ds.features["nifti"] Nifti(decode=True, id=None) >>> ds[0]["nifti"] >>> ds = ds.cast_column("nifti", Nifti(decode=False)) >>> ds[0]["nifti"] {'bytes': None, 'path': 'path/to/file.nii.gz'} ``` #### cast_storage[[datasets.Nifti.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.BinaryArray]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L298) **Parámetros:** storage (`Union[pa.StringArray, pa.StructArray, pa.BinaryArray]`) : Matriz de PyArrow para convertir. **Devuelve:** `pa.StructArray` Array en el tipo de almacenamiento Nifti arrow, es decir, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Convierte un array de Arrow al tipo de almacenamiento de arrow de Nifti. Los tipos de Arrow que se pueden convertir al tipo de almacenamiento de pyarrow de Nifti son: - `pa.string()` - debe contener los datos "path" - `pa.binary()` - debe contener los bytes NIfTI - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - el orden no importa #### decode_example[[datasets.Nifti.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L150) **Parámetros:** value (`str` o `dict`) : Una cadena con la ruta absoluta del archivo NIfTI, o un diccionario con las claves: - `path`: Cadena con la ruta absoluta o relativa del archivo NIfTI. - `bytes`: Los bytes del archivo NIfTI. token_per_repo_id (`dict`, *opcional*) : Para acceder y decodificar archivos NIfTI de repositorios privados en el Hub, puede pasar un diccionario repo_id (`str`) -> token (`bool` o `str`). **Devuelve:** objetos `nibabel.Nifti1Image` Decodificar el archivo NIfTI de ejemplo en un objeto de imagen de nibabel. #### embed_storage[[datasets.Nifti.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L216) **Parámetros:** storage (`pa.StructArray`) : Matriz de PyArrow para incrustar. token_per_repo_id (`dict`, opcional) : Diccionario repo_id -> token para obtener los bytes de los archivos. local_files (`bool`, por defecto `True`) : Si se debe incrustar los datos de archivos locales en el array remote_files (`bool`, por defecto `True`) : Si se debe incrustar los datos de archivos remotos en el array. Por ejemplo, archivos con rutas que comienzan con hf:// o https:// **Devuelve:** `pa.StructArray` Array en el tipo de almacenamiento arrow de NifTI, es decir, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Incrustar archivos NifTI en el array de Arrow. #### encode_example[[datasets.Nifti.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('nib.Nifti1Image')]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L110) **Parámetros:** value (`str`, `bytes`, `nibabel.Nifti1Image` o `dict`) : Datos pasados como entrada a la función Nifti. **Devuelve:** `dict` con los campos "path" y "bytes" Codifica el ejemplo en un formato para Arrow. #### flatten[[datasets.Nifti.flatten]] ```python flatten() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L285) Si está en el estado decodificable, devuelve la característica en sí; de lo contrario, aplana la característica en un diccionario. ### BioSequence[[datasets.BioSequence]] #### datasets.BioSequence[[datasets.BioSequence]] ```python datasets.BioSequence(format: str = 'fasta', decode: bool = True, id: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L44) **Parámetros:** format (`str`, por defecto `"fasta"`) : Nombre del formato de secuencia, tal como lo interpreta `Bio.SeqIO`. Los valores habituales son `"fasta"`, `"fastq"` y `"genbank"`. decode (`bool`, por defecto `True`) : Si se debe decodificar los datos de la secuencia. Si es `False`, devuelve el diccionario subyacente en el formato `{"path": path, "bytes": bytes}`. **Experimental.** `Feature` de BioSequence para leer registros de secuencias biológicas desde un archivo de secuencias. Un archivo de secuencias contiene uno o más registros de residuos con sus identificadores y anotaciones. FASTA, FASTQ y GenBank tienen la misma forma a este nivel, y solo difieren en el analizador utilizado, por lo que `format` selecciona el analizador en lugar del tipo. Input: La función BioSequence acepta como entrada: - Un `str`: Ruta absoluta al archivo de secuencia (es decir, se permite el acceso aleatorio). - Un `pathlib.Path`: ruta al archivo de secuencia (es decir, se permite el acceso aleatorio). - Un `dict` con las claves: - `path`: String con la ruta relativa del archivo de secuencia en un repositorio de datos. - `bytes`: Bytes del archivo de secuencia. Esto es útil para archivos archivados con acceso secuencial. - Un `Bio.SeqRecord.SeqRecord`: registro de secuencia de biopython. Ejemplos: ```py >>> from datasets import Dataset, BioSequence >>> ds = Dataset.from_dict({"seq": ["path/to/sequences.fasta"]}).cast_column("seq", BioSequence()) >>> ds.features["seq"] BioSequence(format='fasta', decode=True) >>> ds[0]["seq"] SeqRecord(seq=Seq('ACGT'), id='seq1', name='seq1', description='seq1', dbxrefs=[]) >>> ds = ds.cast_column("seq", BioSequence(decode=False)) >>> ds[0]["seq"] {'bytes': None, 'path': 'path/to/sequences.fasta'} ``` #### cast_storage[[datasets.BioSequence.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L199) **Parámetros:** storage (`Union[pa.StringArray, pa.StructArray]`) : Matriz de PyArrow para convertir. **Devuelve:** `pa.StructArray` Array en el tipo de almacenamiento arrow de BioSequence, es decir, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Convierte un array de Arrow al tipo de almacenamiento de arrow de BioSequence. Los tipos de Arrow que se pueden convertir al tipo de almacenamiento pyarrow de BioSequence son: - `pa.string()` - debe contener los datos "path" - `pa.binary()` - debe contener los bytes del archivo - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - el orden no importa #### decode_example[[datasets.BioSequence.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L132) **Parámetros:** value (`str` o `dict`) : Una cadena con la ruta absoluta del archivo, o un diccionario con las claves: - `path`: Cadena con la ruta absoluta o relativa del archivo. - `bytes`: Los bytes del archivo. token_per_repo_id (`dict`, *opcional*) : Para acceder y decodificar archivos de repositorios privados en el Hub, puede pasar un diccionario repo_id (`str`) -> token (`bool` o `str`). **Devuelve:** `Bio.SeqRecord.SeqRecord` Decodificar un archivo de secuencia de ejemplo en un registro de biopython. Un archivo puede contener muchos registros; esto devuelve el primero, porque una fila es un registro. Utilice los cargadores de secuencias empaquetados para expandir un archivo de varios registros en una fila por registro. #### embed_storage[[datasets.BioSequence.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L219) **Parámetros:** storage (`pa.StructArray`) : Matriz de PyArrow para incrustar. token_per_repo_id (`dict`, opcional) : Diccionario repo_id -> token para obtener los bytes de los archivos. local_files (`bool`, por defecto `True`) : Si se debe incrustar los datos de archivos locales en el array. remote_files (`bool`, por defecto `True`) : Si se debe incrustar los datos de archivos remotos en el array. **Devuelve:** `pa.StructArray` Array en el tipo de almacenamiento arrow de BioSequence. Incrustar los archivos de secuencias en el array de Arrow. #### encode_example[[datasets.BioSequence.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('SeqRecord')]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L99) **Parámetros:** value (`str`, `bytes`, `Bio.SeqRecord.SeqRecord` o `dict`) : Datos pasados como entrada a la función BioSequence. **Devuelve:** `dict` con los campos "path" y "bytes" Codifica el ejemplo en un formato para Arrow. #### flatten[[datasets.BioSequence.flatten]] ```python flatten() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L186) Si está en el estado decodificable, devuelve la característica en sí; de lo contrario, aplana la característica en un diccionario. ### BioStructure[[datasets.BioStructure]] #### datasets.BioStructure[[datasets.BioStructure]] ```python datasets.BioStructure(format: str = 'pdb', decode: bool = True, id: typing.Optional[str] = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L48) **Parámetros:** format (`str`, por defecto `"pdb"`) : Formato de estructura, ya sea `"pdb"` o `"mmcif"`. decode (`bool`, por defecto `True`) : Si se debe decodificar los datos de la estructura. Si es `False`, devuelve el diccionario subyacente en el formato `{"path": path, "bytes": bytes}`. **Experimental.** La función `Feature` de BioStructure para leer estructuras macromoleculares desde un archivo de estructura. Un archivo de estructura contiene las coordenadas tridimensionales de los átomos de una molécula, agrupados en cadenas y residuos. PDB y mmCIF describen los mismos objetos y solo difieren en el analizador utilizado, por lo que `format` selecciona el analizador y no el tipo. Input: La función BioStructure acepta como entrada: - A `str`: Ruta absoluta al archivo de estructura (es decir, se permite el acceso aleatorio). - Un `pathlib.Path`: ruta al archivo de estructura (es decir, se permite el acceso aleatorio). - Un `dict` con las claves: - `path`: String con la ruta relativa del archivo de estructura en un repositorio de datos. - `bytes`: Bytes del archivo de estructura. Esto es útil para archivos archivados con acceso secuencial. - Una `Bio.PDB.Structure.Structure`: estructura de biopython. Ejemplos: ```py >>> from datasets import Dataset, BioStructure >>> ds = Dataset.from_dict({"st": ["path/to/1abc.pdb"]}).cast_column("st", BioStructure()) >>> ds.features["st"] BioStructure(format='pdb', decode=True) >>> ds[0]["st"] >>> ds = ds.cast_column("st", BioStructure(decode=False)) >>> ds[0]["st"] {'bytes': None, 'path': 'path/to/1abc.pdb'} ``` #### cast_storage[[datasets.BioStructure.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L204) **Parámetros:** storage (`Union[pa.StringArray, pa.StructArray]`) : Matriz de PyArrow para convertir. **Devuelve:** `pa.StructArray` Array en el tipo de almacenamiento arrow de BioStructure, es decir, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Convierte un array de Arrow al tipo de almacenamiento arrow de BioStructure. Los tipos de Arrow que se pueden convertir al tipo de almacenamiento pyarrow de BioStructure son: - `pa.string()` - debe contener los datos "path" - `pa.binary()` - debe contener los bytes del archivo - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - el orden no importa #### decode_example[[datasets.BioStructure.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L138) **Parámetros:** value (`str` o `dict`) : Una cadena con la ruta absoluta del archivo, o un diccionario con las claves: - `path`: Cadena con la ruta absoluta o relativa del archivo. - `bytes`: Los bytes del archivo. token_per_repo_id (`dict`, *opcional*) : Para acceder y decodificar archivos de repositorios privados en el Hub, puede pasar un diccionario repo_id (`str`) -> token (`bool` o `str`). **Devuelve:** `Bio.PDB.Structure.Structure` Decodificar el archivo de estructura de ejemplo en una estructura de biopython. #### embed_storage[[datasets.BioStructure.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L224) **Parámetros:** storage (`pa.StructArray`) : Matriz de PyArrow para incrustar. token_per_repo_id (`dict`, opcional) : Diccionario repo_id -> token para obtener los bytes de los archivos. local_files (`bool`, por defecto `True`) : Si se debe incrustar los datos de archivos locales en el array. remote_files (`bool`, por defecto `True`) : Si se debe incrustar los datos de archivos remotos en el array. **Devuelve:** `pa.StructArray` Array en el tipo de almacenamiento arrow de BioStructure. Incorpora los archivos de estructura en el array de Arrow. #### encode_example[[datasets.BioStructure.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('Structure')]) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L105) **Parámetros:** value (`str`, `bytes`, `Bio.PDB.Structure.Structure` o `dict`) : Datos pasados como entrada a la función BioStructure. **Devuelve:** `dict` con los campos "path" y "bytes" Codifica el ejemplo en un formato para Arrow. #### flatten[[datasets.BioStructure.flatten]] ```python flatten() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L191) Si está en el estado decodificable, devuelve la característica en sí; de lo contrario, aplana la característica en un diccionario. ## Sistemas de archivos[[datasets.filesystems.is_remote_filesystem]] #### datasets.filesystems.is_remote_filesystem[[datasets.filesystems.is_remote_filesystem]] ```python datasets.filesystems.is_remote_filesystem(fs: AbstractFileSystem) ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/filesystems/__init__.py#L33) **Parámetros:** fs (`fsspec.spec.AbstractFileSystem`) : Una superclase abstracta para sistemas de archivos en Python, por ejemplo, `fsspec.filesystem('file')` o `s3fs.S3FileSystem`. Comprueba si `fs` es un sistema de archivos remoto. ## Huella digital[[datasets.fingerprint.Hasher]] #### datasets.fingerprint.Hasher[[datasets.fingerprint.Hasher]] ```python datasets.fingerprint.Hasher() ``` [Fuente](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/fingerprint.py#L196) Hasher que acepta objetos de Python como entradas.