# FlauBERT ## Visão geral O modelo FlauBERT foi proposto no artigo [FlauBERT: Unsupervised Language Model Pre-training for French](https://huggingface.co/papers/1912.05372), 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 sentença. Isso foi amplamente demonstrado para o inglês usando representações contextualizadas (Dai e Le, 2015; Peters et al., 2018; Howard e 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 franceses a diversas tarefas de NLP (classificação de texto, parafraseamento, inferência de linguagem natural, análise sintática, 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 francês.* Este modelo foi contribuído por [formiel](https://huggingface.co/formiel). O código original pode ser encontrado [aqui](https://github.com/getalp/Flaubert). 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](../tasks/sequence_classification) - [Guia de tarefas de classificação de tokens](../tasks/token_classification) - [Guia da tarefa de resposta a perguntas](../tasks/question_answering) - [Guia da tarefa de modelagem de linguagem mascarada](../tasks/masked_language_modeling) - [Guia de tarefas de múltipla escolha](../tasks/multiple_choice) ## FlaubertConfig[[transformers.FlaubertConfig]] #### transformers.FlaubertConfig[[transformers.FlaubertConfig]] ```python transformers.FlaubertConfig(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, pre_norm: bool = False, layerdrop: float | int = 0.0, vocab_size: int = 30145, emb_dim: int = 2048, n_layers: int = 12, n_heads: int = 16, dropout: float | int = 0.1, attention_dropout: float | int = 0.1, gelu_activation: bool = True, sinusoidal_embeddings: bool = False, causal: bool = False, asm: bool = False, n_langs: int = 1, use_lang_emb: bool = True, max_position_embeddings: int = 512, embed_init_std: float = 0.02209708691207961, layer_norm_eps: float = 1e-12, init_std: float = 0.02, bos_index: int = 0, eos_index: int = 1, pad_index: int = 2, unk_index: int = 3, mask_index: int = 5, is_encoder: bool = True, summary_type: str = 'first', summary_use_proj: bool = True, summary_activation: str | None = None, summary_proj_to_labels: bool = True, summary_first_dropout: float | int = 0.1, start_n_top: int = 5, end_n_top: int = 5, mask_token_id: int = 0, lang_id: int = 0, pad_token_id: int | None = 2, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 1, tie_word_embeddings: bool = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/configuration_flaubert.py#L24) **Parâmetros:** pre_norm (`bool`, *opcional*, padrão `False`) : 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ão `0.0`) : A probabilidade de LayerDrop. Consulte o [artigo do LayerDrop](see https://huggingface.co/papers/1909.11556) para mais detalhes. vocab_size (`int`, *opcional*, padrão `30145`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`. emb_dim (`int`, *opcional*, padrão 2048) : A dimensionalidade da camada de incorporação. n_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no decodificador do Transformer. n_heads (`int`, *opcional*, padrão `16`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. dropout (`Union[float, int]`, *opcional*, padrão `0.1`) : A proporção para todas as camadas de dropout. attention_dropout (`Union[float, int]`, *opcional*, padrão `0.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ão `False`) : Indica se deve ou não usar embeddings posicionais sinusoidais em vez de embeddings posicionais absolutos. causal (`bool`, *opcional*, padrão `False`) : 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ão `False`) : 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ão `True`) : Se deve usar embeddings de idioma. Alguns modelos utilizam embeddings de idioma adicionais; consulte [a página de modelos multilíngues](http://huggingface.co/transformers/multilingual.html#xlm-language-embeddings) 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ão `512`) : O comprimento máximo de sequência com o qual este modelo pode ser utilizado. embed_init_std (`float`, *opcional*, padrão `2048**-0.5`) : std do inicializador para camadas de embedding. layer_norm_eps (`float`, *opcional*, padrão `1e-12`) : O epsilon usado pelas camadas de normalização de camada. init_std (`float`, *opcional*, padrão `0.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 da 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"`: Adota a média dos estados ocultos de todos os tokens. - `"cls_index"`: Fornece um Tensor com a posição do token de classificação (como no GPT/GPT-2). - `"attn"`: Não implementado no momento, usa atenção multi-cabeça. summary_use_proj (`bool`, *opcional*, padrão `True`) : 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 usado ao realizar o resumo de sequência. Utilizado 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ão `True`) : Usado nos modelos de classificação de sequência e escolha múltipla. Se as saídas da projeção devem ter `config.num_labels` ou `config.hidden_size` classes. 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ão `2`) : ID do token usado para preenchimento no vocabulário. bos_token_id (`int`, *opcional*, padrão `0`) : ID do token usado para o início do fluxo no vocabulário. eos_token_id (`Union[int, list[int]]`, *opcional*, padrão `1`) : 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 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 valores padrão resultará em uma configuração semelhante à do [flaubert/flaubert_base_uncased](https://huggingface.co/flaubert/flaubert_base_uncased) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. ## FlaubertTokenizer[[transformers.FlaubertTokenizer]] #### transformers.FlaubertTokenizer[[transformers.FlaubertTokenizer]] ```python transformers.FlaubertTokenizer(vocab_file, merges_file, do_lowercase = False, unk_token = '', bos_token = '', sep_token = '', pad_token = '', cls_token = '', mask_token = '', additional_special_tokens = ['', '', '', '', '', '', '', '', '', ''], lang2id = None, id2lang = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/tokenization_flaubert.py#L121) **Parâmetros:** vocab_file (`str`) : Arquivo de vocabulário. merges_file (`str`) : Mescla o arquivo. do_lowercase (`bool`, *opcional*, padrão `False`) : Controla a conversão para minúsculas. unk_token (`str`, *opcional*, padrão `""`) : 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 `""`) : 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 `""`) : O token separador, usado ao montar uma sequência a partir de múltiplas sequências, por exemplo, duas sequências para classificação de sequência ou um texto e uma pergunta para resposta a perguntas. Também é usado como o último token de uma sequência montada com tokens especiais. pad_token (`str`, *opcional*, padrão `""`) : O token usado para preenchimento, por exemplo, ao agrupar sequências de comprimentos diferentes. cls_token (`str`, *opcional*, padrão `""`) : O token de classificador usado ao realizar a 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 `""`) : 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 `['', '', '', '', '', '', '', '', '', '']`) : 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_tokens` e a função `set_special_tokens` podem ser usados para adicionar símbolos adicionais (como "__classify__") a um vocabulário. - O argumento `do_lowercase` controla a conversão para minúsculas (definido automaticamente para vocabulários pré-treinados). Este tokenizer herda de [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend), que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses métodos. #### build_inputs_with_special_tokens[[transformers.FlaubertTokenizer.build_inputs_with_special_tokens]] ```python build_inputs_with_special_tokens(token_ids_0: list, token_ids_1: list[int] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/tokenization_flaubert.py#L430) **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](../glossary#input-ids) 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: ` X ` - par de sequências: ` A B ` #### convert_tokens_to_string[[transformers.FlaubertTokenizer.convert_tokens_to_string]] ```python convert_tokens_to_string(tokens) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/tokenization_flaubert.py#L424) Converte uma sequência de tokens (string) em uma única string. #### get_special_tokens_mask[[transformers.FlaubertTokenizer.get_special_tokens_mask]] ```python get_special_tokens_mask(token_ids_0: list, token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/tokenization_flaubert.py#L458) **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. ## FlaubertModel[[transformers.FlaubertModel]] #### transformers.FlaubertModel[[transformers.FlaubertModel]] ```python transformers.FlaubertModel(config: FlaubertConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L690) **Parâmetros:** config ([FlaubertConfig](/docs/transformers/main/pt/model_doc/flaubert#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.FlaubertModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, lengths: typing.Optional[torch.LongTensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L763) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) langs (`torch.LongTensor` de 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á em `model.config.lang2id` (que é um dicionário de string para int) e o mapeamento de *id do idioma para nome do idioma* está em `model.config.id2lang` (dicionário de int para string). Veja exemplos de uso detalhados na [documentação multilíngue](../multilingual). token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas porções das entradas. Os índices são selecionados em `[0, 1]`: - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*. [O que são IDs de tipo de token?](../glossary#token-type-ids) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) lengths (`torch.LongTensor` de 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*) : Dicionário de strings para `torch.Tensor` que contém os hidden-states pré-computados (chaves e valores nos blocos de atenção) calculados pelo modelo (veja a saída `cache` abaixo). Pode ser usado para acelerar a decodificação sequencial. O objeto dicionário será modificado in-place durante a passagem para frente para adicionar os novos hidden-states calculados. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes. output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. **Retorna:** [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou `tuple(torch.Tensor)` Um [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([FlaubertConfig](/docs/transformers/main/pt/model_doc/flaubert#transformers.FlaubertConfig)) e das entradas. O método forward do [FlaubertModel](/docs/transformers/main/pt/model_doc/flaubert#transformers.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 `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. ## FlaubertWithLMHeadModel[[transformers.FlaubertWithLMHeadModel]] #### transformers.FlaubertWithLMHeadModel[[transformers.FlaubertWithLMHeadModel]] ```python transformers.FlaubertWithLMHeadModel(config: FlaubertConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L940) **Parâmetros:** config ([FlaubertConfig](/docs/transformers/main/pt/model_doc/flaubert#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.FlaubertWithLMHeadModel.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L972) **Parâmetros:** input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) langs (`torch.LongTensor` de 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á em `model.config.lang2id` (que é um dicionário de string para int) e o mapeamento de *id do idioma para nome do idioma* está em `model.config.id2lang` (dicionário de int para string). Veja exemplos de uso detalhados na [documentação multilíngue](../multilingual). 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?](../glossary#token-type-ids) position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) lengths (`torch.LongTensor` de 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*) : Dicionário de strings para `torch.Tensor` que contém os hidden-states pré-computados (chaves e valores nos blocos de atenção) calculados pelo modelo (veja a saída `cache` abaixo). Pode ser usado para acelerar a decodificação sequencial. O objeto dicionário será modificado in-place durante a passagem para frente para adicionar os novos hidden-states calculados. 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 modelagem de linguagem. Observe que os rótulos **são deslocados** dentro do modelo, ou seja, você pode definir `labels = input_ids` Os índices são selecionados em `[-100, 0, ..., config.vocab_size]` Todos os rótulos definidos como `-100` sã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. Consulte `attentions` nos tensores retornados para mais detalhes. output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. **Retorna:** [MaskedLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) ou `tuple(torch.Tensor)` Um [MaskedLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/flaubert#transformers.FlaubertConfig)) e das entradas. O método forward de [FlaubertWithLMHeadModel](/docs/transformers/main/pt/model_doc/flaubert#transformers.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 `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: ```python >>> 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.logits ``` ## FlaubertForSequenceClassification[[transformers.FlaubertForSequenceClassification]] #### transformers.FlaubertForSequenceClassification[[transformers.FlaubertForSequenceClassification]] ```python transformers.FlaubertForSequenceClassification(config: FlaubertConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L1049) **Parâmetros:** config ([FlaubertConfig](/docs/transformers/main/pt/model_doc/flaubert#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.FlaubertForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L1061) **Parâmetros:** input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) langs (`torch.LongTensor` de 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á em `model.config.lang2id` (que é um dicionário de string para int) e o mapeamento de *id do idioma para nome do idioma* está em `model.config.id2lang` (dicionário de int para string). Veja exemplos de uso detalhados na [documentação multilíngue](../multilingual). 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?](../glossary#token-type-ids) position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) lengths (`torch.LongTensor` de 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 de `EncoderDecoderCache` que contém estados KV pré-computados. Pode ser usado para acelerar a decodificação sequencial. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. labels (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos para o cálculo da perda de classificação/regressão de sequência. Os índices devem estar em `[0, ..., config.num_labels - 1]`. Se `config.num_labels == 1`, uma perda de regressão é calculada (perda de erro quadrático médio). Se `config.num_labels > 1`, uma perda de classificação é calculada (entropia cruzada). output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes. output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. **Retorna:** [SequenceClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) ou `tuple(torch.Tensor)` Um [SequenceClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/flaubert#transformers.FlaubertConfig)) e das entradas. O método forward de [FlaubertForSequenceClassification](/docs/transformers/main/pt/model_doc/flaubert#transformers.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 `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: ```python >>> 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: ```python >>> 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).loss ``` ## FlaubertForMultipleChoice[[transformers.FlaubertForMultipleChoice]] #### transformers.FlaubertForMultipleChoice[[transformers.FlaubertForMultipleChoice]] ```python transformers.FlaubertForMultipleChoice(config: FlaubertConfig, *inputs, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L1496) **Parâmetros:** config ([FlaubertConfig](/docs/transformers/main/pt/model_doc/flaubert#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.FlaubertForMultipleChoice.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L1507) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, num_choices, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) langs (`torch.LongTensor` de 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 (fornecido apenas para modelos multilíngues). Mais precisamente, o mapeamento de *nome do idioma para id do idioma* está em `model.config.lang2id` (que é um dicionário de string para int) e o mapeamento de *id do idioma para nome do idioma* está em `model.config.id2lang` (dicionário de int para string). Veja exemplos de uso detalhados na [documentação multilíngue](../multilingual). token_type_ids (`torch.LongTensor` de forma `(batch_size, num_choices, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`: - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*. [O que são IDs de tipo de token?](../glossary#token-type-ids) position_ids (`torch.LongTensor` de forma `(batch_size, num_choices, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.max_position_embeddings - 1]`. [O que são IDs de posição?](../glossary#position-ids) lengths (`torch.LongTensor` de 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 de `EncoderDecoderCache` que contém estados KV pré-computados. Pode ser usado para acelerar a decodificação sequencial. inputs_embeds (`torch.Tensor` de forma `(batch_size, num_choices, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de incorporação interna do modelo. labels (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos para calcular a perda de classificação de múltipla escolha. Os índices devem estar em `[0, ..., num_choices-1]`, onde `num_choices` é o tamanho da segunda dimensão dos tensores de entrada. (Veja `input_ids` acima) output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes. output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. **Retorna:** [MultipleChoiceModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.MultipleChoiceModelOutput) ou `tuple(torch.Tensor)` Um [MultipleChoiceModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/flaubert#transformers.FlaubertConfig)) e das entradas. O método forward de [FlaubertForMultipleChoice](/docs/transformers/main/pt/model_doc/flaubert#transformers.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 `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: ```python >>> 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.logits ``` ## FlaubertForTokenClassification[[transformers.FlaubertForTokenClassification]] #### transformers.FlaubertForTokenClassification[[transformers.FlaubertForTokenClassification]] ```python transformers.FlaubertForTokenClassification(config: FlaubertConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L1151) **Parâmetros:** config ([FlaubertConfig](/docs/transformers/main/pt/model_doc/flaubert#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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 estados ocultos), por exemplo, para tarefas de Reconhecimento de Entidades Nomeadas (NER). Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.FlaubertForTokenClassification.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L1163) **Parâmetros:** input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) langs (`torch.LongTensor` de 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á em `model.config.lang2id` (que é um dicionário de string para int) e o mapeamento de *id do idioma para nome do idioma* está em `model.config.id2lang` (dicionário de int para string). Veja exemplos de uso detalhados na [documentação multilíngue](../multilingual). 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?](../glossary#token-type-ids) position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) lengths (`torch.LongTensor` de 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 de `EncoderDecoderCache` que contém estados KV pré-computados. Pode ser usado para acelerar a decodificação sequencial. 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]`. output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes. output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. **Retorna:** [TokenClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) ou `tuple(torch.Tensor)` Um [TokenClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/flaubert#transformers.FlaubertConfig)) e das entradas. O método forward de [FlaubertForTokenClassification](/docs/transformers/main/pt/model_doc/flaubert#transformers.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 `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: ```python >>> 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[[transformers.FlaubertForQuestionAnsweringSimple]] #### transformers.FlaubertForQuestionAnsweringSimple[[transformers.FlaubertForQuestionAnsweringSimple]] ```python transformers.FlaubertForQuestionAnsweringSimple(config: FlaubertConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L1242) **Parâmetros:** config ([FlaubertConfig](/docs/transformers/main/pt/model_doc/flaubert#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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 (uma camada linear no topo da saída dos estados ocultos para calcular `span start logits` e `span end logits`). Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.FlaubertForQuestionAnsweringSimple.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L1252) **Parâmetros:** input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) langs (`torch.LongTensor` de 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á em `model.config.lang2id` (que é um dicionário de string para int) e o mapeamento de *id do idioma para nome do idioma* está em `model.config.id2lang` (dicionário de int para string). Veja exemplos de uso detalhados na [documentação multilíngue](../multilingual). 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?](../glossary#token-type-ids) position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) lengths (`torch.LongTensor` de 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 de `EncoderDecoderCache` que contém estados KV pré-computados. Pode ser usado para acelerar a decodificação sequencial. 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. output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes. output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. **Retorna:** [QuestionAnsweringModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) ou `tuple(torch.Tensor)` Um [QuestionAnsweringModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([FlaubertConfig](/docs/transformers/main/pt/model_doc/flaubert#transformers.FlaubertConfig)) e das entradas. O método forward de [FlaubertForQuestionAnsweringSimple](/docs/transformers/main/pt/model_doc/flaubert#transformers.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 `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecida) -- A perda total de extração de spans é a soma de uma Cross-Entropy para as posições de início e fim. - **start_logits** (`torch.Tensor` de forma `(batch_size, sequence_length)`) -- Pontuações de início de span (antes do SoftMax). - **end_logits** (`torch.Tensor` de forma `(batch_size, sequence_length)`) -- Pontuações de fim de span (antes do SoftMax). - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Exemplo: ```python >>> from transformers import AutoTokenizer, 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[[transformers.FlaubertForQuestionAnswering]] #### transformers.FlaubertForQuestionAnswering[[transformers.FlaubertForQuestionAnswering]] ```python transformers.FlaubertForQuestionAnswering(config: FlaubertConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L1377) **Parâmetros:** config ([FlaubertConfig](/docs/transformers/main/pt/model_doc/flaubert#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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 resposta a perguntas extrativas, como SQuAD (uma camada linear no topo da saída dos hidden-states para calcular `span start logits` e `span end logits`). Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.FlaubertForQuestionAnswering.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, is_impossible: typing.Optional[torch.Tensor] = None, cls_index: typing.Optional[torch.Tensor] = None, p_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L1387) **Parâmetros:** input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) langs (`torch.LongTensor` de 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á em `model.config.lang2id` (que é um dicionário de string para int) e o mapeamento de *id do idioma para nome do idioma* está em `model.config.id2lang` (dicionário de int para string). Veja exemplos de uso detalhados na [documentação multilíngue](../multilingual). 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?](../glossary#token-type-ids) position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) lengths (`torch.LongTensor` de 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 de `EncoderDecoderCache` que contém estados KV pré-computados. Pode ser usado para acelerar a decodificação sequencial. 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. is_impossible (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos indicando se uma pergunta tem uma resposta ou não (SQuAD 2.0) cls_index (`torch.LongTensor` de 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.Tensor` de 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. Consulte `attentions` nos tensores retornados para mais detalhes. output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. **Retorna:** `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](/docs/transformers/main/pt/model_doc/flaubert#transformers.FlaubertConfig)) e das entradas. O método forward de [FlaubertForQuestionAnswering](/docs/transformers/main/pt/model_doc/flaubert#transformers.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 `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 se `start_positions` e `end_positions` forem 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.Tensor` de forma `(batch_size, config.start_n_top)`, *opcional*, retornado se `start_positions` ou `end_positions` nã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.LongTensor` de forma `(batch_size, config.start_n_top)`, *opcional*, retornado se `start_positions` ou `end_positions` não for fornecido) -- Índices para as config.start_n_top melhores possibilidades de tokens de início (busca por feixe). - **end_top_log_probs** (`torch.Tensor` de forma `(batch_size, config.start_n_top * config.end_n_top)`, *opcional*, retornado se `start_positions` ou `end_positions` não forem fornecidos) -- Probabilidades logarítmicas para as `config.start_n_top * config.end_n_top` melhores possibilidades de tokens finais (beam-search). - **end_top_index** (`torch.LongTensor` de forma `(batch_size, config.start_n_top * config.end_n_top)`, *opcional*, retornado se `start_positions` ou `end_positions` não for fornecido) -- Índices para as `config.start_n_top * config.end_n_top` melhores possibilidades de tokens de fim (beam-search). - **cls_logits** (`torch.Tensor` de forma `(batch_size,)`, *opcional*, retornado se `start_positions` ou `end_positions` não forem fornecidos) -- Probabilidades logarítmicas para o rótulo `is_impossible` das respostas. - **hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Exemplo: ```python >>> 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 ```