# UMT5 ## Visão geral O modelo UMT5 foi proposto em [UniMax: Fairer and More Effective Language Sampling for Large-Scale Multilingual Pretraining](https://huggingface.co/papers/2304.09151) por Hyung Won Chung, Xavier Garcia, Adam Roberts, Yi Tay, Orhan Firat, Sharan Narang, Noah Constant. O resumo do artigo é o seguinte: *Modelos de linguagem grandes multilíngues pré-treinados têm usado tipicamente amostragem heurística baseada em temperatura para equilibrar diferentes idiomas. No entanto, trabalhos anteriores não avaliaram sistematicamente a eficácia de diferentes distribuições de idiomas no pré-treino em várias escalas de modelo. Neste artigo, propomos um novo método de amostragem, UniMax, que oferece uma cobertura mais uniforme dos idiomas principais, ao mesmo tempo em que mitiga o overfitting nos idiomas de cauda, ao limitar explicitamente o número de repetições sobre o corpus de cada idioma. Realizamos uma série extensa de ablações testando uma variedade de estratégias de amostragem em um conjunto de benchmarks multilíngues, variando a escala do modelo. Descobrimos que o UniMax supera a amostragem padrão baseada em temperatura, e os benefícios persistem à medida que a escala aumenta. Como parte da nossa contribuição, liberamos: (i) um corpus multilíngue mC4 aprimorado e atualizado, consistindo em 29 trilhões de caracteres em 107 idiomas, e (ii) um conjunto de checkpoints de modelos umT5 pré-treinados treinados com amostragem UniMax.* A Google lançou as seguintes variantes: - [google/umt5-small](https://huggingface.co/google/umt5-small) - [google/umt5-base](https://huggingface.co/google/umt5-base) - [google/umt5-xl](https://huggingface.co/google/umt5-xl) - [google/umt5-xxl](https://huggingface.co/google/umt5-xxl). Este modelo foi contribuído por [agemagician](https://huggingface.co/agemagician) e [stefan-it](https://huggingface.co/stefan-it). O código original pode ser encontrado [aqui](https://github.com/google-research/t5x). ## Dicas de uso - O UMT5 foi pré-treinado apenas em uma versão atualizada do corpus mC4 (107 idiomas; o mC4 original é a configuração `multilingual` de [`allenai/c4`](https://huggingface.co/datasets/allenai/c4/viewer/multilingual)), excluindo qualquer treinamento supervisionado. Portanto, este modelo precisa ser ajustado antes de ser utilizável em uma tarefa de nível inferior, ao contrário do modelo T5 original. - Como o umT5 foi pré-treinado de forma não supervisionada, não há nenhuma vantagem real em usar um prefixo de tarefa durante o fine-tuning. Se você estiver fazendo fine-tuning multi-tarefa, deve usar um prefixo. ## Diferenças em relação ao mT5? `UmT5` é baseado no mT5, com um viés posicional relativo não compartilhado que é calculado para cada camada. Isso significa que o conjunto do modelo define `has_relative_bias` para cada camada. O script de conversão também é diferente, pois o modelo foi salvo no formato de checkpoint mais recente do t5x. # Uso de exemplo ```python from transformers import AutoModelForSeq2SeqLM, AutoTokenizer model = AutoModelForSeq2SeqLM.from_pretrained("google/umt5-small", device_map="auto") tokenizer = AutoTokenizer.from_pretrained("google/umt5-small") inputs = tokenizer( "A walks into a bar and orders a with pinch of .", return_tensors="pt", ) outputs = model.generate(**inputs) print(tokenizer.batch_decode(outputs)) ['nyone who drink a alcohol A A. This I'] ``` Consulte a [página de documentação do T5](t5) para mais dicas, exemplos de código e notebooks. ## UMT5Config[[transformers.UMT5Config]] #### transformers.UMT5Config[[transformers.UMT5Config]] ```python transformers.UMT5Config(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, 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, is_encoder_decoder: bool = True, vocab_size: int = 250112, d_model: int = 512, d_kv: int = 64, d_ff: int = 1024, num_layers: int = 8, num_decoder_layers: int | None = None, num_heads: int = 6, relative_attention_num_buckets: int = 32, relative_attention_max_distance: int = 128, dropout_rate: float | int = 0.1, layer_norm_epsilon: float = 1e-06, initializer_factor: float = 1.0, feed_forward_proj: str = 'gated-gelu', use_cache: bool = True, pad_token_id: int | None = 0, eos_token_id: int | list[int] | None = 1, decoder_start_token_id: int | None = 0, classifier_dropout: float | int = 0.0, is_decoder: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/umt5/configuration_umt5.py#L24) **Parâmetros:** is_encoder_decoder (`bool`, *opcional*, padrão `True`) : Indica se o modelo é usado como codificador/decodificador ou não. vocab_size (`int`, *opcional*, padrão `250112`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`. d_model (`int`, *opcional*, padrão `512`) : Tamanho das camadas do codificador e da camada pooler. d_kv (`int`, *opcional*, padrão `64`) : Tamanho das projeções de chave, consulta e valor por cabeça de atenção. O `inner_dim` da camada de projeção será definido como `num_heads * d_kv`. d_ff (`int`, *opcional*, padrão `1024`) : Dimensão das representações do MLP. num_layers (`int`, *opcional*, padrão `8`) : Número de camadas ocultas no decodificador do Transformer. num_decoder_layers (`int`, *opcional*) : Número de camadas ocultas no decodificador do Transformer. Usará o mesmo valor de `num_layers` se não for definido. num_heads (`int`, *opcional*, padrão `6`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. relative_attention_num_buckets (`int`, *opcional*, padrão 32) : O número de buckets a serem usados em cada camada de atenção. relative_attention_max_distance (`int`, *opcional*, padrão 128) : A distância máxima das sequências mais longas para a separação em buckets. dropout_rate (`Union[float, int]`, *opcional*, padrão `0.1`) : A proporção para todas as camadas de dropout. layer_norm_epsilon (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização de camada. initializer_factor (`float`, *opcional*, padrão `1.0`) : Um fator para inicializar todas as matrizes de pesos (deve ser mantido em 1, usado internamente para testes de inicialização). feed_forward_proj (`str`, *opcional*, padrão `"gated-gelu"`) : Tipo de camada feed forward a ser usada. Deve ser um dos valores `"relu"` ou `"gated-gelu"`. use_cache (`bool`, *opcional*, padrão `True`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de decodificador. pad_token_id (`int`, *opcional*, padrão `0`) : ID do token usado para preenchimento 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. decoder_start_token_id (`int`, *opcional*, padrão `0`) : Se um modelo encoder-decoder inicia a decodificação com um token diferente de `bos`, o id desse token. classifier_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para o classificador. is_decoder (`bool`, *opcional*, padrão `False`) : Indica se o modelo é usado como decodificador ou não. Se `False`, o modelo é usado como codificador. Esta é a classe de configuração para armazenar a configuração de um UMT5Model. Ela é usada para instanciar um modelo Umt5 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 [google/umt5-small](https://huggingface.co/google/umt5-small) 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. ## UMT5Model[[transformers.UMT5Model]] #### transformers.UMT5Model[[transformers.UMT5Model]] ```python transformers.UMT5Model(config: UMT5Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/umt5/modeling_umt5.py#L736) **Parâmetros:** config ([UMT5Config](/docs/transformers/main/pt/model_doc/umt5#transformers.UMT5Config)) : 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 Umt5 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.UMT5Model.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.FloatTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, encoder_outputs: tuple[tuple[torch.FloatTensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/umt5/modeling_umt5.py#L788) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. O UMT5 é um modelo com embeddings de posição relativa, portanto, você deve poder preencher as entradas tanto à direita quanto à esquerda. 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) Para saber mais sobre como preparar `input_ids` para pré-treinamento, veja [UMT5 Training](./umt5#training). attention_mask (`torch.FloatTensor` 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) decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada do decodificador no vocabulário. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Veja [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 detalhes. [O que são IDs de entrada do decodificador?](../glossary#decoder-input-ids) O UMT5 usa o `pad_token_id` como o token inicial para a geração de `decoder_input_ids`. Se `past_key_values` for usado, opcionalmente apenas os últimos `decoder_input_ids` precisam ser inseridos (veja `past_key_values`). Para saber mais sobre como preparar `decoder_input_ids` para pré-treinamento, dê uma olhada em [UMT5 Training](./umt5#training). decoder_attention_mask (`torch.BoolTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamento padrão: gerar um tensor que ignora tokens de preenchimento em `decoder_input_ids`. A máscara causal também será usada por padrão. encoder_outputs (`tuple[tuple[torch.FloatTensor]]`, *opcional*) : A tupla consiste em (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder. past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. 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. decoder_inputs_embeds (`torch.Tensor` de forma `(batch_size, target_sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `decoder_input_ids`, você pode escolher passar diretamente uma representação incorporada. Se `past_key_values` for usado, opcionalmente apenas o último `decoder_inputs_embeds` precisa ser inserido (veja `past_key_values`). Isso é útil se você quiser ter mais controle sobre como converter os índices de `decoder_input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. Se `decoder_input_ids` e `decoder_inputs_embeds` estiverem ambos não definidos, `decoder_inputs_embeds` assume o valor de `inputs_embeds`. use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). **Retorna:** [Seq2SeqModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqModelOutput) ou `tuple(torch.FloatTensor)` Um [Seq2SeqModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqModelOutput) ou uma tupla de `torch.FloatTensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([UMT5Config](/docs/transformers/main/pt/model_doc/umt5#transformers.UMT5Config)) e das entradas. O método forward do [UMT5Model](/docs/transformers/main/pt/model_doc/umt5#transformers.UMT5Model) 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.FloatTensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do decodificador do modelo. Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado. - **past_key_values** (`EncoderDecoderCache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- É uma instância de [EncoderDecoderCache](/docs/transformers/main/pt/internal/generation_utils#transformers.EncoderDecoderCache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **decoder_hidden_states** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (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 decodificador na saída de cada camada, além das saídas opcionais do embedding inicial. - **decoder_attentions** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. - **cross_attentions** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada. - **encoder_last_hidden_state** (`torch.FloatTensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Sequência de hidden-states na saída da última camada do encoder do modelo. - **encoder_hidden_states** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do codificador na saída de cada camada, além das saídas opcionais do embedding inicial. - **encoder_attentions** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção do codificador, 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, UMT5Model >>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small") >>> model = UMT5Model.from_pretrained("google/umt5-small") >>> input_ids = tokenizer( ... "Studies have been shown that owning a dog is good for you", return_tensors="pt" ... ).input_ids # Batch size 1 >>> decoder_input_ids = tokenizer("Studies show that", return_tensors="pt").input_ids # Batch size 1 >>> # preprocess: Prepend decoder_input_ids with start token which is pad token for UMT5Model. >>> # This is not needed for torch's UMT5ForConditionalGeneration as it does this internally using labels arg. >>> decoder_input_ids = model._shift_right(decoder_input_ids) >>> # forward pass >>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids) >>> last_hidden_states = outputs.last_hidden_state ``` ## UMT5ForConditionalGeneration[[transformers.UMT5ForConditionalGeneration]] #### transformers.UMT5ForConditionalGeneration[[transformers.UMT5ForConditionalGeneration]] ```python transformers.UMT5ForConditionalGeneration(config: UMT5Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/umt5/modeling_umt5.py#L899) **Parâmetros:** config ([UMT5Config](/docs/transformers/main/pt/model_doc/umt5#transformers.UMT5Config)) : 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 UMT5 com uma cabeça de `language modeling` 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.UMT5ForConditionalGeneration.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.FloatTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/umt5/modeling_umt5.py#L954) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. O UMT5 é um modelo com embeddings de posição relativa, portanto, você deve poder preencher as entradas tanto à direita quanto à esquerda. 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) Para saber mais sobre como preparar `input_ids` para pré-treinamento, veja [UMT5 Training](./umt5#training). attention_mask (`torch.FloatTensor` 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) decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada do decodificador no vocabulário. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Veja [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 detalhes. [O que são IDs de entrada do decodificador?](../glossary#decoder-input-ids) O UMT5 usa o `pad_token_id` como o token inicial para a geração de `decoder_input_ids`. Se `past_key_values` for usado, opcionalmente apenas os últimos `decoder_input_ids` precisam ser inseridos (veja `past_key_values`). Para saber mais sobre como preparar `decoder_input_ids` para pré-treinamento, dê uma olhada em [UMT5 Training](./umt5#training). decoder_attention_mask (`torch.BoolTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamento padrão: gerar um tensor que ignora tokens de preenchimento em `decoder_input_ids`. A máscara causal também será usada por padrão. encoder_outputs (`tuple[tuple[torch.Tensor]]`, *opcional*) : A tupla consiste em (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder. past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.FloatTensor` 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. decoder_inputs_embeds (`torch.FloatTensor` de forma `(batch_size, target_sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `decoder_input_ids`, você pode escolher passar diretamente uma representação incorporada. Se `past_key_values` for usado, opcionalmente apenas o último `decoder_inputs_embeds` precisa ser inserido (veja `past_key_values`). Isso é útil se você quiser ter mais controle sobre como converter os índices de `decoder_input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. Se `decoder_input_ids` e `decoder_inputs_embeds` estiverem ambos não definidos, `decoder_inputs_embeds` assume o valor de `inputs_embeds`. 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 `[-100, 0, ..., config.vocab_size - 1]`. Todos os rótulos definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os rótulos em `[0, ..., config.vocab_size]` use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). **Retorna:** [Seq2SeqLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou `tuple(torch.FloatTensor)` Um [Seq2SeqLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou uma tupla de `torch.FloatTensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([UMT5Config](/docs/transformers/main/pt/model_doc/umt5#transformers.UMT5Config)) e das entradas. O método forward de [UMT5ForConditionalGeneration](/docs/transformers/main/pt/model_doc/umt5#transformers.UMT5ForConditionalGeneration) 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.FloatTensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem. - **logits** (`torch.FloatTensor` 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). - **past_key_values** (`EncoderDecoderCache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- É uma instância de [EncoderDecoderCache](/docs/transformers/main/pt/internal/generation_utils#transformers.EncoderDecoderCache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **decoder_hidden_states** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (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 decodificador na saída de cada camada, além das saídas do embedding inicial. - **decoder_attentions** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. - **cross_attentions** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada. - **encoder_last_hidden_state** (`torch.FloatTensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Sequência de hidden-states na saída da última camada do encoder do modelo. - **encoder_hidden_states** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do codificador na saída de cada camada, além das saídas do embedding inicial. - **encoder_attentions** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Exemplos: ```python >>> from transformers import AutoTokenizer, UMT5ForConditionalGeneration >>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small") >>> model = UMT5ForConditionalGeneration.from_pretrained("google/umt5-small") >>> # training >>> input_ids = tokenizer("The walks in park", return_tensors="pt").input_ids >>> labels = tokenizer(" cute dog the ", return_tensors="pt").input_ids >>> outputs = model(input_ids=input_ids, labels=labels) >>> loss = outputs.loss >>> logits = outputs.logits >>> # inference >>> input_ids = tokenizer("Studies have shown that good for you", return_tensors="pt").input_ids >>> outputs = model.generate(input_ids) >>> tokenizer.decode(outputs[0], skip_special_tokens=True) ``` ## UMT5EncoderModel[[transformers.UMT5EncoderModel]] #### transformers.UMT5EncoderModel[[transformers.UMT5EncoderModel]] ```python transformers.UMT5EncoderModel(config: UMT5Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/umt5/modeling_umt5.py#L1091) **Parâmetros:** config ([UMT5Config](/docs/transformers/main/pt/model_doc/umt5#transformers.UMT5Config)) : 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 Umt5 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.UMT5EncoderModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.FloatTensor] = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/umt5/modeling_umt5.py#L1132) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. O UMT5 é um modelo com embeddings de posição relativa, portanto, você deve poder preencher as entradas tanto à direita quanto à esquerda. 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. Para saber mais sobre como preparar `input_ids` para pré-treinamento, veja [UMT5 Training](./umt5#training). attention_mask (`torch.FloatTensor` 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) inputs_embeds (`torch.FloatTensor` 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. **Retorna:** [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou `tuple(torch.FloatTensor)` Um [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou uma tupla de `torch.FloatTensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([UMT5Config](/docs/transformers/main/pt/model_doc/umt5#transformers.UMT5Config)) e das entradas. O método forward do [UMT5EncoderModel](/docs/transformers/main/pt/model_doc/umt5#transformers.UMT5EncoderModel) 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.FloatTensor` 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.FloatTensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (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.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma 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, UMT5EncoderModel >>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small") >>> model = UMT5EncoderModel.from_pretrained("google/umt5-small") >>> input_ids = tokenizer( ... "Studies have been shown that owning a dog is good for you", return_tensors="pt" ... ).input_ids # Batch size 1 >>> outputs = model(input_ids=input_ids) >>> last_hidden_states = outputs.last_hidden_state ``` ## UMT5ForSequenceClassification[[transformers.UMT5ForSequenceClassification]] #### transformers.UMT5ForSequenceClassification[[transformers.UMT5ForSequenceClassification]] ```python transformers.UMT5ForSequenceClassification(config: UMT5Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/umt5/modeling_umt5.py#L1181) **Parâmetros:** config ([UMT5Config](/docs/transformers/main/pt/model_doc/umt5#transformers.UMT5Config)) : 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 UMT5 com uma classificação de sequência/cabeçalho no topo (uma camada linear no topo da saída agrupada), 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.UMT5ForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: list[torch.FloatTensor] | None = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/umt5/modeling_umt5.py#L1193) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. O UMT5 é um modelo com embeddings de posição relativa, portanto, você deve poder preencher as entradas tanto à direita quanto à esquerda. 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) Para saber mais sobre como preparar `input_ids` para pré-treinamento, veja [UMT5 Training](./umt5#training). 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) decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada do decodificador no vocabulário. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Veja [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 detalhes. [O que são IDs de entrada do decodificador?](../glossary#decoder-input-ids) O UMT5 usa o `pad_token_id` como o token inicial para a geração de `decoder_input_ids`. Se `past_key_values` for usado, opcionalmente apenas os últimos `decoder_input_ids` precisam ser inseridos (veja `past_key_values`). Para saber mais sobre como preparar `decoder_input_ids` para pré-treinamento, dê uma olhada em [UMT5 Training](./umt5#training). decoder_attention_mask (`torch.BoolTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamento padrão: gerar um tensor que ignora tokens de preenchimento em `decoder_input_ids`. A máscara causal também será usada por padrão. encoder_outputs (`list[torch.FloatTensor]`, *opcional*) : A tupla consiste em (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder. inputs_embeds (`torch.FloatTensor` 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. decoder_inputs_embeds (`torch.FloatTensor` de forma `(batch_size, target_sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `decoder_input_ids`, você pode escolher passar diretamente uma representação incorporada. Se `past_key_values` for usado, opcionalmente apenas o último `decoder_inputs_embeds` precisa ser inserido (veja `past_key_values`). Isso é útil se você quiser ter mais controle sobre como converter os índices de `decoder_input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. Se `decoder_input_ids` e `decoder_inputs_embeds` estiverem ambos não definidos, `decoder_inputs_embeds` assume o valor de `inputs_embeds`. 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). use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). **Retorna:** [Seq2SeqSequenceClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput) ou `tuple(torch.FloatTensor)` Um [Seq2SeqSequenceClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput) ou uma tupla de `torch.FloatTensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([UMT5Config](/docs/transformers/main/pt/model_doc/umt5#transformers.UMT5Config)) e das entradas. O método forward de [UMT5ForSequenceClassification](/docs/transformers/main/pt/model_doc/umt5#transformers.UMT5ForSequenceClassification) 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.FloatTensor` de forma `(1,)`, *opcional*, retornado quando `label` é fornecido) -- Perda de classificação (ou de regressão se config.num_labels==1). - **logits** (`torch.FloatTensor` de forma `(batch_size, config.num_labels)`) -- Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax). - **past_key_values** (`EncoderDecoderCache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- É uma instância de [EncoderDecoderCache](/docs/transformers/main/pt/internal/generation_utils#transformers.EncoderDecoderCache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **decoder_hidden_states** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (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 decodificador na saída de cada camada, além das saídas do embedding inicial. - **decoder_attentions** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. - **cross_attentions** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada. - **encoder_last_hidden_state** (`torch.FloatTensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Sequência de hidden-states na saída da última camada do encoder do modelo. - **encoder_hidden_states** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do codificador na saída de cada camada, além das saídas do embedding inicial. - **encoder_attentions** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção do codificador, 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, UMT5ForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small") >>> model = UMT5ForSequenceClassification.from_pretrained("google/umt5-small") >>> 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 = UMT5ForSequenceClassification.from_pretrained("google/umt5-small", 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, UMT5ForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small") >>> model = UMT5ForSequenceClassification.from_pretrained("google/umt5-small", 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 = UMT5ForSequenceClassification.from_pretrained( ... "google/umt5-small", 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 ``` ## UMT5ForTokenClassification[[transformers.UMT5ForTokenClassification]] #### transformers.UMT5ForTokenClassification[[transformers.UMT5ForTokenClassification]] ```python transformers.UMT5ForTokenClassification(config: UMT5Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/umt5/modeling_umt5.py#L1321) **Parâmetros:** config ([UMT5Config](/docs/transformers/main/pt/model_doc/umt5#transformers.UMT5Config)) : 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 Umt5 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.UMT5ForTokenClassification.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/umt5/modeling_umt5.py#L1336) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. O UMT5 é um modelo com embeddings de posição relativa, portanto, você deve poder preencher as entradas tanto à direita quanto à esquerda. 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) Para saber mais sobre como preparar `input_ids` para pré-treinamento, veja [UMT5 Training](./umt5#training). 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) inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de classificação de tokens. Os índices devem estar em `[0, ..., config.num_labels - 1]`. **Retorna:** [TokenClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) ou `tuple(torch.FloatTensor)` Um [TokenClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) ou uma tupla de `torch.FloatTensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([UMT5Config](/docs/transformers/main/pt/model_doc/umt5#transformers.UMT5Config)) e das entradas. O método forward de [UMT5ForTokenClassification](/docs/transformers/main/pt/model_doc/umt5#transformers.UMT5ForTokenClassification) 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.FloatTensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de classificação. - **logits** (`torch.FloatTensor` de forma `(batch_size, sequence_length, config.num_labels)`) -- Pontuações de classificação (antes do SoftMax). - **hidden_states** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (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.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma 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, UMT5ForTokenClassification >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small") >>> model = UMT5ForTokenClassification.from_pretrained("google/umt5-small") >>> 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) ... ``` ## UMT5ForQuestionAnswering[[transformers.UMT5ForQuestionAnswering]] #### transformers.UMT5ForQuestionAnswering[[transformers.UMT5ForQuestionAnswering]] ```python transformers.UMT5ForQuestionAnswering(config: UMT5Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/umt5/modeling_umt5.py#L1384) **Parâmetros:** config ([UMT5Config](/docs/transformers/main/pt/model_doc/umt5#transformers.UMT5Config)) : 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 Umt5 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.UMT5ForQuestionAnswering.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.FloatTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, start_positions: typing.Optional[torch.LongTensor] = None, end_positions: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/umt5/modeling_umt5.py#L1422) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. O UMT5 é um modelo com embeddings de posição relativa, portanto, você deve poder preencher as entradas tanto à direita quanto à esquerda. 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) Para saber mais sobre como preparar `input_ids` para pré-treinamento, veja [UMT5 Training](./umt5#training). attention_mask (`torch.FloatTensor` 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) decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada do decodificador no vocabulário. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Veja [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 detalhes. [O que são IDs de entrada do decodificador?](../glossary#decoder-input-ids) O UMT5 usa o `pad_token_id` como o token inicial para a geração de `decoder_input_ids`. Se `past_key_values` for usado, opcionalmente apenas os últimos `decoder_input_ids` precisam ser inseridos (veja `past_key_values`). Para saber mais sobre como preparar `decoder_input_ids` para pré-treinamento, dê uma olhada em [UMT5 Training](./umt5#training). decoder_attention_mask (`torch.BoolTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamento padrão: gerar um tensor que ignora tokens de preenchimento em `decoder_input_ids`. A máscara causal também será usada por padrão. encoder_outputs (`tuple[tuple[torch.Tensor]]`, *opcional*) : A tupla consiste em (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder. start_positions (`torch.LongTensor` 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.LongTensor` 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. inputs_embeds (`torch.FloatTensor` 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. decoder_inputs_embeds (`torch.FloatTensor` de forma `(batch_size, target_sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `decoder_input_ids`, você pode escolher passar diretamente uma representação incorporada. Se `past_key_values` for usado, opcionalmente apenas o último `decoder_inputs_embeds` precisa ser inserido (veja `past_key_values`). Isso é útil se você quiser ter mais controle sobre como converter os índices de `decoder_input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. Se `decoder_input_ids` e `decoder_inputs_embeds` estiverem ambos não definidos, `decoder_inputs_embeds` assume o valor de `inputs_embeds`. use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). **Retorna:** [Seq2SeqQuestionAnsweringModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput) ou `tuple(torch.FloatTensor)` Um [Seq2SeqQuestionAnsweringModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput) ou uma tupla de `torch.FloatTensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([UMT5Config](/docs/transformers/main/pt/model_doc/umt5#transformers.UMT5Config)) e das entradas. O método forward de [UMT5ForQuestionAnswering](/docs/transformers/main/pt/model_doc/umt5#transformers.UMT5ForQuestionAnswering) 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.FloatTensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- A perda total de extração de span é a soma de uma Cross-Entropy para as posições de início e fim. - **start_logits** (`torch.FloatTensor` de forma `(batch_size, sequence_length)`) -- Pontuações de início de trecho (antes do SoftMax). - **end_logits** (`torch.FloatTensor` de forma `(batch_size, sequence_length)`) -- Pontuações de fim de trecho (antes do SoftMax). - **past_key_values** (`EncoderDecoderCache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- É uma instância de [EncoderDecoderCache](/docs/transformers/main/pt/internal/generation_utils#transformers.EncoderDecoderCache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **decoder_hidden_states** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (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 decodificador na saída de cada camada, além das saídas do embedding inicial. - **decoder_attentions** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. - **cross_attentions** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada. - **encoder_last_hidden_state** (`torch.FloatTensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Sequência de hidden-states na saída da última camada do encoder do modelo. - **encoder_hidden_states** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do codificador na saída de cada camada, além das saídas do embedding inicial. - **encoder_attentions** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção do codificador, 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, UMT5ForQuestionAnswering >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small") >>> model = UMT5ForQuestionAnswering.from_pretrained("google/umt5-small") >>> 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) ... ```