Hugging Face's logo

Transformers documentation

CLVP

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 12 de mayo de 2023 y se contribuyó a Hugging Face Transformers el 10 de noviembre de 2023.

CLVP

Resumen

El modelo CLVP (Contrastive Language-Voice Pretrained Transformer) fue propuesto en Better speech synthesis through scaling por James Betker.

El resumen del artículo es el siguiente:

En los últimos años, el campo de la generación de imágenes ha sido revolucionado por la aplicación de transformers autoregresivos y DDPMs. Estos enfoques modelan el proceso de generación de imágenes como un proceso probabilístico por pasos y aprovechan grandes cantidades de cómputo y datos para aprender la distribución de las imágenes. Esta metodología para mejorar el rendimiento no debe limitarse a las imágenes. Este artículo describe una forma de aplicar los avances en el dominio de la generación de imágenes a la síntesis de voz. El resultado es TorToise, un sistema expresivo de texto a voz con múltiples voces.

Este modelo fue aportado por Susnato Dhar. El código original se puede encontrar aquí.

Consejos de uso

  1. CLVP es una parte integral del modelo Tortoise TTS.
  2. CLVP se puede utilizar para comparar diferentes candidatos de voz generados con el texto proporcionado, y los mejores tokens de voz se envían al modelo de difusión.
  3. Se recomienda encarecidamente el uso del método ClvpModelForConditionalGeneration.generate() para el uso de tortoise.
  4. Tenga en cuenta que el modelo CLVP espera que el audio esté muestreado a 22,05 kHz, a diferencia de otros modelos de audio que esperan 16 kHz.

Explicación breve

  • El ClvpTokenizer tokeniza la entrada de texto y el ClvpFeatureExtractor extrae el log mel-espectrograma del audio deseado.
  • ClvpConditioningEncoder toma esos tokens de texto y representaciones de audio y los convierte en embeddings condicionados por el texto y el audio.
  • El ClvpForCausalLM utiliza esas incrustaciones para generar múltiples candidatos de voz.
  • Cada candidato de voz se pasa por el codificador de voz (ClvpEncoder), que los convierte en una representación vectorial, y el codificador de texto (ClvpEncoder) convierte los tokens de texto en el mismo espacio latente.
  • Al final, comparamos cada vector de voz con el vector de texto para ver cuál de los vectores de voz es más similar al vector de texto.
  • ClvpModelForConditionalGeneration.generate() comprime toda la lógica descrita anteriormente en un único método.

Ejemplo:

import datasets

from transformers import ClvpModelForConditionalGeneration, ClvpProcessor


# Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using `datasets` library).
text = "This is an example text."

ds = datasets.load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
ds = ds.cast_column("audio", datasets.Audio(sampling_rate=22050))
sample = ds[0]["audio"]

# Define processor and model.
processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev", device_map="auto")

# Generate processor output and model output.
processor_output = processor(raw_speech=sample["array"], sampling_rate=sample["sampling_rate"], text=text, return_tensors="pt").to(model.device)
generated_output = model.generate(**processor_output)

ClvpConfig

clase transformers.ClvpConfig

< >

( 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 = 0is_encoder_decoder: bool = Falseid2label: 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 = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonespeech_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonedecoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneprojection_dim: int = 768logit_scale_init_value: float = 2.6592initializer_factor: float = 1.0 )

Parámetros

  • text_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — El objeto de configuración o el diccionario del backbone de texto.
  • speech_config (dict, opcional) — Diccionario de opciones de configuración utilizado para inicializar el codificador de voz CLVP.
  • decoder_config (dict, opcional) — Diccionario de opciones de configuración utilizado para inicializar ClvpDecoderConfig.
  • projection_dim (int, opcional, valor predeterminado 768) — Dimensionalidad de las capas de proyección de texto y visión.
  • logit_scale_init_value (float, opcional, valor predeterminado 2.6592) — El valor inicial del parámetro logit_scale.
  • initializer_factor (float, opcional, valor predeterminado 1.0) — Un factor para inicializar todas las matrices de pesos (debe mantenerse en 1, se usa internamente para pruebas de inicialización).

Esta es la clase de configuración para almacenar la configuración de un ClvpModelForConditionalGeneration. Se utiliza para instanciar un modelo Clvp 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 susnato/clvp_dev

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 ClvpConfig, ClvpModelForConditionalGeneration

>>> # Initializing a ClvpConfig with susnato/clvp_dev style configuration
>>> configuration = ClvpConfig()

>>> # Initializing a ClvpModelForConditionalGeneration (with random weights) from the susnato/clvp_dev style configuration
>>> model = ClvpModelForConditionalGeneration(configuration)

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

>>> # We can also initialize a CLVPConfig from a CLVPTextConfig, CLVPSpeechConfig and a CLVPAutoRegressiveConfig
>>> from transformers import ClvpEncoderConfig, ClvpDecoderConfig

>>> # Initializing a CLVP text, CLVP speech and CLVP decoder configuration
>>> config_text = ClvpEncoderConfig()
>>> config_speech = ClvpEncoderConfig()
>>> decoder_config = ClvpDecoderConfig()

>>> config = ClvpConfig(config_text, config_speech, decoder_config)

ClvpEncoderConfig

clase transformers.ClvpEncoderConfig

< >

( 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 = 0is_encoder_decoder: bool = Falseid2label: 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 = Nonevocab_size: int = 256hidden_size: int = 768intermediate_size: int = 1536projection_dim: int = 768num_hidden_layers: int = 20num_attention_heads: int = 12hidden_act: str = 'gelu'layer_norm_eps: float = 1e-05attention_dropout: float | int = 0.1dropout: float | int = 0.1use_rotary_embedding: bool = Trueuse_attention_bias: bool = Falsesummary_type: str = 'mean'initializer_factor: float = 1.0bos_token_id: int | None = 255eos_token_id: int | list[int] | None = 0pad_token_id: int | None = None )

Parámetros

  • vocab_size (int, opcional, valor predeterminado 256) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante input_ids.
  • hidden_size (int, opcional, valor predeterminado 768) — Dimensión de las representaciones ocultas.
  • intermediate_size (int, opcional, valor predeterminado 1536) — Dimensión de las representaciones del MLP.
  • projection_dim (int, opcional, valor predeterminado 768) — Dimensionalidad de las capas de proyección de texto y visión.
  • num_hidden_layers (int, opcional, valor predeterminado 20) — Número de capas ocultas en el decodificador del Transformer.
  • num_attention_heads (int, opcional, valor predeterminado 12) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer.
  • hidden_act (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.
  • layer_norm_eps (float, opcional, valor predeterminado 1e-05) — El epsilon utilizado por las capas de normalización de capa.
  • attention_dropout (Union[float, int], opcional, valor predeterminado 0.1) — La proporción de dropout para las probabilidades de atención.
  • dropout (Union[float, int], opcional, valor predeterminado 0.1) — La proporción para todas las capas de dropout.
  • use_rotary_embedding (bool, opcional, valor predeterminado True) — Si se debe usar rotary_embedding o no.
  • use_attention_bias (bool, opcional, valor predeterminado False) — Si se debe usar sesgo en las capas de Query, Key y Value durante la autoatención.
  • summary_type (str, opcional, por defecto "mean") — Estrategia a utilizar para obtener pooler_output a partir de last_hidden_state. Se admiten "last", "first", "mean" y "cls_index".
  • initializer_factor (float, opcional, valor predeterminado 1.0) — Un factor para inicializar todas las matrices de pesos (debe mantenerse en 1, se usa internamente para pruebas de inicialización).
  • bos_token_id (int, opcional, valor predeterminado 255) — Id del token utilizado para el inicio de la secuencia en el vocabulario.
  • eos_token_id (Union[int, list[int]], opcional, valor predeterminado 0) — Identificador de token utilizado para el fin de secuencia en el vocabulario.
  • pad_token_id (int, opcional) — Id del token utilizado para el relleno en el vocabulario.

Esta es la clase de configuración para almacenar la configuración de un ClvpModelForConditionalGeneration. Se utiliza para instanciar un modelo Clvp 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 susnato/clvp_dev

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 ClvpEncoderConfig, ClvpEncoder

>>> # Initializing a ClvpEncoderConfig with susnato/clvp_dev style configuration
>>> encoder_configuration = ClvpEncoderConfig()

>>> # Initializing a ClvpEncoder (with random weights) from the susnato/clvp_dev style configuration
>>> model = ClvpEncoder(encoder_configuration)

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

ClvpDecoderConfig

clase transformers.ClvpDecoderConfig

< >

( 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 = 0is_encoder_decoder: bool = Falseid2label: 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 = Nonevocab_size: int = 8194max_position_embeddings: int = 608max_text_tokens: int = 404hidden_size: int = 1024num_hidden_layers: int = 30num_attention_heads: int = 16n_inner: int | None = Nonenum_mel_attn_blocks: int = 6activation_function: str = 'gelu_new'resid_pdrop: float | int = 0.1embd_pdrop: float | int = 0.1attention_dropout: float | int = 0.1layer_norm_epsilon: float = 1e-05initializer_range: float = 0.02summary_type: str = 'cls_index'summary_use_proj: bool = Truesummary_activation: str | None = Nonesummary_proj_to_labels: bool = Truesummary_first_dropout: float | int = 0.1use_cache: bool = Truebos_token_id: int | None = 8192eos_token_id: int | list[int] | None = 8193pad_token_id: int | None = Nonefeature_size: int = 80use_attention_bias: bool = Trueinitializer_factor: float = 1.0decoder_fixing_codes: list[int] | tuple[int, ...] = (83, 45, 45, 248)add_cross_attention: bool = False )

Parámetros

  • vocab_size (int, opcional, valor predeterminado 8194) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante input_ids.
  • max_position_embeddings (int, opcional, valor predeterminado 608) — La longitud máxima de secuencia con la que se podría utilizar este modelo.
  • max_text_tokens (int, opcional, valor predeterminado 404) — La longitud máxima de la secuencia de tokens de texto con la que podría usarse este modelo. Similar a n_positions en GPT2Config.
  • hidden_size (int, opcional, valor predeterminado 1024) — Dimensión de las representaciones ocultas.
  • num_hidden_layers (int, opcional, valor predeterminado 30) — Número de capas ocultas en el decodificador del Transformer.
  • num_attention_heads (int, opcional, valor predeterminado 16) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer.
  • n_inner (int, opcional) — Dimensionalidad de las capas feed-forward internas. None la establecerá en 4 veces hidden_size.
  • num_mel_attn_blocks (int, opcional, valor predeterminado 6) — Indica el número de capas de autoatención en ClvpConditioningEncoder.
  • activation_function (str, opcional, valor predeterminado gelu_new) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, "gelu", "relu", "silu", etc.
  • resid_pdrop (Union[float, int], opcional, valor predeterminado 0.1) — La probabilidad de dropout para todas las capas completamente conectadas en las incrustaciones, el codificador y el pooler.
  • embd_pdrop (Union[float, int], opcional, valor predeterminado 0.1) — La proporción de dropout para las incrustaciones.
  • attention_dropout (Union[float, int], opcional, valor predeterminado 0.1) — La proporción de dropout para las probabilidades de atención.
  • layer_norm_epsilon (float, opcional, valor predeterminado 1e-05) — El epsilon utilizado por las capas de normalización de capa.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
  • summary_type (string, opcional, por defecto "cls_index") — Argumento utilizado al realizar un resumen de secuencia. Debe ser una de las siguientes opciones:
    • "last": Toma el estado oculto del último token (como XLNet).
    • "first": Toma el estado oculto del primer token (como BERT).
    • "mean": Toma la media de los estados ocultos de todos los tokens.
    • "cls_index": Proporcione un Tensor con la posición del token de clasificación (como en GPT/GPT-2).
    • "attn": No implementado ahora, usa atención multi-cabeza.
  • summary_use_proj (bool, opcional, valor predeterminado True) — Indica si se debe o no añadir una proyección después de la extracción del vector.
  • summary_activation (str, opcional) — Pase "tanh" para una activación tanh en la salida; cualquier otro valor resultará en ninguna activación.
  • summary_proj_to_labels (bool, opcional, valor predeterminado True) — Si las salidas de la proyección deben tener config.num_labels o config.hidden_size clases.
  • summary_first_dropout (float, opcional, valor predeterminado 0.1) — La proporción de dropout que se utilizará después de la proyección y la activación.
  • 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.
  • bos_token_id (int, opcional, valor predeterminado 8192) — Id del token utilizado para el inicio de la secuencia en el vocabulario.
  • eos_token_id (Union[int, list[int]], opcional, valor predeterminado 8193) — Identificador de token utilizado para el fin de secuencia en el vocabulario.
  • pad_token_id (int, opcional) — Id del token utilizado para el relleno en el vocabulario.
  • feature_size (int, opcional, valor predeterminado 80) — La dimensión de las características de las características mel extraídas. Este valor se utiliza en ClvpConditioningEncoder.
  • use_attention_bias (bool, opcional, valor predeterminado True) — Si se debe usar sesgo en las capas de Query, Key y Value durante la autoatención.
  • initializer_factor (float, opcional, valor predeterminado 1.0) — Un factor para inicializar todas las matrices de pesos (debe mantenerse en 1, se usa internamente para pruebas de inicialización).
  • decoder_fixing_codes (list, opcional, valor predeterminado [83, 45, 45, 248]) — Estos valores se utilizan en el método fix_speech_decoder_output para corregir las salidas generadas por el decodificador.
  • add_cross_attention (bool, opcional, valor predeterminado False) — Si se deben añadir capas de atención cruzada al modelo.

Esta es la clase de configuración para almacenar la configuración de un ClvpModelForConditionalGeneration. Se utiliza para instanciar un modelo Clvp 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 susnato/clvp_dev

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 ClvpDecoderConfig, ClvpDecoder

>>> # Initializing a ClvpDecoderConfig with susnato/clvp_dev style configuration
>>> decoder_configuration = ClvpDecoderConfig()

>>> # Initializing a ClvpDecoder (with random weights) from the susnato/clvp_dev style configuration
>>> model = ClvpDecoder(decoder_configuration)

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

ClvpTokenizer

clase transformers.ClvpTokenizer

< >

( vocab_filemerges_fileerrors = 'replace'unk_token = '[UNK]'bos_token = '<|endoftext|>'eos_token = '[STOP]'pad_token = '[STOP]'add_prefix_space = False**kwargs )

Parámetros

  • vocab_file (str) — Ruta al archivo de vocabulario.
  • merges_file (str) — Ruta al archivo de fusiones.
  • errors (str, opcional, valor predeterminado "replace") — Paradigma a seguir al decodificar bytes a UTF-8. Consulte bytes.decode para obtener más información.
  • unk_token (str, opcional, valor predeterminado "[UNK]") — 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.
  • eos_token (str, opcional, valor predeterminado "[STOP]") — El token de fin de secuencia.
  • pad_token (str, opcional, valor predeterminado "[STOP]") — El token de relleno de la 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 CLVP detecta el inicio de las palabras mediante el espacio que las precede).

Construye un tokenizador CLVP. Basado en Byte-Pair-Encoding a nivel de bytes.

Este tokenizador se ha entrenado para tratar los espacios como partes de los tokens (un poco como sentencepiece), por lo que una palabra

se codifica de manera diferente si se encuentra al principio de la oración (sin espacio) o no:

>>> from transformers import ClvpTokenizer

>>> tokenizer = ClvpTokenizer.from_pretrained("susnato/clvp_dev")
>>> tokenizer("Hello world")["input_ids"]
[62, 84, 28, 2, 179, 79]

>>> tokenizer(" Hello world")["input_ids"]
[2, 62, 84, 28, 2, 179, 79]

Puede evitar ese comportamiento pasando add_prefix_space=True al instanciar este tokenizer o al llamarlo sobre algún texto, pero dado que el modelo no se preentrenó de esa manera, podría provocar una disminución en el rendimiento.

Cuando se usa con is_split_into_words=True, este tokenizador añadirá un espacio antes de cada palabra (incluso la primera).

Este tokenizador hereda de PreTrainedTokenizer, 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.

save_vocabulary

< >

( save_directory: strfilename_prefix: str | None = None ) → tuple[str, ...]

Parámetros

  • save_directory (str) — El directorio en el que se guardará el vocabulario.
  • filename_prefix (str, opcional) — Un prefijo opcional para añadir al nombre de los archivos guardados.

Devuelve

tuple[str, ...]

Rutas a los archivos guardados, o una tupla vacía si no se guardaron archivos.

Implementación predeterminada para los patrones comunes de guardado de vocabulario. Guarda self.encoder/self.vocab como JSON, opcionalmente con self.bpe_ranks como fusiones. Devuelve una tupla vacía si no existe un vocabulario.

Sobrescriba este método si su tokenizador requiere una lógica de guardado personalizada (p. ej., modelos de SentencePiece, varios archivos de vocabulario o formatos de archivo especiales).

ClvpFeatureExtractor

clase transformers.ClvpFeatureExtractor

< >

( feature_size = 80sampling_rate = 22050default_audio_length = 6hop_length = 256chunk_length = 30n_fft = 1024padding_value = 0.0mel_norms = Nonereturn_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 22050) — La tasa de muestreo a la que deben digitalizarse los archivos de audio, expresada en hercios (Hz).
  • default_audio_length (int, opcional, valor predeterminado 6) — La duración predeterminada del audio sin procesar, en segundos. Si max_length no se establece durante __call__, se establecerá automáticamente en default_audio_length * self.sampling_rate.
  • hop_length (int, opcional, valor predeterminado 256) — 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 1024) — 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.
  • mel_norms (list de longitud feature_size, opcional) — Si se proporciona mel_norms, se utilizará para normalizar los espectrogramas log-mel a lo largo de cada filtro mel.
  • return_attention_mask (bool, opcional, por defecto False) — Si se debe devolver la máscara de atención. Si se deja en el valor predeterminado, devolverá la máscara de atención.

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

Construye un extractor de características CLVP.

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 espectrogramas log-mel a partir 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]]sampling_rate: int | None = Nonetruncation: bool = Truepad_to_multiple_of: int | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_attention_mask: bool | None = Truepadding: str | None = 'max_length'max_length: int | None = None**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.
  • 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.
  • 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) — 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_attention_mask (bool, opcional, por defecto True) — Si se devuelve la máscara de atención. Si se deja en el valor predeterminado, se devolverá la máscara de atención.

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

  • 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.
  • padding_value (float, opcional, valor predeterminado 0.0) — El valor que se utiliza para rellenar los valores / vectores de relleno.
  • max_length (int, opcional) — La longitud máxima de entrada de las entradas.

ClvpFeatureExtractor se utiliza para extraer diversas propiedades específicas de la voz, como el tono y la entonación, la velocidad de habla e incluso defectos de habla como el tartamudeo o la siseante, a partir de una muestra de voz o raw_speech.

Primero, la voz se rellena o se trunca de manera que se convierta en una forma de onda de self.default_audio_length segundos de duración y, a continuación, se extrae el espectrograma log-mel de la misma.

ClvpProcessor

clase transformers.ClvpProcessor

< >

( feature_extractortokenizer )

Parámetros

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

Construye un ClvpProcessor que envuelve un extractor de características y un tokenizador en un único procesador.

ClvpProcessor ofrece todas las funcionalidades de ClvpFeatureExtractor y ClvpTokenizer. Consulte ~ClvpFeatureExtractor y ~ClvpTokenizer para obtener más información.

__call__

< >

( *argstext = Noneaudio = None**kwargs )

Parámetros

  • text (`) -- The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings (pretokenized string). If you pass a pretokenized input, set is_split_into_words=True` to avoid ambiguity with batched inputs.
  • audio (“) — El audio o lote de audios que se va a preparar. Cada audio puede ser un array de NumPy o un tensor de PyTorch. En el caso de un array de NumPy/tensor de PyTorch, cada audio debe tener la forma (C, T), donde C es el número de canales y T es la longitud de la muestra del audio.
  • 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.

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.

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.

ClvpModelForConditionalGeneration

clase transformers.ClvpModelForConditionalGeneration

< >

( config: ClvpConfig )

Parámetros

  • config (ClvpConfig) — 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 CLVP compuesto por un codificador de texto, un codificador de voz y un decodificador 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_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.FloatTensor] = Noneconditioning_encoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Nonetext_encoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonereturn_loss: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ClvpOutput or tuple(torch.FloatTensor)

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?

  • input_features (torch.FloatTensor 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 ClvpFeatureExtractor. Consulte ClvpFeatureExtractor.call() para más detalles (ClvpProcessor utiliza ClvpFeatureExtractor para procesar audios).
  • conditioning_encoder_inputs_embeds (torch.FloatTensor, opcional) — inputs_embeds para ClvpConditioningEncoder. Se puede usar en lugar de input_ids.
  • text_encoder_inputs_embeds (torch.FloatTensor, opcional) — inputs_embeds para el modelo de codificador de texto, pasados en lugar de input_ids.
  • 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?

  • return_loss (bool, opcional) — Indica si se debe devolver la pérdida contrastiva.

Devuelve

ClvpOutput o tuple(torch.FloatTensor)

Un ClvpOutput o una tupla de torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (ClvpConfig) y las entradas.

El método forward de ClvpModelForConditionalGeneration sobrescribe 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.FloatTensor de forma (1,), opcional, devuelta cuando return_loss es True) — Pérdida contrastiva para la similitud entre voz y texto.
  • speech_ids (torch.LongTensor, opcional) — speech_ids (o candidatos de speech) generados por el modelo ClvpForCausalLM.
  • logits_per_speech (torch.FloatTensor de forma (speech_batch_size, text_batch_size)) — Las puntuaciones de producto punto escalado entre speech_embeds y text_embeds. Esto representa las puntuaciones de similitud entre el habla y el texto.
  • logits_per_text (torch.FloatTensor de forma (text_batch_size, speech_batch_size)) — Las puntuaciones de producto punto escalado entre text_embeds y speech_embeds. Esto representa las puntuaciones de similitud texto-habla.
  • text_embeds (torch.FloatTensor de forma (batch_size, output_dim) — Las incrustaciones de texto obtenidas al aplicar la capa de proyección a la salida agrupada del codificador de texto del modelo.
  • speech_embeds (torch.FloatTensor de forma (batch_size, output_dim) — Las incrustaciones de voz obtenidas al aplicar la capa de proyección a la salida agrupada del codificador de voz del modelo.
  • text_model_output (~modeling_outputs.BaseModelOutputWithPooling, opcional) — La salida agrupada de last_hidden_state del modelo codificador de texto.
  • speech_model_output (~modeling_outputs.BaseModelOutputWithPooling, opcional) — La salida agrupada de last_hidden_state del modelo codificador de voz.
  • decoder_hidden_states (torch.FloatTensor, opcional) — Los estados ocultos del modelo decodificador.
  • text_encoder_hidden_states (torch.FloatTensor, opcional) — Los estados ocultos del modelo codificador de texto.
  • speech_encoder_hidden_states (torch.FloatTensor, opcional) — Los estados ocultos del modelo de codificador de voz.

Ejemplos:

>>> import datasets
>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration

>>> # Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using `datasets` library)
>>> text = "This is an example text."

>>> ds = datasets.load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", datasets.Audio(sampling_rate=22050))
>>> audio = ds.sort("id")["audio"][0]
>>> audio_sample, sr = audio["array"], audio["sampling_rate"]

>>> # Define processor and model
>>> processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
>>> model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev")

>>> # processor outputs and model outputs
>>> processor_output = processor(raw_speech=audio_sample, sampling_rate=sr, text=text, return_tensors="pt")
>>> outputs = model(
...     input_ids=processor_output["input_ids"],
...     input_features=processor_output["input_features"],
...     return_dict=True,
... )

generate

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.FloatTensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonegeneration_config: transformers.generation.configuration_utils.GenerationConfig | None = Nonepad_to_max_mel_tokens: int | None = Noneoutput_hidden_states: bool | None = None**kwargs ) → ClvpOutput or tuple

Parámetros

  • input_ids (torch.FloatTensor de forma (batch_size, sequence_length), opcional) — Tokens de texto de entrada. Procesados desde el ClvpTokenizer.
  • 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?

  • generation_config (~generation.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.
  • pad_to_max_mel_tokens (int, opcional) — Rellena los speech_ids generados hasta el valor especificado. Esto se hace para implementar la misma lógica del repositorio oficial, enlace: https://github.com/neonbjb/tortoise-tts/blob/80f89987a5abda5e2b082618cd74f9c7411141dc/tortoise/api.py#L430 y para asegurarse de que los logits sean los mismos. Esto no afecta la calidad de la generación, por lo que no se recomienda su uso, ya que es menos eficiente.
  • output_hidden_states (bool, opcional) — Si se deben devolver o no los estados ocultos de los modelos de decodificador, codificador de texto y codificador de voz.

Devuelve

ClvpOutput o tupla

Un ClvpOutput (si return_dict_in_generate=True o cuando config.return_dict_in_generate=True) o una tupla.

Método de generación para ClvpModelForConditionalGeneration, este método llama al método generate de ClvpForCausalLM y luego utiliza los speech_ids generados para procesar text_embeds y speech_embeds mediante ClvpEncoder.

get_text_features

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonetext_encoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ClvpEncoderOutput or tuple(torch.FloatTensor)

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?

  • text_encoder_inputs_embeds (torch.FloatTensor, opcional) — inputs_embeds para el modelo de codificador de texto, pasados en lugar de input_ids.
  • 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?

Devuelve

ClvpEncoderOutput o tuple(torch.FloatTensor)

Un ClvpEncoderOutput o una tupla de torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (ClvpConfig) y las entradas.

Este método se puede utilizar para extraer text_embeds de un texto. Las incrustaciones de texto se obtienen aplicando la capa de proyección a la salida agrupada del modelo de codificador de texto CLVP.

  • embeddings (torch.FloatTensor de forma (batch_size, output_dim), opcional, devuelto cuando el modelo se inicializa con with_projection=True) — Las embeddings obtenidas al aplicar la capa de proyección a pooler_output.

  • last_hidden_state (torch.FloatTensor de forma (batch_size, sequence_length, hidden_size)) — El estado oculto de la última capa del modelo.

  • pooler_output (torch.FloatTensor de forma (batch_size, hidden_size)) — Salida agrupada del last_hidden_state.

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

Ejemplos:

>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration

>>> # Define the Text
>>> text = "This is an example text."

>>> # Define processor and model
>>> processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
>>> model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev")

>>> # Generate processor output and text embeds
>>> processor_output = processor(text=text, return_tensors="pt")
>>> text_embeds = model.get_text_features(input_ids=processor_output["input_ids"])

get_speech_features

< >

( speech_ids: typing.Optional[torch.LongTensor] = Noneinput_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.FloatTensor] = Noneconditioning_encoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonegeneration_config: transformers.generation.configuration_utils.GenerationConfig | None = None**kwargs ) → torch.FloatTensor of shape (batch_size, output_dim)

Parámetros

  • speech_ids (torch.LongTensor de forma (batch_size, num_speech_ids), opcional) — Tokens de voz. El relleno se ignorará de forma predeterminada si se proporciona. Si se proporcionan speech_ids, input_ids e input_features se ignorarán automáticamente.
  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Tokens de texto de entrada. Procesados desde el ClvpTokenizer. Si no se proporciona speech_ids, se utilizarán input_ids y input_features.
  • conditioning_encoder_inputs_embeds (torch.FloatTensor, opcional) — inputs_embeds para ClvpConditioningEncoder. Se puede usar en lugar de input_ids.
  • 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 del audio. 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?

  • generation_config (GenerationConfig, opcional) — configuración de generación para controlar la generación de speech_ids si no se proporcionan.

Devuelve

torch.FloatTensor de forma (batch_size, output_dim)

Las incrustaciones de voz obtenidas al aplicar la capa de proyección a la salida agrupada del Modelo de Voz CLVP.

Este método se puede utilizar para extraer speech_embeds. Los embeddings de voz se obtienen aplicando el modelo de voz sobre speech_ids. Si speech_ids no está presente pero se proporcionan tanto input_ids como input_features, el modelo decodificador se utilizará primero para generar los speech_ids y luego se aplicará el modelo de voz.

Ejemplos:

>>> import datasets
>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration

>>> # Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using `datasets` library)
>>> text = "This is an example text."
>>> ds = datasets.load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", datasets.Audio(sampling_rate=22050))
>>> audio = ds.sort("id")["audio"][0]
>>> audio_sample, sr = audio["array"], audio["sampling_rate"]

>>> # Define processor and model
>>> processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
>>> model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev")

>>> # Generate processor output and model output
>>> processor_output = processor(raw_speech=audio_sample, sampling_rate=sr, text=text, return_tensors="pt")
>>> speech_embeds = model.get_speech_features(
...     input_ids=processor_output["input_ids"], input_features=processor_output["input_features"]
... )

ClvpForCausalLM

clase transformers.ClvpForCausalLM

< >

( config: ClvpDecoderConfig )

Parámetros

  • config (ClvpDecoderConfig) — 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 decodificador CLVP con una cabeza de modelado de lenguaje 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_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

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?

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

  • attention_mask (torch.FloatTensor 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?

  • token_type_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en [0, 1]:
    • 0 corresponde a un token de sentence A,
    • 1 corresponde a un token de sentence B.

    ¿Qué son los IDs de tipo de token?

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

    ¿Qué son los IDs de posición?

  • inputs_embeds (torch.FloatTensor 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 el modelado de lenguaje. Tenga en cuenta que las etiquetas se desplazan dentro del modelo, es decir, puede establecer labels = input_ids Los índices se seleccionan en [-100, 0, ..., config.vocab_size] Todas las etiquetas establecidas en -100 se ignoran (se enmascaran), la pérdida solo se calcula para las 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.FloatTensor)

Un CausalLMOutputWithCrossAttentions o una tupla de torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (ClvpConfig) y las entradas.

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

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

ClvpModel

clase transformers.ClvpModel

< >

( config: ClvpDecoderConfig )

Parámetros

  • config (ClvpDecoderConfig) — 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 Clvp básico que emite 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

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPastAndCrossAttentions or tuple(torch.FloatTensor)

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

  • token_type_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en [0, 1]:
    • 0 corresponde a un token de sentence A,
    • 1 corresponde a un token de sentence B.

    ¿Qué son los IDs de tipo de token?

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

    ¿Qué son los IDs de posición?

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

BaseModelOutputWithPastAndCrossAttentions o tuple(torch.FloatTensor)

Un BaseModelOutputWithPastAndCrossAttentions o una tupla de torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (ClvpConfig) y las entradas.

El método forward de ClvpModel sobrescribe 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.FloatTensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa 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 (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 autoatención y, opcionalmente, si config.is_encoder_decoder=True, en los bloques de atención cruzada) que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.

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

ClvpEncoder

clase transformers.ClvpEncoder

< >

( config: ClvpEncoderConfig )

Parámetros

  • config — ClvpConfig

Codificador Transformer que consiste en config.num_hidden_layers capas de autoatención. Cada capa es una ClvpEncoderLayer.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ClvpEncoderOutput or tuple(torch.FloatTensor)

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?

  • inputs_embeds (torch.LongTensor 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.
  • 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?

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

    ¿Qué son los IDs de posición?

Devuelve

ClvpEncoderOutput o tuple(torch.FloatTensor)

Un ClvpEncoderOutput o una tupla de torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (ClvpConfig) y las entradas.

El método forward de ClvpEncoder sobrescribe 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.

  • embeddings (torch.FloatTensor de forma (batch_size, output_dim), opcional, devuelto cuando el modelo se inicializa con with_projection=True) — Las embeddings obtenidas al aplicar la capa de proyección a pooler_output.

  • last_hidden_state (torch.FloatTensor de forma (batch_size, sequence_length, hidden_size)) — El estado oculto de la última capa del modelo.

  • pooler_output (torch.FloatTensor de forma (batch_size, hidden_size)) — Salida agrupada del last_hidden_state.

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

ClvpDecoder

clase transformers.ClvpDecoder

< >

( config: ClvpDecoderConfig )

Decodificador Transformer que consiste en config.num_hidden_layers capas. Cada capa es una ClvpDecoderLayer

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPastAndCrossAttentions or tuple(torch.FloatTensor)

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

  • token_type_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en [0, 1]:
    • 0 corresponde a un token de sentence A,
    • 1 corresponde a un token de sentence B.

    ¿Qué son los IDs de tipo de token?

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

    ¿Qué son los IDs de posición?

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

BaseModelOutputWithPastAndCrossAttentions o tuple(torch.FloatTensor)

Un BaseModelOutputWithPastAndCrossAttentions o una tupla de torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (ClvpConfig) y las entradas.

El método forward de ClvpDecoder sobrescribe 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.FloatTensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa 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 (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 autoatención y, opcionalmente, si config.is_encoder_decoder=True, en los bloques de atención cruzada) que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.

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

Update on GitHub

←CLIPSeg Modelo de mundo de código (CWM)→