Video-LLaVA
概述
Video-LLaVA 是一种开源多模态 LLM，通过在由 Llava1.5 和 VideChat 生成的多模态指令遵循数据上微调 LlamA/Vicuna 来训练。它是一个基于 Transformer 架构的自回归语言模型。Video-LLaVA 将视觉表示统一到语言特征空间，使 LLM 能够同时对图像和视频执行视觉推理能力。
Video-LLaVA 模型在 Video-LLaVA: Learning United Visual Representation by Alignment Before Projection 中由 Bin Lin、Yang Ye、Bin Zhu、Jiaxi Cui、Munang Ning、Peng Jin、Li Yuan 提出。
论文的摘要如下
大型视觉语言模型 (LVLM) 增强了视觉语言理解中各种下游任务的性能。大多数现有方法将图像和视频编码到单独的特征空间中，然后将其作为输入馈送到大型语言模型。然而，由于缺乏对图像和视频的统一分词，即投影前的错位，大型语言模型 (LLM) 难以从几个较差的投影层学习多模态交互。在这项工作中，我们将视觉表示统一到语言特征空间，以将基础 LLM 推进到统一的 LVLM。因此，我们建立了一个简单但稳健的 LVLM 基线 Video-LLaVA，它从图像和视频的混合数据集学习，相互增强。Video-LLaVA 在 5 个图像问答数据集和 4 个图像基准工具包中，在 9 个图像基准上获得了出色的性能。此外，我们的 Video-LLaVA 在 MSRVTT、MSVD、TGIF 和 ActivityNet 上的性能也分别比 Video-ChatGPT 高出 5.8%、9.9%、18.6% 和 10.1%。值得注意的是，大量实验表明，Video-LLaVA 在统一的视觉表示中相互受益于图像和视频，优于专门为图像或视频设计的模型。我们的目标是这项工作能为 LLM 的多模态输入提供适度的见解。
使用技巧
我们建议用户在计算批次生成时使用 padding_side=“left”，因为它会导致更准确的结果。只需确保在生成之前调用 processor.tokenizer.padding_side = “left”。
请注意，该模型没有经过明确训练来处理同一个提示中的多个图像/视频，尽管这在技术上是可能的，但您可能会遇到不准确的结果。
请注意，视频输入应在输入时正好有 8 帧，因为模型是在这种设置下训练的。
该模型由 RaushanTurganbay 贡献。原始代码可以找到 这里。
使用示例
单媒体模式
该模型可以接受图像和视频作为输入。以下是一半精度 (torch.float16) 推断的示例代码
import av
import torch
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", torch_dtype=torch.float16, device_map="auto")
processor = VideoLlavaProcessor.from_pretrained("LanguageBind/Video-LLaVA-7B-hf")
# Load the video as an np.arrau, 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")
out = model.generate(**inputs, max_new_tokens=60)
processor.batch_decode(out, skip_special_tokens=True, clean_up_tokenization_spaces=True)对于多轮对话，将提示格式更改为
"USER: <video>\nWhat do you see in this video? ASSISTANT: A baby reading a book. USER: Why is the it funny? ASSISTANT:"混合媒体模式
该模型还可以从交织的图像-视频输入中生成。但是请注意，它没有在交织的图像-视频设置中进行训练，这可能会影响性能。以下是混合媒体输入的使用示例，将以下行添加到上面的代码片段中
from PIL import Image
import requests
# 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")
# 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，并且可以访问 CUDA 兼容的 GPU 设备。要加载量化模型，只需添加 BitsAndBytesConfig，如下所示：
from transformers import VideoLlavaForConditionalGeneration, BitsAndBytesConfig
# 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 来显著加快模型推理速度，这是一种更快的注意力机制实现，用于模型内部。
首先，请确保您已安装最新版本的 Flash Attention 2
pip install -U flash-attn --no-build-isolation
此外，您的硬件应与 Flash-Attention 2 兼容。有关更多信息，请参阅 flash attention 存储库 的官方文档。FlashAttention-2 仅在模型以 torch.float16 或 torch.bfloat16 加载时才能使用。
要加载并运行使用 Flash Attention-2 的模型，只需在加载模型时添加 attn_implementation="flash_attention_2"，如下所示：
from transformers import VideoLlavaForConditionalGeneration
model = VideoLlavaForConditionalGeneration.from_pretrained(
"LanguageBind/Video-LLaVA-7B-hf",
torch_dtype=torch.float16,
attn_implementation="flash_attention_2",
).to(0)VideoLlavaConfig
class transformers.VideoLlavaConfig
< 源代码 >( vision_config = None text_config = None ignore_index = -100 image_token_index = 32000 video_token_index = 32001 projector_hidden_act = 'gelu' vision_feature_select_strategy = 'default' vision_feature_layer = -2 **kwargs )
参数
- vision_config (
VideoLlavaVisionConfig, 可选) — 自定义视觉配置或字典。如果未指定，则默认为CLIPVisionConfig。 - text_config (
Union[AutoConfig, dict], 可选) — 文本主干的配置对象。可以是LlamaConfig或MistralConfig中的任何一个。如果未指定，则默认为LlamaConfig。 - ignore_index (
int, 可选，默认为 -100) — 损失函数的忽略索引。 - image_token_index (
int, 可选，默认为 32000) — 用于对图像提示进行编码的图像标记索引。 - video_token_index (
int, 可选，默认为 32001) — 用于对视频提示进行编码的视频标记索引。 - projector_hidden_act (
str, 可选，默认为"gelu") — 多模态投影仪使用的激活函数。
这是用于存储 VideoLlavaForConditionalGeneration 配置的配置类。它用于根据指定的参数实例化 VideoLlava 模型，定义模型架构。使用默认值实例化配置将产生与 LanguageBind/Video-LLaVA-7B-hf 相似的配置。
例如：LanguageBind/Video-LLaVA-7B-hf
配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 文档以了解更多信息。
示例
>>> 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.configVideoLlavaImageProcessor
class transformers.VideoLlavaImageProcessor
< source >( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BICUBIC: 3> do_center_crop: bool = True crop_size: Dict = None do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_convert_rgb: bool = True **kwargs )
参数
- do_resize (
bool, optional, defaults toTrue) — 是否将图像的（高度、宽度）尺寸调整为指定的size。可以在preprocess方法中由do_resize覆盖。 - size (
Dict[str, int]optional, defaults to{"shortest_edge" -- 224}): 调整大小后图像的大小。图像的最短边被调整为 size[“shortest_edge”]，最长边被调整以保持输入纵横比。可以在preprocess方法中由size覆盖。 - resample (
PILImageResampling, optional, defaults toResampling.BICUBIC) — 如果调整图像大小，则使用的重采样过滤器。可以在preprocess方法中由resample覆盖。 - do_center_crop (
bool, optional, defaults toTrue) — 是否将图像居中裁剪到指定的crop_size。可以在preprocess方法中由do_center_crop覆盖。 - crop_size (
Dict[str, int]optional, defaults to 224) — 应用center_crop后输出图像的大小。可以在preprocess方法中由crop_size覆盖。 - do_rescale (
bool, optional, defaults toTrue) — 是否按指定的比例rescale_factor对图像进行缩放。可以在preprocess方法中由do_rescale覆盖。 - rescale_factor (
int或float, 可选, 默认值1/255) — 如果重新缩放图像，要使用的缩放因子。可以在preprocess方法中被rescale_factor覆盖。 - do_normalize (
bool, 可选, 默认值True) — 是否对图像进行归一化。可以在preprocess方法中被do_normalize覆盖。 - image_mean (
float或List[float], 可选, 默认值[0.48145466, 0.4578275, 0.40821073]) — 如果对图像进行归一化，要使用的均值。这是一个浮点数或列表，其长度与图像中通道的数量相同。可以在preprocess方法中被image_mean参数覆盖。 - image_std (
float或List[float], 可选, 默认值[0.26862954, 0.26130258, 0.27577711]) — 如果对图像进行归一化，要使用的标准差。这是一个浮点数或列表，其长度与图像中通道的数量相同。可以在preprocess方法中被image_std参数覆盖。可以在preprocess方法中被image_std参数覆盖。 - do_convert_rgb (
bool, 可选, 默认值True) — 是否将图像转换为 RGB。
构建 CLIP 图像处理器。
preprocess
< 源代码 >( images: List = None videos: List = None do_resize: bool = None size: Dict = None resample: Resampling = None do_center_crop: bool = None crop_size: int = None do_rescale: bool = None rescale_factor: float = None do_normalize: bool = None image_mean: Union = None image_std: Union = None do_convert_rgb: bool = None return_tensors: Union = None data_format: Optional = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None )
参数
- images (
ImageInput, 可选) — 要预处理的图像列表。预期单个或批量的图像，其像素值范围为 0 到 255。如果传入像素值在 0 到 1 之间的图像，请设置do_rescale=False。 - videos (
VideoInput, 可选) — 要预处理的视频列表。预期单个或批量的视频，其像素值范围为 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时有效。 - 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)。
预处理图像或图像批次。
调整大小
< 源代码 >( image: ndarray size: Dict resample: Resampling = <Resampling.BICUBIC: 3> data_format: Union = None input_data_format: Union = None **kwargs )
调整图像大小。图像的最短边调整为 size[“shortest_edge”]，最长边调整为保持输入纵横比。
VideoLlavaProcessor
class transformers.VideoLlavaProcessor
< source >( image_processor = None tokenizer = None chat_template = None **kwargs )
参数
- image_processor (VideoLlavaImageProcessor, optional) — 这是必需的输入参数。
- tokenizer (LlamaTokenizerFast, optional) — 这是必需的输入参数。
- chat_template (
str, optional) — 用于将聊天中的消息列表转换为可标记字符串的 Jinja 模板。
创建一个 VideoLlava 处理器，将 VideoLlava 图像处理器和 Llava 标记器封装到单个处理器中。
VideoLlavaProcessor 提供了 VideoLlavaImageProcessor 和 LlamaTokenizerFast 的所有功能。有关更多信息，请参阅 __call__() 和 decode()。
此方法将其所有参数转发给 LlamaTokenizerFast 的 batch_decode()。有关更多信息，请参阅此方法的文档字符串。
此方法将其所有参数转发给 LlamaTokenizerFast 的 decode()。有关更多信息，请参阅此方法的文档字符串。
VideoLlavaForConditionalGeneration
class transformers.VideoLlavaForConditionalGeneration
< source >( config: VideoLlavaConfig )
参数
- config (VideoLlavaConfig 或
VideoLlavaVisionConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。
VideoLlava 模型由视觉主干和语言模型组成。该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、剪枝头等）。
该模型也是一个 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有事宜。
forward
< source >( input_ids: LongTensor = None pixel_values_images: FloatTensor = None pixel_values_videos: FloatTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None vision_feature_layer: Optional = None vision_feature_select_strategy: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.models.video_llava.modeling_video_llava.VideoLlavaCausalLMOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。如果您提供填充，默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- pixel_values_images (
torch.FloatTensor形状为(batch_size, num_channels, image_size, image_size)) -- 与输入图像相对应的张量。可以使用 [AutoImageProcessor](/docs/transformers/v4.44.0/en/model_doc/auto#transformers.AutoImageProcessor) 获取像素值。有关详细信息，请参见 [VideoLlavaImageProcessor.__call__()](/docs/transformers/v4.44.0/en/model_doc/vit#transformers.ViTFeatureExtractor.__call__) ([]`LlavaProcessor`] 使用 VideoLlavaImageProcessor 处理图像)。 - pixel_values_videos (
torch.FloatTensor形状为(batch_size, num_frames, num_channels, image_size, image_size)) -- 与输入视频相对应的张量。可以使用 [AutoImageProcessor](/docs/transformers/v4.44.0/en/model_doc/auto#transformers.AutoImageProcessor) 获取像素值。有关详细信息，请参见 [VideoLlavaImageProcessor.__call__()](/docs/transformers/v4.44.0/en/model_doc/vit#transformers.ViTFeatureExtractor.__call__) ([]`LlavaProcessor`] 使用 VideoLlavaImageProcessor 处理视频)。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 掩码，用于避免对填充标记索引执行注意力。掩码值选择在[0, 1]中：- 1 表示未掩码的标记，
- 0 表示掩码的标记。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用
past_key_values，则可以选择仅输入最后一个decoder_input_ids（参见past_key_values）。如果您想更改填充行为，则应阅读
modeling_opt._prepare_decoder_attention_mask并修改为您的需求。有关默认策略的更多信息，请参见 论文 中的图表 1。- 1 表示头未掩码，
- 0 表示头掩码。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个词元的 位置嵌入索引。选择范围为[0, config.n_positions - 1]。 什么是位置 ID？ - past_key_values (
tuple(tuple(torch.FloatTensor)), 可选, 当传入use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(tuple(torch.FloatTensor))，每个元组包含两个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，以及两个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的额外张量。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可以用于（参见
past_key_values输入）加速顺序解码。如果使用
past_key_values，用户可以选择仅输入形状为(batch_size, 1)的最后一个decoder_input_ids（没有为此模型提供其过去键值状态的那些），而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。 - inputs_embeds (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多地控制如何将input_ids索引转换为关联的向量，而不是模型的内部嵌入查找矩阵，这将很有用。 - vision_feature_layer (
int, 可选, 默认值为 -2) — 选择视觉特征的层索引。 - vision_feature_select_strategy (
str, 可选, 默认值为"default") — 用于从视觉主干中选择视觉特征的特征选择策略。可以是"default"或"full"之一。 - use_cache (
bool, 可选) — 如果设置为True，则会返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。参数 — labels (
torch.LongTensor形状为(batch_size, sequence_length), 可选): 用于计算掩码语言建模损失的标签。索引应为[0, ..., config.vocab_size]或 -100（参见input_ids文档字符串）。索引设置为-100的词元将被忽略（屏蔽），损失仅针对标签在[0, ..., config.vocab_size]中的词元计算。
返回值
transformers.models.video_llava.modeling_video_llava.VideoLlavaCausalLMOutputWithPast 或 tuple(torch.FloatTensor)
一个 transformers.models.video_llava.modeling_video_llava.VideoLlavaCausalLMOutputWithPast 或 torch.FloatTensor 的元组（如果传入 return_dict=False 或 config.return_dict=False），包含根据配置（VideoLlavaConfig）和输入的不同元素。
-
loss (
torch.FloatTensor形状为(1,), 可选, 当提供labels时返回) — 语言建模损失（用于下一个词元预测）。 -
logits (
torch.FloatTensor形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前的每个词汇表词元的分数）。 -
past_key_values (
tuple(tuple(torch.FloatTensor)), 可选, 当传入use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(tuple(torch.FloatTensor))，每个元组包含两个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量包含预先计算的隐藏状态（自注意力块中的键和值），可以用于（参见
past_key_values输入）加速顺序解码。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（一个用于嵌入的输出，如果模型具有嵌入层，加一个用于每层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态，以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组 (每一层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
-
image_hidden_states (
tuple(torch.FloatTensor), 可选) —torch.FloatTensor的元组 (一个用于图像嵌入的输出，(batch_size, num_images, sequence_length, hidden_size)。视觉编码器，以及可选的感知器产生的模型的图像隐藏状态。
VideoLlavaForConditionalGeneration 的前向方法，覆盖了 __call__ 特殊方法。
虽然前向传递的配方需要在此函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> 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"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> 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']