# 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:

```bash
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.

> [!TIP]
> Consulte la sección [Tokenizers](https://huggingface.co/course/chapter2/4?fw=pt) 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](https://huggingface.co/datasets/rotten_tomatoes) y el tokenizador correspondiente a un modelo [BERT](https://huggingface.co/bert-base-uncased) 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.

```py
>>> 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:

```py
>>> 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()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.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`:

```py
>>> 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:

Use la función [set_format()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.set_format) para establecer el formato del conjunto de datos de forma compatible con PyTorch:

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

Use la función [to_tf_dataset()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.to_tf_dataset) para establecer el formato del conjunto de datos de forma compatible con TensorFlow. También deberá importar un [data collator](https://huggingface.co/docs/transformers/main_classes/data_collator#transformers.DataCollatorWithPadding) de 🤗 Transformers para combinar las longitudes de secuencia variables en un único lote de longitudes iguales:

```py
>>> 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](https://huggingface.co/datasets/PolyAI/minds14), la característica [Audio](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Audio) y el extractor de características correspondiente a un modelo [Wav2Vec2](https://huggingface.co/facebook/wav2vec2-base-960h) preentrenado:

```py
>>> 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:

```py
>>> 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()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.cast_column) y establezca el parámetro `sampling_rate` en la característica [Audio](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.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:

```py
>>> 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()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.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`:

```py
>>> 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](https://huggingface.co/datasets/AI-Lab-Makerere/beans), la característica `Image` y el extractor de características correspondiente a un modelo [ViT](https://huggingface.co/google/vit-base-patch16-224-in21k) preentrenado:

```py
>>> 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.

```py
>>> 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()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.cast_column) para establecer el modo en RGB:

```py
>>> 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](https://albumentations.ai) es una popular biblioteca de aumento de imágenes que ofrece un [conjunto amplio de transformaciones](https://albumentations.ai/docs/reference/supported-targets-by-transform/), incluidas transformaciones a nivel espacial, a nivel de píxel y a nivel de mezcla.

Instale Albumentations:

```bash
pip install albumentations
```

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

```py
>>> 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:

```py
>>> 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()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.with_transform):

```py
>>> 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!