transformers/main/pt/model_doc/align.md

ALIGN

ALIGN é pré-treinado em um conjunto de dados de 1,8 bilhão de pares de texto alternativo e imagem com ruído, para demonstrar que a escala pode compensar o ruído. Ele utiliza uma arquitetura de codificador duplo, EfficientNet para imagens e BERT para texto, e uma perda contrastiva para alinhar embeddings de imagem–texto semelhantes, enquanto afasta embeddings diferentes. Uma vez treinado, o ALIGN pode codificar qualquer imagem e legendas candidatas em um espaço vetorial compartilhado para recuperação ou classificação zero-shot, sem exigir rótulos adicionais. Essa abordagem centrada na escala reduz os custos de curadoria do conjunto de dados e impulsiona a recuperação de imagem–texto e a classificação zero-shot no ImageNet com resultados de estado da arte.

Você pode encontrar todos os checkpoints originais do ALIGN na organização Kakao Brain.

Clique nos modelos ALIGN na barra lateral à direita para ver mais exemplos de como aplicar o ALIGN a diferentes tarefas relacionadas a visão e texto.

O exemplo abaixo demonstra a classificação de imagens zero-shot com Pipeline ou a classe AutoModel.

from transformers import pipeline

pipeline = pipeline(
    task="zero-shot-image-classification",
    model="kakaobrain/align-base",
    device=0,
)

candidate_labels = [
    "a photo of a dog",
    "a photo of a cat",
    "a photo of a person"
]

pipeline("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg", candidate_labels=candidate_labels)

import requests
import torch
from PIL import Image

from transformers import AutoModelForZeroShotImageClassification, AutoProcessor

processor = AutoProcessor.from_pretrained("kakaobrain/align-base")
model = AutoModelForZeroShotImageClassification.from_pretrained("kakaobrain/align-base", device_map="auto")

url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
image = requests.get(url, stream=True)
inputs = Image.open(image.raw).convert("RGB")

image_inputs = processor(images=inputs, return_tensors="pt").to(model.device)
with torch.no_grad():
    image_embeds = model.get_image_features(**image_inputs)

candidate_labels = ["a photo of a dog", "a photo of a cat", "a photo of a person"]
text_inputs = processor(text=candidate_labels, padding=True, return_tensors="pt").to(model.device)
with torch.no_grad():
    text_embeds = model.get_text_features(**text_inputs)

image_embeds = image_embeds / image_embeds.norm(p=2, dim=-1, keepdim=True)
text_embeds  = text_embeds  / text_embeds.norm(p=2, dim=-1, keepdim=True)

logits = (image_embeds @ text_embeds.T) * 100.0
probs  = logits.softmax(dim=-1).cpu().squeeze()

for label, score in zip(candidate_labels, probs):
    print(f"{label:20s} → {score.item():.4f}")

Observações

• O ALIGN projeta os recursos de texto e visuais no espaço latente e o produto escalar entre os recursos de imagem e texto projetados é usado como a pontuação de similaridade. O exemplo abaixo demonstra como calcular a pontuação de similaridade entre imagem e texto com AlignProcessor e AlignModel.

  # Example of using ALIGN for image-text similarity
  from transformers import AlignProcessor, AlignModel
  import torch
  from PIL import Image
  import requests
  from io import BytesIO
  
  # Load processor and model
  processor = AlignProcessor.from_pretrained("kakaobrain/align-base")
  model = AlignModel.from_pretrained("kakaobrain/align-base", device_map="auto")
  
  # Download image from URL
  url = "https://huggingface.co/roschmid/dog-races/resolve/main/images/Golden_Retriever.jpg"
  response = requests.get(url)
  image = Image.open(BytesIO(response.content))  # Convert the downloaded bytes to a PIL Image
  
  texts = ["a photo of a cat", "a photo of a dog"]
  
  # Process image and text inputs
  inputs = processor(images=image, text=texts, return_tensors="pt").to(model.device)
  
  # Get the embeddings
  with torch.no_grad():
      outputs = model(**inputs)
  
  image_embeds = outputs.image_embeds
  text_embeds = outputs.text_embeds
  
  # Normalize embeddings for cosine similarity
  image_embeds = image_embeds / image_embeds.norm(dim=1, keepdim=True)
  text_embeds = text_embeds / text_embeds.norm(dim=1, keepdim=True)
  
  # Calculate similarity scores
  similarity_scores = torch.matmul(text_embeds, image_embeds.T)
  
  # Print raw scores
  print("Similarity scores:", similarity_scores)
  
  # Convert to probabilities
  probs = torch.nn.functional.softmax(similarity_scores, dim=0)
  print("Probabilities:", probs)
  
  # Get the most similar text
  most_similar_idx = similarity_scores.argmax().item()
  print(f"Most similar text: '{texts[most_similar_idx]}'")
  

Recursos

• Consulte o post no blog Kakao Brain’s Open Source ViT, ALIGN, and the New COYO Text-Image Dataset para mais detalhes.

AlignConfig[[transformers.AlignConfig]]

transformers.AlignConfig[[transformers.AlignConfig]]

transformers.AlignConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, projection_dim: int = 640, temperature_init_value: float = 1.0, initializer_range: float = 0.02)

Origem

Parâmetros:

text_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) : O objeto de configuração ou dicionário do backbone de texto.

vision_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) : O objeto de configuração ou dicionário do backbone de visão.

projection_dim (int, opcional, padrão 640) : Dimensionalidade das camadas de projeção de texto e visão.

temperature_init_value (float, opcional, padrão 1.0) : O valor inicial do parâmetro temperature. O padrão é utilizado conforme a implementação original do ALIGN.

initializer_range (float, opcional, padrão 0.02) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

Esta é a classe de configuração para armazenar a configuração de um AlignModel. Ela é usada para instanciar um modelo Align 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 kakaobrain/align-base

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Leia a documentação de PreTrainedConfig para mais informações.

Exemplo:

>>> from transformers import AlignConfig, AlignModel

>>> # Initializing a AlignConfig with kakaobrain/align-base style configuration
>>> configuration = AlignConfig()

>>> # Initializing a AlignModel (with random weights) from the kakaobrain/align-base style configuration
>>> model = AlignModel(configuration)

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

>>> # We can also initialize a AlignConfig from a AlignTextConfig and a AlignVisionConfig
>>> from transformers import AlignTextConfig, AlignVisionConfig

>>> # Initializing ALIGN Text and Vision configurations
>>> config_text = AlignTextConfig()
>>> config_vision = AlignVisionConfig()

>>> config = AlignConfig(text_config=config_text, vision_config=config_vision)

AlignTextConfig[[transformers.AlignTextConfig]]

transformers.AlignTextConfig[[transformers.AlignTextConfig]]

transformers.AlignTextConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 512, type_vocab_size: int = 2, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None)

Origem

Parâmetros:

vocab_size (int, opcional, padrão 30522) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos input_ids.

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.1) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, encoder e pooler.

attention_probs_dropout_prob (Union[float, int], opcional, padrão 0.1) : A taxa de dropout para as probabilidades de atenção.

max_position_embeddings (int, opcional, padrão 512) : O comprimento máximo de sequência com o qual este modelo pode ser utilizado.

type_vocab_size (int, opcional, padrão 2) : O tamanho do vocabulário dos token_type_ids.

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.

pad_token_id (int, opcional, padrão 0) : ID do token usado para preenchimento no vocabulário.

bos_token_id (int, opcional) : ID do token usado para o início do fluxo no vocabulário.

eos_token_id (Union[int, list[int]], opcional) : ID do token usado para o fim do fluxo no vocabulário.

Esta é a classe de configuração para armazenar a configuração de um AlignModel. Ela é usada para instanciar um modelo Align 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 kakaobrain/align-base

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Leia a documentação de PreTrainedConfig para mais informações.

Exemplo:

>>> from transformers import AlignTextConfig, AlignTextModel

>>> # Initializing a AlignTextConfig with kakaobrain/align-base style configuration
>>> configuration = AlignTextConfig()

>>> # Initializing a AlignTextModel (with random weights) from the kakaobrain/align-base style configuration
>>> model = AlignTextModel(configuration)

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

AlignVisionConfig[[transformers.AlignVisionConfig]]

transformers.AlignVisionConfig[[transformers.AlignVisionConfig]]

transformers.AlignVisionConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, num_channels: int = 3, image_size: int | list[int] | tuple[int, int] = 600, width_coefficient: float = 2.0, depth_coefficient: float = 3.1, depth_divisor: int = 8, kernel_sizes: list[int] | tuple[int, ...] = (3, 3, 5, 3, 5, 5, 3), in_channels: list[int] | tuple[int, ...] = (32, 16, 24, 40, 80, 112, 192), out_channels: list[int] | tuple[int, ...] = (16, 24, 40, 80, 112, 192, 320), depthwise_padding: list | tuple[int, ...] = (), strides: list[int] | tuple[int, ...] = (1, 2, 2, 2, 1, 2, 1), num_block_repeats: list[int] | tuple[int, ...] = (1, 2, 2, 3, 3, 4, 1), expand_ratios: list[int] | tuple[int, ...] = (1, 6, 6, 6, 6, 6, 6), squeeze_expansion_ratio: float = 0.25, hidden_act: str = 'swish', hidden_dim: int = 2560, pooling_type: str = 'mean', initializer_range: float = 0.02, batch_norm_eps: float = 0.001, batch_norm_momentum: float = 0.99, drop_connect_rate: float | int = 0.2)

Origem

Parâmetros:

num_channels (int, opcional, padrão 3) : O número de canais de entrada.

image_size (Union[int, list[int], tuple[int, int]], opcional, padrão 600) : O tamanho (resolução) de cada imagem.

width_coefficient (float, opcional, padrão 2.0) : Coeficiente de escala para a largura da rede em cada estágio.

depth_coefficient (float, opcional, padrão 3.1) : Coeficiente de escala para a profundidade da rede em cada estágio.

depth_divisor (int, opcional, padrão 8) : Uma unidade de largura da rede.

kernel_sizes (list[int], opcional, padrão [3, 3, 5, 3, 5, 5, 3]) : Lista de tamanhos de kernel a serem usados em cada bloco.

in_channels (list[int], opcional, padrão [32, 16, 24, 40, 80, 112, 192]) : Lista de tamanhos de canais de entrada a serem usados em cada bloco para as camadas convolucionais.

out_channels (list[int], opcional, padrão [16, 24, 40, 80, 112, 192, 320]) : Lista de tamanhos de canais de saída a serem usados em cada bloco para as camadas convolucionais.

depthwise_padding (list[int], opcional, padrão []) : Lista de índices de blocos com preenchimento quadrado.

strides (list[int], opcional, padrão [1, 2, 2, 2, 1, 2, 1]) : Lista de tamanhos de passo a serem usados em cada bloco para as camadas convolucionais.

num_block_repeats (list[int], opcional, padrão [1, 2, 2, 3, 3, 4, 1]) : Lista com o número de vezes que cada bloco deve ser repetido.

expand_ratios (list[int], opcional, padrão [1, 6, 6, 6, 6, 6, 6]) : Lista dos coeficientes de escala de cada bloco.

squeeze_expansion_ratio (float, opcional, padrão 0.25) : Razão de expansão do squeeze.

hidden_act (str, opcional, padrão swish) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.

hidden_dim (int, opcional, padrão 1280) : A dimensão oculta da camada antes da cabeça de classificação.

pooling_type (str ou function, opcional, padrão "mean") : Tipo de pooling final a ser aplicado antes da cabeça de classificação densa. As opções disponíveis são ["mean", "max"]

initializer_range (float, opcional, padrão 0.02) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

batch_norm_eps (float, opcional, padrão 0.001) : O epsilon usado pelas camadas de normalização de lote.

batch_norm_momentum (float, opcional, padrão 0.99) : O momento usado pelas camadas de normalização de lote.

drop_connect_rate (float, opcional, padrão 0.2) : A taxa de descarte para conexões de atalho.

Esta é a classe de configuração para armazenar a configuração de um AlignModel. Ela é usada para instanciar um modelo Align 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 kakaobrain/align-base

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Leia a documentação de PreTrainedConfig para mais informações.

Exemplo:

>>> from transformers import AlignVisionConfig, AlignVisionModel

>>> # Initializing a AlignVisionConfig with kakaobrain/align-base style configuration
>>> configuration = AlignVisionConfig()

>>> # Initializing a AlignVisionModel (with random weights) from the kakaobrain/align-base style configuration
>>> model = AlignVisionModel(configuration)

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

AlignProcessor[[transformers.AlignProcessor]]

transformers.AlignProcessor[[transformers.AlignProcessor]]

transformers.AlignProcessor(image_processor, tokenizer)

Origem

Parâmetros:

image_processor (EfficientNetImageProcessor) : O processador de imagem é uma entrada obrigatória.

tokenizer (BertTokenizer) : O tokenizer é uma entrada obrigatória.

Constrói um AlignProcessor que encapsula um processador de imagem e um tokenizer em um único processador.

AlignProcessor oferece todas as funcionalidades de EfficientNetImageProcessor e BertTokenizer. Consulte ~EfficientNetImageProcessor e ~BertTokenizer para mais informações.

call[[transformers.AlignProcessor.call]]

__call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | list[list[str]] | None = None, videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)

Origem

Parâmetros:

images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], opcional) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina do_rescale=False.

text (Union[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 pretokenizada). Se você passar uma entrada pretokenizada, defina is_split_into_words=True para evitar ambiguidade com entradas em lote.

videos (Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]], opcional) : Vídeo para pré-processar. Espera um único vídeo ou um lote de vídeos com valores de pixel variando de 0 a 255. Se estiver passando vídeos com valores de pixel entre 0 e 1, defina do_rescale=False.

audio (Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]], opcional) : O áudio ou lote de áudios a ser preparado. Cada áudio pode ser um array NumPy ou um tensor PyTorch. No caso de um array NumPy/tensor PyTorch, cada áudio deve ter a forma (C, T), onde C é o número de canais e T é o comprimento de amostras do áudio.

return_tensors (str ou TensorType, opcional) : Se definido, retornará tensores de um framework específico. Os valores aceitos são: - 'pt': Retorna objetos torch.Tensor do PyTorch. - 'np': Retorna objetos np.ndarray do NumPy.

• **kwargs (ProcessingKwargs, opcional) : Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.

AlignModel[[transformers.AlignModel]]

transformers.AlignModel[[transformers.AlignModel]]

transformers.AlignModel(config: AlignConfig)

Origem

Parâmetros:

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

O modelo Align sem processamento adicional, que produz estados ocultos brutos sem nenhuma cabeça específica 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 e comportamento gerais.

forward[[transformers.AlignModel.forward]]

forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, return_loss: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)

Origem

Parâmetros:

input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada?

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 EfficientNetImageProcessor. Veja EfficientNetImageProcessor.call() para detalhes (AlignProcessor usa EfficientNetImageProcessor para processar imagens).

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?

token_type_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em [0, 1]: - 0 corresponde a um token de frase A, - 1 corresponde a um token de frase B. O que são IDs de tipo de token?

position_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo [0, config.n_positions - 1]. O que são IDs de posição?

inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) : Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de busca de incorporação interna do modelo.

return_loss (bool, opcional) : Se deve ou não retornar a perda contrastiva.

Retorna: AlignOutput ou tuple(torch.Tensor)

Um AlignOutput 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 (AlignConfig) e das entradas.

O método forward do AlignModel 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 return_loss é True) -- Perda contrastiva para similaridade entre imagem e texto.
• logits_per_image (torch.Tensor de forma (image_batch_size, text_batch_size)) -- As pontuações de produto escalar escalonado entre image_embeds e text_embeds. Isso representa as pontuações de similaridade entre imagem e texto.
• logits_per_text (torch.Tensor de forma (text_batch_size, image_batch_size)) -- As pontuações de produto escalar escalonado entre text_embeds e image_embeds. Isso representa as pontuações de similaridade entre texto e imagem.
• text_embeds (torch.Tensor de forma (batch_size, output_dim) -- Os embeddings de texto obtidos ao aplicar a camada de projeção à saída agregada do AlignTextModel.
• image_embeds (torch.Tensor de forma (batch_size, output_dim) -- A saída de AlignVisionModel.
• text_model_output (~modeling_outputs.BaseModelOutputWithPooling, opcional) -- A saída do AlignTextModel.
• vision_model_output (~modeling_outputs.BaseModelOutputWithPoolingAndNoAttention, opcional) -- A saída do AlignVisionModel.

Exemplos:

>>> import torch
>>> from transformers import AutoProcessor, AlignModel
>>> from transformers.image_utils import load_image

>>> model = AlignModel.from_pretrained("kakaobrain/align-base")
>>> processor = AutoProcessor.from_pretrained("kakaobrain/align-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = load_image(url)

>>> inputs = processor(
...     images=image, text=["a photo of a cat", "a photo of a dog"], return_tensors="pt", padding=True
... )

>>> with torch.inference_mode():
...     outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image  # this is the image-text similarity score
>>> probs = logits_per_image.softmax(dim=1)  # we can take the softmax to get the label probabilities

get_text_features[[transformers.AlignModel.get_text_features]]

get_text_features(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)

Origem

Parâmetros:

input_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada?

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?

token_type_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em [0, 1]: - 0 corresponde a um token de frase A, - 1 corresponde a um token de frase B. O que são IDs de tipo de token?

position_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo [0, config.n_positions - 1]. O que são IDs de posição?

inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) : Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de busca de incorporação interna do modelo.

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 (AlignConfig) e das entradas.

• 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 pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por 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) com a forma (batch_size, sequence_length, hidden_size).

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

• attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) -- Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).

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

Exemplos:

>>> import torch
>>> from transformers import AutoTokenizer, AlignModel

>>> model = AlignModel.from_pretrained("kakaobrain/align-base")
>>> tokenizer = AutoTokenizer.from_pretrained("kakaobrain/align-base")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")
>>> with torch.inference_mode():
...     text_features = model.get_text_features(**inputs)

get_image_features[[transformers.AlignModel.get_image_features]]

get_image_features(pixel_values: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)

Origem

Parâmetros:

pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size)) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando EfficientNetImageProcessor. Consulte EfficientNetImageProcessor.call() para mais detalhes (AlignProcessor usa EfficientNetImageProcessor para processar imagens).

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 (AlignConfig) e das entradas.

• 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 pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por 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) com a forma (batch_size, sequence_length, hidden_size).

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

• attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) -- Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).

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

Exemplos:

>>> import torch
>>> from transformers import AutoProcessor, AlignModel
>>> from transformers.image_utils import load_image

>>> model = AlignModel.from_pretrained("kakaobrain/align-base")
>>> processor = AutoProcessor.from_pretrained("kakaobrain/align-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = load_image(url)

>>> inputs = processor(images=image, return_tensors="pt")
>>> with torch.inference_mode():
...     image_features = model.get_image_features(**inputs)

AlignTextModel[[transformers.AlignTextModel]]

transformers.AlignTextModel[[transformers.AlignTextModel]]

transformers.AlignTextModel(config: AlignTextConfig, add_pooling_layer: bool = True)

Origem

Parâmetros:

config (AlignTextConfig) : 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

O modelo de texto do ALIGN sem nenhum head ou projeção 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 e comportamento gerais.

forward[[transformers.AlignTextModel.forward]]

forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)

Origem

Parâmetros:

input_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada?

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?

token_type_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em [0, 1]: - 0 corresponde a um token de frase A, - 1 corresponde a um token de frase B. O que são IDs de tipo de token?

position_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo [0, config.n_positions - 1]. O que são IDs de posição?

inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) : Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de busca de incorporação interna do modelo.

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 (AlignConfig) e das entradas.

O método forward do AlignTextModel 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 pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por 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) com a forma (batch_size, sequence_length, hidden_size).

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

• attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) -- Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).

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

Exemplos:

>>> from transformers import AutoTokenizer, AlignTextModel

>>> model = AlignTextModel.from_pretrained("kakaobrain/align-base")
>>> tokenizer = AutoTokenizer.from_pretrained("kakaobrain/align-base")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled (EOS token) states

AlignVisionModel[[transformers.AlignVisionModel]]

transformers.AlignVisionModel[[transformers.AlignVisionModel]]

transformers.AlignVisionModel(config: AlignVisionConfig)

Origem

Parâmetros:

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

O modelo de visão do ALIGN sem nenhum cabeçalho ou projeção 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 e comportamento gerais.

forward[[transformers.AlignVisionModel.forward]]

forward(pixel_values: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)

Origem

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 EfficientNetImageProcessor. Consulte EfficientNetImageProcessor.call() para obter detalhes (AlignProcessor usa EfficientNetImageProcessor para processar imagens).

Retorna: BaseModelOutputWithPoolingAndNoAttention ou tuple(torch.Tensor)

Um BaseModelOutputWithPoolingAndNoAttention 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 (AlignConfig) e das entradas.

O método forward do AlignVisionModel sobrescreve o método especial __call__.

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

• last_hidden_state (torch.Tensor de forma (batch_size, num_channels, height, width)) -- 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 após uma operação de pooling nas dimensões espaciais.

• hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) -- Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma (batch_size, num_channels, height, width).

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

Exemplos:

>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoProcessor, AlignVisionModel

>>> model = AlignVisionModel.from_pretrained("kakaobrain/align-base")
>>> processor = AutoProcessor.from_pretrained("kakaobrain/align-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> inputs = processor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled CLS states