# 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](./tutorial), 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](https://huggingface.co/datasets). 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!

  
    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg" href="#audio"
    >
      
        Audio
      
      
        Re-muestrear un conjunto de datos de audio y prepararlo para que un modelo clasifique el tipo de problema bancario sobre el que está llamando un hablante.
      
    
    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg" href="#vision"
    >
      
        Visión
      
      
        Aplica la aumentación de datos a un conjunto de datos de imágenes y prepáralo para un modelo que diagnostique enfermedades en plantas de frijol.
      
    
    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg" href="#nlp"
    >
      
        NLP
      
      
        Tokeniza un conjunto de datos y prepáralo para que un modelo determine si un par de oraciones tienen el mismo significado.
      
    
  

> [!TIP]
> Consulte el [Capítulo 5](https://huggingface.co/course/chapter5/1?fw=pt) 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:

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

  ```bash
  pip install datasets[audio]
  ```

- Para trabajar con conjuntos de datos de imágenes, instale la función [Image](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Image):

  ```bash
  pip install datasets[vision]
  ```

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

  ```bash pip install torch ```
  ```bash pip install tensorflow ```

## Audio

Audio datasets are loaded just like text datasets. However, an audio dataset is preprocessed a bit differently. Instead of a tokenizer, you'll need a [feature extractor](https://huggingface.co/docs/transformers/main_classes/feature_extractor#feature-extractor). An audio input may also require resampling its sampling rate to match the sampling rate of the pretrained model you're using. In this quickstart, you'll prepare the [MInDS-14](https://huggingface.co/datasets/PolyAI/minds14) dataset for a model train on and classify the banking issue a customer is having.

**1**. Load the MInDS-14 dataset by providing the [load_dataset()](/docs/datasets/v5.2.0/es/package_reference/loading_methods#datasets.load_dataset) function with the dataset name, dataset configuration (not all datasets will have a configuration), and a dataset split:

```py
>>> from datasets import load_dataset, Audio

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

**2**. A continuación, carga un modelo [Wav2Vec2](https://huggingface.co/facebook/wav2vec2-base) preentrenado y su extractor de características correspondiente desde la biblioteca [🤗 Transformers](https://huggingface.co/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.

```py
>>> 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](https://huggingface.co/datasets/PolyAI/minds14) indica que la tasa de muestreo es de 8 kHz, pero el modelo Wav2Vec2 se preentrenó 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()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.cast_column) y la característica [Audio](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Audio) para que coincida con la tasa de muestreo del modelo.

```py
>>> 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()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.map) para acelerar el procesamiento aplicando la función a lotes de ejemplos en el conjunto de datos.

```py
>>> 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()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.rename_column) para renombrar la columna `intent_class` a `labels`, que es el nombre de entrada esperado en [Wav2Vec2ForSequenceClassification](https://huggingface.co/docs/transformers/main/en/model_doc/wav2vec2#transformers.Wav2Vec2ForSequenceClassification):

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

Use the function [set_format()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.set_format) para establecer el formato del conjunto de datos en `torch` y especificar las columnas que desea formatear. Esta función aplica el formato sobre la marcha. Después de convertir en tensores de PyTorch, envuelva el conjunto de datos en [`torch.utils.data.DataLoader`](https://alband.github.io/doc_view/data.html?highlight=torch%20utils%20data%20dataloader#torch.utils.data.DataLoader):

```py
>>> from torch.utils.data import DataLoader

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

Utilice el método `prepare_tf_dataset` de 🤗 Transformers para preparar el conjunto de datos de forma que sea compatible con TensorFlow y esté listo para entrenar o afinar un modelo, ya que envuelve un [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) de HuggingFace como un `tf.data.Dataset` con colación y lotes, lo que permite pasarlo directamente a métodos de Keras como `fit()` sin modificaciones adicionales.

```py
>>> 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](https://huggingface.co/docs/transformers/tasks/audio_classification) 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](https://huggingface.co/docs/transformers/main_classes/feature_extractor#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](https://huggingface.co/datasets/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()](/docs/datasets/v5.2.0/es/package_reference/loading_methods#datasets.load_dataset):

```py
>>> 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()](/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"))
```

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](https://albumentations.ai/), [imgaug](https://imgaug.readthedocs.io/en/latest/), [Kornia](https://kornia.readthedocs.io/en/latest/)). Aquí, usarás [torchvision](https://pytorch.org/vision/stable/transforms.html) para cambiar aleatoriamente las propiedades de color de una imagen:

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

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

**4**. Use la función [with_transform()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.with_transform) para aplicar las aumentaciones de datos sobre la marcha:

```py
>>> dataset = dataset.with_transform(transforms)
```

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

Envuelve el conjunto de datos en [`torch.utils.data.DataLoader`](https://alband.github.io/doc_view/data.html?highlight=torch%20utils%20data%20dataloader#torch.utils.data.DataLoader). También necesitarás crear una función de collate para agrupar las muestras en lotes:

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

Utilice el método `prepare_tf_dataset` de 🤗 Transformers para preparar el conjunto de datos de forma que sea compatible con TensorFlow y esté listo para entrenar o afinar un modelo, ya que envuelve un [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) de HuggingFace como un `tf.data.Dataset` con colación y lotes, lo que permite pasarlo directamente a métodos de Keras como `fit()` sin modificaciones adicionales.

Antes de comenzar, asegúrate de tener instaladas las versiones más recientes de `albumentations` y `cv2`:

```bash
pip install -U albumentations opencv-python
```

```py
>>> 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](https://huggingface.co/docs/transformers/tasks/image_classification) 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](https://huggingface.co/docs/transformers/main_classes/tokenizer). Para la introducción rápida, cargarás el conjunto de datos de entrenamiento [Microsoft Research Paraphrase Corpus (MRPC)](https://huggingface.co/datasets/nyu-mll/glue/viewer/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()](/docs/datasets/v5.2.0/es/package_reference/loading_methods#datasets.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:

```py
>>> from datasets import load_dataset

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

**2**. A continuación, carga un modelo [BERT](https://huggingface.co/bert-base-uncased) preentrenado y su tokenizador correspondiente desde la biblioteca [🤗 Transformers](https://huggingface.co/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.

```py
>>> from transformers import AutoModelForSequenceClassification, AutoTokenizer

>>> model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased")
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
===PT-TF-SPLIT===
>>> from transformers import TFAutoModelForSequenceClassification, AutoTokenizer

>>> model = TFAutoModelForSequenceClassification.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()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.map) para acelerar el procesamiento aplicando su función de tokenización a lotes de ejemplos del conjunto de datos:

```py
>>> 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](https://huggingface.co/docs/transformers/main/en/model_doc/bert#transformers.BertForSequenceClassification):

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

Use la función [with_format()](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset.with_format) para establecer el formato del dataset en `torch` y especificar las columnas que desea formatear. Esta función aplica el formateo al vuelo. Después de convertir en tensores de PyTorch, envuelva el dataset en [`torch.utils.data.DataLoader`](https://alband.github.io/doc_view/data.html?highlight=torch%20utils%20data%20dataloader#torch.utils.data.DataLoader):

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

Utilice el método `prepare_tf_dataset` de 🤗 Transformers para preparar el conjunto de datos de forma que sea compatible con TensorFlow y esté listo para entrenar o afinar un modelo, ya que envuelve un [Dataset](/docs/datasets/v5.2.0/es/package_reference/main_classes#datasets.Dataset) de HuggingFace como un `tf.data.Dataset` con colación y lotes, lo que permite pasarlo directamente a métodos de Keras como `fit()` sin modificaciones adicionales.

```py
>>> 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](https://huggingface.co/docs/transformers/tasks/sequence_classification) 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](./how_to) 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](./about_arrow).

