# Extratores de recursos

Os extratores de recursos pré-processam dados de áudio no formato correto para um modelo específico. Eles recebem o sinal de áudio bruto e o convertem em um tensor que pode ser enviado a um modelo. A forma do tensor depende do modelo, mas o extrator de recursos pré-processará os dados de áudio corretamente para você, com base no modelo que você está usando. Os extratores de recursos também incluem métodos para preenchimento, truncamento e reamostragem.

Chame [from_pretrained()](/docs/transformers/main/pt/model_doc/auto#transformers.AutoFeatureExtractor.from_pretrained) para carregar um extrator de recursos e sua configuração de pré-processador do [Hub](https://hf.co/models) do Hugging Face ou de um diretório local. A configuração do extrator de recursos e do pré-processador é salva em um arquivo [preprocessor_config.json](https://hf.co/openai/whisper-tiny/blob/main/preprocessor_config.json).

Passe o sinal de áudio, normalmente armazenado em `array`, para o extrator de recursos e defina o parâmetro `sampling_rate` para a taxa de amostragem dos modelos de áudio pré-treinados. É importante que a taxa de amostragem dos dados de áudio corresponda à taxa de amostragem dos dados com os quais um modelo de áudio pré-treinado foi treinado.

```py
from transformers import AutoFeatureExtractor

feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base")
dataset = load_dataset("PolyAI/minds14", name="en-US", split="train")
processed_sample = feature_extractor(dataset[0]["audio"]["array"], sampling_rate=16000)
processed_sample
{'input_values': [array([ 9.4472744e-05,  3.0777880e-03, -2.8888427e-03, ...,
       -2.8888427e-03,  9.4472744e-05,  9.4472744e-05], dtype=float32)]}
```

O extrator de recursos retorna uma entrada, `input_values`, pronta para ser consumida pelo modelo.

Este guia apresenta as classes de extrator de recursos e explica como pré-processar dados de áudio.

## Classes de extratores de recursos

Os feature extractors do Transformers herdam da classe base [SequenceFeatureExtractor](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), que é uma subclasse de [FeatureExtractionMixin](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.FeatureExtractionMixin).

- [SequenceFeatureExtractor](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) fornece um método para [pad()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) sequências até um determinado comprimento, a fim de evitar comprimentos de sequência desiguais.
- [FeatureExtractionMixin](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.FeatureExtractionMixin) fornece [from_pretrained()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) e [save_pretrained()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained) para carregar e salvar um extrator de recursos.

Existem duas formas de carregar um extrator de recursos: [AutoFeatureExtractor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoFeatureExtractor) e uma classe de extrator de recursos específica para o modelo.

A API [AutoClass](./model_doc/auto) carrega automaticamente o extrator de recursos correto para um modelo específico.

Use [from_pretrained()](/docs/transformers/main/pt/model_doc/auto#transformers.AutoFeatureExtractor.from_pretrained) para carregar um extrator de recursos.

```py
from transformers import AutoFeatureExtractor

feature_extractor = AutoFeatureExtractor.from_pretrained("openai/whisper-tiny")
```

Todo modelo de áudio pré-treinado possui um extrator de recursos específico associado para processar corretamente os dados de áudio. Ao carregar um extrator de recursos, ele recupera a configuração do extrator de recursos (tamanho do recurso, comprimento do bloco, etc.) de [preprocessor_config.json](https://hf.co/openai/whisper-tiny/blob/main/preprocessor_config.json).

Um feature extractor pode ser carregado diretamente de sua classe específica do modelo.

```py
from transformers import WhisperFeatureExtractor

feature_extractor = WhisperFeatureExtractor.from_pretrained("openai/whisper-tiny")
```

## Pré-processar

Um feature extractor espera a entrada como um tensor do PyTorch de uma forma específica. A forma exata da entrada pode variar dependendo do modelo de áudio específico que você está usando.

Por exemplo, o [Whisper](./model_doc/whisper) espera que `input_features` seja um tensor de forma `(batch_size, feature_size, sequence_length)`, mas o [Wav2Vec2](https://hf.co/docs/transformers/model_doc/wav2vec2) espera que `input_values` seja um tensor de forma `(batch_size, sequence_length)`.

O extrator de recursos gera a forma de entrada correta para o modelo de áudio que você estiver usando.

Um feature extractor também define a taxa de amostragem (o número de valores do sinal de áudio capturados por segundo) dos arquivos de áudio. A taxa de amostragem dos seus dados de áudio deve corresponder à taxa de amostragem do conjunto de dados em que um modelo pré-treinado foi treinado. Esse valor geralmente é fornecido no model card.

Carregue um conjunto de dados e um extrator de recursos com [from_pretrained()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained).

```py
from datasets import load_dataset, Audio
from transformers import AutoFeatureExtractor

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

Veja o primeiro exemplo do dataset e acesse a coluna `audio`, que contém `array`, o sinal de áudio bruto.

```py
dataset[0]["audio"]["array"]
array([ 0.        ,  0.00024414, -0.00024414, ..., -0.00024414,
        0.        ,  0.        ])
```

O extrator de recursos pré-processa `array` para o formato de entrada esperado por um modelo de áudio específico. Use o parâmetro `sampling_rate` para definir a taxa de amostragem adequada.

```py
processed_dataset = feature_extractor(dataset[0]["audio"]["array"], sampling_rate=16000)
processed_dataset
{'input_values': [array([ 9.4472744e-05,  3.0777880e-03, -2.8888427e-03, ...,
       -2.8888427e-03,  9.4472744e-05,  9.4472744e-05], dtype=float32)]}
```

### Preenchimento

Comprimentos de sequência de áudio diferentes são um problema, pois o Transformers espera que todas as sequências tenham o mesmo comprimento para que possam ser agrupadas em lotes. Comprimentos de sequência desiguais não podem ser agrupados em lotes.

```py
dataset[0]["audio"]["array"].shape
(86699,)

dataset[1]["audio"]["array"].shape
(53248,)
```

O padding adiciona um *token de padding* especial para garantir que todas as sequências tenham o mesmo comprimento. O extrator de recursos adiciona um `0` - interpretado como silêncio - ao `array` para preenchê-lo. Defina `padding=True` para preencher as sequências até o comprimento da sequência mais longa do lote.

```py
def preprocess_function(examples):
    audio_arrays = [x["array"] for x in examples["audio"]]
    inputs = feature_extractor(
        audio_arrays,
        sampling_rate=16000,
        padding=True,
    )
    return inputs

processed_dataset = preprocess_function(dataset[:5])
processed_dataset["input_values"][0].shape
(86699,)

processed_dataset["input_values"][1].shape
(86699,)
```

### Truncamento

Os modelos só conseguem processar sequências até um determinado comprimento antes de falhar.

A truncation é uma estratégia para remover tokens excedentes de uma sequência, garantindo que ela não exceda o comprimento máximo. Defina `truncation=True` para truncar a sequência para o comprimento especificado no parâmetro `max_length`.

```py
def preprocess_function(examples):
    audio_arrays = [x["array"] for x in examples["audio"]]
    inputs = feature_extractor(
        audio_arrays,
        sampling_rate=16000,
        max_length=50000,
        truncation=True,
    )
    return inputs

processed_dataset = preprocess_function(dataset[:5])
processed_dataset["input_values"][0].shape
(50000,)

processed_dataset["input_values"][1].shape
(50000,)
```

### Amostragem

A biblioteca [Datasets](https://hf.co/docs/datasets/index) também pode reamostrar dados de áudio para corresponder à taxa de amostragem esperada por um modelo de áudio. Esse método reamostra os dados de áudio sob demanda quando são carregados, o que pode ser mais rápido do que reamostrar o conjunto de dados inteiro no local.

O conjunto de dados de áudio em que você tem trabalhado tem uma taxa de amostragem de 8 kHz e o modelo pré-treinado espera 16 kHz.

```py
dataset[0]["audio"]
{'path': '/root/.cache/huggingface/datasets/downloads/extracted/f507fdca7f475d961f5bb7093bcc9d544f16f8cab8608e772a2ed4fbeb4d6f50/en-US~JOINT_ACCOUNT/602ba55abb1e6d0fbce92065.wav',
 'array': array([ 0.        ,  0.00024414, -0.00024414, ..., -0.00024414,
         0.        ,  0.        ]),
 'sampling_rate': 8000}
```

Chame [cast_column](https://huggingface.co/docs/datasets/main/en/package_reference/main_classes#datasets.Dataset.cast_column) na coluna `audio` para aumentar a taxa de amostragem para 16 kHz.

```py
dataset = dataset.cast_column("audio", Audio(sampling_rate=16000))
```

Ao carregar a amostra do conjunto de dados, ela agora é reamostrada para 16 kHz.

```py
dataset[0]["audio"]
{'path': '/root/.cache/huggingface/datasets/downloads/extracted/f507fdca7f475d961f5bb7093bcc9d544f16f8cab8608e772a2ed4fbeb4d6f50/en-US~JOINT_ACCOUNT/602ba55abb1e6d0fbce92065.wav',
 'array': array([ 1.70562416e-05,  2.18727451e-04,  2.28099874e-04, ...,
         3.43842403e-05, -5.96364771e-06, -1.76846661e-05]),
 'sampling_rate': 16000}
```