# CLVP ## Resumen El modelo CLVP (Contrastive Language-Voice Pretrained Transformer) fue propuesto en [Better speech synthesis through scaling](https://huggingface.co/papers/2305.07243) 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](https://huggingface.co/susnato). El código original se puede encontrar [aquí](https://github.com/neonbjb/tortoise-tts). ## 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](/docs/transformers/main/es/model_doc/clvp#transformers.ClvpTokenizer) tokeniza la entrada de texto y el [ClvpFeatureExtractor](/docs/transformers/main/es/model_doc/clvp#transformers.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](/docs/transformers/main/es/model_doc/clvp#transformers.ClvpForCausalLM) utiliza esas incrustaciones para generar múltiples candidatos de voz. - Cada candidato de voz se pasa por el codificador de voz ([ClvpEncoder](/docs/transformers/main/es/model_doc/clvp#transformers.ClvpEncoder)), que los convierte en una representación vectorial, y el codificador de texto ([ClvpEncoder](/docs/transformers/main/es/model_doc/clvp#transformers.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: ```python 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[[transformers.ClvpConfig]] #### transformers.ClvpConfig[[transformers.ClvpConfig]] ```python transformers.ClvpConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, speech_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, projection_dim: int = 768, logit_scale_init_value: float = 2.6592, initializer_factor: float = 1.0) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/configuration_clvp.py#L185) **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 utilizadas para inicializar [ClvpDecoderConfig](/docs/transformers/main/es/model_doc/clvp#transformers.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](https://huggingface.co/susnato/clvp_dev) Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. Ejemplo: ```python >>> 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[[transformers.ClvpEncoderConfig]] #### transformers.ClvpEncoderConfig[[transformers.ClvpEncoderConfig]] ```python transformers.ClvpEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 256, hidden_size: int = 768, intermediate_size: int = 1536, projection_dim: int = 768, num_hidden_layers: int = 20, num_attention_heads: int = 12, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-05, attention_dropout: float | int = 0.1, dropout: float | int = 0.1, use_rotary_embedding: bool = True, use_attention_bias: bool = False, summary_type: str = 'mean', initializer_factor: float = 1.0, bos_token_id: int | None = 255, eos_token_id: int | list[int] | None = 0, pad_token_id: int | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/configuration_clvp.py#L29) **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 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 capas. 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`) : Indica si se debe usar rotary_embedding o no. use_attention_bias (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe usar sesgo en las capas de Query, Key y Value durante la autoatención. summary_type (`str`, *opcional*, valor predeterminado `"mean"`) : Estrategia a utilizar para obtener pooler_output desde 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`) : Id de token utilizado para el fin de la secuencia en el vocabulario. pad_token_id (`int`, *opcional*) : Id de 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](https://huggingface.co/susnato/clvp_dev) Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. Ejemplo: ```python >>> 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[[transformers.ClvpDecoderConfig]] #### transformers.ClvpDecoderConfig[[transformers.ClvpDecoderConfig]] ```python transformers.ClvpDecoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 8194, max_position_embeddings: int = 608, max_text_tokens: int = 404, hidden_size: int = 1024, num_hidden_layers: int = 30, num_attention_heads: int = 16, n_inner: int | None = None, num_mel_attn_blocks: int = 6, activation_function: str = 'gelu_new', resid_pdrop: float | int = 0.1, embd_pdrop: float | int = 0.1, attention_dropout: float | int = 0.1, layer_norm_epsilon: float = 1e-05, initializer_range: float = 0.02, summary_type: str = 'cls_index', summary_use_proj: bool = True, summary_activation: str | None = None, summary_proj_to_labels: bool = True, summary_first_dropout: float | int = 0.1, use_cache: bool = True, bos_token_id: int | None = 8192, eos_token_id: int | list[int] | None = 8193, pad_token_id: int | None = None, feature_size: int = 80, use_attention_bias: bool = True, initializer_factor: float = 1.0, decoder_fixing_codes: list[int] | tuple[int, ...] = (83, 45, 45, 248), add_cross_attention: bool = False) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/configuration_clvp.py#L103) **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 secuencia de tokens de texto con la que podría utilizarse 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 del 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 totalmente conectadas en los embeddings, el codificador y el pooler. embd_pdrop (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La proporción de dropout para los embeddings. 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 capas. initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos. summary_type (`string`, *opcional*, valor predeterminado `"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 en XLNet). - `"first"`: Toma el estado oculto del primer token (como en BERT). - `"mean"`: Toma la media de los estados ocultos de todos los tokens. - `"cls_index"`: Suministra un Tensor con la posición del token de clasificación (como en GPT/GPT-2). - `"attn"`: No implementado actualmente, usa atención multi-cabeza. summary_use_proj (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe añadir una proyección después de la extracción del vector. summary_activation (`str`, *opcional*) : Pasa `"tanh"` para aplicar una activación tanh a la salida; cualquier otro valor resultará en que no se aplique ninguna activación. summary_proj_to_labels (`bool`, *opcional*, valor predeterminado `True`) : Indica 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 atenciones de claves/valores (no se utiliza en 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 de token utilizado para el inicio de la secuencia en el vocabulario. eos_token_id (`Union[int, list[int]]`, *opcional*, valor predeterminado `8193`) : Id. de token utilizado para el fin de secuencia en el vocabulario. pad_token_id (`int`, *opcional*) : Id de 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 usa 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](https://huggingface.co/susnato/clvp_dev) Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. Ejemplo: ```python >>> 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[[transformers.ClvpTokenizer]] #### transformers.ClvpTokenizer[[transformers.ClvpTokenizer]] ```python transformers.ClvpTokenizer(vocab_file, merges_file, errors = 'replace', unk_token = '[UNK]', bos_token = '<|endoftext|>', eos_token = '[STOP]', pad_token = '[STOP]', add_prefix_space = False, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/tokenization_clvp.py#L73) **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](https://docs.python.org/3/library/stdtypes.html#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 igual que 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: ```python >>> 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 esta 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](/docs/transformers/main/es/main_classes/tokenizer#transformers.PythonBackend), 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[[transformers.ClvpTokenizer.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L1362) **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 ningún 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[[transformers.ClvpFeatureExtractor]] #### transformers.ClvpFeatureExtractor[[transformers.ClvpFeatureExtractor]] ```python transformers.ClvpFeatureExtractor(feature_size = 80, sampling_rate = 22050, default_audio_length = 6, hop_length = 256, chunk_length = 30, n_fft = 1024, padding_value = 0.0, mel_norms = None, return_attention_mask = False, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/feature_extraction_clvp.py#L30) **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 se deben digitalizar 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*, valor predeterminado `False`) : 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. [¿Qué son las máscaras de atención?](../glossary#attention-mask) Construye un extractor de características CLVP. Este extractor de características hereda de [SequenceFeatureExtractor](/docs/transformers/main/es/main_classes/feature_extractor#transformers.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 bruto mediante una implementación personalizada de numpy de la `Short Time Fourier Transform`, que debe coincidir con el equivalente `torch.stft` de pytorch. #### __llamada__[[transformers.ClvpFeatureExtractor.__call__]] ```python __call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], sampling_rate: int | None = None, truncation: bool = True, pad_to_multiple_of: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_attention_mask: bool | None = True, padding: str | None = 'max_length', max_length: int | None = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/feature_extraction_clvp.py#L128) **Parámetros:** raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : La secuencia o el lote de secuencias que se van a rellenar. Cada secuencia puede ser un array de numpy, una lista de valores flotantes, una lista de arrays de numpy o una lista de listas de valores flotantes. Debe ser audio de un solo canal, no estéreo, es decir, un solo valor flotante 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*, valor predeterminado `True`) : 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. [¿Qué son las máscaras de atención?](../glossary#attention-mask) return_tensors (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores en lugar de listas de enteros de Python. Los valores aceptables son: - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de Numpy. 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 dicción 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[[transformers.ClvpProcessor]] #### transformers.ClvpProcessor[[transformers.ClvpProcessor]] ```python transformers.ClvpProcessor(feature_extractor, tokenizer) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/processing_clvp.py#L27) **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](/docs/transformers/main/es/model_doc/clvp#transformers.ClvpProcessor) ofrece todas las funcionalidades de [ClvpFeatureExtractor](/docs/transformers/main/es/model_doc/clvp#transformers.ClvpFeatureExtractor) y [ClvpTokenizer](/docs/transformers/main/es/model_doc/clvp#transformers.ClvpTokenizer). Consulte [~ClvpFeatureExtractor](/docs/transformers/main/es/model_doc/clvp#transformers.ClvpFeatureExtractor) y [~ClvpTokenizer](/docs/transformers/main/es/model_doc/clvp#transformers.ClvpTokenizer) para obtener más información. #### __llamada__[[transformers.ClvpProcessor.__call__]] ```python __call__(*args, text = None, audio = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/processing_clvp.py#L31) **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 muestra del audio. return_tensors (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.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[[transformers.ClvpProcessor.decode]] ```python decode(*args, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L1957) Este método reenvía todos sus argumentos a [decode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) de PreTrainedTokenizer. Consulte la docstring de este método para obtener más información. #### batch_decode[[transformers.ClvpProcessor.batch_decode]] ```python batch_decode(*args, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L1948) Este método reenvía todos sus argumentos a [batch_decode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) de PreTrainedTokenizer. Consulte la docstring de este método para obtener más información. ## ClvpModelForConditionalGeneration[[transformers.ClvpModelForConditionalGeneration]] #### transformers.ClvpModelForConditionalGeneration[[transformers.ClvpModelForConditionalGeneration]] ```python transformers.ClvpModelForConditionalGeneration(config: ClvpConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1247) **Parámetros:** config ([ClvpConfig](/docs/transformers/main/es/model_doc/clvp#transformers.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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.ClvpModelForConditionalGeneration.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, conditioning_encoder_inputs_embeds: typing.Optional[torch.Tensor] = None, text_encoder_inputs_embeds: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, return_loss: bool | None = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1452) **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 mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) 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 [ClvpFeatureExtractor](/docs/transformers/main/es/model_doc/clvp#transformers.ClvpFeatureExtractor). Consulte [ClvpFeatureExtractor.__call__()](/docs/transformers/main/es/model_doc/clvp#transformers.ClvpFeatureExtractor.__call__) para más detalles ([ClvpProcessor](/docs/transformers/main/es/model_doc/clvp#transformers.ClvpProcessor) utiliza [ClvpFeatureExtractor](/docs/transformers/main/es/model_doc/clvp#transformers.ClvpFeatureExtractor) para procesar audios). conditioning_encoder_inputs_embeds (`torch.Tensor`, *opcional*) : inputs_embeds para `ClvpConditioningEncoder`. Se puede usar en lugar de `input_ids`. text_encoder_inputs_embeds (`torch.Tensor`, *opcional*) : inputs_embeds para el modelo codificador de texto, pasado 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 la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) return_loss (`bool`, *opcional*) : Indica si se debe devolver la pérdida contrastiva. **Devuelve:** `ClvpOutput` o `tuple(torch.Tensor)` Un `ClvpOutput` 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 ([ClvpConfig](/docs/transformers/main/es/model_doc/clvp#transformers.ClvpConfig)) y las entradas. El método forward de [ClvpModelForConditionalGeneration](/docs/transformers/main/es/model_doc/clvp#transformers.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 preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto 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.Tensor` 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.Tensor` 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 entre texto y voz. - **text_embeds** (`torch.Tensor` de forma `(batch_size, output_dim`) -- Las incrustaciones de texto obtenidas al aplicar la capa de proyección a la salida agrupada del modelo codificador de texto. - **speech_embeds** (`torch.Tensor` de forma `(batch_size, output_dim`) -- Las incrustaciones de voz obtenidas al aplicar la capa de proyección a la salida agrupada del modelo codificador de voz. - **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.Tensor`, *opcional*) -- Los estados ocultos del modelo decodificador. - **text_encoder_hidden_states** (`torch.Tensor`, *opcional*) -- Los estados ocultos del modelo codificador de texto. - **speech_encoder_hidden_states** (`torch.Tensor`, *opcional*) -- Los estados ocultos del modelo de codificador de voz. Ejemplos: ```python >>> 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[[transformers.ClvpModelForConditionalGeneration.generate]] ```python generate(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, pad_to_max_mel_tokens: int | None = None, output_hidden_states: bool | None = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1561) **Parámetros:** input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Tokens de texto de entrada. Procesados desde [ClvpTokenizer](/docs/transformers/main/es/model_doc/clvp#transformers.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 la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) 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](/docs/transformers/main/es/main_classes/text_generation#transformers.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*) : Indica si se deben devolver 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[[transformers.ClvpModelForConditionalGeneration.get_text_features]] ```python get_text_features(input_ids: typing.Optional[torch.LongTensor] = None, text_encoder_inputs_embeds: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1315) **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 mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) text_encoder_inputs_embeds (`torch.Tensor`, *opcional*) : inputs_embeds para el modelo codificador de texto, pasado 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 la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) **Devuelve:** `ClvpEncoderOutput` o `tuple(torch.Tensor)` Un `ClvpEncoderOutput` 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 ([ClvpConfig](/docs/transformers/main/es/model_doc/clvp#transformers.ClvpConfig)) y las entradas. Este método se puede utilizar para extraer text_embeds a partir 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. - **embeds** (`torch.Tensor` de forma `(batch_size, output_dim)`, *opcional*, se devuelve cuando el modelo se inicializa con `with_projection=True`) -- Las incrustaciones obtenidas al aplicar la capa de proyección a pooler_output. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- El estado oculto de la última capa del modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Salida agrupada de `last_hidden_state`. - **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 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. Ejemplos: ```python >>> 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[[transformers.ClvpModelForConditionalGeneration.get_speech_features]] ```python get_speech_features(speech_ids: typing.Optional[torch.LongTensor] = None, input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, conditioning_encoder_inputs_embeds: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1357) **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 [ClvpTokenizer](/docs/transformers/main/es/model_doc/clvp#transformers.ClvpTokenizer). Si no se proporciona speech_ids, se utilizarán input_ids e input_features. conditioning_encoder_inputs_embeds (`torch.Tensor`, *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 la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) generation_config (`GenerationConfig`, *opcional*) : configuración de generación para controlar la generación de speech_ids si no se proporcionan. **Devuelve:** `torch.Tensor` de forma `(batch_size, output_dim)` Los embeddings de voz obtenidos 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, se utilizará el modelo decodificador para generar primero speech_ids y luego se aplicará el modelo de voz. Ejemplos: ```python >>> 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[[transformers.ClvpForCausalLM]] #### transformers.ClvpForCausalLM[[transformers.ClvpForCausalLM]] ```python transformers.ClvpForCausalLM(config: ClvpDecoderConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1069) **Parámetros:** config ([ClvpDecoderConfig](/docs/transformers/main/es/model_doc/clvp#transformers.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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.ClvpForCausalLM.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1185) **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 mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) 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 utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada. El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada. Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados 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.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) 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 *oración A*, - 1 corresponde a un token de *oración B*. [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids) 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?](../glossary#position-ids) 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 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 valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`). **Devuelve:** [CausalLMOutputWithCrossAttentions](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) o `tuple(torch.Tensor)` Un [CausalLMOutputWithCrossAttentions](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.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 ([ClvpConfig](/docs/transformers/main/es/model_doc/clvp#transformers.ClvpConfig)) y las entradas. El método forward de [ClvpForCausalLM](/docs/transformers/main/es/model_doc/clvp#transformers.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 preprocesamiento y posprocesamiento, 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*, 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 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). 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[[transformers.ClvpModel]] #### transformers.ClvpModel[[transformers.ClvpModel]] ```python transformers.ClvpModel(config: ClvpDecoderConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1013) **Parámetros:** config ([ClvpDecoderConfig](/docs/transformers/main/es/model_doc/clvp#transformers.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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.ClvpModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1030) **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 mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) 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 la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) 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 *oración A*, - 1 corresponde a un token de *oración B*. [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids) 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?](../glossary#position-ids) 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 utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada. El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada. Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados 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. use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`). **Devuelve:** [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) o `tuple(torch.Tensor)` Un [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) 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 ([ClvpConfig](/docs/transformers/main/es/model_doc/clvp#transformers.ClvpConfig)) y las entradas. El método forward de [ClvpModel](/docs/transformers/main/es/model_doc/clvp#transformers.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 preprocesamiento y posprocesamiento, 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 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). 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.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 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` y `config.add_cross_attention=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. ## ClvpEncoder[[transformers.ClvpEncoder]] #### transformers.ClvpEncoder[[transformers.ClvpEncoder]] ```python transformers.ClvpEncoder(config: ClvpEncoderConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L815) **Parámetros:** config : ClvpConfig Codificador Transformer que consiste en `config.num_hidden_layers` capas de autoatención. Cada capa es una `ClvpEncoderLayer`. #### forward[[transformers.ClvpEncoder.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L849) **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 mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) 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 la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) 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?](../glossary#position-ids) **Devuelve:** `ClvpEncoderOutput` o `tuple(torch.Tensor)` Un `ClvpEncoderOutput` 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 ([ClvpConfig](/docs/transformers/main/es/model_doc/clvp#transformers.ClvpConfig)) y las entradas. El método forward de [ClvpEncoder](/docs/transformers/main/es/model_doc/clvp#transformers.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 preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente. - **embeds** (`torch.Tensor` de forma `(batch_size, output_dim)`, *opcional*, se devuelve cuando el modelo se inicializa con `with_projection=True`) -- Las incrustaciones obtenidas al aplicar la capa de proyección a pooler_output. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- El estado oculto de la última capa del modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Salida agrupada de `last_hidden_state`. - **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 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. ## ClvpDecoder[[transformers.ClvpDecoder]] #### transformers.ClvpDecoder[[transformers.ClvpDecoder]] ```python transformers.ClvpDecoder(config: ClvpDecoderConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L905) Decodificador Transformer que consiste en *config.num_hidden_layers* capas. Cada capa es una `ClvpDecoderLayer` #### forward[[transformers.ClvpDecoder.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L937) **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 mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) 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 la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) 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 *oración A*, - 1 corresponde a un token de *oración B*. [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids) 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?](../glossary#position-ids) 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 utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada. El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada. Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados 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. use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`). **Devuelve:** [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) o `tuple(torch.Tensor)` Un [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) 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 ([ClvpConfig](/docs/transformers/main/es/model_doc/clvp#transformers.ClvpConfig)) y las entradas. El método forward de [ClvpDecoder](/docs/transformers/main/es/model_doc/clvp#transformers.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 preprocesamiento y posprocesamiento, 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 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). 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.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 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` y `config.add_cross_attention=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.