# BLIP-2 ## Resumen El modelo BLIP-2 fue propuesto en [BLIP-2: Bootstrapping Language-Image Pre-training with Frozen Image Encoders and Large Language Models](https://huggingface.co/papers/2301.12597) por Junnan Li, Dongxu Li, Silvio Savarese y Steven Hoi. BLIP-2 aprovecha codificadores de imagen preentrenados congelados y modelos de lenguaje de gran escala (LLM) mediante el entrenamiento de un codificador Transformer ligero de 12 capas entre ellos, logrando un rendimiento de última generación en diversas tareas de visión-lenguaje. En particular, BLIP-2 supera a [Flamingo](https://huggingface.co/papers/2204.14198), un modelo de 80 mil millones de parámetros, en un 8,7 % en VQAv2 zero-shot, con 54 veces menos parámetros entrenables. El resumen del artículo es el siguiente: *El costo del preentrenamiento de visión y lenguaje se ha vuelto cada vez más prohibitivo debido al entrenamiento extremo a extremo de modelos a gran escala. Este artículo propone BLIP-2, una estrategia de preentrenamiento genérica y eficiente que aprovecha el preentrenamiento de visión y lenguaje a partir de codificadores de imagen preentrenados y congelados, así como de modelos de lenguaje grandes congelados. BLIP-2 supera la brecha entre modalidades mediante un Querying Transformer ligero, que se preentrena en dos etapas. La primera etapa aprovecha el aprendizaje de representaciones de visión y lenguaje a partir de un codificador de imagen congelado. La segunda etapa aprovecha el aprendizaje generativo de visión a lenguaje a partir de un modelo de lenguaje congelado. BLIP-2 logra un rendimiento líder en diversas tareas de visión y lenguaje, a pesar de tener significativamente menos parámetros entrenables que los métodos existentes. Por ejemplo, nuestro modelo supera a Flamingo80B en un 8,7 % en VQAv2 sin ejemplos, con 54 veces menos parámetros entrenables. También demostramos las capacidades emergentes del modelo para la generación de texto a partir de imágenes sin ejemplos, que puede seguir instrucciones en lenguaje natural.* drawing Arquitectura de BLIP-2. Tomada del artículo original. Este modelo fue aportado por [nielsr](https://huggingface.co/nielsr). El código original se puede encontrar [aquí](https://github.com/salesforce/LAVIS/tree/5ee63d688ba4cebff63acee04adaef2dee9af207). ## Consejos de uso - BLIP-2 se puede utilizar para la generación de texto condicional a partir de una imagen y un prompt de texto opcional. En el momento de la inferencia, se recomienda utilizar el método `generate`. - Se puede usar [Blip2Processor](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Processor) para preparar las imágenes para el modelo y decodificar los IDs de tokens predichos de vuelta a texto. > [!NOTE] > Los modelos BLIP posteriores a la versión v4.46 emitirán advertencias sobre la adición de `processor.num_query_tokens = {{num_query_tokens}}` y la expansión de la capa de embeddings del modelo para añadir el token especial ``. Se recomienda encarecidamente añadir los atributos al procesador si usted es el propietario del checkpoint del modelo, o abrir un PR si no lo es. Añadir estos atributos significa que BLIP añadirá el número de tokens de consulta requeridos por imagen y expandirá el texto con tantos marcadores de posición `` como tokens de consulta haya. Normalmente son unos 500 tokens por imagen, así que asegúrese de que el texto no se trunca, ya que de lo contrario habrá un fallo al fusionar los embeddings. Los atributos se pueden obtener desde la configuración del modelo, como `model.config.num_query_tokens`, y la expansión de los embeddings del modelo se puede realizar siguiendo [este enlace](https://gist.github.com/zucchini-nlp/e9f20b054fa322f84ac9311d9ab67042). ## Recursos Una lista de recursos oficiales de Hugging Face y de la comunidad (indicados por 🌎) para ayudarte a empezar con BLIP-2. - Los cuadernos de demostración de BLIP-2 para la descripción de imágenes, la respuesta a preguntas visuales (VQA) y las conversaciones tipo chat se pueden encontrar [aquí](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/BLIP-2). Si te interesa enviar un recurso para que se incluya aquí, no dudes en abrir una Pull Request y lo revisaremos. Lo ideal es que el recurso demuestre algo nuevo en lugar de duplicar un recurso existente. ## Blip2Config[[transformers.Blip2Config]] #### transformers.Blip2Config[[transformers.Blip2Config]] ```python transformers.Blip2Config(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, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, qformer_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, num_query_tokens: int = 32, image_text_hidden_size: int = 256, image_token_index: int | None = None, initializer_factor: float = 1.0, initializer_range: float = 0.02) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/configuration_blip_2.py#L107) **Parámetros:** vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : El objeto de configuración o el diccionario del backbone de visión. qformer_config (`dict`, *opcional*) : Diccionario de opciones de configuración utilizado para inicializar [Blip2QFormerConfig](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2QFormerConfig). text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : El objeto de configuración o el diccionario del backbone de texto. num_query_tokens (`int`, *opcional*, valor predeterminado: 32) : El número de tokens de consulta que se pasan a través del Transformer. image_text_hidden_size (`int`, *opcional*, valor predeterminado 256) : Dimensionalidad del estado oculto de la capa de fusión de imagen y texto. image_token_index (`int`, *opcional*) : El índice del token de imagen utilizado como marcador de posición para las imágenes de entrada. initializer_factor (`float`, *opcional*, valor predeterminado `1.0`) : Un factor para inicializar todas las matrices de pesos (debe mantenerse en 1, se usa internamente para pruebas de inicialización). initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos. Esta es la clase de configuración para almacenar la configuración de un modelo Blip 2. Se utiliza para instanciar un modelo Blip 2 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 [Salesforce/blip2-opt-2.7b](https://huggingface.co/Salesforce/blip2-opt-2.7b) Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. Ejemplo: ```python >>> from transformers import ( ... Blip2VisionConfig, ... Blip2QFormerConfig, ... OPTConfig, ... Blip2Config, ... Blip2ForConditionalGeneration, ... ) >>> # Initializing a Blip2Config with Salesforce/blip2-opt-2.7b style configuration >>> configuration = Blip2Config() >>> # Initializing a Blip2ForConditionalGeneration (with random weights) from the Salesforce/blip2-opt-2.7b style configuration >>> model = Blip2ForConditionalGeneration(configuration) >>> # Accessing the model configuration >>> configuration = model.config >>> # We can also initialize a Blip2Config from a Blip2VisionConfig, Blip2QFormerConfig and any PreTrainedConfig >>> # Initializing BLIP-2 vision, BLIP-2 Q-Former and language model configurations >>> vision_config = Blip2VisionConfig() >>> qformer_config = Blip2QFormerConfig() >>> text_config = OPTConfig() >>> config = Blip2Config(vision_config=vision_config, qformer_config=qformer_config, text_config=text_config) ``` ## Blip2VisionConfig[[transformers.Blip2VisionConfig]] #### transformers.Blip2VisionConfig[[transformers.Blip2VisionConfig]] ```python transformers.Blip2VisionConfig(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, hidden_size: int = 1408, intermediate_size: int = 6144, num_hidden_layers: int = 39, num_attention_heads: int = 16, image_size: int | list[int] | tuple[int, int] = 224, patch_size: int | list[int] | tuple[int, int] = 14, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-06, attention_dropout: float | int = 0.0, initializer_range: float = 1e-10, qkv_bias: bool = True) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/configuration_blip_2.py#L29) **Parámetros:** hidden_size (`int`, *opcional*, valor predeterminado `1408`) : Dimensión de las representaciones ocultas. intermediate_size (`int`, *opcional*, valor predeterminado `6144`) : Dimensión de las representaciones MLP. num_hidden_layers (`int`, *opcional*, valor predeterminado `39`) : Número de capas ocultas en el decodificador del Transformer. num_attention_heads (`int`, *opcional*, valor predeterminado `16`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer. image_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, valor predeterminado `224`) : El tamaño (resolución) de cada imagen. patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, valor predeterminado `14`) : El tamaño (resolución) de cada parche. hidden_act (`str`, *opcional*, valor predeterminado `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 predeterminado `1e-06`) : El epsilon utilizado por las capas de normalización de capas. attention_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción de dropout para las probabilidades de atención. initializer_range (`float`, *opcional*, valor predeterminado `1e-10`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos. qkv_bias (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe añadir un sesgo a las consultas, claves y valores. Esta es la clase de configuración para almacenar la configuración de un modelo Blip 2. Se utiliza para instanciar un modelo Blip 2 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 [Salesforce/blip2-opt-2.7b](https://huggingface.co/Salesforce/blip2-opt-2.7b) Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. Ejemplo: ```python >>> from transformers import Blip2VisionConfig, Blip2VisionModel >>> # Initializing a Blip2VisionConfig with Salesforce/blip2-opt-2.7b style configuration >>> configuration = Blip2VisionConfig() >>> # Initializing a Blip2VisionModel (with random weights) from the Salesforce/blip2-opt-2.7b style configuration >>> model = Blip2VisionModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Blip2QFormerConfig[[transformers.Blip2QFormerConfig]] #### transformers.Blip2QFormerConfig[[transformers.Blip2QFormerConfig]] ```python transformers.Blip2QFormerConfig(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, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, cross_attention_frequency: int = 2, encoder_hidden_size: int = 1408, use_qformer_text_input: bool = False) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/configuration_blip_2.py#L64) **Parámetros:** vocab_size (`int`, *opcional*, valor predeterminado `30522`) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`. hidden_size (`int`, *opcional*, valor predeterminado `768`) : Dimensión de las representaciones ocultas. num_hidden_layers (`int`, *opcional*, valor predeterminado `12`) : Número de capas ocultas en el decodificador del Transformer. num_attention_heads (`int`, *opcional*, valor predeterminado `12`) : Número de cabezas de atención para cada capa de atención en el decodificador Transformer. intermediate_size (`int`, *opcional*, valor predeterminado `3072`) : Dimensión de las representaciones MLP. hidden_act (`str`, *opcional*, valor predeterminado `gelu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc. hidden_dropout_prob (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La probabilidad de dropout para todas las capas totalmente conectadas en los embeddings, el codificador y el pooler. attention_probs_dropout_prob (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La proporción de dropout para las probabilidades de atención. max_position_embeddings (`int`, *opcional*, valor predeterminado `512`) : La longitud máxima de secuencia con la que se podría utilizar este modelo. initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos. layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-12`) : El epsilon utilizado por las capas de normalización de capas. pad_token_id (`int`, *opcional*, valor predeterminado `0`) : Id de token utilizado para el relleno en el vocabulario. cross_attention_frequency (`int`, *opcional*, valor predeterminado 2) : La frecuencia con la que se añade atención cruzada a las capas del Transformer. encoder_hidden_size (`int`, *opcional*, valor predeterminado `1408`) : Dimensión de las representaciones ocultas. use_qformer_text_input (`bool`, *opcional*, valor predeterminado `False`) : Si se deben usar embeddings de estilo BERT. Esta es la clase de configuración para almacenar la configuración de un modelo Blip 2. Se utiliza para instanciar un modelo Blip 2 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 [Salesforce/blip2-opt-2.7b](https://huggingface.co/Salesforce/blip2-opt-2.7b) Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. Ejemplos: ```python >>> from transformers import Blip2QFormerConfig, Blip2QFormerModel >>> # Initializing a BLIP-2 Salesforce/blip2-opt-2.7b style configuration >>> configuration = Blip2QFormerConfig() >>> # Initializing a model (with random weights) from the Salesforce/blip2-opt-2.7b style configuration >>> model = Blip2QFormerModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Blip2Processor[[transformers.Blip2Processor]] #### transformers.Blip2Processor[[transformers.Blip2Processor]] ```python transformers.Blip2Processor(image_processor, tokenizer, num_query_tokens = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/processing_blip_2.py#L45) **Parámetros:** image_processor (`BlipImageProcessor`) : El procesador de imágenes es un parámetro de entrada obligatorio. tokenizer (`GPT2Tokenizer`) : El tokenizador es una entrada obligatoria. num_query_tokens (`int`, *opcional*) : Número de tokens utilizados por el Qformer como consultas; debe ser el mismo que en la configuración del modelo. Construye un Blip2Processor que envuelve un procesador de imágenes y un tokenizador en un único procesador. [Blip2Processor](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Processor) ofrece todas las funcionalidades de [BlipImageProcessor](/docs/transformers/main/es/model_doc/blip#transformers.BlipImageProcessor) y [GPT2Tokenizer](/docs/transformers/main/es/model_doc/gpt2#transformers.GPT2Tokenizer). Consulte [~BlipImageProcessor](/docs/transformers/main/es/model_doc/blip#transformers.BlipImageProcessor) y [~GPT2Tokenizer](/docs/transformers/main/es/model_doc/gpt2#transformers.GPT2Tokenizer) para obtener más información. #### __llamada__[[transformers.Blip2Processor.__call__]] ```python __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] | None = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/processing_blip_2.py#L61) **Parámetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *opcional*) : Imagen para 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, establezca `do_rescale=False`. text (`Union[str, list[str]]`, *opcional*) : La secuencia o el lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas de caracteres (cadena pretokenizada). Si se pasa una entrada pretokenizada, establezca `is_split_into_words=True` para evitar ambigüedad con las entradas en lote. return_tensors (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son: - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de NumPy. - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/es/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, vídeos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos. **Devuelve:** `~tokenization_utils_base.BatchEncoding` - **data** (`dict`, *opcional*) -- Diccionario de listas/arrays/tensores devueltos por los métodos `__call__`/`encode_plus`/`batch_encode_plus` ('input_ids', 'attention_mask', etc.). - **encoding** (`tokenizers.Encoding` o `Sequence[tokenizers.Encoding]`, *opcional*) -- Si el tokenizador es un tokenizador rápido que genera información adicional, como el mapeo del espacio de palabras/caracteres al espacio de tokens, la instancia de `tokenizers.Encoding` o la lista de instancias (para lotes) contiene esta información. - **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización. - **prepend_batch_axis** (`bool`, *opcional*, valor predeterminado `False`) -- Indica si se debe añadir un eje de lote al convertir a tensores (consulte `tensor_type` arriba). Tenga en cuenta que este parámetro tiene efecto si el parámetro `tensor_type` está establecido, *en caso contrario no tiene efecto*. - **n_sequences** (`int`, *opcional*) -- El número de secuencias de entrada representadas por cada codificación (`None` para desconocido, `1` para una secuencia única y `2` para un par de secuencias). ## Blip2VisionModel[[transformers.Blip2VisionModel]] #### transformers.Blip2VisionModel[[transformers.Blip2VisionModel]] ```python transformers.Blip2VisionModel(config: Blip2VisionConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L481) **Parámetros:** config ([Blip2VisionConfig](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2VisionConfig)) : 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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo. El modelo Blip 2 básico que genera estados ocultos sin ninguna cabeza específica en la parte superior. Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.Blip2VisionModel.forward]] ```python forward(pixel_values: typing.Optional[torch.Tensor] = None, interpolate_pos_encoding: bool = False, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L501) **Parámetros:** pixel_values (`torch.Tensor` de 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 usando [BlipImageProcessor](/docs/transformers/main/es/model_doc/blip#transformers.BlipImageProcessor). Consulte [BlipImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles ([Blip2Processor](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Processor) utiliza [BlipImageProcessor](/docs/transformers/main/es/model_doc/blip#transformers.BlipImageProcessor) para procesar las imágenes). interpolate_pos_encoding (`bool`, *opcional*, valor predeterminado `False`) : Si se debe interpolar las codificaciones de posición preentrenadas. **Devuelve:** [BaseModelOutputWithPooling](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o `tuple(torch.Tensor)` Un [BaseModelOutputWithPooling](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Blip2Config](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Config)) y las entradas. El método forward de [Blip2VisionModel](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2VisionModel) sobrescribe 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 `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo. - **pooler_output** (`torch.Tensor` de 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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + 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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (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. ## Blip2QFormerModel[[transformers.Blip2QFormerModel]] #### transformers.Blip2QFormerModel[[transformers.Blip2QFormerModel]] ```python transformers.Blip2QFormerModel(config: Blip2QFormerConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L848) **Parámetros:** config ([Blip2QFormerConfig](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2QFormerConfig)) : 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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo. BLIP-2 Querying Transformer (Q-Former). Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.Blip2QFormerModel.forward]] ```python forward(query_embeds: Tensor, query_length: int | None = None, attention_mask: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L885) **Parámetros:** query_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) : Estados ocultos que se utilizarán en el cálculo de la atención. En el caso de atención cruzada, se utilizarán para la consulta (es decir, la clave y el valor usarán encoder_hidden_states). query_length (`int`, *opcional*) : Longitud de la consulta, generalmente basada en el número de tokens de consulta. Si no se proporciona un valor, query_length se inferirá a partir de query_embeds. attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) encoder_hidden_states (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Secuencia de estados ocultos en la salida de la última capa del codificador. Se utiliza en la atención cruzada si el modelo está configurado como decodificador. encoder_attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno de la entrada del codificador. Esta máscara se utiliza en la atención cruzada si el modelo está configurado como decodificador. Valores de máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. **Devuelve:** [BaseModelOutputWithPoolingAndCrossAttentions](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions) o `tuple(torch.Tensor)` Un [BaseModelOutputWithPoolingAndCrossAttentions](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Blip2Config](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Config)) y las entradas. El método forward de [Blip2QFormerModel](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2QFormerModel) sobrescribe 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 `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo. - **pooler_output** (`torch.Tensor` de 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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + 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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (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. - **cross_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` y `config.add_cross_attention=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada. - **past_key_values** (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y, opcionalmente, si `config.is_encoder_decoder=True`, en los bloques de atención cruzada) que pueden utilizarse (véase la entrada `past_key_values`) para acelerar la decodificación secuencial. ## Blip2Model[[transformers.Blip2Model]] #### transformers.Blip2Model[[transformers.Blip2Model]] ```python transformers.Blip2Model(config: Blip2Config) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L957) **Parámetros:** config ([Blip2Config](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Config)) : 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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo. Modelo BLIP-2 para generar texto y características de imagen. El modelo consta de un codificador de visión, un Querying Transformer (Q-Former) y un modelo de lenguaje. Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.Blip2Model.forward]] ```python forward(pixel_values: Tensor, input_ids: Tensor, attention_mask: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, labels: typing.Optional[torch.LongTensor] = None, interpolate_pos_encoding: bool = False, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1152) **Parámetros:** pixel_values (`torch.Tensor` de 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 usando [BlipImageProcessor](/docs/transformers/main/es/model_doc/blip#transformers.BlipImageProcessor). Consulte [BlipImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles ([Blip2Processor](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Processor) utiliza [BlipImageProcessor](/docs/transformers/main/es/model_doc/blip#transformers.BlipImageProcessor) para procesar las imágenes). input_ids (`torch.Tensor` de 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 mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada del decodificador en el vocabulario. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles. [¿Qué son los IDs de entrada del decodificador?](../glossary#decoder-input-ids) decoder_attention_mask (`torch.BoolTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamiento predeterminado: genera un tensor que ignora los tokens de relleno en `decoder_input_ids`. También se usará una máscara causal de forma predeterminada. Solo es relevante en el caso de que se utilice un modelo de lenguaje codificador-decodificador (como T5). labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en `[0, ..., config.vocab_size]` o ser -100 (consulte la docstring de `input_ids`). Los tokens con índices fijados en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`. interpolate_pos_encoding (`bool`, *opcional*, valor predeterminado `False`) : Si se debe interpolar las codificaciones de posición preentrenadas. **Devuelve:** `Blip2ForConditionalGenerationModelOutput` o `tuple(torch.Tensor)` Un `Blip2ForConditionalGenerationModelOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Blip2Config](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Config)) y las entradas. El método forward de [Blip2Model](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Model) sobrescribe 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 `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente. - **loss** (`torch.Tensor`, *opcional*, se devuelve cuando se proporciona `labels`, `torch.Tensor` de forma `(1,)`) -- Pérdida de modelado de lenguaje del modelo de lenguaje. - **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Puntuaciones de predicción de la cabeza de modelado de lenguaje del modelo de lenguaje. - **vision_outputs** (`~modeling_outputs.BaseModelOutputWithPooling`, *opcional*) -- Salidas del codificador de visión. - **qformer_outputs** (`~modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions`, *opcional*) -- Salidas del Q-Former (Querying Transformer). - **language_model_outputs** (`CausalLMOutputWithPast` o `Seq2SeqLMOutput`) -- Salidas del modelo de lenguaje. Ejemplos: ```python >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import Blip2Processor, Blip2Model >>> import torch >>> device = "cuda" if torch.cuda.is_available() else "cpu" >>> processor = Blip2Processor.from_pretrained("Salesforce/blip2-opt-2.7b") >>> model = Blip2Model.from_pretrained("Salesforce/blip2-opt-2.7b", dtype=torch.float16) >>> model.to(device) >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> prompt = "Question: how many cats are there? Answer:" >>> inputs = processor(images=image, text=prompt, return_tensors="pt").to(device, torch.float16) >>> outputs = model(**inputs) ``` #### get_text_features[[transformers.Blip2Model.get_text_features]] ```python get_text_features(input_ids: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.Tensor] = None, decoder_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L994) **Parámetros:** input_ids (`torch.Tensor` de 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 mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada del decodificador en el vocabulario. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada del decodificador?](../glossary#decoder-input-ids) T5 utiliza `pad_token_id` como token inicial para la generación de `decoder_input_ids`. Si se utiliza `past_key_values`, opcionalmente solo se deben introducir los últimos `decoder_input_ids` (consulte `past_key_values`). Para saber más sobre cómo preparar `decoder_input_ids` para el preentrenamiento, eche un vistazo a [T5 Training](./t5#training). decoder_attention_mask (`torch.BoolTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamiento predeterminado: genera un tensor que ignora los tokens de relleno en `decoder_input_ids`. También se usará una máscara causal de forma predeterminada. labels (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en `[0, ..., config.vocab_size]` o ser -100 (ver la docstring de `input_ids`). Los tokens con índices establecidos en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`. **Devuelve:** [BaseModelOutputWithPooling](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o `tuple(torch.Tensor)` Un [BaseModelOutputWithPooling](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Blip2Config](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Config)) y las entradas. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo. - **pooler_output** (`torch.Tensor` de 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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + 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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (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: ```python >>> import torch >>> from transformers import AutoTokenizer, Blip2Model >>> model = Blip2Model.from_pretrained("Salesforce/blip2-opt-2.7b") >>> tokenizer = AutoTokenizer.from_pretrained("Salesforce/blip2-opt-2.7b") >>> inputs = tokenizer(["a photo of a cat"], padding=True, return_tensors="pt") >>> with torch.inference_mode(): ... text_features = model.get_text_features(**inputs) ``` #### get_image_features[[transformers.Blip2Model.get_image_features]] ```python get_image_features(pixel_values: Tensor, interpolate_pos_encoding: bool = False, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1056) **Parámetros:** pixel_values (`torch.Tensor` de 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 usando [BlipImageProcessor](/docs/transformers/main/es/model_doc/blip#transformers.BlipImageProcessor). Consulte [BlipImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles ([Blip2Processor](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Processor) utiliza [BlipImageProcessor](/docs/transformers/main/es/model_doc/blip#transformers.BlipImageProcessor) para procesar las imágenes). interpolate_pos_encoding (`bool`, *opcional*, valor predeterminado `False`) : Si se debe interpolar las codificaciones de posición preentrenadas. **Devuelve:** [BaseModelOutputWithPooling](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o `tuple(torch.Tensor)` Un [BaseModelOutputWithPooling](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Blip2Config](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Config)) y las entradas. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo. - **pooler_output** (`torch.Tensor` de 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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + 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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (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: ```python >>> import torch >>> from transformers import AutoProcessor, Blip2Model >>> from transformers.image_utils import load_image >>> model = Blip2Model.from_pretrained("Salesforce/blip2-opt-2.7b") >>> processor = AutoProcessor.from_pretrained("Salesforce/blip2-opt-2.7b") >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> image = load_image(url) >>> inputs = processor(images=image, return_tensors="pt") >>> with torch.inference_mode(): ... image_outputs = model.get_image_features(**inputs) ``` #### get_qformer_features[[transformers.Blip2Model.get_qformer_features]] ```python get_qformer_features(pixel_values: Tensor, interpolate_pos_encoding: bool = False) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1087) **Parámetros:** pixel_values (`torch.Tensor` de 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 usando [BlipImageProcessor](/docs/transformers/main/es/model_doc/blip#transformers.BlipImageProcessor). Consulte [BlipImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles ([Blip2Processor](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Processor) utiliza [BlipImageProcessor](/docs/transformers/main/es/model_doc/blip#transformers.BlipImageProcessor) para procesar las imágenes). interpolate_pos_encoding (`bool`, *opcional*, valor predeterminado `False`) : Si se debe interpolar las codificaciones de posición preentrenadas. **Devuelve:** qformer_outputs (`torch.Tensor`) Los estados ocultos de la última capa del modelo Q-Former. Ejemplos: ```python >>> import torch >>> from transformers import AutoProcessor, Blip2Model >>> from transformers.image_utils import load_image >>> processor = Blip2Processor.from_pretrained("Salesforce/blip2-opt-2.7b") >>> model = Blip2Model.from_pretrained("Salesforce/blip2-opt-2.7b") >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> image = load_image(url) >>> inputs = processor(images=image, return_tensors="pt") >>> with torch.inference_mode(): ... qformer_outputs = model.get_qformer_features(**inputs) ``` ## Blip2ForConditionalGeneration[[transformers.Blip2ForConditionalGeneration]] #### transformers.Blip2ForConditionalGeneration[[transformers.Blip2ForConditionalGeneration]] ```python transformers.Blip2ForConditionalGeneration(config: Blip2Config) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1460) **Parámetros:** config ([Blip2Config](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Config)) : 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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo. Modelo BLIP-2 para generar texto a partir de una imagen y un prompt de texto opcional. El modelo consta de un codificador de visión, un Querying Transformer (Q-Former) y un modelo de lenguaje. Opcionalmente, se puede pasar `input_ids` al modelo, que actúa como un texto de indicación, para que el modelo de lenguaje continúe la indicación. De lo contrario, el modelo de lenguaje comienza a generar texto desde el token [BOS] (inicio de secuencia). Tenga en cuenta que los puntos de control de Flan-T5 no se pueden convertir a float16. Se preentrenaron utilizando bfloat16. Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.Blip2ForConditionalGeneration.forward]] ```python forward(pixel_values: Tensor, input_ids: LongTensor, attention_mask: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, interpolate_pos_encoding: bool = False, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1587) **Parámetros:** pixel_values (`torch.Tensor` de 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 usando [BlipImageProcessor](/docs/transformers/main/es/model_doc/blip#transformers.BlipImageProcessor). Consulte [BlipImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles ([Blip2Processor](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Processor) utiliza [BlipImageProcessor](/docs/transformers/main/es/model_doc/blip#transformers.BlipImageProcessor) para procesar las imágenes). input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario del modelo de lenguaje. Los tokens de entrada pueden proporcionarse opcionalmente para servir como texto de indicación, que el modelo de lenguaje puede continuar. Los índices se pueden obtener usando [Blip2Processor](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Processor). Consulte [Blip2Processor.__call__()](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Processor.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada del decodificador en el vocabulario. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles. [¿Qué son los IDs de entrada del decodificador?](../glossary#decoder-input-ids) decoder_attention_mask (`torch.BoolTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamiento predeterminado: genera un tensor que ignora los tokens de relleno en `decoder_input_ids`. También se usará una máscara causal de forma predeterminada. Solo es relevante en el caso de que se utilice un modelo de lenguaje codificador-decodificador (como T5). inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en `[0, ..., config.vocab_size]` o ser -100 (consulte la docstring de `input_ids`). Los tokens con índices fijados en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`. interpolate_pos_encoding (`bool`, *opcional*, valor predeterminado `False`) : Si se debe interpolar las codificaciones de posición preentrenadas. mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opcional*) : Diccionario donde las claves son las modalidades admitidas y los valores son las salidas codificadas para esa modalidad. Cada salida codificada es una tupla que consiste en (`pooler_output`, *opcional*: `last_hidden_states`, *opcional*: `hidden_states`, *opcional*: `attentions`) `pooler_output` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) es una secuencia de características multimodales del codificador fusionadas en las incrustaciones de texto. **Devuelve:** `Blip2ForConditionalGenerationModelOutput` o `tuple(torch.Tensor)` Un `Blip2ForConditionalGenerationModelOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Blip2Config](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Config)) y las entradas. El método forward de [Blip2ForConditionalGeneration](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2ForConditionalGeneration) sobrescribe 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 `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente. - **loss** (`torch.Tensor`, *opcional*, se devuelve cuando se proporciona `labels`, `torch.Tensor` de forma `(1,)`) -- Pérdida de modelado de lenguaje del modelo de lenguaje. - **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Puntuaciones de predicción de la cabeza de modelado de lenguaje del modelo de lenguaje. - **vision_outputs** (`~modeling_outputs.BaseModelOutputWithPooling`, *opcional*) -- Salidas del codificador de visión. - **qformer_outputs** (`~modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions`, *opcional*) -- Salidas del Q-Former (Querying Transformer). - **language_model_outputs** (`CausalLMOutputWithPast` o `Seq2SeqLMOutput`) -- Salidas del modelo de lenguaje. Ejemplos: Preparar el procesador, el modelo y la entrada de imagen ```python >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import Blip2Processor, Blip2ForConditionalGeneration >>> import torch >>> device = "cuda" if torch.cuda.is_available() else "cpu" >>> processor = Blip2Processor.from_pretrained("Salesforce/blip2-opt-2.7b") >>> model = Blip2ForConditionalGeneration.from_pretrained( ... "Salesforce/blip2-opt-2.7b", load_in_8bit=True, device_map={"": 0}, dtype=torch.float16 ... ) # doctest: +IGNORE_RESULT >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) ``` Descripción de imágenes (sin proporcionar un texto de entrada): ```python >>> inputs = processor(images=image, return_tensors="pt").to(device, torch.float16) >>> generated_ids = model.generate(**inputs) >>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip() >>> print(generated_text) two cats laying on a couch ``` Respuesta a preguntas visuales (prompt = pregunta): ```python >>> prompt = "Question: how many cats are there? Answer:" >>> inputs = processor(images=image, text=prompt, return_tensors="pt").to(device="cuda", dtype=torch.float16) >>> generated_ids = model.generate(**inputs) >>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip() >>> print(generated_text) two ``` Tenga en cuenta que la inferencia en int8 también se admite a través de [bitsandbytes](https://github.com/TimDettmers/bitsandbytes). Esto reduce significativamente la cantidad de memoria utilizada por el modelo, manteniendo el mismo rendimiento. ```python >>> model = Blip2ForConditionalGeneration.from_pretrained( ... "Salesforce/blip2-opt-2.7b", load_in_8bit=True, device_map={"": 0}, dtype=torch.bfloat16 ... ) # doctest: +IGNORE_RESULT >>> inputs = processor(images=image, text=prompt, return_tensors="pt").to(device="cuda", dtype=torch.bfloat16) >>> generated_ids = model.generate(**inputs) >>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip() >>> print(generated_text) two ``` #### generate[[transformers.Blip2ForConditionalGeneration.generate]] ```python generate(pixel_values: Tensor, input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, interpolate_pos_encoding: bool = False, **generate_kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1738) **Parámetros:** pixel_values (`torch.Tensor` de forma (batch_size, num_channels, height, width)) : Imágenes de entrada a procesar. input_ids (`torch.LongTensor` de forma (batch_size, sequence_length), *opcional*) : La secuencia utilizada como indicación para la generación. attention_mask (`torch.LongTensor` de forma (batch_size, sequence_length), *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) : Representación incrustada de las entradas. Debe ser de tipo float, no tokens int. interpolate_pos_encoding (`bool`, *opcional*, valor predeterminado `False`) : Si se debe interpolar la codificación posicional de las incrustaciones de imagen. **Devuelve:** `captions (list)` Una lista de cadenas de longitud batch_size * num_captions. Sobrescribe la función `generate` para poder usar el modelo como generador condicional. #### get_image_features[[transformers.Blip2ForConditionalGeneration.get_image_features]] ```python get_image_features(pixel_values: Tensor, interpolate_pos_encoding: bool | None = False, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1519) **Parámetros:** pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. interpolate_pos_encoding (`bool`, *opcional*, valor predeterminado `False`) : Si se debe interpolar las codificaciones de posición preentrenadas. **Devuelve:** `BaseModelOutputWithVisionQformerOutputs` o `tuple(torch.Tensor)` Un `BaseModelOutputWithVisionQformerOutputs` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Blip2Config](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Config)) y las entradas. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo. - **pooler_output** (`torch.Tensor` de 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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + 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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (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. - **vision_outputs** (`~modeling_outputs.BaseModelOutputWithPooling`, *opcional*) -- Salidas del codificador de visión. - **qformer_outputs** (`~modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions`, *opcional*) -- Salidas del Q-Former (Querying Transformer). Ejemplo: ```python >>> from PIL import Image >>> from transformers import AutoProcessor, Blip2ForConditionalGeneration >>> model = Blip2ForConditionalGeneration.from_pretrained("Salesforce/blip2-opt-2.7b") >>> processor = AutoProcessor.from_pretrained("Salesforce/blip2-opt-2.7b") >>> messages = [ ... { ... "role": "user", "content": [ ... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"}, ... {"type": "text", "text": "Where is the cat standing?"}, ... ] ... }, ... ] >>> inputs = processor.apply_chat_template( ... messages, ... tokenize=True, ... return_dict=True, ... return_tensors="pt", ... add_generation_prompt=True ... ) >>> # Generate >>> generate_ids = model.generate(**inputs) >>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0] ``` ## Blip2ForImageTextRetrieval[[transformers.Blip2ForImageTextRetrieval]] #### transformers.Blip2ForImageTextRetrieval[[transformers.Blip2ForImageTextRetrieval]] ```python transformers.Blip2ForImageTextRetrieval(config: Blip2Config) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1832) **Parámetros:** config ([Blip2Config](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Config)) : 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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo. Modelo BLIP-2 con un proyector de visión y texto, y una cabeza de clasificación en la parte superior. El modelo se utiliza en el contexto de recuperación de imagen-texto. Dada una imagen y un texto, el modelo devuelve la probabilidad de que el texto sea relevante para la imagen. Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.Blip2ForImageTextRetrieval.forward]] ```python forward(pixel_values: Tensor, input_ids: LongTensor, attention_mask: typing.Optional[torch.LongTensor] = None, use_image_text_matching_head: bool | None = False, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1866) **Parámetros:** pixel_values (`torch.Tensor` de 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 usando [BlipImageProcessor](/docs/transformers/main/es/model_doc/blip#transformers.BlipImageProcessor). Consulte [BlipImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles ([Blip2Processor](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Processor) utiliza [BlipImageProcessor](/docs/transformers/main/es/model_doc/blip#transformers.BlipImageProcessor) para procesar las imágenes). input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario del modelo de lenguaje. Los tokens de entrada pueden proporcionarse opcionalmente para servir como texto de indicación, que el modelo de lenguaje puede continuar. Los índices se pueden obtener usando [Blip2Processor](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Processor). Consulte [Blip2Processor.__call__()](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Processor.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) use_image_text_matching_head (`bool`, *opcional*) : Si se deben devolver las puntuaciones de correspondencia imagen-texto o contrastivas. output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte `attentions` en los tensores devueltos para obtener más detalles. output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. Consulte `hidden_states` en los tensores devueltos para obtener más detalles. return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple. **Devuelve:** `Blip2ImageTextMatchingModelOutput` o `tuple(torch.Tensor)` Un `Blip2ImageTextMatchingModelOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Blip2Config](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Config)) y las entradas. El método forward de [Blip2ForImageTextRetrieval](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2ForImageTextRetrieval) sobrescribe 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 `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, devuelta cuando `return_loss` es `True`) -- Pérdida contrastiva para la similitud imagen-texto. - **logits_per_image** (`torch.Tensor` de forma `(image_batch_size, text_batch_size)`) -- Las puntuaciones de producto punto escalado entre `image_embeds` y `text_embeds`. Esto representa las puntuaciones de similitud entre imagen y texto. - **logits_per_text** (`torch.Tensor` de forma `(text_batch_size, image_batch_size)`) -- Las puntuaciones de producto punto escalado entre `text_embeds` y `image_embeds`. Esto representa las puntuaciones de similitud texto-imagen. - **text_embeds** (`torch.Tensor` de forma `(batch_size, output_dim`) -- Las incrustaciones de texto obtenidas al aplicar la capa de proyección a la salida agrupada. - **image_embeds** (`torch.Tensor` de forma `(batch_size, output_dim`) -- Los embeddings de imagen obtenidos al aplicar la capa de proyección a la salida agrupada. - **text_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`, *opcional*) -- La salida del [Blip2QFormerModel](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2QFormerModel). - **vision_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`, *opcional*) -- La salida del [Blip2VisionModel](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2VisionModel). Ejemplos: ```python >>> import torch >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import AutoProcessor, Blip2ForImageTextRetrieval >>> device = "cuda" if torch.cuda.is_available() else "cpu" >>> model = Blip2ForImageTextRetrieval.from_pretrained("Salesforce/blip2-itm-vit-g", dtype=torch.float16) >>> processor = AutoProcessor.from_pretrained("Salesforce/blip2-itm-vit-g") >>> model.to(device) >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> text = "two cats laying on a pink blanket" >>> inputs = processor(images=image, text=text, return_tensors="pt").to(device, torch.float16) >>> itm_out = model(**inputs, use_image_text_matching_head=True) >>> logits_per_image = torch.nn.functional.softmax(itm_out.logits_per_image, dim=1) >>> probs = logits_per_image.softmax(dim=1) # we can take the softmax to get the label probabilities >>> print(f"{probs[0][0]:.1%} that image 0 is not '{text}'") 26.9% that image 0 is not 'two cats laying on a pink blanket' >>> print(f"{probs[0][1]:.1%} that image 0 is '{text}'") 73.0% that image 0 is 'two cats laying on a pink blanket' >>> texts = ["a photo of a cat", "a photo of a dog"] >>> inputs = processor(images=image, text=texts, return_tensors="pt").to(device, torch.float16) >>> itc_out = model(**inputs, use_image_text_matching_head=False) >>> logits_per_image = itc_out.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 >>> print(f"{probs[0][0]:.1%} that image 0 is '{texts[0]}'") 55.3% that image 0 is 'a photo of a cat' >>> print(f"{probs[0][1]:.1%} that image 0 is '{texts[1]}'") 44.7% that image 0 is 'a photo of a dog' ``` ## Blip2TextModelWithProjection[[transformers.Blip2TextModelWithProjection]] #### transformers.Blip2TextModelWithProjection[[transformers.Blip2TextModelWithProjection]] ```python transformers.Blip2TextModelWithProjection(config: Blip2Config) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1274) **Parámetros:** config ([Blip2Config](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Config)) : 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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo. El modelo Blip 2 con una capa de proyección en la parte superior (una capa lineal sobre la salida agrupada). Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.Blip2TextModelWithProjection.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1298) **Parámetros:** input_ids (`torch.Tensor` de 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 mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`. [¿Qué son los IDs de posición?](../glossary#position-ids) **Devuelve:** `Blip2TextModelOutput` o `tuple(torch.Tensor)` Un `Blip2TextModelOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Blip2Config](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Config)) y las entradas. El método forward de [Blip2TextModelWithProjection](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2TextModelWithProjection) sobrescribe 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 `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente. - **text_embeds** (`torch.Tensor` de forma `(batch_size, output_dim)` *opcional* devuelta cuando el modelo se inicializa con `with_projection=True`) -- Las incrustaciones de texto obtenidas al aplicar la capa de proyección a pooler_output. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del modelo. - **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (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.Tensor, ...]`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (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: ```python >>> import torch >>> from transformers import AutoProcessor, Blip2TextModelWithProjection >>> device = "cuda" if torch.cuda.is_available() else "cpu" >>> model = Blip2TextModelWithProjection.from_pretrained( ... "Salesforce/blip2-itm-vit-g", dtype=torch.float16 ... ) >>> model.to(device) >>> processor = AutoProcessor.from_pretrained("Salesforce/blip2-itm-vit-g") >>> inputs = processor(text=["a photo of a cat", "a photo of a dog"], return_tensors="pt").to(device) >>> outputs = model(**inputs) >>> text_embeds = outputs.text_embeds >>> print(text_embeds.shape) torch.Size([2, 7, 256]) ``` ## Blip2VisionModelWithProjection[[transformers.Blip2VisionModelWithProjection]] #### transformers.Blip2VisionModelWithProjection[[transformers.Blip2VisionModelWithProjection]] ```python transformers.Blip2VisionModelWithProjection(config: Blip2Config) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1359) **Parámetros:** config ([Blip2Config](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Config)) : 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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo. El modelo Blip 2 con una capa de proyección en la parte superior (una capa lineal sobre la salida agrupada). Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.Blip2VisionModelWithProjection.forward]] ```python forward(pixel_values: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1382) **Parámetros:** pixel_values (`torch.Tensor` de 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 usando [BlipImageProcessor](/docs/transformers/main/es/model_doc/blip#transformers.BlipImageProcessor). Consulte [BlipImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles ([Blip2Processor](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Processor) utiliza [BlipImageProcessor](/docs/transformers/main/es/model_doc/blip#transformers.BlipImageProcessor) para procesar las imágenes). **Devuelve:** `Blip2VisionModelOutput` o `tuple(torch.Tensor)` Un `Blip2VisionModelOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Blip2Config](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2Config)) y las entradas. El método forward de [Blip2VisionModelWithProjection](/docs/transformers/main/es/model_doc/blip-2#transformers.Blip2VisionModelWithProjection) sobrescribe 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 `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente. - **image_embeds** (`torch.Tensor` de forma `(batch_size, output_dim)` *opcional* devuelta cuando el modelo se inicializa con `with_projection=True`) -- Las incrustaciones de imagen obtenidas al aplicar la capa de proyección a pooler_output. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del modelo. - **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (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.Tensor, ...]`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (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: ```python >>> import torch >>> from transformers import AutoProcessor, Blip2VisionModelWithProjection >>> from transformers.image_utils import load_image >>> device = "cuda" if torch.cuda.is_available() else "cpu" >>> processor = AutoProcessor.from_pretrained("Salesforce/blip2-itm-vit-g") >>> model = Blip2VisionModelWithProjection.from_pretrained( ... "Salesforce/blip2-itm-vit-g", dtype=torch.float16 ... ) >>> model.to(device) >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> image = load_image(url) >>> inputs = processor(images=image, return_tensors="pt").to(device, torch.float16) >>> with torch.inference_mode(): ... outputs = model(**inputs) >>> image_embeds = outputs.image_embeds >>> print(image_embeds.shape) torch.Size([1, 32, 256]) ```