Cargar

Tus datos pueden estar almacenados en varios lugares; pueden estar en el disco de tu máquina local, en un repositorio de Github y en estructuras de datos en memoria como diccionarios de Python y DataFrames de Pandas. Sin importar dónde se almacene un conjunto de datos, 🤗 Datasets puede ayudarte a cargarlo.

Esta guía te mostrará cómo cargar un conjunto de datos desde:

• El Hugging Face Hub
• Archivos locales
• Datos en memoria
• Offline
• Una porción específica de una división

Para más detalles específicos sobre la carga de otras modalidades de conjuntos de datos, consulte la guía para cargar conjuntos de datos de audio, la guía para cargar conjuntos de datos de imágenes, la guía para cargar conjuntos de datos de video, la guía para cargar conjuntos de datos de mallas, la guía para cargar conjuntos de datos de texto o la guía para cargar tareas de evaluación de agentes.

Hugging Face Hub

También puedes cargar un conjunto de datos desde cualquier repositorio de conjuntos de datos en el Hub. Comienza creando un repositorio de conjuntos de datos y sube tus archivos de datos. Ahora puedes usar la función load_dataset() para cargar el conjunto de datos.

Por ejemplo, intente cargar los archivos de este repositorio de demostración proporcionando el espacio de nombres del repositorio y el nombre del conjunto de datos. Este repositorio de conjuntos de datos contiene archivos CSV, y el código siguiente carga el conjunto de datos desde los archivos CSV:

>>> from datasets import load_dataset
>>> dataset = load_dataset("lhoestq/demo1")

Algunos conjuntos de datos pueden tener más de una versión basada en etiquetas, ramas o commits de Git. Utilice el parámetro revision para especificar la versión del conjunto de datos que desea cargar:

>>> dataset = load_dataset(
...   "lhoestq/custom_squad",
...   revision="main"  # tag name, or branch name, or commit hash
... )

Consulte el tutorial Cargar un conjunto de datos en el Hub para obtener más detalles sobre cómo crear un repositorio de conjuntos de datos en el Hub y cómo cargar sus archivos de datos.

Un conjunto de datos carga por defecto todos los datos en la división train, o busca menciones o nombres de división en los nombres de los archivos de datos (p. ej. “train”, “test” y “validation”). Utilice el parámetro data_files para asignar archivos de datos a divisiones como train, validation y test:

>>> data_files = {"train": "train.csv", "test": "test.csv"}
>>> dataset = load_dataset("namespace/your_dataset_name", data_files=data_files)

Si no especifica qué archivos de datos usar, load_dataset() devolverá todos los archivos de datos. Esto puede tardar mucho tiempo si carga un conjunto de datos grande como C4, que contiene aproximadamente 13 TB de datos.

También puede cargar un subconjunto específico de los archivos con el parámetro data_files o data_dir. Estos parámetros pueden aceptar una ruta relativa que se resuelve en la ruta base correspondiente al lugar desde donde se carga el conjunto de datos.

>>> from datasets import load_dataset

# load files that match the grep pattern
>>> c4_subset = load_dataset("allenai/c4", data_files="en/c4-train.0000*-of-01024.json.gz")

# load dataset from the en directory on the Hub
>>> c4_subset = load_dataset("allenai/c4", data_dir="en")

El parámetro split también puede asignar un archivo de datos a una división específica:

>>> data_files = {"validation": "en/c4-validation.*.json.gz"}
>>> c4_validation = load_dataset("allenai/c4", data_files=data_files, split="validation")

Archivos locales y remotos

Los conjuntos de datos se pueden cargar desde archivos locales almacenados en su computadora y desde archivos remotos. Es probable que los conjuntos de datos estén almacenados como archivos csv, json, txt, parquet o tsfile. La función load_dataset() puede cargar cada uno de estos tipos de archivo.

CSV

🤗 Datasets puede leer un conjunto de datos compuesto por uno o varios archivos CSV (en este caso, pase sus archivos CSV como una lista):

>>> from datasets import load_dataset
>>> dataset = load_dataset("csv", data_files="my_file.csv")

Para más detalles, consulta la guía cómo cargar conjuntos de datos tabulares desde archivos CSV.

JSON

Los archivos JSON se cargan directamente con load_dataset() como se muestra a continuación:

>>> from datasets import load_dataset
>>> dataset = load_dataset("json", data_files="my_file.json")

Los archivos JSON tienen formatos diversos, pero consideramos que el formato más eficiente es tener múltiples objetos JSON; cada línea representa una fila individual de datos. Por ejemplo:

{"a": 1, "b": 2.0, "c": "foo", "d": false}
{"a": 4, "b": -5.5, "c": null, "d": true}

Otro formato JSON que puede encontrar es un campo anidado, en cuyo caso deberá especificar el argumento field como se muestra a continuación:

{"version": "0.1.0",
 "data": [{"a": 1, "b": 2.0, "c": "foo", "d": false},
          {"a": 4, "b": -5.5, "c": null, "d": true}]
}

>>> from datasets import load_dataset
>>> dataset = load_dataset("json", data_files="my_file.json", field="data")

Para cargar archivos JSON remotos a través de HTTP, pase las URL en su lugar:

>>> base_url = "https://rajpurkar.github.io/SQuAD-explorer/dataset/"
>>> dataset = load_dataset("json", data_files={"train": base_url + "train-v1.1.json", "validation": base_url + "dev-v1.1.json"}, field="data")

Aunque estos son los formatos JSON más comunes, verás otros conjuntos de datos con un formato diferente. 🤗 Datasets reconoce estos otros formatos y, en su caso, recurrirá a los métodos de carga de JSON de Python para procesarlos.

Parquet

Los archivos Parquet se almacenan en un formato columnar, a diferencia de los archivos basados en filas, como un CSV. Los conjuntos de datos grandes pueden almacenarse en un archivo Parquet porque es más eficiente y rápido al devolver su consulta.

Para cargar un archivo Parquet:

>>> from datasets import load_dataset
>>> dataset = load_dataset("parquet", data_files={'train': 'train.parquet', 'test': 'test.parquet'})

Para cargar archivos Parquet remotos a través de HTTP, pase las URL en su lugar:

>>> base_url = "https://huggingface.co/datasets/wikimedia/wikipedia/resolve/main/20231101.ab/"
>>> data_files = {"train": base_url + "train-00000-of-00001.parquet"}
>>> wiki = load_dataset("parquet", data_files=data_files, split="train")

Arrow

Los archivos Arrow se almacenan en un formato columnar en memoria, a diferencia de los formatos basados en filas como CSV y los formatos sin comprimir como Parquet.

Para cargar un archivo Arrow:

>>> from datasets import load_dataset
>>> dataset = load_dataset("arrow", data_files={'train': 'train.arrow', 'test': 'test.arrow'})

Para cargar archivos Arrow remotos a través de HTTP, pase las URL en su lugar:

>>> base_url = "https://huggingface.co/datasets/croissantllm/croissant_dataset/resolve/main/english_660B_11/"
>>> data_files = {"train": base_url + "train/data-00000-of-00080.arrow"}
>>> wiki = load_dataset("arrow", data_files=data_files, split="train")

Arrow es el formato de archivo que utiliza 🤗 Datasets internamente, por lo que puedes cargar un archivo Arrow local directamente con Dataset.from_file():

>>> from datasets import Dataset
>>> dataset = Dataset.from_file("data.arrow")

A diferencia de load_dataset(), Dataset.from_file() realiza el mapeo de memoria del archivo Arrow sin preparar el conjunto de datos en la caché, lo que le ahorra espacio en disco. En ese caso, el directorio de caché para almacenar los resultados intermedios de procesamiento será el directorio del archivo Arrow.

Por ahora, solo se admite el formato de streaming de Arrow. El formato de archivo Arrow IPC (también conocido como Feather V2) no está admitido.

Lance

Lance es un formato de tabla de lakehouse multimodal abierto para IA. Las tablas de Lance pueden almacenar de forma nativa no solo texto y valores escalares, sino también objetos binarios grandes (blobs) como imágenes, audio y video junto a sus datos tabulares.

>>> from datasets import load_dataset
>>> lance_base_url = "lance-format/laion-1m"

Para transmitir el conjunto de datos sin copiarlo a su máquina local, especifique el parámetro streaming=True:

ds = load_dataset(lance_base_url, split="train", streaming=True)
# Take first three rows
for row in ds.take(3):
    print(row["caption"], row["image"])

Esto devolverá la descripción de la imagen y los bytes de la imagen en una sola solicitud.

Vortex

Vortex es un formato de archivo columnar diseñado para escaneos rápidos sobre datos comprimidos. Instálalo con pip install vortex-data y luego carga archivos .vortex como cualquier otro formato empaquetado:

>>> from datasets import load_dataset
>>> dataset = load_dataset("vortex", data_files="data.vortex", split="train")

Las columnas y los filtros se aplican directamente en la lectura de Vortex, por lo que solo se leen las filas y columnas que se solicitan. Esto funciona también durante la transmisión en streaming, lo que permite filtrar un conjunto de datos en el Hub sin descargar las partes que no coinciden:

>>> filters = [("label", "==", 1)]
>>> dataset = load_dataset(vortex_dataset_id, columns=["text", "label"], filters=filters, streaming=True, split="train")

Los filtros utilizan la misma forma normal disyuntiva que el cargador de Parquet: una lista de predicados (column, operator, value) es una conjunción, y una lista de esas listas es una disyunción. Los valores nulos siguen la semántica de SQL: un nulo no satisface ninguna comparación, por lo que una fila cuya columna filtrada es nula nunca se devuelve, incluso en el caso de not in. Para lo que esa forma no puede expresar, pase en su lugar una expresión de Vortex:

>>> import vortex.expr as ve
>>> dataset = load_dataset(vortex_dataset_id, filters=ve.column("score") >= 0.5, split="train")

Vortex abre los archivos por sí mismo en lugar de a través de fsspec, por lo que data_files puede apuntar a rutas locales, conjuntos de datos del Hub y las ubicaciones remotas que Vortex lee de forma nativa (HTTP y los almacenes de objetos comunes), pero no dentro de archivos de compresión (zip://...) ni con otros protocolos exclusivos de fsspec.

Archivos HDF5

Los archivos HDF5 se utilizan comúnmente para almacenar grandes cantidades de datos numéricos en computación científica y aprendizaje automático. Cargar archivos HDF5 con 🤗 Datasets es similar a cargar archivos CSV:

>>> from datasets import load_dataset
>>> dataset = load_dataset("hdf5", data_files="data.h5")

Tenga en cuenta que el cargador de HDF5 asume que el archivo tiene una estructura “tabular”, es decir, que todos los conjuntos de datos del archivo tienen (el mismo número de) filas en su primera dimensión.

TsFile

TsFile es un formato de archivo columnar diseñado para datos de series temporales, utilizado como capa de almacenamiento nativa de Apache IoTDB. Representa de forma nativa marcas de tiempo, etiquetas de dispositivos y campos de medición, y mantiene un índice temporal interno que permite una poda eficiente por rango de tiempo.

Cada fila del conjunto de datos resultante corresponde a un device (identificado por sus columnas TAG); la columna time y cada columna FIELD son columnas de listas que contienen la serie temporal completa de ese dispositivo, ordenada en orden ascendente de tiempo.

Para cargar un TsFile:

>>> from datasets import load_dataset
>>> dataset = load_dataset("tsfile", data_files="my_data.tsfile")

Filtrar por rango de tiempo: los límites se aplican al índice de tiempo interno de TsFile y aceptan int epochs, datetime, date, cadenas ISO-8601 o escalares de timestamp de pyarrow:

>>> from datetime import datetime
>>> dataset = load_dataset(
...     "tsfile",
...     data_files="my_data.tsfile",
...     start_time=datetime(2023, 11, 14),
...     end_time=datetime(2023, 11, 15),
... )

Para más detalles, consulta la guía cómo cargar datos de TsFile.

Harbor

Los conjuntos de datos de Harbor son colecciones de tareas utilizadas para evaluar agentes de IA. Están compuestos por directorios en lugar de archivos de datos: cada tarea es un directorio con un archivo de configuración task.toml y un archivo instruction.md, además de su entorno, verificador y solución.

Cada fila del conjunto de datos resultante describe una tarea (su instrucción, su task.toml, los archivos que incluye) y su carga nunca ejecuta nada:

>>> from datasets import load_dataset
>>> dataset = load_dataset("harborframework/terminal-bench")
>>> dataset["train"][0]["task_id"]
'tasks/atrx-vep-crispr'

Para más detalles, consulta la guía cómo cargar tareas de evaluación de agentes.

PDB

PDB (Protein Data Bank) es el formato de ancho fijo heredado para representar estructuras macromoleculares en 3D. Aunque mmCIF es el estándar moderno, PDB sigue siendo de uso generalizado y muchos conjuntos de datos históricos están en este formato.

Cada fila es un archivo de estructura, siguiendo el mismo diseño de carpetas que ImageFolder: los nombres de las subcarpetas se convierten en etiquetas y un archivo metadata.csv/metadata.jsonl añade metadatos por estructura. La columna structure utiliza BioStructure con format="pdb" y se decodifica en un objeto Bio.PDB.Structure.Structure que contiene los modelos, cadenas, residuos y átomos del archivo. La decodificación requiere biopython; sin él, acceder a una estructura decodificada provoca un ImportError.

Para cargar archivos PDB desde un directorio:

>>> from datasets import BioStructure, load_dataset
>>> dataset = load_dataset("pdb", data_dir="path/to/structures")
>>> dataset["train"].features["structure"]
BioStructure(format='pdb', decode=True)

Para acceder al diccionario subyacente {"bytes": ..., "path": ...} sin decodificarlo o requerir biopython, convierta la columna con decode=False:

>>> dataset = dataset.cast_column("structure", BioStructure(format="pdb", decode=False))

Se admiten las extensiones .pdb y .ent.

SQL

Lee el contenido de la base de datos con from_sql() especificando la URI para conectarte a tu base de datos. Puedes leer tanto nombres de tablas como consultas:

>>> from datasets import Dataset
# load entire table
>>> dataset = Dataset.from_sql("data_table_name", con="sqlite:///sqlite_file.db")
# load from query
>>> dataset = Dataset.from_sql("SELECT text FROM table WHERE length(text) > 100 LIMIT 10", con="sqlite:///sqlite_file.db")

Para más detalles, consulta la guía cómo cargar conjuntos de datos tabulares desde bases de datos SQL.

WebDataset

El formato WebDataset se basa en archivos TAR y es adecuado para grandes conjuntos de datos de imágenes. Debido a su tamaño, los WebDatasets generalmente se cargan en modo de transmisión (usando streaming=True).

Puedes cargar un WebDataset de esta manera:

>>> from datasets import load_dataset
>>>
>>> path = "path/to/train/*.tar"
>>> dataset = load_dataset("webdataset", data_files={"train": path}, split="train", streaming=True)

Para cargar WebDatasets remotos a través de HTTP, pase las URL en su lugar:

>>> from datasets import load_dataset
>>>
>>> base_url = "https://huggingface.co/datasets/lhoestq/small-publaynet-wds/resolve/main/publaynet-train-{i:06d}.tar"
>>> urls = [base_url.format(i=i) for i in range(4)]
>>> dataset = load_dataset("webdataset", data_files={"train": urls}, split="train", streaming=True)

mmCIF

mmCIF (macromolecular Crystallographic Information File) es el formato estándar moderno para representar estructuras macromoleculares en 3D, utilizado por el Protein Data Bank (PDB) desde 2014.

Cada fila es un archivo de estructura, siguiendo el mismo diseño de carpetas que ImageFolder: los nombres de las subcarpetas se convierten en etiquetas y un archivo metadata.csv/metadata.jsonl añade metadatos por estructura. La columna structure utiliza BioStructure con format="mmcif" y se decodifica en un objeto Bio.PDB.Structure.Structure que contiene los modelos, cadenas, residuos y átomos del archivo. La decodificación requiere biopython; sin él, acceder a una estructura decodificada provoca un ImportError.

Para cargar archivos mmCIF desde un directorio:

>>> from datasets import BioStructure, load_dataset
>>> dataset = load_dataset("mmcif", data_dir="path/to/structures")
>>> dataset["train"].features["structure"]
BioStructure(format='mmcif', decode=True)

Para acceder al diccionario subyacente {"bytes": ..., "path": ...} sin decodificarlo o requerir biopython, convierta la columna con decode=False:

>>> dataset = dataset.cast_column("structure", BioStructure(format="mmcif", decode=False))

Se admiten las extensiones .cif y .mmcif.

GenBank

GenBank es un formato basado en texto de NCBI para secuencias de nucleótidos y proteínas junto con sus anotaciones. Los archivos usan la extensión .gb, .gbk o .genbank (opcionalmente comprimidos) y la sección FEATURES de cada registro se decodifica en objetos estructurados.

Además de las columnas analizadas ligeras, cada fila incluye una columna record de tipo BioSequence(format="genbank"), que se decodifica en un Bio.SeqRecord.SeqRecord cuando biopython está instalado. Convierta esta columna a BioSequence(format="genbank", decode=False) para acceder a los bytes del registro original como {"bytes": ..., "path": None}, u omita la columna con columns=[...] para usar solo las columnas analizadas sin biopython.

Para cargar archivos GenBank:

>>> from datasets import load_dataset
>>> dataset = load_dataset("genbank", data_files="*.gb", split="train")

Puede probarlo con un pequeño conjunto de datos de ejemplo con registros reales de NCBI (uno de ellos está comprimido con gzip para mostrar que los archivos comprimidos se cargan de forma transparente):

>>> from datasets import load_dataset
>>> dataset = load_dataset("ermiaazarkhalili/datasets-genbank-test", data_files="*.gb*", split="train")
>>> dataset[0]["locus_name"], dataset[0]["organism"], dataset[0]["length"]

FASTQ

FASTQ es un formato basado en texto para almacenar secuencias de nucleótidos junto con sus puntuaciones de calidad, ampliamente utilizado para datos de secuenciación de alto rendimiento.

Cargar un archivo FASTQ:

>>> from datasets import load_dataset
>>> dataset = load_dataset("fastq", data_files="reads.fq")

El cargador devuelve cinco columnas:

Leer las columnas analizadas no requiere Biopython; excluya record con columns, o use dataset.cast_column("record", BioSequence(decode=False)) (importado de datasets) para acceder a su almacenamiento {"bytes": ..., "path": None} sin decodificarlo.

Cargar solo columnas específicas:

>>> dataset = load_dataset("fastq", data_files="reads.fq", columns=["sequence", "quality"])

Los archivos comprimidos (.fq.gz, .fastq.gz, .fq.bz2, .fq.xz) se detectan y descomprimen automáticamente.

FASTA

FASTA es un formato basado en texto para representar secuencias de nucleótidos (ADN/ARN) o secuencias de péptidos (proteínas), ampliamente utilizado en bioinformática.

Para cargar un archivo FASTA:

>>> from datasets import load_dataset
>>> dataset = load_dataset("fasta", data_files="sequences.fasta")

Esto devuelve un conjunto de datos con las siguientes columnas:

• id: Identificador de la secuencia (primera palabra después de >)
• description: Línea de descripción completa (todo lo que sigue al id)
• sequence: La secuencia biológica (ADN/ARN/proteína)
• record: Un BioSequence con format="fasta" que almacena los bytes originales de cada registro y los decodifica a un SeqRecord de Biopython cuando se accede a él.

Leer las columnas analizadas no requiere Biopython; excluya record con columns, o use dataset.cast_column("record", BioSequence(decode=False)) (importado de datasets) para acceder a su almacenamiento {"bytes": ..., "path": None} sin decodificarlo.

También puede cargar solo columnas específicas:

>>> dataset = load_dataset("fasta", data_files="sequences.fa", columns=["id", "sequence"])

Se admiten archivos FASTA con varias extensiones: .fa, .fasta, .fna (ácido nucleico), .ffn (nucleótido de regiones génicas), .faa (ácido amino) y .frn (ARN no codificante). Los archivos comprimidos (gzip, bzip2, xz) se detectan y descomprimen automáticamente.

Archivos remotos

Si tienes archivos remotos, probablemente almacenados como csv, json, txt, parquet o cualquier formato compatible, la función load_dataset() puede cargarlos si especificas sus rutas remotas:

• URLs https:// para archivos en línea públicos, p. ej. data_files=["https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json"]
• URLs hf:// para archivos en cualquier repositorio de Dataset o Storage Bucket en Hugging Face, por ejemplo data_files=["hf://datasets/karpathy/tinystories-gpt4-clean/tinystories_gpt4_clean.parquet"] o data_files=["hf://buckets/julien-c/my-training-bucket/julien/affluence.csv"]

Multiprocesamiento

Cuando un conjunto de datos está compuesto por varios archivos (a los que llamamos “shards”), es posible acelerar significativamente la descarga y la preparación del conjunto de datos.

Puedes elegir cuántos procesos quieres usar para preparar un conjunto de datos en paralelo mediante num_proc. En este caso, a cada proceso se le asigna un subconjunto de fragmentos para preparar:

from datasets import load_dataset

imagenet = load_dataset("timm/imagenet-1k-wds", num_proc=8)
ml_librispeech_spanish = load_dataset("facebook/multilingual_librispeech", "spanish", num_proc=8)

Datos en memoria

🤗 Datasets también te permitirá crear un Dataset directamente a partir de estructuras de datos en memoria, como diccionarios de Python y DataFrames de Pandas.

Diccionario de Python

Carga diccionarios de Python con from_dict():

>>> from datasets import Dataset
>>> my_dict = {"a": [1, 2, 3]}
>>> dataset = Dataset.from_dict(my_dict)

Lista de diccionarios en Python

Carga una lista de diccionarios de Python con from_list():

>>> from datasets import Dataset
>>> my_list = [{"a": 1}, {"a": 2}, {"a": 3}]
>>> dataset = Dataset.from_list(my_list)

Generador de Python

Cree un dataset a partir de un generador de Python con from_generator():

>>> from datasets import Dataset
>>> def my_gen():
...     for i in range(1, 4):
...         yield {"a": i}
...
>>> dataset = Dataset.from_generator(my_gen)

Este enfoque permite cargar datos de mayor tamaño que la memoria disponible.

También puede definir un conjunto de datos fragmentado pasando listas a gen_kwargs:

>>> def gen(shards):
...     for shard in shards:
...         with open(shard) as f:
...             for line in f:
...                 yield {"line": line}
...
>>> shards = [f"data{i}.txt" for i in range(32)]
>>> ds = IterableDataset.from_generator(gen, gen_kwargs={"shards": shards})
>>> ds = ds.shuffle(seed=42, buffer_size=10_000)  # shuffles the shards order + uses a shuffle buffer
>>> from torch.utils.data import DataLoader
>>> dataloader = DataLoader(ds.with_format("torch"), num_workers=4)  # give each worker a subset of 32/4=8 shards

Pandas DataFrame

Carga DataFrames de Pandas con from_pandas():

>>> from datasets import Dataset
>>> import pandas as pd
>>> df = pd.DataFrame({"a": [1, 2, 3]})
>>> dataset = Dataset.from_pandas(df)

Para más detalles, consulta la guía cómo cargar conjuntos de datos tabulares desde DataFrames de Pandas.

Offline

Aunque no tengas una conexión a internet, sigue siendo posible cargar un conjunto de datos. Siempre que hayas descargado un conjunto de datos del repositorio de Hub antes, debería estar en caché. Esto significa que puedes recargar el conjunto de datos desde la caché y usarlo sin conexión.

Si sabes que no tendrás acceso a internet, puedes ejecutar 🤗 Datasets en modo totalmente sin conexión. Esto ahorra tiempo porque, en lugar de esperar a que la descarga del Dataset builder expire, 🤗 Datasets buscará directamente en la caché. Establece la variable de entorno HF_HUB_OFFLINE en 1 para habilitar el modo totalmente sin conexión.

Divisiones de Slice

También puede elegir cargar solo fragmentos específicos de una división. Hay dos opciones para dividir una división: usar cadenas de texto o la API ReadInstruction. Las cadenas de texto son más compactas y legibles para casos simples, mientras que ReadInstruction es más fácil de usar con parámetros de división variables.

Concatenar una división train y una test mediante:

 
String API 
ReadInstruction
>>> train_test_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train+test")

Selecciona filas específicas de la división train:

 
String API 
ReadInstruction
>>> train_10_20_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[10:20]")

O seleccione un porcentaje de una división con:

 
String API 
ReadInstruction
>>> train_10pct_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[:10%]")

Seleccione una combinación de porcentajes de cada división:

 
String API 
ReadInstruction
>>> train_10_80pct_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[:10%]+train[-80%:]")

Por último, incluso puedes crear divisiones con validación cruzada. El ejemplo siguiente crea divisiones con validación cruzada de 10 pliegues. Cada conjunto de validación es un fragmento del 10%, y el conjunto de entrenamiento constituye el fragmento complementario restante del 90%:

 
String API 
ReadInstruction
>>> val_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split=[f"train[{k}%:{k+10}%]" for k in range(0, 100, 10)])
>>> train_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split=[f"train[:{k}%]+train[{k+10}%:]" for k in range(0, 100, 10)])

Recorte y redondeo porcentual

El comportamiento predeterminado es redondear los límites al entero más cercano para los conjuntos de datos en los que los límites de la porción solicitada no se dividen exactamente entre 100. Como se muestra a continuación, algunas porciones pueden contener más ejemplos que otras. Por ejemplo, si la siguiente división de entrenamiento incluye 999 registros, entonces:

# 19 records, from 500 (included) to 519 (excluded).
>>> train_50_52_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[50%:52%]")
# 20 records, from 519 (included) to 539 (excluded).
>>> train_52_54_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[52%:54%]")

Si desea divisiones de tamaño igual, use el redondeo pct1_dropremainder en su lugar. Esto trata los límites de porcentaje especificados como múltiplos de 1%.

# 18 records, from 450 (included) to 468 (excluded).
>>> train_50_52pct1_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split=datasets.ReadInstruction("train", from_=50, to=52, unit="%", rounding="pct1_dropremainder"))
# 18 records, from 468 (included) to 486 (excluded).
>>> train_52_54pct1_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split=datasets.ReadInstruction("train",from_=52, to=54, unit="%", rounding="pct1_dropremainder"))
# Or equivalently:
>>> train_50_52pct1_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[50%:52%](pct1_dropremainder)")
>>> train_52_54pct1_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[52%:54%](pct1_dropremainder)")

El redondeo pct1_dropremainder puede truncar los últimos ejemplos de un conjunto de datos si el número de ejemplos no es divisible exactamente entre 100.

Solución de problemas

A veces, es posible que obtenga resultados inesperados al cargar un conjunto de datos. Dos de los problemas más comunes con los que puede encontrarse son la descarga manual de un conjunto de datos y la especificación de las características de un conjunto de datos.

Especificar características

Cuando creas un dataset a partir de archivos locales, las Features se infieren automáticamente mediante Apache Arrow. Sin embargo, las características del dataset no siempre coinciden con lo que esperas, o quizás prefieras definir las características tú mismo. El siguiente ejemplo muestra cómo puedes añadir etiquetas personalizadas con la característica ClassLabel.

Comience definiendo sus propias etiquetas con la clase Features:

>>> class_names = ["sadness", "joy", "love", "anger", "fear", "surprise"]
>>> emotion_features = Features({'text': Value('string'), 'label': ClassLabel(names=class_names)})

A continuación, especifique el parámetro features en load_dataset() con las características que acaba de crear:

>>> dataset = load_dataset('csv', data_files=file_dict, delimiter=';', column_names=['text', 'label'], features=emotion_features)

Ahora, al revisar las características de tu conjunto de datos, puedes ver que utiliza las etiquetas personalizadas que definiste:

>>> dataset['train'].features
{'text': Value('string'),
'label': ClassLabel(names=['sadness', 'joy', 'love', 'anger', 'fear', 'surprise'])}