# Splinter

## Visão geral

O modelo Splinter foi proposto em [Few-Shot Question Answering by Pretraining Span Selection](https://huggingface.co/papers/2101.00438) por Ori Ram, Yuval Kirstain, Jonathan Berant, Amir Globerson e Omer Levy. O Splinter é um transformer apenas de codificador (similar ao BERT) pré-treinado usando a tarefa de seleção recorrente de spans em um grande corpus que compreende a Wikipédia e o Toronto Book Corpus.

O resumo do artigo é o seguinte:

Em vários benchmarks de question answering, modelos pré-treinados alcançaram paridade com humanos por meio de fine-tuning em uma ordem de 100.000 perguntas e respostas anotadas. Exploramos o cenário mais realista de few-shot, no qual apenas algumas centenas de exemplos de treinamento estão disponíveis, e observamos que os modelos padrão apresentam baixo desempenho, destacando a discrepância entre os objetivos atuais de pré-treinamento e o question answering. Propomos um novo esquema de pré-treinamento adaptado para question answering: seleção recorrente de spans. Dado um trecho com múltiplos conjuntos de spans recorrentes, aplicamos máscara em cada conjunto a todos os spans recorrentes, exceto um, e pedimos ao modelo que selecione o span correto no trecho para cada span mascarado. Os spans mascarados são substituídos por um token especial, visto como uma representação da pergunta, que é usado posteriormente durante o fine-tuning para selecionar o span da resposta. O modelo resultante obtém resultados surpreendentemente bons em vários benchmarks (por exemplo, 72,7 F1 no SQuAD com apenas 128 exemplos de treinamento), mantendo desempenho competitivo no cenário de alto recurso.

Este modelo foi contribuído por [yuvalkirstain](https://huggingface.co/yuvalkirstain) e [oriram](https://huggingface.co/oriram). O código original pode ser encontrado [aqui](https://github.com/oriram/splinter).

## Dicas de uso

- O Splinter foi treinado para prever trechos de respostas condicionados a um token especial [QUESTION]. Esses tokens contextualizam as representações da pergunta, que são usadas para prever as respostas. Essa camada é chamada de QASS e é o comportamento padrão na classe [SplinterForQuestionAnswering](/docs/transformers/main/pt/model_doc/splinter#transformers.SplinterForQuestionAnswering). Portanto:
- Use [SplinterTokenizer](/docs/transformers/main/pt/model_doc/splinter#transformers.SplinterTokenizer) (em vez de [BertTokenizer](/docs/transformers/main/pt/model_doc/lxmert#transformers.BertTokenizer)), pois ele já contém esse token especial. Além disso, seu comportamento padrão é usar esse token quando duas sequências são fornecidas.
- Lembre-se do token de pergunta - ele pode ser importante para o sucesso do seu modelo, especialmente em um cenário de few-shot.
- Observe que existem dois checkpoints diferentes para cada tamanho do Splinter. Ambos são basicamente os mesmos, exceto que um também possui os pesos pré-treinados da camada QASS (*tau/splinter-base-qass* e *tau/splinter-large-qass*) e o outro não (*tau/splinter-base* e *tau/splinter-large*). Isso é feito para suportar a inicialização aleatória dessa camada durante o fine-tuning, pois o artigo demonstra que isso produz melhores resultados em alguns casos.

## Recursos

- [Guia da tarefa de resposta a perguntas](../tasks/question_answering)

## SplinterConfig[[transformers.SplinterConfig]]

#### transformers.SplinterConfig[[transformers.SplinterConfig]]

```python
transformers.SplinterConfig(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 = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 512, type_vocab_size: int = 2, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, question_token_id: int = 104)
```

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

**Parâmetros:**

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

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

num_hidden_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no decodificador do Transformer.

num_attention_heads (`int`, *opcional*, padrão `12`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

intermediate_size (`int`, *opcional*, padrão `3072`) : Dimensão das representações do MLP.

hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

hidden_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.1`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, encoder e pooler.

attention_probs_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.1`) : A taxa de dropout para as probabilidades de atenção.

max_position_embeddings (`int`, *opcional*, padrão `512`) : O comprimento máximo de sequência com o qual este modelo pode ser utilizado.

type_vocab_size (`int`, *opcional*, padrão `2`) : O tamanho do vocabulário dos `token_type_ids`.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

layer_norm_eps (`float`, *opcional*, padrão `1e-12`) : O epsilon usado pelas camadas de normalização de camada.

pad_token_id (`int`, *opcional*, padrão `0`) : ID do token usado para preenchimento no vocabulário.

bos_token_id (`int`, *opcional*) : ID do token usado para o início do fluxo no vocabulário.

eos_token_id (`Union[int, list[int]]`, *opcional*) : ID do token usado para o fim do fluxo no vocabulário.

question_token_id (`int`, *opcional*, padrão 104) : O id do token `[QUESTION]`.

Esta é a classe de configuração para armazenar a configuração de um SplinterModel. Ela é usada para instanciar um modelo Splinter 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 [tau/splinter-base](https://huggingface.co/tau/splinter-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.

Exemplo:

```python
>>> from transformers import SplinterModel, SplinterConfig

>>> # Initializing a Splinter tau/splinter-base style configuration
>>> configuration = SplinterConfig()

>>> # Initializing a model from the tau/splinter-base style configuration
>>> model = SplinterModel(configuration)

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

## SplinterTokenizer[[transformers.SplinterTokenizer]]

#### transformers.SplinterTokenizer[[transformers.SplinterTokenizer]]

```python
transformers.SplinterTokenizer(vocab: str | dict[str, int] | None = None, do_lower_case: bool = True, unk_token: str = '[UNK]', sep_token: str = '[SEP]', pad_token: str = '[PAD]', cls_token: str = '[CLS]', mask_token: str = '[MASK]', question_token: str = '[QUESTION]', tokenize_chinese_chars: bool = True, strip_accents: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/splinter/tokenization_splinter.py#L41)

**Parâmetros:**

vocab_file (`str`, *opcional*) : Caminho para um arquivo de vocabulário.

tokenizer_file (`str`, *opcional*) : Caminho para um arquivo JSON de tokenizers contendo a serialização de um tokenizer.

do_lower_case (`bool`, *opcional*, padrão `True`) : Indica se a entrada deve ser convertida para minúsculas durante a tokenização.

unk_token (`str`, *opcional*, padrão `"[UNK]"`) : O token desconhecido. Um token que não está no vocabulário não pode ser convertido em um ID e é definido como este token em vez disso.

sep_token (`str`, *opcional*, padrão `"[SEP]"`) : O token separador, usado ao construir uma sequência a partir de múltiplas sequências.

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

cls_token (`str`, *opcional*, padrão `"[CLS]"`) : O token do classificador usado ao realizar a classificação de sequência.

mask_token (`str`, *opcional*, padrão `"[MASK]"`) : O token usado para mascarar valores.

question_token (`str`, *opcional*, padrão `"[QUESTION]"`) : O token usado para construir representações de perguntas.

tokenize_chinese_chars (`bool`, *opcional*, padrão `True`) : Se deve ou não tokenizar caracteres chineses.

strip_accents (`bool`, *opcional*) : Se deve ou não remover todos os acentos. Se essa opção não for especificada, ela será determinada pelo valor de `lowercase`.

vocab (`str`, `dict` ou `list`, *opcional*) : Dicionário de vocabulário personalizado. Se não for fornecido, um vocabulário mínimo será criado.

Construa um tokenizador Splinter (baseado na biblioteca tokenizers do HuggingFace). Baseado em WordPiece.

Este tokenizer herda de [TokenizersBackend](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend), que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses métodos.

#### get_special_tokens_mask[[transformers.SplinterTokenizer.get_special_tokens_mask]]

```python
get_special_tokens_mask(token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False)
```

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

**Parâmetros:**

token_ids_0 : Lista de IDs da sequência (possivelmente já formatada).

token_ids_1 : Não utilizado quando `already_has_special_tokens=True`. Deve ser None nesse caso.

already_has_special_tokens : Indica se a sequência já está formatada com tokens especiais.

**Retorna:** Uma lista de inteiros no intervalo [0, 1]

1 para um token especial, 0 para um token de sequência.

Obter os ids de sequência de uma lista de tokens que não possui tokens especiais adicionados.

Para tokenizadores rápidos, os data collators chamam isso com `already_has_special_tokens=True` para construir uma máscara sobre uma sequência já formatada. Nesse caso, calculamos a máscara verificando a pertença em `all_special_ids`.

#### save_vocabulary[[transformers.SplinterTokenizer.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)

## SplinterModel[[transformers.SplinterModel]]

#### transformers.SplinterModel[[transformers.SplinterModel]]

```python
transformers.SplinterModel(config: SplinterConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/splinter/modeling_splinter.py#L312)

**Parâmetros:**

config ([SplinterConfig](/docs/transformers/main/pt/model_doc/splinter#transformers.SplinterConfig)) : 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 Splinter puro, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### forward[[transformers.SplinterModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/splinter/modeling_splinter.py#L335)

**Parâmetros:**

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

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

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

position_ids (`torch.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.max_position_embeddings - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

**Retorna:** [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou `tuple(torch.Tensor)`

Um [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([SplinterConfig](/docs/transformers/main/pt/model_doc/splinter#transformers.SplinterConfig)) e das entradas.

O método forward do [SplinterModel](/docs/transformers/main/pt/model_doc/splinter#transformers.SplinterModel) 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.
- **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.

## SplinterForQuestionAnswering[[transformers.SplinterForQuestionAnswering]]

#### transformers.SplinterForQuestionAnswering[[transformers.SplinterForQuestionAnswering]]

```python
transformers.SplinterForQuestionAnswering(config: SplinterConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/splinter/modeling_splinter.py#L462)

**Parâmetros:**

config ([SplinterConfig](/docs/transformers/main/pt/model_doc/splinter#transformers.SplinterConfig)) : 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 Splinter com uma cabeça de classificação de spans no topo para tarefas de question-answering extrativo 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.SplinterForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.LongTensor] = None, end_positions: typing.Optional[torch.LongTensor] = None, question_positions: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/splinter/modeling_splinter.py#L473)

**Parâmetros:**

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

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

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

position_ids (`torch.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.max_position_embeddings - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

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

question_positions (`torch.LongTensor` de forma `(batch_size, num_questions)`, *opcional*) : As posições de todos os tokens de pergunta. Se fornecida, start_logits e end_logits terão a forma `(batch_size, num_questions, sequence_length)`. Se for None, o primeiro token de pergunta em cada sequência do lote será o único para o qual start_logits e end_logits são calculados, e eles terão a forma `(batch_size, sequence_length)`.

**Retorna:** [QuestionAnsweringModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) ou `tuple(torch.Tensor)`

Um [QuestionAnsweringModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) 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 ([SplinterConfig](/docs/transformers/main/pt/model_doc/splinter#transformers.SplinterConfig)) e das entradas.

O método forward de [SplinterForQuestionAnswering](/docs/transformers/main/pt/model_doc/splinter#transformers.SplinterForQuestionAnswering) 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)`) -- Pontuações de início de span (antes do SoftMax).
- **end_logits** (`torch.Tensor` de forma `(batch_size, sequence_length)`) -- 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` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

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

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

Exemplo:

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

>>> tokenizer = AutoTokenizer.from_pretrained("tau/splinter-base")
>>> model = SplinterForQuestionAnswering.from_pretrained("tau/splinter-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)
...
```

## SplinterForPreTraining[[transformers.SplinterForPreTraining]]

#### transformers.SplinterForPreTraining[[transformers.SplinterForPreTraining]]

```python
transformers.SplinterForPreTraining(config: SplinterConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/splinter/modeling_splinter.py#L595)

**Parâmetros:**

config ([SplinterConfig](/docs/transformers/main/pt/model_doc/splinter#transformers.SplinterConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Modelo Splinter para a tarefa de seleção de trechos recorrentes, conforme realizado durante o pré-treinamento. A diferença em relação à tarefa de QA é que não temos uma pergunta, mas sim múltiplos tokens de pergunta que substituem as ocorrências dos trechos recorrentes.

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.LongTensor] = None, end_positions: typing.Optional[torch.LongTensor] = None, question_positions: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/splinter/modeling_splinter.py#L606)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, num_questions, 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_questions, 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, num_questions, sequence_length`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.max_position_embeddings - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` de forma `(batch_size, num_questions, 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 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, num_questions)`, *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, num_questions)`, *opcional*) : Rótulos para a posição (índice) do final do intervalo 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.

question_positions (`torch.LongTensor` de forma `(batch_size, num_questions)`, *opcional*) : As posições de todos os tokens de pergunta. Se fornecida, start_logits e end_logits terão a forma `(batch_size, num_questions, sequence_length)`. Se for None, o primeiro token de pergunta em cada sequência do lote será o único para o qual start_logits e end_logits são calculados, e eles terão a forma `(batch_size, sequence_length)`.

**Retorna:** `SplinterForPreTrainingOutput` ou `tuple(torch.Tensor)`

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

O método forward de [SplinterForPreTraining](/docs/transformers/main/pt/model_doc/splinter#transformers.SplinterForPreTraining) 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 as posições de início e fim são fornecidas) -- A perda total de extração de span é a soma de uma Cross-Entropy para as posições de início e fim.
- **start_logits** (`torch.Tensor` de forma `(batch_size, num_questions, sequence_length)`) -- Pontuações de início de trecho (antes do SoftMax).
- **end_logits** (`torch.Tensor` de forma `(batch_size, num_questions, sequence_length)`) -- Pontuações de fim de trecho (antes do SoftMax).
- **hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

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

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

Exemplo:

```python
```