Introducción

Esta guía de inicio rápido está destinada a desarrolladores que están listos para sumergirse en el código y ver un ejemplo de cómo integrar 🤗 Datasets en su flujo de trabajo de entrenamiento de modelos. Si eres principiante, te recomendamos comenzar con nuestros tutoriales, donde obtendrás una introducción más detallada.

Cada conjunto de datos es único y, dependiendo de la tarea, algunos pueden requerir pasos adicionales para prepararlo para el entrenamiento. Sin embargo, siempre puedes usar las herramientas de 🤗 Datasets para cargar y procesar un conjunto de datos. La forma más rápida y sencilla de empezar es cargando un conjunto de datos existente desde el Hugging Face Hub. Hay miles de conjuntos de datos para elegir, que abarcan muchas tareas. Elige el tipo de conjunto de datos con el que quieres trabajar y ¡empecemos!

Consulte el Capítulo 5 del curso de Hugging Face para aprender más sobre otros temas importantes, como la carga de conjuntos de datos remotos o locales, las herramientas para limpiar un conjunto de datos y la creación de su propio conjunto de datos.

Comience instalando 🤗 Datasets:

pip install datasets

🤗 Datasets también admite formatos de datos de audio e imagen:

• Para trabajar con conjuntos de datos de audio, instale la función Audio:

  Copiado

  pip install datasets[audio]

• Para trabajar con conjuntos de datos de imágenes, instale la función Image:

  Copiado

  pip install datasets[vision]

Además de 🤗 Datasets, asegúrate de que tu framework de machine learning preferido esté instalado:

Audio

Los conjuntos de datos de audio se cargan de la misma manera que los de texto. Sin embargo, un conjunto de datos de audio se preprocesa de forma ligeramente diferente. En lugar de un tokenizador, necesitarás un extractor de características. Una entrada de audio también puede requerir el re-muestreo de su tasa de muestreo para que coincida con la tasa de muestreo del modelo preentrenado que estás utilizando. En esta introducción rápida, prepararás el conjunto de datos MInDS-14 para entrenar un modelo y clasificar el problema bancario que tiene un cliente.

1. Cargue el conjunto de datos MInDS-14 proporcionando a la función load_dataset() el nombre del conjunto de datos, la configuración del conjunto de datos (no todos los conjuntos de datos tienen una configuración) y una división del conjunto de datos:

>>> from datasets import load_dataset, Audio

>>> dataset = load_dataset("PolyAI/minds14", "en-US", split="train")

2. A continuación, carga un modelo Wav2Vec2 preentrenado y su extractor de características correspondiente desde la biblioteca 🤗 Transformers. Es completamente normal ver una advertencia al cargar el modelo sobre algunos pesos que no están inicializados. Esto es esperado porque estás cargando este punto de control del modelo para entrenarlo con otra tarea.

>>> from transformers import AutoModelForAudioClassification, AutoFeatureExtractor

>>> model = AutoModelForAudioClassification.from_pretrained("facebook/wav2vec2-base")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base")

3. La tarjeta del conjunto de datos MInDS-14 indica que la tasa de muestreo es de 8 kHz, pero el modelo Wav2Vec2 fue preentrenado con una tasa de muestreo de 16 kHz. Deberás aumentar la tasa de muestreo de la columna audio con la función cast_column() y la característica Audio para que coincida con la tasa de muestreo del modelo.

>>> dataset = dataset.cast_column("audio", Audio(sampling_rate=16000))
>>> dataset[0]["audio"]
<datasets.features._torchcodec.AudioDecoder object at 0x11642b6a0>

4. Crea una función para preprocesar el array de audio con el extractor de características, y trunca y rellena las secuencias en tensores rectangulares ordenados. Lo más importante que debes recordar es llamar al array de audio en el extractor de características, ya que el array (la señal de voz real) es la entrada del modelo.

Una vez que tenga una función de preprocesamiento, use la función map() para acelerar el procesamiento aplicando la función a lotes de ejemplos en el conjunto de datos.

>>> def preprocess_function(examples):
...     audio_arrays = [x.get_all_samples().data for x in examples["audio"]]
...     inputs = feature_extractor(
...         audio_arrays,
...         sampling_rate=16000,
...         padding=True,
...         max_length=100000,
...         truncation=True,
...     )
...     return inputs

>>> dataset = dataset.map(preprocess_function, batched=True)

5. Use la función rename_column() para renombrar la columna intent_class a labels, que es el nombre de entrada esperado en Wav2Vec2ForSequenceClassification:

>>> dataset = dataset.rename_column("intent_class", "labels")

6. Establezca el formato del conjunto de datos según el marco de aprendizaje automático que esté utilizando.

>>> from torch.utils.data import DataLoader

>>> dataset.set_format(type="torch", columns=["input_values", "labels"])
>>> dataloader = DataLoader(dataset, batch_size=4)

>>> import tensorflow as tf

>>> tf_dataset = model.prepare_tf_dataset(
...     dataset,
...     batch_size=4,
...     shuffle=True,
... )

7. ¡Comienza a entrenar con tu framework de machine learning! Consulta la guía de clasificación de audio de 🤗 Transformers para un ejemplo de principio a fin sobre cómo entrenar un modelo en un conjunto de datos de audio.

Visión

Los conjuntos de datos de imágenes se cargan de la misma manera que los de texto. Sin embargo, en lugar de un tokenizer, necesitarás un feature extractor para preprocesar el conjunto de datos. Aplicar aumentación de datos a una imagen es común en visión por computadora para hacer que el modelo sea más robusto frente al sobreajuste. Puedes usar libremente cualquier biblioteca de aumentación de datos que desees y luego aplicar las aumentaciones con 🤗 Datasets. En esta introducción rápida, cargarás el conjunto de datos Beans y lo preparará para que el modelo se entrene e identifique enfermedades a partir de las imágenes de las hojas.

1. Cargue el conjunto de datos Beans proporcionando el nombre del conjunto de datos y una división del conjunto de datos a la función load_dataset():

>>> from datasets import load_dataset, Image

>>> dataset = load_dataset("AI-Lab-Makerere/beans", split="train")

La mayoría de los modelos de imagen trabajan con imágenes RBG. Si tu conjunto de datos contiene imágenes en un modo diferente, puedes usar la función cast_column() para establecer el modo en RGB:

>>> dataset = dataset.cast_column("image", Image(mode="RGB"))

El conjunto de datos Beans contiene solo imágenes RGB, por lo que este paso no es necesario aquí.

2. Ahora puedes añadir algunas aumentaciones de datos con la biblioteca que prefieras (Albumentations, imgaug, Kornia). Aquí, usarás torchvision para cambiar aleatoriamente las propiedades de color de una imagen:

>>> from torchvision.transforms import Compose, ColorJitter, ToTensor

>>> jitter = Compose(
...     [ColorJitter(brightness=0.5, hue=0.5), ToTensor()]
... )

3. Crea una función para aplicar tu transformación al conjunto de datos y generar la entrada del modelo: pixel_values.

>>> def transforms(examples):
...     examples["pixel_values"] = [jitter(image.convert("RGB")) for image in examples["image"]]
...     return examples

4. Use la función with_transform() para aplicar las aumentaciones de datos sobre la marcha:

>>> dataset = dataset.with_transform(transforms)

5. Establezca el formato del conjunto de datos según el marco de aprendizaje automático que esté utilizando.

>>> from torch.utils.data import DataLoader

>>> def collate_fn(examples):
...     images = []
...     labels = []
...     for example in examples:
...         images.append((example["pixel_values"]))
...         labels.append(example["labels"])
...
...     pixel_values = torch.stack(images)
...     labels = torch.tensor(labels)
...     return {"pixel_values": pixel_values, "labels": labels}
>>> dataloader = DataLoader(dataset, collate_fn=collate_fn, batch_size=4)

pip install -U albumentations opencv-python

>>> import albumentations
>>> import numpy as np

>>> transform = albumentations.Compose([
...     albumentations.RandomCrop(width=256, height=256),
...     albumentations.HorizontalFlip(p=0.5),
...     albumentations.RandomBrightnessContrast(p=0.2),
... ])

>>> def transforms(examples):
...     examples["pixel_values"] = [
...         transform(image=np.array(image))["image"] for image in examples["image"]
...     ]
...     return examples

>>> dataset.set_transform(transforms)
>>> tf_dataset = model.prepare_tf_dataset(
...     dataset,
...     batch_size=4,
...     shuffle=True,
... )

6. ¡Comienza a entrenar con tu framework de machine learning! Consulta la guía de clasificación de imágenes de 🤗 Transformers para un ejemplo de principio a fin sobre cómo entrenar un modelo en un conjunto de datos de imágenes.

NLP

El texto debe tokenizarse en tokens individuales mediante un tokenizer. Para la introducción rápida, cargarás el conjunto de datos de entrenamiento Microsoft Research Paraphrase Corpus (MRPC) para entrenar un modelo que determine si un par de frases tienen el mismo significado.

1. Cargue el conjunto de datos MRPC proporcionando a la función load_dataset() el nombre del conjunto de datos, la configuración del conjunto de datos (no todos los conjuntos de datos tienen una configuración) y la división del conjunto de datos:

>>> from datasets import load_dataset

>>> dataset = load_dataset("nyu-mll/glue", "mrpc", split="train")

2. A continuación, carga un modelo BERT preentrenado y su tokenizador correspondiente desde la biblioteca 🤗 Transformers. Es completamente normal ver una advertencia al cargar el modelo sobre algunos pesos que no están inicializados. Esto es esperado porque estás cargando este punto de control del modelo para entrenarlo con otra tarea.

 
Pytorch 
TensorFlow
>>> from transformers import AutoModelForSequenceClassification, AutoTokenizer

>>> model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased")
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")

3. Crea una función para tokenizar el conjunto de datos, y también debes truncar y rellenar el texto en tensores rectangulares ordenados. El tokenizador genera tres columnas nuevas en el conjunto de datos: input_ids, token_type_ids y una attention_mask. Estas son las entradas del modelo.

Use la función map() para acelerar el procesamiento aplicando su función de tokenización a lotes de ejemplos del conjunto de datos:

>>> def encode(examples):
...     return tokenizer(examples["sentence1"], examples["sentence2"], truncation=True, padding="max_length")

>>> dataset = dataset.map(encode, batched=True)
>>> dataset[0]
{'sentence1': 'Amrozi accused his brother , whom he called " the witness " , of deliberately distorting his evidence .',
'sentence2': 'Referring to him as only " the witness " , Amrozi accused his brother of deliberately distorting his evidence .',
'label': 1,
'idx': 0,
'input_ids': [  101,  7277,  2180,  5303,  4806,  1117,  1711,   117,  2292, 1119,  1270,   107,  1103,  7737,   107,   117,  1104,  9938, 4267, 12223, 21811,  1117,  2554,   119,   102, 11336,  6732, 3384,  1106,  1140,  1112,  1178,   107,  1103,  7737,   107, 117,  7277,  2180,  5303,  4806,  1117,  1711,  1104,  9938, 4267, 12223, 21811,  1117,  2554,   119,   102, 0, 0, ...],
'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, ...],
'attention_mask': [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, 0, 0, ...]}

4. Cambia el nombre de la columna label a labels, que es el nombre de entrada esperado en BertForSequenceClassification:

>>> dataset = dataset.map(lambda examples: {"labels": examples["label"]}, batched=True)

5. Establezca el formato del conjunto de datos según el marco de aprendizaje automático que esté utilizando.

>>> import torch

>>> dataset = dataset.select_columns(["input_ids", "token_type_ids", "attention_mask", "labels"])
>>> dataset = dataset.with_format(type="torch")
>>> dataloader = torch.utils.data.DataLoader(dataset, batch_size=32)

>>> import tensorflow as tf

>>> tf_dataset = model.prepare_tf_dataset(
...     dataset,
...     batch_size=4,
...     shuffle=True,
... )

6. ¡Comienza a entrenar con tu framework de machine learning! Consulta la guía de clasificación de texto de 🤗 Transformers para un ejemplo de principio a fin sobre cómo entrenar un modelo en un conjunto de datos de texto.

¿Qué sigue?

¡Con esto se completa la introducción rápida a 🤗 Datasets! Puedes cargar cualquier conjunto de datos de texto, audio o imagen con una sola función y dejarlo listo para que tu modelo se entrene con él.

Para tus próximos pasos, echa un vistazo a nuestras Guías de uso y aprende a realizar tareas más específicas, como cargar diferentes formatos de conjuntos de datos, alinear etiquetas y transmitir grandes conjuntos de datos. Si te interesa aprender más sobre los conceptos fundamentales de 🤗 Datasets, toma una taza de café y lee nuestras Guías conceptuales.