Extratores de recursos

Os feature extractors 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 feature extractor pré-processará corretamente os dados de áudio para você, com base no modelo que você está usando. Os feature extractors também incluem métodos para padding, truncamento e reamostragem.

Chame from_pretrained() para carregar um extrator de recursos e sua configuração de pré-processador do Hub 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.

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.

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, que é uma subclasse de FeatureExtractionMixin.

• SequenceFeatureExtractor fornece um método para pad() sequências até um determinado comprimento, a fim de evitar comprimentos de sequência desiguais.
• FeatureExtractionMixin fornece from_pretrained() e save_pretrained() para carregar e salvar um extrator de recursos.

Existem duas formas de carregar um extrator de recursos: AutoFeatureExtractor e uma classe de extrator de recursos específica para o modelo.

from transformers import AutoFeatureExtractor

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

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 espera que input_features seja um tensor de forma (batch_size, feature_size, sequence_length), mas o 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().

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.

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.

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.

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.

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 uma sequência para o comprimento especificado no parâmetro max_length.

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

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 na coluna audio para aumentar a taxa de amostragem para 16 kHz.

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

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

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}