# Início rápido

Este guia rápido é destinado a desenvolvedores que estão prontos para mergulhar no código e ver um exemplo de como integrar o 🤗 Datasets ao seu fluxo de trabalho de treinamento de modelos. Se você é iniciante, recomendamos começar com nossos [tutoriais](./tutorial), onde você terá uma introdução mais completa.

Cada conjunto de dados é único e, dependendo da tarefa, alguns conjuntos de dados podem exigir etapas adicionais para prepará-los para o treinamento. Mas você sempre pode usar as ferramentas do 🤗 Datasets para carregar e processar um conjunto de dados. A maneira mais rápida e fácil de começar é carregando um conjunto de dados existente do [Hugging Face Hub](https://huggingface.co/datasets). Existem milhares de conjuntos de dados para escolher, abrangendo muitas tarefas. Escolha o tipo de conjunto de dados com o qual deseja trabalhar e vamos começar!

  
    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg" href="#audio"
    >
      
        Áudio
      
      
        Reamostra um conjunto de dados de áudio e o prepara para um modelo classificar o tipo de problema bancário sobre o qual um interlocutor está ligando.
      
    
    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg" href="#vision"
    >
      
        Visão
      
      
        Aplique aumento de dados a um conjunto de dados de imagens e prepare-o para um modelo diagnosticar doenças em plantas de feijão.
      
    
    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg" href="#nlp"
    >
      
        NLP
      
      
        Tokenize um conjunto de dados e prepare-o para um modelo determinar se um par de frases tem o mesmo significado.
      
    
  

> [!TIP]
> Confira o [Capítulo 5](https://huggingface.co/course/chapter5/1?fw=pt) do curso da Hugging Face para aprender mais sobre outros tópicos importantes, como carregar conjuntos de dados remotos ou locais, ferramentas para limpar um conjunto de dados e criar seu próprio conjunto de dados.

Comece instalando o 🤗 Datasets:

```bash
pip install datasets
```

🤗 O Datasets também suporta formatos de dados de áudio e imagem:

- Para trabalhar com conjuntos de dados de áudio, instale o recurso [Audio](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Audio):

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

- Para trabalhar com conjuntos de dados de imagens, instale o recurso [Image](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Image):

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

Além do 🤗 Datasets, verifique se o seu 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/pt/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**. Em seguida, carregue um modelo [Wav2Vec2](https://huggingface.co/facebook/wav2vec2-base) pré-treinado e o extrator de recursos correspondente a partir da biblioteca [🤗 Transformers](https://huggingface.co/transformers/). É totalmente normal ver um aviso após carregar o modelo informando que alguns pesos não foram inicializados. Isso é esperado, pois você está carregando esse checkpoint do modelo para treinamento com outra tarefa.

```py
>>> from transformers import AutoModelForAudioClassification, AutoFeatureExtractor

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

**3**. O cartão do dataset [MInDS-14](https://huggingface.co/datasets/PolyAI/minds14) indica que a taxa de amostragem é de 8 kHz, mas o modelo Wav2Vec2 foi pré-treinado com uma taxa de amostragem de 16 kHz. Você precisará fazer o upsample da coluna `audio` com a função [cast_column()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.cast_column) e o recurso [Audio](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Audio) para corresponder à taxa de amostragem do modelo.

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

**4**. Crie uma função para pré-processar o `array` de áudio com o extrator de recursos, truncando e preenchendo as sequências em tensores retangulares organizados. O mais importante a lembrar é chamar o `array` de áudio no extrator de recursos, pois o `array` — o sinal de fala real — é a entrada do modelo.

Depois de ter uma função de pré-processamento, use a função [map()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.map) para acelerar o processamento aplicando a função a lotes de exemplos no conjunto de dados.

```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 a função [rename_column()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.rename_column) para renomear a coluna `intent_class` para `labels`, que é o nome de entrada esperado em [Wav2Vec2ForSequenceClassification](https://huggingface.co/docs/transformers/main/en/model_doc/wav2vec2#transformers.Wav2Vec2ForSequenceClassification):

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

**6**. Defina o formato do conjunto de dados de acordo com o framework de machine learning que você está usando.

Use a função [set_format()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.set_format) para definir o formato do conjunto de dados como `torch` e especificar as colunas que você deseja formatar. Esta função aplica a formatação em tempo real. Após converter para tensores do PyTorch, envolva o conjunto de dados em [`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)
```

Use o método `prepare_tf_dataset` do 🤗 Transformers para preparar o dataset para que seja compatível com o TensorFlow e pronto para treinar/ajustar um modelo, pois ele encapsula um [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) do HuggingFace como um `tf.data.Dataset` com colação e loteamento, permitindo que ele seja passado diretamente para métodos do Keras como `fit()` sem modificações adicionais.

```py
>>> import tensorflow as tf

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

**7**. Comece o treinamento com seu framework de machine learning! Consulte o guia de [classificação de áudio](https://huggingface.co/docs/transformers/tasks/audio_classification) do 🤗 Transformers para um exemplo completo de como treinar um modelo em um conjunto de dados de áudio.

## Visão

Conjuntos de dados de imagens são carregados da mesma forma que conjuntos de dados de texto. No entanto, em vez de um tokenizer, você precisará de um [feature extractor](https://huggingface.co/docs/transformers/main_classes/feature_extractor#feature-extractor) para pré-processar o conjunto de dados. Aplicar aumento de dados a uma imagem é comum em visão computacional para tornar o modelo mais robusto contra overfitting. Você é livre para usar qualquer biblioteca de aumento de dados que desejar e, em seguida, pode aplicar os aumentos com 🤗 Datasets. Neste quickstart, você carregará o conjunto de dados [Beans](https://huggingface.co/datasets/beans) e o preparará para que o modelo possa treinar e identificar doenças a partir das imagens de folhas.

**1**. Carregue o conjunto de dados Beans fornecendo o nome do conjunto de dados e uma divisão do conjunto de dados para a função [load_dataset()](/docs/datasets/v5.2.0/pt/package_reference/loading_methods#datasets.load_dataset):

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

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

A maioria dos modelos de imagem trabalha com imagens RBG. Se o seu conjunto de dados contém imagens em um modo diferente, você pode usar a função [cast_column()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.cast_column) para definir o modo como RGB:

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

O conjunto de dados Beans contém apenas imagens RGB, portanto, esta etapa não é necessária aqui.

**2**. Agora você pode adicionar algumas aumentações de dados com qualquer biblioteca ([Albumentations](https://albumentations.ai/), [imgaug](https://imgaug.readthedocs.io/en/latest/), [Kornia](https://kornia.readthedocs.io/en/latest/)) que preferir. Aqui, você usará o [torchvision](https://pytorch.org/vision/stable/transforms.html) para alterar aleatoriamente as propriedades de cor de uma imagem:

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

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

**3**. Crie uma função para aplicar sua transformação ao conjunto de dados e gerar a entrada do modelo: `pixel_values`.

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

**4**. Use a função [with_transform()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.with_transform) para aplicar as aumentações de dados em tempo real:

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

**5**. Defina o formato do conjunto de dados de acordo com o framework de machine learning que você está usando.

Envolva o conjunto de dados em [`torch.utils.data.DataLoader`](https://alband.github.io/doc_view/data.html?highlight=torch%20utils%20data%20dataloader#torch.utils.data.DataLoader). Você também precisará criar uma função de colagem para agrupar as amostras em 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)
```

Use o método `prepare_tf_dataset` do 🤗 Transformers para preparar o dataset para que seja compatível com o TensorFlow e pronto para treinar/ajustar um modelo, pois ele encapsula um [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) do HuggingFace como um `tf.data.Dataset` com colação e loteamento, permitindo que ele seja passado diretamente para métodos do Keras como `fit()` sem modificações adicionais.

Antes de começar, verifique se você tem as versões mais recentes de `albumentations` e `cv2` instaladas:

```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**. Comece o treinamento com seu framework de machine learning! Confira o [guia de classificação de imagens](https://huggingface.co/docs/transformers/tasks/image_classification) do 🤗 Transformers para um exemplo completo de como treinar um modelo em um conjunto de dados de imagens.

## NLP

O texto precisa ser tokenizado em tokens individuais por um [tokenizer](https://huggingface.co/docs/transformers/main_classes/tokenizer). Para o quickstart, você carregará o conjunto de dados de treinamento [Microsoft Research Paraphrase Corpus (MRPC)](https://huggingface.co/datasets/nyu-mll/glue/viewer/mrpc) para treinar um modelo que determine se um par de frases tem o mesmo significado.

**1**. Carregue o conjunto de dados MRPC fornecendo à função [load_dataset()](/docs/datasets/v5.2.0/pt/package_reference/loading_methods#datasets.load_dataset) o nome do conjunto de dados, a configuração do conjunto de dados (nem todos os conjuntos de dados terão uma configuração) e a divisão do conjunto de dados:

```py
>>> from datasets import load_dataset

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

**2**. Em seguida, carregue um modelo [BERT](https://huggingface.co/bert-base-uncased) pré-treinado e seu tokenizer correspondente a partir da biblioteca [🤗 Transformers](https://huggingface.co/transformers/). É totalmente normal ver um aviso após carregar o modelo sobre alguns pesos não inicializados. Isso é esperado, pois você está carregando esse checkpoint do modelo para treinamento com outra tarefa.

```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**. Crie uma função para tokenizar o conjunto de dados, e você também deve truncar e preencher o texto em tensores retangulares organizados. O tokenizador gera três novas colunas no conjunto de dados: `input_ids`, `token_type_ids` e uma `attention_mask`. Estas são as entradas do modelo.

Use a função [map()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.map) para acelerar o processamento aplicando sua função de tokenização a lotes de exemplos no conjunto de dados:

```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**. Renomeie a coluna `label` para `labels`, que é o nome de entrada esperado em [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**. Defina o formato do conjunto de dados de acordo com o framework de machine learning que você está usando.

Use a função [with_format()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.with_format) para definir o formato do dataset como `torch` e especificar as colunas que você deseja formatar. Esta função aplica a formatação em tempo real. Após converter para tensores do PyTorch, envolva o dataset em [`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)
```

Use o método `prepare_tf_dataset` do 🤗 Transformers para preparar o dataset para que seja compatível com o TensorFlow e pronto para treinar/ajustar um modelo, pois ele encapsula um [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) do HuggingFace como um `tf.data.Dataset` com colação e loteamento, permitindo que ele seja passado diretamente para métodos do Keras como `fit()` sem modificações adicionais.

```py
>>> import tensorflow as tf

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

**6**. Comece o treinamento com seu framework de machine learning! Confira o [guia de classificação de texto](https://huggingface.co/docs/transformers/tasks/sequence_classification) do 🤗 Transformers para um exemplo completo de como treinar um modelo em um conjunto de dados de texto.

## O que vem a seguir?

Isso completa o quickstart do 🤗 Datasets! Você pode carregar qualquer conjunto de dados de texto, áudio ou imagem com uma única função e deixá-lo pronto para o treinamento do seu modelo.

Para os próximos passos, confira nossos [Guias de como fazer](./how_to) e aprenda a realizar tarefas mais específicas, como carregar diferentes formatos de conjunto de dados, alinhar rótulos e transmitir grandes conjuntos de dados. Se você estiver interessado em aprender mais sobre os conceitos principais do 🤗 Datasets, pegue uma xícara de café e leia nossos [Guias conceituais](./about_arrow)!