# LLaVa-NeXT-Video

## Aperçu

Le modèle LLaVa-NeXT-Video a été proposé dans [LLaVA-NeXT: A Strong Zero-shot Video Understanding Model](https://llava-vl.github.io/blog/2024-04-30-llava-next-video/) par Yuanhan Zhang, Bo Li, Haotian Liu, Yong Jae Lee, Liangke Gui, Di Fu, Jiashi Feng, Ziwei Liu, Chunyuan Li. LLaVa-NeXT-Video améliore [LLaVa-NeXT](llava_next) en effectuant un fine-tuning sur un mélange de jeux de données vidéo et image, ce qui augmente les performances du modèle sur les vidéos.

[LLaVA-NeXT](llava_next) présente, de manière surprenante, de solides performances en compréhension du contenu vidéo en mode zero-shot grâce à la technique AnyRes qu’il utilise. La technique AnyRes représente naturellement une image haute résolution sous forme de plusieurs images. Cette technique est naturellement généralisable à la représentation de vidéos, car celles-ci peuvent être considérées comme un ensemble de frames (similaire à un ensemble d’images dans LLaVa-NeXT). La version actuelle de LLaVA-NeXT exploite AnyRes et s’entraîne par fine-tuning supervisé (SFT) sur des données vidéo, en partant de LLaVA-Next, afin d’atteindre de meilleures capacités de compréhension vidéo. Le modèle est actuellement SOTA parmi les modèles open-source sur le [VideoMME bench](https://huggingface.co/papers/2405.21075).

L'introduction du blog est la suivante :

Le 30 janvier 2024, nous avons publié LLaVA-NeXT, un grand modèle multimodal (LMM) open source entraîné exclusivement sur des données texte-image. Grâce à la technique AnyRes proposée, il renforce les capacités de raisonnement, d'OCR et de connaissances du monde, démontrant des performances remarquables sur un large éventail de tâches de compréhension multimodale basées sur l'image, et dépassant même Gemini-Pro sur plusieurs benchmarks d'images, par exemple MMMU et MathVista.

**Dans cette exploration, nous examinons les performances de LLaVA-NeXT dans le domaine des tâches de compréhension vidéo. Nous constatons que LLaVA-NeXT présente, de manière surprenante, de solides performances dans la compréhension du contenu vidéo. La version actuelle de LLaVA-NeXT pour les vidéos apporte plusieurs améliorations :**

- Capacités de représentation vidéo en zéro tir avec AnyRes : la technique AnyRes représente naturellement une image haute résolution en plusieurs images qu'un VIT pré-entraîne peut traiter, et les forme en une séquence concaténée. Cette technique est naturellement généralisable pour représenter des vidéos (composées de plusieurs images), permettant au modèle LLaVA-Next entraîné uniquement sur des images de se comporter de manière surprenante bien sur les tâches vidéo. Notamment, c'est la première fois que les LMMs montrent une forte capacité de transfert de modalité en zéro tir.
- L’inférence avec généralisation de la longueur améliore les performances sur les vidéos plus longues. La technique de mise à l’échelle linéaire permet la généralisation de la longueur, ce qui permet à LLaVA-NeXT de traiter efficacement les vidéos longues au-delà de la limite « max_token_length » du LLM.
- Capacité de compréhension vidéo robuste. (1) LLaVA-Next-Image, qui combine les deux techniques ci-dessus, offre des performances zero-shot supérieures à celles des LMM open-source entraînés sur des vidéos. (2) LLaVA-Next-Video, qui effectue un fine-tuning supervisé (SFT) supplémentaire de LLaVA-Next-Image sur des données vidéo, atteint de meilleures capacités de compréhension vidéo par rapport à LLaVA-Next-Image. (3) LLaVA-Next-Video-DPO, qui aligne la réponse du modèle avec le retour d'information de l'IA en utilisant l'optimisation directe des préférences (DPO), montre une amélioration significative des performances.
- Déploiement et inférence efficaces avec SGLang. Il permet une inférence 5 fois plus rapide sur les tâches vidéo, permettant un service plus scalable, comme la ré-description de vidéos à l'échelle du million. Consultez les instructions dans notre dépôt.**

Ce modèle a été contribué par [RaushanTurganbay](https://huggingface.co/RaushanTurganbay). Le code d'origine peut être trouvé [ici](https://github.com/LLaVA-VL/LLaVA-NeXT/tree/inference).

## Conseils d'utilisation

- Nous recommandons aux utilisateurs d'utiliser `padding_side="left"` lors du calcul de la génération par lots, car cela conduit à des résultats plus précis. Assurez-vous simplement d'appeler `processor.tokenizer.padding_side = "left"` avant de générer.

- Llava-Next utilise un nombre de patches différent pour les images et doit donc effectuer un bourrage des entrées dans le code de modélisation, en plus du bourrage réalisé lors du traitement des entrées. Le réglage par défaut est « left-padding » si le modèle est en mode `eval()`, sinon « right-padding ».

> [!NOTE]
> Les modèles LLaVA publiés après la version v4.46 émettront des avertissements concernant l’ajout de `processor.patch_size = {{patch_size}}`, `processor.num_additional_image_tokens = {{num_additional_image_tokens}}` et `processor.vision_feature_select_strategy = {{vision_feature_select_strategy}}`. Il est vivement recommandé d’ajouter ces attributs au processeur si vous êtes propriétaire du point de contrôle du modèle, ou d’ouvrir une demande de pull s’il ne vous appartient pas.
L’ajout de ces attributs permet à LLaVA de tenter de déduire le nombre de jetons d’image requis par image et d’étendre le texte avec autant de placeholders `<image>` qu’il y aura de jetons. Il s’agit généralement d’environ 500 jetons par image, il est donc essentiel de s’assurer que le texte n’est pas tronqué, car sinon une erreur se produira lors de la fusion des embeddings. Les attributs peuvent être obtenus à partir de la configuration du modèle, par exemple `model.config.vision_config.patch_size` ou `model.config.vision_feature_select_strategy`. L’attribut `num_additional_image_tokens` doit être `1` si l’architecture visuelle ajoute un jeton CLS, ou `0` si rien d’autre n’est ajouté aux patches visuels.

### Mise en forme des prompts avec des modèles de chat  

Chaque **checkpoint** est entraîné avec un format de prompt spécifique, en fonction du modèle de langage de grande taille sous-jacent. Pour garantir un formatage correct, utilisez la méthode `apply_chat_template` du processeur.

**Important :**

- Vous devez construire un historique de conversation — passer une simple chaîne de caractères ne fonctionnera pas.
- Chaque message doit être un dictionnaire avec les clés `"role"` et `"content"`.
- Le `"content"` doit être une liste de dictionnaires pour différentes modalités comme `"text"` et `"image"`.

Voici un exemple de la structure à donner à votre entrée. Nous utiliserons [LLaVA-NeXT-Video-7B-hf](https://huggingface.co/llava-hf/LLaVA-NeXT-Video-7B-hf) et un historique de conversation composé de vidéos et d’images.

```python
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 vous utilisez `transformers>=4.49.0`, vous pouvez également obtenir une sortie vectorisée à partir de `apply_chat_template`. Consultez les **Exemples d'utilisation** ci-dessous pour plus de détails sur son utilisation.

## Exemple d'utilisation

### Mode média unique

Le modèle peut accepter à la fois des images et des vidéos en entrée. Voici un exemple de code pour l'inférence en demi-précision (`torch.float16`) :

```python
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)
```

### Mode multimédia

Le modèle peut également générer à partir d'entrées image-vidéo alternées. Notez toutefois qu'il n'a pas été entraîné dans un contexte image-vidéo alterné, ce qui peut affecter les performances. Voici un exemple d'utilisation pour une entrée multimédia mixte, ajoutez les lignes suivantes à l'extrait de code ci-dessus :

```python

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

```

## Optimisation des modèles

### Quantification à l'aide de Bitsandbytes pour une efficacité mémoire

Le modèle peut être chargé en bits inférieurs, réduisant considérablement la charge mémoire tout en conservant les performances du modèle d'origine. Cela permet un déploiement efficace dans les cas à ressources limitées.

Tout d'abord, assurez-vous d'installer bitsandbytes en exécutant `pip install bitsandbytes` et d'avoir accès à un GPU/accélérateur pris en charge par la bibliothèque.

bitsandbytes est en cours de refonte pour prendre en charge plusieurs backends au-delà de CUDA. Actuellement, les implémentations ROCm (GPU AMD) et Intel CPU sont matures, l'Intel XPU est en cours de développement et la prise en charge d'Apple Silicon est attendue pour le T4/T1. Pour les instructions d'installation et les dernières mises à jour des backends, consultez [ce lien](https://huggingface.co/docs/bitsandbytes/main/en/installation#multi-backend).

Nous valorisons vos retours pour aider à identifier les bugs avant la sortie complète ! Consultez [ces documents](https://huggingface.co/docs/bitsandbytes/main/en/non_cuda_backends) pour plus de détails et les liens de retour.

Chargez ensuite simplement le modèle quantifié en ajoutant [BitsAndBytesConfig](/docs/transformers/v5.23.0/fr/main_classes/quantization#transformers.BitsAndBytesConfig) comme indiqué ci-dessous :

```python
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 pour accélérer la génération

De plus, nous pouvons accélérer considérablement l'inférence du modèle en utilisant [Flash Attention](../kernel_doc/loading_kernels#attention-kernels), qui est une implémentation plus rapide du mécanisme d'attention utilisé à l'intérieur du modèle.

Premièrement, assurez-vous d'installer la dernière version de Flash Attention 2 :

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

De plus, vous devez disposer d'un matériel compatible avec Flash-Attention 2. En savoir plus dans la documentation officielle du [dépôt flash attention](https://github.com/Dao-AILab/flash-attention). FlashAttention-2 ne peut être utilisé que lorsqu'un modèle est chargé en `torch.float16` ou `torch.bfloat16`.

Pour charger et exécuter un modèle en utilisant Flash Attention-2, il suffit d’ajouter `attn_implementation="flash_attention_2"` lors du chargement du modèle, comme suit :

```python
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[[transformers.LlavaNextVideoConfig]]

#### transformers.LlavaNextVideoConfig[[transformers.LlavaNextVideoConfig]]

```python
transformers.LlavaNextVideoConfig(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 = 32001, video_token_index: int = 32000, projector_hidden_act: str = 'gelu', vision_feature_select_strategy: typing.Literal['default', 'full'] = 'default', vision_feature_layer: int | list[int] = -2, multimodal_projector_bias: bool = True, tie_word_embeddings: bool = False, image_grid_pinpoints: list | None = None, spatial_pool_mode: str = 'average', spatial_pool_stride: int = 2, image_seq_length: int = 576, video_seq_length: int = 288)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/configuration_llava_next_video.py#L32)

**Paramètres :**

vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone visuel.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone de texte.

image_token_index (`int`, *facultatif*, valeur par défaut `32001`) : L'index du jeton d'image utilisé comme espace réservé pour les images d'entrée.

video_token_index (`int`, *facultatif*, valeur par défaut `32000`) : L'index du jeton vidéo utilisé comme espace réservé pour les vidéos d'entrée.

projector_hidden_act (`str`, *facultatif*, par défaut `gelu`) : Fonction d'activation utilisée par le projecteur multimodal.

vision_feature_select_strategy (`Literal[default, full]`, *facultatif*, valeur par défaut `default`) : Stratégie de sélection des caractéristiques utilisée pour sélectionner la caractéristique visuelle issue du backbone visuel.

vision_feature_layer (`Union[int, list[int]]`, *facultatif*, valeur par défaut `-2`) : L'indice de la couche à partir de laquelle sélectionner la fonction visuelle. Si plusieurs indices sont fournis, les fonctions visuelles des indices correspondants seront concaténées pour former les fonctions visuelles.

multimodal_projector_bias (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut utiliser un biais dans le projecteur multimodal.

tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle.

image_grid_pinpoints (`List`, *facultatif*, valeur par défaut `[[336, 672], [672, 336], [672, 672], [1008, 336], [336, 1008]]`) : une liste des résolutions possibles à utiliser pour le traitement d'images haute résolution. Chaque élément de la liste doit être un tuple ou une liste de la forme `(height, width)`.

spatial_pool_mode (`str`, *facultatif*, valeur par défaut `"average"`) : Mode de pooling à utiliser pour les vidéos. Peut être "average", "max" ou "conv".

spatial_pool_stride (`int`, *facultatif*, valeur par défaut : 2) : Pas utilisé dans la couche de pooling pour les vidéos.

image_seq_length (`int`, *facultatif*, valeur par défaut `576`) : Longueur de séquence d'un embedding d'image.

video_seq_length (`int`, *facultatif*, valeur par défaut `288`) : Longueur de séquence d'un embedding vidéo.

Ceci est la classe de configuration destinée à stocker la configuration d'un LlavaNextVideoModel. Elle est utilisée pour instancier un modèle Llava Next Video en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [llava-hf/LLaVA-NeXT-Video-7B-hf](https://huggingface.co/llava-hf/LLaVA-NeXT-Video-7B-hf)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```python
>>> 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[[transformers.LlavaNextVideoProcessor]]

#### transformers.LlavaNextVideoProcessor[[transformers.LlavaNextVideoProcessor]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/processing_llava_next_video.py#L31)

**Paramètres :**

video_processor (`LlavaNextVideoVideoProcessor`) : le processeur vidéo est une entrée obligatoire.

image_processor (`LlavaNextImageProcessor`) : le processeur d'images est une entrée obligatoire.

tokenizer (`tokenizer_class`) : Le tokenizer est une entrée obligatoire.

chat_template (`str`) : Un modèle Jinja pour convertir des listes de messages d'une conversation en une chaîne tokenisable.

patch_size (`int`, *facultatif*) : Taille du patch issue de la tour visuelle.

vision_feature_select_strategy (`str`, *facultatif*) : La stratégie de sélection des caractéristiques utilisée pour sélectionner la caractéristique visuelle à partir du backbone visuel. Doit être identique à celle de la configuration du modèle

video_token (`str`, *facultatif*, par défaut `"<video>"`) : Jeton spécial utilisé pour indiquer l'emplacement de la vidéo.

image_token (`str`, *facultatif*, valeur par défaut `"<image>"`) : Jeton spécial utilisé pour indiquer l'emplacement de l'image.

num_additional_image_tokens (`int`, *facultatif*, valeur par défaut 0) : Nombre de jetons supplémentaires ajoutés aux embeddings d'image, tels que CLS (+1). Si le backbone n'a pas de CLS ni d'autres jetons supplémentaires ajoutés, il n'est pas nécessaire de définir cet argument.

Construit un LlavaNextVideoProcessor qui encapsule un processeur de vidéo, un processeur d’image et un tokenizer en un seul processeur.

[LlavaNextVideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoProcessor) offre toutes les fonctionnalités de [LlavaNextVideoVideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoVideoProcessor), [LlavaNextImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/granitevision#transformers.LlavaNextImageProcessor) et `tokenizer_class`. Consultez [~LlavaNextVideoVideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoVideoProcessor), [~LlavaNextImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/granitevision#transformers.LlavaNextImageProcessor) et `~tokenizer_class` pour plus d’informations.

## LlavaNextVideoVideoProcessor[[transformers.LlavaNextVideoVideoProcessor]]

#### transformers.LlavaNextVideoVideoProcessor[[transformers.LlavaNextVideoVideoProcessor]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/video_processing_llava_next_video.py#L22)

**Paramètres :**

do_convert_rgb (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut convertir l'image en RGB.

do_resize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'image.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'shortest_edge' : 224}`) : Décrim les dimensions d'entrée maximales du modèle.

default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut par défaut redimensionner l'image en un carré si la taille est un entier.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, par défaut `3`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir de l'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'image.

rescale_factor (`float`, *kwargs*, *facultatif*, valeur par défaut `0.00392156862745098`) : Facteur de remise à l'échelle appliqué à l'image si `do_rescale` est défini sur `True`.

do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser l'image.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.48145466, 0.4578275, 0.40821073]`) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.26862954, 0.26130258, 0.27577711]`) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

do_center_crop (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut effectuer un recadrage centré de l'image.

do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'height' : 224, 'width': 224}`) : Taille de l'image de sortie après application de `center_crop`.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée.

do_sample_frames (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut échantillonner des images de la vidéo avant le traitement ou traiter la vidéo entière.

video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Métadonnées de la vidéo contenant des informations sur la durée totale, le fps et le nombre total d'images. Elles seront utilisées pour échantillonner des images à partir de la vidéo ou pour calculer des horodatages. Ne passez aucune métadonnée à moins de tenter de décoder manuellement la vidéo avant le traitement.

fps (`Annotated[int | float | None, None]`, *kwargs*) : Nombre de cibles à échantillonner par seconde lorsque `do_sample_frames=True`.

num_frames (`Annotated[int | None, None]`, *kwargs*) : Nombre maximal d'images à échantillonner lorsque `do_sample_frames=True`.

return_metadata (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut renvoyer les métadonnées de la vidéo ou non. Les métadonnées de la vidéo sont un objet contenant des informations sur la durée de la vidéo, le nombre d'images par seconde, le backend de décodage, etc.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Si défini, renverra des tenseurs d'un framework particulier. Les valeurs acceptables sont :  - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de NumPy.

- ****kwargs** ([VideosKwargs](/docs/transformers/v5.23.0/fr/main_classes/processors#transformers.VideosKwargs), *facultatif*) : Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.

Construit un processeur vidéo LlavaNextVideoVideoProcessor.

## LlavaNextVideoModel[[transformers.LlavaNextVideoModel]]

#### transformers.LlavaNextVideoModel[[transformers.LlavaNextVideoModel]]

```python
transformers.LlavaNextVideoModel(config: LlavaNextVideoConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/modeling_llava_next_video.py#L303)

**Paramètres :**

config ([LlavaNextVideoConfig](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Llava-Next, qui se compose d'un backbone visuel et d'un modèle de langage sans tête de modélisation du langage.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.LlavaNextVideoModel.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, image_sizes: typing.Optional[torch.LongTensor] = 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'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/modeling_llava_next_video.py#L502)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de [LlavaNextImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/granitevision#transformers.LlavaNextImageProcessor). Voir [LlavaNextImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([LlavaNextVideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoProcessor) utilise [LlavaNextImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/granitevision#transformers.LlavaNextImageProcessor) pour le traitement des images).

pixel_values_videos (`torch.Tensor` de forme `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *facultatif*) : Les tenseurs correspondant à la vidéo d’entrée. Les valeurs de pixels des vidéos peuvent être obtenues à l’aide de [LlavaNextVideoVideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoVideoProcessor). Voir [LlavaNextVideoVideoProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) pour plus de détails ([LlavaNextVideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoProcessor) utilise [LlavaNextVideoVideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoVideoProcessor) pour le traitement des vidéos).

image_sizes (`torch.LongTensor` de forme `(batch_size, 2)`, *facultatif*) : Les dimensions des images du lot, sous la forme (hauteur, largeur) pour chaque image.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`.  Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

vision_feature_layer (`Union[int, list[int]]`, *facultatif*) : L'indice de la couche à partir de laquelle sélectionner la fonction visuelle. Si plusieurs indices sont fournis, les fonctions visuelles des indices correspondants seront concaténées pour former les fonctions visuelles.

vision_feature_select_strategy (`str`, *facultatif*, valeur par défaut `"default"`) : La stratégie de sélection des caractéristiques utilisée pour choisir la caractéristique visuelle issue du backbone visuel. Peut être `"default"` ou `"full"`. Si `"default"`, le jeton CLS est supprimé des caractéristiques visuelles. Si `"full"`, l'ensemble des caractéristiques visuelles est utilisé.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *facultatif*) : Dictionnaire dont les clés sont les modalités prises en charge et les valeurs sont les sorties encodées pour cette modalité. Chaque sortie encodée est un tuple composé de (`pooler_output`, *facultatif* : `last_hidden_states`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `pooler_output` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence de fonctionnalités multimodales de l'encodeur fusionnées dans les embeddings de texte.

**Retourne :** `LlavaNextVideoModelOutputWithPast` ou `tuple(torch.Tensor)`

Un `LlavaNextVideoModelOutputWithPast` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([LlavaNextVideoConfig](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoConfig)) et les entrées.

La méthode forward du modèle [LlavaNextVideoModel](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoModel) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.

  Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée.
- **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **image_hidden_states** (`torch.Tensor`, *facultatif*) -- Un `torch.Tensor` de taille `(batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states du modèle produit par l'encodeur visuel et après projection de l'état caché final.
- **video_hidden_states** (`torch.Tensor`, *facultatif*) -- Un `torch.Tensor` de taille `(batch_size * num_frames, num_videos, sequence_length, hidden_size)`. Les video_hidden_states du modèle, générés par l'encodeur visuel après projection de l'état caché final.

#### get_image_features[[transformers.LlavaNextVideoModel.get_image_features]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/modeling_llava_next_video.py#L389)

**Paramètres :**

pixel_values (`torch.Tensor` de forme `(batch_size, num_patches, channels, height, width)`) : Les tenseurs correspondant aux images d'entrée.

image_sizes (`torch.Tensor` de forme `(num_images, 2)`) : Taille réelle de chaque image (H, W).

vision_feature_layer (`Union[int, list[int]]`, *facultatif*) : L'indice de la couche à partir de laquelle sélectionner la fonction visuelle. Si plusieurs indices sont fournis, les fonctions visuelles des indices correspondants seront concaténées pour former les fonctions visuelles.

image_sizes (`torch.Tensor` de forme `(batch_size, 2)`) : Les dimensions des images du lot, sous la forme (hauteur, largeur) pour chaque image.

vision_feature_layer (`Union[int, list[int]]`, *facultatif*) : L'indice de la couche à partir de laquelle sélectionner la fonction visuelle. Si plusieurs indices sont fournis, les fonctions visuelles des indices correspondants seront concaténées pour former les fonctions visuelles.

vision_feature_select_strategy (`str`, *facultatif*) : La stratégie de sélection des caractéristiques utilisée pour sélectionner la caractéristique visuelle à partir du backbone visuel. Peut être `"default"` ou `"full"`

**Retourne :** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([LlavaNextVideoConfig](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoConfig)) et les entrées.

Obtient les derniers états cachés de l'image depuis la tour de vision et applique la projection multimodale.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

#### get_placeholder_mask[[transformers.LlavaNextVideoModel.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)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/modeling_llava_next_video.py#L461)

Obtient le masque de jetons multimodaux à partir de `input_ids` ou de `inputs_embeds`, et vérifie que le nombre de jetons multimodaux est égal à la longueur des caractéristiques multimodales. Si les longueurs diffèrent, une erreur est levée.

#### get_video_features[[transformers.LlavaNextVideoModel.get_video_features]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/modeling_llava_next_video.py#L595)

**Paramètres :**

pixel_values_videos (`torch.Tensor]` de forme `(batch_size, num_frames, channels, height, width)`) : Les tenseurs correspondant à la vidéo d'entrée.

vision_feature_layer (`Union[int, list[int]]`, *facultatif*) : L'indice de la couche à partir de laquelle sélectionner la fonction visuelle. Si plusieurs indices sont fournis, les fonctions visuelles des indices correspondants seront concaténées pour former les fonctions visuelles.

vision_feature_layer (`Union[int, list[int]]`, *facultatif*) : L'indice de la couche à partir de laquelle sélectionner la fonction visuelle. Si plusieurs indices sont fournis, les fonctions visuelles des indices correspondants seront concaténées pour former les fonctions visuelles.

vision_feature_select_strategy (`str`, *facultatif*) : La stratégie de sélection des caractéristiques utilisée pour sélectionner la caractéristique visuelle à partir du backbone visuel. Peut être `"default"` ou `"full"`

**Retourne :** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([LlavaNextVideoConfig](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoConfig)) et les entrées.

Obtient les derniers états cachés de la vidéo depuis la tour visuelle et applique la projection multimodale.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

#### pack_image_features[[transformers.LlavaNextVideoModel.pack_image_features]]

```python
pack_image_features(image_features, image_sizes, vision_feature_select_strategy, image_newline = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/modeling_llava_next_video.py#L322)

**Paramètres :**

image_features (`list[torch.Tensor]` de longueur num_images, chacun de forme `(num_patches, image_length, embed_dim)`) : Liste de tenseurs de caractéristiques d'image, chacun contenant toutes les caractéristiques visuelles de tous les patches.

image_sizes (`torch.Tensor` de forme `(num_images, 2)`) : Taille réelle de chaque image (H, W).

vision_feature_select_strategy (`str`) : Stratégie de sélection des caractéristiques utilisée pour sélectionner la caractéristique visuelle issue du backbone visuel.

image_newline (`torch.Tensor` de forme `(embed_dim)`) : Nouveau vecteur d'intégration de ligne.

**Retourne :**

image_features (`torch.Tensor` de forme `(all_feat_len, embed_dim)`) feature_lens (`list[int]`) longueur des jetons de chaque image dans image_features

Redimensionner, retirer le padding puis regrouper chaque image_feature dans un unique tenseur image_features contenant tous les vecteurs visuels.

## LlavaNextVideoForConditionalGeneration[[transformers.LlavaNextVideoForConditionalGeneration]]

#### transformers.LlavaNextVideoForConditionalGeneration[[transformers.LlavaNextVideoForConditionalGeneration]]

```python
transformers.LlavaNextVideoForConditionalGeneration(config: LlavaNextVideoConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/modeling_llava_next_video.py#L651)

**Paramètres :**

config ([LlavaNextVideoConfig](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle LLAVA-NeXT, qui se compose d'un backbone de vision et d'un modèle de langage.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.LlavaNextVideoForConditionalGeneration.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, image_sizes: typing.Optional[torch.LongTensor] = 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'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/modeling_llava_next_video.py#L704)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de [LlavaNextImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/granitevision#transformers.LlavaNextImageProcessor). Voir [LlavaNextImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([LlavaNextVideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoProcessor) utilise [LlavaNextImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/granitevision#transformers.LlavaNextImageProcessor) pour le traitement des images).

pixel_values_videos (`torch.Tensor` de forme `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *facultatif*) : Les tenseurs correspondant à la vidéo d’entrée. Les valeurs de pixels des vidéos peuvent être obtenues à l’aide de [LlavaNextVideoVideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoVideoProcessor). Voir [LlavaNextVideoVideoProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) pour plus de détails ([LlavaNextVideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoProcessor) utilise [LlavaNextVideoVideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoVideoProcessor) pour le traitement des vidéos).

image_sizes (`torch.LongTensor` de forme `(batch_size, 2)`, *facultatif*) : Les dimensions des images du lot, sous la forme (hauteur, largeur) pour chaque image.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`.  Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

vision_feature_layer (`Union[int, list[int]]`, *facultatif*) : L'indice de la couche à partir de laquelle sélectionner la fonction visuelle. Si plusieurs indices sont fournis, les fonctions visuelles des indices correspondants seront concaténées pour former les fonctions visuelles.

vision_feature_select_strategy (`str`, *facultatif*) : La stratégie de sélection des caractéristiques utilisée pour sélectionner la caractéristique visuelle issue du backbone visuel. Peut être `"default"` ou `"full"`.

labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être compris dans `[0, ..., config.vocab_size]` ou égaux à -100 (voir la docstring de `input_ids`). Les jetons dont l'indice est défini sur `-100` sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est comprise dans `[0, ..., config.vocab_size]`.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

logits_to_keep (`Union[int, torch.Tensor]`, *facultatif*, valeur par défaut `0`) : Si c'est un `int`, calcule les logits pour les `logits_to_keep` derniers jetons. Si c'est `0`, calcule les logits pour tous les `input_ids` (cas particulier). Seuls les logits du dernier jeton sont nécessaires pour la génération, et les calculer uniquement pour ce jeton peut faire économiser de la mémoire, ce qui devient assez significatif pour les séquences longues ou les tailles de vocabulaire importantes. Si c'est un `torch.Tensor`, il doit être 1D et correspondre aux indices à conserver dans la dimension de la longueur de la séquence. C'est utile lors de l'utilisation du format de tenseurs empilés (une seule dimension pour le lot et la longueur de la séquence).

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *facultatif*) : Dictionnaire dont les clés sont les modalités prises en charge et les valeurs sont les sorties encodées pour cette modalité. Chaque sortie encodée est un tuple composé de (`pooler_output`, *facultatif* : `last_hidden_states`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `pooler_output` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence de fonctionnalités multimodales de l'encodeur fusionnées dans les embeddings de texte.

**Retourne :** `LlavaNextVideoCausalLMOutputWithPast` ou `tuple(torch.Tensor)`

Un `LlavaNextVideoCausalLMOutputWithPast` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([LlavaNextVideoConfig](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoConfig)) et les entrées.

La méthode forward de [LlavaNextVideoForConditionalGeneration](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoForConditionalGeneration) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de modélisation du langage (pour la prédiction du jeton suivant).
- **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).
- **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.
- **hidden_states** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **image_hidden_states** (`torch.Tensor`, *facultatif*) -- Un `torch.Tensor` de taille (batch_size * num_patches, num_images, sequence_length, hidden_size)`. image_hidden_states du modèle produit par l'encodeur visuel et après projection de l'état caché final.
- **video_hidden_states** (`torch.Tensor`, *facultatif*) -- Un `torch.Tensor` de taille `(batch_size * num_frames, num_videos, sequence_length, hidden_size)`. Les video_hidden_states du modèle, générés par l'encodeur visuel après projection de l'état caché final.

Exemple :

```python
>>> 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[[transformers.LlavaNextVideoForConditionalGeneration.get_image_features]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/modeling_llava_next_video.py#L672)

**Paramètres :**

pixel_values (`torch.Tensor` de forme `(batch_size, num_patches, channels, height, width)`) : Les tenseurs correspondant aux images d'entrée.

image_sizes (`torch.Tensor` de forme `(num_images, 2)`) : Taille réelle de chaque image (H, W).

vision_feature_layer (`Union[int, list[int]]`, *facultatif*) : L'indice de la couche à partir de laquelle sélectionner la fonction visuelle. Si plusieurs indices sont fournis, les fonctions visuelles des indices correspondants seront concaténées pour former les fonctions visuelles.

image_sizes (`torch.Tensor` de forme `(batch_size, 2)`) : Les dimensions des images du lot, sous la forme (hauteur, largeur) pour chaque image.

vision_feature_layer (`Union[int, list[int]]`, *facultatif*) : L'indice de la couche à partir de laquelle sélectionner la fonction visuelle. Si plusieurs indices sont fournis, les fonctions visuelles des indices correspondants seront concaténées pour former les fonctions visuelles.

vision_feature_select_strategy (`str`, *facultatif*) : La stratégie de sélection des caractéristiques utilisée pour sélectionner la caractéristique visuelle à partir du backbone visuel. Peut être `"default"` ou `"full"`

**Retourne :** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([LlavaNextVideoConfig](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoConfig)) et les entrées.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

```python
>>> 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[[transformers.LlavaNextVideoForConditionalGeneration.get_video_features]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/llava_next_video/modeling_llava_next_video.py#L821)

**Paramètres :**

pixel_values_videos (`torch.Tensor]` de forme `(batch_size, num_frames, channels, height, width)`) : Les tenseurs correspondant à la vidéo d'entrée.

vision_feature_layer (`Union[int, list[int]]`, *facultatif*) : L'indice de la couche à partir de laquelle sélectionner la fonction visuelle. Si plusieurs indices sont fournis, les fonctions visuelles des indices correspondants seront concaténées pour former les fonctions visuelles.

vision_feature_layer (`Union[int, list[int]]`, *facultatif*) : L'indice de la couche à partir de laquelle sélectionner la fonction visuelle. Si plusieurs indices sont fournis, les fonctions visuelles des indices correspondants seront concaténées pour former les fonctions visuelles.

vision_feature_select_strategy (`str`, *facultatif*) : La stratégie de sélection des caractéristiques utilisée pour sélectionner la caractéristique visuelle à partir du backbone visuel. Peut être `"default"` ou `"full"`

**Retourne :** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([LlavaNextVideoConfig](/docs/transformers/v5.23.0/fr/model_doc/llava_next_video#transformers.LlavaNextVideoConfig)) et les entrées.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

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

