Transformers documentation
Modelos Encoder-Decoder de Fala
Este modelo foi publicado em papers do HF em 2021-04-14 e contribuído para o Hugging Face Transformers em 2021-09-01.
Modelos Encoder-Decoder de Fala
O SpeechEncoderDecoderModel pode ser usado para inicializar um modelo de fala para texto com qualquer modelo pré-treinado de auto-encodificação de fala como codificador (por exemplo Wav2Vec2, Hubert) e qualquer modelo autoregressivo pré-treinado como decodificador.
A eficácia da inicialização de modelos de sequência de fala para sequência de texto com checkpoints pré-treinados para reconhecimento de fala e tradução de fala foi, por exemplo, demonstrada em Large-Scale Self- and Semi-Supervised Learning for Speech Translation, de Changhan Wang, Anne Wu, Juan Pino, Alexei Baevski, Michael Auli e Alexis Conneau.
Um exemplo de como usar um SpeechEncoderDecoderModel para inferência pode ser visto com o decodificador Speech2Text2.
Inicializando aleatoriamente o SpeechEncoderDecoderModel a partir das configurações do modelo
SpeechEncoderDecoderModel pode ser inicializado aleatoriamente a partir de uma configuração de encoder e uma configuração de decoder. No exemplo a seguir, mostramos como fazer isso usando a configuração padrão Wav2Vec2Model para o encoder
e a configuração padrão BertForCausalLM para o decoder.
from transformers import BertConfig, SpeechEncoderDecoderConfig, SpeechEncoderDecoderModel, Wav2Vec2Config
config_encoder = Wav2Vec2Config()
config_decoder = BertConfig()
config = SpeechEncoderDecoderConfig.from_encoder_decoder_configs(config_encoder, config_decoder)
model = SpeechEncoderDecoderModel(config=config)Inicializando o SpeechEncoderDecoderModel a partir de um codificador pré-treinado e de um decodificador pré-treinado
SpeechEncoderDecoderModel pode ser inicializado a partir de um checkpoint pré-treinado de codificador e de um checkpoint pré-treinado de decodificador. Observe que qualquer modelo de fala baseado em Transformer pré-treinado, por exemplo Wav2Vec2, Hubert, pode servir como codificador, e tanto os modelos auto-encoding pré-treinados, por exemplo BERT, quanto os modelos de linguagem causal pré-treinados, por exemplo GPT2, bem como a parte de decodificador pré-treinada de modelos de sequência para sequência, por exemplo o decodificador do BART, podem ser usados como decodificador.
Dependendo da arquitetura escolhida como decodificador, as camadas de atenção cruzada podem ser inicializadas aleatoriamente.
Inicializar o SpeechEncoderDecoderModel a partir de um checkpoint pré-treinado de codificador e decodificador requer que o modelo seja ajustado em uma tarefa de nível inferior, conforme demonstrado em o post no blog Warm-starting-encoder-decoder.
Para isso, a classe SpeechEncoderDecoderModel fornece o método SpeechEncoderDecoderModel.from_encoder_decoder_pretrained().
from transformers import SpeechEncoderDecoderModel
model = SpeechEncoderDecoderModel.from_encoder_decoder_pretrained(
"facebook/hubert-large-ll60k", "google-bert/bert-base-uncased"
)Carregar um checkpoint existente de SpeechEncoderDecoderModel e executar inferência
Para carregar checkpoints ajustados da classe SpeechEncoderDecoderModel, o SpeechEncoderDecoderModel fornece o método from_pretrained(...), assim como qualquer outra arquitetura de modelo no Transformers.
Para realizar inferência, utiliza-se o método generate, que permite gerar texto de forma autoregressiva. Este método suporta diversas formas de decodificação, como gulosa, busca por feixe e amostragem multinomial.
from transformers import Wav2Vec2Processor, SpeechEncoderDecoderModel
from datasets import load_dataset
import torch
# load a fine-tuned speech translation model and corresponding processor
model = SpeechEncoderDecoderModel.from_pretrained("facebook/wav2vec2-xls-r-300m-en-to-15", device_map="auto")
processor = Wav2Vec2Processor.from_pretrained("facebook/wav2vec2-xls-r-300m-en-to-15")
# let's perform inference on a piece of English speech (which we'll translate to German)
ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
input_values = processor(ds[0]["audio"]["array"], return_tensors="pt").to(model.device).input_values
# autoregressively generate transcription (uses greedy decoding by default)
generated_ids = model.generate(input_values)
generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
print(generated_text)
Mr. Quilter ist der Apostel der Mittelschicht und wir freuen uns, sein Evangelium willkommen heißen zu können.Treinamento
Uma vez que o modelo é criado, ele pode ser ajustado de forma semelhante a BART, T5 ou qualquer outro modelo encoder-decoder em um conjunto de dados de pares (fala, texto).
Como você pode ver, apenas 2 entradas são necessárias para o modelo calcular uma perda: input_values (que são as
entradas de fala) e labels (que são os input_ids da sequência de destino codificada).
from datasets import load_dataset
from transformers import AutoFeatureExtractor, AutoTokenizer, SpeechEncoderDecoderModel
encoder_id = "facebook/wav2vec2-base-960h" # acoustic model encoder
decoder_id = "google-bert/bert-base-uncased" # text decoder
feature_extractor = AutoFeatureExtractor.from_pretrained(encoder_id)
tokenizer = AutoTokenizer.from_pretrained(decoder_id)
# Combine pre-trained encoder and pre-trained decoder to form a Seq2Seq model
model = SpeechEncoderDecoderModel.from_encoder_decoder_pretrained(encoder_id, decoder_id)
model.config.decoder_start_token_id = tokenizer.cls_token_id
model.config.pad_token_id = tokenizer.pad_token_id
# load an audio input and pre-process (normalise mean/std to 0/1)
ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
input_values = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt").to(model.device).input_values
# load its corresponding transcription and tokenize to generate labels
labels = tokenizer(ds[0]["text"], return_tensors="pt").to(model.device).input_ids
# the forward function automatically creates the correct decoder_input_ids
loss = model(input_values=input_values, labels=labels).loss
loss.backward()SpeechEncoderDecoderConfig
classe transformers.SpeechEncoderDecoderConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool | None = Trueencoder: transformers.configuration_utils.PreTrainedConfig | dict | None = Nonedecoder: transformers.configuration_utils.PreTrainedConfig | dict | None = None )
Parâmetros
- is_encoder_decoder (
bool, opcional, padrãoTrue) — Indica se o modelo é usado como encoder/decoder ou não. - encoder (
Union[~configuration_utils.PreTrainedConfig, dict], opcional) — O objeto de configuração ou dicionário do backbone do encoder. - decoder (
Union[~configuration_utils.PreTrainedConfig, dict], opcional) — O objeto de configuração ou dicionário do backbone do decoder.
Esta é a classe de configuração para armazenar a configuração de um Speech Encoder DecoderModel. Ela é usada para instanciar um modelo Speech Encoder Decoder de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
Exemplos:
>>> from transformers import BertConfig, Wav2Vec2Config, SpeechEncoderDecoderConfig, SpeechEncoderDecoderModel
>>> # Initializing a Wav2Vec2 & BERT style configuration
>>> config_encoder = Wav2Vec2Config()
>>> config_decoder = BertConfig()
>>> config = SpeechEncoderDecoderConfig(encoder=config_encoder, decoder=config_decoder)
>>> # Initializing a Wav2Vec2Bert model from a Wav2Vec2 & google-bert/bert-base-uncased style configurations
>>> model = SpeechEncoderDecoderModel(config=config)
>>> # Accessing the model configuration
>>> config_encoder = model.config.encoder
>>> config_decoder = model.config.decoder
>>> # set decoder config to causal lm
>>> config_decoder.is_decoder = True
>>> config_decoder.add_cross_attention = True
>>> # Saving the model, including its configuration
>>> model.save_pretrained("my-model")
>>> # loading model and config from pretrained folder
>>> encoder_decoder_config = SpeechEncoderDecoderConfig.from_pretrained("my-model")
>>> model = SpeechEncoderDecoderModel.from_pretrained("my-model", config=encoder_decoder_config)from_encoder_decoder_configs
< source >( encoder_config: PreTrainedConfigdecoder_config: PreTrainedConfig**kwargs ) → SpeechEncoderDecoderConfig
Retorna
Uma instância de um objeto de configuração
Instancie um SpeechEncoderDecoderConfig (ou uma classe derivada) a partir da configuração de um modelo de codificador pré-treinado e da configuração de um modelo de decodificador.
SpeechEncoderDecoderModel
classe transformers.SpeechEncoderDecoderModel
< source >( config: transformers.configuration_utils.PreTrainedConfig | None = Noneencoder: transformers.modeling_utils.PreTrainedModel | None = Nonedecoder: transformers.modeling_utils.PreTrainedModel | None = None )
Parâmetros
- config (PreTrainedConfig, opcional) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
- encoder (
PreTrainedModel, opcional) — O modelo de codificador a ser utilizado. - decoder (
PreTrainedModel, opcional) — O modelo de decodificador a ser utilizado.
O modelo Speech Encoder Decoder puro, que produz estados ocultos brutos sem nenhum head específico no topo.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.BoolTensor] = Noneencoder_outputs: tuple[torch.Tensor] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Noneinput_values: typing.Optional[torch.Tensor] = Noneinput_features: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = None**kwargs ) → Seq2SeqLMOutput or tuple(torch.Tensor)
Parâmetros
- inputs (
torch.Tensorde forma(batch_size, sequence_length)ou(batch_size, sequence_length, feature_dim), opcional) — Valores em ponto flutuante da forma de onda bruta de fala de entrada ou dos recursos de fala. Os valores podem ser obtidos carregando um arquivo de áudio.flacou.wavem um array do tipolist[float], umnumpy.ndarrayou umtorch.Tensor, por exemplo por meio da biblioteca torchcodec (pip install torchcodec) ou da biblioteca soundfile (pip install soundfile). Para preparar o array parainputs, deve-se usar o Wav2Vec2Processor ou o Speech2TextProcessor para o preenchimento (padding) e a conversão em um tensor do tipotorch.Tensor. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- decoder_input_ids (
torch.LongTensorde forma(batch_size, target_sequence_length), opcional) — Índices dos tokens da sequência de entrada do decodificador no vocabulário. Os índices podem ser obtidos usando PreTrainedTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada? Se past_key_values for usado, opcionalmente, apenas o último decoder_input_ids precisa ser inserido (veja past_key_values). Para treinamento, decoder_input_ids são criados automaticamente pelo modelo deslocando os rótulos para a direita, substituindo -100 por pad_token_id e adicionando decoder_start_token_id no início.Os índices podem ser obtidos usando PreTrainedTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
Se
past_key_valuesfor usado, opcionalmente apenas o últimodecoder_input_idsprecisa ser inserido (vejapast_key_values).Para o treinamento,
decoder_input_idssão criados automaticamente pelo modelo ao deslocarlabelspara a direita, substituindo -100 porpad_token_ide adicionandodecoder_start_token_idno início. - decoder_attention_mask (
torch.BoolTensorde forma(batch_size, target_sequence_length), opcional) — Comportamento padrão: gera um tensor que ignora tokens de preenchimento emdecoder_input_ids. A máscara causal também será usada por padrão. - encoder_outputs (
tuple[torch.Tensor], opcional) — A tupla consiste em (last_hidden_state, opcional:hidden_states, opcional:attentions)last_hidden_statede forma(batch_size, sequence_length, hidden_size), opcional) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder. - past_key_values (
~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nopast_key_valuesretornado pelo modelo em uma etapa anterior da decodificação, quandouse_cache=Trueouconfig.use_cache=True.Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum
past_key_valuesfor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
past_key_valuesforem usados, espera-se que o usuário insira apenas osinput_idsnão processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma(batch_size, unprocessed_length), em vez de todos osinput_idscom a forma(batch_size, sequence_length). - decoder_inputs_embeds (
torch.Tensorde forma(batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passardecoder_input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser mais controle sobre como converter os índices dedecoder_input_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Rótulos para calcular a perda de modelagem de linguagem mascarada para o decodificador. Os índices devem estar em[-100, 0, ..., config.vocab_size](veja a docstring deinput_ids). Tokens com índices definidos como-100são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em[0, ..., config.vocab_size] - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values). - output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - input_values (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio .flac ou .wav em um array do tipo list[float] ou um numpy.ndarray, por exemplo, por meio da biblioteca torchcodec (pip install torchcodec) ou da biblioteca soundfile (pip install soundfile). Para preparar o array para input_values, o Wav2Vec2Processor deve ser usado para padding e conversão em um tensor do tipo torch.Tensor. Consulte Wav2Vec2Processor.call() para mais detalhes. - input_features (
torch.Tensorde forma(batch_size, sequence_length, feature_dim), opcional) — Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usandofeature_extractor_class. Consultefeature_extractor_class.__call__para mais detalhes (processor_classusafeature_extractor_classpara processar áudios). - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.
Retorna
Seq2SeqLMOutput ou tuple(torch.Tensor)
Um Seq2SeqLMOutput ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (SpeechEncoderDecoderConfig) e das entradas.
O método forward do SpeechEncoderDecoderModel substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de modelagem de linguagem.logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).past_key_values (
EncoderDecoderCache, opcional, retornado quandouse_cache=Trueé passado ou quandoconfig.use_cache=True) — Trata-se de uma instância de EncoderDecoderCache. Para mais detalhes, consulte nosso guia de cache kv.Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados (veja a entrada
past_key_values) para acelerar a decodificação sequencial.decoder_hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do decodificador na saída de cada camada, além das saídas do embedding inicial.
decoder_attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
cross_attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada.
encoder_last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do codificador do modelo.encoder_hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do codificador na saída de cada camada, além das saídas do embedding inicial.
encoder_attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
Exemplos:
>>> from transformers import SpeechEncoderDecoderModel, AutoProcessor
>>> from datasets import load_dataset
>>> import torch
>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-xls-r-300m-en-to-15")
>>> model = SpeechEncoderDecoderModel.from_pretrained("facebook/wav2vec2-xls-r-300m-en-to-15")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> input_values = processor(ds[0]["audio"]["array"], return_tensors="pt").input_values
>>> # Inference: Translate English speech to German
>>> generated = model.generate(input_values)
>>> decoded = processor.batch_decode(generated, skip_special_tokens=True)[0]
>>> decoded
'Mr. Quilter ist der Apostel der Mittelschicht und wir freuen uns, sein Evangelium willkommen heißen zu können.'
>>> # Training: Train model on English transcription
>>> labels = processor(text=ds[0]["text"], return_tensors="pt").input_ids
>>> loss = model(input_values, labels=labels).loss
>>> loss.backward()from_encoder_decoder_pretrained
< source >( encoder_pretrained_model_name_or_path: str | None = Nonedecoder_pretrained_model_name_or_path: str | None = None*model_args**kwargs )
Parâmetros
- encoder_pretrained_model_name_or_path (
str, opcional) — Informações necessárias para iniciar o encoder. Pode ser:- Uma string, o model id de um modelo pré-treinado hospedado em um repositório de modelos no huggingface.co.
- Um caminho para um diretório contendo pesos de modelo salvos usando
save_pretrained(), por exemplo,
./my_model_directory/.
- decoder_pretrained_model_name_or_path (
str, opcional, padrão éNone) — Informações necessárias para iniciar o decoder. Pode ser:- Uma string, o model id de um modelo pré-treinado hospedado em um repositório de modelos no huggingface.co.
- Um caminho para um diretório contendo pesos de modelo salvos usando
save_pretrained(), por exemplo,
./my_model_directory/.
- model_args (argumentos posicionais restantes, opcional) —
Todos os argumentas posicionais restantes serão passados para o método
__init__do modelo subjacente. - kwargs (dicionário restante de argumentos por palavra-chave, opcional) —
Pode ser usado para atualizar o objeto de configuração (após o carregamento) e iniciar o modelo (por exemplo,
output_attentions=True).- Para atualizar a configuração do codificador, use o prefixo encoder_ para cada parâmetro de configuração.
- Para atualizar a configuração do decodificador, use o prefixo decoder_ para cada parâmetro de configuração.
- Para atualizar a configuração do modelo pai, não use um prefixo para cada parâmetro de configuração.
Comporta-se de maneira diferente dependendo de uma
configser fornecida ou carregada automaticamente.
Instancie um codificador e um decodificador a partir de uma ou duas classes base da biblioteca a partir de checkpoints de modelos pré-treinados.
O modelo é definido no modo de avaliação por padrão usando model.eval() (os módulos Dropout são desativados). Para treinar o modelo, é necessário primeiro redefinir o modo de treinamento com model.train().
Exemplo:
>>> from transformers import SpeechEncoderDecoderModel
>>> # initialize a wav2vec2bert from a pretrained Wav2Vec2 and a pretrained BERT model. Note that the cross-attention layers will be randomly initialized
>>> model = SpeechEncoderDecoderModel.from_encoder_decoder_pretrained(
... "facebook/wav2vec2-base-960h", "google-bert/bert-base-uncased"
... )
>>> # saving model after fine-tuning
>>> model.save_pretrained("./wav2vec2bert")
>>> # load fine-tuned model
>>> model = SpeechEncoderDecoderModel.from_pretrained("./wav2vec2bert")