Transformers documentation
T5
Este modelo foi publicado no HF papers em 23/10/2019 e contribuído para o Hugging Face Transformers em 16/11/2020.
T5
T5 é um transformer encoder-decoder disponível em uma variedade de tamanhos, de 60M a 11B parâmetros. Ele foi projetado para lidar com uma ampla gama de tarefas de NLP, tratando todas elas como problemas de texto-para-texto. Isso elimina a necessidade de arquiteturas específicas para cada tarefa, pois o T5 converte toda tarefa de NLP em uma tarefa de geração de texto.
Para formular cada tarefa como geração de texto, cada tarefa é precedida por um prefixo específico da tarefa (por exemplo, traduzir inglês para alemão: …, resumir: …). Isso permite que o T5 lide com tarefas como tradução, sumarização, resposta a perguntas e outras.
Você pode encontrar todos os checkpoints oficiais do T5 na coleção T5.
Clique nos modelos T5 na barra lateral à direita para ver mais exemplos de como aplicar o T5 a diferentes tarefas de linguagem.
Defina
use_kernels=Trueem from_pretrained() para substituir camadas compatíveis por kernels otimizados do Hub. Consulte Carregando kernels para saber mais.
O exemplo abaixo demonstra como gerar texto com Pipeline, AutoModel e como traduzir com T5 a partir da linha de comando.
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained(
"google-t5/t5-base"
)
model = AutoModelForSeq2SeqLM.from_pretrained(
"google-t5/t5-base",
device_map="auto"
)
input_ids = tokenizer("translate English to French: The weather is nice today.", return_tensors="pt").to(model.device)
output = model.generate(**input_ids, cache_implementation="static")
print(tokenizer.decode(output[0], skip_special_tokens=True))A quantização reduz a carga de memória de modelos grandes ao representar os pesos em uma precisão menor. Consulte a visão geral de Quantização para mais backends de quantização disponíveis.
O exemplo abaixo usa torchao para quantizar apenas os pesos para int4.
# pip install torchao
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, TorchAoConfig
quantization_config = TorchAoConfig("int4_weight_only", group_size=128)
model = AutoModelForSeq2SeqLM.from_pretrained(
"google/t5-v1_1-xl",
device_map="auto",
quantization_config=quantization_config
)
tokenizer = AutoTokenizer.from_pretrained("google/t5-v1_1-xl")
input_ids = tokenizer("translate English to French: The weather is nice today.", return_tensors="pt").to(model.device)
output = model.generate(**input_ids, cache_implementation="static")
print(tokenizer.decode(output[0], skip_special_tokens=True))Observações
- Você pode aplicar padding nas entradas do codificador à esquerda ou à direita, pois o T5 usa embeddings escalares relativos.
- Os modelos T5 precisam de uma taxa de aprendizado ligeiramente maior do que o padrão usado em Trainer. Normalmente, os valores
1e-4e3e-4funcionam bem para a maioria das tarefas.
T5Config
classe transformers.T5Config
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Truevocab_size: int = 32128d_model: int = 512d_kv: int = 64d_ff: int = 2048num_layers: int = 6num_decoder_layers: int | None = Nonenum_heads: int = 8relative_attention_num_buckets: int = 32relative_attention_max_distance: int = 128dropout_rate: float | int = 0.1layer_norm_epsilon: float = 1e-06initializer_factor: float = 1.0feed_forward_proj: str = 'relu'use_cache: bool = Truepad_token_id: int | None = 0eos_token_id: int | list[int] | None = 1classifier_dropout: float | int = 0.0is_decoder: bool = False )
Parâmetros
- is_encoder_decoder (
bool, opcional, padrãoTrue) — Indica se o modelo é usado como encoder/decoder ou não. - vocab_size (
int, opcional, padrão32128) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelosinput_ids. - d_model (
int, opcional, padrão512) — Tamanho das camadas do codificador e da camada pooler. - d_kv (
int, opcional, padrão64) — Tamanho das projeções de chave, consulta e valor por cabeça de atenção. Oinner_dimda camada de projeção será definido comonum_heads * d_kv. - d_ff (
int, opcional, padrão2048) — Dimensão das representações do MLP. - num_layers (
int, opcional, padrão6) — Número de camadas ocultas no decodificador do Transformer. - num_decoder_layers (
int, opcional) — Número de camadas ocultas no decodificador do Transformer. Se não for definido, usará o mesmo valor denum_layers. - num_heads (
int, opcional, padrão8) — 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ão0.1) — A proporção para todas as camadas de dropout. - layer_norm_epsilon (
float, opcional, padrão1e-06) — O epsilon usado pelas camadas de normalização de camada. - initializer_factor (
float, opcional, padrão1.0) — Fator para inicializar todas as matrizes de pesos (deve ser mantido em 1, usado internamente para testes de inicialização). - feed_forward_proj (
string, opcional, padrão"relu") — Tipo de camada feed forward a ser utilizada. Deve ser"relu"ou"gated-gelu". O T5v1.1 usa a projeção feed forward"gated-gelu". O T5 original usa"relu". - use_cache (
bool, opcional, padrãoTrue) — Se o modelo deve ou não retornar as últimas chaves/valores de atenção (não usado por todos os modelos). Relevante apenas seconfig.is_decoder=Trueou quando o modelo for um modelo generativo somente decodificador. - pad_token_id (
int, opcional, padrão0) — ID do token usado para preenchimento no vocabulário. - eos_token_id (
Union[int, list[int]], opcional, padrão1) — ID do token usado para o fim do fluxo no vocabulário. - classifier_dropout (
Union[float, int], opcional, padrão0.0) — A taxa de dropout para o classificador. - is_decoder (
bool, opcional, padrãoFalse) — Indica se o modelo é usado como decodificador ou não. SeFalse, o modelo é usado como codificador.
Esta é a classe de configuração para armazenar a configuração de um T5Model. Ela é usada para instanciar um modelo T5 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-t5/t5-small
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
T5Tokenizer
classe transformers.T5Tokenizer
< source >( vocab: str | list[tuple[str, float]] | None = Noneeos_token = '</s>'unk_token = '<unk>'pad_token = '<pad>'_spm_precompiled_charsmap = Noneextra_ids = 100additional_special_tokens = None**kwargs )
Parâmetros
- vocab_file (
str, opcional) — arquivo SentencePiece (geralmente com a extensão .spm) que contém o vocabulário necessário para instanciar um tokenizador. - eos_token (
str, opcional, padrão é"</s>") — O token de fim de sequência. Ao construir uma sequência usando tokens especiais, este não é o token usado para o fim da sequência. O token utilizado é o sep_token.Ao construir uma sequência usando tokens especiais, este não é o token utilizado para o fim da sequência. O token utilizado é o
sep_token. - unk_token (
str, opcional, padrão"<unk>") — O token desconhecido. Um token que não está no vocabulário não pode ser convertido em um ID e é definido como este token em vez disso. - pad_token (
str, opcional, padrão"<pad>") — O token usado para preenchimento, por exemplo, ao agrupar sequências de comprimentos diferentes. - extra_ids (
int, opcional, padrão 100) — Adiciona um número de ids extras à vocabulária para uso como sentinels. Esses tokens são acessíveis como “ - additional_special_tokens (
list[str], opcional) — Tokens especiais adicionais usados pelo tokenizer. - vocab (
str,dictoulist, opcional) — Dicionário de vocabulário personalizado. Se não for fornecido, um vocabulário mínimo é criado usando os tokens especiais.
Construa um tokenizador T5 (baseado na biblioteca tokenizers do HuggingFace). Baseado em Unigram.
Este tokenizador herda de TokenizersBackend, que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses métodos.
get_special_tokens_mask
< source >( token_ids_0: list[int]token_ids_1: list[int] | None = Nonealready_has_special_tokens: bool = False ) → A list of integers in the range [0, 1]
Parâmetros
- token_ids_0 — Lista de IDs da sequência (possivelmente já formatada).
- token_ids_1 — Não utilizado quando
already_has_special_tokens=True. Deve ser None nesse caso. - already_has_special_tokens — Indica se a sequência já está formatada com tokens especiais.
Retorna
Uma lista de inteiros no intervalo [0, 1]
1 para um token especial, 0 para um token de sequência.
Obter os ids de sequência de uma lista de tokens que não possui tokens especiais adicionados.
Para tokenizadores rápidos, os data collators chamam isso com already_has_special_tokens=True para construir uma máscara sobre uma sequência já formatada. Nesse caso, calculamos a máscara verificando a pertença em all_special_ids.
T5Model
classe transformers.T5Model
< source >( config: T5Config )
Parâmetros
- config (T5Config) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
O modelo T5 puro, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.BoolTensor] = Noneencoder_outputs: tuple[tuple[torch.FloatTensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqModelOutput or tuple(torch.FloatTensor)
Parâmetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length)) — Índices dos tokens da sequência de entrada no vocabulário. O T5 é um modelo com embeddings de posição relativa, portanto, você deve poder fazer padding das entradas tanto à direita quanto à esquerda.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
Para saber mais sobre como preparar
input_idspara o pré-treino, veja T5 Training. - attention_mask (
torch.FloatTensorde 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.
- decoder_input_ids (
torch.LongTensorde 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. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada do decodificador? O T5 usa o pad_token_id como token inicial para a geração de decoder_input_ids. Se past_key_values for usado, opcionalmente, apenas o último decoder_input_ids precisa ser inserido (veja past_key_values). Para saber mais sobre como preparar decoder_input_ids para pré-treino, consulte T5 Training.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
O que são IDs de entrada do decodificador?
O T5 usa o
pad_token_idcomo o token inicial para a geração dedecoder_input_ids. Sepast_key_valuesfor usado, opcionalmente apenas o últimodecoder_input_idsprecisa ser inserido (vejapast_key_values).Para saber mais sobre como preparar
decoder_input_idspara o pré-treinamento, consulte Treino do T5. - decoder_attention_mask (
torch.BoolTensorde forma(batch_size, target_sequence_length), opcional) — Comportamento padrão: gera um tensor que ignora tokens de preenchimento emdecoder_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_statede 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) — Estados ocultos 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 nopast_key_valuesretornado pelo modelo em uma etapa anterior da decodificação, quandouse_cache=Trueouconfig.use_cache=True.Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum
past_key_valuesfor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
past_key_valuesforem usados, espera-se que o usuário insira apenas osinput_idsnão processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma(batch_size, unprocessed_length), em vez de todos osinput_idscom a forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - decoder_inputs_embeds (
torch.Tensorde forma(batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passardecoder_input_idsvocê pode escolher passar diretamente uma representação incorporada. Sepast_key_valuesfor usado, opcionalmente apenas o últimodecoder_inputs_embedsprecisa ser entrada (vejapast_key_values). Isso é útil se você quiser mais controle sobre como converterdecoder_input_idsíndices em vetores associados do que a matriz de busca de incorporação interna do modelo.Se
decoder_input_idsedecoder_inputs_embedsestiverem ambos não definidos,decoder_inputs_embedsassume o valor deinputs_embeds. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values).
Retorna
Seq2SeqModelOutput ou tuple(torch.FloatTensor)
Um 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 (T5Config) e das entradas.
O método forward do T5Model sobrescreve o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
last_hidden_state (
torch.FloatTensorde 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_valuesfor usado, apenas o último hidden-state das sequências, com forma(batch_size, 1, hidden_size), é retornado.past_key_values (
EncoderDecoderCache, opcional, retornado quandouse_cache=Trueé passado ou quandoconfig.use_cache=True) — Trata-se de uma instância de EncoderDecoderCache. Para mais detalhes, consulte nosso guia de cache kv.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 quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 formato(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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(uma para cada camada) com 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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(uma para cada camada) com 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.FloatTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do codificador do modelo.encoder_hidden_states (
tuple(torch.FloatTensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(uma para cada camada) com 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:
>>> from transformers import AutoTokenizer, T5Model
>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
>>> model = T5Model.from_pretrained("google-t5/t5-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 T5Model.
>>> # This is not needed for torch's T5ForConditionalGeneration 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_stateT5ForConditionalGeneration
classe transformers.T5ForConditionalGeneration
< source >( config: T5Config )
Parâmetros
- config (T5Config) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
Modelo T5 com uma cabeça de language modeling no topo.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.BoolTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqLMOutput or tuple(torch.FloatTensor)
Parâmetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length)) — Índices dos tokens da sequência de entrada no vocabulário. O T5 é um modelo com embeddings de posição relativa, portanto, você deve poder fazer padding das entradas tanto à direita quanto à esquerda.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
Para saber mais sobre como preparar
input_idspara o pré-treino, veja T5 Training. - attention_mask (
torch.FloatTensorde 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.
- decoder_input_ids (
torch.LongTensorde 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. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada do decodificador? O T5 usa o pad_token_id como token inicial para a geração de decoder_input_ids. Se past_key_values for usado, opcionalmente, apenas o último decoder_input_ids precisa ser inserido (veja past_key_values). Para saber mais sobre como preparar decoder_input_ids para pré-treino, consulte T5 Training.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
O que são IDs de entrada do decodificador?
O T5 usa o
pad_token_idcomo o token inicial para a geração dedecoder_input_ids. Sepast_key_valuesfor usado, opcionalmente apenas o últimodecoder_input_idsprecisa ser inserido (vejapast_key_values).Para saber mais sobre como preparar
decoder_input_idspara o pré-treinamento, consulte Treino do T5. - decoder_attention_mask (
torch.BoolTensorde forma(batch_size, target_sequence_length), opcional) — Comportamento padrão: gera um tensor que ignora tokens de preenchimento emdecoder_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_statede 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) — Estados ocultos 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 nopast_key_valuesretornado pelo modelo em uma etapa anterior da decodificação, quandouse_cache=Trueouconfig.use_cache=True.Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum
past_key_valuesfor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
past_key_valuesforem usados, espera-se que o usuário insira apenas osinput_idsnão processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma(batch_size, unprocessed_length), em vez de todos osinput_idscom a forma(batch_size, sequence_length). - inputs_embeds (
torch.FloatTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de incorporação interna do modelo. - decoder_inputs_embeds (
torch.FloatTensorde forma(batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passardecoder_input_idsvocê pode escolher passar diretamente uma representação incorporada. Sepast_key_valuesfor usado, opcionalmente apenas o últimodecoder_inputs_embedsprecisa ser entrada (vejapast_key_values). Isso é útil se você quiser ter mais controle sobre como converterdecoder_input_idsíndices em vetores associados do que a matriz de busca de incorporação interna do modelo.Se
decoder_input_idsedecoder_inputs_embedsestiverem ambos não definidos,decoder_inputs_embedsassume o valor deinputs_embeds. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para o cálculo da perda de classificação/regressão de sequência. Os índices devem estar em[-100, 0, ..., config.vocab_size - 1]. Todos os rótulos definidos como-100são ignorados (mascarados); a perda é calculada apenas para rótulos em[0, ..., config.vocab_size] - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values).
Retorna
Seq2SeqLMOutput ou tuple(torch.FloatTensor)
Um 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 (T5Config) e das entradas.
O método forward de T5ForConditionalGeneration substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
loss (
torch.FloatTensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de modelagem de linguagem.logits (
torch.FloatTensorde 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 quandouse_cache=Trueé passado ou quandoconfig.use_cache=True) — Trata-se de uma instância de EncoderDecoderCache. Para mais detalhes, consulte nosso guia de cache kv.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 quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 formato(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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(uma para cada camada) com 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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(uma para cada camada) com 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.FloatTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do codificador do modelo.encoder_hidden_states (
tuple(torch.FloatTensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(uma para cada camada) com 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:
>>> from transformers import AutoTokenizer, T5ForConditionalGeneration
>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
>>> model = T5ForConditionalGeneration.from_pretrained("google-t5/t5-small")
>>> # training
>>> input_ids = tokenizer("The <extra_id_0> walks in <extra_id_1> park", return_tensors="pt").input_ids
>>> labels = tokenizer("<extra_id_0> cute dog <extra_id_1> the <extra_id_2>", return_tensors="pt").input_ids
>>> outputs = model(input_ids=input_ids, labels=labels)
>>> loss = outputs.loss
>>> logits = outputs.logits
>>> # inference
>>> input_ids = tokenizer(
... "summarize: studies have shown that owning a dog is good for you", return_tensors="pt"
... ).input_ids # Batch size 1
>>> outputs = model.generate(input_ids)
>>> print(tokenizer.decode(outputs[0], skip_special_tokens=True))
>>> # studies have shown that owning a dog is good for you.T5EncoderModel
classe transformers.T5EncoderModel
< source >( config: T5Config )
Parâmetros
- config (T5Config) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
O modelo T5 puro, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutput or tuple(torch.FloatTensor)
Parâmetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length)) — Índices dos tokens da sequência de entrada no vocabulário. O T5 é um modelo com embeddings de posição relativa, portanto, você deve poder fazer padding das entradas tanto à direita quanto à esquerda.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
Para saber mais sobre como preparar
input_idspara o pré-treino, veja T5 Training. - attention_mask (
torch.FloatTensorde 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.
- inputs_embeds (
torch.FloatTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de incorporação interna do modelo.
Retorna
BaseModelOutput ou tuple(torch.FloatTensor)
Um 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 (T5Config) e das entradas.
O método forward do T5EncoderModel substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
last_hidden_state (
torch.FloatTensorde 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 quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com formato(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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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 nos cabeçalhos de autoatenção.
Exemplo:
>>> from transformers import AutoTokenizer, T5EncoderModel
>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
>>> model = T5EncoderModel.from_pretrained("google-t5/t5-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_stateT5ForSequenceClassification
classe transformers.T5ForSequenceClassification
< source >( config: T5Config )
Parâmetros
- config (T5Config) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
Modelo T5 com uma sequência de classificação/cabeça no topo (uma camada linear no topo da saída agregada), por exemplo, para tarefas GLUE.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: list[torch.FloatTensor] | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqSequenceClassifierOutput or tuple(torch.FloatTensor)
Parâmetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length)) — Índices dos tokens da sequência de entrada no vocabulário. O T5 é um modelo com embeddings de posição relativa, portanto, você deve poder fazer padding das entradas tanto à direita quanto à esquerda.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
Para saber mais sobre como preparar
input_idspara o pré-treino, veja T5 Training. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- decoder_input_ids (
torch.LongTensorde 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. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada do decodificador? O T5 usa o pad_token_id como token inicial para a geração de decoder_input_ids. Se past_key_values for usado, opcionalmente, apenas o último decoder_input_ids precisa ser inserido (veja past_key_values). Para saber mais sobre como preparar decoder_input_ids para pré-treino, consulte T5 Training.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
O que são IDs de entrada do decodificador?
O T5 usa o
pad_token_idcomo o token inicial para a geração dedecoder_input_ids. Sepast_key_valuesfor usado, opcionalmente apenas o últimodecoder_input_idsprecisa ser inserido (vejapast_key_values).Para saber mais sobre como preparar
decoder_input_idspara o pré-treinamento, consulte Treino do T5. - decoder_attention_mask (
torch.BoolTensorde forma(batch_size, target_sequence_length), opcional) — Comportamento padrão: gera um tensor que ignora tokens de preenchimento emdecoder_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_statede 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.FloatTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de incorporação interna do modelo. - decoder_inputs_embeds (
torch.FloatTensorde forma(batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passardecoder_input_idsvocê pode escolher passar diretamente uma representação incorporada. Sepast_key_valuesfor usado, opcionalmente apenas o últimodecoder_inputs_embedsprecisa ser entrada (vejapast_key_values). Isso é útil se você quiser ter mais controle sobre como converterdecoder_input_idsíndices em vetores associados do que a matriz de busca de incorporação interna do modelo.Se
decoder_input_idsedecoder_inputs_embedsestiverem ambos não definidos,decoder_inputs_embedsassume o valor deinputs_embeds. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para o cálculo da perda de classificação/regressão de sequência. Os índices devem estar em[0, ..., config.num_labels - 1]. Seconfig.num_labels == 1, uma perda de regressão é calculada (perda de erro quadrático médio). Seconfig.num_labels > 1, uma perda de classificação é calculada (entropia cruzada). - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values).
Retorna
Seq2SeqSequenceClassifierOutput ou tuple(torch.FloatTensor)
Um 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 (T5Config) e das entradas.
O método forward de T5ForSequenceClassification substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
loss (
torch.FloatTensorde forma(1,), opcional, retornado quandolabelé fornecido) — Perda de classificação (ou de regressão se config.num_labels==1).logits (
torch.FloatTensorde 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 quandouse_cache=Trueé passado ou quandoconfig.use_cache=True) — Trata-se de uma instância de EncoderDecoderCache. Para mais detalhes, consulte nosso guia de cache kv.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 quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 formato(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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(uma para cada camada) com 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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(uma para cada camada) com 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.FloatTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do codificador do modelo.encoder_hidden_states (
tuple(torch.FloatTensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(uma para cada camada) com 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:
>>> import torch
>>> from transformers import AutoTokenizer, T5ForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
>>> model = T5ForSequenceClassification.from_pretrained("google-t5/t5-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 = T5ForSequenceClassification.from_pretrained("google-t5/t5-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:
>>> import torch
>>> from transformers import AutoTokenizer, T5ForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
>>> model = T5ForSequenceClassification.from_pretrained("google-t5/t5-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 = T5ForSequenceClassification.from_pretrained(
... "google-t5/t5-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).lossT5ForTokenClassification
classe transformers.T5ForTokenClassification
< source >( config: T5Config )
Parâmetros
- config (T5Config) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
O transformador T5 com uma cabeça de classificação de tokens no topo (uma camada linear sobre a saída dos estados ocultos), por exemplo, para tarefas de Reconhecimento de Entidades Nomeadas (NER).
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → TokenClassifierOutput or tuple(torch.FloatTensor)
Parâmetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length)) — Índices dos tokens da sequência de entrada no vocabulário. O T5 é um modelo com embeddings de posição relativa, portanto, você deve poder fazer padding das entradas tanto à direita quanto à esquerda.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
Para saber mais sobre como preparar
input_idspara o pré-treino, veja T5 Training. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de classificação de tokens. Os índices devem estar em[0, ..., config.num_labels - 1].
Retorna
TokenClassifierOutput ou tuple(torch.FloatTensor)
Um 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 (T5Config) e das entradas.
O método forward de T5ForTokenClassification sobrescreve o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
loss (
torch.FloatTensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de classificação.logits (
torch.FloatTensorde forma(batch_size, sequence_length, config.num_labels)) — Pontuações de classificação (antes do SoftMax).hidden_states (
tuple(torch.FloatTensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com formato(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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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 nos cabeçalhos de autoatenção.
Exemplo:
>>> from transformers import AutoTokenizer, T5ForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
>>> model = T5ForTokenClassification.from_pretrained("google-t5/t5-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)
...T5ForQuestionAnswering
classe transformers.T5ForQuestionAnswering
< source >( config: T5Config )
Parâmetros
- config (T5Config) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
O transformador T5 com uma cabeça de classificação de spans no topo para tarefas de resposta a perguntas extrativas, como
SQuAD (uma camada linear no topo da saída dos hidden-states para calcular span start logits e span end logits).
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.BoolTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonestart_positions: typing.Optional[torch.LongTensor] = Noneend_positions: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqQuestionAnsweringModelOutput or tuple(torch.FloatTensor)
Parâmetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length)) — Índices dos tokens da sequência de entrada no vocabulário. O T5 é um modelo com embeddings de posição relativa, portanto, você deve poder fazer padding das entradas tanto à direita quanto à esquerda.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
Para saber mais sobre como preparar
input_idspara o pré-treino, veja T5 Training. - attention_mask (
torch.FloatTensorde 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.
- decoder_input_ids (
torch.LongTensorde 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. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada do decodificador? O T5 usa o pad_token_id como token inicial para a geração de decoder_input_ids. Se past_key_values for usado, opcionalmente, apenas o último decoder_input_ids precisa ser inserido (veja past_key_values). Para saber mais sobre como preparar decoder_input_ids para pré-treino, consulte T5 Training.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
O que são IDs de entrada do decodificador?
O T5 usa o
pad_token_idcomo o token inicial para a geração dedecoder_input_ids. Sepast_key_valuesfor usado, opcionalmente apenas o últimodecoder_input_idsprecisa ser inserido (vejapast_key_values).Para saber mais sobre como preparar
decoder_input_idspara o pré-treinamento, consulte Treino do T5. - decoder_attention_mask (
torch.BoolTensorde forma(batch_size, target_sequence_length), opcional) — Comportamento padrão: gera um tensor que ignora tokens de preenchimento emdecoder_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_statede 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.LongTensorde 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.LongTensorde 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.FloatTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de incorporação interna do modelo. - decoder_inputs_embeds (
torch.FloatTensorde forma(batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passardecoder_input_idsvocê pode escolher passar diretamente uma representação incorporada. Sepast_key_valuesfor usado, opcionalmente apenas o últimodecoder_inputs_embedsprecisa ser entrada (vejapast_key_values). Isso é útil se você quiser ter mais controle sobre como converterdecoder_input_idsíndices em vetores associados do que a matriz de busca de incorporação interna do modelo.Se
decoder_input_idsedecoder_inputs_embedsestiverem ambos não definidos,decoder_inputs_embedsassume o valor deinputs_embeds. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values).
Retorna
Seq2SeqQuestionAnsweringModelOutput ou tuple(torch.FloatTensor)
Um 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 (T5Config) e das entradas.
O método forward de T5ForQuestionAnswering substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
loss (
torch.FloatTensorde forma(1,), opcional, retornado quandolabelsé fornecido) — A perda total de extração de span é a soma de uma Cross-Entropy para as posições de início e fim.start_logits (
torch.FloatTensorde forma(batch_size, sequence_length)) — Pontuações de início de span (antes do SoftMax).end_logits (
torch.FloatTensorde forma(batch_size, sequence_length)) — Pontuações de fim de trecho (antes do SoftMax).past_key_values (
EncoderDecoderCache, opcional, retornado quandouse_cache=Trueé passado ou quandoconfig.use_cache=True) — Trata-se de uma instância de EncoderDecoderCache. Para mais detalhes, consulte nosso guia de cache kv.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 quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 formato(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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(uma para cada camada) com 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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(uma para cada camada) com 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.FloatTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do codificador do modelo.encoder_hidden_states (
tuple(torch.FloatTensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(uma para cada camada) com 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:
>>> from transformers import AutoTokenizer, T5ForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
>>> model = T5ForQuestionAnswering.from_pretrained("google-t5/t5-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)
...