Transformers documentation
Modelos de codificador-decodificador de voz
Este modelo se publicó en HF papers el 2021-04-14 y se contribuyó a Hugging Face Transformers el 2021-09-01.
Modelos de codificador-decodificador de voz
El SpeechEncoderDecoderModel se puede utilizar para inicializar un modelo de voz a texto con cualquier modelo de auto codificación de voz preentrenado como codificador (por ejemplo Wav2Vec2, Hubert) y cualquier modelo autoregresivo preentrenado como decodificador.
La eficacia de la inicialización de modelos de secuencia de voz a secuencia de texto con puntos de control preentrenados para el reconocimiento de voz y la traducción de voz se ha demostrado, por ejemplo, en Large-Scale Self- and Semi-Supervised Learning for Speech Translation de Changhan Wang, Anne Wu, Juan Pino, Alexei Baevski, Michael Auli, Alexis Conneau.
Un ejemplo de cómo usar un SpeechEncoderDecoderModel para la inferencia se puede ver con el decodificador de Speech2Text2.
Inicialización aleatoria de SpeechEncoderDecoderModel a partir de las configuraciones del modelo
SpeechEncoderDecoderModel se puede inicializar aleatoriamente a partir de una configuración de codificador y una de decodificador. En el siguiente ejemplo, mostramos cómo hacerlo utilizando la configuración predeterminada de Wav2Vec2Model para el codificador y la configuración predeterminada de BertForCausalLM para el decodificador.
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)Inicializar SpeechEncoderDecoderModel a partir de un codificador preentrenado y un decodificador preentrenado
SpeechEncoderDecoderModel se puede inicializar a partir de un checkpoint preentrenado del codificador y un checkpoint preentrenado del decodificador. Tenga en cuenta que cualquier modelo de voz basado en Transformers preentrenado, por ejemplo Wav2Vec2, Hubert, puede servir como codificador, y tanto los modelos de auto-codificación preentrenados, por ejemplo BERT, como los modelos de lenguaje causales preentrenados, por ejemplo GPT2, así como la parte de decodificador preentrenada de los modelos de secuencia a secuencia, por ejemplo el decodificador de BART, pueden usarse como decodificador.
Dependiendo de la arquitectura que elija como decodificador, las capas de atención cruzada podrían inicializarse aleatoriamente.
Inicializar SpeechEncoderDecoderModel a partir de un checkpoint preentrenado del codificador y del decodificador requiere que el modelo se ajuste fino en una tarea descendente, como se ha mostrado en la publicación de blog Warm-starting-encoder-decoder.
Para ello, la clase SpeechEncoderDecoderModel proporciona un 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"
)Cargar un punto de control existente de SpeechEncoderDecoderModel y realizar inferencia
Para cargar puntos de control afinados de la clase SpeechEncoderDecoderModel, SpeechEncoderDecoderModel proporciona el método from_pretrained(...) al igual que cualquier otra arquitectura de modelo en Transformers.
Para realizar la inferencia, se utiliza el método generate, que permite generar texto de forma autoregresiva. Este método admite diversas formas de decodificación, como la búsqueda codiciosa, la búsqueda por haces y la muestreo 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.Entrenamiento
Una vez que el modelo se ha creado, se puede ajustar de forma similar a BART, T5 o cualquier otro modelo encoder-decoder en un conjunto de datos de pares (voz, texto).
Como puede ver, el modelo solo requiere 2 entradas para calcular una pérdida: input_values (que son las entradas de voz) y labels (que son los input_ids de la secuencia objetivo 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
clase 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, valor predeterminadoTrue) — Indica si el modelo se utiliza como codificador/decodificador o no. - encoder (
Union[~configuration_utils.PreTrainedConfig, dict], opcional) — El objeto de configuración o el diccionario del backbone del codificador. - decoder (
Union[~configuration_utils.PreTrainedConfig, dict], opcional) — El objeto de configuración o el diccionario del backbone del decodificador.
Esta es la clase de configuración para almacenar la configuración de un modelo Speech Encoder Decoder. Se utiliza para instanciar un modelo Speech Encoder Decoder según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de
Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.
Ejemplos:
>>> 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
Devuelve
Una instancia de un objeto de configuración
Instanciar un SpeechEncoderDecoderConfig (o una clase derivada) a partir de la configuración de un modelo codificador preentrenado y la configuración de un modelo decodificador.
SpeechEncoderDecoderModel
clase 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) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
- encoder (
PreTrainedModel, opcional) — El modelo codificador a utilizar. - decoder (
PreTrainedModel, opcional) — El modelo decodificador a utilizar.
El modelo Speech Encoder Decoder básico que genera estados ocultos sin ningún cabezal específico en la parte superior.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
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)o(batch_size, sequence_length, feature_dim), opcional) — Valores flotantes de la forma de onda de voz cruda de entrada o de las características de voz. Los valores se pueden obtener cargando un archivo de audio.flaco.waven un array de tipolist[float], unnumpy.ndarrayo untorch.Tensor, por ejemplo mediante la biblioteca torchcodec (pip install torchcodec) o la biblioteca soundfile (pip install soundfile). Para preparar el array comoinputs, se debe utilizar Wav2Vec2Processor o Speech2TextProcessor para el relleno y la conversión a un tensor de tipotorch.Tensor. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- decoder_input_ids (
torch.LongTensorde forma(batch_size, target_sequence_length), opcional) — Índices de los tokens de la secuencia de entrada del decodificador en el vocabulario. Los índices se pueden obtener usando PreTrainedTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles. ¿Qué son los IDs de entrada? Si se usa past_key_values, opcionalmente solo se deben ingresar los últimos decoder_input_ids (consulte past_key_values). Para el entrenamiento, decoder_input_ids se crea automáticamente por el modelo desplazando las etiquetas hacia la derecha, reemplazando -100 por pad_token_id y añadiendo decoder_start_token_id al principio.Los índices se pueden obtener usando PreTrainedTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
Si se usa
past_key_values, opcionalmente solo se deben introducir los últimosdecoder_input_ids(verpast_key_values).Para el entrenamiento,
decoder_input_idsse crean automáticamente por el modelo desplazandolabelshacia la derecha, reemplazando -100 porpad_token_idy añadiendodecoder_start_token_idal principio. - decoder_attention_mask (
torch.BoolTensorde forma(batch_size, target_sequence_length), opcional) — Comportamiento predeterminado: genera un tensor que ignora los tokens de relleno endecoder_input_ids. También se usará una máscara causal de forma predeterminada. - encoder_outputs (
tuple[torch.Tensor], opcional) — La tupla consiste en (last_hidden_state, opcional:hidden_states, opcional:attentions)last_hidden_statede forma(batch_size, sequence_length, hidden_size), opcional) es una secuencia de hidden-states en la salida de la última capa del codificador. Se utiliza en la atención cruzada del decodificador. - past_key_values (
~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en lapast_key_valuesdevuelta por el modelo en una etapa anterior de la decodificación, cuandouse_cache=Trueoconfig.use_cache=True.Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan
past_key_values, DynamicCache se inicializará de forma predeterminada.El modelo generará el mismo formato de caché que se proporciona como entrada.
Si se utilizan
past_key_values, se espera que el usuario introduzca únicamente losinput_idsno procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma(batch_size, unprocessed_length)en lugar de todos losinput_idscon forma(batch_size, sequence_length). - decoder_inputs_embeds (
torch.Tensorde forma(batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasardecoder_input_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices dedecoder_input_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado del decodificador. Los índices deben estar en[-100, 0, ..., config.vocab_size](ver la docstring deinput_ids). Los tokens con índices fijados en-100se ignoran (enmascarados); la pérdida solo se calcula para los tokens con etiquetas en[0, ..., config.vocab_size] - use_cache (
bool, opcional) — Si se establece enTrue, se devuelven los estados de clave-valor depast_key_valuesy pueden usarse para acelerar la decodificación (verpast_key_values). - output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - input_values (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Valores flotantes de la forma de onda de audio de entrada. Los valores se pueden obtener cargando un archivo de audio .flac o .wav en un array de tipo list[float] o un numpy.ndarray, por ejemplo, mediante la biblioteca torchcodec (pip install torchcodec) o la biblioteca soundfile (pip install soundfile). Para preparar el array como input_values, se debe utilizar Wav2Vec2Processor para el relleno y la conversión a un tensor de tipo torch.Tensor. Consulte Wav2Vec2Processor.call() para más detalles. - input_features (
torch.Tensorde forma(batch_size, sequence_length, feature_dim), opcional) — Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener utilizandofeature_extractor_class. Consultefeature_extractor_class.__call__para más detalles (processor_classutilizafeature_extractor_classpara procesar audios). - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.
Devuelve
Seq2SeqLMOutput o tuple(torch.Tensor)
Un Seq2SeqLMOutput o una tupla de
torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (SpeechEncoderDecoderConfig) y las entradas.
El método forward de SpeechEncoderDecoderModel reemplaza el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de modelado de lenguaje.logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).past_key_values (
EncoderDecoderCache, opcional, se devuelve cuando se pasause_cache=Trueo cuandoconfig.use_cache=True) — Es una instancia de EncoderDecoderCache. Para más detalles, consulte nuestra guía de caché kv.Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que pueden utilizarse (véase la entrada
past_key_values) para acelerar la decodificación secuencial.decoder_hidden_states (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del decodificador en la salida de cada capa más las salidas de la incrustación inicial.
decoder_attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
cross_attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
encoder_last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.encoder_hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del codificador en la salida de cada capa más las salidas de la incrustación inicial.
encoder_attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplos:
>>> 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) — Información necesaria para iniciar el codificador. Puede ser:- Una cadena de texto, el model id de un modelo preentrenado alojado en un repositorio de modelos en huggingface.co.
- Una ruta a un directorio que contiene los pesos del modelo guardados con
save_pretrained(), por ejemplo,
./my_model_directory/.
- decoder_pretrained_model_name_or_path (
str, opcional, por defectoNone) — Información necesaria para iniciar el decodificador. Puede ser:- Una cadena de texto, el model id de un modelo preentrenado alojado en un repositorio de modelos en huggingface.co.
- Una ruta a un directorio que contiene los pesos del modelo guardados con
save_pretrained(), por ejemplo,
./my_model_directory/.
- model_args (argumentos posicionales restantes, opcional) —
Todos los argumentes posicionales restantes se pasarán al método
__init__del modelo subyacente. - kwargs (diccionario restante de argumentos de palabra clave, opcional) —
Se puede usar para actualizar el objeto de configuración (después de que se haya cargado) e iniciar el modelo (p. ej.,
output_attentions=True).- Para actualizar la configuración del codificador, use el prefijo encoder_ para cada parámetro de configuración.
- Para actualizar la configuración del decodificador, use el prefijo decoder_ para cada parámetro de configuración.
- Para actualizar la configuración del modelo principal, no utilice un prefijo para cada parámetro de configuración.
Se comporta de manera diferente dependiendo de si se proporciona un
configo se carga automáticamente.
Instanciar un codificador y un decodificador a partir de una o dos clases base de la biblioteca desde puntos de control de modelos preentrenados.
El modelo se establece en modo de evaluación de forma predeterminada mediante model.eval() (los módulos Dropout se desactivan). Para entrenar
el modelo, primero debe volver a establecerlo en modo de entrenamiento con model.train().
Ejemplo:
>>> 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")