# ProphetNet ## Visão geral O modelo ProphetNet foi proposto em [ProphetNet: Predicting Future N-gram for Sequence-to-Sequence Pre-training,](https://huggingface.co/papers/2001.04063) por Yu Yan, Weizhen Qi, Yeyun Gong, Dayiheng Liu, Nan Duan, Jiusheng Chen, Ruofei Zhang, Ming Zhou em 13 de janeiro de 2020. ProphetNet é um modelo encoder-decoder e pode prever n tokens futuros para modelagem de linguagem "ngram" em vez de apenas o próximo token. O resumo do artigo é o seguinte: *Neste artigo, apresentamos um novo modelo de pré-treino de sequência-para-sequência chamado ProphetNet, que introduz um objetivo auto-supervisionado inédito chamado previsão de n-gramas futuros e o mecanismo de autoatenção de n fluxos proposto. Em vez da otimização da previsão de um passo à frente em modelos tradicionais de sequência-para-sequência, o ProphetNet é otimizado pela previsão de n passos à frente, que prevê simultaneamente os próximos n tokens com base nos tokens de contexto anteriores em cada passo de tempo. A previsão de n-gramas futuros incentiva explicitamente o modelo a planejar para os tokens futuros e a evitar o sobreajuste em correlações locais fortes. Pré-treinamos o ProphetNet usando um conjunto de dados em escala base (16GB) e um conjunto de dados em escala grande (160GB), respectivamente. Em seguida, conduzimos experimentos nos benchmarks CNN/DailyMail, Gigaword e SQuAD 1.1 para as tarefas de sumarização abstrativa e geração de perguntas. Os resultados experimentais mostram que o ProphetNet alcança novos resultados de estado da arte em todos esses conjuntos de dados em comparação com os modelos que usam o mesmo corpus de pré-treino em escala.* O código dos autores pode ser encontrado [aqui](https://github.com/microsoft/ProphetNet). ## Dicas de uso - O ProphetNet é um modelo com embeddings de posição absoluta, portanto, geralmente é recomendado preencher os inputs à direita em vez da esquerda. - A arquitetura do modelo é baseada no Transformer original, mas substitui o mecanismo de autoatenção “padrão” no decodificador por um mecanismo principal de autoatenção e um mecanismo de autoatenção de auto e n-stream (previsão). ## Recursos - [Guia da tarefa de modelagem de linguagem causal](../tasks/language_modeling) - [Guia de tarefa de tradução](../tasks/translation) - [Guia da tarefa de sumarização](../tasks/summarization) ## ProphetNetConfig[[transformers.ProphetNetConfig]] #### transformers.ProphetNetConfig[[transformers.ProphetNetConfig]] ```python transformers.ProphetNetConfig(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, 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, is_encoder_decoder: bool = True, activation_dropout: float | int = 0.1, activation_function: str = 'gelu', vocab_size: int = 30522, hidden_size: int = 1024, encoder_ffn_dim: int = 4096, num_encoder_layers: int = 12, num_encoder_attention_heads: int = 16, decoder_ffn_dim: int = 4096, num_decoder_layers: int = 12, num_decoder_attention_heads: int = 16, attention_dropout: float | int = 0.1, dropout: float | int = 0.1, max_position_embeddings: int = 512, init_std: float = 0.02, add_cross_attention: bool = True, decoder_start_token_id: int | None = 0, ngram: int = 2, num_buckets: int = 32, relative_max_distance: int = 128, disable_ngram_loss: bool = False, eps: float = 0.0, use_cache: bool = True, pad_token_id: int | None = 0, bos_token_id: int | None = 1, eos_token_id: int | list[int] | None = 2, is_decoder: bool = False, tie_word_embeddings: bool = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/configuration_prophetnet.py#L24) **Parâmetros:** is_encoder_decoder (`bool`, *opcional*, padrão `True`) : Indica se o modelo é usado como codificador/decodificador ou não. activation_dropout (`Union[float, int]`, *opcional*, padrão `0.1`) : A taxa de dropout para as ativações dentro da camada totalmente conectada. activation_function (`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. vocab_size (`int`, *opcional*, padrão `30522`) : 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 `1024`) : Dimensão das representações ocultas. encoder_ffn_dim (`int`, *opcional*, padrão `4096`) : Dimensionalidade da camada "intermediária" (frequentemente chamada de feed-forward) no codificador. num_encoder_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no codificador do Transformer. Usará o mesmo valor de `num_layers` se não for definido. num_encoder_attention_heads (`int`, *opcional*, padrão `16`) : Número de cabeças de atenção para cada camada de atenção no codificador do Transformer. decoder_ffn_dim (`int`, *opcional*, padrão `4096`) : Dimensionalidade da camada "intermediária" (frequentemente chamada de feed-forward) no decodificador. num_decoder_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no decodificador do Transformer. Usará o mesmo valor de `num_layers` se não for definido. num_decoder_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. 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. max_position_embeddings (`int`, *opcional*, padrão `512`) : O comprimento máximo de sequência com o qual este modelo pode ser utilizado. init_std (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. add_cross_attention (`bool`, *opcional*, padrão `True`) : Se as camadas de atenção cruzada devem ser adicionadas ao modelo. decoder_start_token_id (`int`, *opcional*, padrão `0`) : Se um modelo encoder-decoder inicia a decodificação com um token diferente de `bos`, o id desse token. ngram (`int`, *opcional*, padrão 2) : Número de tokens futuros a prever. Defina como 1 para ser igual ao modelo de linguagem tradicional, que prevê o próximo token. num_buckets (`int`, *opcional*, padrão 32) : O número de buckets a serem usados para cada camada de atenção. Isso é para o cálculo de posição relativa. Veja o [artigo T5](see https://huggingface.co/papers/1910.10683) para mais detalhes. relative_max_distance (`int`, *opcional*, padrão 128) : Distâncias relativas maiores que esse número serão colocadas no último bucket. Isso é para o cálculo de posição relativa. Veja o [artigo do T5](see https://huggingface.co/papers/1910.10683) para mais detalhes. disable_ngram_loss (`bool`, *opcional*, padrão `False`) : Se deve ser treinado para prever apenas o primeiro token seguinte. eps (`float`, *opcional*, padrão 0.0) : Controla o valor do parâmetro `epsilon` para o label smoothing no cálculo da perda. Se definido como 0, nenhum label smoothing é realizado. 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. pad_token_id (`int`, *opcional*, padrão `0`) : ID do token usado para preenchimento no vocabulário. bos_token_id (`int`, *opcional*, padrão `1`) : ID do token usado para o início do fluxo no vocabulário. eos_token_id (`Union[int, list[int]]`, *opcional*, padrão `2`) : ID do token usado para o fim do fluxo no vocabulário. is_decoder (`bool`, *opcional*, padrão `False`) : Indica se o modelo é usado como decodificador ou não. Se `False`, o modelo é usado como codificador. tie_word_embeddings (`bool`, *opcional*, padrão `True`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo. Esta é a classe de configuração para armazenar a configuração de um ProphetNetModel. Ela é usada para instanciar um modelo Prophetnet 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 [microsoft/prophetnet-large-uncased](https://huggingface.co/microsoft/prophetnet-large-uncased) 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. ## ProphetNetTokenizer[[transformers.ProphetNetTokenizer]] #### transformers.ProphetNetTokenizer[[transformers.ProphetNetTokenizer]] ```python transformers.ProphetNetTokenizer(vocab_file: str, do_lower_case: bool | None = True, do_basic_tokenize: bool | None = True, never_split: collections.abc.Iterable | None = None, unk_token: str | None = '[UNK]', sep_token: str | None = '[SEP]', x_sep_token: str | None = '[X_SEP]', pad_token: str | None = '[PAD]', mask_token: str | None = '[MASK]', tokenize_chinese_chars: bool | None = True, strip_accents: bool | None = None, clean_up_tokenization_spaces: bool = True, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/tokenization_prophetnet.py#L267) **Parâmetros:** vocab_file (`str`) : Arquivo contendo o vocabulário. do_lower_case (`bool`, *opcional*, padrão `True`) : Indica se a entrada deve ser convertida para minúsculas durante a tokenização. do_basic_tokenize (`bool`, *opcional*, padrão `True`) : Se deve ou não realizar uma tokenização básica antes do WordPiece. never_split (`Iterable`, *opcional*) : Coleção de tokens que nunca serão divididos durante a tokenização. Tem efeito apenas quando `do_basic_tokenize=True` 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. sep_token (`str`, *opcional*, padrão `"[SEP]"`) : O token separador, usado ao construir uma sequência a partir de múltiplas sequências, por exemplo, duas sequências para classificação de sequência ou um texto e uma pergunta para resposta a perguntas. Também é usado como o último token de uma sequência construída com tokens especiais. x_sep_token (`str`, *opcional*, padrão `"[X_SEP]"`) : Token separador especial secundário, que pode ser gerado por [ProphetNetForConditionalGeneration](/docs/transformers/main/pt/model_doc/prophetnet#transformers.ProphetNetForConditionalGeneration). É usado para separar frases semelhantes a itens de lista em resumos, *por exemplo*. pad_token (`str`, *opcional*, padrão `"[PAD]"`) : O token usado para preenchimento, por exemplo, ao agrupar sequências de comprimentos diferentes. mask_token (`str`, *opcional*, padrão `"[MASK]"`) : O token usado para mascarar valores. Este é o token utilizado ao treinar este modelo com modelagem de linguagem mascarada. É o token que o modelo tentará prever. tokenize_chinese_chars (`bool`, *opcional*, padrão `True`) : Se deve ou não tokenizar caracteres chineses. Isso provavelmente deve ser desativado para o japonês (veja esta [questão](https://github.com/huggingface/transformers/issues/328)). strip_accents (`bool`, *opcional*) : Se deve ou não remover todos os acentos. Se essa opção não for especificada, ela será determinada pelo valor de `lowercase` (como no BERT original). clean_up_tokenization_spaces (`bool`, *opcional*, padrão `True`) : Indica se deve ou não limpar os espaços após a decodificação. A limpeza consiste em remover possíveis artefatos, como espaços extras. Construa um ProphetNetTokenizer. Baseado em WordPiece. 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. #### build_inputs_with_special_tokens[[transformers.ProphetNetTokenizer.build_inputs_with_special_tokens]] ```python build_inputs_with_special_tokens(token_ids_0: list, token_ids_1: list[int] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/tokenization_prophetnet.py#L450) **Parâmetros:** token_ids_0 (`List[int]`) : Lista de IDs aos quais os tokens especiais serão adicionados. token_ids_1 (`List[int]`, *opcional*) : Lista opcional de IDs para pares de sequências. **Retorna:** `List[int]` Lista de [IDs de entrada](../glossary#input-ids) com os tokens especiais apropriados. Construa as entradas do modelo a partir de uma sequência ou de um par de sequências para tarefas de classificação de sequência, concatenando e adicionando tokens especiais. Uma sequência BERT tem o seguinte formato: - sequência única: `[CLS] X [SEP]` - par de sequências: `[CLS] A [SEP] B [SEP]` #### convert_tokens_to_string[[transformers.ProphetNetTokenizer.convert_tokens_to_string]] ```python convert_tokens_to_string(tokens: str) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/tokenization_prophetnet.py#L395) Converte uma sequência de tokens (string) em uma única string. #### get_special_tokens_mask[[transformers.ProphetNetTokenizer.get_special_tokens_mask]] ```python get_special_tokens_mask(token_ids_0: list, token_ids_1: list[int] | None = None, already_has_special_tokens: bool | None = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/tokenization_prophetnet.py#L400) **Parâmetros:** token_ids_0 (`List[int]`) : Lista de IDs. token_ids_1 (`List[int]`, *opcional*) : Lista opcional de IDs para pares de sequências. already_has_special_tokens (`bool`, *opcional*, padrão `False`) : Indica se a lista de tokens já está formatada com tokens especiais para o modelo. **Retorna:** `List[int]` Uma lista de inteiros no intervalo [0, 1]: 1 para um token especial, 0 para um token de sequência. Recupera os ids de sequência de uma lista de tokens que não possui tokens especiais adicionados. Este método é chamado ao adicionar tokens especiais usando o método `prepare_for_model` do tokenizer. ## Saídas específicas do ProphetNet[[transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput]] #### transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput[[transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput]] ```python transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, logits_ngram: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_hidden_states: tuple[torch.Tensor] | None = None, decoder_ngram_hidden_states: tuple[torch.Tensor] | None = None, decoder_attentions: tuple[torch.Tensor] | None = None, decoder_ngram_attentions: tuple[torch.Tensor] | None = None, cross_attentions: tuple[torch.Tensor] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, encoder_attentions: tuple[torch.Tensor] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L122) **Parâmetros:** loss (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) : Perda de modelagem de linguagem. logits (`torch.Tensor` de forma `(batch_size, decoder_sequence_length, config.vocab_size)`) : Pontuações de previsão da cabeça principal de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax). logits_ngram (`torch.Tensor` de forma `(batch_size, ngram * decoder_sequence_length, config.vocab_size)`) : Pontuações de previsão da cabeça de modelagem de linguagem do fluxo de previsão (pontuações para cada token do vocabulário antes do SoftMax). 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 os hidden-states pré-computados (keys e values nos blocos de atenção) do decoder que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. decoder_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 decodificador na saída de cada camada, além das saídas iniciais dos embeddings. decoder_ngram_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 + um para a saída de cada camada) com a forma `(batch_size, ngram * decoder_sequence_length, hidden_size)`. Estados ocultos do fluxo de previsão do decodificador na saída de cada camada, além das saídas dos embeddings iniciais. decoder_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 do decodificador, após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. decoder_ngram_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_attn_heads, decoder_sequence_length, decoder_sequence_length)`. Pesos de atenção do stream de previsão do decodificador, após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos 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` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção da camada de cross-attention do decodificador, após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de cross-attention. encoder_last_hidden_state (`torch.Tensor` de forma `(batch_size, encoder_sequence_length, hidden_size)`, *opcional*) : Sequência de hidden-states na saída da última camada do encoder do modelo. encoder_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 codificador na saída de cada camada, além das saídas iniciais dos embeddings. encoder_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 do codificador, após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. Classe base para as saídas de modelos de linguagem sequência-para-sequência. #### transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqModelOutput[[transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqModelOutput]] ```python transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqModelOutput(last_hidden_state: Tensor, last_hidden_state_ngram: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_hidden_states: tuple[torch.Tensor] | None = None, decoder_ngram_hidden_states: tuple[torch.Tensor] | None = None, decoder_attentions: tuple[torch.Tensor] | None = None, decoder_ngram_attentions: tuple[torch.Tensor] | None = None, cross_attentions: tuple[torch.Tensor] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, encoder_attentions: tuple[torch.Tensor] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L174) **Parâmetros:** last_hidden_state (`torch.Tensor` de forma `(batch_size, decoder_sequence_length, hidden_size)`) : Sequência de estados ocultos do fluxo principal na saída da última camada do decodificador do modelo. Se `past_key_values` for usado, apenas o último estado oculto das sequências, de forma `(batch_size, 1, hidden_size)`, é retornado. last_hidden_state_ngram (`torch.Tensor` de forma `(batch_size,ngram * decoder_sequence_length, config.vocab_size)`, *opcional*) : Sequência de estados ocultos do fluxo de previsão na saída da última camada do decodificador do modelo. 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 os hidden-states pré-computados (keys e values nos blocos de atenção) do decoder que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. decoder_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 decodificador na saída de cada camada, além das saídas iniciais dos embeddings. decoder_ngram_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 + um para a saída de cada camada) com a forma `(batch_size, ngram * decoder_sequence_length, hidden_size)`. Estados ocultos do fluxo de previsão do decodificador na saída de cada camada, além das saídas dos embeddings iniciais. decoder_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 do decodificador, após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. decoder_ngram_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_attn_heads, decoder_sequence_length, decoder_sequence_length)`. Pesos de atenção do stream de previsão do decodificador, após o softmax de atenção, usados para calcular a média ponderada no cross_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 da camada de cross-attention do decodificador, após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de cross-attention. encoder_last_hidden_state (`torch.Tensor` de forma `(batch_size, encoder_sequence_length, hidden_size)`, *opcional*) : Sequência de hidden-states na saída da última camada do encoder do modelo. encoder_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 codificador na saída de cada camada, além das saídas iniciais dos embeddings. encoder_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 do codificador, após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. Classe base para as saídas do codificador de um modelo que também contém: estados ocultos pré-computados que podem acelerar a decodificação sequencial. #### transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutput[[transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutput]] ```python transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutput(last_hidden_state: Tensor, last_hidden_state_ngram: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, hidden_states: tuple[torch.Tensor] | None = None, hidden_states_ngram: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None, ngram_attentions: tuple[torch.Tensor] | None = None, cross_attentions: tuple[torch.Tensor] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L223) **Parâmetros:** last_hidden_state (`torch.Tensor` de forma `(batch_size, decoder_sequence_length, hidden_size)`) : Sequência de estados ocultos do fluxo principal na saída da última camada do decodificador do modelo. Se `past_key_values` for usado, apenas o último estado oculto das sequências, de forma `(batch_size, 1, hidden_size)`, é retornado. last_hidden_state_ngram (`torch.Tensor` de forma `(batch_size, ngram * decoder_sequence_length, config.vocab_size)`) : Sequência de estados ocultos do fluxo de previsão na saída da última camada do decodificador do modelo. 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 os hidden-states pré-computados (keys e values nos blocos de atenção) do decoder 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)`. Hidden-states do modelo na saída de cada camada, além das saídas iniciais opcionais dos embeddings. hidden_states_ngram (`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 + um para a saída de cada camada) com a forma `(batch_size, ngram * decoder_sequence_length, hidden_size)`. Estados ocultos do fluxo de previsão do decodificador na saída de cada camada, além das saídas dos embeddings iniciais. 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 das atenções após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. ngram_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_attn_heads, decoder_sequence_length, decoder_sequence_length)`. Pesos de atenção do stream de previsão do decodificador, após o softmax de atenção, usados para calcular a média ponderada no cross_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 da camada de cross-attention do decodificador, após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de cross-attention. Classe base para as saídas de um modelo que também podem conter chaves/valores passados (para acelerar a decodificação sequencial). #### transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderLMOutput[[transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderLMOutput]] ```python transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, logits_ngram: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, hidden_states: tuple[torch.Tensor] | None = None, hidden_states_ngram: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None, ngram_attentions: tuple[torch.Tensor] | None = None, cross_attentions: tuple[torch.Tensor] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L267) **Parâmetros:** loss (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) : Perda de modelagem de linguagem. logits (`torch.Tensor` de forma `(batch_size, decoder_sequence_length, config.vocab_size)`) : Pontuações de previsão da cabeça principal de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax). logits_ngram (`torch.Tensor` de forma `(batch_size, ngram * decoder_sequence_length, config.vocab_size)`) : Pontuações de previsão da cabeça de modelagem de linguagem do fluxo de previsão (pontuações para cada token do vocabulário antes do SoftMax). 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 os hidden-states pré-computados (keys e values nos blocos de atenção) do decoder 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)`. Hidden-states do modelo na saída de cada camada, além das saídas iniciais opcionais dos embeddings. hidden_states_ngram (`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 + um para a saída de cada camada) com a forma `(batch_size, ngram * decoder_sequence_length, hidden_size)`. Estados ocultos do fluxo de previsão do decodificador na saída de cada camada, além das saídas dos embeddings iniciais. 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 das atenções após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. ngram_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_attn_heads, decoder_sequence_length, decoder_sequence_length)`. Pesos de atenção do stream de previsão do decodificador, após o softmax de atenção, usados para calcular a média ponderada no cross_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 da camada de cross-attention do decodificador, após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de cross-attention. Classe base para as saídas de um modelo que também podem conter chaves/valores passados (para acelerar a decodificação sequencial). ## ProphetNetModel[[transformers.ProphetNetModel]] #### transformers.ProphetNetModel[[transformers.ProphetNetModel]] ```python transformers.ProphetNetModel(config: ProphetNetConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L1354) **Parâmetros:** config ([ProphetNetConfig](/docs/transformers/main/pt/model_doc/prophetnet#transformers.ProphetNetConfig)) : 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 Prophetnet básico 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.ProphetNetModel.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.Tensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, encoder_outputs: tuple | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L1383) **Parâmetros:** input_ids (`torch.Tensor` 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) decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada do decodificador no vocabulário. 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 do decodificador?](../glossary#decoder-input-ids) O ProphetNet usa o `eos_token_id` como o token inicial para a geração de `decoder_input_ids`. Se `past_key_values` for usado, opcionalmente apenas os últimos `decoder_input_ids` precisam ser inseridos (veja `past_key_values`). decoder_attention_mask (`torch.BoolTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamento padrão: gerar um tensor que ignora tokens de preenchimento em `decoder_input_ids`. A máscara causal também será usada por padrão. encoder_outputs (`tuple`, *opcional*) : A tupla consiste em (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de estados ocultos na saída da última camada do codificador. Usado na atenção cruzada do decodificador. 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. decoder_inputs_embeds (`torch.Tensor` de forma `(batch_size, target_sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `decoder_input_ids`, você pode escolher passar diretamente uma representação incorporada. Se `past_key_values` for usado, opcionalmente apenas o último `decoder_inputs_embeds` precisa ser inserido (veja `past_key_values`). Isso é útil se você quiser ter mais controle sobre como converter os índices de `decoder_input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. Se `decoder_input_ids` e `decoder_inputs_embeds` estiverem ambos não definidos, `decoder_inputs_embeds` assume o valor de `inputs_embeds`. 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`). output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes. output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. **Retorna:** [ProphetNetSeq2SeqModelOutput](/docs/transformers/main/pt/model_doc/prophetnet#transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqModelOutput) ou `tuple(torch.Tensor)` Um [ProphetNetSeq2SeqModelOutput](/docs/transformers/main/pt/model_doc/prophetnet#transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqModelOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([ProphetNetConfig](/docs/transformers/main/pt/model_doc/prophetnet#transformers.ProphetNetConfig)) e das entradas. O método forward do [ProphetNetModel](/docs/transformers/main/pt/model_doc/prophetnet#transformers.ProphetNetModel) 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. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, decoder_sequence_length, hidden_size)`) -- Sequência de estados ocultos do fluxo principal na saída da última camada do decodificador do modelo. Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado. - **last_hidden_state_ngram** (`torch.Tensor` de forma `(batch_size,ngram * decoder_sequence_length, config.vocab_size)`, *opcional*) -- Sequência de estados ocultos do fluxo de previsão na saída da última camada do decodificador do modelo. - **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) do decodificador que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **decoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do decodificador na saída de cada camada, além das saídas do embedding inicial. - **decoder_ngram_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 + um para a saída de cada camada) de forma `(batch_size, ngram * decoder_sequence_length, hidden_size)`. Estados ocultos do fluxo de previsão do decodificador na saída de cada camada, mais as saídas do embedding inicial. - **decoder_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) com forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. - **decoder_ngram_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 forma `(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)`. Pesos de atenção do stream de predição do decodificador, após o softmax de atenção, usados para calcular a média ponderada no - **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 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. - **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, encoder_sequence_length, hidden_size)`, *opcional*) -- Sequência de estados ocultos na saída da última camada do codificador do modelo. - **encoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do codificador na saída de cada camada, além das saídas do embedding inicial. - **encoder_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 de atenção do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Exemplo: ```python >>> from transformers import AutoTokenizer, ProphetNetModel >>> tokenizer = AutoTokenizer.from_pretrained("microsoft/prophetnet-large-uncased") >>> model = ProphetNetModel.from_pretrained("microsoft/prophetnet-large-uncased") >>> input_ids = tokenizer( ... "Studies have been shown that owning a dog is good for you", return_tensors="pt" ... ).input_ids # Batch size 1 >>> decoder_input_ids = tokenizer("Studies show that", return_tensors="pt").input_ids # Batch size 1 >>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids) >>> last_hidden_states = outputs.last_hidden_state # main stream hidden states >>> last_hidden_states_ngram = outputs.last_hidden_state_ngram # predict hidden states ``` ## ProphetNetEncoder[[transformers.ProphetNetEncoder]] #### transformers.ProphetNetEncoder[[transformers.ProphetNetEncoder]] ```python transformers.ProphetNetEncoder(config: ProphetNetConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L947) **Parâmetros:** config ([ProphetNetConfig](/docs/transformers/main/pt/model_doc/prophetnet#transformers.ProphetNetConfig)) : 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. A parte de codificador independente do ProphetNetModel. 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.ProphetNetEncoder.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L967) **Parâmetros:** input_ids (`torch.Tensor` 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) 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. output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes. output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. **Retorna:** [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou `tuple(torch.Tensor)` Um [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([ProphetNetConfig](/docs/transformers/main/pt/model_doc/prophetnet#transformers.ProphetNetConfig)) e das entradas. O método forward do [ProphetNetEncoder](/docs/transformers/main/pt/model_doc/prophetnet#transformers.ProphetNetEncoder) 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. - **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. Exemplo: ```python >>> from transformers import AutoTokenizer, ProphetNetEncoder >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("microsoft/prophetnet-large-uncased") >>> model = ProphetNetEncoder.from_pretrained("patrickvonplaten/prophetnet-large-uncased-standalone") >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") >>> outputs = model(**inputs) >>> last_hidden_states = outputs.last_hidden_state ``` ## ProphetNetDecoder[[transformers.ProphetNetDecoder]] #### transformers.ProphetNetDecoder[[transformers.ProphetNetDecoder]] ```python transformers.ProphetNetDecoder(config: ProphetNetConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L1054) **Parâmetros:** config ([ProphetNetConfig](/docs/transformers/main/pt/model_doc/prophetnet#transformers.ProphetNetConfig)) : 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. A parte de decodificador independente do ProphetNetModel. 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.ProphetNetDecoder.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L1083) **Parâmetros:** input_ids (`torch.Tensor` 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) encoder_hidden_states (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Sequência de hidden-states na saída da última camada do encoder. Usada na cross-attention se o modelo estiver configurado como um decoder. encoder_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 da entrada do codificador. Essa máscara é usada na atenção cruzada se o modelo estiver configurado como um decodificador. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. 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`). output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes. output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. **Retorna:** [ProphetNetDecoderModelOutput](/docs/transformers/main/pt/model_doc/prophetnet#transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutput) ou `tuple(torch.Tensor)` Um [ProphetNetDecoderModelOutput](/docs/transformers/main/pt/model_doc/prophetnet#transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([ProphetNetConfig](/docs/transformers/main/pt/model_doc/prophetnet#transformers.ProphetNetConfig)) e das entradas. O método forward do [ProphetNetDecoder](/docs/transformers/main/pt/model_doc/prophetnet#transformers.ProphetNetDecoder) 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. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, decoder_sequence_length, hidden_size)`) -- Sequência de estados ocultos do fluxo principal na saída da última camada do decodificador do modelo. Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado. - **last_hidden_state_ngram** (`torch.Tensor` de forma `(batch_size, ngram * decoder_sequence_length, config.vocab_size)`) -- Sequência de estados ocultos do fluxo de previsão na saída da última camada do decodificador do modelo. - **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) do decodificador 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) 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. - **hidden_states_ngram** (`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 + um para a saída de cada camada) de forma `(batch_size, ngram * decoder_sequence_length, hidden_size)`. Estados ocultos do fluxo de previsão do decodificador na saída de cada camada, mais as saídas 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. - **ngram_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 forma `(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)`. Pesos de atenção do stream de predição do decodificador, após o softmax de atenção, usados para calcular a média ponderada no - **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 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. Exemplo: ```python >>> from transformers import AutoTokenizer, ProphetNetDecoder >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("microsoft/prophetnet-large-uncased") >>> model = ProphetNetDecoder.from_pretrained("microsoft/prophetnet-large-uncased", add_cross_attention=False) >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") >>> outputs = model(**inputs) >>> last_hidden_states = outputs.last_hidden_state ``` ## ProphetNetForConditionalGeneration[[transformers.ProphetNetForConditionalGeneration]] #### transformers.ProphetNetForConditionalGeneration[[transformers.ProphetNetForConditionalGeneration]] ```python transformers.ProphetNetForConditionalGeneration(config: ProphetNetConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L1486) **Parâmetros:** config ([ProphetNetConfig](/docs/transformers/main/pt/model_doc/prophetnet#transformers.ProphetNetConfig)) : 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 ProphetNet com uma cabeça de modelagem de linguagem. Pode ser usado para tarefas de geração de sequência. 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.ProphetNetForConditionalGeneration.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.Tensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L1505) **Parâmetros:** input_ids (`torch.Tensor` 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) decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada do decodificador no vocabulário. 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 do decodificador?](../glossary#decoder-input-ids) O ProphetNet usa o `eos_token_id` como o token inicial para a geração de `decoder_input_ids`. Se `past_key_values` for usado, opcionalmente apenas os últimos `decoder_input_ids` precisam ser inseridos (veja `past_key_values`). decoder_attention_mask (`torch.BoolTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamento padrão: gerar um tensor que ignora tokens de preenchimento em `decoder_input_ids`. A máscara causal também será usada por padrão. encoder_outputs (`torch.Tensor`, *opcional*) : Tupla consiste em (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de hidden-states na saída da última camada do codificador. Usado na cross-attention do decodificador. 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. decoder_inputs_embeds (`torch.Tensor` de forma `(batch_size, target_sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `decoder_input_ids`, você pode escolher passar diretamente uma representação incorporada. Se `past_key_values` for usado, opcionalmente apenas o último `decoder_inputs_embeds` precisa ser inserido (veja `past_key_values`). Isso é útil se você quiser ter mais controle sobre como converter os índices de `decoder_input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. Se `decoder_input_ids` e `decoder_inputs_embeds` estiverem ambos não definidos, `decoder_inputs_embeds` assume o valor de `inputs_embeds`. labels (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos para o cálculo da perda de classificação/regressão de sequência. Os índices devem estar em `[-100, 0, ..., config.vocab_size - 1]`. Todos os rótulos definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os 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`). output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes. output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. **Retorna:** [ProphetNetSeq2SeqLMOutput](/docs/transformers/main/pt/model_doc/prophetnet#transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput) ou `tuple(torch.Tensor)` Um [ProphetNetSeq2SeqLMOutput](/docs/transformers/main/pt/model_doc/prophetnet#transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([ProphetNetConfig](/docs/transformers/main/pt/model_doc/prophetnet#transformers.ProphetNetConfig)) e das entradas. O método forward de [ProphetNetForConditionalGeneration](/docs/transformers/main/pt/model_doc/prophetnet#transformers.ProphetNetForConditionalGeneration) 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*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem. - **logits** (`torch.Tensor` de forma `(batch_size, decoder_sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça principal de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax). - **logits_ngram** (`torch.Tensor` de forma `(batch_size, ngram * decoder_sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem do stream de previsão (pontuações para cada token do vocabulário antes do SoftMax). - **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) do decodificador que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **decoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do decodificador na saída de cada camada, além das saídas do embedding inicial. - **decoder_ngram_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 + um para a saída de cada camada) de forma `(batch_size, ngram * decoder_sequence_length, hidden_size)`. Estados ocultos do fluxo de previsão do decodificador na saída de cada camada, mais as saídas do embedding inicial. - **decoder_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) com forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. - **decoder_ngram_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 forma `(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)`. Pesos de atenção do stream de predição do decodificador, 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 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. - **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, encoder_sequence_length, hidden_size)`, *opcional*) -- Sequência de estados ocultos na saída da última camada do codificador do modelo. - **encoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do codificador na saída de cada camada, além das saídas do embedding inicial. - **encoder_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 de atenção do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Exemplo: ```python >>> from transformers import AutoTokenizer, ProphetNetForConditionalGeneration >>> tokenizer = AutoTokenizer.from_pretrained("microsoft/prophetnet-large-uncased") >>> model = ProphetNetForConditionalGeneration.from_pretrained("microsoft/prophetnet-large-uncased") >>> input_ids = tokenizer( ... "Studies have been shown that owning a dog is good for you", return_tensors="pt" ... ).input_ids # Batch size 1 >>> decoder_input_ids = tokenizer("Studies show that", return_tensors="pt").input_ids # Batch size 1 >>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids) >>> logits_next_token = outputs.logits # logits to predict next token as usual >>> logits_ngram_next_tokens = outputs.logits_ngram # logits to predict 2nd, 3rd, ... next tokens ``` ## ProphetNetForCausalLM[[transformers.ProphetNetForCausalLM]] #### transformers.ProphetNetForCausalLM[[transformers.ProphetNetForCausalLM]] ```python transformers.ProphetNetForCausalLM(config: ProphetNetConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L1660) **Parâmetros:** config ([ProphetNetConfig](/docs/transformers/main/pt/model_doc/prophetnet#transformers.ProphetNetConfig)) : 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. A parte de decodificador independente do ProphetNetModel com um cabeçalho de lm no topo. O modelo pode ser usado para causal 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.ProphetNetForCausalLM.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/prophetnet/modeling_prophetnet.py#L1688) **Parâmetros:** input_ids (`torch.Tensor` 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) encoder_hidden_states (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Sequência de hidden-states na saída da última camada do encoder. Usada na cross-attention se o modelo estiver configurado como um decoder. encoder_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 da entrada do codificador. Essa máscara é usada na atenção cruzada se o modelo estiver configurado como um decodificador. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. 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. labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem da esquerda para a direita (previsão da próxima palavra). Os índices devem estar em `[-100, 0, ..., config.vocab_size]` (veja a docstring de `input_ids`). Tokens com índices definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os tokens com 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`). output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes. output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. **Retorna:** [ProphetNetDecoderLMOutput](/docs/transformers/main/pt/model_doc/prophetnet#transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderLMOutput) ou `tuple(torch.Tensor)` Um [ProphetNetDecoderLMOutput](/docs/transformers/main/pt/model_doc/prophetnet#transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderLMOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([ProphetNetConfig](/docs/transformers/main/pt/model_doc/prophetnet#transformers.ProphetNetConfig)) e das entradas. O método forward de [ProphetNetForCausalLM](/docs/transformers/main/pt/model_doc/prophetnet#transformers.ProphetNetForCausalLM) 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. - **logits** (`torch.Tensor` de forma `(batch_size, decoder_sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça principal de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax). - **logits_ngram** (`torch.Tensor` de forma `(batch_size, ngram * decoder_sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem do stream de previsão (pontuações para cada token do vocabulário antes do SoftMax). - **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) do decodificador 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) 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. - **hidden_states_ngram** (`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 + um para a saída de cada camada) de forma `(batch_size, ngram * decoder_sequence_length, hidden_size)`. Estados ocultos do fluxo de previsão do decodificador na saída de cada camada, mais as saídas 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. - **ngram_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 forma `(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)`. Pesos de atenção do stream de predição do decodificador, após o softmax de atenção, usados para calcular a média ponderada no - **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 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. Exemplo: ```python >>> from transformers import AutoTokenizer, ProphetNetForCausalLM >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("microsoft/prophetnet-large-uncased") >>> model = ProphetNetForCausalLM.from_pretrained("microsoft/prophetnet-large-uncased") >>> assert model.config.is_decoder, f"{model.__class__} has to be configured as a decoder." >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") >>> outputs = model(**inputs) >>> logits = outputs.logits >>> # Model can also be used with EncoderDecoder framework >>> from transformers import BertTokenizer, EncoderDecoderModel, AutoTokenizer >>> import torch >>> tokenizer_enc = BertTokenizer.from_pretrained("google-bert/bert-large-uncased") >>> tokenizer_dec = AutoTokenizer.from_pretrained("microsoft/prophetnet-large-uncased") >>> model = EncoderDecoderModel.from_encoder_decoder_pretrained( ... "google-bert/bert-large-uncased", "microsoft/prophetnet-large-uncased" ... ) >>> ARTICLE = ( ... "the us state department said wednesday it had received no " ... "formal word from bolivia that it was expelling the us ambassador there " ... "but said the charges made against him are `` baseless ." ... ) >>> input_ids = tokenizer_enc(ARTICLE, return_tensors="pt").input_ids >>> labels = tokenizer_dec( ... "us rejects charges against its ambassador in bolivia", return_tensors="pt" ... ).input_ids >>> outputs = model(input_ids=input_ids, decoder_input_ids=labels[:, :-1], labels=labels[:, 1:]) >>> loss = outputs.loss ```