Preprocesar

Además de cargar conjuntos de datos, el otro objetivo principal de 🤗 Datasets es ofrecer un conjunto diverso de funciones de preprocesamiento para poner un conjunto de datos en un formato adecuado para el entrenamiento con tu framework de machine learning.

Existen muchas formas posibles de preprocesar un conjunto de datos, y todo depende de tu conjunto de datos específico. A veces es posible que necesites renombrar una columna, y otras veces es posible que necesites aplanar campos anidados. 🤗 Datasets proporciona una forma de hacer la mayoría de estas cosas. Pero en casi todos los casos de preprocesamiento, dependiendo de la modalidad de tu conjunto de datos, necesitarás:

• Tokenizar un conjunto de datos de texto.
• Re-muestrear un conjunto de datos de audio.
• Aplicar transformaciones a un conjunto de datos de imágenes.

El último paso de preprocesamiento suele ser configurar el formato de tu conjunto de datos para que sea compatible con el formato de entrada esperado por tu framework de aprendizaje automático.

En este tutorial, también necesitarás instalar la biblioteca 🤗 Transformers:

pip install transformers

Graba un conjunto de datos de tu elección y sigue el proceso

Tokenizar texto

Los modelos no pueden procesar texto sin procesar, por lo que es necesario convertir el texto en números. La tokenización ofrece una forma de hacerlo dividiendo el texto en palabras individuales llamadas tokens. Los tokens se convierten finalmente en números.

Consulte la sección Tokenizers en el Capítulo 2 del curso de Hugging Face para obtener más información sobre la tokenización y los diferentes algoritmos de tokenización.

1. Comience cargando el conjunto de datos rotten_tomatoes y el tokenizador correspondiente a un modelo BERT preentrenado. Es importante usar el mismo tokenizador que el modelo preentrenado, ya que desea asegurarse de que el texto se divida de la misma manera.

>>> from transformers import AutoTokenizer
>>> from datasets import load_dataset

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> dataset = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train")

2. Llama a tu tokenizador sobre la primera fila de text en el conjunto de datos:

>>> tokenizer(dataset[0]["text"])
{'input_ids': [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': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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': [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]}

El tokenizador devuelve un diccionario con tres elementos:

• input_ids: los números que representan los tokens en el texto.
• token_type_ids: indica a qué secuencia pertenece un token si hay más de una secuencia.
• attention_mask: indica si un token debe enmascararse o no.

Estos valores son en realidad las entradas del modelo.

3. La forma más rápida de tokenizar todo tu conjunto de datos es usar la función map(). Esta función acelera la tokenización aplicando el tokenizador a lotes de ejemplos en lugar de a ejemplos individuales. Establece el parámetro batched en True:

>>> def tokenization(example):
...     return tokenizer(example["text"])

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

4. Establezca el formato de su conjunto de datos para que sea compatible con su marco de aprendizaje automático:

>>> dataset.set_format(type="torch", columns=["input_ids", "token_type_ids", "attention_mask", "label"])
>>> dataset.format['type']
'torch'

>>> from transformers import DataCollatorWithPadding

>>> data_collator = DataCollatorWithPadding(tokenizer=tokenizer, return_tensors="tf")
>>> tf_dataset = dataset.to_tf_dataset(
...     columns=["input_ids", "token_type_ids", "attention_mask"],
...     label_cols=["label"],
...     batch_size=2,
...     collate_fn=data_collator,
...     shuffle=True
... )

5. ¡El conjunto de datos está listo para el entrenamiento con tu framework de machine learning!

Re-muestrear señales de audio

Las entradas de audio, al igual que los conjuntos de datos de texto, deben dividirse en puntos de datos discretos. Esto se conoce como muestreo; la tasa de muestreo indica cuánto de la señal de voz se captura por segundo. Es importante asegurarse de que la tasa de muestreo de su conjunto de datos coincida con la tasa de muestreo de los datos utilizados para preentrenar el modelo que está utilizando. Si las tasas de muestreo son diferentes, el modelo preentrenado puede tener un rendimiento deficiente en su conjunto de datos porque no reconoce las diferencias en la tasa de muestreo.

1. Comience cargando el conjunto de datos MInDS-14, la característica Audio y el extractor de características correspondiente a un modelo Wav2Vec2 preentrenado:

>>> from transformers import AutoFeatureExtractor
>>> from datasets import load_dataset, Audio

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")
>>> dataset = load_dataset("PolyAI/minds14", "en-US", split="train")

2. Acceda a la primera fila del conjunto de datos. Al llamar a la columna audio del conjunto de datos, se decodifica y se re-muestrea automáticamente:

>>> audio = dataset[0]["audio"]
>>> print(audio)
<datasets.features._torchcodec.AudioDecoder object at 0x11642b6a0>
>>> audio.get_all_samples().sample_rate
8000

3. Leer la tarjeta de un conjunto de datos es increíblemente útil y puede proporcionarte mucha información sobre él. Una rápida mirada a la tarjeta del conjunto de datos MInDS-14 te indica que la tasa de muestreo es de 8 kHz. Del mismo modo, puedes obtener muchos detalles sobre un modelo desde su tarjeta de modelo. La tarjeta del modelo Wav2Vec2 indica que fue muestreado con audio de voz a 16 kHz. Esto significa que necesitarás aumentar la tasa de muestreo del conjunto de datos MInDS-14 para que coincida con la tasa de muestreo del modelo.

Utilice la función cast_column() y establezca el parámetro sampling_rate en la característica Audio para aumentar la frecuencia de muestreo de la señal de audio. Cuando ahora llame a la columna audio, se decodificará y se re-muestreará a 16 kHz:

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

4. Utilice la función map() para re-muestrear todo el conjunto de datos a 16 kHz. Esta función acelera el re-muestreo aplicando el extractor de características a lotes de ejemplos en lugar de a ejemplos individuales. Establezca el parámetro batched en True:

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

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

5. ¡El conjunto de datos está listo para el entrenamiento con tu framework de machine learning!

Aplicar aumentos de datos

El preprocesamiento más común que realizarás con conjuntos de datos de imágenes es la ampliación de datos, un proceso que introduce variaciones aleatorias en una imagen sin cambiar el significado de los datos. Esto puede implicar cambiar las propiedades de color de una imagen o recortarla aleatoriamente. Puedes usar libremente cualquier biblioteca de ampliación de datos que prefieras, y 🤗 Datasets te ayudará a aplicar tus ampliaciones de datos a tu conjunto de datos.

1. Comience cargando el conjunto de datos Beans, la característica Image y el extractor de características correspondiente a un modelo ViT preentrenado:

>>> from transformers import AutoImageProcessor
>>> from datasets import load_dataset, Image

>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224-in21k")
>>> dataset = load_dataset("AI-Lab-Makerere/beans", split="train")

2. Acceda a la primera fila del conjunto de datos. Al llamar a la columna image del conjunto de datos, el objeto PIL subyacente se decodifica automáticamente en una imagen.

>>> dataset[0]["image"]
<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=500x500 at 0x7FE5A047CC70>

La mayoría de los modelos de imágenes esperan que la imagen esté en modo RGB. Las imágenes de Beans ya están en modo RGB, pero 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"))

3. Ahora apliquemos aumentos de datos a tus imágenes. 🤗 Datasets funciona con cualquier biblioteca de aumentos y, en este ejemplo, usaremos Albumentations.

Albumentations es una popular biblioteca de aumento de imágenes que ofrece un conjunto amplio de transformaciones, incluidas transformaciones a nivel espacial, a nivel de píxel y a nivel de mezcla.

Instale Albumentations:

pip install albumentations

4. Crea un pipeline de aumentación típico con Albumentations:

>>> import albumentations as A
>>> import numpy as np
>>> from PIL import Image

>>> transform = A.Compose([
...     A.RandomCrop(height=256, width=256, pad_if_needed=True, p=1),
...     A.HorizontalFlip(p=0.5),
...     A.ColorJitter(p=0.5)
... ])

5. Dado que 🤗 Datasets utiliza imágenes de PIL pero Albumentations espera matrices de NumPy, es necesario convertir entre formatos:

>>> def albumentations_transforms(examples):
...     # Apply Albumentations transforms
...     transformed_images = []
...     for image in examples["image"]:
...         # Convert PIL to numpy array (OpenCV format)
...         image_np = np.array(image.convert("RGB"))
...         
...         # Apply Albumentations transforms
...         transformed_image = transform(image=image_np)["image"]
...         
...         # Convert back to PIL Image
...         pil_image = Image.fromarray(transformed_image)
...         transformed_images.append(pil_image)
...     
...     examples["pixel_values"] = transformed_images
...     return examples

6. Aplique la transformación usando with_transform():

>>> dataset = dataset.with_transform(albumentations_transforms)
>>> dataset[0]["pixel_values"]

Puntos clave al usar Albumentations con 🤗 Datasets:

• Convierta las imágenes de PIL en matrices de NumPy antes de aplicar transformaciones
• Albumentations devuelve un diccionario con la imagen transformada bajo la clave “image”
• Convierte el resultado de nuevo al formato PIL después de la transformación

7. ¡El conjunto de datos está listo para el entrenamiento con tu framework de machine learning!