# CLVP ## Visão geral O modelo CLVP (Contrastive Language-Voice Pretrained Transformer) foi proposto em [Better speech synthesis through scaling](https://huggingface.co/papers/2305.07243) por James Betker. O resumo do artigo é o seguinte: *Nos últimos anos, o campo de geração de imagens foi revolucionado pela aplicação de transformers autoregressivos e DDPMs. Essas abordagens modelam o processo de geração de imagens como um processo probabilístico em etapas e aproveitam grandes quantidades de computação e dados para aprender a distribuição das imagens. Essa metodologia de melhoria de desempenho não precisa ser limitada a imagens. Este artigo descreve uma forma de aplicar os avanços no domínio de geração de imagens à síntese de fala. O resultado é o TorToise — um sistema expressivo de texto para fala com múltiplas vozes.* Este modelo foi contribuído por [Susnato Dhar](https://huggingface.co/susnato). O código original pode ser encontrado [aqui](https://github.com/neonbjb/tortoise-tts). ## Dicas de uso 1. O CLVP é uma parte integrante do modelo Tortoise TTS. 2. O CLVP pode ser usado para comparar diferentes candidatos de fala gerados com o texto fornecido, e os melhores tokens de fala são encaminhados para o modelo de difusão. 3. O uso do método `ClvpModelForConditionalGeneration.generate()` é fortemente recomendado para o uso do tortoise. 4. Observe que o modelo CLVP espera que o áudio seja amostrado a 22,05 kHz, ao contrário de outros modelos de áudio, que esperam 16 kHz. ## Explicação breve - O [ClvpTokenizer](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpTokenizer) realiza a tokenização do texto de entrada, e o [ClvpFeatureExtractor](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpFeatureExtractor) extrai o log mel-espectrograma do áudio desejado. - `ClvpConditioningEncoder` recebe esses tokens de texto e representações de áudio e os converte em embeddings condicionados ao texto e ao áudio. - O [ClvpForCausalLM](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpForCausalLM) usa esses embeddings para gerar múltiplos candidatos de fala. - Cada candidato de fala é processado pelo codificador de fala ([ClvpEncoder](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpEncoder)), que os converte em uma representação vetorial, e o codificador de texto ([ClvpEncoder](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpEncoder)) converte os tokens de texto no mesmo espaço latente. - No final, comparamos cada vetor de fala com o vetor de texto para ver qual vetor de fala é mais semelhante ao vetor de texto. - `ClvpModelForConditionalGeneration.generate()` compacta toda a lógica descrita acima em um único método. Exemplo: ```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) ``` [Origem](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*) : O objeto de configuração ou dicionário do backbone de texto. speech_config (`dict`, *opcional*) : Dicionário de opções de configuração usadas para inicializar o codificador de fala CLVP. decoder_config (`dict`, *opcional*) : Dicionário de opções de configuração usadas para inicializar [ClvpDecoderConfig](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpDecoderConfig). projection_dim (`int`, *opcional*, padrão `768`) : Dimensionalidade das camadas de projeção de texto e visão. logit_scale_init_value (`float`, *opcional*, padrão `2.6592`) : O valor inicial do parâmetro *logit_scale*. initializer_factor (`float`, *opcional*, padrão `1.0`) : Um fator para inicializar todas as matrizes de pesos (deve ser mantido em 1, usado internamente para testes de inicialização). Esta é a classe de configuração para armazenar a configuração de um ClvpModelForConditionalGeneration. Ela é usada para instanciar um modelo Clvp de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [susnato/clvp_dev](https://huggingface.co/susnato/clvp_dev) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplo: ```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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/configuration_clvp.py#L29) **Parâmetros:** vocab_size (`int`, *opcional*, padrão `256`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`. hidden_size (`int`, *opcional*, padrão `768`) : Dimensão das representações ocultas. intermediate_size (`int`, *opcional*, padrão `1536`) : Dimensão das representações do MLP. projection_dim (`int`, *opcional*, padrão `768`) : Dimensionalidade das camadas de projeção de texto e visão. num_hidden_layers (`int`, *opcional*, padrão `20`) : Número de camadas ocultas no decodificador do Transformer. num_attention_heads (`int`, *opcional*, padrão `12`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. layer_norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização de camada. attention_dropout (`Union[float, int]`, *opcional*, padrão `0.1`) : A taxa de dropout para as probabilidades de atenção. dropout (`Union[float, int]`, *opcional*, padrão `0.1`) : A proporção para todas as camadas de dropout. use_rotary_embedding (`bool`, *opcional*, padrão `True`) : Se deve usar rotary_embedding ou não. use_attention_bias (`bool`, *opcional*, padrão `False`) : Se deve usar viés nas camadas de Query, Key e Value durante a autoatenção. summary_type (`str`, *opcional*, padrão `"mean"`) : Estratégia a ser usada para obter o pooler_output a partir do last_hidden_state. `"last"`, `"first"`, `"mean"` e `"cls_index"` são suportados. initializer_factor (`float`, *opcional*, padrão `1.0`) : Um fator para inicializar todas as matrizes de pesos (deve ser mantido em 1, usado internamente para testes de inicialização). bos_token_id (`int`, *opcional*, padrão `255`) : ID do token usado para o início do fluxo no vocabulário. eos_token_id (`Union[int, list[int]]`, *opcional*, padrão `0`) : ID do token usado para o fim do fluxo no vocabulário. pad_token_id (`int`, *opcional*) : ID do token usado para preenchimento (padding) no vocabulário. Esta é a classe de configuração para armazenar a configuração de um ClvpModelForConditionalGeneration. Ela é usada para instanciar um modelo Clvp de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [susnato/clvp_dev](https://huggingface.co/susnato/clvp_dev) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplo: ```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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/configuration_clvp.py#L103) **Parâmetros:** vocab_size (`int`, *opcional*, padrão `8194`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`. max_position_embeddings (`int`, *opcional*, padrão `608`) : O comprimento máximo de sequência com o qual este modelo pode ser usado. max_text_tokens (`int`, *opcional*, padrão 404) : O comprimento máximo da sequência de tokens de texto com o qual este modelo pode ser usado. Similar a `n_positions` em `GPT2Config`. hidden_size (`int`, *opcional*, padrão `1024`) : Dimensão das representações ocultas. num_hidden_layers (`int`, *opcional*, padrão `30`) : Número de camadas ocultas no decodificador do Transformer. num_attention_heads (`int`, *opcional*, padrão `16`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. n_inner (`int`, *opcional*) : Dimensionalidade das camadas feed-forward internas. `None` definirá como 4 vezes `hidden_size`. num_mel_attn_blocks (`int`, *opcional*, padrão 6) : Indica o número de camadas de autoatenção em `ClvpConditioningEncoder`. activation_function (`str`, *opcional*, padrão `gelu_new`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. resid_pdrop (`Union[float, int]`, *opcional*, padrão `0.1`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, encoder e pooler. embd_pdrop (`Union[float, int]`, *opcional*, padrão `0.1`) : A taxa de dropout para os embeddings. attention_dropout (`Union[float, int]`, *opcional*, padrão `0.1`) : A taxa de dropout para as probabilidades de atenção. layer_norm_epsilon (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização de camada. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. summary_type (`string`, *opcional*, padrão `"cls_index"`) : Argumento usado ao realizar o resumo de sequência. Deve ser uma das seguintes opções: - `"last"`: Adota o estado oculto do último token (como no XLNet). - `"first"`: Adota o estado oculto do primeiro token (como no BERT). - `"mean"`: Adota a média dos estados ocultos de todos os tokens. - `"cls_index"`: Fornece um Tensor com a posição do token de classificação (como no GPT/GPT-2). - `"attn"`: Não implementado no momento, usa atenção multi-cabeça. summary_use_proj (`bool`, *opcional*, padrão `True`) : Indica se deve ou não adicionar uma projeção após a extração do vetor. summary_activation (`str`, *opcional*) : Passe `"tanh"` para aplicar uma ativação tanh à saída; qualquer outro valor resultará em nenhuma ativação. summary_proj_to_labels (`bool`, *opcional*, padrão `True`) : Se as saídas da projeção devem ter `config.num_labels` ou `config.hidden_size` classes. summary_first_dropout (`float`, *opcional*, padrão 0.1) : A taxa de dropout a ser utilizada após a projeção e a ativação. use_cache (`bool`, *opcional*, padrão `True`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de decodificador. bos_token_id (`int`, *opcional*, padrão `8192`) : ID do token usado para o início do fluxo no vocabulário. eos_token_id (`Union[int, list[int]]`, *opcional*, padrão `8193`) : ID do token usado para o fim do fluxo no vocabulário. pad_token_id (`int`, *opcional*) : ID do token usado para preenchimento (padding) no vocabulário. feature_size (`int`, *opcional*, padrão 80) : A dimensão dos recursos mel extraídos. Esse valor é utilizado em `ClvpConditioningEncoder`. use_attention_bias (`bool`, *opcional*, padrão `True`) : Se deve usar viés nas camadas de Query, Key e Value durante a autoatenção. initializer_factor (`float`, *opcional*, padrão `1.0`) : Um fator para inicializar todas as matrizes de pesos (deve ser mantido em 1, usado internamente para testes de inicialização). decoder_fixing_codes (`list`, *opcional*, padrão `[83, 45, 45, 248]`) : esses valores são usados no método `fix_speech_decoder_output` para corrigir as saídas geradas pelo decodificador. add_cross_attention (`bool`, *opcional*, padrão `False`) : Se as camadas de atenção cruzada devem ser adicionadas ao modelo. Esta é a classe de configuração para armazenar a configuração de um ClvpModelForConditionalGeneration. Ela é usada para instanciar um modelo Clvp de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [susnato/clvp_dev](https://huggingface.co/susnato/clvp_dev) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplo: ```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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/tokenization_clvp.py#L73) **Parâmetros:** vocab_file (`str`) : Caminho para o arquivo de vocabulário. merges_file (`str`) : Caminho para o arquivo de mesclagens. errors (`str`, *opcional*, padrão `"replace"`) : Paradigma a ser seguido ao decodificar bytes para UTF-8. Consulte [bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode) para mais informações. unk_token (`str`, *opcional*, padrão `"[UNK]"`) : O token desconhecido. Um token que não está no vocabulário não pode ser convertido em um ID e é definido como este token em vez disso. bos_token (`str`, *opcional*, padrão `"<|endoftext|>"`) : O token de início de sequência. eos_token (`str`, *opcional*, padrão `"[STOP]"`) : O token de fim de sequência. pad_token (`str`, *opcional*, padrão `"[STOP]"`) : O token de preenchimento da sequência. add_prefix_space (`bool`, *opcional*, padrão `False`) : Indica se deve ou não adicionar um espaço inicial à entrada. Isso permite tratar a palavra inicial como qualquer outra palavra. (O tokenizador CLVP detecta o início das palavras pelo espaço que as precede). Construa um tokenizador CLVP. Baseado em Byte-Pair-Encoding em nível de bytes. Este tokenizer foi treinado para tratar espaços como partes dos tokens (um pouco como o sentencepiece), de modo que uma palavra será ser codificado de forma diferente, dependendo se está no início da frase (sem espaço) ou não: ```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] ``` Você pode contornar esse comportamento passando `add_prefix_space=True` ao instanciar este tokenizer ou ao chamá-lo em algum texto, mas, como o modelo não foi pré-treinado dessa forma, isso pode resultar em uma queda de desempenho. Quando usado com `is_split_into_words=True`, este tokenizer adiciona um espaço antes de cada palavra (inclusive a primeira). Este tokenizer herda de [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend), que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses métodos. #### save_vocabulary[[transformers.ClvpTokenizer.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L1362) **Parâmetros:** save_directory (`str`) : O diretório em que salvar o vocabulário. filename_prefix (`str`, *opcional*) : Um prefixo opcional para adicionar ao nome dos arquivos salvos. **Retorna:** `tuple[str, ...]` Caminhos para os arquivos salvos, ou tupla vazia se nenhum arquivo foi salvo. Implementação padrão para padrões comuns de salvamento de vocabulário. Salva self.encoder/self.vocab como JSON, opcionalmente com self.bpe_ranks como mesclagens. Retorna uma tupla vazia se nenhum vocabulário existir. Substitua este método se o seu tokenizer precisar de uma lógica de salvamento personalizada (por exemplo, modelos SentencePiece, múltiplos arquivos de vocabulário ou formatos de arquivo especiais). ## 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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/feature_extraction_clvp.py#L30) **Parâmetros:** feature_size (`int`, *opcional*, padrão 80) : A dimensão dos recursos das características extraídas. sampling_rate (`int`, *opcional*, padrão 22050) : A taxa de amostragem na qual os arquivos de áudio devem ser digitalizados, expressa em hertz (Hz). default_audio_length (`int`, *opcional*, padrão 6) : O comprimento padrão do áudio bruto em segundos. Se `max_length` não for definido durante `__call__`, ele será definido automaticamente como default_audio_length * `self.sampling_rate`. hop_length (`int`, *opcional*, padrão 256) : Comprimento das janelas sobrepostas para a STFT usada para obter os coeficientes de Frequência Mel. chunk_length (`int`, *opcional*, padrão 30) : O número máximo de blocos de `sampling_rate` amostras usados para aparar e preencher sequências de áudio mais longas ou mais curtas. n_fft (`int`, *opcional*, padrão 1024) : Tamanho da transformada de Fourier. padding_value (`float`, *opcional*, padrão 0.0) : Valor de preenchimento usado para preencher o áudio. Deve corresponder a silêncios. mel_norms (`list` de comprimento `feature_size`, *opcional*) : Se `mel_norms` for fornecido, ele será usado para normalizar os espectrogramas log-mel ao longo de cada filtro mel. return_attention_mask (`bool`, *opcional*, padrão `False`) : Indica se a máscara de atenção deve ser retornada. Se mantido o valor padrão, a máscara de atenção será retornada. [O que são máscaras de atenção?](../glossary#attention-mask) Constrói um extrator de recursos CLVP. Este extrator de características herda de [SequenceFeatureExtractor](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), que contém a maioria dos métodos principais. Os usuários devem consultar esta superclasse para obter mais informações sobre esses métodos. Esta classe extrai recursos de espectrograma log-mel a partir de fala bruta usando uma implementação customizada em numpy da `Short Time Fourier Transform`, que deve corresponder ao equivalente `torch.stft` do pytorch. #### __call__[[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) ``` [Origem](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]]`) : A sequência ou lote de sequências a serem preenchidas. Cada sequência pode ser um array numpy, uma lista de valores float, uma lista de arrays numpy ou uma lista de listas de valores float. Deve ser áudio mono canal, não estéreo, ou seja, um único float por timestep. sampling_rate (`int`, *opcional*) : A taxa de amostragem na qual a entrada `raw_speech` foi amostrada. É fortemente recomendável passar `sampling_rate` na chamada de forward para evitar erros silenciosos e permitir o pipeline de reconhecimento automático de fala. truncation (`bool`, *opcional*, padrão `True`) : Ativa a truncagem para cortar sequências de entrada maiores que *max_length* para *max_length*. pad_to_multiple_of (`int`, *opcional*) : Se definido, a sequência será preenchida até um múltiplo do valor fornecido. Isso é especialmente útil para permitir o uso de Tensor Cores em hardware NVIDIA com capacidade de computação `>= 7.5` (Volta) ou em TPUs, que se beneficiam de ter comprimentos de sequência que sejam múltiplos de 128. return_attention_mask (`bool`, *opcional*, padrão `True`) : Se deve retornar a máscara de atenção. Se mantido o padrão, a máscara de atenção será retornada. [O que são máscaras de atenção?](../glossary#attention-mask) return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores em vez de lista de inteiros do Python. Os valores aceitos são: - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do Numpy. padding_value (`float`, *opcional*, padrão 0.0) : O valor usado para preencher os valores/vetores de preenchimento. max_length (`int`, *opcional*) : O comprimento máximo de entrada dos inputs. `ClvpFeatureExtractor` é usado para extrair diversas propriedades específicas da voz, como o tom e a entonação, a velocidade da fala e até mesmo defeitos de fala, como gagueira ou chiado, a partir de uma amostra de voz ou `raw_speech`. Primeiro, a voz é preenchida ou truncada de modo a se tornar uma forma de onda com `self.default_audio_length` segundos de duração, e em seguida o espectrograma log-mel é extraído a partir dela. ## ClvpProcessor[[transformers.ClvpProcessor]] #### transformers.ClvpProcessor[[transformers.ClvpProcessor]] ```python transformers.ClvpProcessor(feature_extractor, tokenizer) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/processing_clvp.py#L27) **Parâmetros:** feature_extractor (`ClvpFeatureExtractor`) : O extrator de recursos é uma entrada obrigatória. tokenizer (`ClvpTokenizer`) : O tokenizer é uma entrada obrigatória. Constrói um ClvpProcessor que encapsula um extrator de recursos e um tokenizador em um único processador. [ClvpProcessor](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpProcessor) oferece todas as funcionalidades de [ClvpFeatureExtractor](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpFeatureExtractor) e [ClvpTokenizer](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpTokenizer). Consulte [~ClvpFeatureExtractor](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpFeatureExtractor) e [~ClvpTokenizer](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpTokenizer) para mais informações. #### __call__[[transformers.ClvpProcessor.__call__]] ```python __call__(*args, text = None, audio = None, **kwargs) ``` [Origem](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 (``) : O áudio ou lote de áudios a ser preparado. Cada áudio pode ser um array NumPy ou um tensor PyTorch. No caso de um array NumPy/tensor PyTorch, cada áudio deve ter a forma (C, T), onde C é o número de canais e T é o comprimento de amostras do áudio. return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores de um framework específico. Os valores aceitos são: - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do NumPy. #### decode[[transformers.ClvpProcessor.decode]] ```python decode(*args, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2014) Este método encaminha todos os seus argumentos para o [decode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) do PreTrainedTokenizer. Consulte a docstring deste método para obter mais informações. #### batch_decode[[transformers.ClvpProcessor.batch_decode]] ```python batch_decode(*args, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2005) Este método encaminha todos os seus argumentos para o [batch_decode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) do PreTrainedTokenizer. Consulte a docstring deste método para obter mais informações. ## ClvpModelForConditionalGeneration[[transformers.ClvpModelForConditionalGeneration]] #### transformers.ClvpModelForConditionalGeneration[[transformers.ClvpModelForConditionalGeneration]] ```python transformers.ClvpModelForConditionalGeneration(config: ClvpConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1247) **Parâmetros:** config ([ClvpConfig](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. O modelo CLVP composto por um codificador de texto, um codificador de fala e um decodificador de fala. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### 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: *) ``` [Origem](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 dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando [ClvpFeatureExtractor](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpFeatureExtractor). Veja [ClvpFeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpFeatureExtractor.__call__) para mais detalhes ([ClvpProcessor](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpProcessor) usa [ClvpFeatureExtractor](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpFeatureExtractor) para processar áudios). conditioning_encoder_inputs_embeds (`torch.Tensor`, *opcional*) : inputs_embeds para `ClvpConditioningEncoder`. Pode ser usado no lugar de `input_ids`. text_encoder_inputs_embeds (`torch.Tensor`, *opcional*) : inputs_embeds para o modelo de codificador de texto, passado no lugar de `input_ids`. attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) return_loss (`bool`, *opcional*) : Se deve ou não retornar a perda contrastiva. **Retorna:** `ClvpOutput` ou `tuple(torch.Tensor)` Um `ClvpOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`), composto por diversos elementos, dependendo da configuração ([ClvpConfig](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpConfig)) e das entradas. O método forward do [ClvpModelForConditionalGeneration](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpModelForConditionalGeneration) sobrescreve o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornada quando `return_loss` é `True`) -- Perda contrastiva para similaridade entre fala e texto. - **speech_ids** (`torch.LongTensor`, *opcional*) -- speech_ids (ou candidatos de fala) gerados pelo modelo `ClvpForCausalLM`. - **logits_per_speech** (`torch.Tensor` de forma `(speech_batch_size, text_batch_size)`) -- As pontuações de produto escalar escalonado entre `speech_embeds` e `text_embeds`. Isso representa as pontuações de similaridade entre fala e texto. - **logits_per_text** (`torch.Tensor` de forma `(text_batch_size, speech_batch_size)`) -- As pontuações de produto escalar escalonado entre `text_embeds` e `speech_embeds`. Isso representa as pontuações de similaridade entre texto e fala. - **text_embeds** (`torch.Tensor` de forma `(batch_size, output_dim`) -- Os embeddings de texto obtidos ao aplicar a camada de projeção à saída agregada do modelo de codificador de texto. - **speech_embeds** (`torch.Tensor` de forma `(batch_size, output_dim`) -- Os embeddings de fala obtidos ao aplicar a camada de projeção à saída agregada do modelo de codificador de fala. - **text_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`, *opcional*) -- A saída agregada do `last_hidden_state` do modelo codificador de texto. - **speech_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`, *opcional*) -- A saída agregada do `last_hidden_state` do modelo de codificador de fala. - **decoder_hidden_states** (`torch.Tensor`, *opcional*) -- Os estados ocultos do modelo decodificador. - **text_encoder_hidden_states** (`torch.Tensor`, *opcional*) -- Os estados ocultos do modelo de codificador de texto. - **speech_encoder_hidden_states** (`torch.Tensor`, *opcional*) -- Os estados ocultos do modelo de codificador de fala. Exemplos: ```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) ``` [Origem](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. Processados a partir do [ClvpTokenizer](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpTokenizer). attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de texto de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) generation_config (`~generation.GenerationConfig`, *opcional*) : A configuração de geração a ser usada como parametrização base para a chamada de geração. Os `**kwargs` passados para generate que correspondam aos atributos de `generation_config` os sobrescreverão. Se `generation_config` não for fornecido, o padrão será usado, que tem a seguinte prioridade de carregamento: 1) do arquivo de modelo `generation_config.json`, se existir; 2) da configuração do modelo. Observe que os parâmetros não especificados herdarão os valores padrão de [GenerationConfig](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationConfig), cuja documentação deve ser consultada para parametrizar a geração. pad_to_max_mel_tokens (`int`, *opcional*) : Preenche os speech_ids gerados até o valor especificado. Isso é para implementar a mesma lógica do repositório oficial, link: https://github.com/neonbjb/tortoise-tts/blob/80f89987a5abda5e2b082618cd74f9c7411141dc/tortoise/api.py#L430 e para garantir que os logits sejam os mesmos. Isso não afeta a qualidade da geração, portanto, não considere usá-lo, pois é menos eficiente. output_hidden_states (`bool`, *opcional*) : Se deve ou não retornar os estados ocultos dos modelos de decodificador, codificador de texto e codificador de fala. **Retorna:** `ClvpOutput` ou tupla Um `ClvpOutput` (se `return_dict_in_generate=True` ou quando `config.return_dict_in_generate=True`) ou uma tupla. Método de geração para `ClvpModelForConditionalGeneration`, este método chama o método `generate` de `ClvpForCausalLM` e, em seguida, usa os `speech_ids` gerados para processar `text_embeds` e `speech_embeds` usando `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: *) ``` [Origem](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 dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) text_encoder_inputs_embeds (`torch.Tensor`, *opcional*) : inputs_embeds para o modelo de codificador de texto, passado no lugar de `input_ids`. attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) **Retorna:** `ClvpEncoderOutput` ou `tuple(torch.Tensor)` Um `ClvpEncoderOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`), composto por diversos elementos, dependendo da configuração ([ClvpConfig](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpConfig)) e das entradas. Esse método pode ser usado para extrair text_embeds de um texto. Os embeddings de texto são obtidos aplicando a camada de projeção à saída agregada do modelo de codificador de texto CLVP. - **embeds** (`torch.Tensor` de forma `(batch_size, output_dim)`, *opcional*, retornado quando o modelo é inicializado com `with_projection=True`) -- Os embeddings obtidos ao aplicar a camada de projeção ao pooler_output. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- O estado oculto da última camada do modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Saída agregada do `last_hidden_state`. - **hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Exemplos: ```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) ``` [Origem](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 fala. O preenchimento (padding) será ignorado por padrão, caso você o forneça. Se speech_ids forem fornecidos, input_ids e input_features serão automaticamente ignorados. input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Tokens de texto de entrada. Processados a partir do [ClvpTokenizer](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpTokenizer). Se speech_ids não for fornecido, input_ids e input_features serão utilizados. conditioning_encoder_inputs_embeds (`torch.Tensor`, *opcional*) : inputs_embeds para `ClvpConditioningEncoder`. Pode ser usado no lugar de `input_ids`. attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de fala de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) generation_config (`GenerationConfig`, *opcional*) : configuração de geração para controlar a geração de speech_ids, caso não sejam fornecidos. **Retorna:** `torch.Tensor` de forma `(batch_size, output_dim)` Os embeddings de fala obtidos ao aplicar a camada de projeção à saída agregada do CLVP Speech Model. Este método pode ser usado para extrair speech_embeds. Os embeddings de fala são obtidos aplicando o modelo de fala em speech_ids. Se speech_ids não estiver presente, mas tanto input_ids quanto input_features forem fornecidos, o modelo decodificador será usado primeiro para gerar os speech_ids e, em seguida, o modelo de fala será aplicado. Exemplos: ```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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1069) **Parâmetros:** config ([ClvpDecoderConfig](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpDecoderConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. O modelo decodificador CLVP com uma cabeça de modelagem de linguagem no topo. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### 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: *) ``` [Origem](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 dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas porções das entradas. Os índices são selecionados em `[0, 1]`: - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*. [O que são IDs de tipo de token?](../glossary#token-type-ids) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para modelagem de linguagem. Observe que os rótulos **são deslocados** dentro do modelo, ou seja, você pode definir `labels = input_ids` Os índices são selecionados em `[-100, 0, ..., config.vocab_size]` Todos os rótulos definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para rótulos em `[0, ..., config.vocab_size]` use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). **Retorna:** [CausalLMOutputWithCrossAttentions](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) ou `tuple(torch.Tensor)` Um [CausalLMOutputWithCrossAttentions](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`), composto por diversos elementos, dependendo da configuração ([ClvpConfig](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpConfig)) e das entradas. O método forward da [ClvpForCausalLM](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpForCausalLM) substitui o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem (para previsão do próximo token). - **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax). - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. - **cross_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos das atenções cruzadas após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada. - **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de atenção) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. ## ClvpModel[[transformers.ClvpModel]] #### transformers.ClvpModel[[transformers.ClvpModel]] ```python transformers.ClvpModel(config: ClvpDecoderConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1013) **Parâmetros:** config ([ClvpDecoderConfig](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpDecoderConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. O modelo Clvp puro, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### 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: *) ``` [Origem](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 dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas porções das entradas. Os índices são selecionados em `[0, 1]`: - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*. [O que são IDs de tipo de token?](../glossary#token-type-ids) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). **Retorna:** [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo diversos elementos, dependendo da configuração ([ClvpConfig](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpConfig)) e das entradas. O método forward do [ClvpModel](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpModel) sobrescreve o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado. - **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se `config.is_encoder_decoder=True`, nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. - **cross_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` e `config.add_cross_attention=True` são passados, ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada. ## ClvpEncoder[[transformers.ClvpEncoder]] #### transformers.ClvpEncoder[[transformers.ClvpEncoder]] ```python transformers.ClvpEncoder(config: ClvpEncoderConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L815) **Parâmetros:** config : ClvpConfig Codificador Transformer composto por `config.num_hidden_layers` camadas de autoatenção. Cada camada é uma `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: *) ``` [Origem](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 dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) inputs_embeds (`torch.LongTensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) **Retorna:** `ClvpEncoderOutput` ou `tuple(torch.Tensor)` Um `ClvpEncoderOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`), composto por diversos elementos, dependendo da configuração ([ClvpConfig](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpConfig)) e das entradas. O método forward do [ClvpEncoder](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpEncoder) sobrescreve o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **embeds** (`torch.Tensor` de forma `(batch_size, output_dim)`, *opcional*, retornado quando o modelo é inicializado com `with_projection=True`) -- Os embeddings obtidos ao aplicar a camada de projeção ao pooler_output. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- O estado oculto da última camada do modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Saída agregada do `last_hidden_state`. - **hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. ## ClvpDecoder[[transformers.ClvpDecoder]] #### transformers.ClvpDecoder[[transformers.ClvpDecoder]] ```python transformers.ClvpDecoder(config: ClvpDecoderConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L905) Decoder de Transformer composto por *config.num_hidden_layers* camadas. Cada camada é uma `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: *) ``` [Origem](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 dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas porções das entradas. Os índices são selecionados em `[0, 1]`: - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*. [O que são IDs de tipo de token?](../glossary#token-type-ids) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). **Retorna:** [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo diversos elementos, dependendo da configuração ([ClvpConfig](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpConfig)) e das entradas. O método forward do [ClvpDecoder](/docs/transformers/main/pt/model_doc/clvp#transformers.ClvpDecoder) sobrescreve o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado. - **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se `config.is_encoder_decoder=True`, nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. - **cross_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` e `config.add_cross_attention=True` são passados, ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada.