# Longformer [Longformer](https://huggingface.co/papers/2004.05150) é um modelo de transformer projetado para processar documentos longos. A operação de autoatenção geralmente escala de forma quadrática em relação ao comprimento da sequência, o que impede que os transformers processem sequências mais longas. O mecanismo de atenção do Longformer supera essa limitação, escalando de forma linear em relação ao comprimento da sequência. Ele combina atenção local em janelas com atenção global específica para a tarefa, permitindo o processamento eficiente de documentos com milhares de tokens. Você pode encontrar todos os checkpoints originais do Longformer na organização [Ai2](https://huggingface.co/allenai?search_models=longformer). > [!TIP] > Clique nos modelos Longformer na barra lateral à direita para ver mais exemplos de como aplicar o Longformer a diferentes tarefas de linguagem. O exemplo abaixo demonstra como preencher o token `` com [Pipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.Pipeline), [AutoModel](/docs/transformers/main/pt/model_doc/auto#transformers.AutoModel) e pela linha de comando. ```python from transformers import pipeline pipeline = pipeline( task="fill-mask", model="allenai/longformer-base-4096", device=0 ) pipeline("""San Francisco 49ers cornerback Shawntae Spencer will miss the rest of the with a torn ligament in his left knee. Spencer, a fifth-year pro, will be placed on injured reserve soon after undergoing surgery Wednesday to repair the ligament. He injured his knee late in the 49ers’ road victory at Seattle on Sept. 14, and missed last week’s victory over Detroit. Tarell Brown and Donald Strickland will compete to replace Spencer with the 49ers, who kept 12 defensive backs on their 53-man roster to start the season. Brown, a second-year pro, got his first career interception last weekend while filling in for Strickland, who also sat out with a knee injury.""") ``` ```python from transformers import AutoModelForMaskedLM, AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") model = AutoModelForMaskedLM.from_pretrained("allenai/longformer-base-4096", device_map="auto") text = ( """ San Francisco 49ers cornerback Shawntae Spencer will miss the rest of the with a torn ligament in his left knee. Spencer, a fifth-year pro, will be placed on injured reserve soon after undergoing surgery Wednesday to repair the ligament. He injured his knee late in the 49ers’ road victory at Seattle on Sept. 14, and missed last week’s victory over Detroit. Tarell Brown and Donald Strickland will compete to replace Spencer with the 49ers, who kept 12 defensive backs on their 53-man roster to start the season. Brown, a second-year pro, got his first career interception last weekend while filling in for Strickland, who also sat out with a knee injury. """ ) input_ids = tokenizer([text], return_tensors="pt").to(model.device)["input_ids"] logits = model(input_ids).logits masked_index = (input_ids[0] == tokenizer.mask_token_id).nonzero().item() probs = logits[0, masked_index].softmax(dim=0) values, predictions = probs.topk(5) tokenizer.decode(predictions).split() ``` ## Observações - O Longformer é baseado no [RoBERTa](./roberta) e não possui `token_type_ids`. Você não precisa indicar a qual segmento pertence cada token. Basta separar os segmentos com o token de separação `` ou `tokenizer.sep_token`. - Você pode definir quais tokens podem atender localmente e quais tokens atendem globalmente com o `global_attention_mask` na inferência (veja este [exemplo](/docs/transformers/main/pt/model_doc/longformer#transformers.LongformerModel.forward.example) para mais detalhes). Um valor de `0` significa que um token atende localmente e um valor de `1` significa que um token atende globalmente. - [LongformerForMaskedLM](/docs/transformers/main/pt/model_doc/longformer#transformers.LongformerForMaskedLM) é treinado como [RobertaForMaskedLM](/docs/transformers/main/pt/model_doc/roberta#transformers.RobertaForMaskedLM) e deve ser usado conforme mostrado abaixo. ```py input_ids = tokenizer.encode("This is a sentence from [MASK] training data", return_tensors="pt").to(model.device) mlm_labels = tokenizer.encode("This is a sentence from the training data", return_tensors="pt").to(model.device) loss = model(input_ids, labels=input_ids, masked_lm_labels=mlm_labels)[0] ``` ## LongformerConfig[[transformers.LongformerConfig]] #### transformers.LongformerConfig[[transformers.LongformerConfig]] ```python transformers.LongformerConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, attention_window: list[int] | int = 512, sep_token_id: int | None = 2, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, vocab_size: int = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 512, type_vocab_size: int = 2, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, onnx_export: bool = False, tie_word_embeddings: bool = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/configuration_longformer.py#L24) **Parâmetros:** attention_window (`int` ou `list[int]`, *opcional*, padrão 512) : Tamanho de uma janela de atenção ao redor de cada token. Se for um `int`, use o mesmo tamanho para todas as camadas. Para especificar um tamanho de janela diferente para cada camada, use uma `list[int]` em que `len(attention_window) == num_hidden_layers`. sep_token_id (`int`, *opcional*, padrão `2`) : ID do token usado como separador no vocabulário. pad_token_id (`int`, *opcional*, padrão `1`) : ID do token usado para preenchimento no vocabulário. bos_token_id (`int`, *opcional*, padrão `0`) : 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. 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 `768`) : Dimensão das representações ocultas. num_hidden_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no decodificador do Transformer. num_attention_heads (`int`, *opcional*, padrão `12`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. intermediate_size (`int`, *opcional*, padrão `3072`) : Dimensão das representações do MLP. hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. hidden_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.1`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, encoder e pooler. attention_probs_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.1`) : A taxa de dropout para as probabilidades de atenção. max_position_embeddings (`int`, *opcional*, padrão `512`) : O comprimento máximo de sequência com o qual este modelo pode ser utilizado. type_vocab_size (`int`, *opcional*, padrão `2`) : O tamanho do vocabulário dos `token_type_ids`. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. layer_norm_eps (`float`, *opcional*, padrão `1e-12`) : O epsilon usado pelas camadas de normalização de camada. onnx_export (`bool`, *opcional*, padrão é False) : Se deve criar um modelo que seja exportável para ONNX ou não. 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 LongformerModel. Ela é usada para instanciar um modelo Longformer 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 [allenai/longformer-base-4096](https://huggingface.co/allenai/longformer-base-4096) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplo: ```python >>> from transformers import LongformerConfig, LongformerModel >>> # Initializing a Longformer configuration >>> configuration = LongformerConfig() >>> # Initializing a model from the configuration >>> model = LongformerModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## LongformerTokenizer[[transformers.RobertaTokenizer]] #### transformers.RobertaTokenizer[[transformers.RobertaTokenizer]] ```python transformers.RobertaTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, errors: str = 'replace', bos_token: str = '', eos_token: str = '', sep_token: str = '', cls_token: str = '', unk_token: str = '', pad_token: str = '', mask_token: str = '', add_prefix_space: bool = False, trim_offsets: bool = True, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/roberta/tokenization_roberta.py#L28) **Parâmetros:** vocab (`str`, `dict` ou `list`, *opcional*) : Dicionário de vocabulário personalizado. Se não for fornecido, o vocabulário é carregado de vocab_file. merges (`str` ou `list`, *opcional*) : Lista de mesclagens personalizada. Se não for fornecida, as mesclagens são carregadas de merges_file. errors (`str`, *opcional*, padrão `"replace"`) : Paradigma a ser seguido ao decodificar bytes para UTF-8. Consulte [bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode) para mais informações. bos_token (`str`, *opcional*, padrão `""`) : O token de início de sequência usado durante o pré-treinamento. Pode ser usado como token de classificador de sequência. Ao construir uma sequência usando tokens especiais, este não é o token utilizado para o início da sequência. O token utilizado é o `cls_token`. eos_token (`str`, *opcional*, padrão `""`) : O token de fim de sequência. Ao construir uma sequência usando tokens especiais, este não é o token utilizado para o fim da sequência. O token utilizado é o `sep_token`. sep_token (`str`, *opcional*, padrão `""`) : O token separador, usado ao montar 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 montada com tokens especiais. cls_token (`str`, *opcional*, padrão `""`) : O token de classificador usado na classificação de sequência (classificação da sequência inteira, em vez da classificação por token). É o primeiro token da sequência quando esta é construída com tokens especiais. unk_token (`str`, *opcional*, padrão `""`) : 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. pad_token (`str`, *opcional*, padrão `""`) : O token usado para preenchimento, por exemplo, ao agrupar sequências de comprimentos diferentes. mask_token (`str`, *opcional*, padrão `""`) : 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. add_prefix_space (`bool`, *opcional*, padrão `False`) : Indica se deve ou não adicionar um espaço inicial à entrada. Isso permite tratar a palavra inicial como qualquer outra palavra. (O tokenizer do RoBERTa detecta o início das palavras pelo espaço que as precede). trim_offsets (`bool`, *opcional*, padrão `True`) : Se a etapa de pós-processamento deve aparar os deslocamentos para evitar a inclusão de espaços em branco. Construa um tokenizador RoBERTa (baseado na biblioteca tokenizers da HuggingFace). Baseado em Byte-Pair-Encoding. Este tokenizer foi treinado para tratar espaços como partes dos tokens (um pouco como o sentencepiece), de modo que uma palavra será ser codificado de forma diferente, dependendo se está no início da frase (sem espaço) ou não: ```python >>> from transformers import RobertaTokenizer >>> tokenizer = RobertaTokenizer.from_pretrained("FacebookAI/roberta-base") >>> tokenizer("Hello world")["input_ids"] [0, 31414, 232, 2] >>> tokenizer(" Hello world")["input_ids"] [0, 20920, 232, 2] ``` Você pode contornar esse comportamento passando `add_prefix_space=True` ao instanciar este tokenizer ou ao chamá-lo em algum texto, mas, como o modelo não foi pré-treinado dessa forma, isso pode resultar em uma queda de desempenho. Quando usado com `is_split_into_words=True`, este tokenizer precisa ser instanciado com `add_prefix_space=True`. Este tokenizer herda de [TokenizersBackend](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend), 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. ## Saídas específicas do Longformer[[transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput]] #### transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput[[transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput]] ```python transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput(last_hidden_state: Tensor, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L41) **Parâmetros:** 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) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas iniciais opcionais dos embeddings. 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, x + attention_window + 1)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção local após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. Esses são os pesos de atenção de cada token na sequência para cada token com atenção global (primeiros `x` valores) e para cada token na janela de atenção (restantes `attention_window + 1` valores). Observe que os primeiros `x` valores referem-se a tokens com posições fixas no texto, mas os restantes `attention_window + 1` valores referem-se a tokens com posições relativas: o peso de atenção de um token para si mesmo está localizado no índice `x + attention_window / 2` e os `attention_window / 2` valores precedentes (sucessores) são os pesos de atenção para os `attention_window / 2` tokens precedentes (sucessores). Se a janela de atenção contiver um token com atenção global, o peso de atenção no índice correspondente é definido como 0; o valor deve ser acessado a partir dos primeiros `x` pesos de atenção. Se um token tiver atenção global, os pesos de atenção para todos os outros tokens em `attentions` são definidos como 0, os valores devem ser acessados a partir de `global_attentions`. global_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_heads, sequence_length, x)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção global após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. Esses são os pesos de atenção de cada token com atenção global para cada token na sequência. Classe base para as saídas do Longformer, com estados ocultos potenciais, atenções locais e globais. #### transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling[[transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling]] ```python transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling(last_hidden_state: Tensor, pooler_output: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L79) **Parâmetros:** 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. pooler_output (`torch.Tensor` de forma `(batch_size, hidden_size)`) : Estado oculto da última camada do primeiro token da sequência (token de classificação), processado adicionalmente por uma camada Linear e uma função de ativação Tanh. Os pesos da camada Linear são treinados a partir do objetivo de previsão da próxima sentença (classificação) durante o pré-treinamento. 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 iniciais opcionais dos embeddings. 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, x + attention_window + 1)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção local após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. Esses são os pesos de atenção de cada token na sequência para cada token com atenção global (primeiros `x` valores) e para cada token na janela de atenção (restantes `attention_window + 1` valores). Observe que os primeiros `x` valores referem-se a tokens com posições fixas no texto, mas os restantes `attention_window + 1` valores referem-se a tokens com posições relativas: o peso de atenção de um token para si mesmo está localizado no índice `x + attention_window / 2` e os `attention_window / 2` valores precedentes (sucessores) são os pesos de atenção para os `attention_window / 2` tokens precedentes (sucessores). Se a janela de atenção contiver um token com atenção global, o peso de atenção no índice correspondente é definido como 0; o valor deve ser acessado a partir dos primeiros `x` pesos de atenção. Se um token tiver atenção global, os pesos de atenção para todos os outros tokens em `attentions` são definidos como 0, os valores devem ser acessados a partir de `global_attentions`. global_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_heads, sequence_length, x)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção global após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. Esses são os pesos de atenção de cada token com atenção global para cada token na sequência. Classe base para as saídas do Longformer que também contém um pooling dos últimos estados ocultos. #### transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput[[transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput]] ```python transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L122) **Parâmetros:** loss (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) : Perda de modelagem de linguagem mascarada (MLM). logits (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) : Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax). hidden_states (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas iniciais opcionais dos embeddings. 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, x + attention_window + 1)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção local após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. Esses são os pesos de atenção de cada token na sequência para cada token com atenção global (primeiros `x` valores) e para cada token na janela de atenção (restantes `attention_window + 1` valores). Observe que os primeiros `x` valores referem-se a tokens com posições fixas no texto, mas os restantes `attention_window + 1` valores referem-se a tokens com posições relativas: o peso de atenção de um token para si mesmo está localizado no índice `x + attention_window / 2` e os `attention_window / 2` valores precedentes (sucessores) são os pesos de atenção para os `attention_window / 2` tokens precedentes (sucessores). Se a janela de atenção contiver um token com atenção global, o peso de atenção no índice correspondente é definido como 0; o valor deve ser acessado a partir dos primeiros `x` pesos de atenção. Se um token tiver atenção global, os pesos de atenção para todos os outros tokens em `attentions` são definidos como 0, os valores devem ser acessados a partir de `global_attentions`. global_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_heads, sequence_length, x)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção global após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. Esses são os pesos de atenção de cada token com atenção global para cada token na sequência. Classe base para as saídas de modelos de linguagem mascarada. #### transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput[[transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput]] ```python transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput(loss: typing.Optional[torch.Tensor] = None, start_logits: typing.Optional[torch.Tensor] = None, end_logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L165) **Parâmetros:** loss (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) : A perda total de extração de span é a soma de uma Entropia Cruzada para as posições de início e fim. start_logits (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Pontuações de início de trecho (antes do SoftMax). end_logits (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Pontuações de fim de trecho (antes do SoftMax). hidden_states (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas iniciais opcionais dos embeddings. 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, x + attention_window + 1)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção local após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. Esses são os pesos de atenção de cada token na sequência para cada token com atenção global (primeiros `x` valores) e para cada token na janela de atenção (restantes `attention_window + 1` valores). Observe que os primeiros `x` valores referem-se a tokens com posições fixas no texto, mas os restantes `attention_window + 1` valores referem-se a tokens com posições relativas: o peso de atenção de um token para si mesmo está localizado no índice `x + attention_window / 2` e os `attention_window / 2` valores precedentes (sucessores) são os pesos de atenção para os `attention_window / 2` tokens precedentes (sucessores). Se a janela de atenção contiver um token com atenção global, o peso de atenção no índice correspondente é definido como 0; o valor deve ser acessado a partir dos primeiros `x` pesos de atenção. Se um token tiver atenção global, os pesos de atenção para todos os outros tokens em `attentions` são definidos como 0, os valores devem ser acessados a partir de `global_attentions`. global_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_heads, sequence_length, x)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção global após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. Esses são os pesos de atenção de cada token com atenção global para cada token na sequência. Classe base para as saídas dos modelos Longformer de resposta a perguntas. #### transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput[[transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput]] ```python transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L207) **Parâmetros:** loss (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) : Perda de classificação (ou de regressão se config.num_labels==1). logits (`torch.Tensor` de forma `(batch_size, config.num_labels)`) : Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax). hidden_states (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas iniciais opcionais dos embeddings. 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, x + attention_window + 1)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção local após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. Esses são os pesos de atenção de cada token na sequência para cada token com atenção global (primeiros `x` valores) e para cada token na janela de atenção (restantes `attention_window + 1` valores). Observe que os primeiros `x` valores referem-se a tokens com posições fixas no texto, mas os restantes `attention_window + 1` valores referem-se a tokens com posições relativas: o peso de atenção de um token para si mesmo está localizado no índice `x + attention_window / 2` e os `attention_window / 2` valores precedentes (sucessores) são os pesos de atenção para os `attention_window / 2` tokens precedentes (sucessores). Se a janela de atenção contiver um token com atenção global, o peso de atenção no índice correspondente é definido como 0; o valor deve ser acessado a partir dos primeiros `x` pesos de atenção. Se um token tiver atenção global, os pesos de atenção para todos os outros tokens em `attentions` são definidos como 0, os valores devem ser acessados a partir de `global_attentions`. global_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_heads, sequence_length, x)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção global após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. Esses são os pesos de atenção de cada token com atenção global para cada token na sequência. Classe base para as saídas de modelos de classificação de sentenças. #### transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput[[transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput]] ```python transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L250) **Parâmetros:** loss (`torch.Tensor` de forma *(1,)*, *opcional*, retornado quando `labels` é fornecido) : Perda de classificação. logits (`torch.Tensor` de forma `(batch_size, num_choices)`) : *num_choices* é a segunda dimensão dos tensors de entrada. (veja *input_ids* acima). Pontuações de classificação (antes do SoftMax). hidden_states (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas iniciais opcionais dos embeddings. 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, x + attention_window + 1)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção local após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. Esses são os pesos de atenção de cada token na sequência para cada token com atenção global (primeiros `x` valores) e para cada token na janela de atenção (restantes `attention_window + 1` valores). Observe que os primeiros `x` valores referem-se a tokens com posições fixas no texto, mas os restantes `attention_window + 1` valores referem-se a tokens com posições relativas: o peso de atenção de um token para si mesmo está localizado no índice `x + attention_window / 2` e os `attention_window / 2` valores precedentes (sucessores) são os pesos de atenção para os `attention_window / 2` tokens precedentes (sucessores). Se a janela de atenção contiver um token com atenção global, o peso de atenção no índice correspondente é definido como 0; o valor deve ser acessado a partir dos primeiros `x` pesos de atenção. Se um token tiver atenção global, os pesos de atenção para todos os outros tokens em `attentions` são definidos como 0, os valores devem ser acessados a partir de `global_attentions`. global_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_heads, sequence_length, x)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção global após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. Esses são os pesos de atenção de cada token com atenção global para cada token na sequência. Classe base para as saídas de modelos Longformer de escolha múltipla. #### transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput[[transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput]] ```python transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L295) **Parâmetros:** loss (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) : Perda de classificação. logits (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_labels)`) : Pontuações de classificação (antes do SoftMax). hidden_states (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas iniciais opcionais dos embeddings. 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, x + attention_window + 1)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção local após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. Esses são os pesos de atenção de cada token na sequência para cada token com atenção global (primeiros `x` valores) e para cada token na janela de atenção (restantes `attention_window + 1` valores). Observe que os primeiros `x` valores referem-se a tokens com posições fixas no texto, mas os restantes `attention_window + 1` valores referem-se a tokens com posições relativas: o peso de atenção de um token para si mesmo está localizado no índice `x + attention_window / 2` e os `attention_window / 2` valores precedentes (sucessores) são os pesos de atenção para os `attention_window / 2` tokens precedentes (sucessores). Se a janela de atenção contiver um token com atenção global, o peso de atenção no índice correspondente é definido como 0; o valor deve ser acessado a partir dos primeiros `x` pesos de atenção. Se um token tiver atenção global, os pesos de atenção para todos os outros tokens em `attentions` são definidos como 0, os valores devem ser acessados a partir de `global_attentions`. global_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_heads, sequence_length, x)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção global após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. Esses são os pesos de atenção de cada token com atenção global para cada token na sequência. Classe base para as saídas de modelos de classificação de tokens. ## LongformerModel[[transformers.LongformerModel]] #### transformers.LongformerModel[[transformers.LongformerModel]] ```python transformers.LongformerModel(config: LongformerConfig, add_pooling_layer = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1276) **Parâmetros:** config ([LongformerConfig](/docs/transformers/main/pt/model_doc/longformer#transformers.LongformerConfig)) : 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. add_pooling_layer (`bool`, *opcional*, padrão `True`) : Se deve adicionar uma camada de pooling O modelo Longformer 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.LongformerModel.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: 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/longformer/modeling_longformer.py#L1384) **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) global_attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para decidir a atenção dada a cada token, atenção local ou atenção global. Tokens com atenção global prestam atenção a todos os outros tokens, e todos os outros tokens prestam atenção a eles. Isso é importante para o ajuste fino específico de tarefa, pois torna o modelo mais flexível na representação da tarefa. Por exemplo, para classificação, o token deve receber atenção global. Para QA, todos os tokens da pergunta também devem ter atenção global. Consulte o [artigo do Longformer](https://huggingface.co/papers/2004.05150) para mais detalhes. Valores de máscara selecionados em `[0, 1]`: - 0 para atenção local (atenção com janela deslizante), - 1 para atenção global (tokens que prestam atenção a todos os outros tokens, e todos os outros tokens prestam atenção a eles). token_type_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`: - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*. [O que são IDs de tipo de token?](../glossary#token-type-ids) position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. 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:** [LongformerBaseModelOutputWithPooling](/docs/transformers/main/pt/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Um [LongformerBaseModelOutputWithPooling](/docs/transformers/main/pt/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling) 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 ([LongformerConfig](/docs/transformers/main/pt/model_doc/longformer#transformers.LongformerConfig)) e das entradas. O método forward do [LongformerModel](/docs/transformers/main/pt/model_doc/longformer#transformers.LongformerModel) 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, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação), processado adicionalmente por uma camada Linear e uma função de ativação Tanh. Os pesos da camada Linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento. - **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 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 forma `(batch_size, num_heads, sequence_length, x + attention_window + 1)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção local após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Esses são os pesos de atenção de cada token na sequência para todos os tokens com atenção global (primeiros `x` valores) e para todos os tokens na janela de atenção (valores restantes `attention_window + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `global_attentions`. - **global_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) de forma `(batch_size, num_heads, sequence_length, x)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção global após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Esses são os pesos de atenção de cada token com atenção global para cada token na sequência. Exemplos: ```python >>> import torch >>> from transformers import LongformerModel, AutoTokenizer >>> model = LongformerModel.from_pretrained("allenai/longformer-base-4096") >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") >>> SAMPLE_TEXT = " ".join(["Hello world! "] * 1000) # long input document >>> input_ids = torch.tensor(tokenizer.encode(SAMPLE_TEXT)).unsqueeze(0) # batch of size 1 >>> attention_mask = torch.ones( ... input_ids.shape, dtype=torch.long, device=input_ids.device ... ) # initialize to local attention >>> global_attention_mask = torch.zeros( ... input_ids.shape, dtype=torch.long, device=input_ids.device ... ) # initialize to global attention to be deactivated for all tokens >>> global_attention_mask[ ... :, ... [ ... 1, ... 4, ... 21, ... ], ... ] = 1 # Set global attention to random tokens for the sake of this example >>> # Usually, set global attention based on the task. For example, >>> # classification: the token >>> # QA: question tokens >>> # LM: potentially on the beginning of sentences and paragraphs >>> outputs = model(input_ids, attention_mask=attention_mask, global_attention_mask=global_attention_mask) >>> sequence_output = outputs.last_hidden_state >>> pooled_output = outputs.pooler_output ``` ## LongformerForMaskedLM[[transformers.LongformerForMaskedLM]] #### transformers.LongformerForMaskedLM[[transformers.LongformerForMaskedLM]] ```python transformers.LongformerForMaskedLM(config: LongformerConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1522) **Parâmetros:** config ([LongformerConfig](/docs/transformers/main/pt/model_doc/longformer#transformers.LongformerConfig)) : 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 Longformer com uma cabeça de `language modeling` 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.LongformerForMaskedLM.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: 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/longformer/modeling_longformer.py#L1543) **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) global_attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para decidir a atenção dada a cada token, atenção local ou atenção global. Tokens com atenção global prestam atenção a todos os outros tokens, e todos os outros tokens prestam atenção a eles. Isso é importante para o ajuste fino específico de tarefa, pois torna o modelo mais flexível na representação da tarefa. Por exemplo, para classificação, o token deve receber atenção global. Para QA, todos os tokens da pergunta também devem ter atenção global. Consulte o [artigo do Longformer](https://huggingface.co/papers/2004.05150) para mais detalhes. Valores de máscara selecionados em `[0, 1]`: - 0 para atenção local (atenção com janela deslizante), - 1 para atenção global (tokens que prestam atenção a todos os outros tokens, e todos os outros tokens prestam atenção a eles). token_type_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`: - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*. [O que são IDs de tipo de token?](../glossary#token-type-ids) position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem mascarada. 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]`. 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:** [LongformerMaskedLMOutput](/docs/transformers/main/pt/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput) ou `tuple(torch.Tensor)` Um [LongformerMaskedLMOutput](/docs/transformers/main/pt/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput) 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 ([LongformerConfig](/docs/transformers/main/pt/model_doc/longformer#transformers.LongformerConfig)) e das entradas. O método forward de [LongformerForMaskedLM](/docs/transformers/main/pt/model_doc/longformer#transformers.LongformerForMaskedLM) 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 mascarada (MLM). - **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax). - **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (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 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 forma `(batch_size, num_heads, sequence_length, x + attention_window + 1)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção local após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Esses são os pesos de atenção de cada token na sequência para todos os tokens com atenção global (primeiros `x` valores) e para todos os tokens na janela de atenção (valores restantes `attention_window + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `global_attentions`. - **global_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) de forma `(batch_size, num_heads, sequence_length, x)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção global após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Esses são os pesos de atenção de cada token com atenção global para cada token na sequência. Exemplo de preenchimento de Máscara: ```python >>> from transformers import AutoTokenizer, LongformerForMaskedLM >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") >>> model = LongformerForMaskedLM.from_pretrained("allenai/longformer-base-4096") ``` Vamos tentar uma entrada muito longa. ```python >>> TXT = ( ... "My friends are but they eat too many carbs." ... + " That's why I decide not to eat with them." * 300 ... ) >>> input_ids = tokenizer([TXT], return_tensors="pt")["input_ids"] >>> logits = model(input_ids).logits >>> masked_index = (input_ids[0] == tokenizer.mask_token_id).nonzero().item() >>> probs = logits[0, masked_index].softmax(dim=0) >>> values, predictions = probs.topk(5) >>> tokenizer.decode(predictions).split() ['healthy', 'skinny', 'thin', 'good', 'vegetarian'] ``` ## LongformerForSequenceClassification[[transformers.LongformerForSequenceClassification]] #### transformers.LongformerForSequenceClassification[[transformers.LongformerForSequenceClassification]] ```python transformers.LongformerForSequenceClassification(config: LongformerConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1639) **Parâmetros:** config ([LongformerConfig](/docs/transformers/main/pt/model_doc/longformer#transformers.LongformerConfig)) : 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. Modelo transformer Longformer com uma cabeça de classificação/regressão de sequência no topo (uma camada linear no topo da saída agregada), por exemplo, para tarefas GLUE. 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.LongformerForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: 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/longformer/modeling_longformer.py#L1651) **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) global_attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para decidir a atenção dada a cada token, atenção local ou atenção global. Tokens com atenção global prestam atenção a todos os outros tokens, e todos os outros tokens prestam atenção a eles. Isso é importante para o ajuste fino específico de tarefa, pois torna o modelo mais flexível na representação da tarefa. Por exemplo, para classificação, o token deve receber atenção global. Para QA, todos os tokens da pergunta também devem ter atenção global. Consulte o [artigo do Longformer](https://huggingface.co/papers/2004.05150) para mais detalhes. Valores de máscara selecionados em `[0, 1]`: - 0 para atenção local (atenção com janela deslizante), - 1 para atenção global (tokens que prestam atenção a todos os outros tokens, e todos os outros tokens prestam atenção a eles). token_type_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`: - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*. [O que são IDs de tipo de token?](../glossary#token-type-ids) position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. labels (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos para o cálculo da perda de classificação/regressão de sequência. Os índices devem estar em `[0, ..., config.num_labels - 1]`. Se `config.num_labels == 1`, uma perda de regressão é calculada (perda de erro quadrático médio). Se `config.num_labels > 1`, uma perda de classificação é calculada (entropia cruzada). 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:** [LongformerSequenceClassifierOutput](/docs/transformers/main/pt/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput) ou `tuple(torch.Tensor)` Um [LongformerSequenceClassifierOutput](/docs/transformers/main/pt/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput) 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 ([LongformerConfig](/docs/transformers/main/pt/model_doc/longformer#transformers.LongformerConfig)) e das entradas. O método forward de [LongformerForSequenceClassification](/docs/transformers/main/pt/model_doc/longformer#transformers.LongformerForSequenceClassification) 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 classificação (ou de regressão se config.num_labels==1). - **logits** (`torch.Tensor` de forma `(batch_size, config.num_labels)`) -- Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax). - **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (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 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 forma `(batch_size, num_heads, sequence_length, x + attention_window + 1)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção local após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Esses são os pesos de atenção de cada token na sequência para todos os tokens com atenção global (primeiros `x` valores) e para todos os tokens na janela de atenção (valores restantes `attention_window + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `global_attentions`. - **global_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) de forma `(batch_size, num_heads, sequence_length, x)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção global após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Esses são os pesos de atenção de cada token com atenção global para cada token na sequência. Exemplo de classificação de rótulo único: ```python >>> import torch >>> from transformers import AutoTokenizer, LongformerForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") >>> model = LongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096") >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") >>> with torch.no_grad(): ... logits = model(**inputs).logits >>> predicted_class_id = logits.argmax().item() >>> model.config.id2label[predicted_class_id] ... >>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)` >>> num_labels = len(model.config.id2label) >>> model = LongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096", num_labels=num_labels) >>> labels = torch.tensor([1]) >>> loss = model(**inputs, labels=labels).loss >>> round(loss.item(), 2) ... ``` Exemplo de classificação multirótulo: ```python >>> import torch >>> from transformers import AutoTokenizer, LongformerForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") >>> model = LongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096", problem_type="multi_label_classification") >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") >>> with torch.no_grad(): ... logits = model(**inputs).logits >>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5] >>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)` >>> num_labels = len(model.config.id2label) >>> model = LongformerForSequenceClassification.from_pretrained( ... "allenai/longformer-base-4096", num_labels=num_labels, problem_type="multi_label_classification" ... ) >>> labels = torch.sum( ... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1 ... ).to(torch.float) >>> loss = model(**inputs, labels=labels).loss ``` ## LongformerForMultipleChoice[[transformers.LongformerForMultipleChoice]] #### transformers.LongformerForMultipleChoice[[transformers.LongformerForMultipleChoice]] ```python transformers.LongformerForMultipleChoice(config: LongformerConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1966) **Parâmetros:** config ([LongformerConfig](/docs/transformers/main/pt/model_doc/longformer#transformers.LongformerConfig)) : 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 Longformer com uma cabeça de classificação de múltipla escolha no topo (uma camada linear sobre a saída agregada e um softmax), por exemplo, para as tarefas RocStories/SWAG. 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.LongformerForMultipleChoice.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, position_ids: 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/longformer/modeling_longformer.py#L1977) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, num_choices, sequence_length)`) : Índices dos tokens da sequência de entrada 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?](../glossary#input-ids) token_type_ids (`torch.LongTensor` de forma `(batch_size, num_choices, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`: - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*. [O que são IDs de tipo de token?](../glossary#token-type-ids) 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) global_attention_mask (`torch.Tensor` de forma `(batch_size, num_choices, sequence_length)`, *opcional*) : Máscara para decidir a atenção dada a cada token, atenção local ou atenção global. Tokens com atenção global prestam atenção a todos os outros tokens, e todos os outros tokens prestam atenção a eles. Isso é importante para o ajuste fino específico de tarefa, pois torna o modelo mais flexível na representação da tarefa. Por exemplo, para classificação, o token deve receber atenção global. Para QA, todos os tokens da pergunta também devem ter atenção global. Consulte o [artigo do Longformer](https://huggingface.co/papers/2004.05150) para mais detalhes. Valores de máscara selecionados em `[0, 1]`: - 0 para atenção local (atenção com janela deslizante), - 1 para atenção global (tokens que prestam atenção a todos os outros tokens, e todos os outros tokens prestam atenção a eles). labels (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos para calcular a perda de classificação de múltipla escolha. Os índices devem estar em `[0, ..., num_choices-1]`, onde `num_choices` é o tamanho da segunda dimensão dos tensores de entrada. (Veja `input_ids` acima) position_ids (`torch.LongTensor` de forma `(batch_size, num_choices, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.max_position_embeddings - 1]`. [O que são IDs de posição?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forma `(batch_size, num_choices, 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 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:** [LongformerMultipleChoiceModelOutput](/docs/transformers/main/pt/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput) ou `tuple(torch.Tensor)` Um [LongformerMultipleChoiceModelOutput](/docs/transformers/main/pt/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput) 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 ([LongformerConfig](/docs/transformers/main/pt/model_doc/longformer#transformers.LongformerConfig)) e das entradas. O método forward de [LongformerForMultipleChoice](/docs/transformers/main/pt/model_doc/longformer#transformers.LongformerForMultipleChoice) 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 classificação. - **logits** (`torch.Tensor` de forma `(batch_size, num_choices)`) -- *num_choices* é a segunda dimensão dos tensors de entrada. (veja *input_ids* acima). Pontuações de classificação (antes do SoftMax). - **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (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 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 forma `(batch_size, num_heads, sequence_length, x + attention_window + 1)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção local após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Esses são os pesos de atenção de cada token na sequência para todos os tokens com atenção global (primeiros `x` valores) e para todos os tokens na janela de atenção (valores restantes `attention_window + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `global_attentions`. - **global_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) de forma `(batch_size, num_heads, sequence_length, x)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção global após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Esses são os pesos de atenção de cada token com atenção global para cada token na sequência. Exemplo: ```python >>> from transformers import AutoTokenizer, LongformerForMultipleChoice >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") >>> model = LongformerForMultipleChoice.from_pretrained("allenai/longformer-base-4096") >>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced." >>> choice0 = "It is eaten with a fork and a knife." >>> choice1 = "It is eaten while held in the hand." >>> labels = torch.tensor(0).unsqueeze(0) # choice0 is correct (according to Wikipedia ;)), batch size 1 >>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True) >>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels) # batch size is 1 >>> # the linear classifier still needs to be trained >>> loss = outputs.loss >>> logits = outputs.logits ``` ## LongformerForTokenClassification[[transformers.LongformerForTokenClassification]] #### transformers.LongformerForTokenClassification[[transformers.LongformerForTokenClassification]] ```python transformers.LongformerForTokenClassification(config: LongformerConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1887) **Parâmetros:** config ([LongformerConfig](/docs/transformers/main/pt/model_doc/longformer#transformers.LongformerConfig)) : 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 transformer Longformer com uma cabeça de classificação de tokens no topo (uma camada linear sobre a saída dos estados ocultos), por exemplo, para tarefas de Reconhecimento de Entidades Nomeadas (NER). 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.LongformerForTokenClassification.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: 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/longformer/modeling_longformer.py#L1899) **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) global_attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para decidir a atenção dada a cada token, atenção local ou atenção global. Tokens com atenção global prestam atenção a todos os outros tokens, e todos os outros tokens prestam atenção a eles. Isso é importante para o ajuste fino específico de tarefa, pois torna o modelo mais flexível na representação da tarefa. Por exemplo, para classificação, o token deve receber atenção global. Para QA, todos os tokens da pergunta também devem ter atenção global. Consulte o [artigo do Longformer](https://huggingface.co/papers/2004.05150) para mais detalhes. Valores de máscara selecionados em `[0, 1]`: - 0 para atenção local (atenção com janela deslizante), - 1 para atenção global (tokens que prestam atenção a todos os outros tokens, e todos os outros tokens prestam atenção a eles). token_type_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`: - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*. [O que são IDs de tipo de token?](../glossary#token-type-ids) position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de classificação de tokens. Os índices devem estar em `[0, ..., config.num_labels - 1]`. 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:** [LongformerTokenClassifierOutput](/docs/transformers/main/pt/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput) ou `tuple(torch.Tensor)` Um [LongformerTokenClassifierOutput](/docs/transformers/main/pt/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput) 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 ([LongformerConfig](/docs/transformers/main/pt/model_doc/longformer#transformers.LongformerConfig)) e das entradas. O método forward de [LongformerForTokenClassification](/docs/transformers/main/pt/model_doc/longformer#transformers.LongformerForTokenClassification) 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 classificação. - **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_labels)`) -- Pontuações de classificação (antes do SoftMax). - **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (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 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 forma `(batch_size, num_heads, sequence_length, x + attention_window + 1)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção local após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Esses são os pesos de atenção de cada token na sequência para todos os tokens com atenção global (primeiros `x` valores) e para todos os tokens na janela de atenção (valores restantes `attention_window + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `global_attentions`. - **global_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) de forma `(batch_size, num_heads, sequence_length, x)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção global após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Esses são os pesos de atenção de cada token com atenção global para cada token na sequência. Exemplo: ```python >>> from transformers import AutoTokenizer, LongformerForTokenClassification >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") >>> model = LongformerForTokenClassification.from_pretrained("allenai/longformer-base-4096") >>> inputs = tokenizer( ... "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt" ... ) >>> with torch.no_grad(): ... logits = model(**inputs).logits >>> predicted_token_class_ids = logits.argmax(-1) >>> # Note that tokens are classified rather then input words which means that >>> # there might be more predicted token classes than words. >>> # Multiple token classes might account for the same word >>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]] >>> predicted_tokens_classes ... >>> labels = predicted_token_class_ids >>> loss = model(**inputs, labels=labels).loss >>> round(loss.item(), 2) ... ``` ## LongformerForQuestionAnswering[[transformers.LongformerForQuestionAnswering]] #### transformers.LongformerForQuestionAnswering[[transformers.LongformerForQuestionAnswering]] ```python transformers.LongformerForQuestionAnswering(config: LongformerConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1758) **Parâmetros:** config ([LongformerConfig](/docs/transformers/main/pt/model_doc/longformer#transformers.LongformerConfig)) : 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 transformer Longformer com uma cabeça de classificação de spans no topo para tarefas de resposta a perguntas extrativas, como SQuAD (uma camada linear no topo da saída dos hidden-states para calcular `span start logits` e `span end logits`). 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.LongformerForQuestionAnswering.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: 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/longformer/modeling_longformer.py#L1769) **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) global_attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para decidir a atenção dada a cada token, atenção local ou atenção global. Tokens com atenção global prestam atenção a todos os outros tokens, e todos os outros tokens prestam atenção a eles. Isso é importante para o ajuste fino específico de tarefa, pois torna o modelo mais flexível na representação da tarefa. Por exemplo, para classificação, o token deve receber atenção global. Para QA, todos os tokens da pergunta também devem ter atenção global. Consulte o [artigo do Longformer](https://huggingface.co/papers/2004.05150) para mais detalhes. Valores de máscara selecionados em `[0, 1]`: - 0 para atenção local (atenção com janela deslizante), - 1 para atenção global (tokens que prestam atenção a todos os outros tokens, e todos os outros tokens prestam atenção a eles). token_type_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`: - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*. [O que são IDs de tipo de token?](../glossary#token-type-ids) position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. start_positions (`torch.Tensor` de forma `(batch_size,)`, *opcional*) : Rótulos para a posição (índice) do início do trecho rotulado para o cálculo da perda de classificação de tokens. As posições são limitadas ao comprimento da sequência (`sequence_length`). Posições fora da sequência não são consideradas no cálculo da perda. end_positions (`torch.Tensor` de forma `(batch_size,)`, *opcional*) : Rótulos para a posição (índice) do final do trecho rotulado para o cálculo da perda de classificação de tokens. As posições são limitadas ao comprimento da sequência (`sequence_length`). Posições fora da sequência não são consideradas no cálculo da perda. 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:** [LongformerQuestionAnsweringModelOutput](/docs/transformers/main/pt/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput) ou `tuple(torch.Tensor)` Um [LongformerQuestionAnsweringModelOutput](/docs/transformers/main/pt/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput) 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 ([LongformerConfig](/docs/transformers/main/pt/model_doc/longformer#transformers.LongformerConfig)) e das entradas. O método forward de [LongformerForQuestionAnswering](/docs/transformers/main/pt/model_doc/longformer#transformers.LongformerForQuestionAnswering) 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` é fornecida) -- A perda total de extração de spans é a soma de uma Cross-Entropy para as posições de início e fim. - **start_logits** (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) -- Pontuações de início de span (antes do SoftMax). - **end_logits** (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) -- Pontuações de fim de span (antes do SoftMax). - **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (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 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 forma `(batch_size, num_heads, sequence_length, x + attention_window + 1)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção local após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Esses são os pesos de atenção de cada token na sequência para todos os tokens com atenção global (primeiros `x` valores) e para todos os tokens na janela de atenção (valores restantes `attention_window + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `global_attentions`. - **global_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) de forma `(batch_size, num_heads, sequence_length, x)`, onde `x` é o número de tokens com máscara de atenção global. Pesos de atenção global após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Esses são os pesos de atenção de cada token com atenção global para cada token na sequência. Exemplos: ```python >>> from transformers import AutoTokenizer, LongformerForQuestionAnswering >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-large-4096-finetuned-triviaqa") >>> model = LongformerForQuestionAnswering.from_pretrained("allenai/longformer-large-4096-finetuned-triviaqa") >>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet" >>> encoding = tokenizer(question, text, return_tensors="pt") >>> input_ids = encoding["input_ids"] >>> # default is local attention everywhere >>> # the forward method will automatically set global attention on question tokens >>> attention_mask = encoding["attention_mask"] >>> outputs = model(input_ids, attention_mask=attention_mask) >>> start_logits = outputs.start_logits >>> end_logits = outputs.end_logits >>> all_tokens = tokenizer.convert_ids_to_tokens(input_ids[0].tolist()) >>> answer_tokens = all_tokens[torch.argmax(start_logits) : torch.argmax(end_logits) + 1] >>> answer = tokenizer.decode( ... tokenizer.convert_tokens_to_ids(answer_tokens) ... ) # remove space prepending space token ```