Transformers documentation
Perceiver
Este modelo foi publicado no HF papers em 2021-07-30 e contribuído para o Hugging Face Transformers em 2021-12-08.
Perceiver
Visão geral
O modelo Perceiver IO foi proposto em Perceiver IO: A General Architecture for Structured Inputs & Outputs por Andrew Jaegle, Sebastian Borgeaud, Jean-Baptiste Alayrac, Carl Doersch, Catalin Ionescu, David Ding, Skanda Koppula, Daniel Zoran, Andrew Brock, Evan Shelhamer, Olivier Hénaff, Matthew M. Botvinick, Andrew Zisserman, Oriol Vinyals, João Carreira.
O Perceiver IO é uma generalização do Perceiver para lidar com saídas arbitrárias, além de entradas arbitrárias. O Perceiver original produzia apenas um único rótulo de classificação. Além de rótulos de classificação, o Perceiver IO pode produzir (por exemplo) linguagem, fluxo óptico e vídeos multimodais com áudio. Isso é feito usando os mesmos blocos de construção do Perceiver original. A complexidade computacional do Perceiver IO é linear em relação ao tamanho da entrada e da saída, e a maior parte do processamento ocorre no espaço latente, permitindo processar entradas e saídas muito maiores do que as que podem ser tratadas por Transformers padrão. Isso significa, por exemplo, que o Perceiver IO pode fazer modelagem de linguagem mascarada no estilo BERT diretamente usando bytes, em vez de entradas tokenizadas.
O resumo do artigo é o seguinte:
O modelo Perceiver, proposto recentemente, obtém bons resultados em vários domínios (imagens, áudio, multimodal, nuvens de pontos) enquanto escala linearmente em computação e memória em relação ao tamanho da entrada. Embora o Perceiver suporte muitos tipos de entradas, ele só consegue produzir saídas muito simples, como pontuações de classe. O Perceiver IO supera essa limitação sem sacrificar as propriedades atraentes do modelo original, aprendendo a consultar flexivelmente o espaço latente do modelo para produzir saídas de tamanho e semântica arbitrários. O Perceiver IO ainda desacopla a profundidade do modelo do tamanho dos dados e ainda escala linearmente com o tamanho dos dados, mas agora em relação tanto ao tamanho da entrada quanto ao da saída. O modelo Perceiver IO completo alcança resultados robustos em tarefas com espaços de saída altamente estruturados, como linguagem natural e compreensão visual, StarCraft II, e domínios multitarefa e multimodais. Como destaques, o Perceiver IO iguala um baseline BERT baseado em Transformer no benchmark de linguagem GLUE sem a necessidade de tokenização da entrada e alcança desempenho state-of-the-art na estimativa de fluxo óptico Sintel.
Aqui está um resumo (TLDR) explicando como o Perceiver funciona:
O principal problema do mecanismo de autoatenção do Transformer é que os requisitos de tempo e memória escalam quadraticamente com o comprimento da sequência. Portanto, modelos como BERT e RoBERTa são limitados a um comprimento máximo de sequência de 512 tokens. O Perceiver busca resolver esse problema realizando a autoatenção em um conjunto de variáveis latentes, em vez de realizá-la nas entradas, e usando as entradas apenas para a atenção cruzada. Dessa forma, os requisitos de tempo e memória não dependem mais do comprimento das entradas, pois utiliza-se uma quantidade fixa de variáveis latentes, como 256 ou 512. Essas variáveis são inicializadas aleatoriamente e, em seguida, treinadas de ponta a ponta usando retropropagação.
Internamente, o PerceiverModel criará os latentes, que é um tensor de forma (batch_size, num_latents, d_latents). É necessário fornecer inputs (que podem ser texto, imagens, áudio, o que você quiser!) ao modelo, que os usará para realizar cross-attention com os latentes. A saída do codificador Perceiver é um tensor da mesma forma. Em seguida, de forma semelhante ao BERT, é possível converter os últimos estados ocultos dos latentes em logits de classificação, fazendo a média ao longo da dimensão da sequência e colocando uma camada linear sobre isso para projetar os d_latents para num_labels.
Essa era a ideia do artigo original do Perceiver. No entanto, ele só conseguia gerar logits de classificação. Em um trabalho subsequente, o PerceiverIO, eles generalizaram o método para permitir que o modelo também produza saídas de tamanho arbitrário. Como, você pode perguntar? A ideia é, na verdade, relativamente simples: define-se saídas de tamanho arbitrário e, em seguida, aplica-se atenção cruzada com os últimos estados ocultos dos latentes, usando as saídas como consultas e os latentes como chaves e valores.
Diga-se, por exemplo, que se deseja realizar modelagem de linguagem mascarada (estilo BERT) com o Perceiver. Como o comprimento da entrada do Perceiver não terá impacto no tempo de computação das camadas de autoatenção, é possível fornecer bytes brutos, fornecendo inputs de comprimento 2048 ao modelo. Se agora se mascarar certos desses 2048 tokens, pode-se definir os outputs como tendo a forma: (batch_size, 2048, 768). Em seguida, executa-se a atenção cruzada com os estados ocultos finais dos latentes para atualizar o tensor outputs. Após a atenção cruzada, ainda se tem um tensor de forma (batch_size, 2048, 768). Então, pode-se colocar uma cabeça de modelagem de linguagem regular por cima, para projetar a última dimensão para o tamanho do vocabulário do modelo, ou seja, criando logits de forma (batch_size, 2048, 262) (já que o Perceiver usa um vocabulário de 262 IDs de bytes).
Perceiver IO architecture. Taken from the original paper Este modelo foi contribuído por nielsr. O código original pode ser encontrado aqui.
O Perceiver não funciona com
torch.nn.DataParalleldevido a um bug no PyTorch, veja issue #36035
Recursos
- A maneira mais rápida de começar com o Perceiver é consultar os notebooks de tutorial.
- Consulte o post no blog se você quiser entender completamente como o modelo funciona e é implementado na biblioteca. Observe que os modelos disponíveis na biblioteca apenas apresentam alguns exemplos do que você pode fazer com o Perceiver. Existem muitos outros casos de uso, incluindo question answering, named-entity recognition, object detection, audio classification, video classification, etc.
- Guia da tarefa de classificação de texto
- Guia da tarefa de modelagem de linguagem mascarada
- Guia da tarefa de classificação de imagens
Saídas específicas do Perceiver
classe transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput
< source >( logits: typing.Optional[torch.FloatTensor] = Nonelast_hidden_state: typing.Optional[torch.FloatTensor] = Nonehidden_states: tuple[torch.FloatTensor] | None = Noneattentions: tuple[torch.FloatTensor] | None = Nonecross_attentions: tuple[torch.FloatTensor] | None = None )
Parâmetros
- logits (
torch.FloatTensorde forma(batch_size, num_labels)) — Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax). - 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 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) 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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(um para cada camada) com formato(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.
- cross_attentions (
tuple[torch.FloatTensor], opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(um 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.
Classe base para as saídas do modelo base Perceiver, com estados ocultos, atenções e atenções cruzadas potenciais.
classe transformers.models.perceiver.modeling_perceiver.PerceiverDecoderOutput
< source >( logits: typing.Optional[torch.FloatTensor] = Nonecross_attentions: tuple[torch.FloatTensor] | None = None )
Parâmetros
- logits (
torch.FloatTensorde forma(batch_size, num_labels)) — Saída do decodificador básico. - cross_attentions (
tuple[torch.FloatTensor], opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(um 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.
Classe base para as saídas do decodificador Perceiver, com possíveis cross-attentions.
classe transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput
< source >( loss: typing.Optional[torch.FloatTensor] = Nonelogits: typing.Optional[torch.FloatTensor] = Nonehidden_states: tuple[torch.FloatTensor] | None = Noneattentions: tuple[torch.FloatTensor] | None = Nonecross_attentions: tuple[torch.FloatTensor] | None = None )
Parâmetros
- loss (
torch.FloatTensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de modelagem de linguagem mascarada (MLM). - 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). - 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) 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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(um para cada camada) com formato(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.
- cross_attentions (
tuple[torch.FloatTensor], opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(um 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.
Classe base para as saídas do modelo de linguagem mascarado do Perceiver.
classe transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput
< source >( loss: typing.Optional[torch.FloatTensor] = Nonelogits: typing.Optional[torch.FloatTensor] = Nonehidden_states: tuple[torch.FloatTensor] | None = Noneattentions: tuple[torch.FloatTensor] | None = Nonecross_attentions: tuple[torch.FloatTensor] | None = None )
Parâmetros
- loss (
torch.FloatTensorde forma(1,), opcional, retornado quandolabelsé 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). - 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) 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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(um para cada camada) com formato(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.
- cross_attentions (
tuple[torch.FloatTensor], opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(um 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.
Classe base para as saídas do Perceiver em modelos de classificação de sequência/imagem, fluxo óptico e auto-encodimento multimodal.
PerceiverConfig
classe transformers.PerceiverConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonenum_latents: int = 256d_latents: int = 1280d_model: int = 768num_blocks: int = 1num_self_attends_per_block: int = 26num_self_attention_heads: int = 8num_cross_attention_heads: int = 8qk_channels: int | None = Nonev_channels: int | None = Nonecross_attention_shape_for_attention: str = 'kv'self_attention_widening_factor: int = 1cross_attention_widening_factor: int = 1hidden_act: str = 'gelu'attention_probs_dropout_prob: float | int = 0.1initializer_range: float = 0.02layer_norm_eps: float = 1e-12use_query_residual: bool = Truevocab_size: int = 262max_position_embeddings: int = 2048image_size: int | list[int] | tuple[int, int] = 56train_size: list[int] | tuple[int, ...] = (368, 496)num_frames: int = 16audio_samples_per_frame: int = 1920samples_per_patch: int = 16output_shape: list[int] | tuple[int, ...] = (1, 16, 224, 224)output_num_channels: int = 512_label_trainable_num_channels: int = 1024 )
Parâmetros
- num_latents (
int, opcional, padrão 256) — O número de latentes. - d_latents (
int, opcional, padrão 1280) — Dimensão dos embeddings latentes. - d_model (
int, opcional, padrão768) — Tamanho das camadas do codificador e da camada pooler. - num_blocks (
int, opcional, padrão 1) — Número de blocos no codificador do Transformer. - num_self_attends_per_block (
int, opcional, padrão 26) — O número de camadas de autoatenção por bloco. - num_self_attention_heads (
int, opcional, padrão 8) — Número de cabeças de atenção para cada camada de autoatenção no codificador do Transformer. - num_cross_attention_heads (
int, opcional, padrão 8) — Número de cabeças de atenção para cada camada de cross-attention no codificador do Transformer. - qk_channels (
int, opcional) — Dimensão para projetar as queries + keys antes de aplicar a atenção nas camadas de cross-attention e self-attention do encoder. Se não for especificada, o padrão será preservar a dimensão das queries. - v_channels (
int, opcional) — Dimensão para projetar os valores antes de aplicar a atenção nas camadas de atenção cruzada e autoatenção do codificador. Se não for especificada, o padrão será preservar a dimensão das consultas. - cross_attention_shape_for_attention (
str, opcional, padrão"kv") — Dimensão a ser usada ao reduzir a amostragem das queries e keys na camada de cross-attention do encoder. - self_attention_widening_factor (
int, opcional, padrão 1) — Dimensão da camada feed-forward na camada de cross-attention do codificador do Transformer. - cross_attention_widening_factor (
int, opcional, padrão 1) — Dimensão da camada feed-forward nas camadas de autoatenção do codificador Transformer. - hidden_act (
str, opcional, padrãogelu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo,"gelu","relu","silu", etc. - attention_probs_dropout_prob (
Union[float, int], opcional, padrão0.1) — A taxa de dropout para as probabilidades de atenção. - initializer_range (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - layer_norm_eps (
float, opcional, padrão1e-12) — O epsilon usado pelas camadas de normalização de camada. - use_query_residual (
float, opcional, padrãoTrue) — Indica se deve ser adicionado um residual de query na camada de atenção cruzada do encoder. - vocab_size (
int, opcional, padrão262) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelosinput_ids. - max_position_embeddings (
int, opcional, padrão2048) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado. - image_size (
int, opcional, padrão 56) — Tamanho das imagens após o pré-processamento, para PerceiverForImageClassificationLearned. - train_size (
list[int], opcional, padrão[368, 496]) — Tamanho de treinamento das imagens para o modelo de fluxo óptico. - num_frames (
int, opcional, padrão 16) — Número de quadros de vídeo usados para o modelo de auto-encodagem multimodal. - audio_samples_per_frame (
int, opcional, padrão 1920) — Número de amostras de áudio por quadro para o modelo de auto-encodagem multimodal. - samples_per_patch (
int, opcional, padrão 16) — Número de amostras de áudio por patch ao pré-processar o áudio para o modelo de auto-encoding multimodal. - output_shape (
list[int], opcional, padrão[1, 16, 224, 224]) — Formato da saída (batch_size, num_frames, height, width) para as consultas do decodificador de vídeo do modelo de auto-encoding multimodal. Isso exclui a dimensão de canal. - output_num_channels (
int, opcional, padrão 512) — Número de canais de saída para cada decodificador de modalidade.
Esta é a classe de configuração para armazenar a configuração de um PerceiverModel. Ela é usada para instanciar um modelo Perceiver 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 deepmind/language-perceiver
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.
Exemplo:
>>> from transformers import PerceiverModel, PerceiverConfig
>>> # Initializing a Perceiver deepmind/language-perceiver style configuration
>>> configuration = PerceiverConfig()
>>> # Initializing a model from the deepmind/language-perceiver style configuration
>>> model = PerceiverModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configPerceiverTokenizer
classe transformers.PerceiverTokenizer
< source >( pad_token = '[PAD]'bos_token = '[BOS]'eos_token = '[EOS]'mask_token = '[MASK]'cls_token = '[CLS]'sep_token = '[SEP]'model_max_length = 2048**kwargs )
Parâmetros
- pad_token (
str, opcional, padrão"[PAD]") — O token usado para preenchimento, por exemplo, ao agrupar sequências de comprimentos diferentes. - bos_token (
str, opcional, padrão"[BOS]") — O token BOS (reservado no vocabulário, mas não utilizado na prática). - eos_token (
str, opcional, padrão é"[EOS]") — O token de fim de sequência (reservado no vocabulário, mas não usado de fato). 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.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. - mask_token (
str, opcional, padrão"[MASK]") — O token MASK, útil para modelagem de linguagem mascarada. - cls_token (
str, opcional, padrão"[CLS]") — O token CLS (reservado no vocabulário, mas não utilizado de fato). - sep_token (
str, opcional, padrão"[SEP]") — O token separador, usado ao construir uma sequência a partir de duas sequências.
Construa um tokenizador Perceiver. O Perceiver simplesmente usa a codificação utf-8 de bytes brutos.
Este tokenizer herda de PreTrainedTokenizer, que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses métodos.
__call__
< source >( text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Noneadd_special_tokens: bool = Truepadding: bool | str | PaddingStrategy = Falsetruncation: bool | str | TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0is_split_into_words: bool = Falsepad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_offsets_mapping: bool = Falsereturn_length: bool = Falseverbose: bool = Truetokenizer_kwargs: dict[str, Any] | None = None**kwargs ) → BatchEncoding
Parâmetros
- text (
str,list[str],list[list[str]], opcional) — A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pré-tokenizada). Se as sequências forem fornecidas como lista de strings (pré-tokenizadas), você deve definiris_split_into_words=True(para eliminar a ambiguidade com um lote de sequências). - text_pair (
str,list[str],list[list[str]], opcional) — A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pré-tokenizada). Se as sequências forem fornecidas como lista de strings (pré-tokenizadas), você deve definiris_split_into_words=True(para eliminar a ambiguidade com um lote de sequências). - text_target (
str,list[str],list[list[str]], opcional) — A sequência ou lote de sequências a serem codificadas como textos de destino. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se as sequências forem fornecidas como lista de strings (pretokenizadas), você deve definiris_split_into_words=True(para eliminar a ambiguidade com um lote de sequências). - text_pair_target (
str,list[str],list[list[str]], opcional) — A sequência ou lote de sequências a ser codificada como textos de destino. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se as sequências forem fornecidas como lista de strings (pretokenizadas), você deve definiris_split_into_words=True(para eliminar a ambiguidade com um lote de sequências). - tokenizer_kwargs (
dict[str, Any], opcional) — Kwargs adicionais para passar ao tokenizer. Eles serão mesclados com os parâmetros explícitos e outros kwargs, com os parâmetros explícitos tendo precedência. - add_special_tokens (
bool, opcional, padrãoTrue) — Indica se tokens especiais devem ser adicionados ao codificar as sequências. Isso utiliza a função subjacentePretrainedTokenizerBase.build_inputs_with_special_tokens, que define quais tokens são adicionados automaticamente aos ids de entrada. Isso é útil se você deseja adicionar tokensbosoueosautomaticamente. - padding (
bool,strou PaddingStrategy, opcional, padrão éFalse) — Ativa e controla o padding. Aceita os seguintes valores:Trueou'longest': Preenche até a sequência mais longa do lote (ou não aplica preenchimento se apenas uma sequência for fornecida).'max_length': Preenche até o comprimento máximo especificado com o argumentomax_lengthou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.Falseou'do_not_pad'(padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).
- truncation (
bool,strou TruncationStrategy, opcional, padrão éFalse) — Ativa e controla a truncagem. Aceita os seguintes valores:Trueou'longest_first': Trunca para um comprimento máximo especificado com o argumentomax_lengthou para o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. Isso trunca token por token, removendo um token da sequência mais longa do par, se um par de sequências (ou um lote de pares) for fornecido.'only_first': Trunca para o comprimento máximo especificado com o argumentomax_lengthou para o comprimento máximo aceitável de entrada do modelo, caso esse argumento não seja fornecido. Isso trunca apenas a primeira sequência de um par, se um par de sequências (ou um lote de pares) for fornecido.'only_second': Trunca para um comprimento máximo especificado com o argumentomax_lengthou para o comprimento máximo aceitável de entrada do modelo, caso esse argumento não seja fornecido. Isso trunca apenas a segunda sequência de um par, se um par de sequências (ou um lote de pares) for fornecido.Falseou'do_not_truncate'(padrão): Sem truncamento (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada aceitável pelo modelo).
- max_length (
int, opcional) — Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento.Se não for definido ou for definido como
None, isso usará o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento para um comprimento máximo será desativado. - stride (
int, opcional, padrão 0) — Se definido como um número junto commax_length, os tokens excedentes retornados quandoreturn_overflowing_tokens=Trueconterão alguns tokens do final da sequência truncada retornada para fornecer alguma sobreposição entre as sequências truncadas e excedentes. O valor deste argumento define o número de tokens sobrepostos. - is_split_into_words (
bool, opcional, padrãoFalse) — Indica se a entrada já está pré-tokenizada (por exemplo, dividida em palavras). Se definido comoTrue, o tokenizer assume que a entrada já foi dividida em palavras (por exemplo, separando por espaços em branco) e a tokeniza. Isso é útil para NER ou classificação de tokens. - pad_to_multiple_of (
int, opcional) — Se definido, a sequência será preenchida até um múltiplo do valor fornecido. Exige quepaddingesteja ativado. Isso é especialmente útil para habilitar o uso de Tensor Cores em hardware NVIDIA com capacidade de computação>= 7.5(Volta). - padding_side (
str, opcional) — O lado em que o modelo deve ter o padding aplicado. Deve ser selecionado entre [‘right’, ‘left’]. O valor padrão é obtido do atributo de classe com o mesmo nome. - return_tensors (
strou TensorType, opcional) — Se definido, retornará tensors em vez de uma lista de inteiros do Python. Os valores aceitos são:'pt': Retorna objetostorch.Tensordo PyTorch.'np': Retorna objetosnp.ndarraydo Numpy.
- return_token_type_ids (
bool, opcional) — Se deve retornar os IDs de tipo de token. Se mantido o valor padrão, retornará os IDs de tipo de token de acordo com o padrão do tokenizer específico, definido peloreturn_outputsatributo. - return_attention_mask (
bool, opcional) — Se deve retornar a attention mask. Se mantido o valor padrão, a attention mask será retornada de acordo com o padrão do tokenizer específico, definido pelo atributoreturn_outputs. - return_overflowing_tokens (
bool, opcional, padrãoFalse) — Indica se as sequências de tokens excedentes devem ser retornadas. Se um par de sequências de ids de entrada (ou um lote de pares) for fornecido comtruncation_strategy = longest_firstouTrue, um erro será lançado em vez de retornar os tokens excedentes. - return_special_tokens_mask (
bool, opcional, padrãoFalse) — Indica se a máscara de tokens especiais deve ser retornada. - return_offsets_mapping (
bool, opcional, padrão éFalse) — Se deve ou não retornar(char_start, char_end)para cada token.Isso está disponível apenas em tokenizadores rápidos que herdam de PreTrainedTokenizerFast; se estiver usando o tokenizador em Python, este método lançará
NotImplementedError. - return_length (
bool, opcional, padrãoFalse) — Indica se as comprimentos das entradas codificadas devem ser retornados. - verbose (
bool, opcional, padrãoTrue) — Se deve ou não exibir mais informações e avisos. - **kwargs — passados para o método
self.tokenize()
Retorna
Um BatchEncoding com os seguintes campos:
-
input_ids — Lista de ids de tokens a serem fornecidos a um modelo.
-
token_type_ids — Lista de ids de tipo de token a serem fornecidos a um modelo (quando
return_token_type_ids=Trueou se “token_type_ids” estiver emself.model_input_names). -
attention_mask — Lista de índices que especifica quais tokens devem ser considerados pelo modelo (quando
return_attention_mask=Trueou se “attention_mask” estiver emself.model_input_names). -
overflowing_tokens — Lista de sequências de tokens excedentes (quando um
max_lengthé especificado ereturn_overflowing_tokens=True). -
num_truncated_tokens — Número de tokens truncados (quando um
max_lengthé especificado ereturn_overflowing_tokens=True). -
special_tokens_mask — Lista de 0s e 1s, em que 1 especifica tokens especiais adicionados e 0 especifica tokens regulares da sequência (quando
add_special_tokens=Trueereturn_special_tokens_mask=True). -
length — O comprimento das entradas (quando
return_length=True)
Método principal para tokenizar e preparar uma ou várias sequências ou um ou vários pares de sequências para o modelo.
PerceiverImageProcessor
classe transformers.PerceiverImageProcessor
< source >( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
Parâmetros
- do_convert_rgb (
bool, kwargs, opcional) — Se a imagem deve ser convertida para RGB. - do_resize (
bool, kwargs, opcional, padrãoTrue) — Se deve redimensionar a imagem. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, padrão{'height' -- 224, 'width': 224}): Descreve as dimensões máximas de entrada para o modelo. - default_to_square (
bool, kwargs, opcional, padrãoTrue) — Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, padrão{'height' -- 256, 'width': 256}): Tamanho da imagem de saída após aplicarcenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, padrão3) — Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeraçãoPILImageResampling. Tem efeito apenas sedo_resizeestiver definido comoTrue. - do_rescale (
bool, kwargs, opcional, padrãoTrue) — Se deve reescalar a imagem. - rescale_factor (
float, kwargs, opcional, padrão0.00392156862745098) — Fator de reescala para reescalar a imagem, casodo_rescaleesteja definido comoTrue. - do_normalize (
bool, kwargs, opcional, padrãoTrue) — Se a imagem deve ser normalizada. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão[0.485, 0.456, 0.406]) — Média da imagem a ser usada para normalização. Tem efeito apenas sedo_normalizeestiver definido comoTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão[0.229, 0.224, 0.225]) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas sedo_normalizeestiver definido comoTrue. - do_pad (
bool, kwargs, opcional) — Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — O tamanho em{"height": int, "width" int}para o preenchimento das imagens. Deve ser maior que qualquer tamanho de imagem fornecido para o pré-processamento. Sepad_sizenão for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quandodo_pad=True. - do_center_crop (
bool, kwargs, opcional, padrãoTrue) — Se deve recortar a imagem pelo centro. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — ApenasChannelDimension.FIRSTé suportado. Adicionado para compatibilidade com processadores lentos. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:"channels_first"ouChannelDimension.FIRST: imagem no formato (num_channels, height, width)."channels_last"ouChannelDimension.LAST: imagem no formato (altura, largura, num_canais)."none"ouChannelDimension.NONE: imagem no formato (altura, largura).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retorna tensores empilhados se definido como'pt'; caso contrário, retorna uma lista de tensores. - disable_grouping (
bool, kwargs, opcional) — Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, opcional) — O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.
Constrói um processador de imagem PerceiverImageProcessor.
pré-processamento
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]*argsimage_like_kwargs: dict[str, typing.Any] | None = None**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> ) → ~image_processing_base.BatchFeature
Parâmetros
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se passar imagens com valores de pixel entre 0 e 1, definado_rescale=False. - image_like_kwargs (
dict[str, Any], opcional) — Flag para desenvolvedores destinada a entradas adicionais semelhantes a imagens que também serão pré-processadas. Use apenas se passar as entradas como kwarg não funcionar. Por exemplo,preprocess(images, masks=masks)é a opção preferida, mas resulta em problemas de prioridade de argumentos para alguns modelos. Nesses casos,preprocess(images, image_like_inputs={"masks": masks})pode ser usado em vez disso. - do_convert_rgb (
bool, kwargs, opcional) — Se a imagem deve ser convertida para RGB. - do_resize (
bool, kwargs, opcional) — Se deve redimensionar a imagem. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Descreve as dimensões máximas de entrada para o modelo. - default_to_square (
bool, kwargs, opcional) — Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Tamanho da imagem de saída após a aplicação decenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeraçãoPILImageResampling. Tem efeito apenas sedo_resizeestiver definido comoTrue. - do_rescale (
bool, kwargs, opcional) — Se deve reescalar a imagem. - rescale_factor (
float, kwargs, opcional) — Fator de redimensionamento para redimensionar a imagem, casodo_rescaleesteja definido comoTrue. - do_normalize (
bool, kwargs, opcional) — Se a imagem deve ser normalizada. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Média da imagem a ser usada para normalização. Tem efeito apenas sedo_normalizeestiver definido comoTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas sedo_normalizeestiver definido comoTrue. - do_pad (
bool, kwargs, opcional) — Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — O tamanho em{"height": int, "width" int}para o preenchimento das imagens. Deve ser maior que qualquer tamanho de imagem fornecido para o pré-processamento. Sepad_sizenão for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quandodo_pad=True. - do_center_crop (
bool, kwargs, opcional) — Se deve recortar a imagem centralmente. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — ApenasChannelDimension.FIRSTé suportado. Adicionado para compatibilidade com processadores lentos. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:"channels_first"ouChannelDimension.FIRST: imagem no formato (num_channels, height, width)."channels_last"ouChannelDimension.LAST: imagem no formato (altura, largura, num_canais)."none"ouChannelDimension.NONE: imagem no formato (altura, largura).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retorna tensores empilhados se definido como'pt'; caso contrário, retorna uma lista de tensores. - disable_grouping (
bool, kwargs, opcional) — Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, opcional) — O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.
Retorna
~image_processing_base.BatchFeature
- data (
dict) — Dicionário de listas/arrays/tensors retornados pelo método call (‘pixel_values’, etc.). - tensor_type (
Union[None, str, TensorType], opcional) — Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização.
Pré-processa uma imagem ou um lote de imagens.
PerceiverImageProcessorPil
classe transformers.PerceiverImageProcessorPil
< source >( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
Parâmetros
- do_convert_rgb (
bool, kwargs, opcional) — Se a imagem deve ser convertida para RGB. - do_resize (
bool, kwargs, opcional, padrãoTrue) — Se deve redimensionar a imagem. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, padrão{'height' -- 224, 'width': 224}): Descreve as dimensões máximas de entrada para o modelo. - default_to_square (
bool, kwargs, opcional, padrãoTrue) — Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, padrão{'height' -- 256, 'width': 256}): Tamanho da imagem de saída após aplicarcenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, padrão3) — Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeraçãoPILImageResampling. Tem efeito apenas sedo_resizeestiver definido comoTrue. - do_rescale (
bool, kwargs, opcional, padrãoTrue) — Se deve reescalar a imagem. - rescale_factor (
float, kwargs, opcional, padrão0.00392156862745098) — Fator de reescala para reescalar a imagem, casodo_rescaleesteja definido comoTrue. - do_normalize (
bool, kwargs, opcional, padrãoTrue) — Se a imagem deve ser normalizada. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão[0.485, 0.456, 0.406]) — Média da imagem a ser usada para normalização. Tem efeito apenas sedo_normalizeestiver definido comoTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão[0.229, 0.224, 0.225]) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas sedo_normalizeestiver definido comoTrue. - do_pad (
bool, kwargs, opcional) — Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — O tamanho em{"height": int, "width" int}para o preenchimento das imagens. Deve ser maior que qualquer tamanho de imagem fornecido para o pré-processamento. Sepad_sizenão for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quandodo_pad=True. - do_center_crop (
bool, kwargs, opcional, padrãoTrue) — Se deve recortar a imagem pelo centro. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — ApenasChannelDimension.FIRSTé suportado. Adicionado para compatibilidade com processadores lentos. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:"channels_first"ouChannelDimension.FIRST: imagem no formato (num_channels, height, width)."channels_last"ouChannelDimension.LAST: imagem no formato (altura, largura, num_canais)."none"ouChannelDimension.NONE: imagem no formato (altura, largura).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retorna tensores empilhados se definido como'pt'; caso contrário, retorna uma lista de tensores. - disable_grouping (
bool, kwargs, opcional) — Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, opcional) — O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.
Constrói um processador de imagem PerceiverImageProcessor.
pré-processamento
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]*argsimage_like_kwargs: dict[str, typing.Any] | None = None**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> ) → ~image_processing_base.BatchFeature
Parâmetros
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se passar imagens com valores de pixel entre 0 e 1, definado_rescale=False. - image_like_kwargs (
dict[str, Any], opcional) — Flag para desenvolvedores destinada a entradas adicionais semelhantes a imagens que também serão pré-processadas. Use apenas se passar as entradas como kwarg não funcionar. Por exemplo,preprocess(images, masks=masks)é a opção preferida, mas resulta em problemas de prioridade de argumentos para alguns modelos. Nesses casos,preprocess(images, image_like_inputs={"masks": masks})pode ser usado em vez disso. - do_convert_rgb (
bool, kwargs, opcional) — Se a imagem deve ser convertida para RGB. - do_resize (
bool, kwargs, opcional) — Se deve redimensionar a imagem. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Descreve as dimensões máximas de entrada para o modelo. - default_to_square (
bool, kwargs, opcional) — Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Tamanho da imagem de saída após a aplicação decenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeraçãoPILImageResampling. Tem efeito apenas sedo_resizeestiver definido comoTrue. - do_rescale (
bool, kwargs, opcional) — Se deve reescalar a imagem. - rescale_factor (
float, kwargs, opcional) — Fator de redimensionamento para redimensionar a imagem, casodo_rescaleesteja definido comoTrue. - do_normalize (
bool, kwargs, opcional) — Se a imagem deve ser normalizada. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Média da imagem a ser usada para normalização. Tem efeito apenas sedo_normalizeestiver definido comoTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas sedo_normalizeestiver definido comoTrue. - do_pad (
bool, kwargs, opcional) — Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — O tamanho em{"height": int, "width" int}para o preenchimento das imagens. Deve ser maior que qualquer tamanho de imagem fornecido para o pré-processamento. Sepad_sizenão for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quandodo_pad=True. - do_center_crop (
bool, kwargs, opcional) — Se deve recortar a imagem centralmente. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — ApenasChannelDimension.FIRSTé suportado. Adicionado para compatibilidade com processadores lentos. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:"channels_first"ouChannelDimension.FIRST: imagem no formato (num_channels, height, width)."channels_last"ouChannelDimension.LAST: imagem no formato (altura, largura, num_canais)."none"ouChannelDimension.NONE: imagem no formato (altura, largura).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retorna tensores empilhados se definido como'pt'; caso contrário, retorna uma lista de tensores. - disable_grouping (
bool, kwargs, opcional) — Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, opcional) — O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.
Retorna
~image_processing_base.BatchFeature
- data (
dict) — Dicionário de listas/arrays/tensors retornados pelo método call (‘pixel_values’, etc.). - tensor_type (
Union[None, str, TensorType], opcional) — Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização.
Pré-processa uma imagem ou um lote de imagens.
PerceiverTextPreprocessor
classe transformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessor
< source >( config: PerceiverConfig )
Parâmetros
- config (PerceiverConfig) — Configuração do modelo.
Pré-processamento de texto para o Perceiver Encoder. Pode ser usado para incorporar inputs e adicionar codificações posicionais.
A dimensionalidade dos embeddings é determinada pelo atributo d_model da configuração.
PerceiverImagePreprocessor
classe transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor
< source >( configprep_type = 'conv'spatial_downsample: int = 4temporal_downsample: int = 1position_encoding_type: str = 'fourier'in_channels: int = 3out_channels: int = 64conv_after_patching: bool = Falseconv_after_patching_in_channels: int = 54conv2d_use_batchnorm: bool = Trueconcat_or_add_pos: str = 'concat'project_pos_dim: int = -1**position_encoding_kwargs )
Parâmetros
- config ([PerceiverConfig]) — Configuração do modelo.
- prep_type (
str, opcional, padrão"conv") — Tipo de pré-processamento. Pode ser “conv1x1”, “conv”, “patches”, “pixels”. - spatial_downsample (
int, opcional, padrão 4) — Fator de redução espacial. - temporal_downsample (
int, opcional, padrão 1) — Fator de subamostragem temporal (relevante apenas quando há uma dimensão de tempo). - position_encoding_type (
str, opcional, padrão"fourier") — Tipo de codificação de posição. Pode ser “fourier” ou “trainable”. - in_channels (
int, opcional, padrão 3) — Número de canais na entrada. - out_channels (
int, opcional, padrão 64) — Número de canais na saída. - conv_after_patching (
bool, opcional, padrãoFalse) — Indica se uma camada convolucional deve ser aplicada após o patching. - conv_after_patching_in_channels (
int, opcional, padrão 54) — Número de canais na entrada da camada convolucional após o patching. - conv2d_use_batchnorm (
bool, opcional, padrãoTrue) — Se deve usar normalização de lote na camada convolucional. - concat_or_add_pos (
str, opcional, padrão"concat") — Como concatenar a codificação de posição à entrada. Pode ser “concat” ou “add”. - project_pos_dim (
int, opcional, padrão -1) — Dimensão da codificação de posição para a qual a projeção será aplicada. Se for -1, nenhuma projeção é aplicada. - **position_encoding_kwargs (
Dict, opcional) — Argumentos de palavra-chave para a codificação de posição.
Pré-processamento de imagem para o Perceiver Encoder.
Nota: o argumento out_channels se refere aos canais de saída de uma camada convolucional, caso prep_type esteja definido como “conv1x1” ou “conv”. Se forem adicionados embeddings de posição absoluta, é necessário garantir que o num_channels dos kwargs de codificação de posição esteja igual ao out_channels.
PerceiverOneHotPreprocessor
classe transformers.models.perceiver.modeling_perceiver.PerceiverOneHotPreprocessor
< source >( config: PerceiverConfig )
Parâmetros
- config (PerceiverConfig) — Configuração do modelo.
Pré-processador one-hot para o Perceiver Encoder. Pode ser usado para adicionar uma dimensão de índice fictícia à entrada.
PerceiverAudioPreprocessor
classe transformers.models.perceiver.modeling_perceiver.PerceiverAudioPreprocessor
< source >( configprep_type: str = 'patches'samples_per_patch: int = 96position_encoding_type: str = 'fourier'concat_or_add_pos: str = 'concat'out_channels = 64project_pos_dim = -1**position_encoding_kwargs )
Parâmetros
- config ([PerceiverConfig]) — Configuração do modelo.
- prep_type (
str, opcional, padrão"patches") — Tipo de pré-processador a ser usado. Apenas “patches” é suportado. - samples_per_patch (
int, opcional, padrão 96) — Número de amostras por patch. - position_encoding_type (
str, opcional, padrão"fourier") — Tipo de codificação de posição a ser usado. Pode ser “trainable” ou “fourier”. - concat_or_add_pos (
str, opcional, padrão"concat") — Como concatenar a codificação de posição à entrada. Pode ser “concat” ou “add”. - out_channels (
int, opcional, padrão 64) — Número de canais na saída. - project_pos_dim (
int, opcional, padrão -1) — Dimensão da codificação de posição para a qual a projeção será aplicada. Se for -1, nenhuma projeção é aplicada. - **position_encoding_kwargs (
Dict, opcional) — Argumentos de palavra-chave para a codificação de posição.
Pré-processamento de áudio para o Perceiver Encoder.
PerceiverMultimodalPreprocessor
classe transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor
< source >( modalities: Mappingmask_probs: collections.abc.Mapping[str, float] | None = Nonemin_padding_size: int = 2 )
Parâmetros
- modalities (
Mapping[str, PreprocessorType]) — Dicionário que mapeia o nome da modalidade para o pré-processador. - mask_probs (
dict[str, float]) — Dicionário que mapeia o nome da modalidade para a probabilidade de mascaramento dessa modalidade. - min_padding_size (
int, opcional, padrão 2) — O tamanho mínimo de padding para todas as modalidades. A saída final terá num_channels igual ao máximo de canais entre todas as modalidades mais min_padding_size.
Pré-processamento multimodal para Perceiver Encoder.
As entradas de cada modalidade são pré-processadas e, em seguida, preenchidas com embeddings de posição treináveis para que tenham o mesmo número de canais.
PerceiverProjectionDecoder
classe transformers.models.perceiver.modeling_perceiver.PerceiverProjectionDecoder
< source >( config )
Parâmetros
- config (PerceiverConfig) — Configuração do modelo.
Decodificador de projeção de linha de base (sem atenção cruzada).
PerceiverBasicDecoder
classe transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecoder
< source >( config: PerceiverConfigoutput_num_channels: intposition_encoding_type: str | None = 'trainable'output_index_dims: int | None = Nonenum_channels: int | None = 128subsampled_index_dims: int | None = Noneqk_channels: int | None = Nonev_channels: int | None = Nonenum_heads: int | None = 1widening_factor: int | None = 1use_query_residual: bool | None = Falseconcat_preprocessed_input: bool | None = Falsefinal_project: bool | None = Trueposition_encoding_only: bool | None = False**position_encoding_kwargs )
Parâmetros
- config ([PerceiverConfig]) — Configuração do modelo.
- output_num_channels (
int, opcional) — O número de canais na saída. Será usado apenas se final_project estiver definido comoTrue. - position_encoding_type (
str, opcional, padrão “trainable”) — O tipo de codificação de posição a ser utilizado. Pode ser “trainable”, “fourier” ou “none”. - output_index_dims (
int, opcional) — O número de dimensões das queries de saída. Ignorado se ‘position_encoding_type’ == ‘none’. - num_channels (
int, opcional, padrão 128) — O número de canais das consultas do decodificador. Ignorado se ‘position_encoding_type’ == ‘none’. - qk_channels (
int, opcional) — O número de canais das queries e keys na camada de cross-attention. - v_channels (
int, opcional) — O número de canais dos valores na camada de atenção cruzada. - num_heads (
int, opcional, padrão 1) — O número de cabeças de atenção na camada de atenção cruzada. - widening_factor (
int, opcional, padrão 1) — O fator de alargamento da camada de atenção cruzada. - use_query_residual (
bool, opcional, padrãoFalse) — Se deve usar uma conexão residual entre a query e a saída da camada de atenção cruzada. - concat_preprocessed_input (
bool, opcional, padrãoFalse) — Indica se a entrada pré-processada deve ser concatenada à consulta. - final_project (
bool, opcional, padrãoTrue) — Se deve projetar a saída da camada de cross-attention para uma dimensão de destino. - position_encoding_only (
bool, opcional, padrãoFalse) — Se deve usar esta classe apenas para definir as queries de saída.
Decoder baseado em cross-attention. Esta classe pode ser usada para decodificar os estados ocultos finais dos latentes usando uma operação de cross-attention, na qual os latentes produzem as chaves e os valores.
A forma da saída desta classe depende de como se definem as consultas de saída (também chamadas de consultas do decodificador).
PerceiverClassificationDecoder
classe transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder
< source >( config**decoder_kwargs )
Parâmetros
- config (PerceiverConfig) — Configuração do modelo.
Decodificador de classificação baseado em cross-attention. Wrapper leve de PerceiverBasicDecoder para saída de logits.
Converte a saída do codificador Perceiver, que tem a forma (batch_size, num_latents, d_latents), em um tensor de
forma (batch_size, num_labels). As queries têm a forma (batch_size, 1, num_labels).
PerceiverOpticalFlowDecoder
classe transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder
< source >( configoutput_image_shapeoutput_num_channels = 2rescale_factor = 100.0**decoder_kwargs )
Decodificador de fluxo óptico baseado em atenção cruzada.
PerceiverBasicVideoAutoencodingDecoder
classe transformers.models.perceiver.modeling_perceiver.PerceiverBasicVideoAutoencodingDecoder
< source >( config: PerceiverConfigoutput_shape: listposition_encoding_type: str**decoder_kwargs )
Parâmetros
Decoder de auto-encoding de vídeo baseado em cross-attention. Wrapper leve de [PerceiverBasicDecoder] com lógica de redimensionamento de vídeo.
PerceiverMultimodalDecoder
classe transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder
< source >( config: PerceiverConfigmodalities: dictnum_outputs: intoutput_num_channels: intmin_padding_size: int | None = 2subsampled_index_dims: dict[str, transformers.models.perceiver.modeling_perceiver.PerceiverAbstractDecoder] | None = None**decoder_kwargs )
Parâmetros
- config ([PerceiverConfig]) — Configuração do modelo.
- modalities (
dict[str, PerceiverAbstractDecoder]) — Dicionário que mapeia o nome da modalidade para o decodificador dessa modalidade. - num_outputs (
int) — O número de saídas do decodificador. - output_num_channels (
int) — O número de canais na saída. - min_padding_size (
int, opcional, padrão 2) — O tamanho mínimo de padding para todas as modalidades. A saída final terá num_channels igual ao máximo de canais entre todas as modalidades mais min_padding_size. - subsampled_index_dims (
dict[str, PerceiverAbstractDecoder], opcional) — Dicionário que mapeia o nome da modalidade para as dimensões de índice subsampleadas a serem usadas na consulta do decodificador daquela modalidade.
Decodificação multimodal por composição de decodificadores unimodais. O argumento modalities do construtor é um dicionário que mapeia o nome da modalidade para o decodificador dessa modalidade. Esse decodificador será usado para construir as consultas para essa modalidade. As consultas específicas de cada modalidade são preenchidas com parâmetros treináveis específicos da modalidade, após os quais são concatenadas ao longo da dimensão do tempo.
Em seguida, há uma operação de atenção cruzada compartilhada entre todas as modalidades.
PerceiverProjectionPostprocessor
classe transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor
< source >( in_channels: intout_channels: int )
Pós-processamento de projeção para Perceiver. Pode ser usado para projetar os canais da saída do decodificador para uma dimensão menor.
PerceiverAudioPostprocessor
classe transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor
< source >( config: PerceiverConfigin_channels: intpostproc_type: str = 'patches' )
Pós-processamento de áudio para Perceiver. Pode ser usado para converter a saída do decodificador em características de áudio.
PerceiverClassificationPostprocessor
classe transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor
< source >( config: PerceiverConfigin_channels: int )
Pós-processamento de classificação para Perceiver. Pode ser usado para converter a saída do decodificador em logits de classificação.
PerceiverMultimodalPostprocessor
classe transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor
< source >( modalities: Mappinginput_is_dict: bool = False )
Parâmetros
- modalities (
Mapping[str, PostprocessorType]) — Dicionário que mapeia o nome da modalidade para a classe de pós-processador correspondente a essa modalidade. - input_is_dict (
bool, opcional, padrãoFalse) — Se True, assume-se que a entrada tem estrutura de dicionário e as saídas mantêm a mesma forma de dicionário. Se False, a entrada é um tensor que é fatiado durante o pós-processamento por modality_sizes.
Pós-processamento multimodal para Perceiver. Pode ser usado para combinar pós-processadores específicos de modalidade em um único pós-processador.
PerceiverModel
classe transformers.PerceiverModel
< source >( config: PerceiverConfigdecoder: typing.Optional[ForwardRef('PerceiverAbstractDecoder')] = Noneinput_preprocessor: Callable = Noneoutput_postprocessor: Callable = None )
Parâmetros
- config (PerceiverConfig) — 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.
- decoder (
PerceiverDecoder, opcional) — Módulo decodificador que transforma representações latentes em previsões da tarefa. - input_preprocessor (
PreprocessorType, opcional) — Pré-processador que codifica entradas brutas em tensores para o modelo. - output_postprocessor (
PostprocessorType, opcional) — Pós-processador que transforma as saídas do modelo em previsões finais.
O Perceiver: uma arquitetura totalmente atencional e escalável.
Observe que é possível fazer o ajuste fino do Perceiver em imagens de resolução mais alta do que aquelas em que ele foi treinado, definindo
interpolate_pos_encodingcomoTrueno forward do modelo. Isso interpolará os embeddings de posição pré-treinados para a resolução mais alta.
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 >( inputs: FloatTensorattention_mask: typing.Optional[torch.FloatTensor] = Nonesubsampled_output_points: dict[str, torch.Tensor] | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Noneinterpolate_pos_encoding: bool = Falsereturn_dict: bool | None = None**kwargs ) → PerceiverModelOutput or tuple(torch.FloatTensor)
Parâmetros
- inputs (
torch.FloatTensor) — Entradas para o perceiver. Pode ser qualquer coisa: imagens, texto, áudio, vídeo, etc. - 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.
- subsampled_output_points (
dict[str, torch.Tensor], opcional) — Dicionário de tensores usados como consultas para o decoder. O decoder mapeia essas consultas para a representação latente do modelo. Usado para decodificação subsampleada, por exemplo, quando apenas determinados patches de imagem são decodificados. - output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - interpolate_pos_encoding (
bool, opcional, padrãoFalse) — Se deve interpolar as codificações de posição pré-treinadas. - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.
Retorna
PerceiverModelOutput ou tuple(torch.FloatTensor)
Um PerceiverModelOutput 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 (PerceiverConfig) e das entradas.
O método forward do PerceiverModel 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.
logits (
torch.FloatTensorde forma(batch_size, num_labels)) — Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax).last_hidden_state (
torch.FloatTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Sequência de hidden-states 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(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 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 após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos 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 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.
Exemplos:
>>> from transformers import PerceiverConfig, PerceiverTokenizer, PerceiverImageProcessor, PerceiverModel
>>> from transformers.models.perceiver.modeling_perceiver import (
... PerceiverTextPreprocessor,
... PerceiverImagePreprocessor,
... PerceiverClassificationDecoder,
... )
>>> import torch
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from PIL import Image
>>> # EXAMPLE 1: using the Perceiver to classify texts
>>> # - we define a TextPreprocessor, which can be used to embed tokens
>>> # - we define a ClassificationDecoder, which can be used to decode the
>>> # final hidden states of the latents to classification logits
>>> # using trainable position embeddings
>>> config = PerceiverConfig()
>>> preprocessor = PerceiverTextPreprocessor(config)
>>> decoder = PerceiverClassificationDecoder(
... config,
... num_channels=config.d_latents,
... trainable_position_encoding_kwargs=dict(num_channels=config.d_latents, index_dims=1),
... use_query_residual=True,
... )
>>> model = PerceiverModel(config, input_preprocessor=preprocessor, decoder=decoder)
>>> # you can then do a forward pass as follows:
>>> tokenizer = PerceiverTokenizer()
>>> text = "hello world"
>>> inputs = tokenizer(text, return_tensors="pt").input_ids
>>> with torch.no_grad():
... outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2]
>>> # to train, one can train the model using standard cross-entropy:
>>> criterion = torch.nn.CrossEntropyLoss()
>>> labels = torch.tensor([1])
>>> loss = criterion(logits, labels)
>>> # EXAMPLE 2: using the Perceiver to classify images
>>> # - we define an ImagePreprocessor, which can be used to embed images
>>> config = PerceiverConfig(image_size=224)
>>> preprocessor = PerceiverImagePreprocessor(
... config,
... prep_type="conv1x1",
... spatial_downsample=1,
... out_channels=256,
... position_encoding_type="trainable",
... concat_or_add_pos="concat",
... project_pos_dim=256,
... trainable_position_encoding_kwargs=dict(
... num_channels=256,
... index_dims=config.image_size**2,
... ),
... )
>>> model = PerceiverModel(
... config,
... input_preprocessor=preprocessor,
... decoder=PerceiverClassificationDecoder(
... config,
... num_channels=config.d_latents,
... trainable_position_encoding_kwargs=dict(num_channels=config.d_latents, index_dims=1),
... use_query_residual=True,
... ),
... )
>>> # you can then do a forward pass as follows:
>>> image_processor = PerceiverImageProcessor()
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> inputs = image_processor(image, return_tensors="pt").pixel_values
>>> with torch.no_grad():
... outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2]
>>> # to train, one can train the model using standard cross-entropy:
>>> criterion = torch.nn.CrossEntropyLoss()
>>> labels = torch.tensor([1])
>>> loss = criterion(logits, labels)PerceiverForMaskedLM
classe transformers.PerceiverForMaskedLM
< source >( config: PerceiverConfig )
Parâmetros
- config (PerceiverConfig) — 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.
Exemplo de uso do Perceiver para modelagem de linguagem mascarada.
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 >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = Noneinput_ids: typing.Optional[torch.Tensor] = None**kwargs ) → PerceiverMaskedLMOutput or tuple(torch.FloatTensor)
Parâmetros
- inputs (
torch.Tensor, opcional) — Entradas para o perceiver. Pode ser qualquer coisa: imagens, texto, áudio, vídeo, etc. - 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.
- output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em[-100, 0, ..., config.vocab_size](veja a docstring deinput_ids). Tokens com índices definidos como-100são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em[0, ..., config.vocab_size]. - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples. - input_ids (
torch.Tensorde formato(batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
Retorna
PerceiverMaskedLMOutput ou tuple(torch.FloatTensor)
Um PerceiverMaskedLMOutput 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 (PerceiverConfig) e das entradas.
O método forward de PerceiverForMaskedLM 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 modelagem de linguagem mascarada (MLM).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).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) 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 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 após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos 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 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.
Exemplos:
>>> from transformers import AutoTokenizer, PerceiverForMaskedLM
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("deepmind/language-perceiver")
>>> model = PerceiverForMaskedLM.from_pretrained("deepmind/language-perceiver")
>>> # training
>>> text = "This is an incomplete sentence where some words are missing."
>>> inputs = tokenizer(text, padding="max_length", return_tensors="pt")
>>> # mask " missing."
>>> inputs["input_ids"][0, 52:61] = tokenizer.mask_token_id
>>> labels = tokenizer(text, padding="max_length", return_tensors="pt").input_ids
>>> outputs = model(**inputs, labels=labels)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
19.87
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2048, 262]
>>> # inference
>>> text = "This is an incomplete sentence where some words are missing."
>>> encoding = tokenizer(text, padding="max_length", return_tensors="pt")
>>> # mask bytes corresponding to " missing.". Note that the model performs much better if the masked span starts with a space.
>>> encoding["input_ids"][0, 52:61] = tokenizer.mask_token_id
>>> # forward pass
>>> with torch.no_grad():
... outputs = model(**encoding)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2048, 262]
>>> masked_tokens_predictions = logits[0, 52:61].argmax(dim=-1).tolist()
>>> tokenizer.decode(masked_tokens_predictions)
' missing.'PerceiverForSequenceClassification
classe transformers.PerceiverForSequenceClassification
< source >( config: PerceiverConfig )
Parâmetros
- config (PerceiverConfig) — 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.
Exemplo de uso do Perceiver para classificação de texto.
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 >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = Noneinput_ids: typing.Optional[torch.Tensor] = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.FloatTensor)
Parâmetros
- inputs (
torch.Tensor, opcional) — Entradas para o perceiver. Pode ser qualquer coisa: imagens, texto, áudio, vídeo, etc. - 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.
- output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para o cálculo da perda de classificação/regressão. 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). - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples. - input_ids (
torch.Tensorde formato(batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
Retorna
PerceiverClassifierOutput ou tuple(torch.FloatTensor)
Um PerceiverClassifierOutput 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 (PerceiverConfig) e das entradas.
O método forward de PerceiverForSequenceClassification 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 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).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) 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 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 após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos 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 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.
Exemplos:
>>> from transformers import AutoTokenizer, PerceiverForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("deepmind/language-perceiver")
>>> model = PerceiverForSequenceClassification.from_pretrained("deepmind/language-perceiver")
>>> text = "hello world"
>>> inputs = tokenizer(text, return_tensors="pt").input_ids
>>> outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2]PerceiverForImageClassificationLearned
classe transformers.PerceiverForImageClassificationLearned
< source >( config: PerceiverConfig )
Parâmetros
- config (PerceiverConfig) — 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.
Exemplo de uso do Perceiver para classificação de imagens, em tarefas como ImageNet.
Este modelo usa embeddings de posição aprendidos. Em outras palavras, este modelo não recebe nenhuma informação privilegiada sobre a estrutura das imagens. Conforme mostrado no artigo, este modelo pode alcançar uma precisão top-1 de 72,7 no ImageNet.
PerceiverForImageClassificationLearned usa PerceiverImagePreprocessor (com prep_type="conv1x1") para pré-processar as imagens de entrada e PerceiverClassificationDecoder para decodificar a representação latente de PerceiverModel em logits de classificação.
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 >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Noneinterpolate_pos_encoding: bool = Falsereturn_dict: bool | None = Nonepixel_values: typing.Optional[torch.Tensor] = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.FloatTensor)
Parâmetros
- inputs (
torch.Tensor, opcional) — Entradas para o perceiver. Pode ser qualquer coisa: imagens, texto, áudio, vídeo, etc. - 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.
- output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para o cálculo da perda de classificação/regressão de imagem. 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). - interpolate_pos_encoding (
bool, opcional, padrãoFalse) — Se deve interpolar as codificações de posição pré-treinadas. - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples. - pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando PerceiverImageProcessor. Consulte PerceiverImageProcessor.call() para mais detalhes (processor_classusa PerceiverImageProcessor para processar imagens).
Retorna
PerceiverClassifierOutput ou tuple(torch.FloatTensor)
Um PerceiverClassifierOutput 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 (PerceiverConfig) e das entradas.
O método forward de PerceiverForImageClassificationLearned 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 (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).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) 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 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 após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos 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 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.
Exemplos:
>>> from transformers import AutoImageProcessor, PerceiverForImageClassificationLearned
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> image_processor = AutoImageProcessor.from_pretrained("deepmind/vision-perceiver-learned")
>>> model = PerceiverForImageClassificationLearned.from_pretrained("deepmind/vision-perceiver-learned")
>>> inputs = image_processor(images=image, return_tensors="pt").pixel_values
>>> outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 1000]
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: tabby, tabby catPerceiverForImageClassificationFourier
classe transformers.PerceiverForImageClassificationFourier
< source >( config: PerceiverConfig )
Parâmetros
- config (PerceiverConfig) — 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.
Exemplo de uso do Perceiver para classificação de imagens, em tarefas como ImageNet.
Este modelo usa embeddings de posição 2D de Fourier fixos. Conforme mostrado no artigo, este modelo pode alcançar uma precisão top-1 de 79,0 no ImageNet e 84,5 quando pré-treinado em um conjunto de dados em larga escala (ou seja, JFT).
PerceiverForImageClassificationLearned usa PerceiverImagePreprocessor (com prep_type="pixels") para pré-processar as imagens de entrada e PerceiverClassificationDecoder para decodificar a representação latente de PerceiverModel em logits de classificação.
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 >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = Nonepixel_values: typing.Optional[torch.Tensor] = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.FloatTensor)
Parâmetros
- inputs (
torch.Tensor, opcional) — Entradas para o perceiver. Pode ser qualquer coisa: imagens, texto, áudio, vídeo, etc. - 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.
- output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para o cálculo da perda de classificação/regressão de imagem. 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). - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples. - pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando PerceiverImageProcessor. Consulte PerceiverImageProcessor.call() para detalhes (processor_classusa PerceiverImageProcessor para processar imagens).
Retorna
PerceiverClassifierOutput ou tuple(torch.FloatTensor)
Um PerceiverClassifierOutput 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 (PerceiverConfig) e das entradas.
O método forward de PerceiverForImageClassificationFourier 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 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).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) 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 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 após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos 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 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.
Exemplos:
>>> from transformers import AutoImageProcessor, PerceiverForImageClassificationFourier
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> image_processor = AutoImageProcessor.from_pretrained("deepmind/vision-perceiver-fourier")
>>> model = PerceiverForImageClassificationFourier.from_pretrained("deepmind/vision-perceiver-fourier")
>>> inputs = image_processor(images=image, return_tensors="pt").pixel_values
>>> outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 1000]
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: tabby, tabby catPerceiverForImageClassificationConvProcessing
classe transformers.PerceiverForImageClassificationConvProcessing
< source >( config: PerceiverConfig )
Parâmetros
- config (PerceiverConfig) — 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.
Exemplo de uso do Perceiver para classificação de imagens, em tarefas como ImageNet.
Este modelo utiliza uma rede de pré-processamento com convolução 2D + maxpool. Conforme mostrado no artigo, este modelo pode alcançar uma precisão top-1 de 82,1 no ImageNet.
PerceiverForImageClassificationLearned usa PerceiverImagePreprocessor (com prep_type="conv") para pré-processar as imagens de entrada e PerceiverClassificationDecoder para decodificar a representação latente de PerceiverModel em logits de classificação.
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 >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = Nonepixel_values: typing.Optional[torch.Tensor] = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.FloatTensor)
Parâmetros
- inputs (
torch.Tensor, opcional) — Entradas para o perceiver. Pode ser qualquer coisa: imagens, texto, áudio, vídeo, etc. - 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.
- output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para o cálculo da perda de classificação/regressão de imagem. 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). - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples. - pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando PerceiverImageProcessor. Consulte PerceiverImageProcessor.call() para mais detalhes (processor_classusa PerceiverImageProcessor para processar imagens).
Retorna
PerceiverClassifierOutput ou tuple(torch.FloatTensor)
Um PerceiverClassifierOutput 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 (PerceiverConfig) e das entradas.
O método forward de PerceiverForImageClassificationConvProcessing 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 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).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) 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 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 após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos 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 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.
Exemplos:
>>> from transformers import AutoImageProcessor, PerceiverForImageClassificationConvProcessing
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> image_processor = AutoImageProcessor.from_pretrained("deepmind/vision-perceiver-conv")
>>> model = PerceiverForImageClassificationConvProcessing.from_pretrained("deepmind/vision-perceiver-conv")
>>> inputs = image_processor(images=image, return_tensors="pt").pixel_values
>>> outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 1000]
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: tabby, tabby catPerceiverForOpticalFlow
classe transformers.PerceiverForOpticalFlow
< source >( config: PerceiverConfig )
Parâmetros
- config (PerceiverConfig) — 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.
Exemplo de uso do Perceiver para fluxo óptico, em tarefas como Sintel e KITTI. PerceiverForOpticalFlow usa PerceiverImagePreprocessor (com prep_type=“patches”) para pré-processar as imagens de entrada e PerceiverOpticalFlowDecoder para decodificar a representação latente de PerceiverModel.
Como entrada, concatenam-se 2 quadros subsequentes ao longo da dimensão de canal e extrai-se um patch de 3 x 3 em torno de cada pixel (resultando em 3 x 3 x 3 x 2 = 54 valores para cada pixel). Codificações de posição fixas de Fourier são usadas para codificar a posição de cada pixel no patch. Em seguida, aplica-se o codificador Perceiver. Para decodificar, consulta-se a representação latente usando a mesma codificação utilizada para a entrada.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.FloatTensor)
Parâmetros
- inputs (
torch.Tensor, opcional) — Entradas para o perceiver. Pode ser qualquer coisa: imagens, texto, áudio, vídeo, etc. - 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.
- output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para o cálculo da perda de fluxo óptico. Os índices devem estar em[0, ..., config.num_labels - 1]. - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.
Retorna
PerceiverClassifierOutput ou tuple(torch.FloatTensor)
Um PerceiverClassifierOutput 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 (PerceiverConfig) e das entradas.
O método forward de PerceiverForOpticalFlow 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 (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).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) 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 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 após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos 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 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.
Exemplos:
>>> from transformers import PerceiverForOpticalFlow
>>> import torch
>>> model = PerceiverForOpticalFlow.from_pretrained("deepmind/optical-flow-perceiver")
>>> # in the Perceiver IO paper, the authors extract a 3 x 3 patch around each pixel,
>>> # leading to 3 x 3 x 3 = 27 values for each pixel (as each pixel also has 3 color channels)
>>> # patches have shape (batch_size, num_frames, num_channels, height, width)
>>> # the authors train on resolutions of 368 x 496
>>> patches = torch.randn(1, 2, 27, 368, 496)
>>> outputs = model(inputs=patches)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 368, 496, 2]PerceiverForMultimodalAutoencoding
classe transformers.PerceiverForMultimodalAutoencoding
< source >( config: PerceiverConfig )
Parâmetros
- config (PerceiverConfig) — 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.
Exemplo de uso do Perceiver para autoencoding multimodal (vídeo), para tarefas como Kinetics-700.
PerceiverForMultimodalAutoencoding usa PerceiverMultimodalPreprocessor para pré-processar as 3 modalidades: imagens, áudio e rótulos de classe. Este pré-processador utiliza pré-processadores específicos de cada modalidade para pré-processar cada uma separadamente, após o que são concatenadas. Embeddings de posição treináveis são usados para preencher cada modalidade até o mesmo número de canais, tornando possível a concatenação ao longo da dimensão do tempo. Em seguida, aplica-se o codificador Perceiver.
PerceiverMultimodalDecoder é usado para decodificar a representação latente de PerceiverModel. Este decodificador usa cada decodificador específico de modalidade para construir as consultas. As consultas do decodificador são criadas com base nas entradas após o pré-processamento. No entanto, fazer autoencoding de um vídeo inteiro em uma única passagem de frente é computacionalmente inviável, portanto, apenas partes das consultas do decodificador são usadas para realizar a atenção cruzada com a representação latente. Isso é determinado pelos índices subsampleados para cada modalidade, que podem ser fornecidos como entrada adicional para a passagem de frente de PerceiverForMultimodalAutoencoding.
PerceiverMultimodalDecoder também aplica padding às queries do decoder das diferentes modalidades para que tenham o mesmo número de canais, a fim de concatená-las ao longo da dimensão do tempo. Em seguida, é executada a cross-attention com a representação latente de PerceiverModel.
Por fim, ~models.perceiver.modeling_perceiver.PerceiverMultiModalPostprocessor é usado para transformar esse tensor em um
vídeo real. Primeiro, ele divide a saída nas diferentes modalidades e, em seguida, aplica o
pós-processador correspondente para cada modalidade.
Observe que, ao mascarar o rótulo de classificação durante a avaliação (ou seja, fornecendo simplesmente um tensor de zeros para a modalidade “label”), este modelo de auto-encoding se torna um classificador de vídeos Kinetics 700.
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 >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonesubsampled_output_points: dict[str, torch.Tensor] | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.FloatTensor)
Parâmetros
- inputs (
torch.Tensor, opcional) — Entradas para o perceiver. Pode ser qualquer coisa: imagens, texto, áudio, vídeo, etc. - 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.
- subsampled_output_points (
dict[str, torch.Tensor], opcional) — Dicionário de tensores usados como consultas para o decoder. O decoder mapeia essas consultas para a representação latente do modelo. Usado para decodificação subsampleada, por exemplo, quando apenas determinados patches de imagem são decodificados. - output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para o cálculo da perda de classificação/regressão de imagem. 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). - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.
Retorna
PerceiverClassifierOutput ou tuple(torch.FloatTensor)
Um PerceiverClassifierOutput 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 (PerceiverConfig) e das entradas.
O método forward de PerceiverForMultimodalAutoencoding 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 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).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) 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 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 após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos 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 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.
Exemplos:
>>> from transformers import PerceiverForMultimodalAutoencoding
>>> import torch
>>> import numpy as np
>>> # create multimodal inputs
>>> images = torch.randn((1, 16, 3, 224, 224))
>>> audio = torch.randn((1, 30720, 1))
>>> inputs = dict(image=images, audio=audio, label=torch.zeros((images.shape[0], 700)))
>>> model = PerceiverForMultimodalAutoencoding.from_pretrained("deepmind/multimodal-perceiver")
>>> # in the Perceiver IO paper, videos are auto-encoded in chunks
>>> # each chunk subsamples different index dimensions of the image and audio modality decoder queries
>>> nchunks = 128
>>> image_chunk_size = np.prod((16, 224, 224)) // nchunks
>>> audio_chunk_size = audio.shape[1] // model.config.samples_per_patch // nchunks
>>> # process the first chunk
>>> chunk_idx = 0
>>> subsampling = {
... "image": torch.arange(image_chunk_size * chunk_idx, image_chunk_size * (chunk_idx + 1)),
... "audio": torch.arange(audio_chunk_size * chunk_idx, audio_chunk_size * (chunk_idx + 1)),
... "label": None,
... }
>>> outputs = model(inputs=inputs, subsampled_output_points=subsampling)
>>> logits = outputs.logits
>>> list(logits["audio"].shape)
[1, 240]
>>> list(logits["image"].shape)
[1, 6272, 3]
>>> list(logits["label"].shape)
[1, 700]