# Video-LLaVA

## Resumen

Video-LLaVa es un LLM multimodal de código abierto entrenado mediante el ajuste fino de LlamA/Vicuna con datos de seguimiento de instrucciones multimodales generados por Llava1.5 y VideChat. Es un modelo de lenguaje autoregresivo, basado en la arquitectura transformer. Video-LLaVa unifica las representaciones visuales en el espacio de características del lenguaje y permite que un LLM realice capacidades de razonamiento visual sobre imágenes y videos simultáneamente.

El modelo Video-LLaVA fue propuesto en [Video-LLaVA: Learning United Visual Representation by Alignment Before Projection](https://huggingface.co/papers/2311.10122) por Bin Lin, Yang Ye, Bin Zhu, Jiaxi Cui, Munang Ning, Peng Jin, Li Yuan.

El resumen del artículo es el siguiente:

*El modelo de visión-lenguaje de gran escala (LVLM) ha mejorado el rendimiento de diversas tareas descendentes en la comprensión visual-lenguaje. La mayoría de los enfoques existentes codifican imágenes y videos en espacios de características separados, que luego se alimentan como entradas a los modelos de lenguaje de gran escala. Sin embargo, debido a la falta de una tokenización unificada para imágenes y videos, es decir, a la falta de alineación antes de la proyección, resulta difícil que un modelo de lenguaje de gran escala (LLM) aprenda interacciones multimodales a partir de varias capas de proyección de baja calidad. En este trabajo, unificamos la representación visual en el espacio de características del lenguaje para avanzar el LLM fundamental hacia un LVLM unificado. Como resultado, establecemos una línea base de LVLM simple pero robusta, Video-LLaVA, que aprende de un conjunto de datos mixto de imágenes y videos, mejorándose mutuamente. Video-LLaVA logra un rendimiento superior en una amplia gama de 9 benchmarks de imágenes a través de 5 conjuntos de datos de preguntas y respuestas de imágenes y 4 kits de herramientas de benchmarks de imágenes. Además, nuestro Video-LLaVA también supera a Video-ChatGPT en un 5.8%, 9.9%, 18.6% y 10.1% en MSRVTT, MSVD, TGIF y ActivityNet, respectivamente. Cabe destacar que, experimentos extensos demuestran que Video-LLaVA beneficia mutuamente a las imágenes y los videos dentro de una representación visual unificada, superando a los modelos diseñados específicamente para imágenes o videos. Esperamos que este trabajo proporcione modestas perspectivas sobre las entradas multimodales para el LLM*

## Consejos de uso

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

- Tenga en cuenta que el modelo no se ha entrenado explícitamente para procesar varias imágenes o videos en el mismo prompt, aunque esto es técnicamente posible, es posible que obtenga resultados inexactos.

- Tenga en cuenta que las entradas de video deben tener exactamente 8 fotogramas en la entrada, ya que los modelos se entrenaron con esa configuración.

Este modelo fue aportado por [RaushanTurganbay](https://huggingface.co/RaushanTurganbay). El código original se puede encontrar [aquí](https://github.com/PKU-YuanGroup/Video-LLaVA).

> [!NOTE]
> 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 los atributos al processor si usted es el propietario del checkpoint del modelo, o abrir un PR si no lo es.
Agregar estos atributos hace que LLaVA intente inferir el número de tokens de imagen necesarios por imagen y expanda el texto con tantos marcadores de posición `<image>` como tokens haya. Por lo general, son alrededor de 500 tokens por imagen, por lo 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 agrega un token CLS, o `0` si no se agrega nada adicional a los patches de visión.

## 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`):

```python
import av
import numpy as np

from transformers import VideoLlavaForConditionalGeneration, VideoLlavaProcessor

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

# Load the model in half-precision
model = VideoLlavaForConditionalGeneration.from_pretrained("LanguageBind/Video-LLaVA-7B-hf", device_map="auto")
processor = VideoLlavaProcessor.from_pretrained("LanguageBind/Video-LLaVA-7B-hf")

# Load the video as an np.array, sampling uniformly 8 frames
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)
total_frames = container.streams.video[0].frames
indices = np.arange(0, total_frames, total_frames / 8).astype(int)
video = read_video_pyav(container, indices)

# For better results, we recommend to prompt the model in the following format
prompt = "USER: <video>\nWhy is this funny? ASSISTANT:"
inputs = processor(text=prompt, videos=video, 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)
```

Para una conversación de varios turnos, cambia el formato del prompt a:

```bash
"USER: <video>\nWhat do you see in this video? ASSISTANT: A baby reading a book. USER: Why is the it funny? ASSISTANT:"
```

### 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:

```python
import requests
from PIL import Image

# Generate from image and video mixed inputs
# Load and image and write a new prompt
url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)
prompt = "USER: <image>\nHow many cats are there in the image? ASSISTANT: There are two cats. USER: <video>\nWhy is this video funny? ASSISTANT:"

inputs = processor(text=prompt, images=image, videos=clip, 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](https://huggingface.co/docs/bitsandbytes/main/en/installation#multi-backend).

¡Valoramos tu feedback para ayudar a identificar errores antes del lanzamiento completo! Consulta [estos documentos](https://huggingface.co/docs/bitsandbytes/main/en/non_cuda_backends) para más detalles y enlaces de feedback.

Cargue el modelo cuantizado simplemente añadiendo [BitsAndBytesConfig](/docs/transformers/v5.23.0/es/main_classes/quantization#transformers.BitsAndBytesConfig) como se muestra a continuación:

```python
from transformers import BitsAndBytesConfig, VideoLlavaForConditionalGeneration

# 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 = VideoLlavaForConditionalGeneration.from_pretrained("LanguageBind/Video-LLaVA-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](../kernel_doc/loading_kernels#attention-kernels), 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:

```bash
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](https://github.com/Dao-AILab/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:

```python
from transformers import VideoLlavaForConditionalGeneration

model = VideoLlavaForConditionalGeneration.from_pretrained(
    "LanguageBind/Video-LLaVA-7B-hf", , 
    attn_implementation="flash_attention_2",
).to(0, device_map="auto")
```

## VideoLlavaConfig[[transformers.VideoLlavaConfig]]

#### transformers.VideoLlavaConfig[[transformers.VideoLlavaConfig]]

```python
transformers.VideoLlavaConfig(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, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, image_token_index: int = 32000, video_token_index: int = 32001, projector_hidden_act: str = 'gelu', vision_feature_select_strategy: typing.Literal['default', 'full'] = 'default', vision_feature_layer: int | list[int] = -2, image_seq_length: int = 256, video_seq_length: int = 2056, multimodal_projector_bias: bool = True, tie_word_embeddings: bool = False)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/video_llava/configuration_video_llava.py#L29)

**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 `32000`) : 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 `32001`) : 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`) : La 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 para 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_seq_length (`int`, *opcional*, valor predeterminado `256`) : Longitud de secuencia de un solo embedding de imagen.

video_seq_length (`int`, *opcional*, valor predeterminado `2056`) : Longitud de secuencia de una incrustación de video.

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 incrustaciones de pesos según el mapeo `tied_weights_keys` del modelo.

Esta es la clase de configuración para almacenar la configuración de un VideoLlavaModel. Se utiliza para instanciar un modelo Video Llava 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 [LanguageBind/Video-LLaVA-7B-hf](https://huggingface.co/LanguageBind/Video-LLaVA-7B-hf)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:

```python
>>> from transformers import VideoLlavaForConditionalGeneration, VideoLlavaConfig, CLIPVisionConfig, LlamaConfig

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

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

>>> # Initializing a VideoLlava video_llava-1.5-7b style configuration
>>> configuration = VideoLlavaConfig(vision_config, text_config)

>>> # Initializing a model from the video_llava-1.5-7b style configuration
>>> model = VideoLlavaForConditionalGeneration(configuration)

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

## VideoLlavaImageProcessor[[transformers.VideoLlavaImageProcessor]]

#### transformers.VideoLlavaImageProcessor[[transformers.VideoLlavaImageProcessor]]

```python
transformers.VideoLlavaImageProcessor(do_resize: bool = True, size: dict[str, int] | None = None, resample: Resampling = <Resampling.BICUBIC: 3>, do_center_crop: bool = True, crop_size: dict[str, int] | None = None, do_rescale: bool = True, rescale_factor: int | float = 0.00392156862745098, do_normalize: bool = True, image_mean: float | list[float] | None = None, image_std: float | list[float] | None = None, do_convert_rgb: bool = True, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/video_llava/image_processing_video_llava.py#L58)

**Parámetros:**

do_resize (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben redimensionar las dimensiones (altura, ancho) de la imagen al `size` especificado. Puede ser anulado por `do_resize` en el método `preprocess`.

size (`dict[str, int]` *opcional*, valor predeterminado `{"shortest_edge" : 224}`): Tamaño de la imagen después de redimensionarla. El lado más corto de la imagen se redimensiona a size["shortest_edge"], y el lado más largo se redimensiona para mantener la relación de aspecto de la entrada. Puede ser sobrescrito por `size` en el método `preprocess`.

resample (`PILImageResampling`, *opcional*, valor predeterminado `Resampling.BICUBIC`) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser anulado por `resample` en el método `preprocess`.

do_center_crop (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe recortar la imagen al centro hasta el `crop_size` especificado. Se puede sobrescribir mediante `do_center_crop` en el método `preprocess`.

crop_size (`dict[str, int]` *opcional*, valor predeterminado: 224) : Tamaño de la imagen de salida tras aplicar `center_crop`. Puede ser sobrescrito por `crop_size` en el método `preprocess`.

do_rescale (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe reescalar la imagen según el factor de escala especificado `rescale_factor`. Puede ser anulado por `do_rescale` en el método `preprocess`.

rescale_factor (`int` o `float`, *opcional*, valor predeterminado `1/255`) : Factor de escala a utilizar si se reescala la imagen. Puede ser anulado por `rescale_factor` en el método `preprocess`.

do_normalize (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe normalizar la imagen. Puede sobrescribirse mediante `do_normalize` en el método `preprocess`.

image_mean (`float` o `list[float]`, *opcional*, valor predeterminado `[0.48145466, 0.4578275, 0.40821073]`) : Media a utilizar si se normaliza la imagen. Es un float o una lista de floats con la longitud del número de canales de la imagen. Puede sobrescribirse mediante el parámetro `image_mean` en el método `preprocess`.

image_std (`float` o `list[float]`, *opcional*, valor predeterminado `[0.26862954, 0.26130258, 0.27577711]`) : Desviación estándar a utilizar si se normaliza la imagen. Es un float o una lista de floats con la longitud del número de canales de la imagen. Puede ser sobrescrito por el parámetro `image_std` en el método `preprocess`. Puede ser sobrescrito por el parámetro `image_std` en el método `preprocess`.

do_convert_rgb (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe convertir la imagen a RGB.

Construye un procesador de imágenes CLIP.

#### preprocess[[transformers.VideoLlavaImageProcessor.preprocess]]

```python
preprocess(images: list[typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]] | None = None, do_resize: bool | None = None, size: dict[str, int] | None = None, resample: PIL.Image.Resampling | None = None, do_center_crop: bool | None = None, crop_size: int | None = None, do_rescale: bool | None = None, rescale_factor: float | None = None, do_normalize: bool | None = None, image_mean: float | list[float] | None = None, image_std: float | list[float] | None = None, do_convert_rgb: bool | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, data_format: transformers.image_utils.ChannelDimension | None = <ChannelDimension.FIRST: 'channels_first'>, input_data_format: str | transformers.image_utils.ChannelDimension | None = None, return_legacy_image_output: bool = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/video_llava/image_processing_video_llava.py#L182)

**Parámetros:**

images (`ImageInput`, *opcional*) : Lista de imágenes para preprocesar. Espera una sola imagen 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`.

do_resize (`bool`, *opcional*, valor predeterminado `self.do_resize`) : Si se debe redimensionar la imagen.

size (`dict[str, int]`, *opcional*, valor predeterminado `self.size`) : Tamaño de la imagen después de redimensionar. El lado más corto de la imagen se redimensiona a size["shortest_edge"], y el lado más largo se redimensiona para mantener la relación de aspecto de la entrada.

resample (`int`, *opcional*, valor predeterminado `self.resample`) : Filtro de remuestreo que se 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_center_crop (`bool`, *opcional*, valor predeterminado `self.do_center_crop`) : Indica si se debe recortar la imagen centrada.

crop_size (`dict[str, int]`, *opcional*, valor predeterminado `self.crop_size`) : Tamaño del recorte central. Solo tiene efecto si `do_center_crop` está establecido en `True`.

do_rescale (`bool`, *opcional*, valor predeterminado `self.do_rescale`) : Si se debe reescalar la imagen.

rescale_factor (`float`, *opcional*, valor predeterminado `self.rescale_factor`) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`.

do_normalize (`bool`, *opcional*, valor predeterminado `self.do_normalize`) : Si se debe normalizar la imagen.

image_mean (`float` o `list[float]`, *opcional*, valor predeterminado `self.image_mean`) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

image_std (`float` o `list[float]`, *opcional*, valor predeterminado `self.image_std`) : Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

do_convert_rgb (`bool`, *opcional*, valor predeterminado `self.do_convert_rgb`) : Indica si se debe convertir la imagen a RGB.

return_tensors (`str` o `TensorType`, *opcional*) : El tipo de tensores a devolver. Puede ser uno de: - Sin establecer: Devuelve una lista de `np.ndarray`. - `TensorType.PYTORCH` o `'pt'`: Devuelve un lote de tipo `torch.Tensor`. - `TensorType.NUMPY` o `'np'`: Devuelve un lote de tipo `np.ndarray`.

data_format (`ChannelDimension` o `str`, *opcional*, valor predeterminado `ChannelDimension.FIRST`) : El formato de la dimensión de canal para la imagen de salida. Puede ser uno de los siguientes: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - Sin establecer: usa el formato de la dimensión de canal de la imagen de entrada.

input_data_format (`ChannelDimension` o `str`, *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 los siguientes: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width).

Preprocesa una imagen o un lote de imágenes.

## VideoLlavaVideoProcessor[[transformers.VideoLlavaVideoProcessor]]

#### transformers.VideoLlavaVideoProcessor[[transformers.VideoLlavaVideoProcessor]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/video_llava/video_processing_video_llava.py#L22)

**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, cuando 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`) : Indica 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` se establece 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 canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal 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 (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada.

do_sample_frames (`bool`, *kwargs*, *opcional*, valor predeterminado `False`) : Indica 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 pases ningún metadato a menos que estés intentando decodificar el video manualmente antes de procesarlo

fps (`Annotated[int | float | None, None]`, *kwargs*) : Marcos 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 video. Los metadatos del video son un objeto que contiene información sobre la duración del video, 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](/docs/transformers/v5.23.0/es/main_classes/processors#transformers.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 VideoLlavaVideoProcessor.

## VideoLlavaProcessor[[transformers.VideoLlavaProcessor]]

#### transformers.VideoLlavaProcessor[[transformers.VideoLlavaProcessor]]

```python
transformers.VideoLlavaProcessor(image_processor = None, video_processor = None, tokenizer = None, patch_size = 14, vision_feature_select_strategy = 'default', image_token = '<image>', video_token = '<video>', chat_template = None, num_additional_image_tokens = 1, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/video_llava/processing_video_llava.py#L27)

**Parámetros:**

image_processor (`VideoLlavaImageProcessor`) : El procesador de imágenes es un parámetro de entrada obligatorio.

video_processor (`VideoLlavaVideoProcessor`) : El procesador de video es una entrada obligatoria.

tokenizer (`tokenizer_class`): El tokenizador es una entrada obligatoria.

patch_size (`int`, *opcional*, valor predeterminado 14) : Tamaño del parche de la torre de visión.

vision_feature_select_strategy (`str`, *opcional*, valor predeterminado `"default"`) : 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

image_token (`str`, *opcional*, valor predeterminado `"<image>"`) : Token especial utilizado para indicar la ubicación de la imagen.

video_token (`str`, *opcional*, valor predeterminado `"<video>"`) : Token especial utilizado para indicar la ubicación del video.

chat_template (`str`) : Una plantilla de Jinja para convertir listas de mensajes de un chat en una cadena tokenizable.

num_additional_image_tokens (`int`, *opcional*, valor predeterminado 1) : 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.

Crea un VideoLlavaProcessor que encapsula un procesador de imágenes, un procesador de video y un tokenizador en un único procesador.

[VideoLlavaProcessor](/docs/transformers/v5.23.0/es/model_doc/video_llava#transformers.VideoLlavaProcessor) ofrece todas las funcionalidades de [VideoLlavaImageProcessor](/docs/transformers/v5.23.0/es/model_doc/video_llava#transformers.VideoLlavaImageProcessor), [VideoLlavaVideoProcessor](/docs/transformers/v5.23.0/es/model_doc/video_llava#transformers.VideoLlavaVideoProcessor) y `tokenizer_class`. Consulte [~VideoLlavaImageProcessor](/docs/transformers/v5.23.0/es/model_doc/video_llava#transformers.VideoLlavaImageProcessor), [~VideoLlavaVideoProcessor](/docs/transformers/v5.23.0/es/model_doc/video_llava#transformers.VideoLlavaVideoProcessor) y `~tokenizer_class` para obtener más información.

#### __llamada__[[transformers.VideoLlavaProcessor.__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] | list[list[str]] | None = None, videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/processing_utils.py#L670)

**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], list[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 (cadena pretokenizada). Si se pasa una entrada pretokenizada, establezca `is_split_into_words=True` para evitar ambigüedad con las entradas en lote.

videos (`Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]`, *opcional*) : Video a preprocesar. Se espera un único video o un lote de videos con valores de píxeles que van de 0 a 255. Si se pasan videos con valores de píxeles entre 0 y 1, establezca `do_rescale=False`.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *opcional*) : El audio o lote de audios que se va a preparar. Cada audio puede ser un array de NumPy o un tensor de PyTorch. En el caso de un array de NumPy/tensor de PyTorch, cada audio debe tener la forma (C, T), donde C es el número de canales y T es la longitud de muestreo del audio.

return_mm_token_type_ids (`bool`, *kwargs*) : Si se deben devolver los ids de tipo de token multimodal que indican las posiciones de los tokens de marcador multimodal.

return_text_replacement_offsets (`bool`, *kwargs*) : Si se deben devolver los desplazamientos de caracteres para cada marcador de posición multimodal y su reemplazo.

return_tensors (`str` o [TensorType](/docs/transformers/v5.23.0/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/v5.23.0/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.

## VideoLlavaModel[[transformers.VideoLlavaModel]]

#### transformers.VideoLlavaModel[[transformers.VideoLlavaModel]]

```python
transformers.VideoLlavaModel(config: VideoLlavaConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/video_llava/modeling_video_llava.py#L155)

**Parámetros:**

config ([VideoLlavaConfig](/docs/transformers/v5.23.0/es/model_doc/video_llava#transformers.VideoLlavaConfig)) : 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/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo VideoLlava, que consta de un backbone de visión y un modelo de lenguaje sin cabeza de modelado de lenguaje.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/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.VideoLlavaModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, vision_feature_layer: int | list[int] | None = None, vision_feature_select_strategy: str | None = None, use_cache: bool | None = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.modeling_flash_attention_utils.FlashAttentionKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/video_llava/modeling_video_llava.py#L289)

**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 mediante [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

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 `image_processor_class`. Consulte `image_processor_class.__call__` para obtener más detalles (`processor_class` utiliza `image_processor_class` 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 los videos se pueden obtener usando `video_processor_class`. Consulte `video_processor_class.__call__` para más detalles (`processor_class` usa `video_processor_class` para procesar videos).

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.LongTensor` 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)

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 utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos 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](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados 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 para 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"`.

use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `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:** `VideoLlavaModelOutputWithPast` o `tuple(torch.Tensor)`

Un `VideoLlavaModelOutputWithPast` 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 (`None`) y las entradas.

El método forward de [VideoLlavaModel](/docs/transformers/v5.23.0/es/model_doc/video_llava#transformers.VideoLlavaModel) reemplaza el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `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)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del modelo.
- **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/v5.23.0/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) 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_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[[transformers.VideoLlavaModel.get_image_features]]

```python
get_image_features(pixel_values: typing.Optional[torch.Tensor] = None, pixel_values_images: typing.Optional[torch.Tensor] = None, vision_feature_layer: int | list[int] | None = None, vision_feature_select_strategy: str | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/video_llava/modeling_video_llava.py#L166)

**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 [VideoLlavaImageProcessor](/docs/transformers/v5.23.0/es/model_doc/video_llava#transformers.VideoLlavaImageProcessor). Consulte [VideoLlavaImageProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles ([VideoLlavaProcessor](/docs/transformers/v5.23.0/es/model_doc/video_llava#transformers.VideoLlavaProcessor) utiliza [VideoLlavaImageProcessor](/docs/transformers/v5.23.0/es/model_doc/video_llava#transformers.VideoLlavaImageProcessor) para procesar las imágenes).

pixel_values_images (`torch.Tensor` de forma `(batch_size, channels, height, width)`) : Los tensores correspondientes a las imágenes de entrada.

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"`

vision_feature_layer (`Union[int, list[int]]`, *opcional*) : El índice de la capa para 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](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/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 ([VideoLlavaConfig](/docs/transformers/v5.23.0/es/model_doc/video_llava#transformers.VideoLlavaConfig)) 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*, 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.

#### get_placeholder_mask[[transformers.VideoLlavaModel.get_placeholder_mask]]

```python
get_placeholder_mask(input_ids: LongTensor, inputs_embeds: Tensor, image_features: typing.Optional[torch.Tensor] = None, video_features: typing.Optional[torch.Tensor] = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/video_llava/modeling_video_llava.py#L246)

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[[transformers.VideoLlavaModel.get_video_features]]

```python
get_video_features(pixel_values_videos: Tensor, vision_feature_layer: int | list[int] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/video_llava/modeling_video_llava.py#L212)

**Parámetros:**

pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_frames, num_channels, frame_size, frame_size)`) : Los tensores correspondientes al video de entrada. Los valores de píxel para los videos se pueden obtener usando [VideoLlavaVideoProcessor](/docs/transformers/v5.23.0/es/model_doc/video_llava#transformers.VideoLlavaVideoProcessor). Consulte [VideoLlavaVideoProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para más detalles ([VideoLlavaProcessor](/docs/transformers/v5.23.0/es/model_doc/video_llava#transformers.VideoLlavaProcessor) utiliza [VideoLlavaVideoProcessor](/docs/transformers/v5.23.0/es/model_doc/video_llava#transformers.VideoLlavaVideoProcessor) para procesar videos).

vision_feature_layer (`Union[int, list[int]]`, *opcional*) : El índice de la capa para 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.

**Devuelve:** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/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 ([VideoLlavaConfig](/docs/transformers/v5.23.0/es/model_doc/video_llava#transformers.VideoLlavaConfig)) y las entradas.

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

## VideoLlavaForConditionalGeneration[[transformers.VideoLlavaForConditionalGeneration]]

#### transformers.VideoLlavaForConditionalGeneration[[transformers.VideoLlavaForConditionalGeneration]]

```python
transformers.VideoLlavaForConditionalGeneration(config: VideoLlavaConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/video_llava/modeling_video_llava.py#L371)

**Parámetros:**

config ([VideoLlavaConfig](/docs/transformers/v5.23.0/es/model_doc/video_llava#transformers.VideoLlavaConfig)) : 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/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo VideoLlava, que consta de un backbone de visión y un modelo de lenguaje.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/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.VideoLlavaForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, pixel_values_images: typing.Optional[torch.Tensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, vision_feature_layer: int | list[int] | None = None, vision_feature_select_strategy: str | None = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/video_llava/modeling_video_llava.py#L407)

**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 mediante [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

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 `image_processor_class`. Consulte `image_processor_class.__call__` para obtener más detalles (`processor_class` utiliza `image_processor_class` para procesar las imágenes).

pixel_values_images (`torch.Tensor` of shape `(batch_size, num_channels, image_size, image_size)) : The tensors corresponding to the input images. Pixel values can be obtained using [AutoImageProcessor](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoImageProcessor). See [VideoLlavaImageProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) for details ([]`LlavaProcessor`] uses [VideoLlavaImageProcessor](/docs/transformers/v5.23.0/es/model_doc/video_llava#transformers.VideoLlavaImageProcessor) for processing images).

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 los videos se pueden obtener usando `video_processor_class`. Consulte `video_processor_class.__call__` para más detalles (`processor_class` usa `video_processor_class` para procesar videos).

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.LongTensor` 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)

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 utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos 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](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados 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 para 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 (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]`.

use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `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`, se calculan los logits para los últimos `logits_to_keep` tokens. Si es `0`, se calculan los logits para todos los `input_ids` (caso especial). Solo se necesitan los logits del último token para la generación, y calcularlos únicamente 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:** `VideoLlavaCausalLMOutputWithPast` o `tuple(torch.Tensor)`

Un `VideoLlavaCausalLMOutputWithPast` 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 (`None`) y las entradas.

El método forward de [VideoLlavaForConditionalGeneration](/docs/transformers/v5.23.0/es/model_doc/video_llava#transformers.VideoLlavaForConditionalGeneration) reemplaza el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `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*, 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](/docs/transformers/v5.23.0/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) 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_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:

```python
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> import numpy as np
>>> import av
>>> from huggingface_hub import hf_hub_download
>>> from transformers import VideoLlavaProcessor, VideoLlavaForConditionalGeneration

>>> 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 = VideoLlavaForConditionalGeneration.from_pretrained("LanguageBind/Video-LLaVA-7B-hf")
>>> processor = VideoLlavaProcessor.from_pretrained("LanguageBind/Video-LLaVA-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
>>> 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 = processor(text=prompt, videos=clip, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(**inputs, max_length=80)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"USER:  Why is this video funny? ASSISTANT: The video is funny because the baby is playing with a Wii remote while sitting on the floor, and the baby is wearing glasses.Ъ. The baby's actions are amusing because it is a young child trying to interact with a video game, which is not a typical activity for a"

>>> # to generate from image and video mix
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))
>>> prompt = [
...     "USER: <image>\nHow many cats do you see? ASSISTANT:",
...     "USER: <video>\nWhy is this video funny? ASSISTANT:"
... ]
>>> inputs = processor(text=prompt, images=image, videos=clip, padding=True, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(**inputs, max_length=50)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
['USER:   How many cats do you see? ASSISTANT: There are two cats visible in the image. (or three, if you count the one in the background).', 'USER:  Why is this video funny? ASSISTANT: The video is funny because it shows a baby sitting on a bed and playing with a Wii remote.Ъ. The baby is holding the remote']
```

#### get_image_features[[transformers.VideoLlavaForConditionalGeneration.get_image_features]]

```python
get_image_features(pixel_values: Tensor, vision_feature_layer: int | list[int] | None = None, vision_feature_select_strategy: str | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/video_llava/modeling_video_llava.py#L384)

**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 mediante `image_processor_class`. Consulte `image_processor_class.__call__` para más detalles (`processor_class` utiliza `image_processor_class` para procesar las imágenes).

vision_feature_layer (`Union[int, list[int]]`, *opcional*) : El índice de la capa para 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](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/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 (`None`) 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.

