Transformers documentation
XLNet
Este modelo foi publicado em papers do HF em 2019-06-19 e contribuído para o Hugging Face Transformers em 2020-11-16.
XLNet
Visão geral
O modelo XLNet foi proposto em XLNet: Generalized Autoregressive Pretraining for Language Understanding por Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, Quoc V. Le. O XLNet é uma extensão do modelo Transformer-XL pré-treinado usando um método autoregressivo para aprender contextos bidirecionais, maximizando a verossimilhança esperada sobre todas as permutações da ordem de fatoração da sequência de entrada.
O resumo do artigo é o seguinte:
Com a capacidade de modelar contextos bidirecionais, o pré-treino baseado em auto-encoding de desruído, como o BERT, alcança melhor desempenho do que as abordagens de pré-treino baseadas em modelagem de linguagem autoregressiva. No entanto, ao depender da corrupção da entrada com máscaras, o BERT negligencia a dependência entre as posições mascaradas e sofre com a discrepância entre pré-treino e ajuste fino. Diante dessas vantagens e desvantagens, propomos o XLNet, um método generalizado de pré-treino autoregressivo que (1) permite a aprendizagem de contextos bidirecionais maximizando a verossimilhança esperada sobre todas as permutações da ordem de fatoração e (2) supera as limitações do BERT graças à sua formulação autoregressiva. Além disso, o XLNet integra ideias do Transformer-XL, o modelo autoregressivo mais avançado, no pré-treino. Empiricamente, em configurações de experimento comparáveis, o XLNet supera o BERT em 20 tarefas, muitas vezes por uma grande margem, incluindo resposta a perguntas, inferência de linguagem natural, análise de sentimento e classificação de documentos.
Este modelo foi contribuído por thomwolf. O código original pode ser encontrado aqui.
Dicas de uso
- O padrão de atenção específico pode ser controlado nos momentos de treinamento e de teste usando a entrada
perm_mask. - Devido à dificuldade de treinar um modelo totalmente auto-regressivo sobre diversas ordens de fatoração, o XLNet é pré-treinado usando apenas um subconjunto dos tokens de saída como alvo, selecionados pela entrada
target_mapping. - Para usar o XLNet para decodificação sequencial (ou seja, não em configuração totalmente bidirecional), utilize as entradas
perm_masketarget_mappingpara controlar o alcance da atenção e as saídas - XLNet é um dos poucos modelos que não possui limite de comprimento de sequência.
- XLNet não é um modelo autoregressivo tradicional, mas utiliza uma estratégia de treinamento que se baseia nesse conceito. Ele permuta os tokens da frase e, em seguida, permite que o modelo use os últimos n tokens para prever o token n+1. Como tudo isso é feito com uma máscara, a frase é, na verdade, inserida no modelo na ordem correta, mas, em vez de mascarar os primeiros n tokens para n+1, o XLNet usa uma máscara que oculta os tokens anteriores em alguma permutação dada de 1,…,comprimento da sequência.
- O XLNet também utiliza o mesmo mecanismo de recorrência do Transformer-XL para construir dependências de longo prazo.
Recursos
- Guia da tarefa de classificação de texto
- Guia de tarefas de classificação de tokens
- Guia da tarefa de resposta a perguntas
- Guia da tarefa de modelagem de linguagem causal
- Guia de tarefas de múltipla escolha
XLNetConfig
classe transformers.XLNetConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 32000d_model: int = 1024n_layer: int = 24n_head: int = 16d_inner: int = 4096d_head: int | None = Noneff_activation: str = 'gelu'attn_type: str = 'bi'initializer_range: float = 0.02layer_norm_eps: float = 1e-12dropout: float | int = 0.1mem_len: int | None = 512reuse_len: int | None = Noneuse_mems_eval: bool = Trueuse_mems_train: bool = Falsebi_data: bool = Falseclamp_len: int = -1same_length: bool = Falsesummary_type: str = 'last'summary_use_proj: bool = Truesummary_activation: str = 'tanh'summary_last_dropout: float | int = 0.1start_n_top: int = 5end_n_top: int = 5pad_token_id: int | None = 5bos_token_id: int | None = 1eos_token_id: int | list[int] | None = 2tie_word_embeddings: bool = True )
Parâmetros
- vocab_size (
int, opcional, padrão32000) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelosinput_ids. - d_model (
int, opcional, padrão1024) — Tamanho das camadas do codificador e da camada pooler. - n_layer (
int, opcional, padrão24) — Número de camadas ocultas no decodificador do Transformer. - n_head (
int, opcional, padrão16) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. - d_inner (
int, opcional, padrão4096) — Dimensão das representações do MLP. - d_head (
int, opcional) — A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads - ff_activation (
strouCallable, opcional, padrão"gelu") — A função de ativação não linear (função ou string). Se for string,"gelu","relu","silu"e"gelu_new"são suportadas. - attn_type (
str, opcional, padrão"bi") — O tipo de atenção usado pelo modelo. Defina"bi"para XLNet e"uni"para Transformer-XL. - initializer_range (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - layer_norm_eps (
float, opcional, padrão1e-12) — O epsilon usado pelas camadas de normalização de camada. - dropout (
Union[float, int], opcional, padrão0.1) — A proporção para todas as camadas de dropout. - mem_len (
intouNone, opcional) — O número de tokens a serem armazenados em cache. Os pares de chave/valor que já foram pré-computados em uma passagem de forward anterior não serão recalculados. Consulte o quickstart para mais informações. - reuse_len (
int, opcional) — O número de tokens no lote atual que serão armazenados em cache e reutilizados no futuro. - use_mems_eval (
bool, opcional, padrãoTrue) — Indica se o modelo deve ou não utilizar o mecanismo de memória recorrente no modo de avaliação. - use_mems_train (
bool, opcional, padrãoFalse) — Indica se o modelo deve ou não utilizar o mecanismo de memória recorrente no modo de treinamento.Para pré-treinamento, recomenda-se definir `use_mems_train` como `True`. Para ajuste fino, recomenda-se definir `use_mems_train` como `False`, conforme discutido [here](https://github.com/zihangdai/xlnet/issues/41#issuecomment-505102587). Se `use_mems_train` for definido como `True`, é necessário garantir que os lotes de treinamento sejam pré-processados corretamente, *por exemplo*, `batch_1 = [[This line is], [This is the]]` e `batch_2 = [[ the first line], [ second line]]`, e que todos os lotes tenham tamanho igual. - bi_data (
bool, opcional, padrãoFalse) — Indica se deve ou não usar o pipeline de entrada bidirecional. Geralmente definido comoTruedurante o pré-treinamento eFalsedurante o ajuste fino. - clamp_len (
int, opcional, padrão -1) — Limita todas as distâncias relativas maiores que clamp_len. Definir este atributo como -1 significa que não há limitação. - same_length (
bool, opcional, padrãoFalse) — Indica se deve ou não usar o mesmo comprimento de atenção para cada token. - summary_type (
str, opcional, padrão: “last”) — Argumento usado ao realizar o resumo de sequência. Utilizado nos modelos de classificação de sequência e escolha múltipla. Deve ser uma das seguintes opções:"last": Adota o estado oculto do último token (como no XLNet)."first": Adota o estado oculto do primeiro token (como no BERT)."mean": Calcula a média dos estados ocultos de todos os tokens."cls_index": Forneça um Tensor com a posição do token de classificação (como em GPT/GPT-2)."attn": Não implementado no momento, use atenção multi-cabeça.
- summary_use_proj (
bool, opcional, padrãoTrue) — Argumento utilizado ao realizar o resumo de sequência. Usado nos modelos de classificação de sequência e escolha múltipla. Indica se deve ou não adicionar uma projeção após a extração do vetor. - summary_activation (
str, opcional) — Argumento utilizado ao realizar o resumo da sequência. Usado nos modelos de classificação de sequência e escolha múltipla. Passe"tanh"para uma ativação tanh na saída; qualquer outro valor resultará em nenhuma ativação. - summary_last_dropout (
float, opcional, padrão 0.1) — Usado nos modelos de classificação de sequência e escolha múltipla. A taxa de dropout a ser usada após a projeção e a ativação. - start_n_top (
int, opcional, padrão 5) — Usado no script de avaliação SQuAD. - end_n_top (
int, opcional, padrão 5) — Usado no script de avaliação SQuAD. - pad_token_id (
int, opcional, padrão5) — ID do token usado para preenchimento no vocabulário. - bos_token_id (
int, opcional, padrão1) — ID do token usado para o início do fluxo no vocabulário. - eos_token_id (
Union[int, list[int]], opcional, padrão2) — ID do token usado para o fim do fluxo no vocabulário. - tie_word_embeddings (
bool, opcional, padrãoTrue) — Se deve vincular as embeddings de pesos de acordo com o mapeamentotied_weights_keysdo modelo.
Esta é a classe de configuração para armazenar a configuração de um XLNetModel. Ela é usada para instanciar um modelo Xlnet 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 xlnet/xlnet-large-cased
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
Exemplos:
>>> from transformers import XLNetConfig, XLNetModel
>>> # Initializing a XLNet configuration
>>> configuration = XLNetConfig()
>>> # Initializing a model (with random weights) from the configuration
>>> model = XLNetModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configXLNetTokenizer
classe transformers.XLNetTokenizer
< source >( vocab: str | list[tuple[str, float]] | None = Noneunk_id: int = 0do_lower_case = Falseremove_space = Truekeep_accents = Falsebos_token = '<s>'eos_token = '</s>'unk_token = '<unk>'sep_token = '<sep>'pad_token = '<pad>'cls_token = '<cls>'mask_token = '<mask>'_spm_precompiled_charsmap = Noneadditional_special_tokens = None**kwargs )
Parâmetros
- vocab (
list of tuples, opcional) — Lista de tuplas (token, score) para o modelo Unigram. Se não for fornecida, uma lista vazia é utilizada. - unk_id (
int, opcional, padrão 0) — O ID do token desconhecido no vocabulário. - do_lower_case (
bool, opcional, padrãoFalse) — Se deve converter a entrada em minúsculas ao tokenizar. - remove_space (
bool, opcional, padrãoTrue) — Se deve remover espaços do texto durante a tokenização (removendo espaços excedentes antes e depois da string). - keep_accents (
bool, opcional, padrãoFalse) — Se deve manter os acentos ao tokenizar. - 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 usado para o fim da sequência. O token utilizado é o sep_token.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. - 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, utilizado ao construir uma sequência a partir de múltiplas sequências, por exemplo, duas sequências para classificação de sequência ou um texto e uma pergunta para resposta a perguntas. Também é usado como o último token de uma sequência construída com tokens especiais. - 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 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. - 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. - additional_special_tokens (
list[str], opcional, padrão["<eop>", "<eod>"]) — Tokens especiais adicionais usados pelo tokenizer.
Construa um tokenizador XLNet (baseado na biblioteca tokenizers do HuggingFace). Baseado em Unigram.
Este tokenizador herda de 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
< source >( token_ids_0: list[int]token_ids_1: list[int] | None = Nonealready_has_special_tokens: bool = False ) → A list of integers in the range [0, 1]
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.
Saídas específicas do XLNet
classe transformers.models.xlnet.modeling_xlnet.XLNetModelOutput
< source >( last_hidden_state: Tensormems: list[torch.Tensor] | None = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
Parâmetros
- last_hidden_state (
torch.Tensorde forma(batch_size, num_predict, hidden_size)) — Sequência de estados ocultos na última camada do modelo.num_predictcorresponde atarget_mapping.shape[1]. Setarget_mappingforNone, entãonum_predictcorresponde asequence_length. - mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados. Pode ser usado (veja a entradamems) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados. - hidden_states (
tuple[torch.Tensor, ...], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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 nos cabeçalhos de autoatenção.
Tipo de saída de XLNetModel.
classe transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonemems: list[torch.Tensor] | None = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
Parâmetros
- loss (
torch.Tensorde forma (1,), opcional, retornado quandolabelsé fornecido) — Perda de modelagem de linguagem (para previsão do próximo token). - logits (
torch.Tensorde forma(batch_size, num_predict, 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).num_predictcorresponde atarget_mapping.shape[1]. Setarget_mappingforNone, entãonum_predictcorresponde asequence_length. - mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados. Pode ser usado (veja a entradamems) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados. - hidden_states (
tuple[torch.Tensor, ...], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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 nos cabeçalhos de autoatenção.
Tipo de saída de XLNetLMHeadModel.
classe transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonemems: list[torch.Tensor] | None = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
Parâmetros
- loss (
torch.Tensorde forma(1,), opcional, retornado quandolabelé fornecido) — Perda de classificação (ou regressão se config.num_labels==1). - logits (
torch.Tensorde forma(batch_size, config.num_labels)) — Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax). - mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados. Pode ser usado (veja a entradamems) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados. - hidden_states (
tuple[torch.Tensor, ...], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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 nos cabeçalhos de autoatenção.
Tipo de saída de XLNetForSequenceClassification.
classe transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonemems: list[torch.Tensor] | None = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
Parâmetros
- loss (
torch.Tensorde forma (1,), opcional, retornado quandolabelsé fornecido) — Perda de classificação. - logits (
torch.Tensorde 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).
- mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados. Pode ser usado (veja a entradamems) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados. - hidden_states (
tuple[torch.Tensor, ...], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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 nos cabeçalhos de autoatenção.
Tipo de saída de XLNetForMultipleChoice.
classe transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonemems: list[torch.Tensor] | None = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
Parâmetros
- loss (
torch.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de classificação. - logits (
torch.Tensorde forma(batch_size, sequence_length, config.num_labels)) — Pontuações de classificação (antes do SoftMax). - mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados. Pode ser usado (veja a entradamems) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados. - hidden_states (
tuple[torch.Tensor, ...], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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 nos cabeçalhos de autoatenção.
Tipo de saída de XLNetForTokenClassificationOutput.
classe transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonestart_logits: typing.Optional[torch.Tensor] = Noneend_logits: typing.Optional[torch.Tensor] = Nonemems: list[torch.Tensor] | None = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
Parâmetros
- loss (
torch.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — A perda total de extração de span é a soma de uma Entropia Cruzada para as posições de início e fim. - start_logits (
torch.Tensorde forma(batch_size, sequence_length,)) — Pontuações de início de trecho (antes do SoftMax). - end_logits (
torch.Tensorde forma(batch_size, sequence_length,)) — Pontuações de fim de trecho (antes do SoftMax). - mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados. Pode ser usado (veja a entradamems) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados. - hidden_states (
tuple[torch.Tensor, ...], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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 nos cabeçalhos de autoatenção.
Tipo de saída de XLNetForQuestionAnsweringSimple.
classe transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonestart_top_log_probs: typing.Optional[torch.Tensor] = Nonestart_top_index: typing.Optional[torch.LongTensor] = Noneend_top_log_probs: typing.Optional[torch.Tensor] = Noneend_top_index: typing.Optional[torch.LongTensor] = Nonecls_logits: typing.Optional[torch.Tensor] = Nonemems: list[torch.Tensor] | None = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
Parâmetros
- loss (
torch.Tensorde forma(1,), opcional, retornado sestart_positionseend_positionsforem fornecidos) — Perda de classificação como a soma das perdas de classificação do token inicial, do token final (e de is_impossible, se fornecido). - start_top_log_probs (
torch.Tensorde forma(batch_size, config.start_n_top), opcional, retornado sestart_positionsouend_positionsnão for fornecido) — Probabilidades logarítmicas para as config.start_n_top melhores possibilidades de tokens de início (beam-search). - start_top_index (
torch.LongTensorde forma(batch_size, config.start_n_top), opcional, retornado sestart_positionsouend_positionsnão for fornecido) — Índices para as melhores possibilidades de tokens de início (beam-search) de config.start_n_top. - end_top_log_probs (
torch.Tensorde forma(batch_size, config.start_n_top * config.end_n_top), opcional, retornado sestart_positionsouend_positionsnão forem fornecidos) — Probabilidades logarítmicas para asconfig.start_n_top * config.end_n_topmelhores possibilidades de tokens de fim (beam-search). - end_top_index (
torch.LongTensorde forma(batch_size, config.start_n_top * config.end_n_top), opcional, retornado sestart_positionsouend_positionsnão for fornecido) — Índices para asconfig.start_n_top * config.end_n_topmelhores possibilidades de tokens finais (beam-search). - cls_logits (
torch.Tensorde forma(batch_size,), opcional, retornado sestart_positionsouend_positionsnão forem fornecidos) — Probabilidades logarítmicas para o rótulois_impossibledas respostas. - mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados. Pode ser usado (veja a entradamems) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados. - hidden_states (
tuple[torch.Tensor, ...], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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 nos cabeçalhos de autoatenção.
Tipo de saída de XLNetForQuestionAnswering.
XLNetModel
classe transformers.XLNetModel
< source >( config: XLNetConfig )
Parâmetros
- config (XLNetConfig) — 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() para carregar os pesos do modelo.
O modelo Xlnet básico que produz estados ocultos brutos, sem nenhum cabeçalho específico no topo.
Este modelo herda de 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonemems: typing.Optional[torch.Tensor] = Noneperm_mask: typing.Optional[torch.Tensor] = Nonetarget_mapping: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneinput_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_mems: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → XLNetModelOutput or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.Tensorde formato(batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- attention_mask (
torch.Tensorde 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.
- mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados (vejamemssaída abaixo). Pode ser usado para acelerar a decodificação sequencial. Os token ids cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados.use_memsdeve ser definido comoTruepara utilizarmems. - perm_mask (
torch.Tensorde forma(batch_size, sequence_length, sequence_length), opcional) — Máscara para indicar o padrão de atenção para cada token de entrada, com valores selecionados em[0, 1]:- se
perm_mask[k, i, j] = 0, i presta atenção a j no lote k; - se
perm_mask[k, i, j] = 1, i não presta atenção a j no lote k.
Se não for definido, cada token atende a todos os outros (atenção bidirecional completa). Usado apenas durante o pré-treinamento (para definir a ordem de fatorização) ou para decodificação sequencial (geração).
- se
- target_mapping (
torch.Tensorde forma(batch_size, num_predict, sequence_length), opcional) — Máscara para indicar os tokens de saída a serem usados. Setarget_mapping[k, i, j] = 1, a i-ésima previsão no lote k está no j-ésimo token. Usado apenas durante o pré-treinamento para previsão parcial ou para decodificação sequencial (geração). - token_type_ids (
torch.Tensorde 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 sentence A,
- 1 corresponde a um token de sentence B.
- input_mask (
torch.Tensorde formabatch_size, sequence_length, opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Negativo deattention_mask, ou seja, com 0 para tokens reais e 1 para preenchimento, mantido para compatibilidade com a base de código original.Valores de máscara selecionados em
[0, 1]:- 1 para tokens que estão mascarados,
- 0 para tokens que não estão mascarados.
Você pode usar apenas um de
input_maskeattention_mask. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - use_mems (
bool, opcional) — Indica se os estados de memória devem ser usados para acelerar a decodificação sequencial. Se definido comoTrue, o modelo usará os estados ocultos de passes anteriores para calcular a atenção, o que pode melhorar significativamente o desempenho em tarefas de decodificação sequencial. - output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.
Retorna
XLNetModelOutput ou tuple(torch.Tensor)
Um XLNetModelOutput 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 (XLNetConfig) e das entradas.
O método forward do XLNetModel 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
Moduleem 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.Tensorde forma(batch_size, num_predict, hidden_size)) — Sequência de hidden-states na última camada do modelo.num_predictcorresponde atarget_mapping.shape[1]. Setarget_mappingforNone, entãonum_predictcorresponde asequence_length.mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados. Pode ser usado (veja a entradamems) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados.hidden_states (
tuple[torch.Tensor, ...], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com 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 nos cabeçalhos de autoatenção.
XLNetLMHeadModel
classe transformers.XLNetLMHeadModel
< source >( config: XLNetConfig )
Parâmetros
- config (XLNetConfig) — 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() para carregar os pesos do modelo.
Modelo XLNet com uma cabeça de modelagem de linguagem no topo (camada linear com pesos vinculados aos embeddings de entrada).
Este modelo herda de 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonemems: typing.Optional[torch.Tensor] = Noneperm_mask: typing.Optional[torch.Tensor] = Nonetarget_mapping: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneinput_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneuse_mems: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs ) → XLNetLMHeadModelOutput or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.Tensorde formato(batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- attention_mask (
torch.Tensorde 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.
- mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados (vejamemssaída abaixo). Pode ser usado para acelerar a decodificação sequencial. Os token ids cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados.use_memsdeve ser definido comoTruepara utilizarmems. - perm_mask (
torch.Tensorde forma(batch_size, sequence_length, sequence_length), opcional) — Máscara para indicar o padrão de atenção para cada token de entrada, com valores selecionados em[0, 1]:- se
perm_mask[k, i, j] = 0, i presta atenção a j no lote k; - se
perm_mask[k, i, j] = 1, i não presta atenção a j no lote k.
Se não for definido, cada token atende a todos os outros (atenção bidirecional completa). Usado apenas durante o pré-treinamento (para definir a ordem de fatorização) ou para decodificação sequencial (geração).
- se
- target_mapping (
torch.Tensorde forma(batch_size, num_predict, sequence_length), opcional) — Máscara para indicar os tokens de saída a serem usados. Setarget_mapping[k, i, j] = 1, a i-ésima previsão no lote k está no j-ésimo token. Usado apenas durante o pré-treinamento para previsão parcial ou para decodificação sequencial (geração). - token_type_ids (
torch.Tensorde 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 sentence A,
- 1 corresponde a um token de sentence B.
- input_mask (
torch.Tensorde formabatch_size, sequence_length, opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Negativo deattention_mask, ou seja, com 0 para tokens reais e 1 para preenchimento, mantido para compatibilidade com a base de código original.Valores de máscara selecionados em
[0, 1]:- 1 para tokens que estão mascarados,
- 0 para tokens que não estão mascarados.
Você pode usar apenas um de
input_maskeattention_mask. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - labels (
torch.LongTensorde forma(batch_size, num_predict), opcional) — Rótulos para modelagem de linguagem mascarada.num_predictcorresponde atarget_mapping.shape[1]. Setarget_mappingforNone, entãonum_predictcorresponde asequence_length.Os rótulos devem corresponder às palavras de entrada mascaradas que devem ser previstas e dependem de
target_mapping. Observe que, para realizar o modelamento de linguagem auto-regressivo padrão, um tokendeve ser adicionado aos input_ids(consulte a funçãoprepare_inputs_for_generatione os exemplos abaixo)Os índices são selecionados em
[-100, 0, ..., config.vocab_size]Todos os rótulos definidos como-100são ignorados; a perda é calculada apenas para os rótulos em[0, ..., config.vocab_size] - use_mems (
bool, opcional) — Indica se os estados de memória devem ser usados para acelerar a decodificação sequencial. Se definido comoTrue, o modelo usará os estados ocultos de passes anteriores para calcular a atenção, o que pode melhorar significativamente o desempenho em tarefas de decodificação sequencial. - output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples. - logits_to_keep (
Union[int, torch.Tensor], opcional, padrão0) — Se for umint, calcula os logits para os últimoslogits_to_keeptokens. Se for0, calcula os logits para todos osinput_ids(caso especial). Apenas os logits do último token são necessários para a geração, e calculá-los apenas para esse token pode economizar memória, o que se torna bastante significativo para sequências longas ou tamanho de vocabulário grande. Se for umtorch.Tensor, deve ser 1D, correspondendo aos índices a serem mantidos na dimensão de comprimento da sequência. Isso é útil ao usar o formato de tensor empacotado (uma única dimensão para lote e comprimento da sequência).
Retorna
XLNetLMHeadModelOutput ou tuple(torch.Tensor)
Um XLNetLMHeadModelOutput 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 (XLNetConfig) e das entradas.
O método forward do XLNetLMHeadModel 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
Moduleem 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.Tensorde forma (1,), opcional, retornado quandolabelsé fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).logits (
torch.Tensorde forma(batch_size, num_predict, 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).num_predictcorresponde atarget_mapping.shape[1]. Setarget_mappingforNone, entãonum_predictcorresponde asequence_length.mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados. Pode ser usado (veja a entradamems) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados.hidden_states (
tuple[torch.Tensor, ...], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com 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 nos cabeçalhos de autoatenção.
Exemplos:
>>> from transformers import AutoTokenizer, XLNetLMHeadModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetLMHeadModel.from_pretrained("xlnet/xlnet-large-cased")
>>> # We show how to setup inputs to predict a next token using a bi-directional context.
>>> input_ids = torch.tensor(
... tokenizer.encode("Hello, my dog is very <mask>", add_special_tokens=False)
... ).unsqueeze(
... 0
... ) # We will predict the masked token
>>> perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float)
>>> perm_mask[:, :, -1] = 1.0 # Previous tokens don't see last token
>>> target_mapping = torch.zeros(
... (1, 1, input_ids.shape[1]), dtype=torch.float
... ) # Shape [1, 1, seq_length] => let's predict one token
>>> target_mapping[
... 0, 0, -1
... ] = 1.0 # Our first (and only) prediction will be the last token of the sequence (the masked token)
>>> outputs = model(input_ids, perm_mask=perm_mask, target_mapping=target_mapping)
>>> next_token_logits = outputs[
... 0
... ] # Output has shape [target_mapping.size(0), target_mapping.size(1), config.vocab_size]
>>> # The same way can the XLNetLMHeadModel be used to be trained by standard auto-regressive language modeling.
>>> input_ids = torch.tensor(
... tokenizer.encode("Hello, my dog is very <mask>", add_special_tokens=False)
... ).unsqueeze(
... 0
... ) # We will predict the masked token
>>> labels = torch.tensor(tokenizer.encode("cute", add_special_tokens=False)).unsqueeze(0)
>>> assert labels.shape[0] == 1, "only one word will be predicted"
>>> perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float)
>>> perm_mask[
... :, :, -1
... ] = 1.0 # Previous tokens don't see last token as is done in standard auto-regressive lm training
>>> target_mapping = torch.zeros(
... (1, 1, input_ids.shape[1]), dtype=torch.float
... ) # Shape [1, 1, seq_length] => let's predict one token
>>> target_mapping[
... 0, 0, -1
... ] = 1.0 # Our first (and only) prediction will be the last token of the sequence (the masked token)
>>> outputs = model(input_ids, perm_mask=perm_mask, target_mapping=target_mapping, labels=labels)
>>> loss = outputs.loss
>>> next_token_logits = (
... outputs.logits
... ) # Logits have shape [target_mapping.size(0), target_mapping.size(1), config.vocab_size]XLNetForSequenceClassification
classe transformers.XLNetForSequenceClassification
< source >( config: XLNetConfig )
Parâmetros
- config (XLNetConfig) — 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() para carregar os pesos do modelo.
Modelo XLNet com uma cabeça de classificação/regressão de sequência no topo (uma camada linear no topo da saída agregada), por exemplo, para tarefas GLUE.
Este modelo herda de PreTrainedModel. 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonemems: typing.Optional[torch.Tensor] = Noneperm_mask: typing.Optional[torch.Tensor] = Nonetarget_mapping: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneinput_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneuse_mems: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → XLNetForSequenceClassificationOutput or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.Tensorde formato(batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- attention_mask (
torch.Tensorde 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.
- mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados (vejamemssaída abaixo). Pode ser usado para acelerar a decodificação sequencial. Os token ids cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados.use_memsdeve ser definido comoTruepara utilizarmems. - perm_mask (
torch.Tensorde forma(batch_size, sequence_length, sequence_length), opcional) — Máscara para indicar o padrão de atenção para cada token de entrada, com valores selecionados em[0, 1]:- se
perm_mask[k, i, j] = 0, i presta atenção a j no lote k; - se
perm_mask[k, i, j] = 1, i não presta atenção a j no lote k.
Se não for definido, cada token atende a todos os outros (atenção bidirecional completa). Usado apenas durante o pré-treinamento (para definir a ordem de fatorização) ou para decodificação sequencial (geração).
- se
- target_mapping (
torch.Tensorde forma(batch_size, num_predict, sequence_length), opcional) — Máscara para indicar os tokens de saída a serem usados. Setarget_mapping[k, i, j] = 1, a i-ésima previsão no lote k está no j-ésimo token. Usado apenas durante o pré-treinamento para previsão parcial ou para decodificação sequencial (geração). - token_type_ids (
torch.Tensorde 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 sentence A,
- 1 corresponde a um token de sentence B.
- input_mask (
torch.Tensorde formabatch_size, sequence_length, opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Negativo deattention_mask, ou seja, com 0 para tokens reais e 1 para preenchimento, mantido para compatibilidade com a base de código original.Valores de máscara selecionados em
[0, 1]:- 1 para tokens que estão mascarados,
- 0 para tokens que não estão mascarados.
Você pode usar apenas um de
input_maskeattention_mask. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - labels (
torch.LongTensorde 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]. Seconfig.num_labels == 1, uma perda de regressão é calculada (perda de erro quadrático médio). Seconfig.num_labels > 1, uma perda de classificação é calculada (entropia cruzada). - use_mems (
bool, opcional) — Indica se os estados de memória devem ser usados para acelerar a decodificação sequencial. Se definido comoTrue, o modelo usará os estados ocultos de passes anteriores para calcular a atenção, o que pode melhorar significativamente o desempenho em tarefas de decodificação sequencial. - output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.
Retorna
XLNetForSequenceClassificationOutput ou tuple(torch.Tensor)
Um XLNetForSequenceClassificationOutput 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 (XLNetConfig) e das entradas.
O método forward de XLNetForSequenceClassification 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
Moduleem 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.Tensorde forma(1,), opcional, retornado quandolabelé fornecido) — Perda de classificação (ou regressão se config.num_labels==1).logits (
torch.Tensorde forma(batch_size, config.num_labels)) — Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax).mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados. Pode ser usado (veja a entradamems) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados.hidden_states (
tuple[torch.Tensor, ...], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com 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 nos cabeçalhos de autoatenção.
Exemplo de classificação de rótulo único:
>>> import torch
>>> from transformers import AutoTokenizer, XLNetForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-large-cased")
>>> 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 = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-large-cased", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...Exemplo de classificação multirótulo:
>>> import torch
>>> from transformers import AutoTokenizer, XLNetForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-large-cased", 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 = XLNetForSequenceClassification.from_pretrained(
... "xlnet/xlnet-large-cased", 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).lossXLNetForMultipleChoice
classe transformers.XLNetForMultipleChoice
< source >( config: XLNetConfig )
Parâmetros
- config (XLNetConfig) — 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() para carregar os pesos do modelo.
O Modelo Xlnet 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. 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneinput_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonemems: typing.Optional[torch.Tensor] = Noneperm_mask: typing.Optional[torch.Tensor] = Nonetarget_mapping: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneuse_mems: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → XLNetForMultipleChoiceOutput or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.LongTensorde 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. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- token_type_ids (
torch.LongTensorde 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 sentence A,
- 1 corresponde a um token de sentence B.
- input_mask (
torch.Tensorde formabatch_size, num_choices, sequence_length, opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Negativo deattention_mask, ou seja, com 0 para tokens reais e 1 para preenchimento, mantido para compatibilidade com a base de código original.Valores de máscara selecionados em
[0, 1]:- 1 para tokens que estão mascarados,
- 0 para tokens que não estão mascarados.
Você pode usar apenas um de
input_maskeattention_mask. - attention_mask (
torch.Tensorde 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.
- mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados (vejamemssaída abaixo). Pode ser usado para acelerar a decodificação sequencial. Os token ids cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados.use_memsdeve ser definido comoTruepara utilizarmems. - perm_mask (
torch.Tensorde forma(batch_size, sequence_length, sequence_length), opcional) — Máscara para indicar o padrão de atenção para cada token de entrada, com valores selecionados em[0, 1]:- se
perm_mask[k, i, j] = 0, i presta atenção a j no lote k; - se
perm_mask[k, i, j] = 1, i não presta atenção a j no lote k.
Se não for definido, cada token atende a todos os outros (atenção bidirecional completa). Usado apenas durante o pré-treinamento (para definir a ordem de fatorização) ou para decodificação sequencial (geração).
- se
- target_mapping (
torch.Tensorde forma(batch_size, num_predict, sequence_length), opcional) — Máscara para indicar os tokens de saída a serem usados. Setarget_mapping[k, i, j] = 1, a i-ésima previsão no lote k está no j-ésimo token. Usado apenas durante o pré-treinamento para previsão parcial ou para decodificação sequencial (geração). - inputs_embeds (
torch.Tensorde forma(batch_size, num_choices, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para o cálculo da perda de classificação de múltipla escolha. Os índices devem estar em `[0, …, - use_mems (
bool, opcional) — Indica se os estados de memória devem ser usados para acelerar a decodificação sequencial. Se definido comoTrue, o modelo usará os estados ocultos de passes anteriores para calcular a atenção, o que pode melhorar significativamente o desempenho em tarefas de decodificação sequencial. - output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.
Retorna
XLNetForMultipleChoiceOutput ou tuple(torch.Tensor)
Um XLNetForMultipleChoiceOutput 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 (XLNetConfig) e das entradas.
O método forward de XLNetForMultipleChoice 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
Moduleem 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.Tensorde forma (1,), opcional, retornado quandolabelsé fornecido) — Perda de classificação.logits (
torch.Tensorde forma(batch_size, num_choices)) — num_choices é a segunda dimensão dos tensores de entrada. (veja input_ids acima).Pontuações de classificação (antes do SoftMax).
mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados. Pode ser usado (veja a entradamems) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados.hidden_states (
tuple[torch.Tensor, ...], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com 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 nos cabeçalhos de autoatenção.
Exemplo:
>>> from transformers import AutoTokenizer, XLNetForMultipleChoice
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForMultipleChoice.from_pretrained("xlnet/xlnet-large-cased")
>>> 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.logitsXLNetForTokenClassification
classe transformers.XLNetForTokenClassification
< source >( config: XLNetConfig )
Parâmetros
- config (XLNetConfig) — 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() para carregar os pesos do modelo.
O transformer Xlnet com uma cabeça de classificação de tokens no topo (uma camada linear sobre a saída dos hidden-states), por exemplo, para tarefas de Reconhecimento de Entidades Nomeadas (NER).
Este modelo herda de 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonemems: typing.Optional[torch.Tensor] = Noneperm_mask: typing.Optional[torch.Tensor] = Nonetarget_mapping: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneinput_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneuse_mems: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → XLNetForTokenClassificationOutput or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.Tensorde formato(batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- attention_mask (
torch.Tensorde 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.
- mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados (vejamemssaída abaixo). Pode ser usado para acelerar a decodificação sequencial. Os token ids cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados.use_memsdeve ser definido comoTruepara utilizarmems. - perm_mask (
torch.Tensorde forma(batch_size, sequence_length, sequence_length), opcional) — Máscara para indicar o padrão de atenção para cada token de entrada, com valores selecionados em[0, 1]:- se
perm_mask[k, i, j] = 0, i presta atenção a j no lote k; - se
perm_mask[k, i, j] = 1, i não presta atenção a j no lote k.
Se não for definido, cada token atende a todos os outros (atenção bidirecional completa). Usado apenas durante o pré-treinamento (para definir a ordem de fatorização) ou para decodificação sequencial (geração).
- se
- target_mapping (
torch.Tensorde forma(batch_size, num_predict, sequence_length), opcional) — Máscara para indicar os tokens de saída a serem usados. Setarget_mapping[k, i, j] = 1, a i-ésima previsão no lote k está no j-ésimo token. Usado apenas durante o pré-treinamento para previsão parcial ou para decodificação sequencial (geração). - token_type_ids (
torch.Tensorde 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 sentence A,
- 1 corresponde a um token de sentence B.
- input_mask (
torch.Tensorde formabatch_size, sequence_length, opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Negativo deattention_mask, ou seja, com 0 para tokens reais e 1 para preenchimento, mantido para compatibilidade com a base de código original.Valores de máscara selecionados em
[0, 1]:- 1 para tokens que estão mascarados,
- 0 para tokens que não estão mascarados.
Você pode usar apenas um de
input_maskeattention_mask. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para o cálculo da perda de classificação de múltipla escolha. Os índices devem estar em[0, ..., num_choices], onde num_choices é o tamanho da segunda dimensão dos tensors de entrada. (veja input_ids acima) - use_mems (
bool, opcional) — Se deve usar estados de memória para acelerar a decodificação sequencial. Se definido comoTrue, o modelo usará os estados ocultos de passes anteriores para calcular a atenção, o que pode melhorar significativamente o desempenho em tarefas de decodificação sequencial. Estados de memória para acelerar a decodificação sequencial. Se definido comoTrue, o modelo usará os estados ocultos de passes anteriores para calcular a atenção, o que pode melhorar significativamente o desempenho em tarefas de decodificação sequencial. - output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.
Retorna
XLNetForTokenClassificationOutput ou tuple(torch.Tensor)
Um XLNetForTokenClassificationOutput 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 (XLNetConfig) e das entradas.
O método forward de XLNetForTokenClassification 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
Moduleem 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.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de classificação.logits (
torch.Tensorde forma(batch_size, sequence_length, config.num_labels)) — Pontuações de classificação (antes do SoftMax).mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados. Pode ser usado (veja a entradamems) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados.hidden_states (
tuple[torch.Tensor, ...], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com 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 nos cabeçalhos de autoatenção.
Exemplo:
>>> from transformers import AutoTokenizer, XLNetForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForTokenClassification.from_pretrained("xlnet/xlnet-large-cased")
>>> 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)
...XLNetForQuestionAnsweringSimple
classe transformers.XLNetForQuestionAnsweringSimple
< source >( config: XLNetConfig )
Parâmetros
- config (XLNetConfig) — 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() para carregar os pesos do modelo.
Modelo XLNet com uma cabeça de classificação de span no topo para tarefas de question-answering extrativo, como SQuAD (camadas lineares no topo da saída dos hidden-states para calcular span start logits e span end logits).
Este modelo herda de 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonemems: typing.Optional[torch.Tensor] = Noneperm_mask: typing.Optional[torch.Tensor] = Nonetarget_mapping: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneinput_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonestart_positions: typing.Optional[torch.Tensor] = Noneend_positions: typing.Optional[torch.Tensor] = Noneuse_mems: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → XLNetForQuestionAnsweringSimpleOutput or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.Tensorde formato(batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- attention_mask (
torch.Tensorde 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.
- mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados (vejamemssaída abaixo). Pode ser usado para acelerar a decodificação sequencial. Os token ids cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados.use_memsdeve ser definido comoTruepara utilizarmems. - perm_mask (
torch.Tensorde forma(batch_size, sequence_length, sequence_length), opcional) — Máscara para indicar o padrão de atenção para cada token de entrada, com valores selecionados em[0, 1]:- se
perm_mask[k, i, j] = 0, i presta atenção a j no lote k; - se
perm_mask[k, i, j] = 1, i não presta atenção a j no lote k.
Se não for definido, cada token atende a todos os outros (atenção bidirecional completa). Usado apenas durante o pré-treinamento (para definir a ordem de fatorização) ou para decodificação sequencial (geração).
- se
- target_mapping (
torch.Tensorde forma(batch_size, num_predict, sequence_length), opcional) — Máscara para indicar os tokens de saída a serem usados. Setarget_mapping[k, i, j] = 1, a i-ésima previsão no lote k está no j-ésimo token. Usado apenas durante o pré-treinamento para previsão parcial ou para decodificação sequencial (geração). - token_type_ids (
torch.Tensorde 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 sentence A,
- 1 corresponde a um token de sentence B.
- input_mask (
torch.Tensorde formabatch_size, sequence_length, opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Negativo deattention_mask, ou seja, com 0 para tokens reais e 1 para preenchimento, mantido para compatibilidade com a base de código original.Valores de máscara selecionados em
[0, 1]:- 1 para tokens que estão mascarados,
- 0 para tokens que não estão mascarados.
Você pode usar apenas um de
input_maskeattention_mask. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - start_positions (
torch.Tensorde 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.Tensorde forma(batch_size,), opcional) — Rótulos para a posição (índice) do fim 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. - use_mems (
bool, opcional) — Indica se os estados de memória devem ser usados para acelerar a decodificação sequencial. Se definido comoTrue, o modelo usará os estados ocultos de passes anteriores para calcular a atenção, o que pode melhorar significativamente o desempenho em tarefas de decodificação sequencial. - output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.
Retorna
XLNetForQuestionAnsweringSimpleOutput ou tuple(torch.Tensor)
Um XLNetForQuestionAnsweringSimpleOutput 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 (XLNetConfig) e das entradas.
O método forward de XLNetForQuestionAnsweringSimple 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
Moduleem 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.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — 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.Tensorde forma(batch_size, sequence_length,)) — Pontuações de início de trecho (antes do SoftMax).end_logits (
torch.Tensorde forma(batch_size, sequence_length,)) — Pontuações de fim de trecho (antes do SoftMax).mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados. Pode ser usado (veja a entradamems) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados.hidden_states (
tuple[torch.Tensor, ...], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com 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 nos cabeçalhos de autoatenção.
Exemplo:
>>> from transformers import AutoTokenizer, XLNetForQuestionAnsweringSimple
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForQuestionAnsweringSimple.from_pretrained("xlnet/xlnet-large-cased")
>>> 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)
...XLNetForQuestionAnswering
classe transformers.XLNetForQuestionAnswering
< source >( config: XLNetConfig )
Parâmetros
- config (XLNetConfig) — 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() para carregar os pesos do modelo.
O transformer Xlnet com uma cabeça de classificação de span 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. 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonemems: typing.Optional[torch.Tensor] = Noneperm_mask: typing.Optional[torch.Tensor] = Nonetarget_mapping: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneinput_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonestart_positions: typing.Optional[torch.Tensor] = Noneend_positions: typing.Optional[torch.Tensor] = Noneis_impossible: typing.Optional[torch.Tensor] = Nonecls_index: typing.Optional[torch.Tensor] = Nonep_mask: typing.Optional[torch.Tensor] = Noneuse_mems: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → XLNetForQuestionAnsweringOutput or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.Tensorde formato(batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- attention_mask (
torch.Tensorde 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.
- mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados (vejamemssaída abaixo). Pode ser usado para acelerar a decodificação sequencial. Os token ids cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados.use_memsdeve ser definido comoTruepara utilizarmems. - perm_mask (
torch.Tensorde forma(batch_size, sequence_length, sequence_length), opcional) — Máscara para indicar o padrão de atenção para cada token de entrada, com valores selecionados em[0, 1]:- se
perm_mask[k, i, j] = 0, i presta atenção a j no lote k; - se
perm_mask[k, i, j] = 1, i não presta atenção a j no lote k.
Se não for definido, cada token atende a todos os outros (atenção bidirecional completa). Usado apenas durante o pré-treinamento (para definir a ordem de fatorização) ou para decodificação sequencial (geração).
- se
- target_mapping (
torch.Tensorde forma(batch_size, num_predict, sequence_length), opcional) — Máscara para indicar os tokens de saída a serem usados. Setarget_mapping[k, i, j] = 1, a i-ésima previsão no lote k está no j-ésimo token. Usado apenas durante o pré-treinamento para previsão parcial ou para decodificação sequencial (geração). - token_type_ids (
torch.Tensorde 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 sentence A,
- 1 corresponde a um token de sentence B.
- input_mask (
torch.Tensorde formabatch_size, sequence_length, opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Negativo deattention_mask, ou seja, com 0 para tokens reais e 1 para preenchimento, mantido para compatibilidade com a base de código original.Valores de máscara selecionados em
[0, 1]:- 1 para tokens que estão mascarados,
- 0 para tokens que não estão mascarados.
Você pode usar apenas um de
input_maskeattention_mask. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - start_positions (
torch.Tensorde 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.Tensorde forma(batch_size,), opcional) — Rótulos para a posição (índice) do fim 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. - is_impossible (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos indicando se uma pergunta tem resposta ou não (SQuAD 2.0) - cls_index (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para a posição (índice) do token de classificação a ser usado como entrada para o cálculo da plausibilidade da resposta. - p_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara opcional de tokens que não podem estar nas respostas (por exemplo, [CLS], [PAD], …). 1.0 significa que o token deve ser mascarado. 0.0 significa que o token não é mascarado. - use_mems (
bool, opcional) — Indica se os estados de memória devem ser usados para acelerar a decodificação sequencial. Se definido comoTrue, o modelo usará os estados ocultos de passes anteriores para calcular a atenção, o que pode melhorar significativamente o desempenho em tarefas de decodificação sequencial. - output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.
Retorna
XLNetForQuestionAnsweringOutput ou tuple(torch.Tensor)
Um XLNetForQuestionAnsweringOutput 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 (XLNetConfig) e das entradas.
O método forward de XLNetForQuestionAnswering 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
Moduleem 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.Tensorde forma(1,), opcional, retornado sestart_positionseend_positionsforem fornecidos) — Perda de classificação como a soma das perdas de classificação do token inicial, do token final (e de is_impossible, se fornecido).start_top_log_probs (
torch.Tensorde forma(batch_size, config.start_n_top), opcional, retornado sestart_positionsouend_positionsnão forem fornecidos) — Probabilidades logarítmicas para as config.start_n_top melhores possibilidades de tokens de início (beam-search).start_top_index (
torch.LongTensorde forma(batch_size, config.start_n_top), opcional, retornado sestart_positionsouend_positionsnão for fornecido) — Índices para as config.start_n_top melhores possibilidades de tokens de início (beam-search).end_top_log_probs (
torch.Tensorde forma(batch_size, config.start_n_top * config.end_n_top), opcional, retornado sestart_positionsouend_positionsnão forem fornecidos) — Probabilidades logarítmicas para asconfig.start_n_top * config.end_n_topmelhores possibilidades de tokens finais (beam-search).end_top_index (
torch.LongTensorde forma(batch_size, config.start_n_top * config.end_n_top), opcional, retornado sestart_positionsouend_positionsnão for fornecido) — Índices para asconfig.start_n_top * config.end_n_topmelhores possibilidades de tokens de fim (beam-search).cls_logits (
torch.Tensorde forma(batch_size,), opcional, retornado sestart_positionsouend_positionsnão forem fornecidos) — Probabilidades logarítmicas para o rótulois_impossibledas respostas.mems (
list[torch.Tensor]de comprimentoconfig.n_layers) — Contém hidden-states pré-computados. Pode ser usado (veja a entradamems) para acelerar a decodificação sequencial. Os ids de tokens cujo passado é fornecido a este modelo não devem ser passados comoinput_ids, pois já foram computados.hidden_states (
tuple[torch.Tensor, ...], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com 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 nos cabeçalhos de autoatenção.
Exemplo:
>>> from transformers import AutoTokenizer, XLNetForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = XLNetForQuestionAnswering.from_pretrained("xlnet/xlnet-base-cased")
>>> input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(
... 0
... ) # Batch size 1
>>> start_positions = torch.tensor([1])
>>> end_positions = torch.tensor([3])
>>> outputs = model(input_ids, start_positions=start_positions, end_positions=end_positions)
>>> loss = outputs.loss