Transformers documentation

DeiT

Transformers

Comece agora

Transformers Instalação Início rápido

Classes base

Modelos

Pré-processadores

Inferência

Pipeline API

API de geração

Otimização

Conversar com modelos

Serving

Treinamento

Comece agora

Personalização

Ajuste fino de parâmetros eficientes

Desempenho

Treinamento distribuído

Hardware

Quantização

Integrações com o ecossistema

Recursos

API

Principais classes

Modelos

Modelos de texto

Modelos de visão

Modelos de áudio

Modelos de vídeo

Modelos multimodais

Modelos de aprendizado por reforço

Modelos de séries temporais

Helpers internos

Referência

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Este modelo foi publicado no HF papers em 2020-12-23 e contribuído para o Hugging Face Transformers em 2021-04-13.

DeiT

Visão geral

O modelo DeiT foi proposto em Training data-efficient image transformers & distillation through attention por Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, Hervé Jégou. O Vision Transformer (ViT) introduzido em Dosovitskiy et al., 2020 demonstrou que é possível igualar ou até superar as redes neurais convolucionais existentes usando um codificador Transformer (estilo BERT). No entanto, os modelos ViT introduzidos naquele artigo exigiam treinamento em infraestrutura cara por várias semanas, utilizando dados externos. Os DeiT (data-efficient image transformers) são transformers treinados de forma mais eficiente para classificação de imagens, exigindo muito menos dados e muito menos recursos computacionais em comparação com os modelos ViT originais.

O resumo do artigo é o seguinte:

Recentemente, demonstrou-se que redes neurais baseadas puramente em atenção conseguem resolver tarefas de compreensão de imagem, como a classificação de imagens. No entanto, esses transformers visuais são pré-treinados com centenas de milhões de imagens usando uma infraestrutura cara, o que limita sua adoção. Neste trabalho, produzimos um transformer competitivo e sem convoluções treinando apenas no Imagenet. Os treinamos em um único computador em menos de 3 dias. Nosso transformer de visão de referência (86M de parâmetros) atinge uma precisão top-1 de 83,1% (avaliação single-crop) no ImageNet, sem dados externos. Mais importante ainda, introduzimos uma estratégia de professor-aluno específica para transformers. Ela se baseia em um token de destilação que garante que o aluno aprenda com o professor por meio da atenção. Mostramos o interesse dessa destilação baseada em tokens, especialmente ao usar uma convnet como professora. Isso nos leva a relatar resultados competitivos com convnets tanto no Imagenet (onde obtemos até 85,2% de precisão) quanto ao transferir para outras tarefas. Compartilhamos nosso código e modelos.

Este modelo foi contribuído por nielsr.

Dicas de uso

Em comparação ao ViT, os modelos DeiT utilizam um token de destilação para aprender efetivamente de um modelo professor (que, no artigo do DeiT, é um modelo semelhante a um ResNet). O token de destilação é aprendido por meio da retropropagação, interagindo com os tokens de classe ([CLS]) e de patch através das camadas de autoatenção.
Existem 2 maneiras de fazer o fine-tuning de modelos destilados: (1) de forma clássica, colocando apenas um head de previsão sobre o estado oculto final do token de classe e sem usar o sinal de destilação, ou (2) colocando um head de previsão tanto sobre o token de classe quanto sobre o token de destilação. Nesse caso, o head de previsão do [CLS] é treinado usando a entropia cruzada regular entre a previsão do head e o rótulo verdadeiro, enquanto o head de previsão de destilação é treinado usando destilação dura (entropia cruzada entre a previsão do head de destilação e o rótulo previsto pelo teacher). No momento da inferência, adota-se a previsão média entre os dois heads como previsão final. A opção (2) também é chamada de “fine-tuning com destilação”, pois depende de um teacher que já foi ajustado no dataset de downstream. Em termos de modelos, (1) corresponde a DeiTForImageClassification e (2) corresponde a DeiTForImageClassificationWithTeacher.
Observe que os autores também tentaram a destilação suave para (2) (nesse caso, a cabeça de previsão de destilação é treinada usando a divergência de KL para corresponder à saída softmax do modelo professor), mas a destilação rígida apresentou os melhores resultados.
Todos os checkpoints lançados foram pré-treinados e ajustados (fine-tuned) apenas no ImageNet-1k. Nenhum dado externo foi utilizado. Isso contrasta com o modelo ViT original, que utilizou dados externos, como o conjunto de dados JFT-300M/Imagenet-21k, para o pré-treinamento.
Os autores do DeiT também disponibilizaram modelos ViT treinados de forma mais eficiente, que podem ser plugados diretamente em ViTModel ou ViTForImageClassification. Técnicas como aumento de dados, otimização e regularização foram utilizadas para simular o treinamento em um conjunto de dados muito maior (enquanto apenas o ImageNet-1k era usado para o pré-treinamento). Há 4 variantes disponíveis (em 3 tamanhos diferentes): facebook/deit-tiny-patch16-224, facebook/deit-small-patch16-224, facebook/deit-base-patch16-224 e facebook/deit-base-patch16-384. Observe que deve-se usar DeiTImageProcessor para preparar as imagens para o modelo.

Usando Scaled Dot Product Attention (SDPA)

O PyTorch inclui um operador nativo de atenção de produto escalar com escala (SDPA) como parte de torch.nn.functional. Essa função abrange várias implementações que podem ser aplicadas dependendo das entradas e do hardware em uso. Consulte a documentação oficial ou a página GPU Inference para mais informações.

O SDPA é usado por padrão para torch>=2.1.1 quando uma implementação está disponível, mas você também pode definir attn_implementation="sdpa" em from_pretrained() para solicitar explicitamente o uso do SDPA.

from transformers import DeiTForImageClassification


model = DeiTForImageClassification.from_pretrained("facebook/deit-base-distilled-patch16-224", attn_implementation="sdpa", device_map="auto")
...

Para obter as melhores acelerações, recomendamos carregar o modelo em meia precisão (por exemplo, torch.float16 ou torch.bfloat16).

Em um benchmark local (A100-40GB, PyTorch 2.3.0, sistema operacional Ubuntu 22.04) com float32 e o modelo facebook/deit-base-distilled-patch16-224, observamos os seguintes aumentos de velocidade durante a inferência.

Tamanho do lote	Tempo médio de inferência (ms), modo eager	Tempo médio de inferência (ms), modelo sdpa	Aceleração, Sdpa / Eager (x)
1	8	6	1.33
2	9	6	1.5
4	9	6	1.5
8	8	6	1.33

Recursos

Uma lista de recursos oficiais da Hugging Face e da comunidade (indicados por 🌎) para ajudar você a começar com o DeiT.

Image Classification

DeiTForImageClassification é suportado por este notebook.
Veja também: Guia da tarefa de classificação de imagens

Se você tiver interesse em enviar um recurso para ser incluído aqui, sinta-se à vontade para abrir um Pull Request e faremos a revisão! O recurso deve, idealmente, demonstrar algo novo, em vez de duplicar um recurso existente.

DeiTConfig

classe transformers.DeiTConfig

< 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 = Nonehidden_size: int = 768num_hidden_layers: int = 12num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.0attention_probs_dropout_prob: float | int = 0.0initializer_range: float = 0.02layer_norm_eps: float = 1e-12image_size: int | list[int] | tuple[int, int] = 224patch_size: int | list[int] | tuple[int, int] = 16num_channels: int = 3qkv_bias: bool = Trueencoder_stride: int = 16pooler_output_size: int | None = Nonepooler_act: str = 'tanh' )

Parâmetros

hidden_size (int, opcional, padrão 768) — Dimensão das representações ocultas.
num_hidden_layers (int, opcional, padrão 12) — Número de camadas ocultas no decodificador do Transformer.
num_attention_heads (int, opcional, padrão 12) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
intermediate_size (int, opcional, padrão 3072) — Dimensão das representações do MLP.
hidden_act (str, opcional, padrão gelu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
hidden_dropout_prob (Union[float, int], opcional, padrão 0.0) — A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no encoder e no pooler.
attention_probs_dropout_prob (Union[float, int], opcional, padrão 0.0) — A taxa de dropout para as probabilidades de atenção.
initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
layer_norm_eps (float, opcional, padrão 1e-12) — O epsilon usado pelas camadas de normalização de camada.
image_size (Union[int, list[int], tuple[int, int]], opcional, padrão 224) — O tamanho (resolução) de cada imagem.
patch_size (Union[int, list[int], tuple[int, int]], opcional, padrão 16) — O tamanho (resolução) de cada patch.
num_channels (int, opcional, padrão 3) — O número de canais de entrada.
qkv_bias (bool, opcional, padrão True) — Se deve adicionar um viés às queries, keys e values.
encoder_stride (int, opcional, padrão 16) — Fator pelo qual a resolução espacial é aumentada na cabeça do decodificador para modelagem de imagens mascaradas.
pooler_output_size (int, opcional) — Dimensão da camada pooler. Se for None, o valor padrão é hidden_size.
pooler_act (str, opcional, padrão "tanh") — A função de ativação a ser usada pelo pooler.

Esta é a classe de configuração para armazenar a configuração de um DeiTModel. Ela é usada para instanciar um modelo Deit 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 facebook/deit-base-distilled-patch16-224

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 DeiTConfig, DeiTModel

>>> # Initializing a DeiT deit-base-distilled-patch16-224 style configuration
>>> configuration = DeiTConfig()

>>> # Initializing a model (with random weights) from the deit-base-distilled-patch16-224 style configuration
>>> model = DeiTModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

DeiTImageProcessor

classe transformers.DeiTImageProcessor

< 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ão True) — Se deve redimensionar a imagem.
size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, padrão {'height' -- 256, 'width': 256}): Descreve as dimensões máximas de entrada para o modelo.
default_to_square (bool, kwargs, opcional, padrão True) — 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' -- 224, 'width': 224}): Tamanho da imagem de saída após aplicar center_crop.
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, padrão 3) — Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração PILImageResampling. Tem efeito apenas se do_resize estiver definido como True.
do_rescale (bool, kwargs, opcional, padrão True) — Se deve reescalar a imagem.
rescale_factor (float, kwargs, opcional, padrão 0.00392156862745098) — Fator de reescala para reescalar a imagem, caso do_rescale esteja definido como True.
do_normalize (bool, kwargs, opcional, padrão True) — Se a imagem deve ser normalizada.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão [0.5, 0.5, 0.5]) — Média da imagem a ser usada para normalização. Tem efeito apenas se do_normalize estiver definido como True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão [0.5, 0.5, 0.5]) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se do_normalize estiver definido como True.
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. Se pad_size não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando do_pad=True.
do_center_crop (bool, kwargs, opcional, padrão True) — Se deve recortar a imagem pelo centro.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Apenas ChannelDimension.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" ou ChannelDimension.FIRST: imagem no formato (num_channels, height, width).
- "channels_last" ou ChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
- "none" ou ChannelDimension.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 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 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 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 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 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 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 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 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 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 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 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 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 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.
Returns tensores empilhados se definido como 'pt', caso contrário, retorna uma lista de tensores. —

Constrói um processador de imagens DeiTImageProcessor.

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.

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, defina do_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 de center_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ção PILImageResampling. Tem efeito apenas se do_resize estiver definido como True.
do_rescale (bool, kwargs, opcional) — Se deve reescalar a imagem.
rescale_factor (float, kwargs, opcional) — Fator de redimensionamento para redimensionar a imagem, caso do_rescale esteja definido como True.
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 se do_normalize estiver definido como True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se do_normalize estiver definido como True.
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. Se pad_size não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando do_pad=True.
do_center_crop (bool, kwargs, opcional) — Se deve recortar a imagem centralmente.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Apenas ChannelDimension.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" ou ChannelDimension.FIRST: imagem no formato (num_channels, height, width).
- "channels_last" ou ChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
- "none" ou ChannelDimension.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.

DeiTImageProcessorPil

classe transformers.DeiTImageProcessorPil

< 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ão True) — Se deve redimensionar a imagem.
size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, padrão {'height' -- 256, 'width': 256}): Descreve as dimensões máximas de entrada para o modelo.
default_to_square (bool, kwargs, opcional, padrão True) — 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' -- 224, 'width': 224}): Tamanho da imagem de saída após aplicar center_crop.
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, padrão 3) — Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração PILImageResampling. Tem efeito apenas se do_resize estiver definido como True.
do_rescale (bool, kwargs, opcional, padrão True) — Se deve reescalar a imagem.
rescale_factor (float, kwargs, opcional, padrão 0.00392156862745098) — Fator de reescala para reescalar a imagem, caso do_rescale esteja definido como True.
do_normalize (bool, kwargs, opcional, padrão True) — Se a imagem deve ser normalizada.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão [0.5, 0.5, 0.5]) — Média da imagem a ser usada para normalização. Tem efeito apenas se do_normalize estiver definido como True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão [0.5, 0.5, 0.5]) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se do_normalize estiver definido como True.
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. Se pad_size não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando do_pad=True.
do_center_crop (bool, kwargs, opcional, padrão True) — Se deve recortar a imagem pelo centro.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Apenas ChannelDimension.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" ou ChannelDimension.FIRST: imagem no formato (num_channels, height, width).
- "channels_last" ou ChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
- "none" ou ChannelDimension.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 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 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 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 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 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.
Returns tensores empilhados se definido como 'pt', caso contrário, retorna uma lista de tensores. —

Constrói um processador de imagens DeiTImageProcessor.

pré-processamento

< source >

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, defina do_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 de center_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ção PILImageResampling. Tem efeito apenas se do_resize estiver definido como True.
do_rescale (bool, kwargs, opcional) — Se deve reescalar a imagem.
rescale_factor (float, kwargs, opcional) — Fator de redimensionamento para redimensionar a imagem, caso do_rescale esteja definido como True.
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 se do_normalize estiver definido como True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se do_normalize estiver definido como True.
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. Se pad_size não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando do_pad=True.
do_center_crop (bool, kwargs, opcional) — Se deve recortar a imagem centralmente.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Apenas ChannelDimension.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" ou ChannelDimension.FIRST: imagem no formato (num_channels, height, width).
- "channels_last" ou ChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
- "none" ou ChannelDimension.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.

DeiTModel

classe transformers.DeiTModel

< source >

( config: DeiTConfigadd_pooling_layer: bool = Trueuse_mask_token: bool = False )

Parâmetros

config (DeiTConfig) — 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.
add_pooling_layer (bool, opcional, padrão True) — Se deve adicionar uma camada de pooling
use_mask_token (bool, opcional, padrão False) — Se deve usar um token de máscara para modelagem de imagem mascarada.

O modelo Deit puro, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< source >

( pixel_values: typing.Optional[torch.Tensor] = Nonebool_masked_pos: typing.Optional[torch.BoolTensor] = Noneinterpolate_pos_encoding: bool | None = Noneattention_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Parâmetros

pixel_values (torch.Tensor de 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 DeiTImageProcessor. Consulte DeiTImageProcessor.call() para mais detalhes (processor_class usa DeiTImageProcessor para processar imagens).
bool_masked_pos (torch.BoolTensor de forma (batch_size, num_patches), opcional) — Posições mascaradas booleanas. Indica quais patches estão mascarados (1) e quais não estão (0).
interpolate_pos_encoding (bool, opcional) — Se deve interpolar as codificações de posição pré-treinadas.
attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
O que são máscaras de atenção?

Retorna

BaseModelOutputWithPooling ou tuple(torch.Tensor)

Um BaseModelOutputWithPooling ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos dependendo da configuração (DeiTConfig) e das entradas.

O método forward do DeiTModel substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.
pooler_output (torch.Tensor de forma (batch_size, hidden_size)) — Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional através das camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para a família de modelos BERT, isso retorna o token de classificação após o processamento através de uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.
hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplo:

DeiTForMaskedImageModeling

classe transformers.DeiTForMaskedImageModeling

< source >

( config: DeiTConfig )

Parâmetros

config (DeiTConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

Modelo DeiT com um decodificador no topo para modelagem de imagem mascarada, conforme proposto em SimMIM.

forward

< source >

( pixel_values: typing.Optional[torch.Tensor] = Nonebool_masked_pos: typing.Optional[torch.BoolTensor] = Noneinterpolate_pos_encoding: bool = Falseattention_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MaskedImageModelingOutput or tuple(torch.Tensor)

Parâmetros

pixel_values (torch.Tensor de 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 DeiTImageProcessor. Consulte DeiTImageProcessor.call() para mais detalhes (processor_class usa DeiTImageProcessor para processar imagens).
bool_masked_pos (torch.BoolTensor de forma (batch_size, num_patches)) — Posições mascaradas booleanas. Indica quais patches estão mascarados (1) e quais não estão (0).
interpolate_pos_encoding (bool, opcional, padrão False) — Se deve interpolar as codificações de posição pré-treinadas.
attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
O que são máscaras de atenção?

Retorna

MaskedImageModelingOutput ou tuple(torch.Tensor)

Um MaskedImageModelingOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos dependendo da configuração (DeiTConfig) e das entradas.

O método forward de DeiTForMaskedImageModeling sobrescreve o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

loss (torch.Tensor de forma (1,), opcional, retornado quando bool_masked_pos é fornecido) — Perda de reconstrução.
reconstrução (torch.Tensor de forma (batch_size, num_channels, height, width)) — Imagens reconstruídas/completadas.
hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada estágio) de forma (batch_size, sequence_length, hidden_size). Hidden-states (também chamados de feature maps) do modelo na saída de cada estágio.
attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, patch_size, 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.

Exemplos:

>>> from transformers import AutoImageProcessor, DeiTForMaskedImageModeling
>>> import torch
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = DeiTForMaskedImageModeling.from_pretrained("facebook/deit-base-distilled-patch16-224")

>>> num_patches = (model.config.image_size // model.config.patch_size) ** 2
>>> pixel_values = image_processor(images=image, return_tensors="pt").pixel_values
>>> # create random boolean mask of shape (batch_size, num_patches)
>>> bool_masked_pos = torch.randint(low=0, high=2, size=(1, num_patches)).bool()

>>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos)
>>> loss, reconstructed_pixel_values = outputs.loss, outputs.reconstruction
>>> list(reconstructed_pixel_values.shape)
[1, 3, 224, 224]

DeiTForImageClassification

classe transformers.DeiTForImageClassification

< source >

( config: DeiTConfig )

Parâmetros

config (DeiTConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

Modelo DeiT transformer com uma cabeça de classificação de imagem no topo (uma camada linear no topo do estado oculto final do token [CLS]), por exemplo, para o ImageNet.

Observe que é possível fazer o ajuste fino do DeiT em imagens de resolução mais alta do que aquelas em que ele foi treinado, definindo interpolate_pos_encoding como True no forward do modelo. Isso interpola os embeddings de posição pré-treinados para a resolução mais alta.

forward

< source >

( pixel_values: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneinterpolate_pos_encoding: bool | None = Noneattention_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ImageClassifierOutput or tuple(torch.Tensor)

Parâmetros

pixel_values (torch.Tensor de 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 DeiTImageProcessor. Consulte DeiTImageProcessor.call() para mais detalhes (processor_class usa DeiTImageProcessor para processar imagens).
labels (torch.LongTensor de 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]. Se config.num_labels == 1, uma perda de regressão é calculada (perda de erro quadrático médio); se config.num_labels > 1, uma perda de classificação é calculada (entropia cruzada).
interpolate_pos_encoding (bool, opcional) — Se deve interpolar as codificações de posição pré-treinadas.
attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
O que são máscaras de atenção?

Retorna

ImageClassifierOutput ou tuple(torch.Tensor)

Um ImageClassifierOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos dependendo da configuração (DeiTConfig) e das entradas.

O método forward de DeiTForImageClassification sobrescreve o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

loss (torch.Tensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de classificação (ou regressão se config.num_labels==1).
logits (torch.Tensor de forma (batch_size, config.num_labels)) — Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax).
hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada estágio) de forma (batch_size, sequence_length, hidden_size). Hidden-states (também chamados de feature maps) do modelo na saída de cada estágio.
attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, patch_size, sequence_length).

Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplo:

>>> from transformers import AutoImageProcessor, DeiTForImageClassification
>>> import torch
>>> from datasets import load_dataset

>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = DeiTForImageClassification.from_pretrained("facebook/deit-base-distilled-patch16-224")

>>> inputs = image_processor(image, return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
...

DeiTForImageClassificationWithTeacher

classe transformers.DeiTForImageClassificationWithTeacher

< source >

( config: DeiTConfig )

Parâmetros

config (DeiTConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

Modelo DeiT transformer com cabeças de classificação de imagem no topo (uma camada linear no topo do estado oculto final do token [CLS] e uma camada linear no topo do estado oculto final do token de destilação), por exemplo, para o ImageNet.

.. warning::

Este modelo suporta apenas inferência. O ajuste fino com destilação (ou seja, com um modelo professor) ainda não é suportado.

forward

< source >

( pixel_values: typing.Optional[torch.Tensor] = Noneinterpolate_pos_encoding: bool = Falseattention_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → DeiTForImageClassificationWithTeacherOutput or tuple(torch.Tensor)

Parâmetros

pixel_values (torch.Tensor de 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 DeiTImageProcessor. Consulte DeiTImageProcessor.call() para mais detalhes (processor_class usa DeiTImageProcessor para processar imagens).
interpolate_pos_encoding (bool, opcional, padrão False) — Se deve interpolar as codificações de posição pré-treinadas.
attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
O que são máscaras de atenção?

Retorna

DeiTForImageClassificationWithTeacherOutput ou tuple(torch.Tensor)

Um DeiTForImageClassificationWithTeacherOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos dependendo da configuração (DeiTConfig) e das entradas.

O método forward de DeiTForImageClassificationWithTeacher substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

logits (torch.Tensor de forma (batch_size, config.num_labels)) — Pontuações de previsão como a média dos cls_logits e dos logits de destilação.
cls_logits (torch.Tensor de forma (batch_size, config.num_labels)) — Pontuações de previsão da cabeça de classificação (ou seja, a camada linear no topo do estado oculto final do token de classe).
distillation_logits (torch.Tensor de forma (batch_size, config.num_labels)) — Pontuações de previsão da cabeça de destilação (ou seja, a camada linear no topo do estado oculto final do token de destilação).
hidden_states (tuple[torch.Tensor], opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (tuple[torch.Tensor], opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplo:

>>> from transformers import AutoImageProcessor, DeiTForImageClassificationWithTeacher
>>> import torch
>>> from datasets import load_dataset

>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = DeiTForImageClassificationWithTeacher.from_pretrained("facebook/deit-base-distilled-patch16-224")

>>> inputs = image_processor(image, return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
...

Update on GitHub

←DEIMv2 Depth Anything→