# XLM [XLM](https://huggingface.co/papers/1901.07291) demonstra o pré-treino multilíngue com duas abordagens: treinamento não supervisionado em um único idioma e treinamento supervisionado em mais de um idioma com um objetivo de modelo de linguagem multilíngue. O modelo XLM suporta o objetivo de modelagem de linguagem causal, modelagem de linguagem mascarada e modelagem de linguagem de tradução (uma extensão do objetivo de modelagem de linguagem mascarada do [BERT](./bert) para entradas de múltiplos idiomas). Você pode encontrar todos os checkpoints originais do XLM na organização [Facebook AI community](https://huggingface.co/FacebookAI?search_models=xlm-mlm). > [!TIP] > Clique nos modelos XLM na barra lateral à direita para ver mais exemplos de como aplicar o XLM a diferentes tarefas multilíngues, como classificação, tradução e resposta a perguntas. O exemplo abaixo demonstra como prever o token `` com [Pipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.Pipeline), [AutoModel](/docs/transformers/main/pt/model_doc/auto#transformers.AutoModel) e pela linha de comando. ```python from transformers import pipeline pipeline = pipeline( task="fill-mask", model="facebook/xlm-roberta-xl", device=0 ) pipeline("Bonjour, je suis un modèle .") ``` ```python import torch from transformers import AutoModelForMaskedLM, AutoTokenizer tokenizer = AutoTokenizer.from_pretrained( "FacebookAI/xlm-mlm-en-2048", ) model = AutoModelForMaskedLM.from_pretrained( "FacebookAI/xlm-mlm-en-2048", device_map="auto", ) inputs = tokenizer("Hello, I'm a model.", return_tensors="pt").to(model.device) with torch.no_grad(): outputs = model(**inputs) predictions = outputs.logits.argmax(dim=-1) predicted_token = tokenizer.decode(predictions[0][inputs["input_ids"][0] == tokenizer.mask_token_id]) print(f"Predicted token: {predicted_token}") ``` ## XLMConfig[[transformers.XLMConfig]] #### transformers.XLMConfig[[transformers.XLMConfig]] ```python transformers.XLMConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 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, 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 | None = 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/xlm/configuration_xlm.py#L24) **Parâmetros:** 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`) : Dimensionalidade dos embeddings e dos estados ocultos. 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 ou não usar *gelu* para as ativações em vez de *relu*. 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. 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) : O desvio padrão do truncated_normal_initializer para inicializar as matrizes de incorporação. 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. 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`) : Se o modelo inicializado deve ser um codificador ou decodificador de transformer, conforme visto em Vaswani et al. 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 XLMModel. Ela é usada para instanciar um modelo Xlm 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 [FacebookAI/xlm-mlm-en-2048](https://huggingface.co/FacebookAI/xlm-mlm-en-2048) 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. Exemplos: ```python >>> from transformers import XLMConfig, XLMModel >>> # Initializing a XLM configuration >>> configuration = XLMConfig() >>> # Initializing a model (with random weights) from the configuration >>> model = XLMModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## XLMTokenizer[[transformers.XLMTokenizer]] #### transformers.XLMTokenizer[[transformers.XLMTokenizer]] ```python transformers.XLMTokenizer(vocab_file, merges_file, unk_token = '', bos_token = '', sep_token = '', pad_token = '', cls_token = '', mask_token = '', additional_special_tokens = ['', '', '', '', '', '', '', '', '', ''], lang2id = None, id2lang = None, do_lowercase_and_remove_accent = True, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/tokenization_xlm.py#L134) **Parâmetros:** vocab_file (`str`) : Arquivo de vocabulário. merges_file (`str`) : Mescla o arquivo. 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. do_lowercase_and_remove_accent (`bool`, *opcional*, padrão `True`) : Se deve converter para minúsculas e remover acentos ao tokenizar. Construa um tokenizador XLM. Baseado em Byte-Pair Encoding. O processo de tokenização é o seguinte: - Pré-processamento e tokenização do Moses para a maioria dos idiomas suportados. - Tokenização específica de idioma para chinês (Jieba), japonês (KyTea) e tailandês (PyThaiNLP). - Opcionalmente, converte todo o texto de entrada para minúsculas e o normaliza. - 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 atributo `lang2id` mapeia os idiomas suportados pelo modelo com seus IDs, se fornecidos (definidos automaticamente para vocabulários pré-treinados). - O atributo `id2lang` realiza o mapeamento inverso, se fornecido (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.XLMTokenizer.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/xlm/tokenization_xlm.py#L475) **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 ` #### get_special_tokens_mask[[transformers.XLMTokenizer.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/xlm/tokenization_xlm.py#L502) **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. #### criar_ids_de_tipo_de_token_a_partir_de_sequências[[transformers.XLMTokenizer.create_token_type_ids_from_sequences]] ```python create_token_type_ids_from_sequences(token_ids_0: list, token_ids_1: list[int] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L1298) **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. **Retorna:** `list[int]` IDs de tipo de token de acordo com o padrão configurado. Crie uma máscara a partir das duas sequências passadas para ser usada em uma tarefa de classificação de pares de sequências. Este método constrói dinamicamente os IDs de tipo de token com base nos atributos de configuração do tokenizer: - `token_type_ids_pattern`: Padrão a ser usado ("all_zeros" ou "bert_style") - `token_type_ids_include_special_tokens`: Se deve considerar tokens especiais no cálculo do comprimento Exemplos: ```python # All zeros pattern (default, used by RoBERTa, BART, etc.) tokenizer.token_type_ids_pattern = "all_zeros" # Returns: [0, 0, 0, ...] for both sequences # BERT-style pattern (first sequence gets 0s, second gets 1s) tokenizer.token_type_ids_pattern = "bert_style" # Returns: [0, 0, 0, ..., 1, 1, 1, ...] for sequence pairs ``` #### save_vocabulary[[transformers.XLMTokenizer.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/tokenization_xlm.py#L530) ## Saídas específicas do XLM[[transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput]] #### transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput[[transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput]] ```python transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput(loss: typing.Optional[torch.Tensor] = None, start_top_log_probs: typing.Optional[torch.Tensor] = None, start_top_index: typing.Optional[torch.LongTensor] = None, end_top_log_probs: typing.Optional[torch.Tensor] = None, end_top_index: typing.Optional[torch.LongTensor] = None, cls_logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/modeling_xlm.py#L638) **Parâmetros:** 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 for fornecido) : Probabilidades logarítmicas para as config.start_n_top 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 (beam-search). 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 for fornecido) : Probabilidades logarítmicas para as `config.start_n_top * config.end_n_top` melhores possibilidades de tokens finais (busca por feixe). 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 finais (beam-search). cls_logits (`torch.Tensor` de forma `(batch_size,)`, *opcional*, retornado se `start_positions` ou `end_positions` não for fornecido) : 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 iniciais opcionais dos embeddings. attentions (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) : Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. Classe base para as saídas de modelos de resposta a perguntas que utilizam um `XLMSQuADHead`. ## XLMModel[[transformers.XLMModel]] #### transformers.XLMModel[[transformers.XLMModel]] ```python transformers.XLMModel(config: XLMConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/modeling_xlm.py#L667) **Parâmetros:** config ([XLMConfig](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMConfig)) : 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 Xlm puro, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.XLMModel.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, 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/xlm/modeling_xlm.py#L735) **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. 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 ([XLMConfig](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMConfig)) e das entradas. O método forward do [XLMModel](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMModel) substitui o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. ## XLMWithLMHeadModel[[transformers.XLMWithLMHeadModel]] #### transformers.XLMWithLMHeadModel[[transformers.XLMWithLMHeadModel]] ```python transformers.XLMWithLMHeadModel(config: XLMConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/modeling_xlm.py#L913) **Parâmetros:** config ([XLMConfig](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMConfig)) : 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 do modelo XLM 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.XLMWithLMHeadModel.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, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/modeling_xlm.py#L957) **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 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. logits_to_keep (`Union[int, torch.Tensor]`, *opcional*, padrão `0`) : Se for um `int`, calcula os logits para os últimos `logits_to_keep` tokens. Se for `0`, calcula os logits para todos os `input_ids` (caso especial). Apenas os logits do último token são necessários para a geração, e calculá-los apenas para esse token pode economizar memória, o que se torna bastante significativo para sequências longas ou tamanho de vocabulário grande. Se for um `torch.Tensor`, deve ser 1D, correspondendo aos índices a serem mantidos na dimensão de comprimento da sequência. Isso é útil ao usar o formato de tensor empacotado (uma única dimensão para lote e comprimento da sequência). **Retorna:** [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 ([XLMConfig](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMConfig)) e das entradas. O método forward do [XLMWithLMHeadModel](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMWithLMHeadModel) sobrescreve o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem mascarada (MLM). - **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax). - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Exemplo: ```python >>> import torch >>> from transformers import AutoTokenizer, XLMWithLMHeadModel >>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048") >>> model = XLMWithLMHeadModel.from_pretrained("FacebookAI/xlm-mlm-en-2048") >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") >>> outputs = model(**inputs, labels=inputs["input_ids"]) >>> loss = outputs.loss >>> logits = outputs.logits ``` ## XLMForSequenceClassification[[transformers.XLMForSequenceClassification]] #### transformers.XLMForSequenceClassification[[transformers.XLMForSequenceClassification]] ```python transformers.XLMForSequenceClassification(config: XLMConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/modeling_xlm.py#L1038) **Parâmetros:** config ([XLMConfig](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMConfig)) : 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 XLM 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.XLMForSequenceClassification.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/xlm/modeling_xlm.py#L1050) **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 ([XLMConfig](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMConfig)) e das entradas. O método forward de [XLMForSequenceClassification](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMForSequenceClassification) 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, XLMForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048") >>> model = XLMForSequenceClassification.from_pretrained("FacebookAI/xlm-mlm-en-2048") >>> 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 = XLMForSequenceClassification.from_pretrained("FacebookAI/xlm-mlm-en-2048", 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, XLMForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048") >>> model = XLMForSequenceClassification.from_pretrained("FacebookAI/xlm-mlm-en-2048", 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 = XLMForSequenceClassification.from_pretrained( ... "FacebookAI/xlm-mlm-en-2048", 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 ``` ## XLMForMultipleChoice[[transformers.XLMForMultipleChoice]] #### transformers.XLMForMultipleChoice[[transformers.XLMForMultipleChoice]] ```python transformers.XLMForMultipleChoice(config: XLMConfig, *inputs, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/modeling_xlm.py#L1446) **Parâmetros:** config ([XLMConfig](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMConfig)) : 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 Xlm com uma cabeça de classificação de escolha múltipla no topo (uma camada linear no topo da 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.XLMForMultipleChoice.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/xlm/modeling_xlm.py#L1457) **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 ([XLMConfig](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMConfig)) e das entradas. O método forward de [XLMForMultipleChoice](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMForMultipleChoice) 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, XLMForMultipleChoice >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048") >>> model = XLMForMultipleChoice.from_pretrained("FacebookAI/xlm-mlm-en-2048") >>> 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 ``` ## XLMForTokenClassification[[transformers.XLMForTokenClassification]] #### transformers.XLMForTokenClassification[[transformers.XLMForTokenClassification]] ```python transformers.XLMForTokenClassification(config: XLMConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/modeling_xlm.py#L1361) **Parâmetros:** config ([XLMConfig](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMConfig)) : 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 transformador Xlm com uma cabeça de classificação de tokens no topo (uma camada linear no topo da 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.XLMForTokenClassification.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/xlm/modeling_xlm.py#L1373) **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 ([XLMConfig](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMConfig)) e das entradas. O método forward de [XLMForTokenClassification](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMForTokenClassification) substitui o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de classificação. - **logits** (`torch.Tensor` de forma `(batch_size, 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, XLMForTokenClassification >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048") >>> model = XLMForTokenClassification.from_pretrained("FacebookAI/xlm-mlm-en-2048") >>> 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) ... ``` ## XLMForQuestionAnsweringSimple[[transformers.XLMForQuestionAnsweringSimple]] #### transformers.XLMForQuestionAnsweringSimple[[transformers.XLMForQuestionAnsweringSimple]] ```python transformers.XLMForQuestionAnsweringSimple(config: XLMConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/modeling_xlm.py#L1144) **Parâmetros:** config ([XLMConfig](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMConfig)) : 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 XLM 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.XLMForQuestionAnsweringSimple.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/xlm/modeling_xlm.py#L1154) **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 ([XLMConfig](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMConfig)) e das entradas. O método forward de [XLMForQuestionAnsweringSimple](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMForQuestionAnsweringSimple) 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, XLMForQuestionAnsweringSimple >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048") >>> model = XLMForQuestionAnsweringSimple.from_pretrained("FacebookAI/xlm-mlm-en-2048") >>> 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) ... ``` ## XLMForQuestionAnswering[[transformers.XLMForQuestionAnswering]] #### transformers.XLMForQuestionAnswering[[transformers.XLMForQuestionAnswering]] ```python transformers.XLMForQuestionAnswering(config: XLMConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/modeling_xlm.py#L1243) **Parâmetros:** config ([XLMConfig](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMConfig)) : 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 transformador Xlm com uma cabeça de classificação de spans no topo para tarefas de question-answering extrativo como SQuAD (uma camada linear no topo da saída dos hidden-states para calcular `span start logits` e `span end logits`). Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.XLMForQuestionAnswering.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/xlm/modeling_xlm.py#L1253) **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:** [XLMForQuestionAnsweringOutput](/docs/transformers/main/pt/model_doc/xlm#transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput) ou `tuple(torch.Tensor)` Um [XLMForQuestionAnsweringOutput](/docs/transformers/main/pt/model_doc/xlm#transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput) 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 ([XLMConfig](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMConfig)) e das entradas. O método forward de [XLMForQuestionAnswering](/docs/transformers/main/pt/model_doc/xlm#transformers.XLMForQuestionAnswering) 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 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` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma para cada camada) de 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, XLMForQuestionAnswering >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048") >>> model = XLMForQuestionAnswering.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 ```