transformers/main/pt/model_doc/bert.md

BERT

BERT é um transformer bidirecional pré-treinado em texto não rotulado para prever tokens mascarados em uma frase e prever se uma frase segue outra. A ideia principal é que, ao mascarar aleatoriamente alguns tokens, o modelo pode ser treinado com o texto à esquerda e à direita, proporcionando uma compreensão mais aprofundada. O BERT também é muito versátil, pois suas representações de linguagem aprendidas podem ser adaptadas para outras tarefas de PLN por meio do ajuste fino de uma camada ou cabeça adicional.

Você pode encontrar todos os checkpoints originais do BERT na coleção BERT.

Clique nos modelos BERT na barra lateral à direita para ver mais exemplos de como aplicar o BERT a diferentes tarefas de linguagem.

Defina use_kernels=True em from_pretrained() para substituir camadas compatíveis por kernels otimizados do Hub. Consulte Carregando kernels para saber mais.

O exemplo abaixo demonstra como prever o token [MASK] com Pipeline, AutoModel e pela linha de comando.

from transformers import pipeline

pipeline = pipeline(
    task="fill-mask",
    model="google-bert/bert-base-uncased",
    device=0
)
pipeline("Plants create [MASK] through a process known as photosynthesis.")

import torch

from transformers import AutoModelForMaskedLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(
    "google-bert/bert-base-uncased",
)
model = AutoModelForMaskedLM.from_pretrained(
    "google-bert/bert-base-uncased",
    device_map="auto",
    attn_implementation="sdpa"
)
inputs = tokenizer("Plants create [MASK] through a process known as photosynthesis.", return_tensors="pt").to(model.device)

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

masked_index = torch.where(inputs['input_ids'] == tokenizer.mask_token_id)[1]
predicted_token_id = predictions[0, masked_index].argmax(dim=-1)
predicted_token = tokenizer.decode(predicted_token_id)

print(f"The predicted token is: {predicted_token}")

Observações

• As entradas devem ser preenchidas à direita, pois o BERT usa embeddings de posição absoluta.

BertConfig[[transformers.BertConfig]]

transformers.BertConfig[[transformers.BertConfig]]

transformers.BertConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 512, type_vocab_size: int = 2, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, use_cache: bool = True, classifier_dropout: float | int | None = None, is_decoder: bool = False, add_cross_attention: bool = False, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, tie_word_embeddings: bool = True)

Origem

Parâmetros:

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

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

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

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

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

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

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

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

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

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

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

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

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

use_cache (bool, opcional, padrão True) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se config.is_decoder=True ou quando o modelo for um modelo generativo somente de decodificador.

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

is_decoder (bool, opcional, padrão False) : Indica se o modelo é usado como decodificador ou não. Se False, o modelo é usado como codificador.

add_cross_attention (bool, opcional, padrão False) : Se as camadas de atenção cruzada devem ser adicionadas ao modelo.

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

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

tie_word_embeddings (bool, opcional, padrão True) : Se deve vincular as embeddings de pesos de acordo com o mapeamento tied_weights_keys do modelo.

Esta é a classe de configuração para armazenar a configuração de um BertModel. Ela é usada para instanciar um modelo Bert de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os valores padrão resultará em uma configuração semelhante à do google-bert/bert-base-uncased

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Leia a documentação de PreTrainedConfig para mais informações.

Exemplos:

>>> from transformers import BertConfig, BertModel

>>> # Initializing a BERT google-bert/bert-base-uncased style configuration
>>> configuration = BertConfig()

>>> # Initializing a model (with random weights) from the google-bert/bert-base-uncased style configuration
>>> model = BertModel(configuration)

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

BertTokenizer[[transformers.BertTokenizer]]

transformers.BertTokenizer[[transformers.BertTokenizer]]

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

Origem

Parâmetros:

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

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

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

sep_token (str, opcional, padrão "[SEP]") : O token separador, usado ao construir uma sequência a partir de múltiplas sequências, 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 ao realizar classificação de sequência (classificação da sequência inteira, em vez de 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.

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

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

Construa um tokenizador BERT (baseado na biblioteca tokenizers da HuggingFace). Baseado em WordPiece.

Este tokenizer 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[[transformers.BertTokenizer.get_special_tokens_mask]]

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

Origem

Parâmetros:

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

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

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

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

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

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

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

save_vocabulary[[transformers.BertTokenizer.save_vocabulary]]

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

Origem

BertTokenizerLegacy[[transformers.BertTokenizerLegacy]]

transformers.BertTokenizerLegacy[[transformers.BertTokenizerLegacy]]

transformers.BertTokenizerLegacy(vocab_file, do_lower_case = True, do_basic_tokenize = True, never_split = None, unk_token = '[UNK]', sep_token = '[SEP]', pad_token = '[PAD]', cls_token = '[CLS]', mask_token = '[MASK]', tokenize_chinese_chars = True, strip_accents = None, clean_up_tokenization_spaces = True, **kwargs)

Origem

Parâmetros:

vocab_file (str) : Arquivo contendo o vocabulário.

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

do_basic_tokenize (bool, opcional, padrão True) : Se deve ou não realizar uma tokenização básica antes do WordPiece.

never_split (Iterable, opcional) : Coleção de tokens que nunca serão divididos durante a tokenização. Tem efeito apenas quando do_basic_tokenize=True

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

sep_token (str, opcional, padrão "[SEP]") : O token separador, usado ao construir uma sequência a partir de múltiplas sequências, por exemplo, duas sequências para classificação de sequência ou um texto e uma pergunta para resposta a perguntas. Também é usado como o último token de uma sequência construída com tokens especiais.

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 ao realizar classificação de sequência (classificação da sequência inteira, em vez de 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.

tokenize_chinese_chars (bool, opcional, padrão True) : Se deve ou não tokenizar caracteres chineses. Isso provavelmente deve ser desativado para o japonês (veja esta questão).

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

clean_up_tokenization_spaces (bool, opcional, padrão True) : Indica se deve ou não limpar os espaços após a decodificação. A limpeza consiste em remover possíveis artefatos, como espaços extras.

Construa um tokenizador BERT. Baseado em WordPiece.

Este tokenizer herda de PreTrainedTokenizer, que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses métodos.

build_inputs_with_special_tokens[[transformers.BertTokenizerLegacy.build_inputs_with_special_tokens]]

build_inputs_with_special_tokens(token_ids_0: list, token_ids_1: list[int] | None = None)

Origem

Parâmetros:

token_ids_0 (List[int]) : Lista de IDs aos quais os tokens especiais serão adicionados.

token_ids_1 (List[int], opcional) : Lista opcional de IDs para pares de sequências.

Retorna: List[int]

Lista de IDs de entrada com os tokens especiais apropriados.

Construa as entradas do modelo a partir de uma sequência ou de um par de sequências para tarefas de classificação de sequência, concatenando e adicionando tokens especiais. Uma sequência BERT tem o seguinte formato:

• sequência única: [CLS] X [SEP]
• par de sequências: [CLS] A [SEP] B [SEP]

convert_tokens_to_string[[transformers.BertTokenizerLegacy.convert_tokens_to_string]]

convert_tokens_to_string(tokens)

Origem

Converte uma sequência de tokens (string) em uma única string.

get_special_tokens_mask[[transformers.BertTokenizerLegacy.get_special_tokens_mask]]

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

Origem

Parâmetros:

token_ids_0 (List[int]) : Lista de IDs.

token_ids_1 (List[int], opcional) : Lista opcional de IDs para pares de sequências.

already_has_special_tokens (bool, opcional, padrão False) : Indica se a lista de tokens já está formatada com tokens especiais para o modelo.

Retorna: List[int]

Uma lista de inteiros no intervalo [0, 1]: 1 para um token especial, 0 para um token de sequência.

Recupera os ids de sequência de uma lista de tokens que não possui tokens especiais adicionados. Este método é chamado ao adicionar tokens especiais usando o método prepare_for_model do tokenizer.

BertModel[[transformers.BertModel]]

transformers.BertModel[[transformers.BertModel]]

transformers.BertModel(config: BertConfig, add_pooling_layer = True)

Origem

Parâmetros:

config (BertConfig) : 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.

add_pooling_layer (bool, opcional, padrão True) : Se deve adicionar uma camada de pooling

O modelo pode atuar como um codificador (com apenas autoatenção) e também como um decodificador, no qual uma camada de atenção cruzada é adicionada entre as camadas de autoatenção, seguindo a arquitetura descrita em Attention is all you need, de Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser e Illia Polosukhin.

Para se comportar como um decoder, o modelo precisa ser inicializado com o argumento is_decoder da configuração definido como True. Para ser usado em um modelo Seq2Seq, o modelo precisa ser inicializado com os argumentos is_decoder e add_cross_attention definidos como True; nesse caso, espera-se que encoder_hidden_states seja fornecido como entrada para a passagem de forward.

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 e comportamento gerais.

forward[[transformers.BertModel.forward]]

forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)

Origem

Parâmetros:

input_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada?

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

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

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

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

encoder_hidden_states (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) : Sequência de hidden-states na saída da última camada do encoder. Usada na cross-attention se o modelo estiver configurado como um decoder.

encoder_attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento da entrada do codificador. Essa máscara é usada na atenção cruzada se o modelo estiver configurado como um decodificador. Valores de máscara selecionados em [0, 1]: - 1 para tokens que não estão mascarados, - 0 para tokens que estão mascarados.

past_key_values (~cache_utils.Cache, opcional) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos past_key_values retornados pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True. Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de kv cache. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se past_key_values forem usados, espera-se que o usuário insira apenas input_ids não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma (batch_size, unprocessed_length) em vez de todos os input_ids com a forma (batch_size, sequence_length).

use_cache (bool, opcional) : Se definido como True, os estados de chave-valor de past_key_values são retornados e podem ser usados para acelerar a decodificação (veja past_key_values).

Retorna: BaseModelOutputWithPoolingAndCrossAttentions ou tuple(torch.Tensor)

Um BaseModelOutputWithPoolingAndCrossAttentions 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 (BertConfig) e das entradas.

O método forward do BertModel sobrescreve o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

• last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) -- Sequência de estados ocultos na saída da última camada do modelo.

• pooler_output (torch.Tensor de forma (batch_size, hidden_size)) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.

• hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) -- Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma (batch_size, sequence_length, hidden_size).

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

• attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) -- Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).

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

• cross_attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True e config.add_cross_attention=True são passados, ou quando config.output_attentions=True) -- Tupla de torch.Tensor (uma para cada camada) de forma (batch_size, num_heads, sequence_length, sequence_length).

  Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada.

• past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) -- Trata-se de uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

  Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se config.is_encoder_decoder=True, nos blocos de atenção cruzada) que podem ser usados (veja a entrada past_key_values) para acelerar a decodificação sequencial.

BertForPreTraining[[transformers.BertForPreTraining]]

transformers.BertForPreTraining[[transformers.BertForPreTraining]]

transformers.BertForPreTraining(config: BertConfig)

Origem

Parâmetros:

config (BertConfig) : 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 Bert com duas camadas de saída no topo, conforme realizado durante o pré-treinamento: uma camada de masked language modeling e uma camada de next sentence prediction (classification).

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 e comportamento gerais.

forward[[transformers.BertForPreTraining.forward]]

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

Origem

Parâmetros:

input_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada?

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

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

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

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

labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) : Rótulos para calcular a perda de modelagem de linguagem mascarada. Os índices devem estar em [-100, 0, ..., config.vocab_size] (veja a docstring de input_ids). Tokens com índices definidos como -100 são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em [0, ..., config.vocab_size]

next_sentence_label (torch.LongTensor de forma (batch_size,), opcional) : Rótulos para calcular a perda de previsão da próxima sequência (classificação). A entrada deve ser um par de sequências (veja a docstring de input_ids). Os índices devem estar em [0, 1]: - 0 indica que a sequência B é uma continuação da sequência A, - 1 indica que a sequência B é uma sequência aleatória.

Retorna: BertForPreTrainingOutput ou tuple(torch.Tensor)

Um BertForPreTrainingOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False), contendo diversos elementos, dependendo da configuração (BertConfig) e das entradas.

O método forward de BertForPreTraining sobrescreve o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

• loss (*optional*, returned when labels is provided, torch.Tensor of shape (1,)) -- Perda total como a soma da perda de modelagem de linguagem mascarada e da perda de previsão da próxima sequência (classificação).

• prediction_logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).

• seq_relationship_logits (torch.Tensor de forma (batch_size, 2)) -- Pontuações de previsão da cabeça de previsão da próxima sequência (classificação) (pontuações de continuação True/False antes do SoftMax).

• hidden_states (tuple[torch.Tensor], opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) -- Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

• attentions (tuple[torch.Tensor], opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) -- Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).

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

Exemplo:

>>> from transformers import AutoTokenizer, BertForPreTraining
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
>>> model = BertForPreTraining.from_pretrained("google-bert/bert-base-uncased")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> prediction_logits = outputs.prediction_logits
>>> seq_relationship_logits = outputs.seq_relationship_logits

BertLMHeadModel[[transformers.BertLMHeadModel]]

transformers.BertLMHeadModel[[transformers.BertLMHeadModel]]

transformers.BertLMHeadModel(config: BertConfig)

Origem

Parâmetros:

config (BertConfig) : 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 Bert com uma cabeça de language modeling no topo para ajuste fino de CLM.

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 e comportamento gerais.

forward[[transformers.BertLMHeadModel.forward]]

forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)

Origem

Parâmetros:

input_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada?

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

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

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

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

encoder_hidden_states (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) : Sequência de hidden-states na saída da última camada do encoder. Usada na cross-attention se o modelo estiver configurado como um decoder.

encoder_attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento da entrada do codificador. Essa máscara é usada na atenção cruzada se o modelo estiver configurado como um decodificador. Valores de máscara selecionados em [0, 1]: - 1 para tokens que não estão mascarados, - 0 para tokens que estão mascarados.

labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) : Rótulos para calcular a perda de modelagem de linguagem da esquerda para a direita (previsão da próxima palavra). Os índices devem estar em [-100, 0, ..., config.vocab_size] (veja a docstring de input_ids). Tokens com índices definidos como -100 são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em [0, ..., config.vocab_size]

past_key_values (~cache_utils.Cache, opcional) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos past_key_values retornados pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True. Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de kv cache. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se past_key_values forem usados, espera-se que o usuário insira apenas input_ids não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma (batch_size, unprocessed_length) em vez de todos os input_ids com a forma (batch_size, sequence_length).

use_cache (bool, opcional) : Se definido como True, os estados de chave-valor de past_key_values são retornados e podem ser usados para acelerar a decodificação (veja past_key_values).

logits_to_keep (Union[int, torch.Tensor], opcional, padrão 0) : Se for um int, calcula os logits para os últimos logits_to_keep tokens. Se for 0, calcula os logits para todos os input_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 um torch.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: CausalLMOutputWithCrossAttentions ou tuple(torch.Tensor)

Um CausalLMOutputWithCrossAttentions ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False), composto por vários elementos dependendo da configuração (BertConfig) e das entradas.

O método forward do BertLMHeadModel substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

• loss (torch.Tensor de forma (1,), opcional, retornado quando labels é fornecido) -- Perda de modelagem de linguagem (para previsão do próximo token).

• logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).

• hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) -- Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma (batch_size, sequence_length, hidden_size).

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

• attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) -- Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).

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

• cross_attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) -- Tupla de torch.Tensor (uma para cada camada) de forma (batch_size, num_heads, sequence_length, sequence_length).

  Pesos das atenções cruzadas após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada.

• past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) -- Trata-se de uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

  Contém estados ocultos pré-computados (chaves e valores nos blocos de atenção) que podem ser usados (veja a entrada past_key_values) para acelerar a decodificação sequencial.

Exemplo:

>>> import torch
>>> from transformers import AutoTokenizer, BertLMHeadModel

>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
>>> model = BertLMHeadModel.from_pretrained("google-bert/bert-base-uncased")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits

BertForMaskedLM[[transformers.BertForMaskedLM]]

transformers.BertForMaskedLM[[transformers.BertForMaskedLM]]

transformers.BertForMaskedLM(config: BertConfig)

Origem

Parâmetros:

config (BertConfig) : 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 Bert com uma cabeça de language modeling 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 e comportamento gerais.

forward[[transformers.BertForMaskedLM.forward]]

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

Origem

Parâmetros:

input_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada?

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

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

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

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

encoder_hidden_states (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) : Sequência de hidden-states na saída da última camada do encoder. Usada na cross-attention se o modelo estiver configurado como um decoder.

encoder_attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento da entrada do codificador. Essa máscara é usada na atenção cruzada se o modelo estiver configurado como um decodificador. Valores de máscara selecionados em [0, 1]: - 1 para tokens que não estão mascarados, - 0 para tokens que estão mascarados.

labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) : Rótulos para calcular a perda de modelagem de linguagem mascarada. Os índices devem estar em [-100, 0, ..., config.vocab_size] (veja a docstring de input_ids). Tokens com índices definidos como -100 são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em [0, ..., config.vocab_size].

Retorna: MaskedLMOutput ou tuple(torch.Tensor)

Um MaskedLMOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False), composto por diversos elementos, dependendo da configuração (BertConfig) e das entradas.

O método forward de BertForMaskedLM sobrescreve o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

• loss (torch.Tensor de forma (1,), opcional, retornado quando labels é fornecido) -- Perda de modelagem de linguagem mascarada (MLM).

• logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).

• hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) -- Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma (batch_size, sequence_length, hidden_size).

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

• attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) -- Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).

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

Exemplo:

>>> from transformers import AutoTokenizer, BertForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
>>> model = BertForMaskedLM.from_pretrained("google-bert/bert-base-uncased")

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

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

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

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

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

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

BertForNextSentencePrediction[[transformers.BertForNextSentencePrediction]]

transformers.BertForNextSentencePrediction[[transformers.BertForNextSentencePrediction]]

transformers.BertForNextSentencePrediction(config: BertConfig)

Origem

Parâmetros:

config (BertConfig) : 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 Bert com um cabeçalho de next sentence prediction (classification) 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 e comportamento gerais.

forward[[transformers.BertForNextSentencePrediction.forward]]

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

Origem

Parâmetros:

input_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada?

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

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

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

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

labels (torch.LongTensor de forma (batch_size,), opcional) : Rótulos para calcular a perda de previsão da próxima sequência (classificação). A entrada deve ser um par de sequências (veja a docstring de input_ids). Os índices devem estar em [0, 1]: - 0 indica que a sequência B é uma continuação da sequência A, - 1 indica que a sequência B é uma sequência aleatória.

Retorna: NextSentencePredictorOutput ou tuple(torch.Tensor)

Um NextSentencePredictorOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False), composto por vários elementos dependendo da configuração (BertConfig) e das entradas.

O método forward de BertForNextSentencePrediction sobrescreve o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

• loss (torch.Tensor de forma (1,), opcional, retornado quando next_sentence_label é fornecido) -- Perda de previsão da próxima sequência (classificação).

• logits (torch.Tensor de forma (batch_size, 2)) -- Pontuações de previsão da cabeça de previsão da próxima sequência (classificação) (pontuações de continuação True/False antes do SoftMax).

• hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) -- Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma (batch_size, sequence_length, hidden_size).

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

• attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) -- Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).

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

Exemplo:

>>> from transformers import AutoTokenizer, BertForNextSentencePrediction
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
>>> model = BertForNextSentencePrediction.from_pretrained("google-bert/bert-base-uncased")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> next_sentence = "The sky is blue due to the shorter wavelength of blue light."
>>> encoding = tokenizer(prompt, next_sentence, return_tensors="pt")

>>> outputs = model(**encoding, labels=torch.LongTensor([1]))
>>> logits = outputs.logits
>>> assert logits[0, 0] < logits[0, 1]  # next sentence was random

BertForSequenceClassification[[transformers.BertForSequenceClassification]]

transformers.BertForSequenceClassification[[transformers.BertForSequenceClassification]]

transformers.BertForSequenceClassification(config: BertConfig)

Origem

Parâmetros:

config (BertConfig) : 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 transformer Bert com uma cabeça de classificação/regressão de sequência no topo (uma camada linear sobre a 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 e comportamento gerais.

forward[[transformers.BertForSequenceClassification.forward]]

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

Origem

Parâmetros:

input_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada?

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

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

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

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

labels (torch.LongTensor de forma (batch_size,), opcional) : Rótulos para o cálculo da perda de classificação/regressão de sequência. Os índices devem estar em [0, ..., config.num_labels - 1]. Se config.num_labels == 1, uma perda de regressão é calculada (perda de erro quadrático médio). Se config.num_labels > 1, uma perda de classificação é calculada (entropia cruzada).

Retorna: SequenceClassifierOutput ou tuple(torch.Tensor)

Um SequenceClassifierOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False), composto por diversos elementos, dependendo da configuração (BertConfig) e das entradas.

O método forward de BertForSequenceClassification sobrescreve o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

• loss (torch.Tensor de forma (1,), opcional, retornado quando labels é fornecido) -- Perda de classificação (ou de regressão se config.num_labels==1).

• logits (torch.Tensor de forma (batch_size, config.num_labels)) -- Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax).

• hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) -- Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma (batch_size, sequence_length, hidden_size).

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

• attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) -- Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).

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

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

>>> import torch
>>> from transformers import AutoTokenizer, BertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
>>> model = BertForSequenceClassification.from_pretrained("google-bert/bert-base-uncased")

>>> 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 = BertForSequenceClassification.from_pretrained("google-bert/bert-base-uncased", 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, BertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
>>> model = BertForSequenceClassification.from_pretrained("google-bert/bert-base-uncased", 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 = BertForSequenceClassification.from_pretrained(
...     "google-bert/bert-base-uncased", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss

BertForMultipleChoice[[transformers.BertForMultipleChoice]]

transformers.BertForMultipleChoice[[transformers.BertForMultipleChoice]]

transformers.BertForMultipleChoice(config: BertConfig)

Origem

Parâmetros:

config (BertConfig) : 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 Bert 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 e comportamento gerais.

forward[[transformers.BertForMultipleChoice.forward]]

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

Origem

Parâmetros:

input_ids (torch.LongTensor de forma (batch_size, num_choices, sequence_length)) : Índices dos tokens da sequência de entrada no vocabulário. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada?

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

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

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

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

labels (torch.LongTensor de forma (batch_size,), opcional) : Rótulos para calcular a perda de classificação de múltipla escolha. Os índices devem estar em [0, ..., num_choices-1], onde num_choices é o tamanho da segunda dimensão dos tensores de entrada. (Veja input_ids acima)

Retorna: MultipleChoiceModelOutput ou tuple(torch.Tensor)

Um MultipleChoiceModelOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo diversos elementos, dependendo da configuração (BertConfig) e das entradas.

O método forward de BertForMultipleChoice substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

• loss (torch.Tensor de forma (1,), opcional, retornado quando labels é fornecido) -- Perda de classificação.

• logits (torch.Tensor de forma (batch_size, num_choices)) -- num_choices é a segunda dimensão dos tensors de entrada. (veja input_ids acima).

  Pontuações de classificação (antes do SoftMax).

• hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) -- Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma (batch_size, sequence_length, hidden_size).

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

• attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) -- Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).

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

Exemplo:

>>> from transformers import AutoTokenizer, BertForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
>>> model = BertForMultipleChoice.from_pretrained("google-bert/bert-base-uncased")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits

BertForTokenClassification[[transformers.BertForTokenClassification]]

transformers.BertForTokenClassification[[transformers.BertForTokenClassification]]

transformers.BertForTokenClassification(config: BertConfig)

Origem

Parâmetros:

config (BertConfig) : 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 Bert com uma cabeça de classificação de tokens no topo (uma camada linear sobre a saída dos estados ocultos), por exemplo, para tarefas de Reconhecimento de Entidades Nomeadas (NER).

Este modelo herda de PreTrainedModel. 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 e comportamento gerais.

forward[[transformers.BertForTokenClassification.forward]]

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

Origem

Parâmetros:

input_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada?

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

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

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

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

labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) : Rótulos para calcular a perda de classificação de tokens. Os índices devem estar em [0, ..., config.num_labels - 1].

Retorna: TokenClassifierOutput ou tuple(torch.Tensor)

Um TokenClassifierOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False), composto por diversos elementos, dependendo da configuração (BertConfig) e das entradas.

O método forward de BertForTokenClassification sobrescreve o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

• loss (torch.Tensor de forma (1,), opcional, retornado quando labels é fornecido) -- Perda de classificação.

• logits (torch.Tensor de forma (batch_size, sequence_length, config.num_labels)) -- Pontuações de classificação (antes do SoftMax).

• hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) -- Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma (batch_size, sequence_length, hidden_size).

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

• attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) -- Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).

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

Exemplo:

>>> from transformers import AutoTokenizer, BertForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
>>> model = BertForTokenClassification.from_pretrained("google-bert/bert-base-uncased")

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

BertForQuestionAnswering[[transformers.BertForQuestionAnswering]]

transformers.BertForQuestionAnswering[[transformers.BertForQuestionAnswering]]

transformers.BertForQuestionAnswering(config: BertConfig)

Origem

Parâmetros:

config (BertConfig) : 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 Bert com uma cabeça de classificação de spans no topo para tarefas de question-answering extrativo, como SQuAD (uma camada linear no topo da saída dos hidden-states para calcular span start logits e span end logits).

Este modelo herda de PreTrainedModel. 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 e comportamento gerais.

forward[[transformers.BertForQuestionAnswering.forward]]

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

Origem

Parâmetros:

input_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada?

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

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

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

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

start_positions (torch.Tensor de forma (batch_size,), opcional) : Rótulos para a posição (índice) do início do trecho rotulado para o cálculo da perda de classificação de tokens. As posições são limitadas ao comprimento da sequência (sequence_length). Posições fora da sequência não são consideradas no cálculo da perda.

end_positions (torch.Tensor de forma (batch_size,), opcional) : Rótulos para a posição (índice) do final do trecho rotulado para o cálculo da perda de classificação de tokens. As posições são limitadas ao comprimento da sequência (sequence_length). Posições fora da sequência não são consideradas no cálculo da perda.

Retorna: QuestionAnsweringModelOutput ou tuple(torch.Tensor)

Um QuestionAnsweringModelOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) composto por vários elementos, dependendo da configuração (BertConfig) e das entradas.

O método forward de BertForQuestionAnswering substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

• loss (torch.Tensor de forma (1,), opcional, retornado quando labels é fornecida) -- A perda total de extração de spans é a soma de uma Cross-Entropy para as posições de início e fim.

• start_logits (torch.Tensor de forma (batch_size, sequence_length)) -- Pontuações de início de span (antes do SoftMax).

• end_logits (torch.Tensor de forma (batch_size, sequence_length)) -- Pontuações de fim de span (antes do SoftMax).

• hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) -- Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma (batch_size, sequence_length, hidden_size).

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

• attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) -- Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).

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

Exemplo:

>>> from transformers import AutoTokenizer, BertForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
>>> model = BertForQuestionAnswering.from_pretrained("google-bert/bert-base-uncased")

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

Saídas específicas do Bert[[transformers.models.bert.modeling_bert.BertForPreTrainingOutput]]

transformers.models.bert.modeling_bert.BertForPreTrainingOutput[[transformers.models.bert.modeling_bert.BertForPreTrainingOutput]]

transformers.models.bert.modeling_bert.BertForPreTrainingOutput(loss: typing.Optional[torch.Tensor] = None, prediction_logits: typing.Optional[torch.Tensor] = None, seq_relationship_logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None)

Origem

Parâmetros:

loss (*optional*, retornado quando labels é fornecido, torch.Tensor de forma (1,)) : Perda total como a soma da perda de modelagem de linguagem mascarada e da perda de previsão da próxima sequência (classificação).

prediction_logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) : Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).

seq_relationship_logits (torch.Tensor de forma (batch_size, 2)) : Pontuações de previsão da cabeça de previsão da próxima sequência (classificação) (pontuações de continuação True/False antes do SoftMax).

hidden_states (tuple[torch.Tensor], opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) : Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma (batch_size, sequence_length, hidden_size). Hidden-states do modelo na saída de cada camada, além das saídas iniciais opcionais dos embeddings.

attentions (tuple[torch.Tensor], opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) : Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length). Pesos das atenções após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Tipo de saída de BertForPreTraining.