Hugging Face's logo

Transformers documentation

Whisper

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo se publicó en HF papers el 2022-12-06 y se contribuyó a Hugging Face Transformers el 2022-10-05.

FlashAttention SDPA

Whisper

Whisper es un transformer codificador-decodificador (secuencia a secuencia) preentrenado con 680.000 horas de datos de audio etiquetados. Esta cantidad de datos de preentrenamiento permite un rendimiento zero-shot en tareas de audio en inglés y en muchos otros idiomas. El decodificador permite que Whisper mapee las representaciones del habla aprendidas por el codificador a salidas útiles, como texto, sin necesidad de un ajuste fino adicional. Whisper funciona directamente sin configuración adicional.

Puedes encontrar todos los puntos de control originales de Whisper en la colección Whisper.

Haz clic en los modelos de Whisper en la barra lateral derecha para ver más ejemplos de cómo aplicar Whisper a diferentes tareas de audio.

Establezca use_kernels=True en from_pretrained() para reemplazar las capas compatibles con kernels optimizados del Hub. Consulte Carga de kernels para obtener más información.

El siguiente ejemplo demuestra cómo transcribir automáticamente el habla en texto con Pipeline o la clase AutoModel.

Pipeline
AutoModel
from transformers import pipeline


pipeline = pipeline(
    task="automatic-speech-recognition",
    model="openai/whisper-large-v3-turbo",
    device=0
)
pipeline("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac")

Notas

  • Whisper se basa en un generate personalizado para la inferencia, asegúrate de consultar la documentación a continuación.
  • El WhisperProcessor se puede utilizar para preparar el audio y decodificar los ids predichos de vuelta en texto.

WhisperConfig

clase transformers.WhisperConfig

< >

( 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 = Truevocab_size: int = 51865num_mel_bins: int = 80encoder_layers: int = 4encoder_attention_heads: int = 6decoder_layers: int = 4decoder_attention_heads: int = 6decoder_ffn_dim: int = 1536encoder_ffn_dim: int = 1536encoder_layerdrop: float | int = 0.0decoder_layerdrop: float | int = 0.0decoder_start_token_id: int = 50257use_cache: bool = Trueactivation_function: str = 'gelu'd_model: int = 384dropout: float | int = 0.0attention_dropout: float | int = 0.0activation_dropout: float | int = 0.0init_std: float = 0.02scale_embedding: bool = Falsemax_source_positions: int = 1500max_target_positions: int = 448pad_token_id: int | None = 50256bos_token_id: int | None = 50256eos_token_id: int | list[int] | None = 50256suppress_tokens: list | None = Nonebegin_suppress_tokens: list[int] | tuple[int, ...] | None = (220, 50256)use_weighted_layer_sum: bool = Falseclassifier_proj_size: int = 256apply_spec_augment: bool = Falsemask_time_prob: float | int = 0.05mask_time_length: int = 10mask_time_min_masks: int = 2mask_feature_prob: float | int = 0.0mask_feature_length: int = 10mask_feature_min_masks: int = 0median_filter_width: int = 7tie_word_embeddings: bool = True )

Parámetros

  • is_encoder_decoder (bool, opcional, valor predeterminado True) — Indica si el modelo se utiliza como codificador/decodificador o no.
  • vocab_size (int, opcional, valor predeterminado 51865) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante input_ids.
  • num_mel_bins (int, opcional, valor predeterminado 80) — Número de características mel utilizadas por cada cuadro de entrada. Debe corresponder al valor utilizado en la clase AutoFeatureExtractor.
  • encoder_layers (int, opcional, valor predeterminado 4) — Número de capas ocultas en el codificador del Transformer. Usará el mismo valor que num_layers si no se establece.
  • encoder_attention_heads (int, opcional, valor predeterminado 6) — Número de cabezas de atención para cada capa de atención en el codificador Transformer.
  • decoder_layers (int, opcional, valor predeterminado 4) — Número de capas ocultas en el decodificador del Transformer. Si no se establece, se usará el mismo valor que num_layers.
  • decoder_attention_heads (int, opcional, valor predeterminado 6) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer.
  • decoder_ffn_dim (int, opcional, valor predeterminado 1536) — Dimensionalidad de la capa “intermedia” (a menudo denominada feed-forward) en el decodificador.
  • encoder_ffn_dim (int, opcional, valor predeterminado 1536) — Dimensionalidad de la capa “intermedia” (a menudo denominada feed-forward) en el codificador.
  • encoder_layerdrop (Union[float, int], opcional, valor predeterminado 0.0) — La probabilidad de LayerDrop para el codificador. Consulte el [artículo de LayerDrop](ver https://huggingface.co/papers/1909.11556) para más detalles.
  • decoder_layerdrop (Union[float, int], opcional, valor predeterminado 0.0) — La probabilidad de LayerDrop para el decodificador. Consulte el [artículo de LayerDrop](ver https://huggingface.co/papers/1909.11556) para más detalles.
  • decoder_start_token_id (int, opcional, valor predeterminado 50257) — Si un modelo encoder-decoder inicia la decodificación con un token diferente de bos, el id de ese token.
  • use_cache (bool, opcional, valor predeterminado True) — Indica si el modelo debe devolver las últimas claves/valores de atención (no utilizado por todos los modelos). Solo es relevante si config.is_decoder=True o cuando el modelo es un modelo generativo solo de decodificador.
  • activation_function (str, opcional, valor predeterminado gelu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, "gelu", "relu", "silu", etc.
  • d_model (int, opcional, valor predeterminado 384) — Tamaño de las capas del codificador y de la capa pooler.
  • dropout (Union[float, int], opcional, valor predeterminado 0.0) — La proporción para todas las capas de dropout.
  • attention_dropout (Union[float, int], opcional, valor predeterminado 0.0) — La proporción de dropout para las probabilidades de atención.
  • activation_dropout (Union[float, int], opcional, valor predeterminado 0.0) — La proporción de dropout para las activaciones dentro de la capa totalmente conectada.
  • init_std (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
  • scale_embedding (bool, opcional, valor predeterminado False) — Si se deben escalar los embeddings dividiendo por sqrt(d_model).
  • max_source_positions (int, opcional, valor predeterminado 1500) — La longitud máxima de secuencia de características de filtros mel que este modelo podría llegar a utilizarse.
  • max_target_positions (int, opcional, valor predeterminado: 448) — La longitud máxima de secuencia con la que podría utilizarse este modelo. Por lo general, se establece en un valor grande por si acaso (p. ej., 512, 1024 o 2048).
  • pad_token_id (int, opcional, valor predeterminado 50256) — Id del token utilizado para el relleno en el vocabulario.
  • bos_token_id (int, opcional, valor predeterminado 50256) — Identificador de token utilizado para el inicio de la secuencia en el vocabulario.
  • eos_token_id (Union[int, list[int]], opcional, valor predeterminado 50256) — Identificador de token utilizado para el fin de secuencia en el vocabulario.
  • suppress_tokens (list[int], opcional) — Una lista que contiene los tokens no de voz que se utilizarán en el procesador de logits de la función generate. NON_SPEECH_TOKENS y NON_SPEECH_TOKENS_MULTI corresponden, respectivamente, al modelo english-only y al modelo multilingual.
  • begin_suppress_tokens (list[int], opcional, valor predeterminado [220,50256]) — Una lista que contiene los tokens que se suprimirán al inicio del proceso de muestreo. Se inicializa con el token de " " (blank_token_id) y el eos_token_id
  • use_weighted_layer_sum (bool, opcional, valor predeterminado False) — Indica si se debe utilizar una media ponderada de las salidas de las capas con pesos aprendidos. Solo es relevante al utilizar una instancia de WhisperForAudioClassification.
  • classifier_proj_size (int, opcional, valor predeterminado 256) — Dimensionalidad de la proyección antes del pooling medio de tokens para clasificación. Solo es relevante al usar una instancia de WhisperForAudioClassification.
  • apply_spec_augment (bool, opcional, valor predeterminado False) — Indica si se debe aplicar la aumentación de datos SpecAugment a las salidas del codificador de características. Para más información, consulte SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition.
  • mask_time_prob (float, opcional, valor predeterminado 0.05) — Porcentaje (entre 0 y 1) de todos los vectores de características a lo largo del eje temporal que se enmascararán. El procedimiento de enmascarado genera mask_time_prob*len(time_axis)/mask_time_length máscaras independientes sobre el eje. Si se razona a partir de la probabilidad de que cada vector de características sea elegido como inicio del tramo de vectores a enmascarar, mask_time_prob debería ser prob_vector_start*mask_time_length. Tenga en cuenta que la superposición puede disminuir el porcentaje real de vectores enmascarados. Esto solo es relevante si apply_spec_augment == True.
  • mask_time_length (int, opcional, valor predeterminado 10) — Longitud del tramo del vector a lo largo del eje temporal.
  • mask_time_min_masks (int, opcional, valor predeterminado 2), — El número mínimo de máscaras de longitud mask_feature_length generadas a lo largo del eje temporal, en cada paso de tiempo, independientemente de mask_feature_prob. Solo es relevante si ”mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks”
  • mask_feature_prob (float, opcional, valor predeterminado 0.0) — Porcentaje (entre 0 y 1) de todos los vectores de características a lo largo del eje de características que se enmascararán. El procedimiento de enmascarado genera mask_feature_prob*len(feature_axis)/mask_time_length máscaras independientes sobre el eje. Si se razona a partir de la probabilidad de que cada vector de características sea elegido como inicio del tramo de vectores a enmascarar, mask_feature_prob debería ser prob_vector_start*mask_feature_length. Tenga en cuenta que la superposición puede disminuir el porcentaje real de vectores enmascarados. Esto solo es relevante si apply_spec_augment is True.
  • mask_feature_prob (Union[float, int], opcional, valor predeterminado 0.0) — Porcentaje (entre 0 y 1) de todos los vectores de características a lo largo del eje de características que se enmascararán. El procedimiento de enmascarado genera mask_feature_prob*len(feature_axis)/mask_time_length máscaras independientes sobre el eje. Si se razona a partir de la probabilidad de que cada vector de características sea elegido como el inicio del tramo de vectores a enmascarar, mask_feature_prob debería ser prob_vector_start*mask_feature_length. Tenga en cuenta que la superposición puede disminuir el porcentaje real de vectores enmascarados. Esto solo es relevante si apply_spec_augment es True.
  • mask_feature_length (int, opcional, valor predeterminado 10) — Longitud del tramo del vector a lo largo del eje de características.
  • mask_feature_min_masks (int, opcional, valor predeterminado 0) — El número mínimo de máscaras de longitud mask_feature_length generadas a lo largo del eje de características, en cada paso de tiempo, independientemente de mask_feature_prob. Solo es relevante si mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks.
  • median_filter_width (int, opcional, valor predeterminado: 7) — Ancho del filtro mediano utilizado para suavizar las salidas de la atención cruzada al calcular las marcas de tiempo de los tokens. Debe ser un número impar.
  • tie_word_embeddings (bool, opcional, valor predeterminado True) — Si se deben vincular las matrices de pesos de embeddings según el mapeo tied_weights_keys del modelo.

Esta es la clase de configuración para almacenar la configuración de un WhisperModel. Se utiliza para instanciar un modelo Whisper 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 openai/whisper-tiny

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.

Ejemplo:

>>> from transformers import WhisperConfig, WhisperModel

>>> # Initializing a Whisper tiny style configuration
>>> configuration = WhisperConfig()

>>> # Initializing a model (with random weights) from the tiny style configuration
>>> model = WhisperModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

WhisperTokenizer

clase transformers.WhisperTokenizer

< >

( vocab: str | dict[str, int] | None = Nonemerges = Nonenormalizer_file = Noneunk_token = '<|endoftext|>'bos_token = '<|endoftext|>'eos_token = '<|endoftext|>'add_prefix_space = Falselanguage = Nonetask = Nonepredict_timestamps = False**kwargs )

Parámetros

  • vocab_file (str, opcional) — Ruta al archivo de vocabulario.
  • merges_file (str, opcional) — Ruta al archivo de fusiones.
  • normalizer_file (str, opcional) — Ruta al archivo normalizer_file.
  • tokenizer_file (str, opcional) — Ruta al archivo de tokenizers (generalmente con extensión .json) que contiene todo lo necesario para cargar el tokenizador.
  • unk_token (str, opcional, valor predeterminado "<|endoftext|>") — El token desconocido. Un token que no está en el vocabulario no se puede convertir en un ID y se establece como este token en su lugar.
  • bos_token (str, opcional, valor predeterminado "<|endoftext|>") — El token de inicio de secuencia. El decoder_start_token_id se utiliza para establecer el primer token como "<|startoftranscript|>" durante la generación.
  • eos_token (str, opcional, por defecto "<|endoftext|>") — El token de fin de secuencia.
  • add_prefix_space (bool, opcional, valor predeterminado False) — Indica si se debe añadir un espacio inicial a la entrada. Esto permite tratar la palabra inicial como cualquier otra palabra. (El tokenizador de Whisper detecta el inicio de las palabras mediante el espacio que las precede).
  • language (str, opcional) — El idioma del texto de la transcripción. El token de identificador de idioma correspondiente se añade al inicio de la secuencia para tareas de reconocimiento de voz y traducción de voz multilingües, por ejemplo, para el español se añade el token "<|es|>" al inicio de la secuencia. Esto debe usarse únicamente para el ajuste fino multilingüe.
  • task (str, opcional) — Identificador de tarea que se añade al inicio de la secuencia (si lo hay). Debe usarse para el ajuste fino multilingüe, con "transcribe" para el reconocimiento de voz y "translate" para la traducción de voz.
  • predict_timestamps (bool, opcional, valor predeterminado False) — Si se debe omitir el token <|notimestamps|> al inicio de la secuencia.

Construya un tokenizador de Whisper “rápido” (respaldado por la biblioteca tokenizers de HuggingFace).

Este tokenizador hereda de PreTrainedTokenizerFast, que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos.

set_prefix_tokens

< >

( language: str | None = Nonetask: str | None = Nonepredict_timestamps: bool | None = None )

Parámetros

  • language (str, opcional, valor predeterminado None) — El idioma del texto de la transcripción.
  • task (str, opcional, valor predeterminado None) — Identificador de tarea que se añade al inicio de la secuencia (si lo hay).
  • predict_timestamps (bool, opcional, valor predeterminado None) — Indica si se debe omitir el token <|notimestamps|> al inicio de la secuencia.

Sobrescribe los tokens de prefijo que se agregan al inicio de la secuencia de etiquetas. Este método se puede usar de forma independiente para

actualice los tokens de prefijo según sea necesario durante el ajuste fino. Ejemplo:

>>> # instantiate the tokenizer and set the prefix token to Spanish
>>> tokenizer = WhisperTokenizerFast.from_pretrained("openai/whisper-tiny", language="spanish")
>>> # now switch the prefix token from Spanish to French
>>> tokenizer.set_prefix_tokens(language="french")

get_special_tokens_mask

< >

( token_ids_0: listtoken_ids_1: list[int] | None = Nonealready_has_special_tokens: bool = False ) → list[int]

Parámetros

  • token_ids_0 (list[int]) — Lista de IDs.
  • token_ids_1 (list[int], opcional) — Segunda lista de IDs opcional para pares de secuencias.
  • already_has_special_tokens (bool, opcional, valor predeterminado False) — Indica si la lista de tokens ya está formateada con tokens especiales para el modelo.

Devuelve

list[int]

Una lista de enteros en el rango [0, 1]: 1 para un token especial, 0 para un token de secuencia.

Obtiene los ids de secuencia de una lista de tokens a la que no se le han añadido tokens especiales. Este método se llama al añadir tokens especiales mediante el método prepare_for_model del tokenizer.

save_vocabulary

< >

( save_directory: strfilename_prefix: str | None = None )

batch_decode

< >

( sequences: list[int] | list[list[int]] | np.ndarray | torch.Tensorskip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = None**kwargs ) → list[str]

Parámetros

  • sequences (Union[list[int], list[list[int]], np.ndarray, torch.Tensor]) — Lista de ids de entrada tokenizados. Se puede obtener usando el método __call__.
  • skip_special_tokens (bool, opcional, valor predeterminado False) — Indica si se deben eliminar los tokens especiales durante la decodificación.
  • clean_up_tokenization_spaces (bool, opcional) — Si se deben limpiar los espacios de tokenización. Si es None, se usará por defecto self.clean_up_tokenization_spaces.
  • kwargs (argumentos de palabra clave adicionales, opcional) — Se pasará al método de decodificación específico del modelo subyacente.

Devuelve

list[str]

La lista de oraciones decodificadas.

Convierta una lista de listas de ids de tokens en una lista de cadenas de texto llamando a decode.

Este método se proporciona por compatibilidad con versiones anteriores. El método decode ahora maneja la entrada por lotes de forma nativa, por lo que puede usar decode directamente en lugar de batch_decode.

decode

< >

( token_idsskip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = Noneoutput_offsets: bool = Falsetime_precision: float = 0.02decode_with_timestamps: bool = Falsenormalize: bool = Falsebasic_normalize: bool = Falseremove_diacritics: bool = False**kwargs ) → str

Parámetros

  • token_ids (Union[int, list[int], np.ndarray, torch.Tensor]) — Lista de ids de entrada tokenizados. Se puede obtener mediante el método __call__.
  • skip_special_tokens (bool, opcional, valor predeterminado False) — Indica si se deben eliminar los tokens especiales durante la decodificación. Si están presentes, se eliminarán los tokens anteriores (pre-prompt).
  • clean_up_tokenization_spaces (bool, opcional) — Indica si se deben limpiar los espacios de tokenización. Si es None, se usará por defecto self.clean_up_tokenization_spaces (disponible en tokenizer_config).
  • output_offsets (bool, opcional, valor predeterminado False) — Indica si se deben o no mostrar los desplazamientos de los tokens. Esto solo debe configurarse si el modelo predijo marcas de tiempo. Si hay tokens previos (antes del prompt) por decodificar, solo aparecerán en el texto decodificado si contienen tokens de marca de tiempo.
  • time_precision (float, opcional, valor predeterminado 0.02) — La proporción de tiempo para convertir de token a tiempo.
  • decode_with_timestamps (bool, opcional, valor predeterminado False) — Indica si se debe decodificar incluyendo marcas de tiempo en el texto sin procesar.
  • normalize (bool, opcional, valor predeterminado False) — Indica si se debe aplicar el normalizador de texto en inglés al texto decodificado. Solo es aplicable cuando el texto de destino está en inglés. En caso contrario, se debe aplicar el normalizador de texto básico.
  • basic_normalize (bool, opcional, valor predeterminado False) — Indica si se debe aplicar el normalizador de texto Basic al texto decodificado. Aplicable al texto objetivo multilingüe.
  • remove_diacritics (bool, opcional, valor predeterminado False) — Indica si se deben eliminar las diacríticas al aplicar el normalizador de texto básico. La eliminación de diacríticas puede destruir información en el texto decodificado, por lo que debe usarse con precaución.
  • kwargs (argumentos de palabra clave adicionales, opcional) — Se pasará al método de decodificación específico del modelo subyacente.

Devuelve

str

La frase decodificada.

Convierte una secuencia de ids en una cadena de texto, utilizando el tokenizador y el vocabulario, con opciones para eliminar tokens especiales y limpiar los espacios de tokenización.

Similar a hacer self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids)).

basic_normalize

< >

( textremove_diacritics = False )

Normaliza una cadena de texto dada mediante la clase BasicTextNormalizer, que realiza transformaciones comunes en texto multilingüe.

normalize

< >

( text )

Normaliza una cadena de texto dada mediante la clase EnglishTextNormalizer, que realiza transformaciones comunes en texto en inglés.

WhisperFeatureExtractor

clase transformers.WhisperFeatureExtractor

< >

( feature_size = 80sampling_rate = 16000hop_length = 160chunk_length = 30n_fft = 400padding_value = 0.0dither = 0.0return_attention_mask = False**kwargs )

Parámetros

  • feature_size (int, opcional, valor predeterminado 80) — La dimensión de las características de las características extraídas.
  • sampling_rate (int, opcional, valor predeterminado 16000) — La tasa de muestreo a la que deben digitalizarse los archivos de audio, expresada en hercios (Hz).
  • hop_length (int, opcional, valor predeterminado 160) — Longitud de las ventanas superpuestas para la STFT utilizada para obtener los coeficientes de Frecuencia Mel.
  • chunk_length (int, opcional, valor predeterminado 30) — El número máximo de fragmentos de sampling_rate muestras utilizados para recortar y rellenar secuencias de audio más largas o más cortas.
  • n_fft (int, opcional, valor predeterminado 400) — Tamaño de la transformada de Fourier.
  • padding_value (float, opcional, valor predeterminado 0.0) — Valor de relleno utilizado para rellenar el audio. Debe corresponder a silencios.
  • dither (float, optional, defaults to 0.0) — Adds dithering. In other words, adds a small Gaussian noise to each frame. E.g. use 0.0001 to add dithering with a normal distribution centered around 0.0 with standard deviation 0.0001 (assuming [-1,+1] range of raw_speech). The value 0.0 means no dithering. Dithering has similar effect as spectrogram(mel_floor=...). It reduces the high log_mel_fbank values for signals with hard-zero sections, when VAD cutoff is present in the signal.

Construye un extractor de características de Whisper.

Este extractor de características hereda de SequenceFeatureExtractor, que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos.

Esta clase extrae características de banco de filtros mel de audio en bruto mediante una implementación personalizada de numpy de la Short Time Fourier Transform que debe coincidir con el equivalente torch.stft de pytorch.

__call__

< >

( raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]truncation: bool = Truepad_to_multiple_of: int | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_attention_mask: bool | None = Nonepadding: str | None = 'max_length'max_length: int | None = Nonesampling_rate: int | None = Nonedo_normalize: bool | None = Nonedevice: str | None = 'cpu'**kwargs )

Parámetros

  • raw_speech (np.ndarray, list[float], list[np.ndarray], list[list[float]]) — La secuencia o lote de secuencias que se van a rellenar. Cada secuencia puede ser un array de numpy, una lista de valores float, una lista de arrays de numpy o una lista de listas de valores float. Debe ser audio de canal mono, no estéreo, es decir, un solo float por paso de tiempo.
  • truncation (bool, opcional, valor predeterminado True) — Activa la truncación para recortar las secuencias de entrada más largas que max_length hasta max_length.
  • pad_to_multiple_of (int, opcional, predeterminado a None) — Si se establece, rellenará la secuencia hasta un múltiplo del valor proporcionado.

    Esto resulta especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo >= 7.5 (Volta), o en TPUs, que se benefician de que las longitudes de secuencia sean un múltiplo de 128.

  • return_tensors (str o TensorType, opcional) — Si se establece, devolverá tensores en lugar de una lista de enteros de Python. Los valores aceptables son:
    • 'pt': Devuelve objetos torch.Tensor de PyTorch.
    • 'np': Devuelve objetos Numpy np.ndarray.
  • return_attention_mask (bool, opcional) — Indica si se debe devolver la máscara de atención. Si se deja en el valor predeterminado, se devolverá la máscara de atención según el valor predeterminado del feature_extractor específico.

    ¿Qué son las máscaras de atención?

    Para los modelos Whisper, attention_mask siempre debe pasarse en la inferencia por lotes para evitar errores sutiles.

  • padding (str o PaddingStrategy, opcional, valor predeterminado 'max_length') — Activa y controla el relleno. Acepta los siguientes valores: 'longest': Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia). 'max_length' (predeterminado): Rellena hasta una longitud máxima especificada con el argumento max_length o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. 'do_not_pad': Sin relleno (es decir, puede generar un lote con secuencias de diferentes longitudes).
    • 'longest': Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia).
    • 'max_length' (predeterminado): Rellena hasta una longitud máxima especificada con el argumento max_length o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento.
    • 'do_not_pad': Sin relleno (es decir, puede generar un lote con secuencias de longitudes diferentes).
  • max_length (int, opcional) — Controla la longitud máxima que se utilizará mediante uno de los parámetros de truncamiento/relleno.

    Si se deja sin definir o se establece en None, se utilizará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno lo requiere. Si el modelo no tiene una longitud máxima de entrada específica (como XLNet), el truncamiento/relleno a una longitud máxima se desactivará.

  • sampling_rate (int, opcional) — La tasa de muestreo a la que se muestreó la entrada raw_speech. Se recomienda encarecidamente pasar sampling_rate en la llamada forward para evitar errores silenciosos y permitir el pipeline de reconocimiento automático de voz.
  • do_normalize (bool, opcional, valor predeterminado False) — Indica si se debe normalizar la entrada con media cero y varianza unitaria. La normalización puede ayudar a mejorar significativamente el rendimiento del modelo.
  • device (str, opcional, por defecto 'cpu') — Especifica el dispositivo para el cálculo del espectrograma log-mel de las señales de audio en el método _torch_extract_fbank_features. (p. ej., “cpu”, “cuda”)
  • **kwargs — No es compatible con WhisperFeatureExtractor.call() y se ignora.

Método principal para extraer características y preparar una o varias secuencias para el modelo. La implementación utiliza PyTorch para el cálculo de la STFT si está disponible; de lo contrario, se utiliza una implementación más lenta basada en NumPy.

WhisperProcessor

clase transformers.WhisperProcessor

< >

( feature_extractortokenizer )

Parámetros

  • feature_extractor (WhisperFeatureExtractor) — El extractor de características es una entrada obligatoria.
  • tokenizer (WhisperTokenizer) — El tokenizador es una entrada obligatoria.

Crea un WhisperProcessor que envuelve un extractor de características y un tokenizador en un único procesador.

WhisperProcessor ofrece todas las funcionalidades de WhisperFeatureExtractor y WhisperTokenizer. Consulte ~WhisperFeatureExtractor y ~WhisperTokenizer para obtener más información.

__call__

< >

( *args**kwargs )

Parámetros

  • return_tensors (str o TensorType, opcional) — Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:
    • 'pt': Devuelve objetos torch.Tensor de PyTorch.
    • 'np': Devuelve objetos np.ndarray de NumPy.

from_pretrained

< >

( pretrained_model_name_or_path: str | os.PathLikecache_dir: str | os.PathLike | None = Noneforce_download: bool = Falselocal_files_only: bool = Falsetoken: str | bool | None = Nonerevision: str = 'main'**kwargs )

Parámetros

  • pretrained_model_name_or_path (str o os.PathLike) — Puede ser:
    • una cadena, el model id de un feature_extractor preentrenado alojado en un repositorio de modelos en huggingface.co.
    • una ruta a un directorio que contenga un archivo de extractor de características guardado usando el método save_pretrained(), por ejemplo, ./my_model_directory/.
    • una ruta a un archivo JSON de extractor de características guardado, archivo, p. ej., ./my_model_directory/preprocessor_config.json.
  • **kwargs — Argumentos de palabra clave adicionales que se pasan tanto a from_pretrained() como a ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained.

Instanciar un procesador asociado con un modelo preentrenado.

Este método de clase simplemente llama a los métodos from_pretrained() del extractor de características, ImageProcessingMixin del procesador de imágenes y ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained del tokenizador. Consulte las docstrings de los métodos anteriores para obtener más información.

save_pretrained

< >

( save_directorypush_to_hub: bool = False**kwargs )

Parámetros

  • save_directory (str o os.PathLike) — Directorio donde se guardará el archivo JSON del extractor de características y los archivos del tokenizador (el directorio se creará si no existe).
  • push_to_hub (bool, opcional, valor predeterminado False) — Indica si se debe subir el modelo al hub de modelos de Hugging Face después de guardarlo. Puedes especificar el repositorio al que deseas subirlo con repo_id (por defecto, usará el nombre de save_directory en tu espacio de nombres).
  • kwargs (dict[str, Any], opcional) — Argumentos de palabra clave adicionales que se pasan al método push_to_hub().

Guarda los atributos de este procesador (extractor de características, tokenizador…) en el directorio especificado para que pueda recargarse mediante el método from_pretrained().

Este método de clase simplemente llama a save_pretrained() y save_pretrained(). Consulte las docstrings de los métodos anteriores para obtener más información.

batch_decode

< >

( *args**kwargs )

Este método reenvía todos sus argumentos a batch_decode() de PreTrainedTokenizer. Consulte la docstring de este método para obtener más información.

decode

< >

( *args**kwargs )

Este método reenvía todos sus argumentos a decode() de PreTrainedTokenizer. Consulte la docstring de este método para obtener más información.

WhisperModel

clase transformers.WhisperModel

< >

( config: WhisperConfig )

Parámetros

  • config (WhisperConfig) — 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.

El modelo Whisper básico que genera estados ocultos sin ninguna cabeza específica 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

< >

( input_features: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonedecoder_inputs_embeds: tuple[torch.Tensor] | None = Nonedecoder_position_ids: tuple[torch.LongTensor] | None = Noneuse_cache: bool | None = None**kwargs ) → Seq2SeqModelOutput or tuple(torch.Tensor)

Parámetros

  • input_features (torch.Tensor de 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 utilizando WhisperFeatureExtractor. Consulte WhisperFeatureExtractor.call() para más detalles (WhisperProcessor utiliza WhisperFeatureExtractor para procesar audios).
  • attention_mask (torch.LongTensor de 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.

    ¿Qué son las máscaras de atención?

  • decoder_input_ids (torch.LongTensor de 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 con WhisperTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles. ¿Qué son los IDs de entrada del decodificador? Whisper utiliza decoder_start_token_id como token inicial para la generación de decoder_input_ids. Si se usa past_key_values, opcionalmente solo se deben ingresar los últimos decoder_input_ids (consulte past_key_values).

    Los índices se pueden obtener mediante WhisperTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para obtener más detalles.

    ¿Qué son los IDs de entrada del decodificador?

    Whisper utiliza decoder_start_token_id como el token inicial para la generación de decoder_input_ids. Si se utiliza past_key_values, opcionalmente solo se deben introducir los últimos decoder_input_ids (consulte past_key_values).

  • decoder_attention_mask (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Comportamiento predeterminado: genera un tensor que ignora los tokens de relleno en decoder_input_ids. También se usará una máscara causal de forma predeterminada.

    Si desea cambiar el comportamiento del relleno, debe leer modeling_whisper._prepare_decoder_attention_mask y modificarlo según sus necesidades. Consulte el diagrama 1 de el artículo de BART para obtener más información sobre la estrategia predeterminada.

  • encoder_outputs (tuple[tuple[torch.Tensor]], opcional) — La tupla consiste en (last_hidden_state, opcional: hidden_states, opcional: attentions) last_hidden_state de 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 la past_key_values devuelta por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.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 los input_ids no 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 los input_ids con forma (batch_size, sequence_length).

  • decoder_inputs_embeds (tuple[torch.Tensor] de forma (batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar decoder_input_ids puede optar por pasar directamente una representación incrustada. Si past_key_values se usa, opcionalmente solo el último decoder_inputs_embeds debe ser introducido (ver past_key_values). Esto es útil si se desea tener más control sobre cómo convertir decoder_input_ids índices en vectores asociados que la matriz de búsqueda de incrustaciones interna del modelo.

    Si decoder_input_ids y decoder_inputs_embeds no están configurados, decoder_inputs_embeds toma el valor de inputs_embeds.

  • decoder_position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • use_cache (bool, opcional) — Si se establece en True, se devuelven los estados de clave-valor de past_key_values y pueden usarse para acelerar la decodificación (ver past_key_values).

Devuelve

Seq2SeqModelOutput o tuple(torch.Tensor)

Un Seq2SeqModelOutput 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 (WhisperConfig) y las entradas.

El método forward de WhisperModel 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 Module despué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.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del decodificador del modelo.

    Si se utiliza past_key_values, solo se genera el último hidden-state de las secuencias con forma (batch_size, 1, hidden_size).

  • past_key_values (EncoderDecoderCache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.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 pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.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 opcionales de la incrustación inicial.

  • decoder_attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.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 pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.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.Tensor de 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 pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.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 opcionales de la incrustación inicial.

  • encoder_attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.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.

Ejemplo:

>>> import torch
>>> from transformers import AutoFeatureExtractor, WhisperModel
>>> from datasets import load_dataset

>>> model = WhisperModel.from_pretrained("openai/whisper-base")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("openai/whisper-base")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt")
>>> input_features = inputs.input_features
>>> decoder_input_ids = torch.tensor([[1, 1]]) * model.config.decoder_start_token_id
>>> last_hidden_state = model(input_features, decoder_input_ids=decoder_input_ids).last_hidden_state
>>> list(last_hidden_state.shape)
[1, 2, 512]

_mask_input_features

< >

( input_features: Tensorattention_mask: typing.Optional[torch.LongTensor] = None )

Las máscaras extraen características a lo largo del eje temporal y/o del eje de características según SpecAugment.

WhisperForConditionalGeneration

clase transformers.WhisperForConditionalGeneration

< >

( config: WhisperConfig )

Parámetros

  • config (WhisperConfig) — 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.

El modelo Whisper con una cabeza de modelado de lenguaje. Puede usarse para el reconocimiento automático de voz.

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

< >

( input_features: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonedecoder_inputs_embeds: tuple[torch.Tensor] | None = Nonedecoder_position_ids: tuple[torch.LongTensor] | None = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs ) → Seq2SeqLMOutput or tuple(torch.Tensor)

Parámetros

  • input_features (torch.Tensor de 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 utilizando WhisperFeatureExtractor. Consulte WhisperFeatureExtractor.call() para más detalles (WhisperProcessor utiliza WhisperFeatureExtractor para procesar audios).
  • attention_mask (torch.LongTensor de 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.

    ¿Qué son las máscaras de atención?

  • decoder_input_ids (torch.LongTensor de 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 con WhisperTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles. ¿Qué son los IDs de entrada del decodificador? Whisper utiliza decoder_start_token_id como token inicial para la generación de decoder_input_ids. Si se usa past_key_values, opcionalmente solo se deben ingresar los últimos decoder_input_ids (consulte past_key_values).

    Los índices se pueden obtener mediante WhisperTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para obtener más detalles.

    ¿Qué son los IDs de entrada del decodificador?

    Whisper utiliza decoder_start_token_id como el token inicial para la generación de decoder_input_ids. Si se utiliza past_key_values, opcionalmente solo se deben introducir los últimos decoder_input_ids (consulte past_key_values).

  • decoder_attention_mask (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Comportamiento predeterminado: genera un tensor que ignora los tokens de relleno en decoder_input_ids. También se usará una máscara causal de forma predeterminada.

    Si desea cambiar el comportamiento del relleno, debe leer modeling_whisper._prepare_decoder_attention_mask y modificarlo según sus necesidades. Consulte el diagrama 1 de el artículo de BART para obtener más información sobre la estrategia predeterminada.

  • encoder_outputs (tuple[tuple[torch.Tensor]], opcional) — La tupla consiste en (last_hidden_state, opcional: hidden_states, opcional: attentions) last_hidden_state de 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 la past_key_values devuelta por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.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 los input_ids no 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 los input_ids con forma (batch_size, sequence_length).

  • decoder_inputs_embeds (tuple[torch.Tensor] de forma (batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar decoder_input_ids puede optar por pasar directamente una representación incrustada. Si past_key_values se usa, opcionalmente solo el último decoder_inputs_embeds debe ser introducido (ver past_key_values). Esto es útil si se desea tener más control sobre cómo convertir decoder_input_ids índices en vectores asociados que la matriz de búsqueda de incrustaciones interna del modelo.

    Si decoder_input_ids y decoder_inputs_embeds no están configurados, decoder_inputs_embeds toma el valor de inputs_embeds.

  • decoder_position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje. Los índices deben estar en [0, ..., config.vocab_size] o ser -100 (ver la docstring de input_ids). Los tokens con índices establecidos en -100 se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en [0, ..., config.vocab_size]. sequence_length debe ser menor o igual que config.max_target_positions.
  • use_cache (bool, opcional) — Si se establece en True, se devuelven los estados de clave-valor de past_key_values y pueden usarse para acelerar la decodificación (ver past_key_values).

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 (WhisperConfig) y las entradas.

El método forward de WhisperForConditionalGeneration 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 Module despué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.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida de modelado de lenguaje.

  • logits (torch.Tensor de 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 pasa use_cache=True o cuando config.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 pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.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 pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.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 pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.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.Tensor de 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 pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.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 pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.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.

Ejemplo:

>>> import torch
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

>>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt")
>>> input_features = inputs.input_features

>>> generated_ids = model.generate(inputs=input_features)

>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> transcription
' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'

generate

< >

( input_features: typing.Optional[torch.Tensor] = Nonegeneration_config: transformers.generation.configuration_utils.GenerationConfig | None = Nonelogits_processor: transformers.generation.logits_process.LogitsProcessorList | None = Nonestopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = Noneprefix_allowed_tokens_fn: collections.abc.Callable[[int, torch.Tensor], list[int]] | None = Nonesynced_gpus: bool = Falsereturn_timestamps: bool | None = Nonetask: str | None = Nonelanguage: str | list[str] | None = Noneis_multilingual: bool | None = Noneprompt_ids: typing.Optional[torch.Tensor] = Noneprompt_condition_type: str | None = Nonecondition_on_prev_tokens: bool | None = Nonetemperature: float | tuple[float, ...] | None = Nonecompression_ratio_threshold: float | None = Nonelogprob_threshold: float | None = Noneno_speech_threshold: float | None = Nonenum_segment_frames: int | None = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetime_precision: float = 0.02time_precision_features: float = 0.01return_token_timestamps: bool | None = Nonereturn_segments: bool = Falsereturn_dict_in_generate: bool | None = Noneforce_unique_generate_call: bool | None = Nonemonitor_progress: collections.abc.Callable[[torch.Tensor], None] | None = None**kwargs ) → ModelOutput or dict[str, Any] or torch.LongTensor

Parámetros

  • input_features (torch.Tensor de forma (batch_size, feature_size, sequence_length), opcional) — Valores flotantes de características log-mel extraídas de la forma de onda de voz cruda. La forma de onda de voz cruda se puede obtener cargando un archivo de audio .flac o .wav en un array de tipo list[float], un numpy.ndarray o un torch.Tensor, por ejemplo mediante la biblioteca torchcodec (pip install torchcodec) o la biblioteca soundfile (pip install soundfile). Para preparar el array como input_features, se debe utilizar AutoFeatureExtractor para extraer las características mel, rellenar y convertir en un tensor de tipo torch.Tensor. Vea call() para más detalles.
  • generation_config (GenerationConfig, opcional) — La configuración de generación que se utilizará como parametrización base para la llamada de generación. Los **kwargs pasados a generate que coincidan con los atributos de generation_config los sobrescribirán. Si no se proporciona generation_config, se utilizará la predeterminada, que tiene la siguiente prioridad de carga: 1) desde el archivo de modelo generation_config.json, si existe; 2) desde la configuración del modelo. Tenga en cuenta que los parámetros no especificados heredarán los valores predeterminados de GenerationConfig, cuya documentación debe consultarse para parametrizar la generación.
  • logits_processor (LogitsProcessorList, opcional) — Procesadores de logits personalizados que complementan los procesadores de logits predeterminados creados a partir de los argumentos y la configuración de generación. Si se pasa un procesador de logits que ya fue creado con los argumentos o una configuración de generación, se lanza un error. Esta función está destinada a usuarios avanzados.
  • stopping_criteria (StoppingCriteriaList, opcional) — Criterios de parada personalizados que complementan los criterios de parada predeterminados creados a partir de los argumentos y una configuración de generación. Si se pasa un criterio de parada que ya ha sido creado con los argumentos o una configuración de generación, se lanza un error. Esta función está destinada a usuarios avanzados.
  • prefix_allowed_tokens_fn (Callable[[int, torch.Tensor], list[int]], opcional) — Si se proporciona, esta función restringe la búsqueda por haz a los tokens permitidos en cada paso. Si no se proporciona, no se aplica ninguna restricción. Esta función toma 2 argumentos: el ID del lote batch_id y input_ids. Debe devolver una lista con los tokens permitidos para el siguiente paso de generación condicionado al ID del lote batch_id y a los tokens generados previamente inputs_ids. Este argumento es útil para la generación condicionada al prefijo, tal como se describe en Autoregressive Entity Retrieval.
  • synced_gpus (bool, opcional, valor predeterminado False) — Si se debe continuar ejecutando el bucle while hasta max_length (necesario para evitar bloqueos con FullyShardedDataParallel y DeepSpeed ZeRO Stage 3).
  • return_timestamps (bool, opcional) — Indica si se deben devolver las marcas de tiempo junto con el texto. Esto habilita WhisperTimestampsLogitsProcessor. Para audios de más de 30 segundos, es necesario establecer return_timestamps=True.
  • task (str, opcional) — Tarea a utilizar para la generación, ya sea “translate” o “transcribe”.
  • language (str o lista de str, opcional) — Token de idioma a utilizar para la generación, puede estar en la forma <|en|>, en o english. Para la generación por lotes, se puede pasar una lista de tokens de idioma. Puedes encontrar todos los tokens de idioma posibles en el diccionario model.generation_config.lang_to_id.
  • is_multilingual (bool, opcional) — Indica si el modelo es multilingüe.
  • prompt_ids (torch.Tensor, opcional) — Tensor de rango 1 con IDs de tokens creado al pasar texto a get_prompt_ids() y proporcionado como prompt a cada chunk. Esto se puede usar para proporcionar o “prompt-engineer” un contexto para la transcripción, p. ej. vocabularios personalizados o nombres propios para aumentar la probabilidad de predecir esas palabras correctamente. No se puede usar junto con decoder_start_token_id ya que sobrescribe este valor.
  • prompt_condition_type (str, opcional) — Solo es relevante para la transcripción de formato largo. Tipo de condición de prompt_ids. ‘first-segment’ significa que solo el primer segmento se condiciona en prompt_ids. ‘all-segments’ significa que cada segmento se condiciona en prompt_ids. Asegúrate de habilitar condition_on_prev_tokens para ‘all-segments’. El valor predeterminado es ‘first-segment’. Para la transcripción de corto plazo, solo es posible ‘first-segment’.
  • condition_on_prev_tokens (bool, opcional) — Solo relevante para la transcripción de formato largo. Indica si cada segmento debe condicionar en el segmento anterior. Como se muestra en el paper de Whisper, esto puede ayudar a mejorar el rendimiento.
  • temperature (float o lista de float, opcional) — La temperatura que se utilizará para la generación. Pasar un único valor float y do_sample=True activa la generación mediante muestreo. Para transcripciones de formato largo, se puede activar el uso de temperatura de respaldo pasando una lista de valores float, como (0.0, 0.2, 0.4, 0.6, 0.8, 1.0). Como se muestra en el paper de Whisper, esto puede ayudar a mejorar el rendimiento.
  • compression_ratio_threshold (float, opcional) — Solo es relevante para la transcripción de formato largo. Si se define, se calculará la tasa de compresión zlib de cada segmento. Si la tasa de compresión de un segmento es mayor que compression_ratio_threshold, se activa el fallback de temperatura: el segmento generado se descarta y la generación se repite utilizando una temperatura más alta. La intuición detrás de esta función es que los segmentos con tasas de compresión muy altas sufren de mucha repetición. La repetición no deseada puede reducirse inyectando más aleatoriedad aumentando la temperatura. Si compression_ratio_threshold está definido, asegúrese de que temperature sea una lista de valores. Un valor común para compression_ratio_threshold es 1.35. Como se muestra en el paper de Whisper, esto puede ayudar a mejorar el rendimiento.
  • logprob_threshold (float, opcional) — Solo es relevante para la transcripción de formato largo. Si se define, se calculará la log-probabilidad media de cada segmento. Si la log-probabilidad de un segmento dado es menor que logprob_threshold, se activa el fallback de temperatura: el segmento generado se descarta y la generación se repite utilizando una temperatura más alta. La intuición detrás de esta función es que los segmentos de baja log-probabilidad pueden mejorarse inyectando más aleatoriedad aumentando la temperatura. Si logprob_threshold está definido, asegúrese de que temperature sea una lista de valores. Un valor común para logprob_threshold es -1.0. Como se muestra en el paper de Whisper, esto puede ayudar a mejorar el rendimiento.
  • no_speech_threshold (float, opcional) — Solo es relevante para la transcripción de audio de larga duración. Si se define, el token “no-speech” combinado con logprob_threshold se utiliza para determinar si un segmento contiene solo silencio. En ese caso, se omite la transcripción de ese segmento. Como se muestra en el paper de Whisper, esto puede ayudar a mejorar el rendimiento.
  • num_segment_frames (int, opcional) — El número de fotogramas de los que consta un segmento individual. Si no se define, num_segment_frames toma por defecto el valor del stride del modelo multiplicado por la longitud máxima de entrada.
  • attention_mask (torch.Tensor, opcional) — attention_mask debe pasarse al realizar transcripciones de formato largo con un tamaño de lote > 1.
  • time_precision (int, opcional, valor predeterminado 0.02) — La duración del token de salida en segundos. P. ej. 0.02 significa que un token generado representa en promedio 20 ms.
  • time_precision_features (int, opcional, valor predeterminado 0.01) — La duración representada por un cuadro de características en segundos.
  • return_token_timestamps (bool, opcional) — Indica si se deben devolver marcas de tiempo a nivel de token junto con el texto. Esto se puede usar con o sin la opción return_timestamps. Para obtener marcas de tiempo a nivel de palabra, usa el tokenizador para agrupar los tokens en palabras.
  • return_segments (bool, opcional, valor predeterminado False) — Indica si se debe devolver adicionalmente una lista de todos los segmentos. Tenga en cuenta que esta opción solo se puede habilitar al realizar transcripciones de formato largo.
  • return_dict_in_generate (bool, opcional, valor predeterminado False) — Indica si se debe devolver un ModelOutput en lugar de solo los tokens generados. Tenga en cuenta que, al realizar transcripciones de formato largo, return_dict_in_generate solo se puede habilitar cuando return_segments se establece en True. En este caso, las salidas de generación de cada segmento se añaden a cada segmento.
  • force_unique_generate_call (bool, opcional) — Indica si se debe forzar una llamada única al método generate() de la GenerationMixin subyacente. Esto es útil para el decodificado asistido y con fines de prueba, para garantizar que solo se realice una llamada a generate() y, por lo tanto, se devuelvan los ids de tokens de entrada del decodificador y los ids de tokens eos.
  • monitor_progress (Callable[[torch.Tensor], None], opcional) — Si se proporciona, esta función puede llamarse para informar sobre el progreso de la transcripción de audio. La función recibe un argumento tensor p de forma (n, 2), donde n es el tamaño del lote. p[i, 0] contiene el índice del fotograma de audio que se está transcribiendo actualmente para el elemento del lote i. p[i, 1] contiene el número total de fotogramas para el elemento del lote i. No se espera ningún valor de retorno.
  • kwargs (dict[str, Any], opcional) — Parametrización ad hoc de generate_config y/o kwargs adicionales específicos del modelo que se reenviarán a la función forward del modelo. Si el modelo es un modelo encoder-decoder, los kwargs específicos del encoder no deben tener prefijo y los kwargs específicos del decoder deben tener el prefijo decoder_.

Devuelve

ModelOutput o dict[str, Any] o torch.LongTensor

Una de las siguientes:

  • ModelOutput cuando return_dict_in_generate=True y (return_timestamps=False o force_unique_generate_call=True), que incluye los ids de entrada del decodificador y el id de fin de secuencia.
  • dict[str, Any] cuando (return_dict_in_generate=True y return_timestamps=True) o return_segments=True o return_token_timestamps=True.
  • torch.LongTensor en todos los demás casos, excluyendo los ids de entrada del decodificador y el id de fin de secuencia.

Los tipos posibles de ModelOutput son:

segments es una lista de listas (una lista por elemento del lote) de segment. Un segment es un diccionario con las claves start, end, tokens, idxs y result.

  • start: marca de tiempo de inicio del segmento.
  • end: marca de tiempo final del segmento.
  • tokens: los tokens del segmento, excluyendo los ids de entrada del decodificador y el id de fin de secuencia.
  • idxs: los índices de inicio (incluido) y fin (excluido) de los tokens del segmento en la llamada subyacente a generate() de GenerationMixin (presente en result).
  • result: el resultado de la llamada subyacente a generate() de GenerationMixin.

Cuando return_timestamps=True, return_dict_in_generate=True se aplica a cada llamada de generate() de la GenerationMixin subyacente, con las salidas almacenadas en result de cada segment.

Transcribe o traduce las características de entrada log-mel a una secuencia de ids de tokens generados de forma auto-regresiva.

La mayoría de los parámetros de control de generación se configuran en generation_config, que, si no se pasa, se establecerá en la configuración de generación predeterminada del modelo. Puede invalidar cualquier generation_config pasando los parámetros correspondientes a generate(), por ejemplo, .generate(inputs, num_beams=4, do_sample=True).

Para obtener una visión general de las estrategias de generación y ejemplos de código, consulte la siguiente guía.

Ejemplo:

  • Transcripción de formato largo: Para transcribir o traducir audios de más de 30 segundos, procese los archivos de audio sin truncarlos y pase todas las características mel a generate de una sola vez. Es necesario establecer return_timestamps=True. De hecho, la transcripción de formato largo utiliza un algoritmo secuencial basado en predicciones de marcas de tiempo, con heurísticas como el umbral de ratio de compresión, el umbral de probabilidad logarítmica y el fallback de temperatura. Este algoritmo se describe en el artículo original de Whisper, sección 3.8. Long-form Transcription.
>>> import torch
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset, Audio

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> model.cuda()
>>> # load audios > 30 seconds
>>> ds = load_dataset("distil-whisper/meanwhile", "default")["test"]
>>> # resample to 16kHz
>>> ds = ds.cast_column("audio", Audio(sampling_rate=16000))
>>> # take first 8 audios and retrieve array
>>> audio = ds[:8]["audio"]
>>> audio = [x["array"] for x in audio]

>>> # make sure to NOT truncate the input audio, to return the `attention_mask` and to pad to the longest audio
>>> inputs = processor(audio, return_tensors="pt", truncation=False, padding="longest", return_attention_mask=True, sampling_rate=16_000)
>>> inputs = inputs.to("cuda", torch.float32)

>>> # transcribe audio to ids
>>> generated_ids = model.generate(**inputs, return_timestamps=True)

>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)
>>> transcription[0]
" Folks, if you watch the show, you know, I spent a lot of time right over there. Patiently and astutely scrutinizing the boxwood and mahogany chest set of the day's biggest stories developing the central headline pawns, definitely maneuvering an oso topical night to F6, fainting a classic Sicilian, nade door variation on the news, all the while seeing eight moves deep and patiently marshalling the latest press releases into a fisher's shows in Lip Nitsky attack that culminates in the elegant lethal slow-played, all-passant checkmate that is my nightly monologue. But sometimes, sometimes, folks, I. CHEERING AND APPLAUSE Sometimes I startle away, cubside down in the monkey bars of a condemned playground on a super fun site. Get all hept up on goofballs. Rummage that were discarded tag bag of defective toys. Yank out a fist bowl of disembodied doll limbs, toss them on a stained kid's place mat from a defunct dennies. set up a table inside a rusty cargo container down by the Wharf and challenged toothless drifters to the godless bughouse blitz of tournament that is my segment. Meanwhile."

El callback monitor_progress se puede utilizar para supervisar el progreso de la transcripción:

>>> from tqdm import tqdm

>>> # prepare inputs like above

>>> # define a callback to monitor the progress of the transcription.
>>> with tqdm(desc="Progress") as pbar:
>>>     def monitor_progress(p_batch):
>>>         i = torch.argmax(p_batch[:, 1])
>>>         p = p_batch[i].detach().cpu()
>>>         pbar.total = int(p[1])
>>>         pbar.n = int(p[0])
>>>         pbar.update()

>>>     # transcribe audio to ids
>>>     generated_ids = model.generate(**inputs, return_timestamps=True, monitor_progress=monitor_progress)

>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)
>>> transcription[0]
Progress:  95%|█████████████████████████████████████████████████████████████████████████████████████████████████▎    | 8497/8901 [00:04<00:00, 2052.79it/s]
" Folks, if you watch the show, you know, I spent a lot of time right over there. Patiently and astutely scrutinizing the boxwood and mahogany chest set of the day's biggest stories developing the central headline pawns, definitely maneuvering an oso topical night to F6, fainting a classic Sicilian, nade door variation on the news, all the while seeing eight moves deep and patiently marshalling the latest press releases into a fisher's shows in Lip Nitsky attack that culminates in the elegant lethal slow-played, all-passant checkmate that is my nightly monologue. But sometimes, sometimes, folks, I. CHEERING AND APPLAUSE Sometimes I startle away, cubside down in the monkey bars of a condemned playground on a super fun site. Get all hept up on goofballs. Rummage that were discarded tag bag of defective toys. Yank out a fist bowl of disembodied doll limbs, toss them on a stained kid's place mat from a defunct dennies. set up a table inside a rusty cargo container down by the Wharf and challenged toothless drifters to the godless bughouse blitz of tournament that is my segment. Meanwhile."
  • Transcripción de formato corto: Si las características de entrada mel pasadas son de 30 segundos o menos, hay dos posibilidades:
    • return_timestamps=False: se transcribirá todo el audio con una única llamada a generate() de GenerationMixin.
    • return_timestamps=True: el audio se transcribirá usando la misma lógica que la transcripción de formato largo.
>>> import torch
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

>>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt")
>>> input_features = inputs.input_features

>>> generated_ids = model.generate(inputs=input_features)

>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> transcription
' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'

WhisperForCausalLM

clase transformers.WhisperForCausalLM

< >

( config: WhisperConfig )

Parámetros

  • config (WhisperConfig) — 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.

Decodificador de Whisper con una cabeza de modelado de lenguaje en la parte superior (capa lineal con pesos vinculados a las incrustaciones de entrada).

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

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneencoder_outputs: tuple[torch.Tensor] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs ) → CausalLMOutputWithCrossAttentions or tuple(torch.Tensor)

Parámetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • attention_mask (torch.Tensor de 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.

    ¿Qué son las máscaras de atención?

  • encoder_outputs (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del codificador. Se utiliza en la atención cruzada si el modelo está configurado como 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 la past_key_values devuelta por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.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 los input_ids no 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 los input_ids con forma (batch_size, sequence_length).

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar 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 de input_ids en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.
  • labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en [0, ..., config.vocab_size] o ser -100 (ver la docstring de input_ids). Los tokens con índices establecidos en -100 se 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 en True, se devuelven los estados de clave-valor de past_key_values y pueden usarse para acelerar la decodificación (ver past_key_values).

Devuelve

CausalLMOutputWithCrossAttentions o tuple(torch.Tensor)

Un CausalLMOutputWithCrossAttentions 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 (WhisperConfig) y las entradas.

El método forward de WhisperForCausalLM 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 Module despué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.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida de modelado de lenguaje (para la predicción del siguiente token).

  • logits (torch.Tensor de 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).

  • hidden_states (tuple(torch.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.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 modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el 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 pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de las atenciones cruzadas después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.

  • past_key_values (Cache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.

    Contiene estados ocultos precalculados (claves y valores en los bloques de atención) que se pueden utilizar (véase la entrada past_key_values) para acelerar la decodificación secuencial.

Ejemplo:

>>> from transformers import WhisperForCausalLM, WhisperForConditionalGeneration, WhisperProcessor
>>> import torch
>>> from datasets import load_dataset

>>> processor = WhisperProcessor.from_pretrained("openai/whisper-large-v2")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-large-v2")

>>> assistant_model = WhisperForCausalLM.from_pretrained("distil-whisper/distil-large-v2")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> sample = ds[0]["audio"]
>>> input_features = processor(
...     sample["array"], sampling_rate=sample["sampling_rate"], return_tensors="pt"
... ).input_features

>>> predicted_ids = model.generate(input_features, assistant_model=assistant_model)

>>> # decode token ids to text
>>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
>>> transcription
' Mr. Quilter is the apostle of the middle classes and we are glad to welcome his gospel.'

WhisperForAudioClassification

clase transformers.WhisperForAudioClassification

< >

( config: WhisperConfig )

Parámetros

  • config (WhisperConfig) — 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.

Modelo de codificador Whisper con una cabeza de clasificación de secuencias en la parte superior (una capa lineal sobre la salida agrupada) para tareas como el reconocimiento de palabras clave de SUPERB.

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

< >

( input_features: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonelabels: typing.Optional[torch.LongTensor] = None**kwargs ) → SequenceClassifierOutput or tuple(torch.Tensor)

Parámetros

  • input_features (torch.LongTensor de 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 utilizando WhisperFeatureExtractor. Consulte WhisperFeatureExtractor.call() para obtener más detalles (WhisperProcessor utiliza WhisperFeatureExtractor para procesar audios).
  • encoder_outputs (tuple[tuple[torch.Tensor]], opcional) — La tupla consiste en (last_hidden_state, opcional: hidden_states, opcional: attentions) last_hidden_state de 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.
  • labels (torch.LongTensor de forma (batch_size,), opcional) — Etiquetas para calcular la pérdida de clasificación/regresión de secuencia. Los índices deben estar en [0, ..., config.num_labels - 1]. Si config.num_labels == 1 se calcula una pérdida de regresión (pérdida de error cuadrático medio), si config.num_labels > 1 se calcula una pérdida de clasificación (entropía cruzada).

Devuelve

SequenceClassifierOutput o tuple(torch.Tensor)

Un SequenceClassifierOutput 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 (WhisperConfig) y las entradas.

El método forward de WhisperForAudioClassification 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 Module despué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.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida de clasificación (o de regresión si config.num_labels==1).

  • logits (torch.Tensor de forma (batch_size, config.num_labels)) — Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax).

  • hidden_states (tuple(torch.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.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 modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplo:

>>> import torch
>>> from transformers import AutoFeatureExtractor, WhisperForAudioClassification
>>> from datasets import load_dataset

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("sanchit-gandhi/whisper-medium-fleurs-lang-id")
>>> model = WhisperForAudioClassification.from_pretrained("sanchit-gandhi/whisper-medium-fleurs-lang-id")

>>> ds = load_dataset("google/fleurs", "all", split="validation", streaming=True)
>>> sample = next(iter(ds))

>>> inputs = feature_extractor(
...     sample["audio"]["array"], sampling_rate=sample["audio"]["sampling_rate"], return_tensors="pt"
... )
>>> input_features = inputs.input_features

>>> with torch.no_grad():
...     logits = model(input_features).logits

>>> predicted_class_ids = torch.argmax(logits).item()
>>> predicted_label = model.config.id2label[predicted_class_ids]
>>> predicted_label
'Afrikaans'
Update on GitHub

←WavLM X-Codec→