Datasets documentation
Clases principales
Clases principales
DatasetInfo
clase datasets.DatasetInfo
< source >( description: str = <factory>citation: str = <factory>homepage: str = <factory>license: str = <factory>features: typing.Optional[datasets.features.features.Features] = Nonepost_processed: typing.Optional[datasets.info.PostProcessedInfo] = Nonesupervised_keys: typing.Optional[datasets.info.SupervisedKeysData] = Nonebuilder_name: typing.Optional[str] = Nonedataset_name: typing.Optional[str] = Noneconfig_name: typing.Optional[str] = Noneversion: typing.Union[str, datasets.utils.version.Version, NoneType] = Nonesplits: typing.Optional[datasets.splits.SplitDict] = Nonedownload_checksums: typing.Optional[dict] = Nonedownload_size: typing.Optional[int] = Nonepost_processing_size: typing.Optional[int] = Nonedataset_size: typing.Optional[int] = Nonesize_in_bytes: typing.Optional[int] = None )
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 (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 deGeneratorBasedBuilderutilizada para crear el conjunto de datos. También es la versión en snake_case del nombre de la clase del generador del conjunto de datos. - config_name (
str, opcional) — El nombre de la configuración derivada de BuilderConfig. - version (
stro Version, opcional) — La versión del conjunto de datos. - splits (
dict, opcional) — La correspondencia entre el nombre de la división y los metadatos. - download_checksums (
dict, opcional) — El mapeo entre la URL para descargar los checksums del conjunto de datos y los metadatos correspondientes. - download_size (
int, opcional) — El tamaño de los archivos que se descargan 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 al conjunto de datos (archivos descargados + archivos Arrow). - **config_kwargs (argumentos de palabra clave adicionales) — Argumentos de palabra clave que se pasarán al BuilderConfig y se usarán en el DatasetBuilder.
Información sobre un conjunto de datos.
DatasetInfo documenta conjuntos de datos, incluyendo su nombre, versión y características.
Consulte 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
< source >( dataset_info_dir: strstorage_options: typing.Optional[dict] = None )
Crea DatasetInfo a partir del archivo JSON en dataset_info_dir.
Esta función actualiza todos los campos generados dinámicamente (num_examples, hash, hora de creación,…) de DatasetInfo.
Esto sobrescribirá todos los metadatos anteriores.
write_to_directory
< source >( dataset_info_dirpretty_print = Falsestorage_options: typing.Optional[dict] = None )
Parámetros
- dataset_info_dir (
str) — Directorio de destino. - pretty_print (
bool, por defectoFalse) — Si esTrue, el JSON se mostrará con formato legible y 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.Añadido en 2.9.0
Escribe DatasetInfo y la licencia (si existe) como archivos JSON en dataset_info_dir.
Dataset
La clase base Dataset implementa un Dataset respaldado por una tabla de Apache Arrow.
clase datasets.Dataset
< source >( arrow_table: Tableinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Noneindices_table: typing.Optional[datasets.table.Table] = Nonefingerprint: typing.Optional[str] = None )
Un Dataset respaldado por una tabla Arrow.
add_column
< source >( name: strcolumn: typing.Union[list, numpy.ndarray]new_fingerprint: typing.Optional[str] = Nonefeature: 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 )
Agregar columna a Dataset.
Añadido en 1.7
add_item
< source >( item: dictnew_fingerprint: typing.Optional[str] = None )
Añadir elemento al Dataset.
Añadido en 1.7
Ejemplo:
>>> 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
< source >( filename: strinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Noneindices_filename: typing.Optional[str] = Nonein_memory: bool = False )
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 índices. - in_memory (
bool, por defectoFalse) — Si se debe copiar los datos en memoria.
Instancia un Dataset respaldado por una tabla Arrow en filename.
from_buffer
< source >( buffer: Bufferinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Noneindices_buffer: typing.Optional[pyarrow.lib.Buffer] = None )
Parámetros
Instanciar un Dataset respaldado por un búfer de Arrow.
from_pandas
< source >( df: DataFramefeatures: typing.Optional[datasets.features.features.Features] = Noneinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Nonepreserve_index: typing.Optional[bool] = None )
Parámetros
- df (
pandas.DataFrame) — Dataframe que contiene el conjunto de datos. - 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. - preserve_index (
bool, opcional) — Si se debe almacenar el índice como una columna adicional en el Dataset resultante. El valor predeterminado deNonealmacenará el índice como una columna, excepto paraRangeIndex, que se almacena solo como metadatos. Usapreserve_index=Truepara forzar que se almacene como una columna.
Convierta pandas.DataFrame en una pyarrow.Table para crear un Dataset.
Los tipos de columna en la Tabla Arrow resultante se infieren a partir de los dtypes de los 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 determinar 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() 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 quieres reducir el uso de memoria, deberías volver a escribirlo en disco y recargarlo usando, por ejemplo, save_to_disk / load_from_disk.
from_dict
< source >( mapping: dictfeatures: typing.Optional[datasets.features.features.Features] = Noneinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Noneon_mixed_types: typing.Optional[typing.Literal['use_json']] = None )
Parámetros
- mapping (
Mapping) — Mapeo de cadenas a Arrays o listas de Python. - 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, por defectoNone) — Si se usa “use_json”, se emplea 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 cadenas/enteros/decimales, por ejemplo, o diccionarios con tipos de valores arbitrarios.
Añadido en 4.7.0
Convierta dict en una pyarrow.Table para crear un 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 quieres reducir el uso de memoria, deberías volver a escribirlo en 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:
>>> 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:
>>> 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:
>>> 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:
>>> 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}]] # OKOtro ejemplo con datos de llamadas a herramientas:
>>> 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
< source >( mapping: listfeatures: typing.Optional[datasets.features.features.Features] = Noneinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Noneon_mixed_types: typing.Optional[typing.Literal['use_json']] = None )
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, por defectoNone) — Si se usa “use_json”, se emplea 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 cadenas/enteros/decimales, por ejemplo, o diccionarios con tipos de valores arbitrarios.
Añadido en 4.7.0
Convierta una lista de diccionarios en una pyarrow.Table para crear un 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() 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 quieres reducir el uso de memoria, deberías escribirlo de nuevo en disco y recargarlo usando, por ejemplo, save_to_disk / load_from_disk.
Ejemplos:
Obtén un Dataset a partir de una lista que contiene los ejemplos:
>>> 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:
>>> 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:
>>> 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:
>>> 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}]] # OKOtro ejemplo con datos de llamadas a herramientas:
>>> 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
< source >( generator: typing.Callablefeatures: typing.Optional[datasets.features.features.Features] = Nonecache_dir: str = Nonekeep_in_memory: bool = Falsegen_kwargs: typing.Optional[dict] = Nonenum_proc: typing.Optional[int] = Nonesplit: NamedSplit = NamedSplit('train')fingerprint: typing.Optional[str] = None**kwargs )
Parámetros
- generator ( —
Callable): Una función generadora queyieldsejemplos. - features (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 defectoFalse) — Si se debe copiar los datos en memoria. - gen_kwargs(
dict, opcional) — Argumentos de palabra clave que se pasarán al objeto invocablegenerator. Puede definir un conjunto de datos fragmentado pasando la lista de fragmentos engen_kwargsy estableciendonum_procen un valor mayor que 1. - num_proc (
int, opcional, por defectoNone) — 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. Sinum_proces mayor que uno, entonces todos los valores de lista engen_kwargsdeben tener la misma longitud. Estos valores se dividirán entre las llamadas al generador. El número de shards será el mínimo entre la lista más corta engen_kwargsynum_proc.Añadido en 2.7.0
- split (NamedSplit, por defecto es
Split.TRAIN) — Nombre de la división que se asignará al conjunto de datos.Añadido en 2.21.0
- fingerprint (
str, opcional) — Huella digital que se usará para generar el ID del conjunto de datos. Por defecto,fingerprintse 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.Añadido en 4.3.0
- **kwargs (argumentos de palabra clave adicionales) —
Argumentos de palabra clave que se pasarán a :
GeneratorConfig.
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.
La tabla Apache Arrow que respalda el conjunto de datos.
Ejemplo:
>>> 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]]Los archivos de caché que contienen la tabla Apache Arrow que respalda el conjunto de datos.
Ejemplo:
>>> 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'}]Número de columnas en el conjunto de datos.
Número de filas en el conjunto de datos (igual que Dataset.len()).
Nombres de las columnas en el conjunto de datos.
Forma del conjunto de datos (número de columnas, número de filas).
unique
< source >( column: str ) → list
Parámetros
- column (
str) — Column name (list all the column names with 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.
flatten
< source >( new_fingerprint: typing.Optional[str] = Nonemax_depth = 16 ) → Dataset
Parámetros
- new_fingerprint (
str, opcional) — La nueva huella digital del conjunto de datos después de la transformación. Si esNone, la nueva huella digital se calcula mediante un hash de la huella digital anterior y de los argumentos de la transformación.
Devuelve
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 dejan sin cambios.
Ejemplo:
>>> 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
< source >( features: Featuresbatch_size: typing.Optional[int] = 1000keep_in_memory: bool = Falseload_from_cache_file: typing.Optional[bool] = Nonecache_file_name: typing.Optional[str] = Nonewriter_batch_size: typing.Optional[int] = 1000num_proc: typing.Optional[int] = None ) → Dataset
Parámetros
- features (Features) —
Nuevas características a las que 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() para actualizar el Dataset. - batch_size (
int, por defecto1000) — Número de ejemplos por lote proporcionados a cast. Sibatch_size <= 0obatch_size == None, se proporciona el conjunto de datos completo como un único lote a cast. - keep_in_memory (
bool, por defectoFalse) — Si se debe copiar los datos en memoria. - load_from_cache_file (
bool, por defectoTruesi la caché está habilitada) — Si se puede identificar un archivo de caché que almacena el cálculo actual defunction, úsese en lugar de recalcular. - cache_file_name (
str, opcional, valor predeterminadoNone) — 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 defecto1000) — Número de filas por operación de escritura para el escritor del archivo 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(). - num_proc (
int, opcional, valor predeterminadoNone) — Número de procesos para la multiprocesación. De forma predeterminada, no utiliza multiprocesación.
Devuelve
Una copia del conjunto de datos con las características convertidas.
Castea el conjunto de datos a un nuevo conjunto de características.
Ejemplo:
>>> 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
< source >( column: strfeature: 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 )
Parámetros
- column (
str) — Nombre de la column. - feature (
FeatureType) — Característica objetivo. - new_fingerprint (
str, opcional) — La nueva huella digital del conjunto de datos después de la transformación. Si esNone, la nueva huella digital se calcula mediante un hash de la huella digital anterior y de los argumentos de la transformación.
Castea la columna a característica para la decodificación.
Ejemplo:
>>> 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
< source >( column_names: typing.Union[str, list[str]]new_fingerprint: typing.Optional[str] = None ) → Dataset
Parámetros
- column_names (
Union[str, List[str]]) — Nombre de la columna o columnas a eliminar. - new_fingerprint (
str, opcional) — La nueva huella digital del conjunto de datos después de la transformación. Si esNone, la nueva huella digital se calcula mediante un hash de la huella digital anterior y de los argumentos de la transformación.
Devuelve
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() 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:
>>> 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
< source >( original_column_name: strnew_column_name: strnew_fingerprint: typing.Optional[str] = None ) → Dataset
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 esNone, la nueva huella digital se calcula mediante un hash de la huella digital anterior y de los argumentos de la transformación.
Devuelve
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.
rename_columns
< source >( column_mapping: dictnew_fingerprint: typing.Optional[str] = None ) → Dataset
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 esNone, la nueva huella digital se calcula mediante un hash de la huella digital anterior y de los argumentos de la transformación.
Devuelve
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.
select_columns
< source >( column_names: typing.Union[str, list[str]]new_fingerprint: typing.Optional[str] = None ) → Dataset
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 esNone, la nueva huella digital se calcula usando un hash de la huella digital anterior y los argumentos de la transformación.
Devuelve
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.
class_encode_column
< source >( column: strinclude_nulls: bool = False )
Parámetros
- column (
str) — El nombre de la columna a convertir (puedes ver todos los nombres de columnas con column_names) - include_nulls (
bool, por defectoFalse) — Si se incluyen valores nulos en las etiquetas de clase. SiTrue, los valores nulos se codificarán como la etiqueta de clase"None".Añadido en 1.14.2
Convierte la columna indicada en ClassLabel y actualiza la tabla.
Ejemplo:
>>> 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')}Número de filas en el conjunto de datos.
Itera sobre los ejemplos.
Si se establece un formato con Dataset.set_format(), las filas se devolverán con el formato seleccionado.
iter
< source >( batch_size: intdrop_last_batch: bool = False )
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
< source >( type: typing.Optional[str] = Nonecolumns: typing.Optional[list] = Noneoutput_all_columns: bool = False**format_kwargs )
Parámetros
- type (
str, opcional) — Tipo de salida seleccionado en[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars'].Nonesignifica que getitem devuelve objetos de Python (predeterminado). - columns (
List[str], opcional) — Columnas que se formatearán en la salida.Nonesignifica que__getitem__devuelve todas las columnas (valor predeterminado). - output_all_columns (
bool, por defectoFalse) — Mantener también las columnas sin formatear 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.tensorotensorflow.ragged.constant.
Para usarse en una declaración with. Establece el formato de retorno de __getitem__ (tipo y columnas).
set_format
< source >( type: typing.Optional[str] = Nonecolumns: typing.Optional[list] = Noneoutput_all_columns: bool = False**format_kwargs )
Parámetros
- type (
str, opcional) — Tipo de salida seleccionado en[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars'].Nonesignifica que__getitem__devuelve objetos de python (valor predeterminado). - columns (
List[str], opcional) — Columnas que se formatearán en la salida.Nonesignifica que__getitem__devuelve todas las columnas (valor predeterminado). - output_all_columns (
bool, por defectoFalse) — Mantener también las columnas sin formatear 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.tensorotensorflow.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().
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á de la siguiente manera:
new formatted columns = (all columns - previously unformatted columns)Ejemplo:
>>> 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
< source >( transform: typing.Optional[typing.Callable]columns: typing.Optional[list] = Noneoutput_all_columns: bool = False )
Parámetros
- transform (
Callable, opcional) — Transformación de formato definida por el usuario, reemplaza el formato definido por set_format(). Una función de formato es un objeto invocable que toma un lote (como undict) como entrada y devuelve un lote. Esta función se aplica justo antes de devolver los objetos en__getitem__. - columns (
List[str], opcional) — 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 defectoFalse) — Mantener también las columnas sin formatear en la salida (como objetos de python). Si se establece en True, las demás columnas sin formatear 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(), esto se puede restablecer usando reset_format().
Ejemplo:
>>> 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])}Restablecer el formato de retorno de __getitem__ a objetos de Python y todas las columnas.
Igual que self.set_format()
Ejemplo:
>>> 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
< source >( type: typing.Optional[str] = Nonecolumns: typing.Optional[list] = Noneoutput_all_columns: bool = False**format_kwargs )
Parámetros
- type (
str, opcional) — Tipo de salida seleccionado en[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars'].Nonesignifica que__getitem__devuelve objetos de python (valor predeterminado). - columns (
List[str], opcional) — Columnas que se formatearán en la salida.Nonesignifica que__getitem__devuelve todas las columnas (valor predeterminado). - output_all_columns (
bool, por defectoFalse) — Mantener también las columnas sin formatear 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.tensorotensorflow.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().
A diferencia de set_format(), with_format devuelve un nuevo objeto Dataset.
Ejemplo:
>>> 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
< source >( transform: typing.Optional[typing.Callable]columns: typing.Optional[list] = Noneoutput_all_columns: bool = False )
Parámetros
- transform (
Callable,optional) — Transformación de formato definida por el usuario, reemplaza el formato definido por set_format(). Una función de formato es un objeto invocable que toma un lote (como undict) 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 defectoFalse) — Mantener también las columnas sin formatear en la salida (como objetos de Python). Si se establece enTrue, las demás columnas sin formatear 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(), esto se puede restablecer usando reset_format().
A diferencia de set_transform(), with_transform devuelve un nuevo objeto Dataset.
Ejemplo:
>>> 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])}Se puede usar para indexar columnas (por nombres de cadena) o filas (por índice entero o iterable de índices o booleanos).
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é.
map
< source >( function: typing.Optional[typing.Callable] = Nonewith_indices: bool = Falsewith_rank: bool = Falseinput_columns: typing.Union[str, list[str], NoneType] = Nonebatched: bool = Falsebatch_size: typing.Optional[int] = 1000drop_last_batch: bool = Falseremove_columns: typing.Union[str, list[str], NoneType] = Nonekeep_in_memory: bool = Falseload_from_cache_file: typing.Optional[bool] = Nonecache_file_name: typing.Optional[str] = Nonewriter_batch_size: typing.Optional[int] = 1000features: typing.Optional[datasets.features.features.Features] = Nonedisable_nullable: bool = Falsefn_kwargs: typing.Optional[dict] = Nonenum_proc: typing.Optional[int] = Nonesuffix_template: str = '_{rank:05d}_of_{num_proc:05d}'new_fingerprint: typing.Optional[str] = Nonedesc: typing.Optional[str] = Nonetry_original_type: typing.Optional[bool] = Trueon_mixed_types: typing.Optional[typing.Literal['use_json']] = 'use_json' )
Parámetros
- function (
Callable) — Función con una de las siguientes firmas:function(example: Dict[str, Any]) -> Dict[str, Any]sibatched=Falseywith_indices=Falseywith_rank=Falsefunction(example: Dict[str, Any], *extra_args) -> Dict[str, Any]sibatched=Falseywith_indices=Truey/owith_rank=True(un argumento adicional por cada uno)function(batch: Dict[str, List]) -> Dict[str, List]sibatched=Trueywith_indices=Falseywith_rank=Falsefunction(batch: Dict[str, List], *extra_args) -> Dict[str, List]sibatched=Trueywith_indices=Truey/owith_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,mapejecutará su función en paralelo. Además, si su función no devuelve nada (None),mapejecutará 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 defectoFalse) — Proporciona índices de ejemplo afunction. Ten en cuenta que, en este caso, la firma defunctiondebe serdef function(example, idx[, rank]): .... - with_rank (
bool, por defectoFalse) — Proporciona el rango del proceso afunction. Ten en cuenta que, en este caso, la firma defunctiondebe serdef function(example[, idx], rank): .... - input_columns (
Optional[Union[str, List[str]]], por defectoNone) — Las columnas que se pasarán afunctioncomo argumentos posicionales. Si esNone, se pasa undictque mapea todas las columnas formateadas como un solo argumento. - batched (
bool, por defectoFalse) — Proporciona un lote de ejemplos afunction. - batch_size (
int, opcional, valor predeterminado1000) — Número de ejemplos por lote que se proporcionan afunctionsibatched=True. Sibatch_size <= 0obatch_size == None, se proporciona el conjunto de datos completo como un único lote afunction. - drop_last_batch (
bool, por defectoFalse) — 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 defectoNone) — Elimina una selección de columnas durante el mapeo. Las columnas se eliminarán antes de actualizar los ejemplos con la salida defunction, es decir, sifunctionestá añadiendo columnas con nombres enremove_columns, estas columnas se conservarán. - keep_in_memory (
bool, por defectoFalse) — Mantiene el conjunto de datos en memoria en lugar de escribirlo en un archivo de caché. - load_from_cache_file (
Optional[bool], por defectoTruesi la caché está habilitada) — Si se puede identificar un archivo de caché que almacena el cálculo actual defunction, úsese en lugar de recalcular. - cache_file_name (
str, opcional, valor predeterminadoNone) — 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 defecto1000) — Número de filas por operación de escritura para el escritor del archivo 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 demap. - features (
Optional[datasets.Features], por defectoNone) — Usa un Features específico para almacenar el archivo de caché en lugar del generado automáticamente. - disable_nullable (
bool, por defectoFalse) — No permite valores nulos en la tabla. - fn_kwargs (
Dict, opcional, por defectoNone) — Argumentos de palabra clave que se pasarán afunction. - num_proc (
int, opcional, el valor predeterminado esNone) — 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 funciones definidas en el nivel superior de un módulo, no dentro de otra función o clase).- Si es
Noneo0, no se usa multiproceso y la operación se ejecuta en el proceso principal. - If greater than
1, one or multiple worker processes are used to process data in parallel. Note: The function passed tomap()must be picklable for multiprocessing to work correctly (i.e., prefer functions defined at the top level of a module, not inside another function or class). suffixtemplate (str): Ifcache_file_nameis specified, then this suffix will be added at the end of the base name of each. Defaults to `”{rank:05d}of{num_proc:05d}”. For example, ifcache_file_nameis "processed.arrow", then forrank=1andnum_proc=4, the resulting file would be“processed_00001_of_00004.arrow”` for the default suffix.
- Si es
- new_fingerprint (
str, opcional, valor predeterminadoNone) — La nueva huella digital del conjunto de datos después de la transformación. Si esNone, la nueva huella digital se calcula mediante un hash de la huella digital anterior y de los argumentos de la transformación. - desc (
str, opcional, valor predeterminadoNone) — Descripción significativa que se mostrará junto con la barra de progreso mientras se mapean los ejemplos. - try_original_type (
Optional[bool], por defectoTrue) — Intenta mantener los tipos de las columnas originales (p. ej. int32 -> int32). Establece en False si deseas inferir siempre nuevos tipos. - on_mixed_types (
Literal["use_json"], opcional, por defectoNone) — Si se usa “use_json”, se emplea 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 cadenas/enteros/decimales, por ejemplo, o diccionarios con tipos de valores arbitrarios.
Añadido en 4.7.0
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
FalseesFalse, la función toma 1 ejemplo como entrada y debe devolver 1 ejemplo. Un ejemplo es un diccionario, p. ej.{"text": "Hello there !"}. - Si
Trueybatch_sizees 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
Trueybatch_sizeesn > 1, la función toma como entrada un lote denejemplos y puede devolver un lote connejemplos, o con un número arbitrario de ejemplos. Tenga en cuenta que el último lote puede tener menos denejemplos. Un lote es un diccionario, por ejemplo, un lote denejemplos 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:
>>> 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)filter
< source >( function: typing.Optional[typing.Callable] = Nonewith_indices: bool = Falsewith_rank: bool = Falseinput_columns: typing.Union[str, list[str], NoneType] = Nonebatched: bool = Falsebatch_size: typing.Optional[int] = 1000keep_in_memory: bool = Falseload_from_cache_file: typing.Optional[bool] = Nonecache_file_name: typing.Optional[str] = Nonewriter_batch_size: typing.Optional[int] = 1000fn_kwargs: typing.Optional[dict] = Nonenum_proc: typing.Optional[int] = Nonesuffix_template: str = '_{rank:05d}_of_{num_proc:05d}'new_fingerprint: typing.Optional[str] = Nonedesc: typing.Optional[str] = None )
Parámetros
- function (
Callable) — Función con una de las siguientes firmas:function(example: Dict[str, Any]) -> boolsibatched=Falseywith_indices=Falseywith_rank=Falsefunction(example: Dict[str, Any], *extra_args) -> boolsibatched=Falseywith_indices=Truey/owith_rank=True(un argumento adicional por cada uno)function(batch: Dict[str, List]) -> List[bool]sibatched=Trueywith_indices=Falseywith_rank=Falsefunction(batch: Dict[str, List], *extra_args) -> List[bool]sibatched=Trueywith_indices=Truey/owith_rank=True(un argumento adicional por cada uno)
Si la función es asíncrona,
filterejecutará su función en paralelo. Si no se proporciona ninguna función, el valor predeterminado es una función que siempre devuelveTrue:lambda x: True. - with_indices (
bool, por defectoFalse) — Proporciona índices de ejemplo afunction. Ten en cuenta que, en este caso, la firma defunctiondebe serdef function(example, idx[, rank]): .... - with_rank (
bool, por defectoFalse) — Proporciona el rango del proceso afunction. Ten en cuenta que, en este caso, la firma defunctiondebe serdef function(example[, idx], rank): .... - input_columns (
stroList[str], opcional) — Las columnas que se pasarán afunctioncomo argumentos posicionales. Si esNone, se pasa undictque mapea todas las columnas formateadas como un solo argumento. - batched (
bool, por defectoFalse) — Proporciona un lote de ejemplos afunction. - batch_size (
int, opcional, valor predeterminado1000) — Número de ejemplos por lote que se proporcionan afunctionsibatched = True. Sibatched = False, se pasa un ejemplo por lote afunction. Sibatch_size <= 0obatch_size == None, se proporciona el conjunto de datos completo como un único lote afunction. - keep_in_memory (
bool, por defectoFalse) — Mantiene el conjunto de datos en memoria en lugar de escribirlo en un archivo de caché. - load_from_cache_file (
Optional[bool], por defectoTruesi la caché está habilitada) — Si se puede identificar un archivo de caché que almacena el cálculo actual defunction, ú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 defecto1000) — Número de filas por operación de escritura para el escritor del archivo 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 demap. - fn_kwargs (
dict, opcional) — Argumentos de palabra clave que se pasarán afunction. - num_proc (
int, opcional, el valor predeterminado esNone) — El número de procesos a utilizar para la multiprocesamiento. Si es None o 0, no se utiliza multiprocesamiento 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 el multiprocesamiento funcione correctamente (es decir, se prefieren funciones definidas en el nivel superior de un módulo, no dentro de otra función o clase).- Si es
Noneo0, no se usa multiproceso 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 amap()debe ser serializable con pickle 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).
- Si es
- suffix_template (
str) — Si se especificacache_file_name, se añadirá este sufijo al final del nombre base de cada archivo. Por ejemplo, sicache_file_namees"processed.arrow", entonces pararank = 1ynum_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 esNone, la nueva huella digital se calcula mediante un hash de la huella digital anterior y de los argumentos de la transformación. - desc (
str, opcional, valor predeterminadoNone) — 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.
select
< source >( indices: Iterablekeep_in_memory: bool = Falseindices_cache_file_name: typing.Optional[str] = Nonewriter_batch_size: typing.Optional[int] = 1000new_fingerprint: typing.Optional[str] = None )
Parámetros
- indices (
range,list,iterable,ndarrayoSeries) — Rango, lista o matriz unidimensional de índices enteros para la indexación. 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 sigue siendo más rápido que recrear una tabla Arrow compuesta por las filas solicitadas. - keep_in_memory (
bool, por defectoFalse) — Mantener el mapeo de índices en memoria en lugar de escribirlo en un archivo de caché. - indices_cache_file_name (
str, opcional, valor predeterminadoNone) — 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 defecto1000) — Número de filas por operación de escritura para el escritor del archivo 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 demap. - new_fingerprint (
str, opcional, valor predeterminadoNone) — La nueva huella digital del conjunto de datos después de la transformación. Si esNone, la nueva huella digital se calcula mediante un hash de la huella digital anterior y de los argumentos de la transformación.
Cree un nuevo conjunto de datos con las filas seleccionadas según la lista/matriz de índices.
sort
< source >( column_names: typing.Union[str, collections.abc.Sequence[str]]reverse: typing.Union[bool, collections.abc.Sequence[bool]] = Falsenull_placement: str = 'at_end'keep_in_memory: bool = Falseload_from_cache_file: typing.Optional[bool] = Noneindices_cache_file_name: typing.Optional[str] = Nonewriter_batch_size: typing.Optional[int] = 1000new_fingerprint: typing.Optional[str] = None )
Parámetros
- column_names (
Union[str, Sequence[str]]) — Nombre(s) de columna(s) para ordenar. - reverse (
Union[bool, Sequence[bool]], por defectoFalse) — Si esTrue, 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 defectoat_end) — Coloca los valoresNoneal principio siat_startofirsto al final siat_endolastAñadido en 1.14.2
- keep_in_memory (
bool, por defectoFalse) — Mantener los índices ordenados en memoria en lugar de escribirlos en un archivo de caché. - load_from_cache_file (
Optional[bool], por defectoTruesi la caché está habilitada) — Si se puede identificar un archivo de caché que almacena los índices ordenados, úsese en lugar de recalcularlos. - indices_cache_file_name (
str, opcional, valor predeterminadoNone) — 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 defecto1000) — Número de filas por operación de escritura para el escritor del archivo de caché. Un valor más alto produce archivos de caché más pequeños, mientras que un valor más bajo consume menos memoria temporal. - new_fingerprint (
str, opcional, valor predeterminadoNone) — La nueva huella digital del conjunto de datos después de la transformación. Si esNone, la nueva huella digital se calcula mediante 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:
>>> 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
< source >( seed: typing.Optional[int] = Nonegenerator: typing.Optional[numpy.random._generator.Generator] = Nonekeep_in_memory: bool = Falseload_from_cache_file: typing.Optional[bool] = Noneindices_cache_file_name: typing.Optional[str] = Nonewriter_batch_size: typing.Optional[int] = 1000new_fingerprint: typing.Optional[str] = None )
Parámetros
- seed (
int, opcional) — Una semilla para inicializar el BitGenerator predeterminado sigenerator=None. SiNone, se extraerá entropía fresca e impredecible del sistema operativo. Si se pasa uninto unarray_like[ints], se pasará a SeedSequence para derivar el estado inicial de BitGenerator. - generator (
numpy.random.Generator, opcional) — Generador aleatorio de Numpy para calcular la permutación de las filas del conjunto de datos. Sigenerator=None(predeterminado), usanp.random.default_rng(el BitGenerator predeterminado (PCG64) de NumPy). - keep_in_memory (
bool, por defectoFalse) — Mantener los índices barajados en memoria en lugar de escribirlos en un archivo de caché. - load_from_cache_file (
Optional[bool], por defectoTruesi la caché está habilitada) — Si se puede identificar un archivo de caché que almacena los índices barajados, úsese en lugar de recalcularlos. - indices_cache_file_name (
str, opcional) — Proporciona 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 defecto1000) — Número de filas por operación de escritura para el escritor del archivo 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 demap. - new_fingerprint (
str, opcional, valor predeterminadoNone) — La nueva huella digital del conjunto de datos después de la transformación. Si esNone, la nueva huella digital se calcula mediante un hash de la huella digital anterior y de 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 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(), que elimina el mapeo de índices.
Sin embargo, esto puede llevar mucho tiempo dependiendo del tamaño de su conjunto de datos:
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 againEn este caso, recomendamos cambiar a un IterableDataset y aprovechar su rápido método de barajado aproximado 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:
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
passCrea un nuevo Dataset que omita los primeros n elementos.
Ejemplo:
>>> 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 .'}]Cree un nuevo Dataset con solo los primeros n elementos.
Ejemplo:
>>> 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
< source >( test_size: typing.Union[float, int, NoneType] = Nonetrain_size: typing.Union[float, int, NoneType] = Noneshuffle: bool = Truestratify_by_column: typing.Optional[str] = Noneseed: typing.Optional[int] = Nonegenerator: typing.Optional[numpy.random._generator.Generator] = Nonekeep_in_memory: bool = Falseload_from_cache_file: typing.Optional[bool] = Nonetrain_indices_cache_file_name: typing.Optional[str] = Nonetest_indices_cache_file_name: typing.Optional[str] = Nonewriter_batch_size: typing.Optional[int] = 1000train_new_fingerprint: typing.Optional[str] = Nonetest_new_fingerprint: typing.Optional[str] = None )
Parámetros
- test_size (
Union[float, int, None], opcional) — Tamaño de la división de prueba Si esfloat, debe estar entre0.0y1.0y representar la proporción del conjunto de datos que se incluirá en la división de prueba. Si esint, representa el número absoluto de muestras de prueba. Si esNone, el valor se establece como el complemento del tamaño de entrenamiento. Sitrain_sizetambién esNone, se establecerá en0.25. - train_size (
Union[float, int, None], opcional) — Tamaño de la división de entrenamiento Si esfloat, debe estar entre0.0y1.0y representar la proporción del conjunto de datos que se incluirá en la división de entrenamiento. Si esint, representa el número absoluto de muestras de entrenamiento. Si esNone, el valor se establece automáticamente como el complemento del tamaño de la división de prueba. - shuffle (
bool, opcional, valor predeterminadoTrue) — Si se barajan los datos antes de dividirlos. - stratify_by_column (
str, opcional, valor predeterminadoNone) — El nombre de la columna de etiquetas que se utilizará para realizar una división estratificada de los datos. - seed (
int, opcional) — Una semilla para inicializar el BitGenerator predeterminado sigenerator=None. SiNone, se extraerá entropía fresca e impredecible del sistema operativo. Si se pasa uninto unarray_like[ints], se pasará a SeedSequence para derivar el estado inicial de BitGenerator. - generator (
numpy.random.Generator, opcional) — Generador aleatorio de Numpy para calcular la permutación de las filas del conjunto de datos. Sigenerator=None(predeterminado), usanp.random.default_rng(el BitGenerator predeterminado (PCG64) de NumPy). - keep_in_memory (
bool, por defectoFalse) — Mantener los índices de las divisiones en memoria en lugar de escribirlos en un archivo de caché. - load_from_cache_file (
Optional[bool], por defectoTruesi la caché está habilitada) — Si se puede identificar un archivo de caché que almacena los índices de las divisiones, úsese en lugar de recalcularlos. - train_cache_file_name (
str, opcional) — Proporciona 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) — Proporciona 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 defecto1000) — Número de filas por operación de escritura para el escritor del archivo 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 demap. - train_new_fingerprint (
str, opcional, valor predeterminadoNone) — La nueva huella digital del conjunto de entrenamiento después de la transformación. Si esNone, la nueva huella digital se calcula utilizando un hash de la huella digital anterior y los argumentos de la transformación - test_new_fingerprint (
str, opcional, valor predeterminadoNone) — La nueva huella digital del conjunto de pruebas después de la transformación. SiNone, la nueva huella digital se calcula utilizando un hash de la huella digital anterior y los argumentos de la transformación
Devuelve un diccionario (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:
>>> 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
< source >( num_shards: intindex: intcontiguous: bool = Truekeep_in_memory: bool = Falseindices_cache_file_name: typing.Optional[str] = Nonewriter_batch_size: typing.Optional[int] = 1000 )
Parámetros
- num_shards (
int) — Número de fragmentos en los que dividir el conjunto de datos. - index (
int) — Indica qué fragmento seleccionar y devolver. - contiguous — (
bool, por defectoTrue): Si se deben seleccionar bloques contiguos de índices para los fragmentos. - keep_in_memory (
bool, por defectoFalse) — Mantiene el conjunto de datos en memoria en lugar de escribirlo en un archivo de caché. - indices_cache_file_name (
str, opcional) — Proporciona el nombre de una ruta para el archivo de caché. Se utiliza para almacenar los índices de cada shard en lugar del nombre de archivo de caché generado automáticamente. - writer_batch_size (
int, por defecto1000) — Esto solo afecta al mapeo de índices. Número de índices por operación de escritura para el escritor del archivo de caché. Este valor es un buen equilibrio entre el uso de memoria durante el procesamiento y la velocidad de procesamiento. Un valor mayor hace que el procesamiento realice menos búsquedas, mientras que un valor menor consume menos memoria temporal durante la ejecución demap.
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).
Es preferible que el operador de particionado se use al inicio de la tubería de datos.
Ejemplo:
>>> 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
})repeat
< source >( num_times: int )
Crea un nuevo Dataset que repita el subyacente num_times veces.
Al igual que itertools.repeat, repetir una sola vez devuelve el conjunto de datos completo.
Ejemplo:
>>> 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
< source >( batch_size: typing.Optional[int] = Nonecolumns: typing.Union[str, list[str], NoneType] = Noneshuffle: bool = Falsecollate_fn: typing.Optional[typing.Callable] = Nonedrop_remainder: bool = Falsecollate_fn_args: typing.Optional[dict[str, typing.Any]] = Nonelabel_cols: typing.Union[str, list[str], NoneType] = Noneprefetch: bool = Truenum_workers: int = 0num_test_batches: int = 20 )
Parámetros
- batch_size (
int, opcional) — Tamaño de los lotes que se cargarán del conjunto de datos. El valor predeterminado esNone, 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 contf_dataset.batch(batch_size). - columns (
List[str]ostr, opcional) — Columna(s) del dataset que se cargarán en eltf.data.Dataset. Se pueden utilizar nombres de columnas creados porcollate_fnque no existan en el dataset original. - shuffle(
bool, por defectoFalse) — Baraja el orden del conjunto de datos al cargarlo. Se recomiendaTruepara el entrenamiento yFalsepara la validación/evaluación. - drop_remainder(
bool, por defectoFalse) — 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 unDataCollator) que agrupará listas de muestras en un lote. - collate_fn_args (
Dict, opcional) — Undictopcional de argumentos de palabra clave para pasar acollate_fn. - label_cols (
List[str]ostr, por defectoNone) — 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 lascolumnsde entrada. - prefetch (
bool, por defectoTrue) — 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 defecto0) — Número de workers para usar al cargar el conjunto de datos. - num_test_batches (
int, por defecto20) — Número de lotes que se usarán para inferir la firma de salida del conjunto de datos. A mayor número, más precisa será la firma, pero más tiempo tardará en crearse el conjunto de datos.
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.
push_to_hub
< source >( repo_id: strconfig_name: str = 'default'set_default: typing.Optional[bool] = Nonesplit: typing.Optional[str] = Nonedata_dir: typing.Optional[str] = Nonecommit_message: typing.Optional[str] = Nonecommit_description: typing.Optional[str] = Noneprivate: typing.Optional[bool] = Nonetoken: typing.Optional[str] = Nonerevision: typing.Optional[str] = Nonecreate_pr: typing.Optional[bool] = Falsemax_shard_size: typing.Union[str, int, NoneType] = Nonenum_shards: typing.Optional[int] = Noneembed_external_files: bool = Truenum_proc: typing.Optional[int] = None )
Parámetros
- repo_id (
str) — El ID del repositorio al que se enviarán los datos, en el siguiente formato:<user>/<dataset_name>o<org>/<dataset_name>. También acepta<dataset_name>, que usará el espacio de nombres del usuario conectado por defecto.También podría ser una ubicación dentro de un bucket, p. ej.
buckets/<user_or_org>/<bucket_name>/... - 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 debe establecer esta configuración como la predeterminada. De lo contrario, la configuración predeterminada es la que se llama “default”. - split (
str, opcional) — El nombre de la división que se asignará a ese conjunto de datos. El valor predeterminado esself.split. - data_dir (
str, opcional) — Nombre del directorio que contendrá los archivos de datos cargados. El valor predeterminado esconfig_namesi es diferente de «default», en caso contrario, «data».Añadido en 2.17.0
- commit_message (
str, opcional) — Mensaje para el commit al hacer push. El valor predeterminado es"Upload dataset". - commit_description (
str, opcional) — Descripción del commit que se creará. Además, descripción del PR si se crea un PR (create_pres True).Añadido en 2.16.0
- private (
bool, opcional) — Si se debe hacer el repositorio privado. Si esNone(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 conhf 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. El valor predeterminado es la rama"main".Añadido en 2.15.0
- create_pr (
bool, opcional, por defectoFalse) — Si se debe crear una PR con los archivos subidos o realizar un commit directamente.Añadido en 2.15.0
- max_shard_size (
intostr, 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 shards a escribir. De forma predeterminada, el número de shards depende demax_shard_size.Añadido en 2.8.0
- embed_external_files (
bool, por defecto esTrue) — Si se incrustan los bytes de los archivos en los fragmentos. En particular, antes de la publicación, esto hará lo siguiente para los campos de tipo: - num_proc (
int, opcional, por defectoNone) — 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. Utiliza el contexto “spawn” para funcionar con hf_xet, el cliente de Rust para subidas rápidas a HF. La multiprocesación está deshabilitada por defecto.Añadido en 4.0.0
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 de forma predeterminada. Si su conjunto de datos contiene datos de Image, Audio o 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:
>>> dataset.push_to_hub("<organization>/<dataset_id>")
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", private=True)
>>> dataset.push_to_hub("<organization>/<dataset_id>", max_shard_size="1GB")
>>> dataset.push_to_hub("<organization>/<dataset_id>", num_shards=1024)Si su conjunto de datos tiene varias divisiones (p. ej., entrenamiento/validación/prueba):
>>> train_dataset.push_to_hub("<organization>/<dataset_id>", split="train")
>>> val_dataset.push_to_hub("<organization>/<dataset_id>", split="validation")
>>> # later
>>> dataset = load_dataset("<organization>/<dataset_id>")
>>> 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):
>>> english_dataset.push_to_hub("<organization>/<dataset_id>", "en")
>>> french_dataset.push_to_hub("<organization>/<dataset_id>", "fr")
>>> # later
>>> english_dataset = load_dataset("<organization>/<dataset_id>", "en")
>>> french_dataset = load_dataset("<organization>/<dataset_id>", "fr")save_to_disk
< source >( dataset_path: typing.Union[str, bytes, os.PathLike]max_shard_size: typing.Union[str, int, NoneType] = Nonenum_shards: typing.Optional[int] = Nonenum_proc: typing.Optional[int] = Nonestorage_options: typing.Optional[dict] = None )
Parámetros
- dataset_path (
path-like) — Ruta (p. ej.dataset/train) o URI remoto (p. ej.s3://my-bucket/dataset/train) del directorio del conjunto de datos donde se guardará. - max_shard_size (
intostr, 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 shards a escribir. Por defecto, el número de shards depende demax_shard_sizeynum_proc.Añadido en 2.8.0
- num_proc (
int, opcional) — Número de procesos al descargar y generar el dataset localmente. La multiprocesación está deshabilitada de forma predeterminada.Añadido en 2.8.0
- storage_options (
dict, opcional) — Pares clave/valor que se pasarán al backend del sistema de archivos, si lo hay.Añadido en 2.8.0
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, Audio y 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”).
load_from_disk
< source >( dataset_path: typing.Union[str, bytes, os.PathLike]keep_in_memory: typing.Optional[bool] = Nonestorage_options: typing.Optional[dict] = None ) → Dataset or DatasetDict
Parámetros
- dataset_path (
path-like) — Ruta (p. ej."dataset/train") o URI remoto (p. ej."s3//my-bucket/dataset/train") del directorio del conjunto de datos desde el que se cargará. - keep_in_memory (
bool, por defectoNone) — Si se debe copiar el conjunto de datos en memoria. Si esNone, el conjunto de datos no se copiará en memoria a menos que se habilite explícitamente estableciendodatasets.config.IN_MEMORY_MAX_SIZEen un valor distinto de cero. Más detalles en la sección mejorar el rendimiento. - storage_options (
dict, opcional) — Pares clave/valor que se pasarán al backend del sistema de archivos, si lo hay.Añadido en 2.8.0
Devuelve
- Si
dataset_pathes la ruta de un directorio de datos, el conjunto de datos solicitado. - Si
dataset_pathes la ruta de un directorio de diccionario de datos, undatasets.DatasetDictcon 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.
flatten_indices
< source >( keep_in_memory: bool = Falsecache_file_name: typing.Optional[str] = Nonewriter_batch_size: typing.Optional[int] = 1000features: typing.Optional[datasets.features.features.Features] = Nonedisable_nullable: bool = Falsenum_proc: typing.Optional[int] = Nonenew_fingerprint: typing.Optional[str] = None )
Parámetros
- keep_in_memory (
bool, por defectoFalse) — Mantiene el conjunto de datos en memoria en lugar de escribirlo en un archivo de caché. - cache_file_name (
str, opcional, valor predeterminadoNone) — Proporciona 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 defecto1000) — Número de filas por operación de escritura para el escritor del archivo 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 demap. - features (
Optional[datasets.Features], por defectoNone) — Usa un Features específico para almacenar el archivo de caché en lugar del generado automáticamente. - disable_nullable (
bool, por defectoFalse) — Permite valores nulos en la tabla. - num_proc (
int, opcional, valor predeterminadoNone) — Número máximo de procesos al generar la caché. Los fragmentos ya en caché se cargan de forma secuencial - new_fingerprint (
str, opcional, valor predeterminadoNone) — La nueva huella digital del conjunto de datos después de la transformación. Si esNone, la nueva huella digital se calcula mediante 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
< source >( path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO]batch_size: typing.Optional[int] = Nonenum_proc: typing.Optional[int] = Nonestorage_options: typing.Optional[dict] = None**to_csv_kwargs ) → int
Parámetros
- path_or_buf (
PathLikeoFileOrBuffer) — 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 que se cargará en memoria y se escribirá de una vez. Por defecto,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_sizetoma por defecto el valor dedatasets.config.DEFAULT_MAX_BATCH_SIZE, pero puede aumentarse a 5 o 10 veces el valor predeterminado si se dispone 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.Añadido en 2.19.0
- **to_csv_kwargs (argumentos de palabra clave adicionales) —
Parámetros para pasar a pandas’s
pandas.DataFrame.to_csv.Cambios en 2.10.0
Ahora,
indextiene un valor predeterminado deFalsesi no se especifica.Si desea escribir el índice, pase
index=Truey también establezca un nombre para la columna de índice pasandoindex_label.
Devuelve
int
El número de caracteres o bytes escritos.
Exporta el conjunto de datos a csv
to_pandas
< source >( batch_size: typing.Optional[int] = Nonebatched: bool = False )
Parámetros
- batch_size (
int, opcional) — El tamaño (número de filas) de los lotes sibatchedesTrue. Por defecto,datasets.config.DEFAULT_MAX_BATCH_SIZE. - batched (
bool) — EstablezcaTruepara devolver un generador que produce el conjunto de datos en lotes debatch_sizefilas. El valor predeterminado esFalse(devuelve todo el conjunto de datos de una sola vez).
Devuelve el conjunto de datos como un pandas.DataFrame. También puede devolver un generador para conjuntos de datos grandes.
to_dict
< source >( batch_size: typing.Optional[int] = Nonebatched: bool = False )
Parámetros
- batch_size (
int, opcional) — El tamaño (número de filas) de los lotes sibatchedesTrue. Por defecto,datasets.config.DEFAULT_MAX_BATCH_SIZE. - batched (
bool) — EstablezcaTruepara devolver un generador que produce el conjunto de datos en lotes debatch_sizefilas. El valor predeterminado esFalse(devuelve todo el conjunto de datos de una sola vez).
Devuelve el conjunto de datos como un diccionario de Python. También puede devolver un generador para conjuntos de datos grandes.
to_json
< source >( path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO]batch_size: typing.Optional[int] = Nonenum_proc: typing.Optional[int] = Nonestorage_options: typing.Optional[dict] = None**to_json_kwargs ) → int
Parámetros
- path_or_buf (
PathLikeoFileOrBuffer) — 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 que se cargará en memoria y se escribirá de una vez. Por defecto,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_sizetoma por defecto el valor dedatasets.config.DEFAULT_MAX_BATCH_SIZE, pero puede aumentarse a 5 o 10 veces el valor predeterminado si se dispone 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.Añadido en 2.19.0
- **to_json_kwargs (argumentos de palabra clave adicionales) —
Parámetros para pasar a pandas
pandas.DataFrame.to_json. Los argumentos predeterminados sonlines=Truey `orient=“records”.Cambios en 2.11.0
El parámetro
indextiene un valor predeterminado deFalsesiorientes"split"o"table".Si desea escribir el índice, pase
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.
Para exportar a JSON, pase el argumento lines=False y el orient deseado.
to_parquet
< source >( path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO]batch_size: typing.Optional[int] = Nonestorage_options: typing.Optional[dict] = None**parquet_writer_kwargs ) → int
Parámetros
- path_or_buf (
PathLikeoFileOrBuffer) — 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 que se carga en memoria y se escribe de una vez. Por defecto, apunta a grupos de filas con un tamaño máximo de bytes sin comprimir de “100MB”, definido pordatasets.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.Añadido en 2.19.0
- **parquet_writer_kwargs (argumentos de palabra clave adicionales) —
Parámetros para pasar a
pyarrow.parquet.ParquetWriterde PyArrow.
Devuelve
int
El número de caracteres o bytes escritos.
Exporta el conjunto de datos a parquet
to_sql
< source >( name: strcon: typing.Union[str, ForwardRef('sqlalchemy.engine.Connection'), ForwardRef('sqlalchemy.engine.Engine'), ForwardRef('sqlite3.Connection')]batch_size: typing.Optional[int] = Nonenum_proc: typing.Optional[int] = None**sql_writer_kwargs ) → int
Parámetros
- name (
str) — Nombre de la tabla SQL. - con (
strosqlite3.Connectionosqlalchemy.engine.Connectionosqlalchemy.engine.Connection) — Una cadena URI o un objeto de conexión SQLite3/SQLAlchemy utilizado para escribir en una base de datos. - batch_size (
int, opcional) — Tamaño del lote que se cargará en memoria y se escribirá de una vez. Por defecto,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_sizetoma por defecto el valor dedatasets.config.DEFAULT_MAX_BATCH_SIZE, pero puede aumentarse a 5 o 10 veces el valor predeterminado si se dispone de suficiente capacidad de cálculo. - **sql_writer_kwargs (argumentos de palabra clave adicionales) —
Parámetros para pasar a
pandas.DataFrame.to_sql.Cambios en 2.11.0
Ahora,
indextiene un valor predeterminado deFalsesi no se especifica.Si desea escribir el índice, pase
index=Truey también establezca un nombre para la columna de índice pasandoindex_label.
Devuelve
int
El número de registros escritos.
Exporta el conjunto de datos a una base de datos SQL.
to_iterable_dataset
< source >( num_shards: typing.Optional[int] = 1 )
Parámetros
- num_shards (
int, por defecto1) — Número de shards que se definen al instanciar el dataset iterable. Esto es especialmente útil para datasets grandes, para poder hacer shuffle correctamente, y también para habilitar la carga paralela rápida usando un PyTorch DataLoader o, por ejemplo, en configuraciones distribuidas. Los shards se definen usando datasets.Dataset.shard(): simplemente segmenta los datos sin escribir nada en disco.
Obtén un datasets.IterableDataset a partir de un datasets.Dataset de estilo mapa. Esto es equivalente a cargar un conjunto de datos en modo de transmisión con 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 conjuntos de datos 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(). 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:
Con filtrado y procesamiento perezosos:
>>> 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:
... passCon el particionamiento para habilitar un barajado eficiente:
>>> 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:
... passCon un DataLoader de PyTorch:
>>> 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:
... passCon un DataLoader de PyTorch y barajado:
>>> 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:
... passEn una configuración distribuida como PyTorch DDP con un PyTorch DataLoader y barajado
>>> 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:
... passCon barajado y múltiples épocas:
>>> 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:
... passadd_faiss_index
< source >( column: strindex_name: typing.Optional[str] = Nonedevice: typing.Optional[int] = Nonestring_factory: typing.Optional[str] = Nonemetric_type: typing.Optional[int] = Nonecustom_index: typing.Optional[ForwardRef('faiss.Index')] = Nonebatch_size: int = 1000train_size: typing.Optional[int] = Nonefaiss_verbose: bool = Falsedtype = <class 'numpy.float32'> )
Parámetros
- column (
str) — La columna de los vectores que se añadirán al índice. - index_name (
str, opcional) — Elindex_name/identificador del índice. Este es elindex_nameque se utiliza para llamar a get_nearest_examples() o search(). Por defecto, corresponde acolumn. - device (
Union[int, List[int]], opcional) — Si es un entero positivo, 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 esIndexFlat. - metric_type (
int, opcional) — Tipo de métrica. Ej:faiss.METRIC_INNER_PRODUCTofaiss.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 que se utilizará al agregar vectores alFaissIndex. El valor predeterminado es1000.Añadido en 2.4.0
- 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 defectoFalse) — Activa la verbosidad del índice Faiss. - dtype (
data-type) — El dtype de los arrays de numpy que se indexan. El valor predeterminado esnp.float32.
Agregue un índice denso usando Faiss para una recuperación rápida.
Por defecto, 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
Ejemplo:
>>> 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
< source >( external_arrays: arrayindex_name: strdevice: typing.Optional[int] = Nonestring_factory: typing.Optional[str] = Nonemetric_type: typing.Optional[int] = Nonecustom_index: typing.Optional[ForwardRef('faiss.Index')] = Nonebatch_size: int = 1000train_size: typing.Optional[int] = Nonefaiss_verbose: bool = Falsedtype = <class 'numpy.float32'> )
Parámetros
- external_arrays (
np.array) — Si desea utilizar matrices externas a la librería para el índice, puede establecerexternal_arrays. Se utilizaráexternal_arrayspara crear el índice Faiss en lugar de las matrices de lacolumnindicada. - index_name (
str) — Elindex_name/identificador del índice. Este es elindex_nameque se utiliza para llamar a get_nearest_examples() o search(). - device (Opcional
Union[int, List[int]], optional) — 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 esIndexFlat. - metric_type (
int, opcional) — Tipo de métrica. Ej:faiss.faiss.METRIC_INNER_PRODUCTofaiss.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 que se utilizará al agregar vectores al FaissIndex. El valor predeterminado es 1000.Añadido en 2.4.0
- 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, predeterminado en False) — Activa 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
save_faiss_index
< source >( index_name: strfile: typing.Union[str, pathlib.PurePath]storage_options: typing.Optional[dict] = None )
Parámetros
- index_name (
str) — El index_name/identificador del índice. Este es el index_name que se utiliza para llamar a.get_nearesto.search. - file (
str) — La ruta al índice faiss serializado en el disco o URI remoto (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.Añadido en 2.11.0
Guardar un FaissIndex en disco.
load_faiss_index
< source >( index_name: strfile: typing.Union[str, pathlib.PurePath]device: typing.Union[int, list[int], NoneType] = Nonestorage_options: typing.Optional[dict] = None )
Parámetros
- index_name (
str) — El index_name/identificador del índice. Este es el index_name que se utiliza para llamar a.get_nearesto.search. - file (
str) — La ruta al índice faiss serializado en el disco o URI remoto (p. ej."s3://my-bucket/index.faiss"). - device (Opcional
Union[int, List[int]]) — Si es un entero positivo, 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. Por defecto, utiliza la CPU. - storage_options (
dict, opcional) — Pares clave/valor que se pasarán al backend del sistema de archivos, si lo hay.Añadido en 2.11.0
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
< source >( column: strindex_name: typing.Optional[str] = Nonehost: typing.Optional[str] = Noneport: typing.Optional[int] = Nonees_client: typing.Optional[ForwardRef('elasticsearch.Elasticsearch')] = Nonees_index_name: typing.Optional[str] = Nonees_index_config: typing.Optional[dict] = None )
Parámetros
- column (
str) — La columna de los documentos que se van a añadir al índice. - index_name (
str, opcional) — Elindex_name/identificador del índice. Este es el nombre del índice que se utiliza para llamar a get_nearest_examples() o search(). Por defecto, corresponde acolumn. - host (
str, opcional, valor predeterminadolocalhost) — Host donde se está ejecutando ElasticSearch. - port (
str, opcional, valor predeterminado9200) — Puerto donde se está ejecutando ElasticSearch. - es_client (
elasticsearch.Elasticsearch, opcional) — El cliente de elasticsearch utilizado para crear el índice si host y port sonNone. - 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:
Agregue un índice de texto usando ElasticSearch para una recuperación rápida. Esto se realiza in situ.
Ejemplo:
>>> 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
< source >( index_name: stres_index_name: strhost: typing.Optional[str] = Noneport: typing.Optional[int] = Nonees_client: typing.Optional[ForwardRef('Elasticsearch')] = Nonees_index_config: typing.Optional[dict] = None )
Parámetros
- index_name (
str) — Elindex_name/identificador del índice. Este es el nombre del índice que se utiliza para llamar aget_nearestosearch. - es_index_name (
str) — El nombre del índice de elasticsearch que se va a cargar. - host (
str, opcional, valor predeterminadolocalhost) — Host donde se está ejecutando ElasticSearch. - port (
str, opcional, valor predeterminado9200) — Puerto donde se está ejecutando ElasticSearch. - es_client (
elasticsearch.Elasticsearch, opcional) — El cliente de elasticsearch utilizado para crear el índice si host y port sonNone. - es_index_config (
dict, opcional) — La configuración del índice de elasticsearch. La configuración predeterminada es:
Cargue un índice de texto existente usando ElasticSearch para una recuperación rápida.
Muestra los colindex_nameumns/identificadores de todos los índices adjuntos.
Muestra los index_name/identificadores de todos los índices adjuntos.
drop_index
< source >( index_name: str )
Descarta el índice con la columna especificada.
buscar
< source >( index_name: strquery: typing.Union[str, <built-in function array>]k: int = 10**kwargs ) → (scores, indices)
Parámetros
- index_name (
str) — El nombre/identificador del índice. - query (
Union[str, np.ndarray]) — La consulta como una cadena de texto siindex_namees un índice de texto, o como un array de numpy siindex_namees 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 (IndexFlatL2por 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
< source >( index_name: strqueries: typing.Union[list[str], <built-in function array>]k: int = 10**kwargs ) → (total_scores, total_indices)
Parámetros
- index_name (
str) — Elindex_name/identificador del índice. - queries (
Union[List[str], np.ndarray]) — Las consultas como una lista de cadenas siindex_namees un índice de texto o como un array de numpy siindex_namees 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 (IndexFlatL2por 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
< source >( index_name: strquery: typing.Union[str, <built-in function array>]k: int = 10**kwargs ) → (scores, examples)
Parámetros
- index_name (
str) — El index_name/identificador del índice. - query (
Union[str, np.ndarray]) — La consulta como una cadena de texto siindex_namees un índice de texto, o como un array de numpy siindex_namees 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 (IndexFlatL2por 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
< source >( index_name: strqueries: typing.Union[list[str], <built-in function array>]k: int = 10**kwargs ) → (total_scores, total_examples)
Parámetros
- index_name (
str) — Elindex_name/identificador del índice. - queries (
Union[List[str], np.ndarray]) — Las consultas como una lista de cadenas siindex_namees un índice de texto o como un array de numpy siindex_namees 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 (IndexFlatL2por 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.
Objeto DatasetInfo que contiene todos los metadatos del conjunto de datos.
objeto NamedSplit correspondiente a una división de datos con nombre.
from_csv
< source >( path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]]split: typing.Optional[datasets.splits.NamedSplit] = Nonefeatures: typing.Optional[datasets.features.features.Features] = Nonecache_dir: str = Nonekeep_in_memory: bool = Falsenum_proc: typing.Optional[int] = None**kwargs )
Parámetros
- path_or_paths (
path-likeo lista depath-like) — Ruta(s) del archivo(s) CSV. - 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 almacenar los datos en caché. - keep_in_memory (
bool, por defectoFalse) — Si se debe copiar los datos en memoria. - num_proc (
int, opcional, el valor predeterminado esNone) — 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.Añadido en 2.8.0
- **kwargs (argumentos de palabra clave adicionales) —
Argumentos de palabra clave que se pasarán a
pandas.read_csv.
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.
from_json
< source >( path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]]split: typing.Optional[datasets.splits.NamedSplit] = Nonefeatures: typing.Optional[datasets.features.features.Features] = Nonecache_dir: str = Nonekeep_in_memory: bool = Falsefield: typing.Optional[str] = Nonenum_proc: typing.Optional[int] = None**kwargs )
Parámetros
- path_or_paths (
path-likeo lista depath-like) — Ruta(s) del archivo o archivos JSON o JSON Lines. - 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 almacenar los datos en caché. - keep_in_memory (
bool, por defectoFalse) — 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 defectoNone) — Número de procesos al descargar y generar el dataset localmente. Esto es útil si el dataset está compuesto por varios archivos. El multiprocessing está deshabilitado por defecto.Añadido en 2.8.0
- **kwargs (argumentos de palabra clave adicionales) —
Argumentos de palabra clave que se pasarán a
JsonConfig.
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.
from_parquet
< source >( path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]]split: typing.Optional[datasets.splits.NamedSplit] = Nonefeatures: typing.Optional[datasets.features.features.Features] = Nonecache_dir: str = Nonekeep_in_memory: bool = Falsecolumns: typing.Optional[list[str]] = Nonenum_proc: typing.Optional[int] = Nonefilters: typing.Union[pyarrow._compute.Expression, list[tuple], list[list[tuple]], NoneType] = Nonefragment_scan_options: typing.Optional[pyarrow._dataset_parquet.ParquetFragmentScanOptions] = Noneon_bad_files: typing.Literal['error', 'warn', 'skip'] = 'error'**kwargs )
Parámetros
- path_or_paths (
path-likeo lista depath-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 almacenar los datos en caché. - keep_in_memory (
bool, por defectoFalse) — Si se debe copiar los datos en memoria. - columns (
List[str], opcional) — Si no esNone, 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, el valor predeterminado esNone) — 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.Añadido en 2.8.0
- 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 delega 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. En caso contrario, filtra los RecordBatches cargados antes de devolverlos. - fragment_scan_options (
pyarrow.dataset.ParquetFragmentScanOptions, opcional) — Opciones específicas de escaneo para fragmentos Parquet. Esto es especialmente útil para configurar el almacenamiento en búfer y la caché.Añadido en 4.2.0
- on_bad_files (
Literal["error", "warn", "skip"], opcional, el valor predeterminado es “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 incorrecto.
- ‘warn’, emitir una advertencia cuando se encuentra un archivo incorrecto y omitir ese archivo.
- ‘skip’, omite los archivos defectuosos sin lanzar excepciones ni emitir advertencias cuando se encuentran.
Añadido en 4.2.0
- **kwargs (argumentos de palabra clave adicionales) —
Argumentos de palabra clave que se pasarán a
ParquetConfig.
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.
from_text
< source >( path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]]split: typing.Optional[datasets.splits.NamedSplit] = Nonefeatures: typing.Optional[datasets.features.features.Features] = Nonecache_dir: str = Nonekeep_in_memory: bool = Falsenum_proc: typing.Optional[int] = Nonekeep_linebreaks: bool = Falsesample_by: typing.Literal['line', 'paragraph', 'document'] = 'line'**kwargs )
Parámetros
- path_or_paths (
path-likeo lista depath-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 almacenar los datos en caché. - keep_in_memory (
bool, por defectoFalse) — Si se debe copiar los datos en memoria. - num_proc (
int, opcional, el valor predeterminado esNone) — 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.Añadido en 2.8.0
- 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.
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.
from_sql
< source >( 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] = Nonecache_dir: str = Nonekeep_in_memory: bool = False**kwargs )
Parámetros
- sql (
strosqlalchemy.sql.Selectable) — Consulta SQL a ejecutar o nombre de una tabla. - con (
strosqlite3.Connectionosqlalchemy.engine.Connectionosqlalchemy.engine.Connection) — Una cadena URI utilizada para instanciar una conexión a la base de datos o un objeto de conexión SQLite3/SQLAlchemy. - features (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 defectoFalse) — Si se debe copiar los datos en memoria. - **kwargs (argumentos de palabra clave adicionales) —
Argumentos de palabra clave que se pasarán a
SqlConfig.
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:
>>> # 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")El conjunto de datos devuelto solo se puede cachear si
conse especifica como una cadena URI.
align_labels_with_mapping
< source >( label2id: dictlabel_column: str )
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:
>>> # 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
< source >( dsets: listinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Noneaxis: int = 0 )
Parámetros
- dsets (
List[datasets.Dataset]oList[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 es0) — Eje sobre el que concatenar, donde0significa sobre filas (verticalmente) y1significa sobre columnas (horizontalmente).Añadido en 1.6.0
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_shardsdel conjunto de datos resultante es la suma de losnum_shardsde 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(), todos deben dividirse de la misma manera, y el conjunto de datos resultante conserva esa división.
datasets.interleave_datasets
< source >( datasets: listprobabilities: typing.Optional[list[float]] = Noneseed: typing.Optional[int] = Noneinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Nonestopping_strategy: typing.Literal['first_exhausted', 'all_exhausted', 'all_exhausted_without_replacement'] = 'first_exhausted' ) → Dataset or IterableDataset
Parámetros
- datasets (
List[Dataset]oList[IterableDataset]) — Lista de conjuntos de datos para intercalar. - probabilities (
List[float], opcional, valor predeterminadoNone) — 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 predeterminadoNone) — La semilla aleatoria utilizada para elegir una fuente para cada ejemplo. - info (DatasetInfo, opcional) —
Información del dataset, como la descripción, la cita, etc.
Añadido en 2.4.0
- split (NamedSplit, opcional) —
Nombre del split del dataset.
Añadido en 2.4.0
- stopping_strategy (
str, por defectofirst_exhausted) — Actualmente se proponen tres estrategias,first_exhausted,all_exhaustedyall_exhausted_without_replacement. Por defecto,first_exhaustedes 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 esall_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 esall_exhausted_without_replacementnos aseguramos de que cada muestra en cada conjunto de datos se muestree solo una vez. Tenga en cuenta que si la estrategia esall_exhausted, el tamaño del conjunto de datos intercalado puede volverse enorme:- sin probabilidades, el conjunto de datos resultante tendrá
max_length_datasets*nb_datasetmuestras. - con las probabilidades dadas, el conjunto de datos resultante tendrá más muestras si algunos conjuntos de datos tienen una probabilidad de visita realmente baja.
- sin probabilidades, el conjunto de datos resultante tendrá
Devuelve
El tipo de retorno depende del parámetro 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 o en una lista de objetos IterableDataset.
- Si
probabilitiesesNone(valor predeterminado), el nuevo conjunto de datos se construye alternando entre cada fuente para obtener los ejemplos. - Si
probabilitiesno esNone, 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_shardsdel dataset resultante es el mínimo de losnum_shardsde cada dataset para garantizar un buen paralelismo. Si algunos de tus datasets tienen un número muy bajo de shards, puedes usar IterableDataset.reshard(). - En una configuración distribuida o en los workers de PyTorch DataLoader, la estrategia de parada 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):
>>> 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
< source >( dataset: ~DatasetTyperank: intworld_size: intstrategy: typing.Literal['auto', 'shards', 'examples'] = 'auto' ) → Dataset or IterableDataset
Parámetros
- dataset (Dataset o 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 conjunto de datos iterable. Debe ser uno de"auto","shards"o"examples". Los conjuntos de datos de estilo mapa solo admiten"auto".
Devuelve
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, siempre que sea 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 deworld_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 deworld_size(es decir, sidataset.num_shards % world_size == 0), que es la opción más optimizada. En caso contrario, usa"examples".
Si barajas tu conjunto de datos iterable en una configuración distribuida, asegúrate de establecer una
seedfija en IterableDataset.shuffle() para que se utilice la misma lista barajada de fragmentos en cada nodo y se sepa qué fragmentos debe omitir el nodo.
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() para guardar un dataset transformado o se eliminará al cerrar la sesión
- La caché no afecta a load_dataset(). Si desea regenerar un conjunto de datos desde cero, debe utilizar el parámetro
download_modeen load_dataset().
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() para guardar un dataset transformado o se eliminará al cerrar la sesión
- La caché no afecta a load_dataset(). Si desea regenerar un conjunto de datos desde cero, debe utilizar el parámetro
download_modeen load_dataset().
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()] para guardar un dataset transformado, ya que se eliminará al cerrar la sesión
- La caché no afecta a load_dataset(). Si desea regenerar un conjunto de datos desde cero, debe utilizar el parámetro
download_modeen load_dataset().
clase datasets.Column
< source >( source: typing.Union[ForwardRef('Dataset'), ForwardRef('Column')]column_name: str )
Un iterable para una columna específica de un Dataset.
Ejemplo:
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.
Un diccionario (dict de str: datasets.Dataset) con los métodos de transformación de conjuntos de datos (map, filter, etc.)
Las tablas Apache Arrow que respaldan cada división.
Los archivos de caché que contienen la tabla Apache Arrow que respalda cada división.
Ejemplo:
>>> 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'}]}Número de columnas en cada división del conjunto de datos.
Número de filas en cada división del conjunto de datos.
Nombres de las columnas en cada división del conjunto de datos.
Forma de cada división del conjunto de datos (número de filas, número de columnas).
unique
< source >( column: str ) → Dict[str, list]
Parámetros
- column (
str) — nombre de la columna (muestra todos los nombres de columnas con 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.
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 asegurarte de que ningún otro proceso esté utilizando otros archivos de caché en ese momento.
map
< source >( function: typing.Optional[typing.Callable] = Nonewith_indices: bool = Falsewith_rank: bool = Falsewith_split: bool = Falseinput_columns: typing.Union[str, list[str], NoneType] = Nonebatched: bool = Falsebatch_size: typing.Optional[int] = 1000drop_last_batch: bool = Falseremove_columns: typing.Union[str, list[str], NoneType] = Nonekeep_in_memory: bool = Falseload_from_cache_file: typing.Optional[bool] = Nonecache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = Nonewriter_batch_size: typing.Optional[int] = 1000features: typing.Optional[datasets.features.features.Features] = Nonedisable_nullable: bool = Falsefn_kwargs: typing.Optional[dict] = Nonenum_proc: typing.Optional[int] = Nonedesc: typing.Optional[str] = Nonetry_original_type: typing.Optional[bool] = Trueon_mixed_types: typing.Optional[typing.Literal['use_json']] = None )
Parámetros
- function (
callable) — con una de las siguientes firmas:function(example: Dict[str, Any]) -> Dict[str, Any]sibatched=Falseywith_indices=Falsefunction(example: Dict[str, Any], indices: int) -> Dict[str, Any]sibatched=Falseywith_indices=Truefunction(batch: Dict[str, list]) -> Dict[str, list]sibatched=Trueywith_indices=Falsefunction(batch: Dict[str, list], indices: list[int]) -> Dict[str, list]sibatched=Trueywith_indices=True
Para un uso avanzado, la función también puede devolver una
pyarrow.Table. Si la función es asíncrona,mapejecutará su función en paralelo. Además, si su función no devuelve nada (None),mapejecutará 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 defectoFalse) — Proporciona índices de ejemplo afunction. Ten en cuenta que, en este caso, la firma defunctiondebe serdef function(example, idx): .... - with_rank (
bool, por defectoFalse) — Proporciona el rango del proceso afunction. Ten en cuenta que, en este caso, la firma defunctiondebe serdef function(example[, idx], rank): .... - with_split (
bool, por defectoFalse) — Proporciona la división del proceso afunction. Tenga en cuenta que en este caso la firma defunctiondebe serdef function(example[, idx], split): .... - input_columns (
[Union[str, list[str]]], opcional, valor predeterminadoNone) — Las columnas que se pasarán afunctioncomo argumentos posicionales. Si esNone, se pasa un diccionario que mapea a todas las columnas formateadas como un solo argumento. - batched (
bool, por defectoFalse) — Proporciona un lote de ejemplos afunction. - batch_size (
int, opcional, valor predeterminado1000) — Número de ejemplos por lote proporcionados afunctionsibatched=True, sibatch_size <= 0obatch_size == None, se proporciona el conjunto de datos completo como un único lote afunction. - drop_last_batch (
bool, por defectoFalse) — 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 predeterminadoNone) — Elimina una selección de columnas durante el mapeo. Las columnas se eliminarán antes de actualizar los ejemplos con la salida defunction, es decir, sifunctionestá añadiendo columnas con nombres enremove_columns, estas columnas se conservarán. - keep_in_memory (
bool, por defectoFalse) — Mantiene el conjunto de datos en memoria en lugar de escribirlo en un archivo de caché. - load_from_cache_file (
Optional[bool], por defectoTruesi la caché está habilitada) — Si se puede identificar un archivo de caché que almacena el cálculo actual defunction, úsese en lugar de recalcular. - cache_file_names (
[Dict[str, str]], opcional, valor predeterminadoNone) — Proporciona 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. Debes proporcionar uncache_file_namepor cada conjunto de datos en el diccionario de conjuntos de datos. - writer_batch_size (
int, valor predeterminado1000) — Número de filas por operación de escritura para el escritor del archivo 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 demap. - features (
[datasets.Features], opcional, valor predeterminadoNone) — Usa un Features específico para almacenar el archivo de caché en lugar del generado automáticamente. - disable_nullable (
bool, por defectoFalse) — No permite valores nulos en la tabla. - fn_kwargs (
Dict, opcional, por defectoNone) — Argumentos de palabra clave que se pasarán afunction - num_proc (
int, opcional, el valor predeterminado esNone) — El número de procesos a utilizar para la multiprocesamiento. Si es None o 0, no se utiliza multiprocesamiento 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 el multiprocesamiento funcione correctamente (es decir, se prefieren funciones definidas en el nivel superior de un módulo, no dentro de otra función o clase).- Si es
Noneo0, no se usa multiproceso 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 amap()debe ser serializable con pickle 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).
- Si es
- desc (
str, opcional, valor predeterminadoNone) — Descripción significativa que se mostrará junto con la barra de progreso mientras se mapean los ejemplos. - try_original_type (
Optional[bool], por defectoTrue) — Intenta mantener los tipos de las columnas originales (p. ej. int32 -> int32). Establece en False si deseas inferir siempre nuevos tipos. - on_mixed_types (
Literal["use_json"], opcional, por defectoNone) — Si se usa “use_json”, se emplea 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 cadenas/enteros/decimales, por ejemplo, o diccionarios con tipos de valores arbitrarios.
Añadido en 4.7.0
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. La transformación se aplica a todos los datasets del dataset dictionary.
Puede especificar si la función debe agruparse o no con el parámetro batched:
- Si
FalseesFalse, la función toma 1 ejemplo como entrada y debe devolver 1 ejemplo. Un ejemplo es un diccionario, p. ej.{"text": "Hello there !"}. - Si
Trueybatch_sizees 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
Trueybatch_sizeesn > 1, la función toma como entrada un lote denejemplos y puede devolver un lote connejemplos, o con un número arbitrario de ejemplos. Tenga en cuenta que el último lote puede tener menos denejemplos. Un lote es un diccionario, por ejemplo, un lote denejemplos 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:
>>> 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)filter
< source >( function: typing.Optional[typing.Callable] = Nonewith_indices: bool = Falsewith_rank: bool = Falseinput_columns: typing.Union[str, list[str], NoneType] = Nonebatched: bool = Falsebatch_size: typing.Optional[int] = 1000keep_in_memory: bool = Falseload_from_cache_file: typing.Optional[bool] = Nonecache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = Nonewriter_batch_size: typing.Optional[int] = 1000fn_kwargs: typing.Optional[dict] = Nonenum_proc: typing.Optional[int] = Nonedesc: typing.Optional[str] = None )
Parámetros
- function (
Callable) — Función con una de las siguientes firmas:function(example: Dict[str, Any]) -> boolsibatched=Falseywith_indices=Falseywith_rank=Falsefunction(example: Dict[str, Any], *extra_args) -> boolsibatched=Falseywith_indices=Truey/owith_rank=True(un argumento adicional por cada uno)function(batch: Dict[str, list]) -> list[bool]sibatched=Trueywith_indices=Falseywith_rank=Falsefunction(batch: Dict[str, list], *extra_args) -> list[bool]sibatched=Trueywith_indices=Truey/owith_rank=True(un argumento adicional 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 defectoFalse) — Proporciona índices de ejemplo afunction. Ten en cuenta que, en este caso, la firma defunctiondebe serdef function(example, idx[, rank]): .... - with_rank (
bool, por defectoFalse) — Proporciona el rango del proceso afunction. Ten en cuenta que, en este caso, la firma defunctiondebe serdef function(example[, idx], rank): .... - input_columns (
[Union[str, list[str]]], opcional, valor predeterminadoNone) — Las columnas que se pasarán afunctioncomo argumentos posicionales. Si esNone, se pasa un diccionario que mapea a todas las columnas formateadas como un solo argumento. - batched (
bool, por defectoFalse) — Proporciona un lote de ejemplos afunction. - batch_size (
int, opcional, valor predeterminado1000) — Número de ejemplos por lote proporcionados afunctionsibatched=Truebatch_size <= 0obatch_size == Noneentonces proporciona el conjunto de datos completo como un único lote afunction. - keep_in_memory (
bool, por defectoFalse) — Mantiene el conjunto de datos en memoria en lugar de escribirlo en un archivo de caché. - load_from_cache_file (
Optional[bool], por defectoTruesi la caché está habilitada) — Si se puede identificar un archivo de caché que almacena el cálculo actual defunction, úsese en lugar de recalcular. - cache_file_names (
[Dict[str, str]], opcional, valor predeterminadoNone) — Proporciona 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. Debes proporcionar uncache_file_namepor cada conjunto de datos en el diccionario de conjuntos de datos. - writer_batch_size (
int, por defecto1000) — Número de filas por operación de escritura para el escritor del archivo 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 demap. - fn_kwargs (
Dict, opcional, por defectoNone) — Argumentos de palabra clave que se pasarán afunction - num_proc (
int, opcional, el valor predeterminado esNone) — El número de procesos a utilizar para la multiprocesamiento. Si es None o 0, no se utiliza multiprocesamiento 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 el multiprocesamiento funcione correctamente (es decir, se prefieren funciones definidas en el nivel superior de un módulo, no dentro de otra función o clase).- Si es
Noneo0, no se usa multiproceso 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 amap()debe ser serializable con pickle 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).
- Si es
- desc (
str, opcional, valor predeterminadoNone) — 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:
>>> 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
< source >( column_names: typing.Union[str, collections.abc.Sequence[str]]reverse: typing.Union[bool, collections.abc.Sequence[bool]] = Falsenull_placement: str = 'at_end'keep_in_memory: bool = Falseload_from_cache_file: typing.Optional[bool] = Noneindices_cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = Nonewriter_batch_size: typing.Optional[int] = 1000 )
Parámetros
- column_names (
Union[str, Sequence[str]]) — Nombre(s) de columna(s) para ordenar. - reverse (
Union[bool, Sequence[bool]], por defectoFalse) — Si esTrue, 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 defectoat_end) — Coloca los valoresNoneal principio si esat_startofirst, o al final si esat_endolast - keep_in_memory (
bool, por defectoFalse) — Mantener los índices ordenados en memoria en lugar de escribirlos en un archivo de caché. - load_from_cache_file (
Optional[bool], por defectoTruesi la caché está habilitada) — Si se puede identificar un archivo de caché que almacena los índices ordenados, úsese en lugar de recalcularlos. - indices_cache_file_names (
[Dict[str, str]], opcional, valor predeterminadoNone) — Proporciona 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. Debes proporcionar uncache_file_namepor cada conjunto de datos en el diccionario de conjuntos de datos. - writer_batch_size (
int, por defecto1000) — Número de filas por operación de escritura para el escritor del archivo de caché. Un valor más alto produce 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:
>>> 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
< source >( seeds: typing.Union[int, dict[str, typing.Optional[int]], NoneType] = Noneseed: typing.Optional[int] = Nonegenerators: typing.Optional[dict[str, numpy.random._generator.Generator]] = Nonekeep_in_memory: bool = Falseload_from_cache_file: typing.Optional[bool] = Noneindices_cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = Nonewriter_batch_size: typing.Optional[int] = 1000 )
Parámetros
- seeds (
Dict[str, int]oint, opcional) — Una semilla para inicializar el BitGenerator predeterminado sigenerator=None. Si esNone, se extraerá entropía fresca e impredecible del sistema operativo. Si se pasa uninto unarray_like[ints], se pasará a SeedSequence para derivar el estado inicial del BitGenerator. Puede proporcionar unaseedpor conjunto de datos en el diccionario de conjuntos de datos. - seed (
int, opcional) — Una semilla para inicializar el BitGenerator predeterminado sigenerator=None. Alias de seeds (se lanza unValueErrorsi 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. Sigenerator=None(predeterminado), se utilizanp.random.default_rng(el BitGenerator predeterminado (PCG64) de NumPy). Debe proporcionar ungeneratorpor cada conjunto de datos en el diccionario de conjuntos de datos. - keep_in_memory (
bool, por defectoFalse) — Mantiene el conjunto de datos en memoria en lugar de escribirlo en un archivo de caché. - load_from_cache_file (
Optional[bool], por defectoTruesi la caché está habilitada) — Si se puede identificar un archivo de caché que almacena el cálculo actual defunction, úsese en lugar de recalcular. - indices_cache_file_names (
Dict[str, str], opcional) — Proporciona 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. Debes proporcionar uncache_file_namepor cada conjunto de datos en el diccionario de conjuntos de datos. - writer_batch_size (
int, por defecto1000) — Número de filas por operación de escritura para el escritor del archivo 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 demap.
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).
set_format
< source >( type: typing.Optional[str] = Nonecolumns: typing.Optional[list] = Noneoutput_all_columns: bool = False**format_kwargs )
Parámetros
- type (
str, opcional) — Tipo de salida seleccionado en[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars'].Nonesignifica que__getitem__devuelve objetos de python (valor predeterminado). - columns (
list[str], opcional) — Columnas a formatear en la salida.Nonesignifica que__getitem__devuelve todas las columnas (predeterminado). - output_all_columns (
bool, predeterminado en False) — Mantener también las columnas sin formatear 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.tensorotensorflow.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:
>>> 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'}Restablecer 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:
>>> 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
< source >( type: typing.Optional[str] = Nonecolumns: typing.Optional[list] = Noneoutput_all_columns: bool = False**format_kwargs )
Parámetros
- type (
str, opcional) — Tipo de salida seleccionado en[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars'].Nonesignifica que__getitem__devuelve objetos de python (valor predeterminado). - columns (
list[str], opcional) — Columnas a formatear en la salida.Nonesignifica que__getitem__devuelve todas las columnas (predeterminado). - output_all_columns (
bool, predeterminado en False) — Mantener también las columnas sin formatear 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.tensorotensorflow.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
< source >( type: typing.Optional[str] = Nonecolumns: typing.Optional[list] = Noneoutput_all_columns: bool = False**format_kwargs )
Parámetros
- type (
str, opcional) — Tipo de salida seleccionado en[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars'].Nonesignifica que__getitem__devuelve objetos de python (valor predeterminado). - columns (
list[str], opcional) — Columnas a formatear en la salida.Nonesignifica que__getitem__devuelve todas las columnas (predeterminado). - output_all_columns (
bool, por defectoFalse) — Mantener también las columnas sin formatear 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.tensorotensorflow.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().
A diferencia de set_format(), with_format devuelve un nuevo objeto DatasetDict con nuevos objetos Dataset.
Ejemplo:
>>> 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
< source >( transform: typing.Optional[typing.Callable]columns: typing.Optional[list] = Noneoutput_all_columns: bool = False )
Parámetros
- transform (
Callable, opcional) — Transformación de formato definida por el usuario, reemplaza el formato definido por 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 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, predeterminado en False) — Mantiene también las columnas sin formatear en la salida (como objetos de python). Si se establece enTrue, las demás columnas sin formatear 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__.
La transformación se establece para cada conjunto de datos en el diccionario de conjuntos de datos
Al igual que set_format(), esto se puede restablecer usando reset_format().
A diferencia de set_transform(), with_transform devuelve un nuevo objeto DatasetDict con nuevos objetos Dataset.
Ejemplo:
>>> 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])}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 dejan sin cambios.
Ejemplo:
>>> 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
< source >( features: Features )
Parámetros
- features (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() 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:
>>> 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
< source >( column: strfeature )
Castea la columna a característica para la decodificación.
Ejemplo:
>>> 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
< source >( column_names: typing.Union[str, list[str]] ) → DatasetDict
Parámetros
Devuelve
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() 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:
>>> 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
< source >( original_column_name: strnew_column_name: str )
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() 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 dataset y, por lo tanto, es mucho más rápido.
Ejemplo:
>>> 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
< source >( column_mapping: dict ) → DatasetDict
Parámetros
Devuelve
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:
>>> 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
< source >( column_names: typing.Union[str, list[str]] )
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 del conjunto de datos.
Ejemplo:
>>> 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
< source >( column: strinclude_nulls: bool = False )
Convierte la columna indicada en ClassLabel y actualiza las tablas.
Ejemplo:
>>> 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
< source >( repo_id: strconfig_name: str = 'default'set_default: typing.Optional[bool] = Nonedata_dir: typing.Optional[str] = Nonecommit_message: typing.Optional[str] = Nonecommit_description: typing.Optional[str] = Noneprivate: typing.Optional[bool] = Nonetoken: typing.Optional[str] = Nonerevision: typing.Optional[str] = Nonecreate_pr: typing.Optional[bool] = Falsemax_shard_size: typing.Union[str, int, NoneType] = Nonenum_shards: typing.Optional[dict[str, int]] = Noneembed_external_files: bool = Truenum_proc: typing.Optional[int] = None )
Parámetros
- repo_id (
str) — El ID del repositorio al que se enviarán los datos, en el siguiente formato:<user>/<dataset_name>o<org>/<dataset_name>. También acepta<dataset_name>, que usará el espacio de nombres del usuario conectado por defecto.También podría ser una ubicación dentro de un bucket, p. ej.
buckets/<user_or_org>/<bucket_name>/... - config_name (
str) — Nombre de la configuración de un conjunto de datos. El valor predeterminado es “default”. - set_default (
bool, opcional) — Si se debe establecer esta configuración como la predeterminada. De lo contrario, la configuración predeterminada es la que se llama “default”. - data_dir (
str, opcional) — Nombre del directorio que contendrá los archivos de datos cargados. El valor predeterminado esconfig_namesi es diferente de «default», en caso contrario, «data».Añadido en 2.17.0
- commit_message (
str, opcional) — Mensaje para el commit al hacer push. El valor predeterminado es"Upload dataset". - commit_description (
str, opcional) — Descripción del commit que se creará. Además, descripción del PR si se crea un PR (create_pres True).Añadido en 2.16.0
- private (
bool, opcional) — Si se debe hacer el repositorio privado. Si esNone(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 conhf 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. El valor predeterminado es la rama"main".Añadido en 2.15.0
- create_pr (
bool, opcional, por defectoFalse) — Si se debe crear una PR con los archivos subidos o realizar un commit directamente.Añadido en 2.15.0
- max_shard_size (
intostr, 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 shards a escribir. De forma predeterminada, el número de shards depende demax_shard_size. Usa un diccionario para definir un num_shards diferente para cada split.Añadido en 2.8.0
- embed_external_files (
bool, por defecto esTrue) — Si se incrustan los bytes de los archivos en los fragmentos. En particular, antes de la publicación, esto hará lo siguiente para los campos de tipo: - num_proc (
int, opcional, por defectoNone) — 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. Utiliza el contexto “spawn” para funcionar con hf_xet, el cliente de Rust para subidas rápidas a HF. La multiprocesación está deshabilitada por defecto.Añadido en 4.0.0
Envía el DatasetDict al hub como un conjunto de datos Parquet. El 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 o 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:
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>")
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", private=True)
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", max_shard_size="1GB")
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", 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):
>>> english_dataset.push_to_hub("<organization>/<dataset_id>", "en")
>>> french_dataset.push_to_hub("<organization>/<dataset_id>", "fr")
>>> # later
>>> english_dataset = load_dataset("<organization>/<dataset_id>", "en")
>>> french_dataset = load_dataset("<organization>/<dataset_id>", "fr")save_to_disk
< source >( dataset_dict_path: typing.Union[str, bytes, os.PathLike]max_shard_size: typing.Union[str, int, NoneType] = Nonenum_shards: typing.Optional[dict[str, int]] = Nonenum_proc: typing.Optional[int] = Nonestorage_options: typing.Optional[dict] = None )
Parámetros
- dataset_dict_path (
path-like) — Ruta (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 (
intostr, 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 shards a escribir. Por defecto, el número de shards depende demax_shard_sizeynum_proc. Debe proporcionar el número de shards para cada dataset en el diccionario de datasets. Use un diccionario para definir un num_shards diferente para cada split.Añadido en 2.8.0
- num_proc (
int, opcional, predeterminadoNone) — Número de procesos al descargar y generar el dataset localmente. La multiprocesación está deshabilitada de forma predeterminada.Añadido en 2.8.0
- storage_options (
dict, opcional) — Pares clave/valor que se pasarán al backend del sistema de archivos, si lo hay.Añadido en 2.8.0
Guarda un diccionario de datos en un sistema de archivos usando fsspec.spec.AbstractFileSystem.
Para datos de Image, Audio y 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”).
load_from_disk
< source >( dataset_dict_path: typing.Union[str, bytes, os.PathLike]keep_in_memory: typing.Optional[bool] = Nonestorage_options: typing.Optional[dict] = None )
Parámetros
- dataset_dict_path (
path-like) — Ruta (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 defectoNone) — Si se debe copiar el conjunto de datos en memoria. Si esNone, el conjunto de datos no se copiará en memoria a menos que se habilite explícitamente estableciendodatasets.config.IN_MEMORY_MAX_SIZEen un valor distinto de cero. Más detalles en la sección mejorar el rendimiento. - storage_options (
dict, opcional) — Pares clave/valor que se pasarán al backend del sistema de archivos, si lo hay.Añadido en 2.8.0
Cargue un conjunto de datos que se guardó previamente en un sistema de archivos con save_to_disk usando fsspec.spec.AbstractFileSystem.
from_csv
< source >( path_or_paths: dictfeatures: typing.Optional[datasets.features.features.Features] = Nonecache_dir: str = Nonekeep_in_memory: bool = False**kwargs )
Parámetros
- path_or_paths (
dictde path-like) — Ruta(s) del archivo(s) CSV. - features (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 defectoFalse) — 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.
Crea un DatasetDict a partir de archivo(s) CSV.
from_json
< source >( path_or_paths: dictfeatures: typing.Optional[datasets.features.features.Features] = Nonecache_dir: str = Nonekeep_in_memory: bool = False**kwargs )
Parámetros
- path_or_paths (
path-likeo lista depath-like) — Ruta(s) del archivo(s) JSON Lines. - features (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 defectoFalse) — Si se debe copiar los datos en memoria. - **kwargs (argumentos de palabra clave adicionales) —
Argumentos de palabra clave que se pasarán a
JsonConfig.
Crea DatasetDict a partir de archivo(s) JSON Lines.
from_parquet
< source >( path_or_paths: dictfeatures: typing.Optional[datasets.features.features.Features] = Nonecache_dir: str = Nonekeep_in_memory: bool = Falsecolumns: typing.Optional[list[str]] = None**kwargs )
Parámetros
- path_or_paths (
dictde path-like) — Ruta(s) del archivo(s) CSV. - features (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 defectoFalse) — Si se debe copiar los datos en memoria. - columns (
list[str], opcional) — Si no esNone, 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.
Crea un DatasetDict a partir de archivo(s) Parquet.
from_text
< source >( path_or_paths: dictfeatures: typing.Optional[datasets.features.features.Features] = Nonecache_dir: str = Nonekeep_in_memory: bool = False**kwargs )
Parámetros
- path_or_paths (
dictde path-like) — Ruta(s) del archivo(s) de texto. - features (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 defectoFalse) — Si se debe copiar los datos en memoria. - **kwargs (argumentos de palabra clave adicionales) —
Argumentos de palabra clave que se pasarán a
TextConfig.
Crea un DatasetDict a partir de archivo(s) de texto.
IterableDataset
La clase base IterableDataset implementa un Dataset iterable basado en generadores de python.
clase datasets.IterableDataset
< source >( ex_iterable: _BaseExamplesIterableinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Noneformatting: typing.Optional[datasets.iterable_dataset.FormattingConfig] = Nonedistributed: typing.Optional[datasets.iterable_dataset.DistributedConfig] = Nonetoken_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None )
Un Dataset respaldado por un iterable.
from_file
< source >( filename: str )
Instancia un IterableDataset desde una tabla Arrow en el archivo con el nombre especificado.
from_pandas
< source >( df: DataFramefeatures: typing.Optional[datasets.features.features.Features] = Noneinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Nonepreserve_index: typing.Optional[bool] = Nonenum_shards: typing.Optional[int] = 1 )
Parámetros
- df (
pandas.DataFrame) — Dataframe que contiene el conjunto de datos. - 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. - preserve_index (
bool, opcional) — Si se debe almacenar el índice como una columna adicional en el Dataset resultante. El valor predeterminado deNonealmacenará el índice como una columna, excepto paraRangeIndex, que se almacena solo como metadatos. Usapreserve_index=Truepara forzar que se almacene como una columna. - num_shards (
int, por defecto1) — Número de shards que se definen 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.
Convierta pandas.DataFrame en una pyarrow.Table para crear un IterableDataset.
Los tipos de columna en la Tabla Arrow resultante se infieren a partir de los dtypes de los 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 determinar 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.
from_dict
< source >( mapping: dictfeatures: typing.Optional[datasets.features.features.Features] = Noneinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Nonenum_shards: typing.Optional[int] = 1 )
Parámetros
- mapping (
Mapping) — Mapeo de cadenas a Arrays o listas de Python. - 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 defecto1) — Número de shards que se definen 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.
Convierta dict en una pyarrow.Table para crear un 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 usando, por ejemplo, to_parquet / from_parquet.
from_list
< source >( mapping: listfeatures: typing.Optional[datasets.features.features.Features] = Noneinfo: typing.Optional[datasets.info.DatasetInfo] = Nonesplit: typing.Optional[datasets.splits.NamedSplit] = Nonenum_shards: typing.Optional[int] = 1 )
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 defecto1) — Número de shards que se definen 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.
Convierta una lista de diccionarios en una pyarrow.Table para crear un 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
< source >( generator: typing.Callablefeatures: typing.Optional[datasets.features.features.Features] = Nonegen_kwargs: typing.Optional[dict] = Nonesplit: NamedSplit = NamedSplit('train') )
Parámetros
- generator (
Callable) — Una función generadora queyieldsejemplos. - features (
Features, opcional) — Características del conjunto de datos. - gen_kwargs(
dict, opcional) — Argumentos de palabra clave que se pasarán al objeto invocablegenerator. Puede definir un conjunto de datos iterable fragmentado pasando la lista de fragmentos engen_kwargs. Esto se puede usar para mejorar el barajado y al iterar sobre el conjunto de datos con múltiples trabajadores. - split (NamedSplit, por defecto es
Split.TRAIN) — Nombre de la división que se asignará al conjunto de datos.Añadido en 2.21.0
Crea un Iterable Dataset a partir de un generador.
Ejemplo:
>>> def gen():
... yield {"text": "Good", "label": 0}
... yield {"text": "Bad", "label": 1}
...
>>> ds = IterableDataset.from_generator(gen)>>> 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 shardsremove_columns
< source >( column_names: typing.Union[str, list[str]] ) → IterableDataset
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:
>>> 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
< source >( column_names: typing.Union[str, list[str]] ) → IterableDataset
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:
>>> 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
< source >( column: strfeature: 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] ) → IterableDataset
Castea la columna a característica para la decodificación.
Ejemplo:
>>> 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
< source >( features: Features ) → IterableDataset
Parámetros
- features (Features) —
Nuevas características a las que 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() 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:
>>> 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
< source >( enable: bool = Truenum_threads: typing.Optional[int] = None ) → IterableDataset
Parámetros
- enable (
bool, por defectoTrue) — Activa o desactiva la decodificación de características. - num_threads (
int, opcional, valor predeterminadoNone) — Habilita la multihilo para la decodificación de características. Tenga en cuenta que 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_threadsse 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() 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 deseas iterar sobre las rutas o los bytes de los archivos multimedia sin decodificar realmente su contenido. Para desactivar la decodificación puedes 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:
>>> from datasets import load_dataset
>>> ds = load_dataset("sshh12/planet-textures", split="train", streaming=True)
>>> next(iter(ds))
{'image': <PIL.PngImagePlugin.PngImageFile image mode=RGB size=2048x1024>,
'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:
>>> 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
< source >( batch_size: intdrop_last_batch: bool = False )
Itera sobre los lotes de tamaño batch_size.
map
< source >( function: typing.Optional[typing.Callable] = Nonewith_indices: bool = Falseinput_columns: typing.Union[str, list[str], NoneType] = Nonebatched: bool = Falsebatch_size: typing.Optional[int] = 1000drop_last_batch: bool = Falseremove_columns: typing.Union[str, list[str], NoneType] = Nonefeatures: typing.Optional[datasets.features.features.Features] = Nonefn_kwargs: typing.Optional[dict] = None )
Parámetros
- function (
Callable, opcional, por defectoNone) — Función aplicada al vuelo a los ejemplos al iterar sobre el conjunto de datos. Debe tener una de las siguientes firmas:function(example: Dict[str, Any]) -> Dict[str, Any]sibatched=Falseywith_indices=Falsefunction(example: Dict[str, Any], idx: int) -> Dict[str, Any]sibatched=Falseywith_indices=Truefunction(batch: Dict[str, List]) -> Dict[str, List]sibatched=Trueywith_indices=Falsefunction(batch: Dict[str, List], indices: List[int]) -> Dict[str, List]sibatched=Trueywith_indices=True
Para un uso avanzado, la función también puede devolver una
pyarrow.Table. Si la función es asíncrona,mapejecutará su función en paralelo. Además, si su función no devuelve nada (None),mapejecutará 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 defectoFalse) — Proporciona índices de ejemplo afunction. Ten en cuenta que, en este caso, la firma defunctiondebe serdef function(example, idx[, rank]): .... - input_columns (
Optional[Union[str, List[str]]], por defectoNone) — Las columnas que se pasarán afunctioncomo argumentos posicionales. Si esNone, se pasa un diccionario que mapea a todas las columnas formateadas como un solo argumento. - batched (
bool, por defectoFalse) — Proporciona un lote de ejemplos afunction. - batch_size (
int, opcional, valor predeterminado1000) — Número de ejemplos por lote proporcionados afunctionsibatched=True. Sibatch_size <= 0obatch_size == None, se proporciona el conjunto de datos completo como un único lote afunction. - drop_last_batch (
bool, por defectoFalse) — 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 predeterminadoNone) — Elimina una selección de columnas durante el mapeo. Las columnas se eliminarán antes de actualizar los ejemplos con la salida defunction, es decir, sifunctionestá añadiendo columnas con nombres enremove_columns, estas columnas se conservarán. - features (
[Features], opcional, valor predeterminadoNone) — Tipos de características del conjunto de datos resultante. - fn_kwargs (
Dict, opcional, valor predeterminadoNone) — Argumentos de palabra clave que se pasarán afunction.
Aplica una función a todos los ejemplos del dataset iterable (de forma individual o en lotes) y los actualiza. Si tu 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
FalseesFalse, la función toma 1 ejemplo como entrada y debe devolver 1 ejemplo. Un ejemplo es un diccionario, p. ej.{"text": "Hello there !"}. - If batched is
Trueandbatch_sizeis 1, then the function takes a batch of 1 example as input and can return a batch with 1 or more examples. A batch is a dictionary, e.g. a batch of 1 example is {“text”: [“Hello there !”]}. - Si
Trueybatch_sizeesn> 1, la función toma como entrada un lote denejemplos y puede devolver un lote connejemplos, o con un número arbitrario de ejemplos. Tenga en cuenta que el último lote puede tener menos denejemplos. Un lote es un diccionario, por ejemplo, un lote denejemplos 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:
>>> 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
< source >( original_column_name: strnew_column_name: str ) → IterableDataset
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:
>>> 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 .'}filter
< source >( function: typing.Optional[typing.Callable] = Nonewith_indices = Falseinput_columns: typing.Union[str, list[str], NoneType] = Nonebatched: bool = Falsebatch_size: typing.Optional[int] = 1000fn_kwargs: typing.Optional[dict] = None )
Parámetros
- function (
Callable) — Función con una de las siguientes firmas:function(example: Dict[str, Any]) -> boolsiwith_indices=False, batched=Falsefunction(example: Dict[str, Any], indices: int) -> boolsiwith_indices=True, batched=Falsefunction(example: Dict[str, List]) -> List[bool]siwith_indices=False, batched=Truefunction(example: Dict[str, List], indices: List[int]) -> List[bool]siwith_indices=True, batched=True
Si la función es asíncrona,
filterejecutará 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 defectoFalse) — Proporciona índices de ejemplo afunction. Ten en cuenta que, en este caso, la firma defunctiondebe serdef function(example, idx): .... - input_columns (
stroList[str], opcional) — Las columnas que se pasarán afunctioncomo argumentos posicionales. Si esNone, se pasa un diccionario con todas las columnas formateadas como un solo argumento. - batched (
bool, por defectoFalse) — Proporciona un lote de ejemplos afunction. - batch_size (
int, opcional, valor predeterminado1000) — Número de ejemplos por lote proporcionados afunctionsibatched=True. - fn_kwargs (
Dict, opcional, valor predeterminadoNone) — Argumentos de palabra clave que se pasarán afunction.
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 hasta 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:
>>> 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
< source >( seed = Nonegenerator: typing.Optional[numpy.random._generator.Generator] = Nonebuffer_size: int = 1000max_buffer_input_shards: int = 10 )
Parámetros
- seed (
int, opcional, valor predeterminadoNone) — Semilla aleatoria que se utilizará para barajar el conjunto de datos. Se utiliza para muestrear desde el 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. Sigenerator=None(predeterminado), usanp.random.default_rng(el BitGenerator predeterminado (PCG64) de NumPy). - buffer_size (
int, por defecto1000) — Tamaño del búfer. - max_buffer_input_shards (
int, por defecto10) — Número máximo de shards para alimentar el buffer 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 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 del barajado.
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() o 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:
>>> 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}]lote
< source >( batch_size: typing.Optional[int] = Noneby_column: typing.Union[str, list[str], NoneType] = Nonedrop_last_batch: bool = False )
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 se 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.Añadido en 4.9.0
- drop_last_batch (
bool, por defectoFalse) — Si se debe descartar el último lote incompleto.
Agrupa las muestras del conjunto de datos en lotes.
Ejemplo:
Cree un nuevo IterableDataset que omita los primeros n elementos.
Ejemplo:
>>> 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 .'}]Cree un nuevo IterableDataset con solo los primeros n elementos.
Ejemplo:
>>> 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
< source >( num_shards: intindex: intcontiguous: bool = True )
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).
Es preferible que el operador de particionado se use al inicio de la tubería de datos.
Ejemplo:
>>> 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
})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).
Es mejor usar el operador de división al principio de la tubería de datos.
Ejemplo:
>>> 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
})repeat
< source >( num_times: typing.Optional[int] )
Cree un nuevo 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 shards 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:
>>> 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
< source >( path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO]batch_size: typing.Optional[int] = Nonestorage_options: typing.Optional[dict] = None**to_csv_kwargs ) → int
Parámetros
- path_or_buf (
PathLikeoFileOrBuffer) — 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 que se cargará en memoria y se escribirá de una vez. Por defecto,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_csvde pandas. El parámetroindextiene un valor predeterminado deFalsesi no se especifica. Si desea escribir el índice, paseindex=Truey también establezca un nombre para la columna de índice pasandoindex_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.
to_pandas
< source >( batch_size: typing.Optional[int] = Nonebatched: bool = False )
Parámetros
- batch_size (
int, opcional) — El tamaño (número de filas) de los lotes sibatchedesTrue. Por defecto,datasets.config.DEFAULT_MAX_BATCH_SIZE. - batched (
bool) — EstablezcaTruepara devolver un generador que produce el conjunto de datos en lotes debatch_sizefilas. El valor predeterminado esFalse(devuelve todo el conjunto de datos de una sola vez).
Devuelve el conjunto de datos como un pandas.DataFrame. También puede devolver un generador para conjuntos de datos grandes.
to_dict
< source >( batch_size: typing.Optional[int] = Nonebatched: bool = False )
Devuelve el conjunto de datos como un diccionario de Python. También puede devolver un generador para conjuntos de datos grandes.
to_json
< source >( path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO]batch_size: typing.Optional[int] = Nonestorage_options: typing.Optional[dict] = None**to_json_kwargs ) → int
Parámetros
- path_or_buf (
PathLikeoFileOrBuffer) — 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 que se cargará en memoria y se escribirá de una vez. Por defecto,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 (argumentos de palabra clave adicionales) —
Parámetros para pasar a
pandas.DataFrame.to_jsonde pandas. Los argumentos predeterminados sonlines=Trueyorient="records". The parameterindexdefaults toFalseiforientis“split”or“table”. If you would like to write the index, passindex=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.
Para exportar a JSON, pase el argumento lines=False y el orient deseado.
to_parquet
< source >( path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO]batch_size: typing.Optional[int] = Nonestorage_options: typing.Optional[dict] = None**parquet_writer_kwargs ) → int
Parámetros
- path_or_buf (
PathLikeoFileOrBuffer) — 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 que se cargará en memoria y se escribirá de una vez. Por defecto,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.Añadido en 2.19.0
- **parquet_writer_kwargs (argumentos de palabra clave adicionales) —
Parámetros para pasar a
pyarrow.parquet.ParquetWriterde PyArrow.
Devuelve
int
El número de caracteres o bytes escritos.
Exporta el conjunto de datos a parquet
to_sql
< source >( name: strcon: typing.Union[str, ForwardRef('sqlalchemy.engine.Connection'), ForwardRef('sqlalchemy.engine.Engine'), ForwardRef('sqlite3.Connection')]batch_size: typing.Optional[int] = None**sql_writer_kwargs ) → int
Parámetros
- name (
str) — Nombre de la tabla SQL. - con (
strosqlite3.Connectionosqlalchemy.engine.Connectionosqlalchemy.engine.Connection) — Una cadena URI o un objeto de conexión SQLite3/SQLAlchemy utilizado para escribir en una base de datos. - batch_size (
int, opcional) — Tamaño del lote que se cargará en memoria y se escribirá de una vez. Por defecto,datasets.config.DEFAULT_MAX_BATCH_SIZE. - **sql_writer_kwargs (argumentos de palabra clave adicionales) —
Parámetros para pasar a
pandas.DataFrame.to_sqlde pandas. El parámetroindextiene un valor predeterminado deFalsesi no se especifica. Si desea escribir el índice, paseindex=Truey también establezca un nombre para la columna de índice pasandoindex_label.
Devuelve
int
El número de registros escritos.
Exporta el conjunto de datos a una base de datos SQL.
push_to_hub
< source >( repo_id: strconfig_name: str = 'default'set_default: typing.Optional[bool] = Nonesplit: typing.Optional[str] = Nonedata_dir: typing.Optional[str] = Nonecommit_message: typing.Optional[str] = Nonecommit_description: typing.Optional[str] = Noneprivate: typing.Optional[bool] = Nonetoken: typing.Optional[str] = Nonerevision: typing.Optional[str] = Nonecreate_pr: typing.Optional[bool] = Falsemax_shard_size: typing.Union[str, int, NoneType] = Nonenum_shards: typing.Optional[int] = Noneembed_external_files: bool = Truenum_proc: typing.Optional[int] = None )
Parámetros
- repo_id (
str) — El ID del repositorio al que se enviarán los datos, en el siguiente formato:<user>/<dataset_name>o<org>/<dataset_name>. También acepta<dataset_name>, que usará el espacio de nombres del usuario conectado por defecto.También podría ser una ubicación dentro de un bucket, p. ej.
buckets/<user_or_org>/<bucket_name>/... - 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 debe establecer esta configuración como la predeterminada. De lo contrario, la configuración predeterminada es la que se llama “default”. - split (
str, opcional) — El nombre de la división que se asignará a ese conjunto de datos. El valor predeterminado esself.split. - data_dir (
str, opcional) — Nombre del directorio que contendrá los archivos de datos subidos. El valor predeterminado esconfig_namesi es diferente de “default”; en caso contrario, “data”. - commit_message (
str, opcional) — Mensaje para el commit al hacer push. El valor predeterminado es"Upload dataset". - commit_description (
str, opcional) — Descripción del commit que se creará. Además, descripción del PR si se crea un PR (create_pres True). - private (
bool, opcional) — Si se debe hacer el repositorio privado. Si esNone(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 conhf 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, valor predeterminadoFalse) — Si se debe crear una PR con los archivos subidos o realizar el commit directamente. - max_shard_size (
intostr, 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 será el.num_shardsde este conjunto de datos. - num_shards (
int, opcional) — Número de shards a escribir. Si se proporcionamax_shard_sizey no se proporcionanum_shards, el número de shards se estima a partir demax_shard_size. Puede ser mayor que.num_shardsde este conjunto de datos: en ese caso, cada shard de entrada se distribuye en varios shards de salida escribiendo sus ejemplos en ellos de forma round-robin. - embed_external_files (
bool, por defecto esTrue) — Si se incrustan los bytes de los archivos en los fragmentos. En particular, antes de la publicación, esto hará lo siguiente para los campos de tipo: - num_proc (
int, opcional, valor predeterminadoNone) — 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 y transformaciones. Utiliza el contexto “spawn” para trabajar con hf_xet, el cliente de rust para subidas rápidas a HF. La multiprocesación está deshabilitada de forma predeterminada.
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 de forma predeterminada. Si su conjunto de datos contiene datos de Image, Audio o 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:
>>> dataset.push_to_hub("<organization>/<dataset_id>")
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", private=True)
>>> dataset.push_to_hub("<organization>/<dataset_id>", max_shard_size="1GB")
>>> dataset.push_to_hub("<organization>/<dataset_id>", num_shards=1024)Si su conjunto de datos tiene varias divisiones (p. ej., entrenamiento/validación/prueba):
>>> train_dataset.push_to_hub("<organization>/<dataset_id>", split="train")
>>> val_dataset.push_to_hub("<organization>/<dataset_id>", split="validation")
>>> # later
>>> dataset = load_dataset("<organization>/<dataset_id>")
>>> 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):
>>> english_dataset.push_to_hub("<organization>/<dataset_id>", "en")
>>> french_dataset.push_to_hub("<organization>/<dataset_id>", "fr")
>>> # later
>>> english_dataset = load_dataset("<organization>/<dataset_id>", "en")
>>> french_dataset = load_dataset("<organization>/<dataset_id>", "fr")Cargue el state_dict del conjunto de datos. La iteración se reiniciará 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:
- los ejemplos de los búferes de barajado se pierden al reanudar y los búferes se rellenan con nuevos datos
- Las combinaciones de
.with_format(arrow)y.map()por lotes pueden omitir un lote.
Ejemplo:
>>> 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}>>> 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 hoodObtiene el state_dict actual del conjunto de datos. 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:
- los ejemplos de los búferes de barajado se pierden al reanudar y los búferes se rellenan con nuevos datos
- Las combinaciones de
.with_format(arrow)y.map()por lotes pueden omitir un lote.
Ejemplo:
>>> 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}>>> 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 hoodObjeto DatasetInfo que contiene todos los metadatos del conjunto de datos.
objeto NamedSplit correspondiente a una división de datos con nombre.
from_csv
< source >( path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]]split: typing.Optional[datasets.splits.NamedSplit] = Nonefeatures: typing.Optional[datasets.features.features.Features] = Nonekeep_in_memory: bool = False**kwargs )
Parámetros
- path_or_paths (
path-likeo lista depath-like) — Ruta(s) del archivo(s) CSV. - 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 defectoFalse) — 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.
Crea un IterableDataset a partir de archivo(s) CSV.
from_json
< source >( path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]]split: typing.Optional[datasets.splits.NamedSplit] = Nonefeatures: typing.Optional[datasets.features.features.Features] = Nonekeep_in_memory: bool = Falsefield: typing.Optional[str] = None**kwargs )
Parámetros
- path_or_paths (
path-likeo lista depath-like) — Ruta(s) del archivo o archivos JSON o JSON Lines. - 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 defectoFalse) — 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.
Crea un IterableDataset a partir de uno o varios archivos JSON o JSON Lines.
from_parquet
< source >( path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]]split: typing.Optional[datasets.splits.NamedSplit] = Nonefeatures: typing.Optional[datasets.features.features.Features] = Nonekeep_in_memory: bool = Falsecolumns: typing.Optional[list[str]] = Nonefilters: typing.Union[pyarrow._compute.Expression, list[tuple], list[list[tuple]], NoneType] = Nonefragment_scan_options: typing.Optional[pyarrow._dataset_parquet.ParquetFragmentScanOptions] = Noneon_bad_files: typing.Literal['error', 'warn', 'skip'] = 'error'**kwargs )
Parámetros
- path_or_paths (
path-likeo lista depath-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 defectoFalse) — Si se debe copiar los datos en memoria. - columns (
List[str], opcional) — Si no esNone, 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 delega 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. En caso contrario, filtra los RecordBatches cargados antes de devolverlos. - fragment_scan_options (
pyarrow.dataset.ParquetFragmentScanOptions, opcional) — Opciones específicas de escaneo para fragmentos Parquet. Esto es especialmente útil para configurar el almacenamiento en búfer y la caché.Añadido en 4.2.0
- on_bad_files (
Literal["error", "warn", "skip"], opcional, el valor predeterminado es “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 incorrecto.
- ‘warn’, emitir una advertencia cuando se encuentra un archivo incorrecto y omitir ese archivo.
- ‘skip’, omite los archivos defectuosos sin lanzar excepciones ni emitir advertencias cuando se encuentran.
Añadido en 4.2.0
- **kwargs (argumentos de palabra clave adicionales) —
Argumentos de palabra clave que se pasarán a
ParquetConfig.
Crea un IterableDataset a partir de archivo(s) Parquet.
from_text
< source >( path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]]split: typing.Optional[datasets.splits.NamedSplit] = Nonefeatures: typing.Optional[datasets.features.features.Features] = Nonekeep_in_memory: bool = Falsekeep_linebreaks: bool = Falsesample_by: typing.Literal['line', 'paragraph', 'document'] = 'line'**kwargs )
Parámetros
- path_or_paths (
path-likeo lista depath-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 defectoFalse) — 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.
Crea un IterableDataset a partir de archivo(s) de texto.
clase datasets.IterableColumn
< source >( source: typing.Union[ForwardRef('IterableDataset'), ForwardRef('IterableColumn')]column_name: str )
Un iterable para una columna específica de un IterableDataset.
Ejemplo:
IterableDatasetDict
Diccionario con los nombres de las divisiones como claves (por ejemplo, ‘train’, ‘test’) y objetos IterableDataset como valores.
map
< source >( function: typing.Optional[typing.Callable] = Nonewith_indices: bool = Falsewith_split: bool = Falseinput_columns: typing.Union[str, list[str], NoneType] = Nonebatched: bool = Falsebatch_size: int = 1000drop_last_batch: bool = Falseremove_columns: typing.Union[str, list[str], NoneType] = Nonefn_kwargs: typing.Optional[dict] = None )
Parámetros
- function (
Callable, opcional, por defectoNone) — 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]sibatched=Falseywith_indices=Falsefunction(example: Dict[str, Any], idx: int) -> Dict[str, Any]sibatched=Falseywith_indices=Truefunction(batch: Dict[str, list]) -> Dict[str, list]sibatched=Trueywith_indices=Falsefunction(batch: Dict[str, list], indices: list[int]) -> Dict[str, list]sibatched=Trueywith_indices=True
Para un uso avanzado, la función también puede devolver una
pyarrow.Table. Si la función es asíncrona,mapejecutará su función en paralelo. Además, si su función no devuelve nada (None),mapejecutará 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 defectoFalse) — Proporciona índices de ejemplo afunction. Ten en cuenta que, en este caso, la firma defunctiondebe serdef function(example, idx[, rank]): .... - input_columns (
[Union[str, list[str]]], opcional, valor predeterminadoNone) — Las columnas que se pasarán afunctioncomo argumentos posicionales. Si esNone, se pasa un diccionario que mapea a todas las columnas formateadas como un solo argumento. - batched (
bool, por defectoFalse) — Proporciona un lote de ejemplos afunction. - batch_size (
int, opcional, valor predeterminado1000) — Número de ejemplos por lote proporcionados afunctionsibatched=True. - drop_last_batch (
bool, por defectoFalse) — Si un último lote más pequeño quebatch_sizedebe descartarse en lugar de ser procesado por la función. - remove_columns (
[list[str]], opcional, valor predeterminadoNone) — Elimina una selección de columnas durante el mapeo. Las columnas se eliminarán antes de actualizar los ejemplos con la salida defunction, es decir, sifunctionestá añadiendo columnas con nombres enremove_columns, estas columnas se conservarán. - fn_kwargs (
Dict, opcional, por defectoNone) — Argumentos de palabra clave que se pasarán afunction
Aplica una función a todos los ejemplos del dataset iterable (de forma individual o en lotes) y los actualiza. Si tu 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
FalseesFalse, la función toma 1 ejemplo como entrada y debe devolver 1 ejemplo. Un ejemplo es un diccionario, p. ej.{"text": "Hello there !"}. - Si
Trueybatch_sizees 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
Trueybatch_sizeesn> 1, la función toma como entrada un lote denejemplos y puede devolver un lote connejemplos, o con un número arbitrario de ejemplos. Tenga en cuenta que el último lote puede tener menos denejemplos. Un lote es un diccionario, por ejemplo, un lote denejemplos 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:
>>> 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 .'}filter
< source >( function: typing.Optional[typing.Callable] = Nonewith_indices = Falseinput_columns: typing.Union[str, list[str], NoneType] = Nonebatched: bool = Falsebatch_size: typing.Optional[int] = 1000fn_kwargs: typing.Optional[dict] = None )
Parámetros
- function (
Callable) — Función con una de las siguientes firmas:function(example: Dict[str, Any]) -> boolsiwith_indices=False, batched=Falsefunction(example: Dict[str, Any], indices: int) -> boolsiwith_indices=True, batched=Falsefunction(example: Dict[str, list]) -> list[bool]siwith_indices=False, batched=Truefunction(example: Dict[str, list], indices: list[int]) -> list[bool]siwith_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 defectoFalse) — Proporciona índices de ejemplo afunction. Ten en cuenta que, en este caso, la firma defunctiondebe serdef function(example, idx): .... - input_columns (
strolist[str], opcional) — Las columnas que se pasarán afunctioncomo argumentos posicionales. Si esNone, se pasa un diccionario con todas las columnas formateadas como un solo argumento. - batched (
bool, por defectoFalse) — Proporciona un lote de ejemplos afunction - batch_size (
int, opcional, valor predeterminado1000) — Número de ejemplos por lote proporcionados afunctionsibatched=True. - fn_kwargs (
Dict, opcional, por defectoNone) — Argumentos de palabra clave que se pasarán afunction
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:
>>> 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
< source >( seed = Nonegenerator: typing.Optional[numpy.random._generator.Generator] = Nonebuffer_size: int = 1000max_buffer_input_shards: int = 10 )
Parámetros
- seed (
int, opcional, valor predeterminadoNone) — Semilla aleatoria que se utilizará para barajar el conjunto de datos. Se utiliza para muestrear desde el 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. Sigenerator=None(predeterminado), usanp.random.default_rng(el BitGenerator predeterminado (PCG64) de NumPy). - buffer_size (
int, por defecto1000) — Tamaño del búfer. - max_buffer_input_shards (
int, por defecto10) — Número máximo de shards para alimentar el buffer 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 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() o take(), el orden de los fragmentos se mantiene sin cambios.
Ejemplo:
>>> 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
< source >( type: typing.Optional[str] = None )
Devuelve un conjunto de datos con el formato especificado.
Ejemplo:
>>> 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
< source >( features: Features ) → IterableDatasetDict
Parámetros
- features (
Features) — Nuevas características a las que convertir el dataset. 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 usarmappara actualizar el Dataset.
Devuelve
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:
>>> 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
< source >( column: strfeature: 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] )
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:
>>> 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
< source >( column_names: typing.Union[str, list[str]] ) → IterableDatasetDict
Parámetros
Devuelve
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:
>>> 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
< source >( original_column_name: strnew_column_name: str ) → IterableDatasetDict
Renombrar una columna en el conjunto de datos y mover 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:
>>> 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
< source >( column_mapping: dict ) → IterableDatasetDict
Parámetros
Devuelve
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:
>>> 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
< source >( column_names: typing.Union[str, list[str]] ) → IterableDatasetDict
Parámetros
Devuelve
Una copia del objeto de conjunto de datos con solo las columnas seleccionadas.
Selecciona 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:
>>> 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
< source >( repo_id: strconfig_name: str = 'default'set_default: typing.Optional[bool] = Nonedata_dir: typing.Optional[str] = Nonecommit_message: typing.Optional[str] = Nonecommit_description: typing.Optional[str] = Noneprivate: typing.Optional[bool] = Nonetoken: typing.Optional[str] = Nonerevision: typing.Optional[str] = Nonecreate_pr: typing.Optional[bool] = Falsemax_shard_size: typing.Union[str, int, NoneType] = Nonenum_shards: typing.Optional[dict[str, int]] = Noneembed_external_files: bool = Truenum_proc: typing.Optional[int] = None )
Parámetros
- repo_id (
str) — El ID del repositorio al que se enviarán los datos, en el siguiente formato:<user>/<dataset_name>o<org>/<dataset_name>. También acepta<dataset_name>, que usará el espacio de nombres del usuario conectado por defecto.También podría ser una ubicación dentro de un bucket, p. ej.
buckets/<user_or_org>/<bucket_name>/... - config_name (
str) — Nombre de la configuración de un conjunto de datos. El valor predeterminado es “default”. - set_default (
bool, opcional) — Si se debe establecer esta configuración como la predeterminada. De lo contrario, la configuración predeterminada es la que se llama “default”. - data_dir (
str, opcional) — Nombre del directorio que contendrá los archivos de datos cargados. El valor predeterminado esconfig_namesi es diferente de «default», en caso contrario, «data».Añadido en 2.17.0
- commit_message (
str, opcional) — Mensaje para el commit al hacer push. El valor predeterminado es"Upload dataset". - commit_description (
str, opcional) — Descripción del commit que se creará. Además, descripción del PR si se crea un PR (create_pres True).Añadido en 2.16.0
- private (
bool, opcional) — Si se debe hacer el repositorio privado. Si esNone(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 conhf 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, valor predeterminadoFalse) — Si se debe crear una PR con los archivos subidos o realizar el commit directamente. - max_shard_size (
intostr, 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 shards a escribir. Use un diccionario para definir unnum_shardsdiferente para cada split. Si se proporcionamax_shard_sizey no se especifica elnum_shardsde un split, el número de shards para ese split se estima a partir demax_shard_size. - embed_external_files (
bool, por defecto esTrue) — Si se incrustan los bytes de los archivos en los fragmentos. En particular, antes de la publicación, esto hará lo siguiente para los campos de tipo: - num_proc (
int, opcional, por defectoNone) — 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. Utiliza el contexto “spawn” para funcionar con hf_xet, el cliente de Rust para subidas rápidas a HF. La multiprocesación está deshabilitada por defecto.Añadido en 4.0.0
Envía el IterableDatasetDict al hub como un dataset Parquet. El 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 o 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:
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>")
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", private=True)
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", max_shard_size="1GB")
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", 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):
>>> english_dataset.push_to_hub("<organization>/<dataset_id>", "en")
>>> french_dataset.push_to_hub("<organization>/<dataset_id>", "fr")
>>> # later
>>> english_dataset = load_dataset("<organization>/<dataset_id>", "en")
>>> french_dataset = load_dataset("<organization>/<dataset_id>", "fr")Características
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 especifica un valor de un solo tipo de datos, por ejemplo,
int64ostring. - La característica 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
dictde 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 o LargeList especifica una característica compuesta que contiene una secuencia de subcaracterísticas, todas del mismo tipo de característica.
- Característica Array2D, Array3D, Array4D o Array5D para matrices multidimensionales.
- La característica 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 con un decodificador.
- Característica Image para almacenar la ruta absoluta a un archivo de imagen, un objeto
np.ndarray, un objetoPIL.Image.Imageo 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 para almacenar la ruta absoluta a un archivo de video, un objeto
torchcodec.decoders.VideoDecodero 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 para almacenar la ruta absoluta a un archivo PDF, un objeto
pdfplumber.pdf.PDFo 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. - Característica Nifti para almacenar la ruta absoluta a un archivo de neuroimagen NIfTI, un objeto
nibabel.Nifti1Imageo 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 o TranslationVariableLanguages específica de la traducción automática.
- Característica Json para almacenar datos no estructurados, por ejemplo, que contienen tipos mixtos o arbitrarios. Internamente
Realiza una copia profunda de Features.
decode_batch
< source >( batch: dicttoken_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None )
Decodificar el lote con decodificación de características personalizada.
decode_column
< source >( column: listcolumn_name: strtoken_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None )
Decodificar columna con decodificación de características personalizada.
decode_example
< source >( example: dicttoken_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None )
Ejemplo de decodificación con decodificación de características personalizada.
encode_batch
< source >( batch )
Codificar el lote en un formato para Arrow.
encode_column
< source >( columncolumn_name: str )
Codifica la columna en un formato para Arrow.
encode_example
< source >( example )
Codifica el ejemplo en un formato para Arrow.
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: <original>.<subfield>.
Si una columna contiene diccionarios anidados, los nombres de todos los subcampos de niveles inferiores también se concatenan para formar nuevas columnas: <original>.<subfield>.<subsubfield>, etc.
Ejemplo:
>>> 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
< source >( pa_schema: Schema )
Construye 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, datasets convierte los objetos DictionaryArray en sus valores reales.
from_dict
< source >( dic ) → Features
Construir [Features] a partir de un diccionario.
Regenera el objeto de característica anidado a partir de 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. Esto 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 dtypes primitivos de pyarrow que [Value] realiza automáticamente.
reorder_fields_as
< source >( other: Features )
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:
>>> 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({"root": {"a": Value("string"), "b": Value("string")}})
>>> f2 = Features({"root": {"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)
{'root': List({'b': Value('string'), 'a': Value('string')})}
>>> assert f1.reorder_fields_as(f2).type == f2.typeScalar
clase datasets.Value
< source >( dtype: strid: typing.Optional[str] = None )
Valor de característica escalar de un tipo de datos particular.
Los posibles dtypes de Value son los siguientes:
nullboolint8int16int32int64uint8uint16uint32uint64float16float32(alias float)float64(alias double)time32[(s|ms)]time64[(us|ns)]timestamp[(s|ms|us|ns)]timestamp[(s|ms|us|ns), tz=(tzstring)]date32date64duration[(s|ms|us|ns)]decimal128(precision, scale)decimal256(precision, scale)binarylarge_binarybinary_viewstringlarge_stringstring_view
clase datasets.ClassLabel
< source >( num_classes: dataclasses.InitVar[typing.Optional[int]] = Nonenames: list = Nonenames_file: dataclasses.InitVar[typing.Optional[str]] = Noneid: typing.Optional[str] = None )
Parámetros
- num_classes (
int, opcional) — Número de clases. Todas las etiquetas deben ser <num_classes. - names (
listdestr, 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:
>>> 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
< source >( storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.IntegerArray] ) → pa.Int64Array
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()
Conversión de integer => cadena de nombre de clase string.
En cuanto a las etiquetas desconocidas o faltantes: pasar enteros negativos provoca ValueError.
Nombre de la clase de conversión string => integer.
Compuesto
clase datasets.LargeList
< source >( feature: typing.Anyid: typing.Optional[str] = None )
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.
clase datasets.List
< source >( feature: typing.Anylength: int = -1id: typing.Optional[str] = None )
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.
clase datasets.Sequence
< source >( feature = Nonelength = -1**kwargs )
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 deseas este comportamiento, puedes usar una List o una LargeList en lugar de la Sequence.
Traducción
clase datasets.Translation
< source >( languages: listid: typing.Optional[str] = None )
Feature para traducciones con idiomas fijos por ejemplo.
Aquí por compatibilidad con tfds.
Ejemplo:
>>> # At construction time:
>>> datasets.features.Translation(languages=['en', 'fr', 'de'])
>>> # During data generation:
>>> yield {
... 'en': 'the cat',
... 'fr': 'le chat',
... 'de': 'die katze'
... }Aplana la función Translation en un diccionario.
clase datasets.TranslationVariableLanguages
< source >( languages: typing.Optional[list] = Nonenum_languages: typing.Optional[int] = Noneid: typing.Optional[str] = None ) →
language or translation (variable-length 1D tf.Tensor of tf.string)
Parámetros
- languages (
dict) — Un diccionario para cada ejemplo que mapea códigos de idioma en formato de cadena a una o más traducciones en formato de cadena. Los idiomas presentes pueden variar de un ejemplo a otro.
Devuelve
languageotranslation(tf.Tensorunidimensional de longitud variable detf.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í por compatibilidad con tfds.
Ejemplo:
>>> # 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'],
... }Aplana la función TranslationVariableLanguages en un diccionario.
Arrays
clase datasets.Array2D
< source >( shape: tupledtype: strid: typing.Optional[str] = None )
Crea un array bidimensional.
clase datasets.Array3D
< source >( shape: tupledtype: strid: typing.Optional[str] = None )
Crea un array tridimensional.
clase datasets.Array4D
< source >( shape: tupledtype: strid: typing.Optional[str] = None )
Crea un array de cuatro dimensiones.
clase datasets.Array5D
< source >( shape: tupledtype: strid: typing.Optional[str] = None )
Crea un array de cinco dimensiones.
Audio
clase datasets.Audio
< source >( sampling_rate: typing.Optional[int] = Nonedecode: bool = Truenum_channels: typing.Optional[int] = Nonestream_index: typing.Optional[int] = Noneid: typing.Optional[str] = None )
Parámetros
- sampling_rate (
int, opcional) — Tasa de muestreo objetivo. Si esNone, 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) ActualmenteNone(número de canales de la fuente, valor predeterminado),1(mono) o2(estéreo) canales son compatibles. Elnum_channelsargumento se pasa atorchcodec.decoders.AudioDecoder.Añadido en 4.4.0
- decode (
bool, por defectoTrue) — Si se debe decodificar los datos de audio. Si esFalse, devuelve el diccionario subyacente en el formato{"path": audio_path, "bytes": audio_bytes}. - stream_index (
int, opcional) — El índice de streaming a utilizar del archivo. Si esNone, 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
dictcon 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
dictcon las claves:array: Matriz que contiene la muestra de audiosampling_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 audiosampling_rate: Entero que corresponde a la tasa de muestreo de la muestra de audio.
Ejemplo:
>>> 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"]
<datasets.features._torchcodec.AudioDecoder object at 0x11642b6a0>
>>> 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: 44100cast_storage
< source >( storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray] ) → pa.StructArray
Convierte un array de Arrow al tipo de almacenamiento de flecha de Audio. Los tipos de Arrow que se pueden convertir al tipo de almacenamiento de flecha de Audio de pyarrow son:
pa.string()- debe contener los datos de “path”pa.binary()- debe contener los bytes de audiopa.struct({"bytes": pa.binary()})pa.struct({"path": pa.string()})pa.struct({"bytes": pa.binary(), "path": pa.string()})- el orden no importa
decode_example
< source >( value: dicttoken_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None )
Parámetros
- value (
dict) — Un diccionario con las siguientes claves:path: String 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 (boolostr)
Decodificar un archivo de audio de ejemplo en datos de audio.
embed_storage
< source >( storage: StructArraytoken_per_repo_id = Nonelocal_files: bool = Trueremote_files: bool = True ) → pa.StructArray
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 esTrue) — Si se incrustan los datos de archivos locales en la matrizAñadido en 4.8.5
- remote_files (
bool, por defecto esTrue) — Si se incrustan los datos de archivos remotos en el array. Por ejemplo, archivos con rutas que comienzan con hf:// o https://Añadido en 4.8.5
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
< source >( value: typing.Union[str, bytes, bytearray, dict, ForwardRef('AudioDecoder')] ) → dict
Codifica el ejemplo en un formato para Arrow.
Si se encuentra en el estado decodificable, se lanza un error; de lo contrario, se aplanan las características en un diccionario.
Imagen
clase datasets.Image
< source >( mode: typing.Optional[str] = Nonedecode: bool = Trueid: typing.Optional[str] = None )
Parámetros
- mode (
str, opcional) — El modo al que se debe convertir la imagen. Si esNone, se utiliza el modo nativo de la imagen. - decode (
bool, por defectoTrue) — Si se debe decodificar los datos de la imagen. Si esFalse, 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
dictcon 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:
>>> 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"]
<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=500x500 at 0x15E52E7F0>
>>> 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
< source >( storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray] ) → pa.StructArray
Convierte un array de Arrow al tipo de almacenamiento de Arrow Image. Los tipos de Arrow que se pueden convertir al tipo de almacenamiento de pyarrow Image son:
pa.string()- debe contener los datos de “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 imagenpa.struct({"bytes": pa.binary()})pa.struct({"path": pa.string()})pa.struct({"bytes": pa.binary(), "path": pa.string()})- el orden no importapa.list(*)- debe contener los datos del array de imágenes
decode_example
< source >( value: dicttoken_per_repo_id = None )
Parámetros
- value (
strodict) — Una cadena con la ruta absoluta del archivo de imagen, o un diccionario con las claves:path: String 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 (boolostr).
Decodificar el archivo de imagen de ejemplo en datos de imagen.
embed_storage
< source >( storage: StructArraytoken_per_repo_id = Nonelocal_files: bool = Trueremote_files: bool = True ) → pa.StructArray
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 esTrue) — Si se incrustan los datos de archivos locales en la matrizAñadido en 4.8.5
- remote_files (
bool, por defecto esTrue) — Si se incrustan los datos de archivos remotos en el array. Por ejemplo, archivos con rutas que comienzan con hf:// o https://Añadido en 4.8.5
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
< source >( value: typing.Union[str, bytes, bytearray, dict, numpy.ndarray, ForwardRef('PIL.Image.Image')] )
Codifica el ejemplo en un formato para Arrow.
Si está en el estado decodificable, devuelve la característica en sí; de lo contrario, aplana la característica en un diccionario.
Video
clase datasets.Video
< source >( decode: bool = Truestream_index: typing.Optional[int] = Nonedimension_order: typing.Literal['NCHW', 'NHWC'] = 'NCHW'num_ffmpeg_threads: int = 1device: typing.Union[str, ForwardRef('torch.device'), NoneType] = 'cpu'seek_mode: typing.Literal['exact', 'approximate'] = 'exact'id: typing.Optional[str] = None )
Parámetros
- decode (
bool, por defectoTrue) — Si se debe decodificar los datos del vídeo. Si esFalse, devuelve el diccionario subyacente en el formato{"path": video_path, "bytes": video_bytes}. - stream_index (
int, opcional) — El índice de streaming a utilizar del archivo. Si esNone, se usa por defecto el índice “óptimo”. - dimension_order (
str, por defectoNCHW) — 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 defecto1) — El número de hilos a utilizar para decodificar el video. (Se recomienda mantenerlo en 1) - device (
strotorch.device, por defectocpu) — El dispositivo que se utilizará para decodificar el video. - seek_mode (
str, por defectoexact) — 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 porque evita escanear el archivo, pero es menos preciso, ya que utiliza los metadatos del archivo para calcular dónde probablemente se encuentra i. leer más aquí
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
dictcon 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:
>>> 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"]
<torchcodec.decoders._video_decoder.VideoDecoder object at 0x14a61e080>
>>> 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
< source >( storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray] ) → pa.StructArray
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 de “path”pa.binary()- debe contener los bytes del videopa.struct({"bytes": pa.binary()})pa.struct({"path": pa.string()})pa.struct({"bytes": pa.binary(), "path": pa.string()})- el orden no importapa.list(*)- debe contener los datos del array de video
decode_example
< source >( value: typing.Union[str, datasets.features.video.Example]token_per_repo_id: typing.Optional[dict[str, typing.Union[bool, str]]] = None )
Parámetros
- value (
strodict) — Una cadena con la ruta absoluta del archivo de video, o un diccionario con las claves:path: String 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 (boolostr).
Decodificar un archivo de video de ejemplo en datos de video.
embed_storage
< source >( storage: StructArraytoken_per_repo_id = Nonelocal_files: bool = Trueremote_files: bool = True ) → pa.StructArray
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 esTrue) — Si se incrustan los datos de archivos locales en la matrizAñadido en 4.8.5
- remote_files (
bool, por defecto esTrue) — Si se incrustan los datos de archivos remotos en el array. Por ejemplo, archivos con rutas que comienzan con hf:// o https://Añadido en 4.8.5
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
< source >( value: typing.Union[str, bytes, bytearray, datasets.features.video.Example, numpy.ndarray, ForwardRef('VideoDecoder')] )
Codifica el ejemplo en un formato para Arrow.
Si está en el estado decodificable, devuelve la característica en sí; de lo contrario, aplana la característica en un diccionario.
Mesh
clase datasets.Mesh
< source >( decode: bool = Trueid: typing.Optional[str] = None )
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
dictcon 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.Trimeshotrimesh.Scene: objeto de malla o escena 3D.
Salida: La función Mesh genera datos como objetos trimesh.Trimesh o trimesh.Scene.
cast_storage
< source >( storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray] ) → pa.StructArray
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 de pyarrow de Mesh son:
pa.string()- debe contener los datos de “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 mallapa.struct({"bytes": pa.binary()})pa.struct({"path": pa.string()})pa.struct({"bytes": pa.binary(), "path": pa.string()})- el orden no importa
decode_example
< source >( value: dicttoken_per_repo_id = None )
Parámetros
- value (
dict) — Un diccionario con las siguientes claves:path: String 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 mesh de repositorios privados en el Hub, puede pasar un diccionario repo_id (str) -> token (boolostr).
Decodificar un archivo de malla de ejemplo.
embed_storage
< source >( storage: StructArraytoken_per_repo_id = Nonelocal_files: bool = Trueremote_files: bool = True ) → pa.StructArray
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 defectoTrue) — Si se debe incrustar los datos de archivos locales en la matriz. - remote_files (
bool, por defectoTrue) — 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
< source >( value: typing.Union[str, bytes, bytearray, dict, ForwardRef('trimesh.Trimesh'), ForwardRef('trimesh.Scene')] )
Codifica el ejemplo en un formato para Arrow.
Si está en el estado decodificable, devuelve la característica en sí; de lo contrario, aplana la característica en un diccionario.
Json
Tipo de característica para objetos JSON.
Por debajo, los objetos se almacenan como cadenas codificadas en JSON.
Ejemplo:
>>> from datasets import Features, Json
>>> features = Features({'json': Json()})
>>> features
{'json': Json()}>>> 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
< source >( storage: Array ) → pa.JsonArray
Convierte un array de Arrow al tipo de almacenamiento de Arrow Json.
clase datasets.Pdf
< source >( decode: bool = Trueid: typing.Optional[str] = None )
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
dictcon 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:
>>> 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"]
<pdfplumber.pdf.PDF object at 0x7f8a1c2d8f40>
>>> ds = ds.cast_column("pdf", Pdf(decode=False))
>>> ds[0]["pdf"]
{'bytes': None,
'path': 'path/to/pdf/file.pdf'}cast_storage
< source >( storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray] ) → pa.StructArray
Convierte un array de Arrow al tipo de almacenamiento de arrow Pdf. Los tipos de Arrow que se pueden convertir al tipo de almacenamiento de pyarrow Pdf son:
pa.string()- debe contener los datos de “path”pa.binary()- debe contener los bytes de la imagenpa.struct({"bytes": pa.binary()})pa.struct({"path": pa.string()})pa.struct({"bytes": pa.binary(), "path": pa.string()})- el orden no importapa.list(*)- debe contener los datos del array pdf
decode_example
< source >( value: dicttoken_per_repo_id = None )
Parámetros
- value (
strodict) — Una cadena con la ruta absoluta del archivo pdf, o un diccionario con las claves:path: String 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 (boolostr).
Decodifica un archivo pdf de ejemplo en datos pdf.
embed_storage
< source >( storage: StructArraytoken_per_repo_id = Nonelocal_files: bool = Trueremote_files: bool = True ) → pa.StructArray
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 esTrue) — Si se incrustan los datos de archivos locales en la matrizAñadido en 4.8.5
- remote_files (
bool, por defecto esTrue) — Si se incrustan los datos de archivos remotos en el array. Por ejemplo, archivos con rutas que comienzan con hf:// o https://Añadido en 4.8.5
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
< source >( value: typing.Union[str, bytes, bytearray, dict, ForwardRef('pdfplumber.pdf.PDF')] )
Codifica el ejemplo en un formato para Arrow.
Si está en el estado decodificable, devuelve la característica en sí; de lo contrario, aplana la característica en un diccionario.
Nifti
clase datasets.Nifti
< source >( decode: bool = Trueid: typing.Optional[str] = None )
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
dictcon 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:
>>> 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"]
<nibabel.nifti1.Nifti1Image object at 0x7f8a1c2d8f40>
>>> ds = ds.cast_column("nifti", Nifti(decode=False))
>>> ds[0]["nifti"]
{'bytes': None,
'path': 'path/to/file.nii.gz'}cast_storage
< source >( storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.BinaryArray] ) → pa.StructArray
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 de “path”pa.binary()- debe contener los bytes NIfTIpa.struct({"bytes": pa.binary()})pa.struct({"path": pa.string()})pa.struct({"bytes": pa.binary(), "path": pa.string()})- el orden no importa
decode_example
< source >( value: dicttoken_per_repo_id = None )
Parámetros
- value (
strodict) — Una cadena con la ruta absoluta del archivo NIfTI, o un diccionario con las claves:path: String 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 (boolostr).
Decodificar el archivo NIfTI de ejemplo en un objeto de imagen de nibabel.
embed_storage
< source >( storage: StructArraytoken_per_repo_id = Nonelocal_files: bool = Trueremote_files: bool = True ) → pa.StructArray
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 esTrue) — Si se incrustan los datos de archivos locales en la matrizAñadido en 4.8.5
- remote_files (
bool, por defecto esTrue) — Si se incrustan los datos de archivos remotos en el array. Por ejemplo, archivos con rutas que comienzan con hf:// o https://Añadido en 4.8.5
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
< source >( value: typing.Union[str, bytes, bytearray, dict, ForwardRef('nib.Nifti1Image')] )
Codifica el ejemplo en un formato para Arrow.
Si está en el estado decodificable, devuelve la característica en sí; de lo contrario, aplana la característica en un diccionario.
BioSequence
clase datasets.BioSequence
< source >( format: str = 'fasta'decode: bool = Trueid: typing.Optional[str] = None )
Parámetros
- format (
str, por defecto"fasta") — Nombre del formato de secuencia, tal como lo interpretaBio.SeqIO. Los valores habituales son"fasta","fastq"y"genbank". - decode (
bool, por defectoTrue) — Si se debe decodificar los datos de la secuencia. Si esFalse, 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
dictcon 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:
>>> 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
< source >( storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray] ) → pa.StructArray
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 de pyarrow de BioSequence son:
pa.string()- debe contener los datos de “path”pa.binary()- debe contener los bytes del archivopa.struct({"bytes": pa.binary()})pa.struct({"path": pa.string()})pa.struct({"bytes": pa.binary(), "path": pa.string()})- el orden no importa
decode_example
< source >( value: dicttoken_per_repo_id = None )
Parámetros
- value (
strodict) — Una cadena con la ruta absoluta del archivo, o un diccionario con las claves:path: String 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 (boolostr).
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
< source >( storage: StructArraytoken_per_repo_id = Nonelocal_files: bool = Trueremote_files: bool = True ) → pa.StructArray
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 defectoTrue) — Si se debe incrustar los datos de archivos locales en la matriz. - remote_files (
bool, por defectoTrue) — 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
< source >( value: typing.Union[str, bytes, bytearray, dict, ForwardRef('SeqRecord')] )
Codifica el ejemplo en un formato para Arrow.
Si está en el estado decodificable, devuelve la característica en sí; de lo contrario, aplana la característica en un diccionario.
BioStructure
clase datasets.BioStructure
< source >( format: str = 'pdb'decode: bool = Trueid: typing.Optional[str] = None )
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
dictcon 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:
>>> 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"]
<Structure id=1abc>
>>> ds = ds.cast_column("st", BioStructure(decode=False))
>>> ds[0]["st"]
{'bytes': None,
'path': 'path/to/1abc.pdb'}cast_storage
< source >( storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray] ) → pa.StructArray
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 de “path”pa.binary()- debe contener los bytes del archivopa.struct({"bytes": pa.binary()})pa.struct({"path": pa.string()})pa.struct({"bytes": pa.binary(), "path": pa.string()})- el orden no importa
decode_example
< source >( value: dicttoken_per_repo_id = None )
Parámetros
- value (
strodict) — Una cadena con la ruta absoluta del archivo, o un diccionario con las claves:path: String 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 (boolostr).
Decodificar el archivo de estructura de ejemplo en una estructura de biopython.
embed_storage
< source >( storage: StructArraytoken_per_repo_id = Nonelocal_files: bool = Trueremote_files: bool = True ) → pa.StructArray
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 defectoTrue) — Si se debe incrustar los datos de archivos locales en la matriz. - remote_files (
bool, por defectoTrue) — 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
< source >( value: typing.Union[str, bytes, bytearray, dict, ForwardRef('Structure')] )
Codifica el ejemplo en un formato para Arrow.
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
< source >( fs: AbstractFileSystem )
Comprueba si fs es un sistema de archivos remoto.
Huella digital
Hasher que acepta objetos de Python como entradas.