# Video-LLaVA

## Обзор

Video-LLaVa — это открытая мультимодальная LLM, обученная методом дообучения LlamA/Vicuna на данных для следования мультимодальным инструкциям, сгенерированных с помощью Llava1.5 и VideChat. Это авто-регрессионная языковая модель, основанная на архитектуре трансформера. Video-LLaVa объединяет визуальные представления в пространстве языковых признаков и позволяет LLM выполнять задачи визуального рассуждения как на изображениях, так и на видео одновременно.

Модель Video-LLaVA была предложена в статье [Video-LLaVA: Learning United Visual Representation by Alignment Before Projection](https://huggingface.co/papers/2311.10122) авторами Bin Lin, Yang Ye, Bin Zhu, Jiaxi Cui, Munang Ning, Peng Jin, Li Yuan.

Аннотация из статьи следующая:

*Большая модель «зрение-язык» (LVLM) повысила качество выполнения различных задач, связанных с пониманием визуального и языкового контекста. Большинство существующих подходов кодируют изображения и видео в отдельные пространства признаков, которые затем подаются на вход большим языковым моделям. Однако из-за отсутствия унифицированной токенизации изображений и видео, а именно из-за рассогласования до проекции, большой языковой модели (LLM) сложно обучаться мультимодальным взаимодействиям через несколько неэффективных проекционных слоёв. В данной работе мы объединяем визуальные представления в пространстве языковых признаков, чтобы продвинуть базовую LLM в сторону унифицированной LVLM. В результате мы создали простой, но устойчивый базовый вариант LVLM — Video-LLaVA, который обучается на смешанном наборе данных, содержащем изображения и видео, взаимно усиливая качество обработки каждого из них. Video-LLaVA демонстрирует превосходные результаты на широком спектре из 9 бенчмарков изображений, охватывающих 5 наборов данных для визуального вопросно-ответного взаимодействия и 4 набора инструментов для бенчмарков изображений. Кроме того, наша модель Video-LLaVA превосходит Video-ChatGPT на 5,8%, 9,9%, 18,6% и 10,1% на наборах MSRVTT, MSVD, TGIF и ActivityNet соответственно. Примечательно, что обширные эксперименты показывают, что Video-LLaVA взаимно улучшает качество обработки изображений и видео в рамках унифицированного визуального представления, превосходя модели, разработанные специально для изображений или видео. Мы надеемся, что данная работа даст скромные, но полезные представления о мультимодальных входах для LLM*

## Советы по использованию

- Мы рекомендуем пользователям использовать padding_side="left" при вычислении пакетной генерации, так как это приводит к более точным результатам. Просто убедитесь, что вы вызываете processor.tokenizer.padding_side = "left" перед генерацией.

- Обратите внимание, что модель не была явно обучена для обработки нескольких изображений/видео в одном запросе, хотя технически это возможно, результаты могут быть неточными.

- Обратите внимание, что на входе видео должно содержать ровно 8 кадров, поскольку модели обучались именно в таком режиме.

Эта модель была добавлена пользователем [RaushanTurganbay](https://huggingface.co/RaushanTurganbay). Исходный код можно найти [здесь](https://github.com/PKU-YuanGroup/Video-LLaVA).

> [!NOTE]
> Модели LLaVA после выпуска v4.46 будут выдавать предупреждения о добавлении `processor.patch_size = {{patch_size}}`, `processor.num_additional_image_tokens = {{num_additional_image_tokens}}` и `processor.vision_feature_select_strategy = {{vision_feature_select_strategy}}`. Если вы являетесь владельцем контрольной точки модели, настоятельно рекомендуется добавить эти атрибуты в процессор; если же она вам не принадлежит, создайте pull request.
Добавление этих атрибутов означает, что LLaVA будет пытаться определить количество токенов изображений, необходимых на каждое изображение, и расширить текст таким количеством плейсхолдеров `<image>`, сколько будет токенов. Обычно это около 500 токенов на изображение, поэтому убедитесь, что текст не обрезается, иначе произойдёт сбой при объединении эмбеддингов. Атрибуты можно получить из конфигурации модели, например, как `model.config.vision_config.patch_size` или `model.config.vision_feature_select_strategy`. Значение `num_additional_image_tokens` должно быть `1`, если визуальный бэкбон добавляет CLS-токен, или `0`, если к визуальным патчам ничего дополнительного не добавляется.

## Пример использования

### Одиночный режим медиа

Модель может принимать в качестве входных данных как изображения, так и видео. Ниже приведён пример кода для инференса в половинной точности (`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)
```

Для многоходового диалога измените формат промпта на следующий:

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

### Режим смешанных медиа

Модель также может генерировать вывод на основе чередующихся входных данных изображения и видео. Однако обратите внимание, что она не обучалась в режиме чередования изображений и видео, что может повлиять на качество работы. Ниже приведён пример использования смешанного мультимедийного ввода; добавьте следующие строки в приведённый выше фрагмент кода:

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

## Оптимизация модели

### Квантование с использованием Bitsandbytes для экономии памяти

Модель можно загрузить в формате с пониженной разрядностью, что значительно снижает нагрузку на память при сохранении производительности исходной модели. Это позволяет эффективно разворачивать модель в условиях ограниченных ресурсов.

Сначала убедитесь, что библиотека bitsandbytes установлена с помощью команды `pip install bitsandbytes`, и что у вас есть доступ к поддерживаемому библиотекой GPU/ускорителю.

bitsandbytes переписывается для поддержки нескольких бэкендов помимо CUDA. На данный момент реализации для ROCm (GPU AMD) и Intel CPU являются зрелыми, поддержка Intel XPU находится в разработке, а поддержка Apple Silicon ожидается в IV квартале / I квартале. Инструкции по установке и последние обновления бэкендов доступны по [этой ссылке](https://huggingface.co/docs/bitsandbytes/main/en/installation#multi-backend).

Мы ценим ваши отзывы, которые помогают выявлять ошибки до полного выпуска! Подробнее и ссылки для обратной связи — в [этих документах](https://huggingface.co/docs/bitsandbytes/main/en/non_cuda_backends).

Загрузите квантованную модель, просто добавив [BitsAndBytesConfig](/docs/transformers/main/ru/main_classes/quantization#transformers.BitsAndBytesConfig), как показано ниже:

```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 для ускорения генерации

Кроме того, мы можем значительно ускорить инференс модели, используя [Flash Attention](../kernel_doc/loading_kernels#attention-kernels) — более быструю реализацию механизма внимания, применяемого внутри модели.

Сначала убедитесь, что установлена последняя версия Flash Attention 2:

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

Также у вас должно быть оборудование, совместимое с Flash-Attention 2. Подробнее об этом можно прочитать в официальной документации [репозитория flash attention](https://github.com/Dao-AILab/flash-attention). FlashAttention-2 можно использовать только тогда, когда модель загружена в формате `torch.float16` или `torch.bfloat16`.

Чтобы загрузить и запустить модель с использованием Flash Attention-2, просто добавьте `attn_implementation="flash_attention_2"` при загрузке модели, как показано ниже:

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/video_llava/configuration_video_llava.py#L29)

**Параметры:**

vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *необязательный*) : Объект конфигурации или словарь для визуального бэкбона.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *необязательный*) : Объект конфигурации или словарь текстового бэкбона.

image_token_index (`int`, *необязательный*, по умолчанию `32000`) : Индекс токена изображения, используемый как плейсхолдер для входных изображений.

video_token_index (`int`, *необязательный*, по умолчанию `32001`) : Индекс токена видео, используемый как плейсхолдер для входных видео.

projector_hidden_act (`str`, *необязательный*, по умолчанию `gelu`) : Функция активации, используемая мультимодальным проектором.

vision_feature_select_strategy (`Literal[default, full]`, *необязательный*, по умолчанию `default`) : Стратегия отбора признаков, используемая для выбора визуального признака из визуального базового блока.

vision_feature_layer (`Union[int, list[int]]`, *необязательный*, по умолчанию `-2`) : Индекс слоя, из которого извлекаются визуальные признаки. Если указано несколько индексов, визуальные признаки соответствующих индексов будут объединены в один набор визуальных признаков.

image_seq_length (`int`, *необязательный*, по умолчанию `256`) : Длина последовательности одного эмбеддинга изображения.

video_seq_length (`int`, *необязательный*, по умолчанию `2056`) : Длина последовательности одного видео-эмбеддинга.

multimodal_projector_bias (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли смещение (bias) в мультимодальном проекторе.

tie_word_embeddings (`bool`, *необязательный*, по умолчанию `False`) : Связывать ли веса эмбеддингов согласно отображению `tied_weights_keys` модели.

Это класс конфигурации для хранения настроек модели VideoLlavaModel. Он используется для создания модели Video Llava в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [LanguageBind/Video-LLaVA-7B-hf](https://huggingface.co/LanguageBind/Video-LLaVA-7B-hf)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig).

Пример:

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/video_llava/image_processing_video_llava.py#L58)

**Параметры:**

do_resize (`bool`, *необязательный*, по умолчанию `True`) : Указывает, следует ли изменить размеры изображения (высота, ширина) до заданного значения `size`. Может быть переопределено параметром `do_resize` в методе `preprocess`.

size (`dict[str, int]` *необязательный*, по умолчанию `{"shortest_edge" : 224}`): Размер изображения после изменения масштаба. Короткая сторона изображения масштабируется до size["shortest_edge"], а длинная сторона масштабируется так, чтобы сохранить исходное соотношение сторон. Может быть переопределено параметром `size` в методе `preprocess`.

resample (`PILImageResampling`, *необязательный*, по умолчанию `Resampling.BICUBIC`) : Фильтр ресемплинга, используемый при изменении размера изображения. Может быть переопределён параметром `resample` в методе `preprocess`.

do_center_crop (`bool`, *необязательный*, по умолчанию `True`) : Указывает, следует ли центрировать обрезку изображения до заданного размера `crop_size`. Может быть переопределено параметром `do_center_crop` в методе `preprocess`.

crop_size (`dict[str, int]` *необязательный*, по умолчанию 224) : Размер выходного изображения после применения `center_crop`. Может быть переопределён параметром `crop_size` в методе `preprocess`.

do_rescale (`bool`, *необязательный*, по умолчанию `True`) : Указывает, следует ли масштабировать изображение с помощью заданного коэффициента `rescale_factor`. Может быть переопределено параметром `do_rescale` в методе `preprocess`.

rescale_factor (`int` или `float`, *необязательный*, по умолчанию `1/255`) : Коэффициент масштабирования, используемый при перемасштабировании изображения. Может быть переопределён параметром `rescale_factor` в методе `preprocess`.

do_normalize (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли нормализовать изображение. Может быть переопределено параметром `do_normalize` в методе `preprocess`.

image_mean (`float` или `list[float]`, *необязательный*, по умолчанию `[0.48145466, 0.4578275, 0.40821073]`) : Среднее значение, используемое при нормализации изображения. Это число с плавающей точкой или список таких чисел, длина которого равна количеству каналов в изображении. Может быть переопределено параметром `image_mean` в методе `preprocess`.

image_std (`float` или `list[float]`, *необязательный*, по умолчанию `[0.26862954, 0.26130258, 0.27577711]`) : Стандартное отклонение, используемое при нормализации изображения. Это число с плавающей точкой или список таких чисел, длина которого равна количеству каналов в изображении. Может быть переопределено параметром `image_std` в методе `preprocess`. Может быть переопределено параметром `image_std` в методе `preprocess`.

do_convert_rgb (`bool`, *необязательный*, по умолчанию `True`) : Преобразовать ли изображение в RGB.

Создаёт процессор изображений 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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/video_llava/image_processing_video_llava.py#L182)

**Параметры:**

images (`ImageInput`, *необязательный*) : Список изображений для предобработки. Ожидается одно изображение или пакет изображений со значениями пикселей в диапазоне от 0 до 255. Если передаются изображения со значениями пикселей в диапазоне от 0 до 1, установите `do_rescale=False`.

do_resize (`bool`, *необязательный*, по умолчанию `self.do_resize`) : Нужно ли изменять размер изображения.

size (`dict[str, int]`, *необязательный*, по умолчанию `self.size`) : Размер изображения после изменения масштаба. Короткая сторона изображения масштабируется до size["shortest_edge"], а длинная сторона масштабируется так, чтобы сохранить исходное соотношение сторон.

resample (`int`, *необязательный*, по умолчанию `self.resample`) : Фильтр ресемплинга, используемый при изменении размера изображения. Может быть одним из значений перечисления `PILImageResampling`. Влияет только в том случае, если `do_resize` установлено в `True`.

do_center_crop (`bool`, *необязательный*, по умолчанию `self.do_center_crop`) : Указывает, следует ли выполнять центрированное обрезание изображения.

crop_size (`dict[str, int]`, *необязательный*, по умолчанию `self.crop_size`) : Размер центрального кадрирования. Влияет только в том случае, если `do_center_crop` установлен в `True`.

do_rescale (`bool`, *необязательный*, по умолчанию `self.do_rescale`) : Нужно ли масштабировать изображение.

rescale_factor (`float`, *необязательный*, по умолчанию `self.rescale_factor`) : Коэффициент масштабирования для изменения размера изображения, если `do_rescale` установлен в `True`.

do_normalize (`bool`, *необязательный*, по умолчанию `self.do_normalize`) : Нужно ли нормализовать изображение.

image_mean (`float` или `list[float]`, *необязательный*, по умолчанию `self.image_mean`) : Среднее значение изображения, используемое для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`.

image_std (`float` или `list[float]`, *необязательный*, по умолчанию `self.image_std`) : Стандартное отклонение изображения, используемое для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`.

do_convert_rgb (`bool`, *необязательный*, по умолчанию `self.do_convert_rgb`) : Преобразовать ли изображение в RGB.

return_tensors (`str` или `TensorType`, *необязательный*) : Тип возвращаемых тензоров. Может быть одним из: - Не задано: возвращает список `np.ndarray`. - `TensorType.PYTORCH` или `'pt'`: возвращает батч типа `torch.Tensor`. - `TensorType.NUMPY` или `'np'`: возвращает батч типа `np.ndarray`.

data_format (`ChannelDimension` или `str`, *необязательный*, по умолчанию `ChannelDimension.FIRST`) : Формат размерности каналов для выходного изображения. Может быть одним из: - `"channels_first"` или `ChannelDimension.FIRST`: изображение в формате (num_channels, height, width). - `"channels_last"` или `ChannelDimension.LAST`: изображение в формате (height, width, num_channels). - Не задано: Использовать формат размерности каналов входного изображения.

input_data_format (`ChannelDimension` или `str`, *необязательный*) : Формат размерности каналов для входного изображения. Если не задано, формат размерности каналов определяется по входному изображению. Может быть одним из: - `"channels_first"` или `ChannelDimension.FIRST`: изображение в формате (num_channels, height, width). - `"channels_last"` или `ChannelDimension.LAST`: изображение в формате (height, width, num_channels). - `"none"` или `ChannelDimension.NONE`: изображение в формате (height, width).

Предобработка изображения или пакета изображений.

## VideoLlavaVideoProcessor[[transformers.VideoLlavaVideoProcessor]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/video_llava/video_processing_video_llava.py#L22)

**Параметры:**

do_convert_rgb (`bool`, *kwargs*, *необязательный*, по умолчанию `True`) : Преобразовать ли изображение в RGB.

do_resize (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Нужно ли изменять размер изображения.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, по умолчанию `{'shortest_edge' : 224}`): Описывает максимальные размеры входных данных для модели.

default_to_square (`bool`, *kwargs*, *optional*, по умолчанию `False`) : Использовать ли квадратное изображение по умолчанию при изменении размера, если size является int.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, по умолчанию `3`) : Фильтр ресемплинга, используемый при изменении размера изображения. Может быть одним из значений перечисления `PILImageResampling`. Влияет только в том случае, если `do_resize` установлено в `True`.

do_rescale (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Нужно ли масштабировать изображение.

rescale_factor (`float`, *kwargs*, *optional*, по умолчанию `0.00392156862745098`) : Коэффициент масштабирования для изменения масштаба изображения, если `do_rescale` установлен в `True`.

do_normalize (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Нужно ли нормализовать изображение.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, по умолчанию `[0.48145466, 0.4578275, 0.40821073]`) : Среднее значение изображения для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, по умолчанию `[0.26862954, 0.26130258, 0.27577711]`) : Стандартное отклонение изображения, используемое для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`.

do_center_crop (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Нужно ли выполнять центрированный кроп изображения.

do_pad (`bool`, *kwargs*, *необязательный*) : Указывает, нужно ли выравнивать изображение. Выравнивание выполняется либо до максимального размера в батче, либо до фиксированного квадратного размера для каждого изображения. Конкретная стратегия выравнивания зависит от модели.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, по умолчанию `{'height' : 224, 'width': 224}`): Размер выходного изображения после применения `center_crop`.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *необязательный*) : Поддерживается только `ChannelDimension.FIRST`. Добавлено для совместимости с медленными процессорами.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Формат размерности каналов для входного изображения. Если не задано, формат размерности каналов определяется по входному изображению. Может быть одним из: - `"channels_first"` или `ChannelDimension.FIRST`: изображение в формате (num_channels, height, width). - `"channels_last"` или `ChannelDimension.LAST`: изображение в формате (height, width, num_channels). - `"none"` или `ChannelDimension.NONE`: изображение в формате (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Устройство для обработки видео. Если не задано, устройство определяется на основе входных видео.

do_sample_frames (`bool`, *kwargs*, *optional*, по умолчанию `False`) : Нужно ли выбирать кадры из видео перед обработкой или обрабатывать всё видео целиком.

video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Метаданные видео, содержащие информацию о общей длительности, fps и общем количестве кадров. Будут использоваться для выборки кадров из видео или вычисления временных меток. Не передавайте метаданные, если вы не пытаетесь декодировать видео вручную перед обработкой

fps (`Annotated[int | float | None, None]`, *kwargs*) : Целевое количество кадров для выборки в секунду при `do_sample_frames=True`.

num_frames (`Annotated[int | None, None]`, *kwargs*) : Максимальное количество кадров для выборки при `do_sample_frames=True`.

return_metadata (`bool`, *kwargs*, *optional*, по умолчанию `False`) : Нужно ли возвращать метаданные видео. Метаданные видео — это объект, содержащий информацию о длительности видео, частоте кадров, бэкенде декодирования и т. д.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Если задано, возвращает тензоры конкретного фреймворка. Допустимые значения:  - `'pt'`: возвращает объекты `torch.Tensor` PyTorch. - `'np'`: возвращает объекты `np.ndarray` NumPy.

- ****kwargs** ([VideosKwargs](/docs/transformers/main/ru/main_classes/processors#transformers.VideosKwargs), *optional*) : Дополнительные параметры обработки для каждой модальности (текст, изображения, видео, аудио). Специфичные для модели параметры перечислены выше; полный список поддерживаемых аргументов см. в классе TypedDict.

Создаёт видеопроцессор 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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/video_llava/processing_video_llava.py#L37)

**Параметры:**

image_processor (`VideoLlavaImageProcessor`) : Процессор изображений является обязательным входным параметром.

video_processor (`VideoLlavaVideoProcessor`) : процессор видео является обязательным входным параметром.

tokenizer (`tokenizer_class`) : Токенизатор является обязательным входным параметром.

patch_size (`int`, *optional*, по умолчанию 14) : Размер патча из визуальной башни.

vision_feature_select_strategy (`str`, *необязательный*, по умолчанию `"default"`) : Стратегия отбора признаков, используемая для выбора визуального признака из визуального базового блока. Должна совпадать с настройкой модели

image_token (`str`, *необязательный*, по умолчанию `"<image>"`) : Специальный токен, используемый для обозначения местоположения изображения.

video_token (`str`, *необязательный*, по умолчанию `"<video>"`) : Специальный токен, используемый для обозначения местоположения видео.

chat_template (`str`) : Шаблон Jinja для преобразования списков сообщений в чате в строку, готовую к токенизации.

num_additional_image_tokens (`int`, *optional*, по умолчанию 1) : Количество дополнительных токенов, добавляемых к эмбеддингам изображения, например CLS (+1). Если у backbone нет CLS или других дополнительных токенов, нет необходимости задавать этот аргумент.

Создаёт VideoLlavaProcessor, объединяющий image processor, video processor и tokenizer в единый процессор.

[VideoLlavaProcessor](/docs/transformers/main/ru/model_doc/video_llava#transformers.VideoLlavaProcessor) предоставляет все возможности [VideoLlavaImageProcessor](/docs/transformers/main/ru/model_doc/video_llava#transformers.VideoLlavaImageProcessor), [VideoLlavaVideoProcessor](/docs/transformers/main/ru/model_doc/video_llava#transformers.VideoLlavaVideoProcessor) и `tokenizer_class`. Подробнее см. в [~VideoLlavaImageProcessor](/docs/transformers/main/ru/model_doc/video_llava#transformers.VideoLlavaImageProcessor), [~VideoLlavaVideoProcessor](/docs/transformers/main/ru/model_doc/video_llava#transformers.VideoLlavaVideoProcessor) и `~tokenizer_class`.

#### __call__[[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'>)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L659)

**Параметры:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *необязательный*) : Изображение для предварительной обработки. Ожидается одно изображение или пакет изображений со значениями пикселей в диапазоне от 0 до 255. Если передаются изображения со значениями пикселей в диапазоне от 0 до 1, установите `do_rescale=False`.

text (`Union[str, list[str], list[list[str]]]`, *необязательный*) : Последовательность или батч последовательностей для кодирования. Каждая последовательность может быть строкой или списком строк (предтокенизированная строка). Если вы передаёте предтокенизированный вход, установите `is_split_into_words=True`, чтобы избежать неоднозначности с батчированными входами.

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]]]`, *optional*) : Видео для предобработки. Ожидается одно видео или батч видео со значениями пикселей в диапазоне от 0 до 255. Если передаются видео со значениями пикселей от 0 до 1, установите `do_rescale=False`.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *необязательный*) : Аудио или пакет аудио для подготовки. Каждое аудио может быть массивом NumPy или тензором PyTorch. В случае массива NumPy/тензора PyTorch каждое аудио должно иметь форму (C, T), где C — количество каналов, а T — длина выборки аудио.

return_tensors (`str` или [TensorType](/docs/transformers/main/ru/internal/file_utils#transformers.TensorType), *optional*) : Если задано, возвращает тензоры конкретного фреймворка. Допустимые значения:  - `'pt'`: возвращает объекты `torch.Tensor` PyTorch. - `'np'`: возвращает объекты `np.ndarray` NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/ru/main_classes/processors#transformers.ProcessingKwargs), *optional*) : Дополнительные параметры обработки для каждой модальности (текст, изображения, видео, аудио). Специфичные для модели параметры перечислены выше; полный список поддерживаемых аргументов см. в классе TypedDict.

## VideoLlavaModel[[transformers.VideoLlavaModel]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/video_llava/modeling_video_llava.py#L154)

**Параметры:**

config ([VideoLlavaConfig](/docs/transformers/main/ru/model_doc/video_llava#transformers.VideoLlavaConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель VideoLlava, состоящая из визуального бэкбона и языковой модели без заголовка для моделирования языка.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/video_llava/modeling_video_llava.py#L288)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`, *необязательный*) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью `image_processor_class`. Подробности см. в `image_processor_class.__call__` (`processor_class` использует `image_processor_class` для обработки изображений).

pixel_values_videos (`torch.Tensor` формы `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *необязательный*) : Тензоры, соответствующие входному видео. Значения пикселей для видео можно получить с помощью `video_processor_class`. Подробности см. в `video_processor_class.__call__` (`processor_class` использует `video_processor_class` для обработки видео).

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое position IDs?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/main/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

vision_feature_layer (`Union[int, list[int]]`, *необязательный*) : Индекс слоя, из которого извлекаются визуальные признаки. Если указано несколько индексов, визуальные признаки соответствующих индексов будут объединены в один набор визуальных признаков.

vision_feature_select_strategy (`str`, *необязательный*) : Стратегия отбора признаков, используемая для выбора визуальных признаков из визуального базового блока. Может принимать значение `"default"` или `"full"`.

use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`).

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *необязательный*) : Словарь, где ключами являются поддерживаемые модальности, а значениями — закодированные выходные данные для данной модальности. Каждый закодированный выход представляет собой кортеж, состоящий из (`pooler_output`, *необязательный*: `last_hidden_states`, *необязательный*: `hidden_states`, *необязательный*: `attentions`) `pooler_output` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) — это последовательность мультимодальных признаков энкодера, объединенных в текстовые эмбеддинги.

**Возвращает:** `VideoLlavaModelOutputWithPast` или `tuple(torch.Tensor)`

`VideoLlavaModelOutputWithPast` или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации (`None`) и входных данных.

Метод forward модели [VideoLlavaModel](/docs/transformers/main/ru/model_doc/video_llava#transformers.VideoLlavaModel) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) -- Последовательность скрытых состояний на выходе последнего слоя модели.
- **past_key_values** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания), которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования.
- **hidden_states** (`tuple[torch.Tensor]`, *необязательный*, возвращается, если передано `output_hidden_states=True` или если `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple[torch.Tensor]`, *необязательный*, возвращается при передаче `output_attentions=True` или когда `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.
- **image_hidden_states** (`torch.Tensor`, *необязательный*) -- `torch.Tensor` размера (batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states модели, полученные визуальным энкодером после проекции последнего скрытого состояния.
- **video_hidden_states** (`torch.Tensor`, *необязательный*) -- `torch.Tensor` размера `(batch_size * num_frames, num_videos, sequence_length, hidden_size)`. video_hidden_states модели, полученные визуальным энкодером после проекции последнего скрытого состояния.

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/video_llava/modeling_video_llava.py#L165)

**Параметры:**

pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`, *необязательный*) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью `image_processor_class`. Подробности см. в `image_processor_class.__call__` (`processor_class` использует `image_processor_class` для обработки изображений).

pixel_values_images (`torch.Tensor` формы `(batch_size, channels, height, width)`) : тензоры, соответствующие входным изображениям.

vision_feature_select_strategy (`str`, *необязательный*) : Стратегия отбора признаков, используемая для выбора визуальных признаков из визуального базового блока. Может принимать значение `"default"` или `"full"`

vision_feature_layer (`Union[int, list[int]]`, *необязательный*) : Индекс слоя, из которого извлекаются визуальные признаки. Если указано несколько индексов, визуальные признаки соответствующих индексов будут объединены в один набор визуальных признаков.

vision_feature_select_strategy (`str`, *необязательный*) : Стратегия отбора признаков, используемая для выбора визуальных признаков из визуального базового блока. Может принимать значение `"default"` или `"full"`.

**Возвращает:** [BaseModelOutputWithPooling](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) или `tuple(torch.Tensor)`

[BaseModelOutputWithPooling](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации (`None`) и входных данных.

Получает последние скрытые состояния изображений из визуальной башни и применяет мультимодальную проекцию.

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели.
- **pooler_output** (`torch.Tensor` формы `(batch_size, hidden_size)`) -- Скрытое состояние последнего слоя для первого токена последовательности (токен классификации) после дополнительной обработки слоями, используемыми для вспомогательной задачи предварительного обучения. Например, для моделей семейства BERT это возвращает токен классификации после обработки линейным слоем и функцией активации tanh. Веса линейного слоя обучаются по задаче предсказания следующего предложения (классификации) во время предварительного обучения.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/video_llava/modeling_video_llava.py#L245)

Получает маску мультимодальных плейсхолдеров из `input_ids` или `inputs_embeds` и проверяет, что количество плейсхолдер-токенов равно длине мультимодальных признаков. Если длины различаются, возникает ошибка.

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/video_llava/modeling_video_llava.py#L211)

**Параметры:**

pixel_values_videos (`torch.Tensor` формы `(batch_size, num_frames, num_channels, frame_size, frame_size)`) : Тензоры, соответствующие входному видео. Значения пикселей для видео можно получить с помощью [VideoLlavaVideoProcessor](/docs/transformers/main/ru/model_doc/video_llava#transformers.VideoLlavaVideoProcessor). Подробности см. в [VideoLlavaVideoProcessor.__call__()](/docs/transformers/main/ru/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) ([VideoLlavaProcessor](/docs/transformers/main/ru/model_doc/video_llava#transformers.VideoLlavaProcessor) использует [VideoLlavaVideoProcessor](/docs/transformers/main/ru/model_doc/video_llava#transformers.VideoLlavaVideoProcessor) для обработки видео).

vision_feature_layer (`Union[int, list[int]]`, *необязательный*) : Индекс слоя, из которого извлекаются визуальные признаки. Если указано несколько индексов, визуальные признаки соответствующих индексов будут объединены в один набор визуальных признаков.

**Возвращает:** [BaseModelOutputWithPooling](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) или `tuple(torch.Tensor)`

Объект [BaseModelOutputWithPooling](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([VideoLlavaConfig](/docs/transformers/main/ru/model_doc/video_llava#transformers.VideoLlavaConfig)) и входных данных.

Получает последние скрытые состояния видео из визуальной башни и применяет мультимодальную проекцию.

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели.
- **pooler_output** (`torch.Tensor` формы `(batch_size, hidden_size)`) -- Скрытое состояние последнего слоя для первого токена последовательности (токен классификации) после дополнительной обработки слоями, используемыми для вспомогательной задачи предварительного обучения. Например, для моделей семейства BERT это возвращает токен классификации после обработки линейным слоем и функцией активации tanh. Веса линейного слоя обучаются по задаче предсказания следующего предложения (классификации) во время предварительного обучения.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

## VideoLlavaForConditionalGeneration[[transformers.VideoLlavaForConditionalGeneration]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/video_llava/modeling_video_llava.py#L370)

**Параметры:**

config ([VideoLlavaConfig](/docs/transformers/main/ru/model_doc/video_llava#transformers.VideoLlavaConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель VideoLlava, состоящая из визуального бэкбона и языковой модели.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/video_llava/modeling_video_llava.py#L406)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`, *необязательный*) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью `image_processor_class`. Подробности см. в `image_processor_class.__call__` (`processor_class` использует `image_processor_class` для обработки изображений).

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/main/ru/model_doc/auto#transformers.AutoImageProcessor). See [VideoLlavaImageProcessor.__call__()](/docs/transformers/main/ru/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) for details ([]`LlavaProcessor`] uses [VideoLlavaImageProcessor](/docs/transformers/main/ru/model_doc/video_llava#transformers.VideoLlavaImageProcessor) for processing images).

pixel_values_videos (`torch.Tensor` формы `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *необязательный*) : Тензоры, соответствующие входному видео. Значения пикселей для видео можно получить с помощью `video_processor_class`. Подробности см. в `video_processor_class.__call__` (`processor_class` использует `video_processor_class` для обработки видео).

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое position IDs?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/main/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

vision_feature_layer (`Union[int, list[int]]`, *необязательный*) : Индекс слоя, из которого извлекаются визуальные признаки. Если указано несколько индексов, визуальные признаки соответствующих индексов будут объединены в один набор визуальных признаков.

vision_feature_select_strategy (`str`, *необязательный*) : Стратегия отбора признаков, используемая для выбора визуальных признаков из визуального базового блока. Может принимать значение `"default"` или `"full"`.

labels (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Метки для вычисления потерь маскированного языкового моделирования. Индексы должны находиться в диапазоне `[0, ..., config.vocab_size]` или равняться -100 (см. docstring `input_ids`). Токены с индексами, установленными в `-100`, игнорируются (маскируются); потери вычисляются только для токенов с метками в диапазоне `[0, ..., config.vocab_size]`.

use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`).

logits_to_keep (`Union[int, torch.Tensor]`, *необязательный*, по умолчанию `0`) : Если передано значение типа `int`, вычисляются logits для последних `logits_to_keep` токенов. Если передано `0`, logits вычисляются для всех `input_ids` (специальный случай). Для генерации нужны logits только последнего токена, и вычисление их только для этого токена позволяет сэкономить память, что становится весьма значимым для длинных последовательностей или большого размера словаря. Если передано значение типа `torch.Tensor`, оно должно быть одномерным и соответствовать индексам, которые нужно сохранить в измерении длины последовательности. Это полезно при использовании упакованного формата тензоров (одно измерение для batch и длины последовательности).

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *необязательный*) : Словарь, где ключами являются поддерживаемые модальности, а значениями — закодированные выходные данные для данной модальности. Каждый закодированный выход представляет собой кортеж, состоящий из (`pooler_output`, *необязательный*: `last_hidden_states`, *необязательный*: `hidden_states`, *необязательный*: `attentions`) `pooler_output` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) — это последовательность мультимодальных признаков энкодера, объединенных в текстовые эмбеддинги.

**Возвращает:** `VideoLlavaCausalLMOutputWithPast` или `tuple(torch.Tensor)`

`VideoLlavaCausalLMOutputWithPast` или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации (`None`) и входных данных.

Метод forward класса [VideoLlavaForConditionalGeneration](/docs/transformers/main/ru/model_doc/video_llava#transformers.VideoLlavaForConditionalGeneration) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потеря языковой модели (для предсказания следующего токена).
- **logits** (`torch.Tensor` формы `(batch_size, sequence_length, config.vocab_size)`) — Оценки предсказаний языковой модели (оценки для каждого токена словаря до применения SoftMax).
- **past_key_values** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания), которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования.
- **hidden_states** (`tuple[torch.Tensor]`, *необязательный*, возвращается, если передано `output_hidden_states=True` или если `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple[torch.Tensor]`, *необязательный*, возвращается при передаче `output_attentions=True` или когда `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.
- **image_hidden_states** (`torch.Tensor`, *необязательный*) -- `torch.Tensor` размера (batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states модели, полученные визуальным энкодером после проекции последнего скрытого состояния.
- **video_hidden_states** (`torch.Tensor`, *необязательный*) -- `torch.Tensor` размера `(batch_size * num_frames, num_videos, sequence_length, hidden_size)`. video_hidden_states модели, полученные визуальным энкодером после проекции последнего скрытого состояния.

Пример:

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/video_llava/modeling_video_llava.py#L383)

**Параметры:**

pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью `image_processor_class`. Подробности см. в `image_processor_class.__call__` (`processor_class` использует `image_processor_class` для обработки изображений).

vision_feature_layer (`Union[int, list[int]]`, *необязательный*) : Индекс слоя, из которого извлекаются визуальные признаки. Если указано несколько индексов, визуальные признаки соответствующих индексов будут объединены в один набор визуальных признаков.

vision_feature_select_strategy (`str`, *необязательный*) : Стратегия отбора признаков, используемая для выбора визуальных признаков из визуального базового блока. Может принимать значение `"default"` или `"full"`

**Возвращает:** [BaseModelOutputWithPooling](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) или `tuple(torch.Tensor)`

[BaseModelOutputWithPooling](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации (`None`) и входных данных.

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели.
- **pooler_output** (`torch.Tensor` формы `(batch_size, hidden_size)`) -- Скрытое состояние последнего слоя для первого токена последовательности (токен классификации) после дополнительной обработки слоями, используемыми для вспомогательной задачи предварительного обучения. Например, для моделей семейства BERT это возвращает токен классификации после обработки линейным слоем и функцией активации tanh. Веса линейного слоя обучаются по задаче предсказания следующего предложения (классификации) во время предварительного обучения.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.