Transformers documentation

LLaVa-NeXT-Video

Transformers

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

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Este modelo se publicó en HF papers el 31 de mayo de 2024 y se contribuyó a Hugging Face Transformers el 26 de junio de 2024.

LLaVa-NeXT-Video

Resumen

El modelo LLaVa-NeXT-Video se propuso en LLaVA-NeXT: A Strong Zero-shot Video Understanding Model de Yuanhan Zhang, Bo Li, Haotian Liu, Yong Jae Lee, Liangke Gui, Di Fu, Jiashi Feng, Ziwei Liu, Chunyuan Li. LLaVa-NeXT-Video mejora a LLaVa-NeXT mediante el ajuste fino en una mezcla de conjuntos de datos de video e imagen, lo que aumenta el rendimiento del modelo en videos.

LLaVA-NeXT presenta, sorprendentemente, un rendimiento sólido en la comprensión del contenido de vídeo de forma zero-shot gracias a la técnica AnyRes que utiliza. La técnica AnyRes representa de manera natural una imagen de alta resolución en múltiples imágenes. Esta técnica es generalizable de forma natural para representar vídeos, ya que los vídeos pueden considerarse como un conjunto de fotogramas (similar a un conjunto de imágenes en LLaVa-NeXT). La versión actual de LLaVA-NeXT hace uso de AnyRes y se entrena con fine-tuning supervisado (SFT) sobre LLaVA-Next con datos de vídeo para lograr mejores capacidades de comprensión de vídeo. El modelo es el SOTA actual entre los modelos de código abierto en VideoMME bench.

La introducción del blog es la siguiente:

El 30 de enero de 2024, lanzamos LLaVA-NeXT, un Large Multimodal Model (LMM) de código abierto entrenado exclusivamente con datos de texto e imágenes. Con la técnica AnyRes propuesta, mejora las capacidades de razonamiento, OCR y conocimiento del mundo, demostrando un rendimiento notable en un amplio espectro de tareas de comprensión multimodal basadas en imágenes, e incluso superando a Gemini-Pro en varios benchmarks de imágenes, por ejemplo, MMMU y MathVista.

**En la exploración de hoy, analizamos el rendimiento de LLaVA-NeXT en el ámbito de las tareas de comprensión de video. Revelamos que LLaVA-NeXT tiene, sorprendentemente, un fuerte rendimiento en la comprensión del contenido de video. La versión actual de LLaVA-NeXT para videos presenta varias mejoras:**

Capacidades de representación de video en modo zero-shot con AnyRes: la técnica AnyRes representa de forma natural una imagen de alta resolución en múltiples imágenes que un VIT preentrenado puede procesar, y las organiza en una secuencia concatenada. Esta técnica es generalizable de forma natural para representar videos (compuestos por múltiples fotogramas), lo que permite que el modelo LLaVA-Next, entrenado solo con imágenes, rinda de manera sorprendentemente bien en tareas de video. Cabe destacar que esta es la primera vez que los LMMs muestran una fuerte capacidad de transferencia de modalidad en modo zero-shot.
La inferencia con generalización de longitud mejora en videos más largos. La técnica de escalado lineal permite la generalización de longitud, lo que permite a LLaVA-NeXT manejar de manera efectiva videos largos más allá de la limitación de “max_token_length” del LLM.
Capacidad de comprensión de video robusta. (1) LLaVA-Next-Image, que combina las dos técnicas anteriores, ofrece un rendimiento superior en modo zero-shot en comparación con los LMM de código abierto ajustados en videos. (2) LLaVA-Next-Video, que realiza un ajuste fino supervisado (SFT) adicional de LLaVA-Next-Image con datos de video, logra mejores capacidades de comprensión de video en comparación con LLaVA-Next-Image. (3) LLaVA-Next-Video-DPO, que alinea la respuesta del modelo con la retroalimentación de la IA mediante la optimización directa de preferencias (DPO), muestra una mejora significativa en el rendimiento.
Despliegue e inferencia eficientes con SGLang. Permite una inferencia 5 veces más rápida en tareas de video, lo que habilita un servicio más escalable, como la re-descripción de videos a nivel de millones. Consulta las instrucciones en nuestro repositorio.**

Este modelo fue aportado por RaushanTurganbay. El código original se puede encontrar aquí.

Consejos de uso

Recomendamos a los usuarios que utilicen padding_side="left" al calcular la generación por lotes, ya que esto conduce a resultados más precisos. Simplemente asegúrese de llamar a processor.tokenizer.padding_side = "left" antes de generar.

Llava-Next utiliza un número diferente de parches para las imágenes y, por lo tanto, debe rellenar las entradas dentro del código de modelado, además del relleno realizado al procesar las entradas. La configuración predeterminada es “left-padding” si el modelo está en modo eval(), de lo contrario es “right-padding”.

Los modelos LLaVA posteriores a la versión v4.46 emitirán advertencias sobre la adición de processor.patch_size = {{patch_size}}, processor.num_additional_image_tokens = {{num_additional_image_tokens}} y processor.vision_feature_select_strategy = {{vision_feature_select_strategy}}. Se recomienda encarecidamente añadir estos 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 LLaVA intentará inferir el número de tokens de imagen necesarios por imagen y expandirá el texto con tantos marcadores de posición <image> como tokens haya. Normalmente son alrededor de 500 tokens por imagen, así que asegúrese de que el texto no se trunque, ya que de lo contrario habrá un fallo al fusionar los embeddings. Los atributos se pueden obtener de la configuración del modelo, como model.config.vision_config.patch_size o model.config.vision_feature_select_strategy. El valor de num_additional_image_tokens debe ser 1 si el backbone de visión añade un token CLS o 0 si no se añade nada extra a los patches de visión.

Formateo de prompts con plantillas de chat

Cada checkpoint se entrena con un formato de prompt específico, dependiendo del modelo de lenguaje de gran escala subyacente. Para garantizar un formato correcto, utiliza el método apply_chat_template del procesador.

Importante:

Debes construir un historial de conversación; pasar una cadena de texto simple no funcionará.
Cada mensaje debe ser un diccionario con las claves "role" y "content".
El "content" debe ser una lista de diccionarios para diferentes modalidades como "text" y "image".

A continuación se muestra un ejemplo de cómo estructurar la entrada. Utilizaremos LLaVA-NeXT-Video-7B-hf y un historial de conversación de videos e imágenes.

from transformers import LlavaNextVideoProcessor


processor = LlavaNextVideoProcessor.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")

conversation = [
    {
        "role": "system",
        "content": [
            {"type": "text", "text": "A chat between a curious human and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the human's questions."},
            ],
    },
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "What’s shown in this image?"},
            {"type": "image"},
            ],
    },
    {
        "role": "assistant",
        "content": [{"type": "text", "text": "This image shows a red stop sign."},]
    },
    {

        "role": "user",
        "content": [
            {"type": "text", "text": "Why is this video funny?"},
            {"type": "video"},
            ],
    },
]

text_prompt = processor.apply_chat_template(conversation, add_generation_prompt=True)

# Note that the template simply formats your prompt, you still have to tokenize it and obtain pixel values for your visuals
print(text_prompt)

🚀 Bonus: Si estás usando transformers>=4.49.0, también puedes obtener una salida vectorizada de apply_chat_template. Consulta los Ejemplos de uso a continuación para más detalles sobre cómo utilizarla.

Ejemplo de uso

Modo de medios único

El modelo puede aceptar tanto imágenes como videos como entrada. A continuación, se muestra un ejemplo de código para la inferencia en media precisión (torch.float16):

from huggingface_hub import hf_hub_download

from transformers import LlavaNextVideoForConditionalGeneration, LlavaNextVideoProcessor


# Load the model in half-precision
model = LlavaNextVideoForConditionalGeneration.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf", device_map="auto")
processor = LlavaNextVideoProcessor.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")

# Load the video as an np.array, sampling uniformly 8 frames (can sample more for longer videos)
video_path = hf_hub_download(repo_id="raushan-testing-hf/videos-test", filename="sample_demo_1.mp4", repo_type="dataset")

conversation = [
    {

        "role": "user",
        "content": [
            {"type": "text", "text": "Why is this video funny?"},
            {"type": "video", "path": video_path},
            ],
    },
]

inputs = processor.apply_chat_template(conversation, num_frames=8, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(model.device)

out = model.generate(**inputs, max_new_tokens=60)
processor.batch_decode(out, skip_special_tokens=True, clean_up_tokenization_spaces=True)

Modo de medios mixtos

El modelo también puede generar a partir de entradas de imagen y video intercaladas. Sin embargo, ten en cuenta que no fue entrenado en un entorno de imagen y video intercalados, lo que podría afectar el rendimiento. A continuación se muestra un ejemplo de uso para entrada de medios mixtos; agrega las siguientes líneas al fragmento de código anterior:


# Generate from image and video mixed inputs
conversation = [
    {

        "role": "user",
        "content": [
            {"type": "text", "text": "How many cats are there in the image?"},
            {"type": "image", "url": "http://images.cocodataset.org/val2017/000000039769.jpg"},
            ],
    },
    {

        "role": "assistant",
        "content": [{"type": "text", "text": "There are two cats"}],
    },
    {

        "role": "user",
        "content": [
            {"type": "text", "text": "Why is this video funny?"},
            {"type": "video", "path": video_path},
            ],
    },
]
inputs = processor.apply_chat_template(conversation, num_frames=8, add_generation_prompt=True, tokenize=True, return_dict=True, padding=True, return_tensors="pt").to(model.device)

# Generate
generate_ids = model.generate(**inputs, max_length=50)
processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)

Optimización de modelos

Cuanticización con Bitsandbytes para la eficiencia de memoria

El modelo se puede cargar en bits más bajos, lo que reduce significativamente la carga de memoria mientras mantiene el rendimiento del modelo original. Esto permite una implementación eficiente en casos con recursos limitados.

Primero, asegúrate de instalar bitsandbytes ejecutando pip install bitsandbytes y de tener acceso a una GPU/acelerador compatible con la biblioteca.

bitsandbytes se está refactorizando para admitir múltiples backends además de CUDA. Actualmente, las implementaciones de ROCm (GPU de AMD) y CPU de Intel están maduras, la de Intel XPU está en curso y se espera el soporte para Apple Silicon para el Q4/Q1. Para obtener instrucciones de instalación y las últimas actualizaciones de backends, visita este enlace.

¡Valoramos tu feedback para ayudar a identificar errores antes del lanzamiento completo! Consulta estos documentos para más detalles y enlaces de feedback.

Luego, simplemente cargue el modelo cuantizado añadiendo BitsAndBytesConfig como se muestra a continuación:

from transformers import LlavaNextVideoForConditionalGeneration


# specify how to quantize the model
quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
)

model = LlavaNextVideoForConditionalGeneration.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf", quantization_config=quantization_config, device_map="auto")

Flash-Attention 2 para acelerar la generación

Además, podemos acelerar considerablemente la inferencia del modelo mediante el uso de Flash Attention, que es una implementación más rápida del mecanismo de atención utilizado dentro del modelo.

Primero, asegúrate de instalar la última versión de Flash Attention 2:

pip install -U flash-attn --no-build-isolation

Además, debe contar con un hardware compatible con Flash-Attention 2. Puede leer más al respecto en la documentación oficial del repositorio de flash attention. FlashAttention-2 solo puede utilizarse cuando un modelo se carga en torch.float16 o torch.bfloat16.

Para cargar y ejecutar un modelo usando Flash Attention-2, simplemente agregue attn_implementation="flash_attention_2" al cargar el modelo, de la siguiente manera:

from transformers import LlavaNextVideoForConditionalGeneration

model = LlavaNextVideoForConditionalGeneration.from_pretrained(
    "llava-hf/LLaVA-NeXT-Video-7B-hf", , 
    attn_implementation="flash_attention_2",
).to(0, device_map="auto")

LlavaNextVideoConfig

clase transformers.LlavaNextVideoConfig

< 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 = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneimage_token_index: int = 32001video_token_index: int = 32000projector_hidden_act: str = 'gelu'vision_feature_select_strategy: typing.Literal['default', 'full'] = 'default'vision_feature_layer: int | list[int] = -2multimodal_projector_bias: bool = Truetie_word_embeddings: bool = Falseimage_grid_pinpoints: list | None = Nonespatial_pool_mode: str = 'average'spatial_pool_stride: int = 2image_seq_length: int = 576video_seq_length: int = 288 )

Parámetros

vision_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — El objeto de configuración o el diccionario del backbone de visión.
text_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — El objeto de configuración o el diccionario del backbone de texto.
image_token_index (int, opcional, valor predeterminado 32001) — El índice del token de imagen utilizado como marcador de posición para las imágenes de entrada.
video_token_index (int, opcional, valor predeterminado 32000) — El índice de token de video utilizado como marcador de posición para los videos de entrada.
projector_hidden_act (str, opcional, valor predeterminado gelu) — La función de activación utilizada por el proyector multimodal.
vision_feature_select_strategy (Literal[default, full], opcional, valor predeterminado default) — Estrategia de selección de características utilizada para seleccionar la característica visual del backbone visual.
vision_feature_layer (Union[int, list[int]], opcional, valor predeterminado -2) — El índice de la capa de la que se selecciona la característica visual. Si se proporcionan varios índices, las características visuales de los índices correspondientes se concatenarán para formar las características visuales.
multimodal_projector_bias (bool, opcional, valor predeterminado True) — Si se debe usar sesgo en el proyector multimodal.
tie_word_embeddings (bool, opcional, valor predeterminado False) — Si se deben vincular las matrices de pesos de embeddings según el mapeo tied_weights_keys del modelo.
image_grid_pinpoints (List, opcional, valor predeterminado [[336, 672], [672, 336], [672, 672], [1008, 336], [336, 1008]]) — Una lista de resoluciones posibles para procesar imágenes de alta resolución. Cada elemento de la lista debe ser una tupla o lista de la forma (height, width).
spatial_pool_mode (str, opcional, valor predeterminado "average") — Modo de pooling a utilizar para los vídeos. Puede ser “average”, “max” o “conv”.
spatial_pool_stride (int, opcional, valor predeterminado 2) — Paso utilizado en la capa de pooling para videos.
image_seq_length (int, opcional, valor predeterminado 576) — Longitud de secuencia de un embedding de imagen.
video_seq_length (int, opcional, valor predeterminado 288) — Longitud de secuencia de una incrustación de video.

Esta es la clase de configuración para almacenar la configuración de un LlavaNextVideoModel. Se utiliza para instanciar un modelo Llava Next Video 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 llava-hf/LLaVA-NeXT-Video-7B-hf

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 LlavaNextVideoForConditionalGeneration, LlavaNextVideoConfig, CLIPVisionConfig, LlamaConfig

>>> # Initializing a CLIP-vision config
>>> vision_config = CLIPVisionConfig()

>>> # Initializing a Llama config
>>> text_config = LlamaConfig()

>>> configuration = LlavaNextVideoConfig(vision_config, text_config)

>>> model = LlavaNextVideoForConditionalGeneration(configuration)

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

LlavaNextVideoProcessor

clase transformers.LlavaNextVideoProcessor

< source >

( video_processor = Noneimage_processor = Nonetokenizer = Nonechat_template = Nonepatch_size = Nonevision_feature_select_strategy = Nonevideo_token = '<video>'image_token = '<image>'num_additional_image_tokens = 0**kwargs )

Parámetros

video_processor (LlavaNextVideoVideoProcessor) — El procesador de video es una entrada obligatoria.
image_processor (LlavaNextImageProcessor) — El procesador de imágenes es una entrada obligatoria.
tokenizer (tokenizer_class) — El tokenizador es una entrada obligatoria.
chat_template (str) — Plantilla de Jinja para convertir listas de mensajes de un chat en una cadena tokenizable.
patch_size (int, opcional) — Tamaño del parche de la torre de visión.
vision_feature_select_strategy (str, opcional) — La estrategia de selección de características utilizada para seleccionar la característica visual del backbone visual. Debe ser la misma que en la configuración del modelo
video_token (str, opcional, valor predeterminado "<video>") — Token especial utilizado para indicar la ubicación del video.
image_token (str, opcional, valor predeterminado "<image>") — Token especial utilizado para indicar la ubicación de la imagen.
num_additional_image_tokens (int, opcional, valor predeterminado 0) — Número de tokens adicionales añadidos a las incrustaciones de imagen, como CLS (+1). Si el backbone no tiene CLS u otros tokens adicionales añadidos, no es necesario establecer este argumento.

Construye un LlavaNextVideoProcessor que encapsula un procesador de video, un procesador de imagen y un tokenizador en un único procesador.

LlavaNextVideoProcessor ofrece todas las funcionalidades de LlavaNextVideoVideoProcessor, LlavaNextImageProcessor y tokenizer_class. Consulte ~LlavaNextVideoVideoProcessor, ~LlavaNextImageProcessor y ~tokenizer_class para obtener más información.

LlavaNextVideoVideoProcessor

clase transformers.LlavaNextVideoVideoProcessor

< source >

( **kwargs: *<class 'transformers.processing_utils.VideosKwargs'> )

Parámetros

do_convert_rgb (bool, kwargs, opcional, valor predeterminado True) — Si se debe convertir la imagen a RGB.
do_resize (bool, kwargs, opcional, valor predeterminado True) — Si se debe redimensionar la imagen.
size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, por defecto {'shortest_edge' -- 224}): Describe las dimensiones máximas de entrada para el modelo.
default_to_square (bool, kwargs, opcional, valor predeterminado False) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si size es un int.
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, por defecto 3) — Filtro de remuestreo a utilizar si se redimensiona la imagen. Puede ser uno de los valores de la enumeración PILImageResampling. Solo tiene efecto si do_resize está establecido en True.
do_rescale (bool, kwargs, opcional, valor predeterminado True) — Si se debe reescalar la imagen.
rescale_factor (float, kwargs, opcional, valor predeterminado 0.00392156862745098) — Factor de reescalado para reescalar la imagen si do_rescale está establecido en True.
do_normalize (bool, kwargs, opcional, valor predeterminado True) — Si se debe normalizar la imagen.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional, valor predeterminado [0.48145466, 0.4578275, 0.40821073]) — Media de la imagen a utilizar para la normalización. Solo tiene efecto si do_normalize está establecido en True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional, valor predeterminado [0.26862954, 0.26130258, 0.27577711]) — Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si do_normalize está establecido en True.
do_center_crop (bool, kwargs, opcional, valor predeterminado True) — Si se debe recortar la imagen centrada.
do_pad (bool, kwargs, opcional) — Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo.
crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, por defecto {'height' -- 224, 'width': 224}): Tamaño de la imagen de salida tras aplicar center_crop.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Solo se admite ChannelDimension.FIRST. Se añadió para garantizar la compatibilidad con los procesadores lentos.
input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — El formato de la dimensión de canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales se infiere a partir de la imagen de entrada. Puede ser uno de:
- "channels_first" o ChannelDimension.FIRST: imagen en formato (num_channels, height, width).
- "channels_last" o ChannelDimension.LAST: imagen en formato (altura, ancho, num_canales).
- "none" o ChannelDimension.NONE: imagen en formato (altura, ancho).
device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos de entrada.
do_sample_frames (bool, kwargs, opcional, valor predeterminado False) — Si se deben muestrear fotogramas del video antes de procesarlo o si se debe procesar el video completo.
video_metadata (Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None], kwargs) — Metadatos del video que contienen información sobre la duración total, los fps y el número total de fotogramas. Se utilizarán para muestrear fotogramas del video o calcular marcas de tiempo. No pase ningún metadato a menos que intente decodificar el video manualmente antes de procesarlo
fps (Annotated[int | float | None, None], kwargs) — Fotogramas objetivo a muestrear por segundo cuando do_sample_frames=True.
num_frames (Annotated[int | None, None], kwargs) — Número máximo de fotogramas a muestrear cuando do_sample_frames=True.
return_metadata (bool, kwargs, opcional, valor predeterminado False) — Indica si se debe devolver o no la metadatos del vídeo. Los metadatos del vídeo son un objeto que contiene información sobre la duración del vídeo, los fps, el backend de decodificación, etc.
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — 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 (VideosKwargs, 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.

Construye un procesador de video LlavaNextVideoVideoProcessor.

LlavaNextVideoModel

clase transformers.LlavaNextVideoModel

< source >

( config: LlavaNextVideoConfig )

Parámetros

config (LlavaNextVideoConfig) — 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 Llava-Next, que consiste en un backbone de visión y un modelo de lenguaje sin cabeza de modelado de lenguaje.

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.Tensor] = Nonepixel_values_videos: typing.Optional[torch.Tensor] = Noneimage_sizes: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonevision_feature_layer: int | list[int] | None = Nonevision_feature_select_strategy: str | None = Noneuse_cache: bool | None = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.modeling_flash_attention_utils.FlashAttentionKwargs'> ) → LlavaNextVideoModelOutputWithPast or tuple(torch.Tensor)

Parámetros

input_ids (torch.LongTensor 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 usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

¿Qué son los IDs de entrada?
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 utilizando LlavaNextImageProcessor. Consulte LlavaNextImageProcessor.call() para más detalles (LlavaNextVideoProcessor utiliza LlavaNextImageProcessor para procesar las imágenes).
pixel_values_videos (torch.Tensor de forma (batch_size, num_frames, num_channels, frame_size, frame_size), opcional) — Los tensores correspondientes al video de entrada. Los valores de píxel para videos se pueden obtener utilizando LlavaNextVideoVideoProcessor. Consulte LlavaNextVideoVideoProcessor.call() para más detalles (LlavaNextVideoProcessor utiliza LlavaNextVideoVideoProcessor para procesar videos).
image_sizes (torch.LongTensor de forma (batch_size, 2), opcional) — Los tamaños de las imágenes del lote, siendo (altura, ancho) para cada imagen.
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 máscara seleccionados en [0, 1]:
- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
¿Qué son las máscaras de atención?
position_ids (torch.LongTensor de 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].
¿Qué son los IDs de posición?
past_key_values (~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en la past_key_values devuelta por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.use_cache=True.
Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan past_key_values, DynamicCache se inicializará de forma predeterminada.

El modelo generará el mismo formato de caché que se proporciona como entrada.

Si se utilizan past_key_values, se espera que el usuario introduzca únicamente los input_ids no procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma (batch_size, unprocessed_length) en lugar de todos los input_ids con forma (batch_size, sequence_length).
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.
vision_feature_layer (Union[int, list[int]], opcional) — El índice de la capa de la que seleccionar la característica visual. Si se proporcionan varios índices, las características visuales de los índices correspondientes se concatenarán para formar las características visuales.
vision_feature_select_strategy (str, opcional, valor predeterminado "default") — Estrategia de selección de características utilizada para seleccionar la característica visual del backbone visual. Puede ser "default" o "full". Si es "default", se elimina el token CLS de las características visuales. Si es "full", se utilizan las características visuales completas.
use_cache (bool, opcional) — Si se establece en True, se devuelven los estados de clave-valor de past_key_values y pueden usarse para acelerar la decodificación (ver past_key_values).
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

LlavaNextVideoModelOutputWithPast o tuple(torch.Tensor)

Un LlavaNextVideoModelOutputWithPast 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 (LlavaNextVideoConfig) y las entradas.

El método forward de LlavaNextVideoModel 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 pre y postprocesamiento, 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.

Si se utiliza past_key_values, solo se genera el último hidden-state de las secuencias con forma (batch_size, 1, hidden_size).
past_key_values (Cache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.

Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención) que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.
hidden_states (tuple(torch.Tensor), opcional, devuelto 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.
image_hidden_states (torch.Tensor, opcional) — Un torch.Tensor de tamaño (batch_size, num_images, sequence_length, hidden_size). image_hidden_states del modelo generado por el codificador de visión y después de proyectar el último estado oculto.
video_hidden_states (torch.Tensor, opcional) — Un torch.Tensor de tamaño (batch_size * num_frames, num_videos, sequence_length, hidden_size). video_hidden_states del modelo generado por el codificador de visión y después de proyectar el último estado oculto.

get_image_features

< source >

( pixel_values: Tensorimage_sizes: Tensorvision_feature_layer: int | list[int] | None = Nonevision_feature_select_strategy: str | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Parámetros

pixel_values (torch.Tensor de forma (batch_size, num_patches, channels, height, width)) — Los tensores correspondientes a las imágenes de entrada.
image_sizes (torch.Tensor de forma (num_images, 2)) — Tamaño real de cada imagen (H, W).
vision_feature_layer (Union[int, list[int]], opcional) — El índice de la capa de la que seleccionar la característica visual. Si se proporcionan varios índices, las características visuales de los índices correspondientes se concatenarán para formar las características visuales.
image_sizes (torch.Tensor de forma (batch_size, 2)) — Los tamaños de las imágenes del lote, siendo (altura, ancho) para cada imagen.
vision_feature_layer (Union[int, list[int]], opcional) — El índice de la capa de la que seleccionar la característica visual. Si se proporcionan varios índices, las características visuales de los índices correspondientes se concatenarán para formar las características visuales.
vision_feature_select_strategy (str, opcional) — La estrategia de selección de características utilizada para seleccionar la característica visual del backbone visual. Puede ser "default" o "full"

Devuelve

BaseModelOutputWithPooling o tuple(torch.Tensor)

Un 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 (LlavaNextVideoConfig) y las entradas.

Obtiene los estados ocultos finales de la imagen de la torre de visión y aplica la proyección multimodal.

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, devuelto 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.

get_placeholder_mask

< source >

( input_ids: LongTensorinputs_embeds: Tensorimage_features: typing.Optional[torch.Tensor] = Nonevideo_features: typing.Optional[torch.Tensor] = None )

Obtiene la máscara de marcador de posición multimodal a partir de input_ids o inputs_embeds y comprueba que la cantidad de tokens de marcador de posición sea igual a la longitud de las características multimodales. Si las longitudes son diferentes, se genera un error.

get_video_features

< source >

( pixel_values_videos: Tensorvision_feature_layer: int | list[int] | None = Nonevision_feature_select_strategy: str | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Parámetros

pixel_values_videos (torch.Tensor] de forma (batch_size, num_frames, channels, height, width)) — Los tensores correspondientes al video de entrada.
vision_feature_layer (Union[int, list[int]], opcional) — El índice de la capa de la que seleccionar la característica visual. Si se proporcionan varios índices, las características visuales de los índices correspondientes se concatenarán para formar las características visuales.
vision_feature_layer (Union[int, list[int]], opcional) — El índice de la capa de la que seleccionar la característica visual. Si se proporcionan varios índices, las características visuales de los índices correspondientes se concatenarán para formar las características visuales.
vision_feature_select_strategy (str, opcional) — La estrategia de selección de características utilizada para seleccionar la característica visual del backbone visual. Puede ser "default" o "full"

Devuelve

BaseModelOutputWithPooling o tuple(torch.Tensor)

Obtiene los estados ocultos finales del video de la torre de visión y aplica la proyección multimodal.

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, devuelto 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.

pack_image_features

< source >

( image_featuresimage_sizesvision_feature_select_strategyimage_newline = None )

Parámetros

image_features (list[torch.Tensor] de longitud num_images, cada uno con forma (num_patches, image_length, embed_dim)) — Lista de tensores de características de imagen, cada uno contiene todas las características visuales de todos los parches.
image_sizes (torch.Tensor de forma (num_images, 2)) — Tamaño real de cada imagen (H, W).
vision_feature_select_strategy (str) — Estrategia de selección de características utilizada para seleccionar la característica visual del backbone visual.
image_newline (torch.Tensor de forma (embed_dim)) — Vector de incrustación de nueva línea.

Redimensiona, elimina el relleno y luego empaqueta cada image_feature en un único tensor image_features que contenga todos los vectores visuales.

LlavaNextVideoForConditionalGeneration

clase transformers.LlavaNextVideoForConditionalGeneration

< source >

( config: LlavaNextVideoConfig )

Parámetros

config (LlavaNextVideoConfig) — 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 LLAVA-NeXT, que consta de un backbone de visión y un modelo de lenguaje.

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonepixel_values_videos: typing.Optional[torch.Tensor] = Noneimage_sizes: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonevision_feature_layer: int | list[int] | None = Nonevision_feature_select_strategy: str | None = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → LlavaNextVideoCausalLMOutputWithPast or tuple(torch.Tensor)

Parámetros

input_ids (torch.LongTensor 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 usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

¿Qué son los IDs de entrada?
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 utilizando LlavaNextImageProcessor. Consulte LlavaNextImageProcessor.call() para más detalles (LlavaNextVideoProcessor utiliza LlavaNextImageProcessor para procesar las imágenes).
pixel_values_videos (torch.Tensor de forma (batch_size, num_frames, num_channels, frame_size, frame_size), opcional) — Los tensores correspondientes al video de entrada. Los valores de píxel para videos se pueden obtener utilizando LlavaNextVideoVideoProcessor. Consulte LlavaNextVideoVideoProcessor.call() para más detalles (LlavaNextVideoProcessor utiliza LlavaNextVideoVideoProcessor para procesar videos).
image_sizes (torch.LongTensor de forma (batch_size, 2), opcional) — Los tamaños de las imágenes del lote, siendo (altura, ancho) para cada imagen.
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 máscara seleccionados en [0, 1]:
- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
¿Qué son las máscaras de atención?
position_ids (torch.LongTensor de 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].
¿Qué son los IDs de posición?
past_key_values (~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en la past_key_values devuelta por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.use_cache=True.
Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan past_key_values, DynamicCache se inicializará de forma predeterminada.

El modelo generará el mismo formato de caché que se proporciona como entrada.

Si se utilizan past_key_values, se espera que el usuario introduzca únicamente los input_ids no procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma (batch_size, unprocessed_length) en lugar de todos los input_ids con forma (batch_size, sequence_length).
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.
vision_feature_layer (Union[int, list[int]], opcional) — El índice de la capa de la que seleccionar la característica visual. Si se proporcionan varios índices, las características visuales de los índices correspondientes se concatenarán para formar las características visuales.
vision_feature_select_strategy (str, opcional) — La estrategia de selección de características utilizada para seleccionar la característica visual del backbone visual. Puede ser "default" o "full".
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 (ver la docstring de input_ids). Los tokens con índices establecidos en -100 se ignoran (enmascarados); la pérdida solo se calcula para los tokens con etiquetas en [0, ..., config.vocab_size].
use_cache (bool, opcional) — Si se establece en True, se devuelven los estados de clave-valor de past_key_values y pueden usarse para acelerar la decodificación (ver past_key_values).
logits_to_keep (Union[int, torch.Tensor], opcional, valor predeterminado 0) — Si es un int, calcula los logits para los últimos logits_to_keep tokens. Si es 0, calcula los logits para todos los input_ids (caso especial). Solo se necesitan los logits del último token para la generación, y calcularlos solo para ese token puede ahorrar memoria, lo cual se vuelve bastante significativo para secuencias largas o un tamaño de vocabulario grande. Si es un torch.Tensor, debe ser de 1D y corresponder a los índices a conservar en la dimensión de longitud de secuencia. Esto es útil al usar el formato de tensor empaquetado (una sola dimensión para el lote y la longitud de secuencia).
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

LlavaNextVideoCausalLMOutputWithPast o tuple(torch.Tensor)

Un LlavaNextVideoCausalLMOutputWithPast 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 (LlavaNextVideoConfig) y las entradas.

El método forward de LlavaNextVideoForConditionalGeneration 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 pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

loss (torch.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida de modelado de lenguaje (para la predicción del siguiente token).
logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).
past_key_values (Cache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.

Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención) que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.
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.
image_hidden_states (torch.Tensor, opcional) — Un torch.Tensor de tamaño (batch_size * num_patches, num_images, sequence_length, hidden_size)`. image_hidden_states del modelo generado por el codificador de visión y después de proyectar el último estado oculto.
video_hidden_states (torch.Tensor, opcional) — Un torch.Tensor de tamaño (batch_size * num_frames, num_videos, sequence_length, hidden_size). video_hidden_states del modelo generado por el codificador de visión y después de proyectar el último estado oculto.

Ejemplo:

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

>>> def read_video_pyav(container, indices):
...     '''
...     Decode the video with PyAV decoder.
...     Args:
...         container (`av.container.input.InputContainer`): PyAV container.
...         indices (`list[int]`): List of frame indices to decode.
...     Returns:
...         result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
...     '''
...     frames = []
...     container.seek(0)
...     start_index = indices[0]
...     end_index = indices[-1]
...     for i, frame in enumerate(container.decode(video=0)):
...         if i > end_index:
...             break
...         if i >= start_index and i in indices:
...             frames.append(frame)
...     return np.stack([x.to_ndarray(format="rgb24") for x in frames])

>>> model = LlavaNextVideoForConditionalGeneration.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf", device_map="auto")
>>> processor = AutoProcessor.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")

>>> prompt = "USER: <video>\nWhy is this video funny? ASSISTANT:"
>>> video_path = hf_hub_download(repo_id="raushan-testing-hf/videos-test", filename="sample_demo_1.mp4", repo_type="dataset")
>>> container = av.open(video_path)

>>> # sample uniformly 8 frames from the video (model was trained with 32 frames per video, but this video is short)
>>> total_frames = container.streams.video[0].frames
>>> indices = np.arange(0, total_frames, total_frames / 8).astype(int)
>>> clip = read_video_pyav(container, indices)
>>> inputs_video = processor(text=prompt, videos=clip, return_tensors="pt").to(model.device)

>>> # load an image to generate from an image
>>> prompt = "USER:<image>\nWhat is shown in this image? ASSISTANT:"
>>> url = "https://www.ilankelman.org/stopsigns/australia.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))
>>> inputs_image = processor(text=prompt, images=image, return_tensors="pt").to(model.device)

>>> # Generate from video
>>> generate_ids = model.generate(**inputs_video, max_length=50)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"USER:\nWhy is this video funny? ASSISTANT: The humor in this video comes from the unexpected and endearing sight of a baby wearing glasses and (...)"

>>> # Generate from image
>>> generate_ids = model.generate(**inputs_image, max_length=30)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"USER: \nWhat's the content of the image? ASSISTANT: The image shows a red stop sign on a pole, with a traditional Chinese archway (...)"

get_image_features

< source >

Parámetros

pixel_values (torch.Tensor de forma (batch_size, num_patches, channels, height, width)) — Los tensores correspondientes a las imágenes de entrada.
image_sizes (torch.Tensor de forma (num_images, 2)) — Tamaño real de cada imagen (H, W).
vision_feature_layer (Union[int, list[int]], opcional) — El índice de la capa de la que seleccionar la característica visual. Si se proporcionan varios índices, las características visuales de los índices correspondientes se concatenarán para formar las características visuales.
image_sizes (torch.Tensor de forma (batch_size, 2)) — Los tamaños de las imágenes del lote, siendo (altura, ancho) para cada imagen.
vision_feature_layer (Union[int, list[int]], opcional) — El índice de la capa de la que seleccionar la característica visual. Si se proporcionan varios índices, las características visuales de los índices correspondientes se concatenarán para formar las características visuales.
vision_feature_select_strategy (str, opcional) — La estrategia de selección de características utilizada para seleccionar la característica visual del backbone visual. Puede ser "default" o "full"

Devuelve

BaseModelOutputWithPooling o tuple(torch.Tensor)

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, devuelto 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.

Ejemplo:

>>> from PIL import Image
>>> from transformers import AutoProcessor, LlavaNextVideoForConditionalGeneration

>>> model = LlavaNextVideoForConditionalGeneration.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")
>>> processor = AutoProcessor.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")

>>> 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]

get_video_features

< source >

Parámetros

pixel_values_videos (torch.Tensor] de forma (batch_size, num_frames, channels, height, width)) — Los tensores correspondientes al video de entrada.
vision_feature_layer (Union[int, list[int]], opcional) — El índice de la capa de la que seleccionar la característica visual. Si se proporcionan varios índices, las características visuales de los índices correspondientes se concatenarán para formar las características visuales.
vision_feature_layer (Union[int, list[int]], opcional) — El índice de la capa de la que seleccionar la característica visual. Si se proporcionan varios índices, las características visuales de los índices correspondientes se concatenarán para formar las características visuales.
vision_feature_select_strategy (str, opcional) — La estrategia de selección de características utilizada para seleccionar la característica visual del backbone visual. Puede ser "default" o "full"

Devuelve

BaseModelOutputWithPooling o tuple(torch.Tensor)

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, devuelto 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.

Ejemplo:

>>> from PIL import Image
>>> from transformers import AutoProcessor, LlavaNextVideoForConditionalGeneration

>>> model = LlavaNextVideoForConditionalGeneration.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")
>>> processor = AutoProcessor.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")

>>> 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]

Update on GitHub

←LLaVA-NeXT LLaVA-Onevision→