Transformers documentation
AltCLIP
Este modelo se publicó en HF papers el 12-11-2022 y se contribuyó a Hugging Face Transformers el 04-01-2023.
AltCLIP
AltCLIP reemplaza el codificador de texto de CLIP con un codificador XLM-R multilingüe y alinea las representaciones de imagen y texto mediante aprendizaje con maestro y aprendizaje contrastivo.
Puedes encontrar todos los puntos de control originales de AltCLIP en la colección AltClip.
Haz clic en los modelos de AltCLIP en la barra lateral derecha para ver más ejemplos de cómo aplicar AltCLIP a diferentes tareas.
Los ejemplos a continuación demuestran cómo calcular puntuaciones de similitud entre una imagen y una o más descripciones con la clase AutoModel.
import requests
from PIL import Image
from transformers import AltCLIPModel, AltCLIPProcessor
model = AltCLIPModel.from_pretrained("BAAI/AltCLIP", device_map="auto")
processor = AltCLIPProcessor.from_pretrained("BAAI/AltCLIP")
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
image = Image.open(requests.get(url, stream=True).raw)
inputs = processor(text=["a photo of a cat", "a photo of a dog"], images=image, return_tensors="pt", padding=True).to(model.device)
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
labels = ["a photo of a cat", "a photo of a dog"]
for label, prob in zip(labels, probs[0]):
print(f"{label}: {prob.item():.4f}")La cuantización reduce la carga de memoria de los modelos grandes al representar los pesos con una precisión inferior. Consulte el resumen de Cuantización para conocer más backends de cuantización disponibles.
El ejemplo siguiente utiliza torchao para cuantizar únicamente los pesos a int4.
# !pip install torchao
import requests
from PIL import Image
from transformers import AltCLIPModel, AltCLIPProcessor, TorchAoConfig
model = AltCLIPModel.from_pretrained(
"BAAI/AltCLIP",
quantization_config=TorchAoConfig("int4_weight_only", group_size=128),
device_map="auto",
)
processor = AltCLIPProcessor.from_pretrained("BAAI/AltCLIP")
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
image = Image.open(requests.get(url, stream=True).raw)
inputs = processor(text=["a photo of a cat", "a photo of a dog"], images=image, return_tensors="pt", padding=True).to(model.device)
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
labels = ["a photo of a cat", "a photo of a dog"]
for label, prob in zip(labels, probs[0]):
print(f"{label}: {prob.item():.4f}")Notas
- AltCLIP usa atención bidireccional en lugar de atención causal y utiliza el token
[CLS]de XLM-R para representar un embedding de texto. - Use CLIPImageProcessor para redimensionar (o reescalar) y normalizar las imágenes para el modelo.
- AltCLIPProcessor combina CLIPImageProcessor y XLMRobertaTokenizer en una única instancia para codificar texto y preparar imágenes.
AltCLIPConfig
clase transformers.AltCLIPConfig
< 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 = Nonetext_config: dict | transformers.models.altclip.configuration_altclip.AltCLIPTextConfig | None = Nonevision_config: dict | transformers.models.altclip.configuration_altclip.AltCLIPVisionConfig | None = Noneprojection_dim: int = 768logit_scale_init_value: float | int | None = 2.6592initializer_factor: float | None = 1.0 )
Parámetros
- text_config (
Union[dict, ~models.altclip.configuration_altclip.AltCLIPTextConfig], opcional) — El objeto de configuración o el diccionario del backbone de texto. - vision_config (
Union[dict, ~models.altclip.configuration_altclip.AltCLIPVisionConfig], opcional) — El objeto de configuración o el diccionario del backbone de visión. - projection_dim (
int, opcional, valor predeterminado768) — Dimensionalidad de las capas de proyección de texto y visión. - logit_scale_init_value (
Union[float, int], opcional, valor predeterminado2.6592) — El valor inicial del parámetro logit_scale. - initializer_factor (
float, opcional, valor predeterminado1.0) — Un factor para inicializar todas las matrices de pesos (debe mantenerse en 1, se usa internamente para pruebas de inicialización).
Esta es la clase de configuración para almacenar la configuración de un AltCLIPModel. Se utiliza para instanciar un modelo Altclip según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de BAAI/AltCLIP
Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.
Ejemplo:
>>> from transformers import AltCLIPConfig, AltCLIPModel
>>> # Initializing a AltCLIPConfig with BAAI/AltCLIP style configuration
>>> configuration = AltCLIPConfig()
>>> # Initializing a AltCLIPModel (with random weights) from the BAAI/AltCLIP style configuration
>>> model = AltCLIPModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
>>> # We can also initialize a AltCLIPConfig from a AltCLIPTextConfig and a AltCLIPVisionConfig
>>> # Initializing a AltCLIPText and AltCLIPVision configuration
>>> config_text = AltCLIPTextConfig()
>>> config_vision = AltCLIPVisionConfig()
>>> config = AltCLIPConfig(text_config=config_text, vision_config=config_vision)AltCLIPTextConfig
clase transformers.AltCLIPTextConfig
< 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 = Nonevocab_size: int = 250002hidden_size: int = 1024intermediate_size: int = 4096num_hidden_layers: int = 24num_attention_heads: int = 16max_position_embeddings: int = 514hidden_act: str = 'gelu'layer_norm_eps: float | None = 1e-05initializer_range: float = 0.02initializer_factor: float = 0.02pad_token_id: int | None = 1bos_token_id: int | None = 0eos_token_id: int | None = 2hidden_dropout_prob: int | float = 0.1attention_probs_dropout_prob: int | float = 0type_vocab_size: int = 1project_dim: int = 768 )
Parámetros
- vocab_size (
int, opcional, valor predeterminado250002) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse medianteinput_ids. - hidden_size (
int, opcional, valor predeterminado1024) — Dimensión de las representaciones ocultas. - intermediate_size (
int, opcional, valor predeterminado4096) — Dimensión de las representaciones del MLP. - num_hidden_layers (
int, opcional, valor predeterminado24) — Número de capas ocultas en el decodificador del Transformer. - num_attention_heads (
int, opcional, valor predeterminado16) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer. - max_position_embeddings (
int, opcional, valor predeterminado514) — La longitud máxima de secuencia con la que se podría utilizar este modelo. - hidden_act (
str, opcional, valor predeterminadogelu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo,"gelu","relu","silu", etc. - layer_norm_eps (
float, opcional, valor predeterminado1e-05) — El epsilon utilizado por las capas de normalización de capa. - initializer_range (
float, opcional, valor predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos. - initializer_factor (
float, opcional, valor predeterminado0.02) — Un factor para inicializar todas las matrices de pesos (debe mantenerse en 1, se usa internamente para pruebas de inicialización). - pad_token_id (
int, opcional, valor predeterminado1) — Id del token utilizado para el relleno en el vocabulario. - bos_token_id (
int, opcional, valor predeterminado0) — Id del token utilizado para el inicio de la secuencia en el vocabulario. - eos_token_id (
int, opcional, valor predeterminado2) — Id del token utilizado para el fin de secuencia en el vocabulario. - hidden_dropout_prob (
Union[int, float], opcional, valor predeterminado0.1) — La probabilidad de dropout para todas las capas completamente conectadas en las incrustaciones, el codificador y el pooler. - attention_probs_dropout_prob (
Union[int, float], opcional, valor predeterminado0) — La proporción de dropout para las probabilidades de atención. - type_vocab_size (
int, opcional, valor predeterminado1) — El tamaño del vocabulario detoken_type_ids. - project_dim (
int, opcional, valor predeterminado 768) — Las dimensiones del modelo maestro antes de la capa de mapeo.
Esta es la clase de configuración para almacenar la configuración de un AltCLIPModel. Se utiliza para instanciar un modelo Altclip según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de BAAI/AltCLIP
Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.
Ejemplos:
>>> from transformers import AltCLIPTextModel, AltCLIPTextConfig
>>> # Initializing a AltCLIPTextConfig with BAAI/AltCLIP style configuration
>>> configuration = AltCLIPTextConfig()
>>> # Initializing a AltCLIPTextModel (with random weights) from the BAAI/AltCLIP style configuration
>>> model = AltCLIPTextModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configAltCLIPVisionConfig
clase transformers.AltCLIPVisionConfig
< 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 = 768intermediate_size: int = 3072projection_dim: int = 512num_hidden_layers: int = 12num_attention_heads: int = 12num_channels: int = 3image_size: int | list[int] | tuple[int, int] | None = 224patch_size: int | list[int] | tuple[int, int] | None = 32hidden_act: str = 'quick_gelu'layer_norm_eps: float = 1e-05attention_dropout: int | float | None = 0.0initializer_range: float = 0.02initializer_factor: float = 1.0 )
Parámetros
- hidden_size (
int, opcional, valor predeterminado768) — Dimensión de las representaciones ocultas. - intermediate_size (
int, opcional, valor predeterminado3072) — Dimensión de las representaciones del MLP. - projection_dim (
int, opcional, valor predeterminado512) — Dimensionalidad de las capas de proyección de texto y visión. - num_hidden_layers (
int, opcional, valor predeterminado12) — Número de capas ocultas en el decodificador del Transformer. - num_attention_heads (
int, opcional, valor predeterminado12) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer. - num_channels (
int, opcional, valor predeterminado3) — El número de canales de entrada. - image_size (
Union[int, list[int], tuple[int, int]], opcional, valor predeterminado224) — El tamaño (resolución) de cada imagen. - patch_size (
Union[int, list[int], tuple[int, int]], opcional, valor predeterminado32) — El tamaño (resolución) de cada parche. - hidden_act (
str, opcional, valor predeterminadoquick_gelu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo,"gelu","relu","silu", etc. - layer_norm_eps (
float, opcional, valor predeterminado1e-05) — El epsilon utilizado por las capas de normalización de capa. - attention_dropout (
Union[int, float], opcional, valor predeterminado0.0) — La proporción de dropout para las probabilidades de atención. - initializer_range (
float, opcional, valor predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos. - initializer_factor (
float, opcional, valor predeterminado1.0) — Un factor para inicializar todas las matrices de pesos (debe mantenerse en 1, se usa internamente para pruebas de inicialización).
Esta es la clase de configuración para almacenar la configuración de un AltCLIPModel. Se utiliza para instanciar un modelo Altclip según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de BAAI/AltCLIP
Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.
Ejemplo:
>>> from transformers import AltCLIPVisionConfig, AltCLIPVisionModel
>>> # Initializing a AltCLIPVisionConfig with BAAI/AltCLIP style configuration
>>> configuration = AltCLIPVisionConfig()
>>> # Initializing a AltCLIPVisionModel (with random weights) from the BAAI/AltCLIP style configuration
>>> model = AltCLIPVisionModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configAltCLIPModel
clase transformers.AltCLIPModel
< source >( config: AltCLIPConfig )
Parámetros
- config (AltCLIPConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El modelo Altclip básico que emite estados ocultos sin ningún cabezal específico en la parte superior.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.FloatTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonereturn_loss: bool | None = Noneinterpolate_pos_encoding: bool = False**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → AltCLIPOutput or tuple(torch.FloatTensor)
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- pixel_values (
torch.FloatTensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando CLIPImageProcessor. Consulte CLIPImageProcessor.call() para más detalles (AltCLIPProcessor utiliza CLIPImageProcessor para procesar las imágenes). - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - return_loss (
bool, opcional) — Indica si se debe devolver la pérdida contrastiva. - interpolate_pos_encoding (
bool, opcional, valor predeterminadoFalse) — Si se debe interpolar las codificaciones de posición preentrenadas.
Devuelve
AltCLIPOutput o tuple(torch.FloatTensor)
Un AltCLIPOutput o una tupla de
torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (AltCLIPConfig) y las entradas.
El método forward de AltCLIPModel reemplaza el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
- loss (
torch.FloatTensorde forma(1,), opcional, devuelta cuandoreturn_lossesTrue) — Pérdida contrastiva para la similitud imagen-texto. - logits_per_image (
torch.FloatTensorde forma(image_batch_size, text_batch_size)) — Las puntuaciones de producto punto escalado entreimage_embedsytext_embeds. Esto representa las puntuaciones de similitud entre imagen y texto. - logits_per_text (
torch.FloatTensorde forma(text_batch_size, image_batch_size)) — Las puntuaciones de producto punto escalado entretext_embedsyimage_embeds. Esto representa las puntuaciones de similitud texto-imagen. - text_embeds (
torch.FloatTensorde forma(batch_size, output_dim) — Las incrustaciones de texto obtenidas al aplicar la capa de proyección a la salida agrupada de AltCLIPTextModel. - image_embeds (
torch.FloatTensorde forma(batch_size, output_dim) — Los embeddings de imagen obtenidos al aplicar la capa de proyección a la salida agrupada de AltCLIPVisionModel. - text_model_output (
~modeling_outputs.BaseModelOutputWithPooling, opcional) — La salida del AltCLIPTextModel. - vision_model_output (
~modeling_outputs.BaseModelOutputWithPooling, opcional) — La salida del AltCLIPVisionModel.
Ejemplos:
>>> import torch
>>> from transformers import AutoProcessor, AltCLIPModel
>>> from transformers.image_utils import load_image
>>> model = AltCLIPModel.from_pretrained("OFA-Sys/chinese-clip-vit-base-patch16")
>>> processor = AutoProcessor.from_pretrained("OFA-Sys/chinese-clip-vit-base-patch16")
>>> url = "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/pokemon.jpeg"
>>> image = load_image(url)
>>> inputs = processor(text=["杰尼龟", "妙蛙种子", "小火龙", "皮卡丘"], images=image, 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 probabilitiesget_image_features
< source >( pixel_values: FloatTensorinterpolate_pos_encoding: bool = False**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.FloatTensor)
Parámetros
- pixel_values (
torch.FloatTensorde forma(batch_size, num_channels, image_size, image_size)) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando CLIPImageProcessor. Consulte CLIPImageProcessor.call() para más detalles (AltCLIPProcessor utiliza CLIPImageProcessor para procesar las imágenes). - interpolate_pos_encoding (
bool, opcional, valor predeterminadoFalse) — Si se debe interpolar las codificaciones de posición preentrenadas.
Devuelve
BaseModelOutputWithPooling o tuple(torch.FloatTensor)
Un BaseModelOutputWithPooling o una tupla de
torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (AltCLIPConfig) y las entradas.
last_hidden_state (
torch.FloatTensorde forma(batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.pooler_output (
torch.FloatTensorde forma(batch_size, hidden_size)) — Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.hidden_states (
tuple(torch.FloatTensor), opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (
tuple(torch.FloatTensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplos:
>>> import torch
>>> from transformers import AutoProcessor, AltCLIPModel
>>> from transformers.image_utils import load_image
>>> model = AltCLIPModel.from_pretrained("BAAI/AltCLIP")
>>> processor = AutoProcessor.from_pretrained("BAAI/AltCLIP")
>>> 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)get_text_features
< source >( input_ids: Tensorattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.FloatTensor)
Parámetros
- input_ids (
torch.Tensorde forma(batch_size, sequence_length)) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- position_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1].
Devuelve
BaseModelOutputWithPooling o tuple(torch.FloatTensor)
Un BaseModelOutputWithPooling o una tupla de
torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (AltCLIPConfig) y las entradas.
last_hidden_state (
torch.FloatTensorde forma(batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.pooler_output (
torch.FloatTensorde forma(batch_size, hidden_size)) — Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.hidden_states (
tuple(torch.FloatTensor), opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (
tuple(torch.FloatTensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplos:
>>> import torch
>>> from transformers import AutoProcessor, AltCLIPModel
>>> model = AltCLIPModel.from_pretrained("BAAI/AltCLIP")
>>> processor = AutoProcessor.from_pretrained("BAAI/AltCLIP")
>>> inputs = processor(text=["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)AltCLIPTextModel
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPoolingAndProjection or tuple(torch.FloatTensor)
Parámetros
- input_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- position_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.
Devuelve
BaseModelOutputWithPoolingAndProjection o tuple(torch.FloatTensor)
Un BaseModelOutputWithPoolingAndProjection o una tupla de
torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (AltCLIPConfig) y las entradas.
El método forward de AltCLIPTextModel reemplaza el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
last_hidden_state (
torch.FloatTensorde forma(batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.pooler_output (
torch.FloatTensorde forma(batch_size, hidden_size)) — Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.hidden_states (
tuple(torch.FloatTensor), opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (
tuple(torch.FloatTensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
projection_state (
tuple(torch.FloatTensor), devuelto cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.FloatTensorde forma(batch_size,config.project_dim).Embeddings de texto antes de la capa de proyección, utilizados para imitar el último estado oculto del codificador maestro.
Ejemplos:
>>> from transformers import AutoProcessor, AltCLIPTextModel
>>> model = AltCLIPTextModel.from_pretrained("BAAI/AltCLIP")
>>> processor = AutoProcessor.from_pretrained("BAAI/AltCLIP")
>>> texts = ["it's a cat", "it's a dog"]
>>> inputs = processor(text=texts, padding=True, return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output # pooled CLS statesAltCLIPVisionModel
clase transformers.AltCLIPVisionModel
< source >( config: AltCLIPVisionConfig )
Parámetros
- config (AltCLIPVisionConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El modelo de visión de ALTCLIP sin ninguna cabeza ni proyección en la parte superior.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( pixel_values: typing.Optional[torch.FloatTensor] = Noneinterpolate_pos_encoding: bool | None = False**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.FloatTensor)
Parámetros
- pixel_values (
torch.FloatTensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando CLIPImageProcessor. Consulte CLIPImageProcessor.call() para más detalles (AltCLIPProcessor utiliza CLIPImageProcessor para procesar las imágenes). - interpolate_pos_encoding (
bool, opcional, valor predeterminadoFalse) — Si se debe interpolar las codificaciones de posición preentrenadas.
Devuelve
BaseModelOutputWithPooling o tuple(torch.FloatTensor)
Un BaseModelOutputWithPooling o una tupla de
torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (AltCLIPConfig) y las entradas.
El método forward de AltCLIPVisionModel reemplaza el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
last_hidden_state (
torch.FloatTensorde forma(batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.pooler_output (
torch.FloatTensorde forma(batch_size, hidden_size)) — Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.hidden_states (
tuple(torch.FloatTensor), opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (
tuple(torch.FloatTensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplos:
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from PIL import Image
>>> from transformers import AutoProcessor, AltCLIPVisionModel
>>> model = AltCLIPVisionModel.from_pretrained("BAAI/AltCLIP")
>>> processor = AutoProcessor.from_pretrained("BAAI/AltCLIP")
>>> 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 statesAltCLIPProcessor
clase transformers.AltCLIPProcessor
< source >( image_processor = Nonetokenizer = None )
Construye un AltCLIPProcessor que envuelve un procesador de imágenes y un tokenizador en un único procesador.
AltCLIPProcessor ofrece todas las funcionalidades de CLIPImageProcessor y tokenizer_class. Consulte ~CLIPImageProcessor y ~tokenizer_class para obtener más información.
__call__
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: str | list[str] | list[list[str]] | None = Nonevideos: 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] = Noneaudio: 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'> )
Parámetros
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], opcional) — Imagen a preprocesar. Espera una imagen única o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezcado_rescale=False. - text (
Union[str, list[str], list[list[str]]], opcional) — La secuencia o lote de secuencias que se codificarán. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas de caracteres (cadenas pre-tokenizadas). Si se pasa una entrada pre-tokenizada, establezcais_split_into_words=Truepara evitar ambigüedad con las entradas por lotes. - 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 a preprocesar. Espera un único vídeo o un lote de vídeos con valores de píxeles que van de 0 a 255. Si se pasan vídeos con valores de píxeles entre 0 y 1, establecedo_rescale=False. - audio (
Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]], opcional) — El audio o lote de audios que se va a preparar. Cada audio puede ser un array de NumPy o un tensor de PyTorch. En el caso de un array de NumPy/tensor de PyTorch, cada audio debe tener la forma (C, T), donde C es el número de canales y T es la longitud de la muestra del audio. - return_tensors (
stro TensorType, opcional) — Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:'pt': Devuelve objetostorch.Tensorde PyTorch.'np': Devuelve objetosnp.ndarrayde NumPy.
- **kwargs (ProcessingKwargs, opcional) — Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, videos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.