Transformers documentation
FlauBERT
Este modelo foi publicado no HF papers em 2019-12-11 e contribuído para o Hugging Face Transformers em 2020-11-16.
FlauBERT
Visão geral
O modelo FlauBERT foi proposto no artigo FlauBERT: Unsupervised Language Model Pre-training for French, de Hang Le et al. Trata-se de um modelo transformer pré-treinado usando um objetivo de modelagem de linguagem mascarada (MLM) (como o BERT).
O resumo do artigo é o seguinte:
Os modelos de linguagem se tornaram uma etapa fundamental para alcançar resultados de estado da arte em diversas tarefas de Processamento de Linguagem Natural (NLP). Aproveitando a enorme quantidade de textos não rotulados disponíveis atualmente, eles oferecem uma maneira eficiente de pré-treinar representações contínuas de palavras que podem ser ajustadas para uma tarefa de nível inferior, juntamente com sua contextualização no nível da frase. Isso foi amplamente demonstrado para o inglês usando representações contextualizadas (Dai and Le, 2015; Peters et al., 2018; Howard and Ruder, 2018; Radford et al., 2018; Devlin et al., 2019; Yang et al., 2019b). Neste artigo, apresentamos e compartilhamos o FlauBERT, um modelo aprendido em um corpus francês muito grande e heterogêneo. Modelos de diferentes tamanhos são treinados usando o novo supercomputador Jean Zay do CNRS (Centro Nacional de Pesquisa Científica da França). Aplicamos nossos modelos de linguagem em francês a diversas tarefas de NLP (classificação de texto, parafraseamento, inferência de linguagem natural, análise, desambiguação de sentido de palavras) e mostramos que, na maioria das vezes, eles superam outras abordagens de pré-treinamento. Diferentes versões do FlauBERT, bem como um protocolo de avaliação unificado para as tarefas de nível inferior, chamado FLUE (French Language Understanding Evaluation), são compartilhados com a comunidade de pesquisa para experimentos reprodutíveis adicionais em NLP em francês.
Este modelo foi contribuído por formiel. O código original pode ser encontrado aqui.
Dicas:
- Assim como o RoBERTa, sem a previsão de ordenação de frases (ou seja, treinado apenas no objetivo MLM).
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 mascarada
- Guia de tarefas de múltipla escolha
FlaubertConfig
classe transformers.FlaubertConfig
< 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 = Nonepre_norm: bool = Falselayerdrop: float | int = 0.0vocab_size: int = 30145emb_dim: int = 2048n_layers: int = 12n_heads: int = 16dropout: float | int = 0.1attention_dropout: float | int = 0.1gelu_activation: bool = Truesinusoidal_embeddings: bool = Falsecausal: bool = Falseasm: bool = Falsen_langs: int = 1use_lang_emb: bool = Truemax_position_embeddings: int = 512embed_init_std: float = 0.02209708691207961layer_norm_eps: float = 1e-12init_std: float = 0.02bos_index: int = 0eos_index: int = 1pad_index: int = 2unk_index: int = 3mask_index: int = 5is_encoder: bool = Truesummary_type: str = 'first'summary_use_proj: bool = Truesummary_activation: str | None = Nonesummary_proj_to_labels: bool = Truesummary_first_dropout: float | int = 0.1start_n_top: int = 5end_n_top: int = 5mask_token_id: int = 0lang_id: int = 0pad_token_id: int | None = 2bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 1tie_word_embeddings: bool = True )
Parâmetros
- pre_norm (
bool, opcional, padrãoFalse) — Se a normalização de camada deve ser aplicada antes ou depois da camada feed forward que segue a atenção em cada camada (Vaswani et al., Tensor2Tensor for Neural Machine Translation. 2018) - layerdrop (
Union[float, int], opcional, padrão0.0) — A probabilidade de LayerDrop. Consulte o [artigo do LayerDrop](veja https://huggingface.co/papers/1909.11556) para mais detalhes. - vocab_size (
int, opcional, padrão30145) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelosinput_ids. - emb_dim (
int, opcional, padrão 2048) — A dimensionalidade da camada de incorporação. - n_layers (
int, opcional, padrão12) — Número de camadas ocultas no decodificador do Transformer. - n_heads (
int, opcional, padrão16) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. - dropout (
Union[float, int], opcional, padrão0.1) — A proporção para todas as camadas de dropout. - attention_dropout (
Union[float, int], opcional, padrão0.1) — A taxa de dropout para as probabilidades de atenção. - gelu_activation (
bool, opcional, padrão True) — Se deve usar a função de ativação GeLU. - sinusoidal_embeddings (
bool, opcional, padrãoFalse) — Indica se deve-se usar embeddings posicionais sinusoidais em vez de embeddings posicionais absolutos. - causal (
bool, opcional, padrãoFalse) — Indica se o modelo deve se comportar de forma causal. Modelos causais usam uma máscara de atenção triangular para prestar atenção apenas ao contexto à esquerda, em vez de um contexto bidirecional. - asm (
bool, opcional, padrãoFalse) — Indica se deve ou não usar uma camada de projeção de log softmax adaptativo em vez de uma camada linear para a camada de previsão. - n_langs (
int, opcional, padrão 1) — O número de idiomas que o modelo processa. Defina como 1 para modelos monolíngues. - use_lang_emb (
bool, opcional, padrãoTrue) — Indica se deve usar embeddings de idioma. Alguns modelos utilizam embeddings de idioma adicionais; consulte a página dos modelos multilíngues para obter informações sobre como usá-los. - embed_init_std (
float, opcional, padrão 2048^-0.5) — O desvio padrão do truncated_normal_initializer para inicializar as matrizes de incorporação. - max_position_embeddings (
int, opcional, padrão512) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado. - embed_init_std (
float, opcional, padrão2048**-0.5) — Padrão inicial para as camadas de incorporação. - layer_norm_eps (
float, opcional, padrão1e-12) — O epsilon usado pelas camadas de normalização de camada. - init_std (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - bos_index (
int, opcional, padrão 0) — O índice do token de início de frase no vocabulário. - eos_index (
int, opcional, padrão 1) — O índice do token de fim de frase no vocabulário. - pad_index (
int, opcional, padrão 2) — O índice do token de preenchimento no vocabulário. - unk_index (
int, opcional, padrão 3) — O índice do token desconhecido no vocabulário. - mask_index (
int, opcional, padrão 5) — O índice do token de mascaramento no vocabulário. - is_encoder (
bool, opcional, padrão True) — Indica se o modelo é usado como um codificador. - summary_type (
string, opcional, padrão: “first”) — 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_proj_to_labels (
bool, opcional, padrãoTrue) — Usado nos modelos de classificação de sequência e escolha múltipla. Se as saídas da projeção devem terconfig.num_labelsouconfig.hidden_sizeclasses. - summary_first_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. - mask_token_id (
int, opcional, padrão 0) — Parâmetro agnóstico ao modelo para identificar tokens mascarados ao gerar texto em um contexto de MLM. - lang_id (
int, opcional, padrão 1) — O ID do idioma usado pelo modelo. Este parâmetro é utilizado ao gerar texto em um idioma específico. - pad_token_id (
int, opcional, padrão2) — ID do token usado para preenchimento no vocabulário. - bos_token_id (
int, opcional, padrão0) — ID do token usado para o início do fluxo no vocabulário. - eos_token_id (
Union[int, list[int]], opcional, padrão1) — 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 FlaubertModel. Ela é usada para instanciar um modelo Flaubert 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 flaubert/flaubert_base_uncased
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.
FlaubertTokenizer
classe transformers.FlaubertTokenizer
< source >( vocab_filemerges_filedo_lowercase = Falseunk_token = '<unk>'bos_token = '<s>'sep_token = '</s>'pad_token = '<pad>'cls_token = '</s>'mask_token = '<special1>'additional_special_tokens = ['<special0>', '<special1>', '<special2>', '<special3>', '<special4>', '<special5>', '<special6>', '<special7>', '<special8>', '<special9>']lang2id = Noneid2lang = None**kwargs )
Parâmetros
- vocab_file (
str) — Arquivo de vocabulário. - merges_file (
str) — Arquivo de mesclagens. - do_lowercase (
bool, opcional, padrãoFalse) — Controla a conversão para minúsculas. - 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. - 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. - sep_token (
str, opcional, padrão"</s>") — 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 question answering. 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"</s>") — O token de classificador usado na classificação de sequência (classificação da sequência inteira, em vez da classificação por token). É o primeiro token da sequência quando esta é construída com tokens especiais. - mask_token (
str, opcional, padrão"<special1>") — 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['<special0>', '<special1>', '<special2>', '<special3>', '<special4>', '<special5>', '<special6>', '<special7>', '<special8>', '<special9>']) — Lista de tokens especiais adicionais. - lang2id (
Dict[str, int], opcional) — Dicionário que mapeia identificadores de strings de idiomas para seus IDs. - id2lang (
Dict[int, str], opcional) — Dicionário que mapeia IDs de idioma para seus identificadores em string.
Construa um tokenizador Flaubert. Baseado em Byte-Pair Encoding. O processo de tokenização é o seguinte:
- Pré-processamento e tokenização do Moses.
- Normalizando todo o texto de entrada.
- Os argumentos
special_tokense a funçãoset_special_tokenspodem ser usados para adicionar símbolos adicionais (como ”classify”) a um vocabulário. - O argumento
do_lowercasecontrola a conversão para minúsculas (definido automaticamente para vocabulários pré-treinados).
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
< source >( token_ids_0: listtoken_ids_1: list[int] | None = None ) → List[int]
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 XLM tem o seguinte formato:
- sequência única:
<s> X </s> - par de sequências:
<s> A </s> B </s>
Converte uma sequência de tokens (string) em uma única string.
get_special_tokens_mask
< source >( token_ids_0: listtoken_ids_1: list[int] | None = Nonealready_has_special_tokens: bool = False ) → List[int]
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ãoFalse) — 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.
FlaubertModel
classe transformers.FlaubertModel
< source >( config: FlaubertConfig )
Parâmetros
- config (FlaubertConfig) — 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 Flaubert 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.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonelengths: typing.Optional[torch.LongTensor] = Nonecache: dict[str, torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BaseModelOutput or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.LongTensorde forma(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.
- langs (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Uma sequência paralela de tokens a ser usada para indicar o idioma de cada token na entrada. Os índices são ids de idiomas, que podem ser obtidos a partir dos nomes dos idiomas usando os dois mapeamentos de conversão fornecidos na configuração do modelo (fornecidos apenas para modelos multilíngues). Mais precisamente, o mapeamento de nome do idioma para id do idioma está emmodel.config.lang2id((que é um dicionário de string para int) e o mapeamento de id do idioma para nome do idioma está emmodel.config.id2lang((dicionário de int para string). Veja exemplos de uso detalhados na documentação multilíngue.Veja exemplos de uso detalhados na documentação multilíngue.
- token_type_ids (
torch.LongTensorde 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.
- position_ids (
torch.LongTensorde 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]. - lengths (
torch.LongTensorde forma(batch_size,), opcional) — Comprimento de cada frase que pode ser usado para evitar a execução de atenção nos índices de tokens de preenchimento. Você também pode usarattention_maskpara obter o mesmo resultado (veja acima), mantido aqui por compatibilidade. Índices selecionados em[0, ..., input_ids.size(-1)]: - cache (
dict[str, torch.Tensor], opcional) — Dicionário de strings paratorch.Tensorque contém os hidden-states pré-computados (chaves e valores nos blocos de atenção) conforme calculados pelo modelo (veja a saídacacheabaixo). Pode ser usado para acelerar a decodificação sequencial. O objeto dicionário será modificado in-place durante o forward pass para adicionar os novos hidden-states calculados. - 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. - 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
BaseModelOutput ou tuple(torch.Tensor)
Um BaseModelOutput ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos dependendo da configuração (FlaubertConfig) e das entradas.
O método forward do FlaubertModel 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.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.hidden_states (
tuple(torch.Tensor), opcional, retornado 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.
FlaubertWithLMHeadModel
classe transformers.FlaubertWithLMHeadModel
< source >( config: FlaubertConfig )
Parâmetros
- config (FlaubertConfig) — 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 transformer Flaubert 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] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelengths: typing.Optional[torch.Tensor] = Nonecache: dict[str, torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → MaskedLMOutput 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.
- langs (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Uma sequência paralela de tokens a ser usada para indicar o idioma de cada token na entrada. Os índices são ids de idiomas, que podem ser obtidos a partir dos nomes dos idiomas usando os dois mapeamentos de conversão fornecidos na configuração do modelo (fornecidos apenas para modelos multilíngues). Mais precisamente, o mapeamento de nome do idioma para id do idioma está emmodel.config.lang2id((que é um dicionário de string para int) e o mapeamento de id do idioma para nome do idioma está emmodel.config.id2lang((dicionário de int para string). Veja exemplos de uso detalhados na documentação multilíngue.Veja exemplos de uso detalhados na documentação multilíngue.
- 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.
- position_ids (
torch.Tensorde 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]. - lengths (
torch.LongTensorde forma(batch_size,), opcional) — Comprimento de cada frase que pode ser usado para evitar a execução de atenção nos índices de tokens de preenchimento. Você também pode usarattention_maskpara obter o mesmo resultado (veja acima), mantido aqui por compatibilidade. Índices selecionados em[0, ..., input_ids.size(-1)]: - cache (
dict[str, torch.Tensor], opcional) — Dicionário de strings paratorch.Tensorque contém os hidden-states pré-computados (chaves e valores nos blocos de atenção) conforme calculados pelo modelo (veja a saídacacheabaixo). Pode ser usado para acelerar a decodificação sequencial. O objeto dicionário será modificado in-place durante o forward pass para adicionar os novos hidden-states calculados. - 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, sequence_length), opcional) — Rótulos para modelagem de linguagem. Observe que os rótulos são deslocados dentro do modelo, ou seja, você pode definirlabels = input_idsOs índices são selecionados em[-100, 0, ..., config.vocab_size]Todos os rótulos definidos como-100são ignorados (mascarados); a perda é calculada apenas para rótulos em[0, ..., config.vocab_size] - output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. 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
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) contendo vários
elementos dependendo da configuração (FlaubertConfig) e das entradas.
O método forward de FlaubertWithLMHeadModel 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) — Perda de modelagem de linguagem mascarada (MLM).logits (
torch.Tensorde 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 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:
>>> import torch
>>> from transformers import AutoTokenizer, FlaubertWithLMHeadModel
>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertWithLMHeadModel.from_pretrained("flaubert/flaubert_base_uncased")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logitsFlaubertForSequenceClassification
classe transformers.FlaubertForSequenceClassification
< source >( config: FlaubertConfig )
Parâmetros
- config (FlaubertConfig) — 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 Flaubert 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] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelengths: typing.Optional[torch.Tensor] = Nonecache: dict[str, torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → SequenceClassifierOutput 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.
- langs (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Uma sequência paralela de tokens a ser usada para indicar o idioma de cada token na entrada. Os índices são ids de idiomas, que podem ser obtidos a partir dos nomes dos idiomas usando os dois mapeamentos de conversão fornecidos na configuração do modelo (fornecidos apenas para modelos multilíngues). Mais precisamente, o mapeamento de nome do idioma para id do idioma está emmodel.config.lang2id((que é um dicionário de string para int) e o mapeamento de id do idioma para nome do idioma está emmodel.config.id2lang((dicionário de int para string). Veja exemplos de uso detalhados na documentação multilíngue.Veja exemplos de uso detalhados na documentação multilíngue.
- 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.
- position_ids (
torch.Tensorde 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]. - lengths (
torch.LongTensorde forma(batch_size,), opcional) — Comprimento de cada frase que pode ser usado para evitar a execução de atenção nos índices de tokens de preenchimento. Você também pode usar attention_mask para obter o mesmo resultado (veja acima), mantido aqui por compatibilidade. Índices selecionados em[0, ..., input_ids.size(-1)]. - cache (
dict[str, torch.Tensor], opcional) — Instância deEncoderDecoderCacheque contém estados KV pré-computados. Pode ser usado para acelerar a decodificação sequencial. - 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). - 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
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) contendo vários
elementos dependendo da configuração (FlaubertConfig) e das entradas.
O método forward de FlaubertForSequenceClassification 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 (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).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, FlaubertForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertForSequenceClassification.from_pretrained("flaubert/flaubert_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 = FlaubertForSequenceClassification.from_pretrained("flaubert/flaubert_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, FlaubertForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertForSequenceClassification.from_pretrained("flaubert/flaubert_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 = FlaubertForSequenceClassification.from_pretrained(
... "flaubert/flaubert_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).lossFlaubertForMultipleChoice
classe transformers.FlaubertForMultipleChoice
< source >( config: FlaubertConfig*inputs**kwargs )
Parâmetros
- config (FlaubertConfig) — 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 Flaubert 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] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelengths: typing.Optional[torch.Tensor] = Nonecache: dict[str, torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → MultipleChoiceModelOutput 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.
- 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.
- langs (
torch.LongTensorde forma(batch_size, num_choices, sequence_length), opcional) — Uma sequência paralela de tokens a ser usada para indicar o idioma de cada token na entrada. Os índices são ids de idiomas, que podem ser obtidos a partir dos nomes dos idiomas usando os dois mapeamentos de conversão fornecidos na configuração do modelo (fornecidos apenas para modelos multilíngues). Mais precisamente, o mapeamento de nome do idioma para id do idioma está emmodel.config.lang2id((que é um dicionário de string para int) e o mapeamento de id do idioma para nome do idioma está emmodel.config.id2lang((dicionário de int para string).Veja exemplos de uso detalhados na documentação multilíngue.
- 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.
- position_ids (
torch.LongTensorde 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]. - lengths (
torch.LongTensorde forma(batch_size,), opcional) — Comprimento de cada frase que pode ser usado para evitar a execução de atenção nos índices de tokens de preenchimento. Você também pode usar attention_mask para obter o mesmo resultado (veja acima), mantido aqui por compatibilidade. Índices selecionados em[0, ..., input_ids.size(-1)]. - cache (
dict[str, torch.Tensor], opcional) — Instância deEncoderDecoderCacheque contém estados KV pré-computados. Pode ser usado para acelerar a decodificação sequencial. - 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, ..., num_choices-1], ondenum_choicesé o tamanho da segunda dimensão dos tensores de entrada. (Vejainput_idsacima) - 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
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 vários
elementos dependendo da configuração (FlaubertConfig) e das entradas.
O método forward de FlaubertForMultipleChoice 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).
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, FlaubertForMultipleChoice
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertForMultipleChoice.from_pretrained("flaubert/flaubert_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.logitsFlaubertForTokenClassification
classe transformers.FlaubertForTokenClassification
< source >( config: FlaubertConfig )
Parâmetros
- config (FlaubertConfig) — 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 Flaubert 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] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelengths: typing.Optional[torch.Tensor] = Nonecache: dict[str, torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → TokenClassifierOutput 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.
- langs (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Uma sequência paralela de tokens a ser usada para indicar o idioma de cada token na entrada. Os índices são ids de idiomas, que podem ser obtidos a partir dos nomes dos idiomas usando os dois mapeamentos de conversão fornecidos na configuração do modelo (fornecidos apenas para modelos multilíngues). Mais precisamente, o mapeamento de nome do idioma para id do idioma está emmodel.config.lang2id((que é um dicionário de string para int) e o mapeamento de id do idioma para nome do idioma está emmodel.config.id2lang((dicionário de int para string). Veja exemplos de uso detalhados na documentação multilíngue.Veja exemplos de uso detalhados na documentação multilíngue.
- 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.
- position_ids (
torch.Tensorde 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]. - lengths (
torch.LongTensorde forma(batch_size,), opcional) — Comprimento de cada frase que pode ser usado para evitar a execução de atenção nos índices de tokens de preenchimento. Você também pode usar attention_mask para obter o mesmo resultado (veja acima), mantido aqui por compatibilidade. Índices selecionados em[0, ..., input_ids.size(-1)]. - cache (
dict[str, torch.Tensor], opcional) — Instância deEncoderDecoderCacheque contém estados KV pré-computados. Pode ser usado para acelerar a decodificação sequencial. - 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, sequence_length), opcional) — Rótulos para o cálculo da perda de classificação de tokens. Os índices devem estar em[0, ..., config.num_labels - 1]. - output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. 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
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) contendo vários
elementos dependendo da configuração (FlaubertConfig) e das entradas.
O método forward de FlaubertForTokenClassification 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).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, FlaubertForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertForTokenClassification.from_pretrained("flaubert/flaubert_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)
...FlaubertForQuestionAnsweringSimple
classe transformers.FlaubertForQuestionAnsweringSimple
< source >( config: FlaubertConfig )
Parâmetros
- config (FlaubertConfig) — 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 Flaubert com uma cabeça de classificação de intervalos no topo para tarefas de resposta a perguntas extrativas, como SQuAD (camadas lineares no topo da saída dos estados ocultos 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] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelengths: typing.Optional[torch.Tensor] = Nonecache: dict[str, torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonestart_positions: typing.Optional[torch.Tensor] = Noneend_positions: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → QuestionAnsweringModelOutput 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.
- langs (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Uma sequência paralela de tokens a ser usada para indicar o idioma de cada token na entrada. Os índices são ids de idiomas, que podem ser obtidos a partir dos nomes dos idiomas usando os dois mapeamentos de conversão fornecidos na configuração do modelo (fornecidos apenas para modelos multilíngues). Mais precisamente, o mapeamento de nome do idioma para id do idioma está emmodel.config.lang2id((que é um dicionário de string para int) e o mapeamento de id do idioma para nome do idioma está emmodel.config.id2lang((dicionário de int para string). Veja exemplos de uso detalhados na documentação multilíngue.Veja exemplos de uso detalhados na documentação multilíngue.
- 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.
- position_ids (
torch.Tensorde 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]. - lengths (
torch.LongTensorde forma(batch_size,), opcional) — Comprimento de cada frase que pode ser usado para evitar a execução de atenção nos índices de tokens de preenchimento. Você também pode usar attention_mask para obter o mesmo resultado (veja acima), mantido aqui por compatibilidade. Índices selecionados em[0, ..., input_ids.size(-1)]. - cache (
dict[str, torch.Tensor], opcional) — Instância deEncoderDecoderCacheque contém estados KV pré-computados. Pode ser usado para acelerar a decodificação sequencial. - 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. - 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
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) contendo vários
elementos dependendo da configuração (FlaubertConfig) e das entradas.
O método forward de FlaubertForQuestionAnsweringSimple 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) — 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).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, FlaubertForQuestionAnsweringSimple
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertForQuestionAnsweringSimple.from_pretrained("flaubert/flaubert_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)
...FlaubertForQuestionAnswering
classe transformers.FlaubertForQuestionAnswering
< source >( config: FlaubertConfig )
Parâmetros
- config (FlaubertConfig) — 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 Flaubert 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 geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelengths: typing.Optional[torch.Tensor] = Nonecache: dict[str, torch.Tensor] | None = 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] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → FlaubertForQuestionAnsweringOutput 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.
- langs (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Uma sequência paralela de tokens a ser usada para indicar o idioma de cada token na entrada. Os índices são ids de idiomas, que podem ser obtidos a partir dos nomes dos idiomas usando os dois mapeamentos de conversão fornecidos na configuração do modelo (fornecidos apenas para modelos multilíngues). Mais precisamente, o mapeamento de nome do idioma para id do idioma está emmodel.config.lang2id((que é um dicionário de string para int) e o mapeamento de id do idioma para nome do idioma está emmodel.config.id2lang((dicionário de int para string). Veja exemplos de uso detalhados na documentação multilíngue.Veja exemplos de uso detalhados na documentação multilíngue.
- 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.
- position_ids (
torch.Tensorde 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]. - lengths (
torch.LongTensorde forma(batch_size,), opcional) — Comprimento de cada frase que pode ser usado para evitar a execução de atenção nos índices de tokens de preenchimento. Você também pode usar attention_mask para obter o mesmo resultado (veja acima), mantido aqui por compatibilidade. Índices selecionados em[0, ..., input_ids.size(-1)]. - cache (
dict[str, torch.Tensor], opcional) — Instância deEncoderDecoderCacheque contém estados KV pré-computados. Pode ser usado para acelerar a decodificação sequencial. - 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. - 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
FlaubertForQuestionAnsweringOutput ou tuple(torch.Tensor)
Um FlaubertForQuestionAnsweringOutput 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 (FlaubertConfig) e das entradas.
O método forward de FlaubertForQuestionAnswering 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.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, FlaubertForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = FlaubertForQuestionAnswering.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> 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