# LUKE

## Visão geral

O modelo LUKE foi proposto em [LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention](https://huggingface.co/papers/2010.01057) por Ikuya Yamada, Akari Asai, Hiroyuki Shindo, Hideaki Takeda e Yuji Matsumoto. Ele é baseado no RoBERTa e adiciona embeddings de entidades, além de um mecanismo de autoatenção consciente de entidades, o que ajuda a melhorar o desempenho em diversas tarefas downstream que envolvem raciocínio sobre entidades, como reconhecimento de entidades nomeadas, resposta a perguntas extrativa e no estilo cloze, tipagem de entidades e classificação de relações.

O resumo do artigo é o seguinte:

*Representações de entidades são úteis em tarefas de linguagem natural que envolvem entidades. Neste artigo, propomos novas representações contextualizadas pré-treinadas de palavras e entidades baseadas no transformador bidirecional. O modelo proposto trata palavras e entidades em um texto dado como tokens independentes e produz representações contextualizadas deles. Nosso modelo é treinado usando uma nova tarefa de pré-treinamento baseada no modelo de linguagem mascarado do BERT. A tarefa envolve prever palavras e entidades mascaradas aleatoriamente em um grande corpus anotado com entidades recuperado da Wikipédia. Também propomos um mecanismo de autoatenção consciente de entidades, que é uma extensão do mecanismo de autoatenção do transformador e considera os tipos de tokens (palavras ou entidades) ao calcular as pontuações de atenção. O modelo proposto atinge um desempenho empírico impressionante em uma ampla variedade de tarefas relacionadas a entidades. Em particular, ele obtém resultados de estado da arte em cinco conjuntos de dados bem conhecidos: Open Entity (tipagem de entidades), TACRED (classificação de relações), CoNLL-2003 (reconhecimento de entidades nomeadas), ReCoRD (resposta a perguntas no estilo cloze) e SQuAD 1.1 (resposta a perguntas extrativa).*

Este modelo foi contribuído por [ikuyamada](https://huggingface.co/ikuyamada) e [nielsr](https://huggingface.co/nielsr). O código original pode ser encontrado [aqui](https://github.com/studio-ousia/luke).

## Dicas de uso

- Esta implementação é a mesma de [RobertaModel](/docs/transformers/main/pt/model_doc/roberta#transformers.RobertaModel), com a adição de embeddings de entidades e de um mecanismo de autoatenção consciente de entidades, o que melhora o desempenho em tarefas que envolvem raciocínio sobre entidades.
- O LUKE trata as entidades como tokens de entrada; portanto, ele recebe `entity_ids`, `entity_attention_mask`, `entity_token_type_ids` e `entity_position_ids` como entradas extras. Você pode obtê-los usando o [LukeTokenizer](/docs/transformers/main/pt/model_doc/luke#transformers.LukeTokenizer).
- [LukeTokenizer](/docs/transformers/main/pt/model_doc/luke#transformers.LukeTokenizer) recebe `entities` e `entity_spans` (posições de início e fim baseadas em caracteres das entidades no texto de entrada) como entrada adicional. `entities` geralmente consistem em entidades [MASK] ou entidades da Wikipédia. A breve descrição ao inserir essas entidades é a seguinte:

  - *Inserindo entidades [MASK] para calcular representações de entidades*: a entidade [MASK] é usada para mascarar as entidades a serem previstas durante o pré-treinamento. Quando o LUKE recebe a entidade [MASK], ele tenta prever a entidade original, reunindo as informações sobre a entidade a partir do texto de entrada. Portanto, a entidade [MASK] pode ser usada para lidar com tarefas de nível inferior que exigem as informações das entidades no texto, como tipagem de entidades, classificação de relações e reconhecimento de entidades nomeadas.
  - *Entrada de entidades da Wikipédia para calcular representações de tokens enriquecidas com conhecimento*: o LUKE aprende informações ricas (ou conhecimento) sobre entidades da Wikipédia durante o pré-treinamento e armazena essas informações em seu embedding de entidade. Ao usar entidades da Wikipédia como tokens de entrada, o LUKE produz representações de tokens enriquecidas com as informações armazenadas nos embeddings dessas entidades. Isso é particularmente eficaz para tarefas que exigem conhecimento do mundo real, como resposta a perguntas.

- Há três modelos de cabeçalho para o caso de uso anterior:

  - [LukeForEntityClassification](/docs/transformers/main/pt/model_doc/luke#transformers.LukeForEntityClassification), para tarefas de classificação de uma única entidade em um texto de entrada, como a tipagem de entidades, por exemplo, o [Open Entity dataset](https://www.cs.utexas.edu/~eunsol/html_pages/open_entity.html). Este modelo adiciona uma camada linear sobre a representação de saída da entidade.
  - [LukeForEntityPairClassification](/docs/transformers/main/pt/model_doc/luke#transformers.LukeForEntityPairClassification), para tarefas de classificação da relação entre duas entidades, como a classificação de relações, por exemplo, no [conjunto de dados TACRED](https://nlp.stanford.edu/projects/tacred/). Este modelo aplica uma camada linear sobre a representação de saída concatenada do par de entidades fornecidas.
  - [LukeForEntitySpanClassification](/docs/transformers/main/pt/model_doc/luke#transformers.LukeForEntitySpanClassification), para tarefas de classificação de sequências de spans de entidades, como o reconhecimento de entidades nomeadas (NER). Este modelo adiciona uma camada linear sobre as representações de saída das entidades. Você pode abordar o NER usando este modelo ao inserir no modelo todos os spans de entidades possíveis no texto.

  [LukeTokenizer](/docs/transformers/main/pt/model_doc/luke#transformers.LukeTokenizer) possui um argumento `task`, que permite criar facilmente uma entrada para esses modelos de head especificando `task="entity_classification"`, `task="entity_pair_classification"` ou `task="entity_span_classification"`. Consulte o código de exemplo de cada modelo de head.

Exemplo de uso:

```python
from transformers import LukeForEntityPairClassification, LukeModel, LukeTokenizer

model = LukeModel.from_pretrained("studio-ousia/luke-base", device_map="auto")
tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-base")
# Example 1: Computing the contextualized entity representation corresponding to the entity mention "Beyoncé"

text = "Beyoncé lives in Los Angeles."
entity_spans = [(0, 7)]  # character-based entity span corresponding to "Beyoncé"
inputs = tokenizer(text, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt").to(model.device)
outputs = model(**inputs)
word_last_hidden_state = outputs.last_hidden_state
entity_last_hidden_state = outputs.entity_last_hidden_state
# Example 2: Inputting Wikipedia entities to obtain enriched contextualized representations

entities = [
    "Beyoncé",
    "Los Angeles",
]  # Wikipedia entity titles corresponding to the entity mentions "Beyoncé" and "Los Angeles"
entity_spans = [(0, 7), (17, 28)]  # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
inputs = tokenizer(text, entities=entities, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt").to(model.device)
outputs = model(**inputs)
word_last_hidden_state = outputs.last_hidden_state
entity_last_hidden_state = outputs.entity_last_hidden_state
# Example 3: Classifying the relationship between two entities using LukeForEntityPairClassification head model

model = LukeForEntityPairClassification.from_pretrained("studio-ousia/luke-large-finetuned-tacred", device_map="auto")
tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
entity_spans = [(0, 7), (17, 28)]  # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt").to(model.device)
outputs = model(**inputs)
logits = outputs.logits
predicted_class_idx = int(logits[0].argmax())
print("Predicted class:", model.config.id2label[predicted_class_idx])
```

## Recursos

- [Um notebook de demonstração sobre como fazer o ajuste fino de [LukeForEntityPairClassification](/docs/transformers/main/pt/model_doc/luke#transformers.LukeForEntityPairClassification) para classificação de relações](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/LUKE)
- [Notebooks que mostram como reproduzir os resultados relatados no artigo com a implementação do LUKE da HuggingFace](https://github.com/studio-ousia/luke/tree/master/notebooks)
- [Guia da tarefa de classificação de texto](../tasks/sequence_classification)
- [Guia de tarefas de classificação de tokens](../tasks/token_classification)
- [Guia da tarefa de resposta a perguntas](../tasks/question_answering)
- [Guia da tarefa de modelagem de linguagem mascarada](../tasks/masked_language_modeling)
- [Guia de tarefas de múltipla escolha](../tasks/multiple_choice)

## LukeConfig[[transformers.LukeConfig]]

#### transformers.LukeConfig[[transformers.LukeConfig]]

```python
transformers.LukeConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 50267, entity_vocab_size: int = 500000, hidden_size: int = 768, entity_emb_size: int = 256, 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, use_entity_aware_attention: bool = True, classifier_dropout: float | int | None = None, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, tie_word_embeddings: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/configuration_luke.py#L24)

**Parâmetros:**

vocab_size (`int`, *opcional*, padrão `50267`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`.

entity_vocab_size (`int`, *opcional*, padrão 500000) : Tamanho do vocabulário de entidades do modelo LUKE. Define o número de entidades diferentes que podem ser representadas pelos `entity_ids` passados ao chamar [LukeModel](/docs/transformers/main/pt/model_doc/luke#transformers.LukeModel).

hidden_size (`int`, *opcional*, padrão `768`) : Dimensão das representações ocultas.

entity_emb_size (`int`, *opcional*, padrão 256) : O número de dimensões do embedding de entidade.

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.

use_entity_aware_attention (`bool`, *opcional*, padrão `True`) : Indica se o modelo deve ou não usar o mecanismo de autoatenção consciente de entidades proposto em [LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention (Yamada et al.)](https://huggingface.co/papers/2010.01057).

classifier_dropout (`Union[float, int]`, *opcional*) : A taxa de dropout para o classificador.

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.

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 LukeModel. Ela é usada para instanciar um modelo Luke 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 [studio-ousia/luke-base](https://huggingface.co/studio-ousia/luke-base)

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.

Exemplos:

```python
>>> from transformers import LukeConfig, LukeModel

>>> # Initializing a LUKE configuration
>>> configuration = LukeConfig()

>>> # Initializing a model from the configuration
>>> model = LukeModel(configuration)

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

## LukeTokenizer[[transformers.LukeTokenizer]]

#### transformers.LukeTokenizer[[transformers.LukeTokenizer]]

```python
transformers.LukeTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, entity_vocab: str | dict | list | None = None, errors = 'replace', bos_token = '<s>', eos_token = '</s>', sep_token = '</s>', cls_token = '<s>', unk_token = '<unk>', pad_token = '<pad>', mask_token = '<mask>', add_prefix_space = False, task = None, max_entity_length = 32, max_mention_length = 30, entity_1_token = '<ent>', entity_2_token = '<ent2>', entity_unk_token = '[UNK]', entity_pad_token = '[PAD]', entity_mask_token = '[MASK]', entity_mask2_token = '[MASK2]', **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/tokenization_luke.py#L131)

**Parâmetros:**

vocab_file (`str`) : Caminho para o arquivo de vocabulário.

merges_file (`str`) : Caminho para o arquivo de mesclagens.

vocab (`str` ou `dict[str, int]`, *opcional*) : Dicionário de vocabulário personalizado. Se não for fornecido, o vocabulário é carregado a partir de `vocab_file`.

merges (`str` ou `list[str]`, *opcional*) : Lista de mesclagens personalizada. Se não for fornecida, as mesclagens são carregadas de `merges_file`.

entity_vocab_file (`str`) : Caminho para o arquivo de vocabulário de entidades.

task (`str`, *opcional*) : Tarefa para a qual você deseja preparar sequências. Uma de `"entity_classification"`, `"entity_pair_classification"` ou `"entity_span_classification"`. Se você especificar este argumento, a sequência de entidades é criada automaticamente com base no(s) span(s) de entidade fornecido(s).

max_entity_length (`int`, *opcional*, padrão 32) : O comprimento máximo de `entity_ids`.

max_mention_length (`int`, *opcional*, padrão 30) : O número máximo de tokens dentro de um intervalo de entidade.

entity_1_token (`str`, *opcional*, padrão `<ent>`) : O token especial usado para representar um trecho de entidade em uma sequência de tokens de palavras. Este token é usado apenas quando `task` está definido como `"entity_classification"` ou `"entity_pair_classification"`.

entity_2_token (`str`, *opcional*, padrão `<ent2>`) : O token especial usado para representar um intervalo de entidade em uma sequência de tokens de palavras. Este token é usado apenas quando `task` está definido como `"entity_pair_classification"`.

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 `"<s>"`) : 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 `"</s>"`) : 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 `"</s>"`) : 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 `"<s>"`) : 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 `"<unk>"`) : O token desconhecido. Um token que não está no vocabulário não pode ser convertido em um ID e é definido como este token em vez disso.

pad_token (`str`, *opcional*, padrão `"<pad>"`) : O token usado para preenchimento, por exemplo, ao agrupar sequências de comprimentos diferentes.

mask_token (`str`, *opcional*, padrão `"<mask>"`) : O token usado para mascarar valores. Este é o token utilizado ao treinar este modelo com modelagem de linguagem mascarada. É o token que o modelo tentará prever.

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 LUKE detecta o início das palavras pelo espaço que as precede).

Constrói um tokenizador LUKE, derivado do tokenizador GPT-2, usando Byte-Pair-Encoding em nível de bytes.

Este tokenizer foi treinado para tratar espaços como partes dos tokens (um pouco como o sentencepiece), de modo que uma palavra será

ser codificado de forma diferente, dependendo se está no início da frase (sem espaço) ou não:

```python
>>> from transformers import LukeTokenizer

>>> tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-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 adiciona um espaço antes de cada palavra (inclusive a primeira).

Este tokenizer herda de [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend), que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses métodos. Ele também cria sequências de entidades, a saber `entity_ids`, `entity_attention_mask`, `entity_token_type_ids` e `entity_position_ids`, para serem usadas pelo modelo LUKE.

#### __call__[[transformers.LukeTokenizer.__call__]]

```python
__call__(text: str | list[str], text_pair: str | list[str] | None = None, entity_spans: list[tuple[int, int]] | list[list[tuple[int, int]]] | None = None, entity_spans_pair: list[tuple[int, int]] | list[list[tuple[int, int]]] | None = None, entities: list[str] | list[list[str]] | None = None, entities_pair: list[str] | list[list[str]] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None, max_length: int | None = None, max_entity_length: int | None = None, stride: int = 0, is_split_into_words: bool | None = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/tokenization_luke.py#L411)

**Retorna:** [BatchEncoding](/docs/transformers/main/pt/main_classes/tokenizer#transformers.BatchEncoding)

Um [BatchEncoding](/docs/transformers/main/pt/main_classes/tokenizer#transformers.BatchEncoding) com os seguintes campos:

- **input_ids** -- Lista de ids de tokens a serem fornecidos a um modelo.

  [O que são IDs de entrada?](../glossary#input-ids)

- **token_type_ids** -- Lista de ids de tipo de token a serem fornecidos a um modelo (quando `return_token_type_ids=True` ou se *"token_type_ids"* estiver em `self.model_input_names`).

  [O que são IDs de tipo de token?](../glossary#token-type-ids)

- **attention_mask** -- Lista de índices que especifica quais tokens devem ser considerados pelo modelo (quando `return_attention_mask=True` ou se *"attention_mask"* estiver em `self.model_input_names`).

  [O que são máscaras de atenção?](../glossary#attention-mask)

- **entity_ids** -- Lista de ids de entidades a serem fornecidas a um modelo.

  [O que são IDs de entrada?](../glossary#input-ids)

- **entity_position_ids** -- Lista de posições de entidades na sequência de entrada a ser fornecida a um modelo.

- **entity_token_type_ids** -- Lista de ids de tipo de token de entidade a serem fornecidos a um modelo (quando `return_token_type_ids=True` ou se *"entity_token_type_ids"* estiver em `self.model_input_names`).

  [O que são IDs de tipo de token?](../glossary#token-type-ids)

- **entity_attention_mask** -- Lista de índices que especifica quais entidades devem ser consideradas pelo modelo (quando `return_attention_mask=True` ou se *"entity_attention_mask"* estiver em `self.model_input_names`).

  [O que são máscaras de atenção?](../glossary#attention-mask)

- **entity_start_positions** -- Lista das posições iniciais das entidades na sequência de tokens de palavras (quando `task="entity_span_classification"`).
- **entity_end_positions** -- Lista das posições finais das entidades na sequência de tokens de palavras (quando `task="entity_span_classification"`).
- **overflowing_tokens** -- Lista de sequências de tokens excedentes (quando um `max_length` é especificado e `return_overflowing_tokens=True`).
- **num_truncated_tokens** -- Número de tokens truncados (quando um `max_length` é especificado e `return_overflowing_tokens=True`).
- **special_tokens_mask** -- Lista de 0s e 1s, em que 1 especifica tokens especiais adicionados e 0 especifica tokens regulares da sequência (quando `add_special_tokens=True` e `return_special_tokens_mask=True`).
- **length** -- O comprimento das entradas (quando `return_length=True`)

add_special_tokens (`bool`, *opcional*, padrão `True`): Indica se tokens especiais devem ser adicionados ao codificar as sequências. Isso utiliza a função subjacente `PretrainedTokenizerBase.build_inputs_with_special_tokens`, que define quais tokens são adicionados automaticamente aos ids de entrada. Isso é útil se você deseja adicionar automaticamente tokens `bos` ou `eos`. padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, padrão `False`): Ativa e controla o padding. Aceita os seguintes valores:

- `True` ou `'longest'`: Preenche até a sequência mais longa do lote (ou não aplica preenchimento se apenas uma sequência for fornecida).
- `'max_length'`: Preenche até o comprimento máximo especificado pelo argumento `max_length` ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.
- `False` ou `'do_not_pad'` (padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).
truncation (`bool`, `str` ou [TruncationStrategy](/docs/transformers/main/pt/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, padrão `False`): Ativa e controla a truncagem. Aceita os seguintes valores:

- `True` ou `'longest_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. Isso trunca token por token, removendo um token da sequência mais longa do par, se um par de sequências (ou um lote de pares) for fornecido.
- `'only_first'`: Trunca para o comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo aceitável de entrada do modelo, caso esse argumento não seja fornecido. Isso trunca apenas a primeira sequência de um par, se um par de sequências (ou um lote de pares) for fornecido.
- `'only_second'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a segunda sequência de um par, se um par de sequências (ou um lote de pares) for fornecido.
- `False` ou `'do_not_truncate'` (padrão): Sem truncamento (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada aceito pelo modelo).
max_length (`int`, *opcional*): Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/padronização.

If left unset or set to `None`, this will use the predefined model maximum length if a maximum length is required by one of the truncation/padding parameters. If the model has no specific maximum input length (like XLNet) truncation/padding to a maximum length will be deactivated. stride (`int`, *optional*, defaults to 0): If set to a number along with `max_length`, the overflowing tokens returned when `return_overflowing_tokens=True` will contain some tokens from the end of the truncated sequence returned to provide some overlap between truncated and overflowing sequences. The value of this argument defines the number of overlapping tokens. is_split_into_words (`bool`, *optional*, defaults to `False`): Whether or not the input is already pre-tokenized (e.g., split into words). If set to `True`, the tokenizer assumes the input is already split into words (for instance, by splitting it on whitespace) which it will tokenize. This is useful for NER or token classification. pad_to_multiple_of (`int`, *optional*): If set will pad the sequence to a multiple of the provided value. Requires `padding` to be activated. This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability `>= 7.5` (Volta). padding_side (`str`, *optional*): The side on which the model should have padding applied. Should be selected between ['right', 'left']. Default value is picked from the class attribute of the same name. return_tensors (`str` or [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *optional*): If set, will return tensors instead of list of python integers. Acceptable values are:

- `'pt'`: Retorna objetos `torch.Tensor` do PyTorch.
- `'np'`: Retorna objetos `np.ndarray` do Numpy.

return_token_type_ids (`bool`, *opcional*): Se deve retornar os IDs de tipo de token. Se mantido no padrão, retornará os IDs de tipo de token de acordo com o padrão do tokenizer específico, definido pelo atributo `return_outputs`.

[O que são IDs de tipo de token?](../glossary#token-type-ids) return_attention_mask (`bool`, *opcional*): Se deve retornar a máscara de atenção. Se mantido no padrão, retornará a máscara de atenção de acordo com o padrão do tokenizer específico, definido pelo atributo `return_outputs`.

[O que são máscaras de atenção?](../glossary#attention-mask) return_overflowing_tokens (`bool`, *opcional*, padrão `False`): Se deve ou não retornar sequências de tokens excedentes. Se um par de sequências de ids de entrada (ou um lote de pares) for fornecido com `truncation_strategy = longest_first` ou `True`, um erro será lançado em vez de retornar tokens excedentes. return_special_tokens_mask (`bool`, *opcional*, padrão `False`): Se deve ou não retornar informações da máscara de tokens especiais. return_offsets_mapping (`bool`, *opcional*, padrão `False`): Se deve ou não retornar `(char_start, char_end)` para cada token.

Isso está disponível apenas em tokenizadores rápidos que herdam de [PreTrainedTokenizerFast](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend); se estiver usando o tokenizador em Python, este método lançará `NotImplementedError`. return_length (`bool`, *opcional*, padrão `False`): Indica se os comprimentos das entradas codificadas devem ser retornados. verbose (`bool`, *opcional*, padrão `True`): Indica se mais informações e avisos devem ser exibidos. **kwargs: passados para o método `self.tokenize()`

#### save_vocabulary[[transformers.LukeTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L546)

## LukeModel[[transformers.LukeModel]]

#### transformers.LukeModel[[transformers.LukeModel]]

```python
transformers.LukeModel(config: LukeConfig, add_pooling_layer: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L788)

**Parâmetros:**

config ([LukeConfig](/docs/transformers/main/pt/model_doc/luke#transformers.LukeConfig)) : 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

A saída do transformador do modelo LUKE básico, que gera estados ocultos brutos para tokens de palavras e entidades, sem

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.LukeModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = 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/luke/modeling_luke.py#L818)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas porções das entradas. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

entity_ids (`torch.LongTensor` de forma `(batch_size, entity_length)`) : Índices dos tokens de entidade no vocabulário de entidades. 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.

entity_attention_mask (`torch.Tensor` de forma `(batch_size, entity_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de entidade de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens de entidade que **não estão mascarados**, - 0 para tokens de entidade que estão **mascarados**.

entity_token_type_ids (`torch.LongTensor` de forma `(batch_size, entity_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes dos tokens de entrada da entidade. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de entidade da *parte A*, - 1 corresponde a um token de entidade da *parte B*.

entity_position_ids (`torch.LongTensor` de forma `(batch_size, entity_length, max_mention_length)`, *opcional*) : Índices das posições de cada entidade de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.max_position_embeddings - 1]`.

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:** `BaseLukeModelOutputWithPooling` ou `tuple(torch.Tensor)`

Um `BaseLukeModelOutputWithPooling` 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 ([LukeConfig](/docs/transformers/main/pt/model_doc/luke#transformers.LukeConfig)) e das entradas.

O método forward do [LukeModel](/docs/transformers/main/pt/model_doc/luke#transformers.LukeModel) 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.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **entity_last_hidden_state** (`torch.Tensor` de forma `(batch_size, entity_length, hidden_size)`) -- Sequência de estados ocultos de entidades na saída da última camada do modelo.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings + um para a saída de cada camada) com forma `(batch_size, entity_length, hidden_size)`. Estados ocultos das entidades do modelo na saída de cada camada, além das saídas dos embeddings iniciais das entidades.

Exemplos:

```python
>>> from transformers import AutoTokenizer, LukeModel

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeModel.from_pretrained("studio-ousia/luke-base")
# Compute the contextualized entity representation corresponding to the entity mention "Beyoncé"

>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [(0, 7)]  # character-based entity span corresponding to "Beyoncé"

>>> encoding = tokenizer(text, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt")
>>> outputs = model(**encoding)
>>> word_last_hidden_state = outputs.last_hidden_state
>>> entity_last_hidden_state = outputs.entity_last_hidden_state
# Input Wikipedia entities to obtain enriched contextualized representations of word tokens

>>> text = "Beyoncé lives in Los Angeles."
>>> entities = [
...     "Beyoncé",
...     "Los Angeles",
... ]  # Wikipedia entity titles corresponding to the entity mentions "Beyoncé" and "Los Angeles"
>>> entity_spans = [
...     (0, 7),
...     (17, 28),
... ]  # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"

>>> encoding = tokenizer(
...     text, entities=entities, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt"
... )
>>> outputs = model(**encoding)
>>> word_last_hidden_state = outputs.last_hidden_state
>>> entity_last_hidden_state = outputs.entity_last_hidden_state
```

## LukeForMaskedLM[[transformers.LukeForMaskedLM]]

#### transformers.LukeForMaskedLM[[transformers.LukeForMaskedLM]]

```python
transformers.LukeForMaskedLM(config: LukeConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1019)

**Parâmetros:**

config ([LukeConfig](/docs/transformers/main/pt/model_doc/luke#transformers.LukeConfig)) : 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 LUKE com uma cabeça de modelagem de linguagem e uma cabeça de previsão de entidades no topo para modelagem de linguagem mascarada e previsão de entidades mascaradas.

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.LukeForMaskedLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.LongTensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, labels: typing.Optional[torch.LongTensor] = None, entity_labels: typing.Optional[torch.LongTensor] = 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/luke/modeling_luke.py#L1044)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas porções das entradas. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

entity_ids (`torch.LongTensor` de forma `(batch_size, entity_length)`) : Índices dos tokens de entidade no vocabulário de entidades. 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.

entity_attention_mask (`torch.Tensor` de forma `(batch_size, entity_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de entidade de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens de entidade que **não estão mascarados**, - 0 para tokens de entidade que estão **mascarados**.

entity_token_type_ids (`torch.LongTensor` de forma `(batch_size, entity_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes dos tokens de entrada da entidade. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de entidade da *parte A*, - 1 corresponde a um token de entidade da *parte B*.

entity_position_ids (`torch.LongTensor` de forma `(batch_size, entity_length, max_mention_length)`, *opcional*) : Índices das posições de cada entidade de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.max_position_embeddings - 1]`.

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]`.

entity_labels (`torch.LongTensor` de forma `(batch_size, entity_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]`.

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:** `LukeMaskedLMOutput` ou `tuple(torch.Tensor)`

Um `LukeMaskedLMOutput` 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 ([LukeConfig](/docs/transformers/main/pt/model_doc/luke#transformers.LukeConfig)) e das entradas.

O método forward de [LukeForMaskedLM](/docs/transformers/main/pt/model_doc/luke#transformers.LukeForMaskedLM) 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) -- A soma da perda de modelagem de linguagem mascarada (MLM) e da perda de previsão de entidade.
- **mlm_loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem mascarada (MLM).
- **mep_loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de previsão de entidade mascarada (MEP).
- **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).
- **entity_logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de previsão de entidades (pontuações para cada token do vocabulário de entidades 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 opcionais do embedding inicial.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings + um para a saída de cada camada) com forma `(batch_size, entity_length, hidden_size)`. Estados ocultos das entidades do modelo na saída de cada camada, além das saídas dos embeddings iniciais das entidades.
- **attentions** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplo:

```python
>>> from transformers import AutoTokenizer, LukeForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForMaskedLM.from_pretrained("studio-ousia/luke-base")

>>> inputs = tokenizer("The capital of France is <mask>.", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # retrieve index of <mask>
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> tokenizer.decode(predicted_token_id)
...

>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-<mask> tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

>>> outputs = model(**inputs, labels=labels)
>>> round(outputs.loss.item(), 2)
...
```

## LukeForEntityClassification[[transformers.LukeForEntityClassification]]

#### transformers.LukeForEntityClassification[[transformers.LukeForEntityClassification]]

```python
transformers.LukeForEntityClassification(config: LukeConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1162)

**Parâmetros:**

config ([LukeConfig](/docs/transformers/main/pt/model_doc/luke#transformers.LukeConfig)) : 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 LUKE com uma cabeça de classificação no topo (uma camada linear no topo do estado oculto do primeiro token da entidade) para tarefas de classificação de entidades, como Open Entity.

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.LukeForEntityClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = 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/luke/modeling_luke.py#L1175)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas porções das entradas. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

entity_ids (`torch.LongTensor` de forma `(batch_size, entity_length)`) : Índices dos tokens de entidade no vocabulário de entidades. 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.

entity_attention_mask (`torch.Tensor` de forma `(batch_size, entity_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de entidade de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens de entidade que **não estão mascarados**, - 0 para tokens de entidade que estão **mascarados**.

entity_token_type_ids (`torch.LongTensor` de forma `(batch_size, entity_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes dos tokens de entrada da entidade. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de entidade da *parte A*, - 1 corresponde a um token de entidade da *parte B*.

entity_position_ids (`torch.LongTensor` de forma `(batch_size, entity_length, max_mention_length)`, *opcional*) : Índices das posições de cada entidade de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.max_position_embeddings - 1]`.

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,)` ou `(batch_size, num_labels)`, *opcional*) : Rótulos para o cálculo da perda de classificação. Se a forma for `(batch_size,)`, a perda de entropia cruzada é usada para a classificação de rótulo único. Nesse caso, os rótulos devem conter os índices que devem estar em `[0, ..., config.num_labels - 1]`. Se a forma for `(batch_size, num_labels)`, a perda de entropia cruzada binária é usada para a classificação de múltiplos rótulos. Nesse caso, os rótulos devem conter apenas `[0, 1]`, em que 0 e 1 indicam falso e verdadeiro, respectivamente.

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:** `EntityClassificationOutput` ou `tuple(torch.Tensor)`

Um `EntityClassificationOutput` 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 ([LukeConfig](/docs/transformers/main/pt/model_doc/luke#transformers.LukeConfig)) e das entradas.

O método forward de [LukeForEntityClassification](/docs/transformers/main/pt/model_doc/luke#transformers.LukeForEntityClassification) 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, 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.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings + um para a saída de cada camada) com forma `(batch_size, entity_length, hidden_size)`. Estados ocultos das entidades do modelo na saída de cada camada, além das saídas dos embeddings iniciais das entidades.
- **attentions** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplos:

```python
>>> from transformers import AutoTokenizer, LukeForEntityClassification

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-open-entity")
>>> model = LukeForEntityClassification.from_pretrained("studio-ousia/luke-large-finetuned-open-entity")

>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [(0, 7)]  # character-based entity span corresponding to "Beyoncé"
>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: person
```

## LukeForEntityPairClassification[[transformers.LukeForEntityPairClassification]]

#### transformers.LukeForEntityPairClassification[[transformers.LukeForEntityPairClassification]]

```python
transformers.LukeForEntityPairClassification(config: LukeConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1291)

**Parâmetros:**

config ([LukeConfig](/docs/transformers/main/pt/model_doc/luke#transformers.LukeConfig)) : 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 LUKE com uma cabeça de classificação no topo (uma camada linear sobre os estados ocultos dos dois tokens de entidade) para tarefas de classificação de pares de entidades, como o TACRED.

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.LukeForEntityPairClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = 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/luke/modeling_luke.py#L1304)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas porções das entradas. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

entity_ids (`torch.LongTensor` de forma `(batch_size, entity_length)`) : Índices dos tokens de entidade no vocabulário de entidades. 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.

entity_attention_mask (`torch.Tensor` de forma `(batch_size, entity_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de entidade de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens de entidade que **não estão mascarados**, - 0 para tokens de entidade que estão **mascarados**.

entity_token_type_ids (`torch.LongTensor` de forma `(batch_size, entity_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes dos tokens de entrada da entidade. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de entidade da *parte A*, - 1 corresponde a um token de entidade da *parte B*.

entity_position_ids (`torch.LongTensor` de forma `(batch_size, entity_length, max_mention_length)`, *opcional*) : Índices das posições de cada entidade de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.max_position_embeddings - 1]`.

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,)` ou `(batch_size, num_labels)`, *opcional*) : Rótulos para o cálculo da perda de classificação. Se a forma for `(batch_size,)`, a perda de entropia cruzada é usada para a classificação de rótulo único. Nesse caso, os rótulos devem conter os índices que devem estar em `[0, ..., config.num_labels - 1]`. Se a forma for `(batch_size, num_labels)`, a perda de entropia cruzada binária é usada para a classificação de múltiplos rótulos. Nesse caso, os rótulos devem conter apenas `[0, 1]`, em que 0 e 1 indicam falso e verdadeiro, respectivamente.

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:** `EntityPairClassificationOutput` ou `tuple(torch.Tensor)`

Um `EntityPairClassificationOutput` 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 ([LukeConfig](/docs/transformers/main/pt/model_doc/luke#transformers.LukeConfig)) e das entradas.

O método forward de [LukeForEntityPairClassification](/docs/transformers/main/pt/model_doc/luke#transformers.LukeForEntityPairClassification) 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, 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.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings + um para a saída de cada camada) com forma `(batch_size, entity_length, hidden_size)`. Estados ocultos das entidades do modelo na saída de cada camada, além das saídas dos embeddings iniciais das entidades.
- **attentions** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplos:

```python
>>> from transformers import AutoTokenizer, LukeForEntityPairClassification

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
>>> model = LukeForEntityPairClassification.from_pretrained("studio-ousia/luke-large-finetuned-tacred")

>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [
...     (0, 7),
...     (17, 28),
... ]  # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: per:cities_of_residence
```

## LukeForEntitySpanClassification[[transformers.LukeForEntitySpanClassification]]

#### transformers.LukeForEntitySpanClassification[[transformers.LukeForEntitySpanClassification]]

```python
transformers.LukeForEntitySpanClassification(config: LukeConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1425)

**Parâmetros:**

config ([LukeConfig](/docs/transformers/main/pt/model_doc/luke#transformers.LukeConfig)) : 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 LUKE com uma cabeça de classificação de spans no topo (uma camada linear sobre os estados ocultos de saída) para tarefas como reconhecimento de entidades nomeadas.

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.LukeForEntitySpanClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.LongTensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, entity_start_positions: typing.Optional[torch.LongTensor] = None, entity_end_positions: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = 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/luke/modeling_luke.py#L1438)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas porções das entradas. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

entity_ids (`torch.LongTensor` de forma `(batch_size, entity_length)`) : Índices dos tokens de entidade no vocabulário de entidades. 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.

entity_attention_mask (`torch.Tensor` de forma `(batch_size, entity_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de entidade de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens de entidade que **não estão mascarados**, - 0 para tokens de entidade que estão **mascarados**.

entity_token_type_ids (`torch.LongTensor` de forma `(batch_size, entity_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes dos tokens de entrada da entidade. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de entidade da *parte A*, - 1 corresponde a um token de entidade da *parte B*.

entity_position_ids (`torch.LongTensor` de forma `(batch_size, entity_length, max_mention_length)`, *opcional*) : Índices das posições de cada entidade de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.max_position_embeddings - 1]`.

entity_start_positions (`torch.LongTensor`, *opcional*) : As posições iniciais das entidades na sequência de tokens de palavras.

entity_end_positions (`torch.LongTensor`, *opcional*) : As posições finais das entidades na sequência de tokens de palavras.

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, entity_length)` ou `(batch_size, entity_length, num_labels)`, *opcional*) : Rótulos para o cálculo da perda de classificação. Se a forma for `(batch_size, entity_length)`, a perda de entropia cruzada é usada para a classificação de rótulo único. Nesse caso, os rótulos devem conter os índices que devem estar em `[0, ..., config.num_labels - 1]`. Se a forma for `(batch_size, entity_length, num_labels)`, a perda de entropia cruzada binária é usada para a classificação de múltiplos rótulos. Nesse caso, os rótulos devem conter apenas `[0, 1]`, em que 0 e 1 indicam falso e verdadeiro, respectivamente.

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:** `EntitySpanClassificationOutput` ou `tuple(torch.Tensor)`

Um `EntitySpanClassificationOutput` 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 ([LukeConfig](/docs/transformers/main/pt/model_doc/luke#transformers.LukeConfig)) e das entradas.

O método forward de [LukeForEntitySpanClassification](/docs/transformers/main/pt/model_doc/luke#transformers.LukeForEntitySpanClassification) 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.
- **logits** (`torch.Tensor` de forma `(batch_size, entity_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.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings + um para a saída de cada camada) com forma `(batch_size, entity_length, hidden_size)`. Estados ocultos das entidades do modelo na saída de cada camada, além das saídas dos embeddings iniciais das entidades.
- **attentions** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplos:

```python
>>> from transformers import AutoTokenizer, LukeForEntitySpanClassification

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-conll-2003")
>>> model = LukeForEntitySpanClassification.from_pretrained("studio-ousia/luke-large-finetuned-conll-2003")

>>> text = "Beyoncé lives in Los Angeles"
# List all possible entity spans in the text

>>> word_start_positions = [0, 8, 14, 17, 21]  # character-based start positions of word tokens
>>> word_end_positions = [7, 13, 16, 20, 28]  # character-based end positions of word tokens
>>> entity_spans = []
>>> for i, start_pos in enumerate(word_start_positions):
...     for end_pos in word_end_positions[i:]:
...         entity_spans.append((start_pos, end_pos))

>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_indices = logits.argmax(-1).squeeze().tolist()
>>> for span, predicted_class_idx in zip(entity_spans, predicted_class_indices):
...     if predicted_class_idx != 0:
...         print(text[span[0] : span[1]], model.config.id2label[predicted_class_idx])
Beyoncé PER
Los Angeles LOC
```

## LukeForSequenceClassification[[transformers.LukeForSequenceClassification]]

#### transformers.LukeForSequenceClassification[[transformers.LukeForSequenceClassification]]

```python
transformers.LukeForSequenceClassification(config: LukeConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1583)

**Parâmetros:**

config ([LukeConfig](/docs/transformers/main/pt/model_doc/luke#transformers.LukeConfig)) : 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 do modelo LUKE 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 do 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.LukeForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = 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/luke/modeling_luke.py#L1596)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas porções das entradas. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

entity_ids (`torch.LongTensor` de forma `(batch_size, entity_length)`) : Índices dos tokens de entidade no vocabulário de entidades. 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.

entity_attention_mask (`torch.Tensor` de forma `(batch_size, entity_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de entidade de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens de entidade que **não estão mascarados**, - 0 para tokens de entidade que estão **mascarados**.

entity_token_type_ids (`torch.LongTensor` de forma `(batch_size, entity_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes dos tokens de entrada da entidade. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de entidade da *parte A*, - 1 corresponde a um token de entidade da *parte B*.

entity_position_ids (`torch.LongTensor` de forma `(batch_size, entity_length, max_mention_length)`, *opcional*) : Índices das posições de cada entidade de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.max_position_embeddings - 1]`.

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:** `LukeSequenceClassifierOutput` ou `tuple(torch.Tensor)`

Um `LukeSequenceClassifierOutput` 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 ([LukeConfig](/docs/transformers/main/pt/model_doc/luke#transformers.LukeConfig)) e das entradas.

O método forward de [LukeForSequenceClassification](/docs/transformers/main/pt/model_doc/luke#transformers.LukeForSequenceClassification) 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.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings + um para a saída de cada camada) com forma `(batch_size, entity_length, hidden_size)`. Estados ocultos das entidades do modelo na saída de cada camada, além das saídas dos embeddings iniciais das entidades.
- **attentions** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplo de classificação de rótulo único:

```python
>>> import torch
>>> from transformers import AutoTokenizer, LukeForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-base")

>>> 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 = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-base", 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, LukeForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-base", 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 = LukeForSequenceClassification.from_pretrained(
...     "studio-ousia/luke-base", 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
```

## LukeForMultipleChoice[[transformers.LukeForMultipleChoice]]

#### transformers.LukeForMultipleChoice[[transformers.LukeForMultipleChoice]]

```python
transformers.LukeForMultipleChoice(config: LukeConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1926)

**Parâmetros:**

config ([LukeConfig](/docs/transformers/main/pt/model_doc/luke#transformers.LukeConfig)) : 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 Luke 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.LukeForMultipleChoice.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = 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/luke/modeling_luke.py#L1939)

**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)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forma `(batch_size, 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)

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)

entity_ids (`torch.LongTensor` de forma `(batch_size, entity_length)`) : Índices dos tokens de entidade no vocabulário de entidades. 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.

entity_attention_mask (`torch.Tensor` de forma `(batch_size, entity_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de entidade de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens de entidade que **não estão mascarados**, - 0 para tokens de entidade que estão **mascarados**.

entity_token_type_ids (`torch.LongTensor` de forma `(batch_size, entity_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes dos tokens de entrada da entidade. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de entidade da *parte A*, - 1 corresponde a um token de entidade da *parte B*.

entity_position_ids (`torch.LongTensor` de forma `(batch_size, entity_length, max_mention_length)`, *opcional*) : Índices das posições de cada entidade de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.max_position_embeddings - 1]`.

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.

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)

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:** `LukeMultipleChoiceModelOutput` ou `tuple(torch.Tensor)`

Um `LukeMultipleChoiceModelOutput` 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 ([LukeConfig](/docs/transformers/main/pt/model_doc/luke#transformers.LukeConfig)) e das entradas.

O método forward de [LukeForMultipleChoice](/docs/transformers/main/pt/model_doc/luke#transformers.LukeForMultipleChoice) 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.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings + um para a saída de cada camada) com forma `(batch_size, entity_length, hidden_size)`. Estados ocultos das entidades do modelo na saída de cada camada, além das saídas dos embeddings iniciais das entidades.
- **attentions** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplo:

```python
>>> from transformers import AutoTokenizer, LukeForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForMultipleChoice.from_pretrained("studio-ousia/luke-base")

>>> 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
```

## LukeForTokenClassification[[transformers.LukeForTokenClassification]]

#### transformers.LukeForTokenClassification[[transformers.LukeForTokenClassification]]

```python
transformers.LukeForTokenClassification(config: LukeConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1705)

**Parâmetros:**

config ([LukeConfig](/docs/transformers/main/pt/model_doc/luke#transformers.LukeConfig)) : 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 LUKE com uma cabeça de classificação de tokens no topo (uma camada linear no topo da saída dos hidden-states). Para resolver a tarefa de Reconhecimento de Entidades Nomeadas (NER) usando LUKE, `LukeForEntitySpanClassification` é mais adequado do que esta classe.

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.LukeForTokenClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = 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/luke/modeling_luke.py#L1719)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas porções das entradas. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

entity_ids (`torch.LongTensor` de forma `(batch_size, entity_length)`) : Índices dos tokens de entidade no vocabulário de entidades. 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.

entity_attention_mask (`torch.Tensor` de forma `(batch_size, entity_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de entidade de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens de entidade que **não estão mascarados**, - 0 para tokens de entidade que estão **mascarados**.

entity_token_type_ids (`torch.LongTensor` de forma `(batch_size, entity_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes dos tokens de entrada da entidade. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de entidade da *parte A*, - 1 corresponde a um token de entidade da *parte B*.

entity_position_ids (`torch.LongTensor` de forma `(batch_size, entity_length, max_mention_length)`, *opcional*) : Índices das posições de cada entidade de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.max_position_embeddings - 1]`.

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

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:** `LukeTokenClassifierOutput` ou `tuple(torch.Tensor)`

Um `LukeTokenClassifierOutput` 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 ([LukeConfig](/docs/transformers/main/pt/model_doc/luke#transformers.LukeConfig)) e das entradas.

O método forward de [LukeForTokenClassification](/docs/transformers/main/pt/model_doc/luke#transformers.LukeForTokenClassification) 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.
- **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.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings + um para a saída de cada camada) com forma `(batch_size, entity_length, hidden_size)`. Estados ocultos das entidades do modelo na saída de cada camada, além das saídas dos embeddings iniciais das entidades.
- **attentions** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplo:

```python
>>> from transformers import AutoTokenizer, LukeForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForTokenClassification.from_pretrained("studio-ousia/luke-base")

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

## LukeForQuestionAnswering[[transformers.LukeForQuestionAnswering]]

#### transformers.LukeForQuestionAnswering[[transformers.LukeForQuestionAnswering]]

```python
transformers.LukeForQuestionAnswering(config: LukeConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1808)

**Parâmetros:**

config ([LukeConfig](/docs/transformers/main/pt/model_doc/luke#transformers.LukeConfig)) : 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 transformador Luke 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.LukeForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.Tensor] = None, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.LongTensor] = None, end_positions: typing.Optional[torch.LongTensor] = 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/luke/modeling_luke.py#L1820)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas porções das entradas. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

position_ids (`torch.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)

entity_ids (`torch.LongTensor` de forma `(batch_size, entity_length)`) : Índices dos tokens de entidade no vocabulário de entidades. 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.

entity_attention_mask (`torch.Tensor` de forma `(batch_size, entity_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de entidade de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens de entidade que **não estão mascarados**, - 0 para tokens de entidade que estão **mascarados**.

entity_token_type_ids (`torch.LongTensor` de forma `(batch_size, entity_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes dos tokens de entrada da entidade. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de entidade da *parte A*, - 1 corresponde a um token de entidade da *parte B*.

entity_position_ids (`torch.LongTensor` de forma `(batch_size, entity_length, max_mention_length)`, *opcional*) : Índices das posições de cada entidade de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.max_position_embeddings - 1]`.

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.LongTensor` 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.LongTensor` 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:** `LukeQuestionAnsweringModelOutput` ou `tuple(torch.Tensor)`

Um `LukeQuestionAnsweringModelOutput` 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 ([LukeConfig](/docs/transformers/main/pt/model_doc/luke#transformers.LukeConfig)) e das entradas.

O método forward de [LukeForQuestionAnswering](/docs/transformers/main/pt/model_doc/luke#transformers.LukeForQuestionAnswering) 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.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings + um para a saída de cada camada) com forma `(batch_size, entity_length, hidden_size)`. Estados ocultos das entidades do modelo na saída de cada camada, além das saídas dos embeddings iniciais das entidades.
- **attentions** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplo:

```python
>>> from transformers import AutoTokenizer, LukeForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForQuestionAnswering.from_pretrained("studio-ousia/luke-base")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...
```