LLaVa-NeXT-Video
概述
LLaVa-NeXT-Video 模型由张元瀚、李博、刘浩天、李永在、桂良科、傅迪、冯佳希、刘子维、李春元在 LLaVA-NeXT: A Strong Zero-shot Video Understanding Model 中提出。LLaVa-NeXT-Video 在 LLaVa-NeXT 的基础上进行了改进，通过在视频和图像混合数据集上进行微调，从而提高了模型在视频上的性能。
LLaVa-NeXT 出人意料地在零样本情况下展现出强大的理解视频内容的能力，这得益于它所使用的 AnyRes 技术。AnyRes 技术能够将高分辨率图像自然地表示为多个图像。这种技术自然可以推广到视频表示，因为视频可以被看作是一组帧（类似于 LLaVA-NeXT 中的一组图像）。当前版本的 LLaVA-NeXT 利用 AnyRes 技术，并在 LLaVA-Next 的基础上对视频数据进行监督微调（SFT），从而实现了更好的视频理解能力。该模型在 VideoMME 基准 上是当前开源模型中的 SOTA。
博客中的介绍如下
2024 年 1 月 30 日，我们发布了 LLaVA-NeXT，这是一个完全在文本-图像数据上训练的开源大型多模态模型 (LMM)。通过提出的 AnyRes 技术，它在推理、OCR 和世界知识方面提升了能力，在各种基于图像的多模态理解任务中展现出卓越的性能，甚至在几个图像基准测试中（例如 MMMU 和 MathVista）超越了 Gemini-Pro。
**在今天的探索中，我们深入研究了 LLaVA-NeXT 在视频理解任务中的性能。我们发现 LLaVA-NeXT 在理解视频内容方面出人意料地具有很强的性能。当前版本的 LLaVA-NeXT for videos 有几个改进**
- 使用 AnyRes 的零样本视频表示能力：AnyRes 技术能够将高分辨率图像自然地表示为多个图像，这些图像可以被预训练的 VIT 消化，并形成一个连接的序列。这种技术自然可以推广到视频表示（由多个帧组成），使仅在图像上训练的 LLaVA-Next 模型在视频任务上表现出惊人的性能。值得注意的是，这是 LMM 首次展现出强大的零样本模态迁移能力。
- 具有长度泛化能力的推理在更长的视频上得到改进。线性缩放技术可以实现长度泛化，使 LLaVA-NeXT 能够有效地处理超出 LLM “max_token_length” 限制的长视频。
- 强大的视频理解能力。 (1) LLaVA-Next-Image，它结合了上述两种技术，比在视频上微调的开源 LMM 具有更高的零样本性能。 (2) LLaVA-Next-Video，通过对 LLaVA-Next-Image 在视频数据上进行进一步的监督微调 (SFT)，实现了比 LLaVA-Next-Image 更好的视频理解能力。 (3) LLaVA-Next-Video-DPO，它使用直接偏好优化 (DPO) 使模型响应与 AI 反馈保持一致，展现出显著的性能提升。
- 使用 SGLang 实现高效部署和推理。它可以将视频任务的推理速度提高 5 倍，从而实现更可扩展的视频服务，例如百万级视频重新字幕。有关说明，请参阅我们的仓库。**
该模型由 RaushanTurganbay 贡献。原始代码可以在这里找到 here。
使用技巧
- 我们建议用户在计算批量生成时使用 `padding_side="left"`，因为它可以带来更准确的结果。只需确保在生成之前调用 `processor.tokenizer.padding_side = "left"` 即可。
- Llava-Next 对图像使用不同数量的补丁，因此除了在处理输入时进行的填充之外，还必须在建模代码中填充输入。如果模型处于 `eval()` 模式，则默认设置是“左填充”，否则是“右填充”。
- 请注意，每个检查点都使用特定的提示格式进行训练，具体取决于使用的哪个大型语言模型 (LLM)。您可以使用分词器的 `apply_chat_template` 来正确格式化您的提示。以下是如何执行此操作的示例。
我们将使用 LLaVA-NeXT-Video-7B-hf 和视频和图像的对话历史记录。每个内容字段必须是字典列表，如下所示
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)使用示例
单媒体模式
该模型可以接受图像和视频作为输入。以下是在半精度 ( `torch.float16` ) 中进行推理的示例代码
import av
import torch
import numpy as np
from transformers import LlavaNextVideoForConditionalGeneration, LlavaNextVideoProcessor
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 = LlavaNextVideoForConditionalGeneration.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf", torch_dtype=torch.float16, 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")
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)
conversation = [
{
"role": "user",
"content": [
{"type": "text", "text": "Why is this video funny?"},
{"type": "video"},
],
},
]
prompt = processor.apply_chat_template(conversation, add_generation_prompt=True)
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)混合媒体模式
该模型还可以从交织的图像-视频输入中生成。但是请注意，它不是在交织的图像-视频设置中训练的，这可能会影响性能。以下是混合媒体输入的示例用法，将以下几行添加到上面的代码片段中
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)
conversation = [
{
"role": "user",
"content": [
{"type": "text", "text": "How many cats are there in the image?"},
{"type": "image"},
],
},
{
"role": "assistant",
"content": [{"type": "text", "text": "There are two cats"}],
},
{
"role": "user",
"content": [
{"type": "text", "text": "Why is this video funny?"},
{"type": "video"},
],
},
]
prompt = processor.apply_chat_template(conversation, add_generation_prompt=True)
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 量化以提高内存效率
模型可以以更低的位数加载，从而显着降低内存负担，同时保持原始模型的性能。这使得在资源受限的情况下能够有效地部署模型。
首先确保通过运行 pip install bitsandbytes 来安装 bitsandbytes，并确保可以访问与 CUDA 兼容的 GPU 设备。只需添加 BitsAndBytesConfig 即可加载量化模型，如下所示
from transformers import LlavaNextVideoForConditionalGeneration, LlavaNextVideoProcessor
# 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 加速生成
此外，我们可以通过使用 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 LlavaNextVideoForConditionalGeneration
model = LlavaNextVideoForConditionalGeneration.from_pretrained(
"llava-hf/LLaVA-NeXT-Video-7B-hf",
torch_dtype=torch.float16,
attn_implementation="flash_attention_2",
).to(0)LlavaNextVideoConfig
class transformers.LlavaNextVideoConfig
< source >( vision_config = None text_config = None ignore_index = -100 image_token_index = 32001 projector_hidden_act = 'gelu' vision_feature_select_strategy = 'default' vision_feature_layer = -2 image_grid_pinpoints = None tie_word_embeddings = False video_token_index = 32000 spatial_pool_mode = 'average' spatial_pool_stride = 2 **kwargs )
参数
- vision_config (
Union[AutoConfig, dict], 可选, 默认为CLIPVisionConfig) — 视觉主干的配置对象或字典。 - text_config (
Union[AutoConfig, dict], 可选, 默认为LlamaConfig) — 文本主干的配置对象或字典。 - ignore_index (
int, 可选, 默认为 -100) — 损失函数的忽略索引。 - image_token_index (
int, 可选, 默认为 32001) — 用于编码图像提示的图像令牌索引。 - projector_hidden_act (
str, 可选, 默认为"gelu") — 多模态投影仪使用的激活函数。 - vision_feature_select_strategy (
str, optional, defaults to"default") — 用于从视觉主干选择视觉特征的特征选择策略。可以是"default"或"full"之一。如果为"default"，则从视觉特征中删除 CLS token。如果为"full"，则使用完整的视觉特征。 - vision_feature_layer (
int, optional, defaults to -2) — 选择视觉特征的层的索引。 - image_grid_pinpoints (
List, optional, defaults to[[336, 672], [672, 336], [672, 672], [1008, 336], [336, 1008]]) — 用于处理高分辨率图像的可能的解析度列表。列表中的每个项目应为一个元组或列表，形式为(height, width)。 - tie_word_embeddings (
bool, optional, defaults toFalse) — 模型的输入和输出词嵌入是否应绑定。 - video_token_index (
int, optional, defaults to 32000) — 用于编码图像提示的视频 token 索引。 - spatial_pool_mode (
str, optional, defaults to"average") — 用于视频的池化模式。可以是 “average”、“max” 或 “conv”。 - spatial_pool_stride (
int, optional, defaults to 2) — 用于视频池化层的步长。
这是用于存储 LlavaNextVideoForConditionalGeneration 配置的配置类。它用于根据指定参数实例化 Llava-NeXT 模型，定义模型架构。使用默认值实例化配置将产生类似于 llava-hf/LLaVA-NeXT-Video-7B-hf 模型的配置。配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读来自 PretrainedConfig 的文档以了解更多信息。
示例
>>> 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.configLlavaNextVideoProcessor
class transformers.LlavaNextVideoProcessor
< source >( video_processor = None image_processor = None tokenizer = None chat_template = None **kwargs )
参数
- tokenizer (LlamaTokenizerFast, 可选) — 分词器是必需的输入。
- chat_template (
str, 可选) — 将在分词器的apply_chat_template中使用的 Jinja 聊天模板。
构建一个 LLaVa-NeXT-Video 处理器，它将 LLaVa-NeXT 图片处理器、LLaVa-NeXT-Video 视频处理器和 LLaMa 分词器封装到一个处理器中。
LlavaNextVideoProcessor 提供了 LlavaNextImageProcessor、LlavaNextVideoImageProcessor 和 LlamaTokenizerFast 的所有功能。有关更多信息，请参见 __call__() 和 decode()。
此方法将所有参数转发给 LlamaTokenizerFast 的 batch_decode()。有关更多信息，请参阅此方法的文档字符串。
LlavaNextVideoImageProcessor
class transformers.LlavaNextVideoImageProcessor
< 源代码 >( do_resize: bool = True size: Dict = None image_grid_pinpoints: List = 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, 可选, 默认为True) — 是否将图像的（高度、宽度）尺寸调整为指定的size。可以在preprocess方法中由do_resize覆盖。 - size (
Dict[str, int]可选, 默认值{"shortest_edge" -- 224}): 调整大小后的图像尺寸。图像最短边调整为 size[“shortest_edge”]，最长边调整为保持输入纵横比。可以被preprocess方法中的size参数覆盖。 - image_grid_pinpoints (
List可选, 默认值[[672, 336], [336, 672], [672, 672], [336, 1008], [1008, 336]]) — 用于处理高分辨率图像的可能分辨率列表。根据图像的原始大小选择最佳分辨率。可以被preprocess方法中的image_grid_pinpoints参数覆盖。不适用于视频处理。 - resample (
PILImageResampling, 可选, 默认值Resampling.BICUBIC) — 调整图像大小时使用的重采样过滤器。可以被preprocess方法中的resample参数覆盖。 - do_center_crop (
bool, 可选, 默认值True) — 是否将图像居中裁剪为指定的crop_size。可以被preprocess方法中的do_center_crop参数覆盖。 - crop_size (
Dict[str, int]可选, 默认值 224) — 应用center_crop后输出图像的大小。可以被preprocess方法中的crop_size参数覆盖。 - do_rescale (
bool, 可选, 默认值True) — 是否按指定的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参数覆盖。 - 构建一个 LLaVa-NeXT-Video 视频处理器。基于 CLIPImageProcessor，并结合了对每个视频帧的处理。
预处理
< 源代码 >( images: Union 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 (
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时有效。 - do_convert_rgb (
bool, 可选, 默认为self.do_convert_rgb) — 是否将视频转换为 RGB。 - return_tensors (
str或TensorType, 可选) — 要返回的张量类型。可以是以下之一：- 未设置：返回
np.ndarray的列表。 TensorType.TENSORFLOW或'tf'：返回tf.Tensor类型的批次。TensorType.PYTORCH或'pt'：返回torch.Tensor类型的批次。TensorType.NUMPY或'np'：返回np.ndarray类型的批次。TensorType.JAX或'jax'：返回jax.numpy.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) 格式的图像。
resize
< 源代码 >( image: ndarray size: Dict resample: Resampling = <Resampling.BICUBIC: 3> data_format: Union = None input_data_format: Union = None **kwargs )
调整图像大小。图像的最短边将调整为 size[“shortest_edge”]，最长边将调整以保持输入纵横比。
- images (
LlavaNextVideoForConditionalGeneration
class transformers.LlavaNextVideoForConditionalGeneration
< 源代码 >( config: LlavaNextVideoConfig )
参数
- config (LlavaNextVideoConfig 或
LlavaNextVideoVisionConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained() 方法加载模型权重。
LLAVA-NeXT 模型，包含视觉骨干和语言模型。此模型继承自 PreTrainedModel。查看超类文档了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解有关一般用法和行为的所有事项。
forward
< 源代码 >( input_ids: LongTensor = None pixel_values: FloatTensor = None pixel_values_videos: FloatTensor = None image_sizes: Optional = 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.llava_next_video.modeling_llava_next_video.LlavaNextVideoCausalLMOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。如果您提供填充，默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- pixel_values (
torch.FloatTensor形状为(batch_size, num_channels, image_size, image_size)) — 与输入图像对应的张量。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 LlavaNextVideoImageProcessor.call()。 LlavaProcessor 使用 LlavaNextVideoImageProcessor 处理图像。 - image_sizes (
torch.LongTensor形状为(batch_size, 2)，可选) — 批次中图像的大小，对于每个图像为 (高度，宽度)。 - 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(torch.FloatTensor)元组，每个元组包含 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量）和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），这些状态可以用于（请参阅
past_key_values输入）加快顺序解码速度。如果使用
past_key_values，用户可以选择性地仅输入最后的decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）形状为(batch_size, 1)，而不是所有decoder_input_ids形状为(batch_size, sequence_length)。 - 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"之一。如果为"default"，则从视觉特征中删除 CLS token。如果为"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 而不是一个简单的元组。参数 — 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) 获取。有关详细信息，请参见 LlavaNextVideoVideoProcessor.call。[LlavaProcessor](/docs/transformers/v4.44.0/en/model_doc/llava#transformers.LlavaProcessor) 使用LlavaNextVideoVideoProcessor处理视频。labels (torch.LongTensor形状为(batch_size, sequence_length)，*可选*): 用于计算掩码语言建模损失的标签。索引应在[0, …, config.vocab_size]或 -100 中（参见input_ids文档字符串）。索引设置为-100的标记被忽略（掩码），仅计算标签在[0, …, config.vocab_size]中的标记的损失。
返回
transformers.models.llava_next_video.modeling_llava_next_video.LlavaNextVideoCausalLMOutputWithPast 或 tuple(torch.FloatTensor)
transformers.models.llava_next_video.modeling_llava_next_video.LlavaNextVideoCausalLMOutputWithPast 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包括取决于配置 (LlavaNextVideoConfig) 和输入的各种元素。
-
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时返回) —tuple(torch.FloatTensor)的元组，长度为config.n_layers，每个元组包含 2 个形状为(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)。视觉编码器和可选的感知器生成的模型的图像隐藏状态
The LlavaNextVideoForConditionalGeneration 正向方法，重写 __call__ 特殊方法。
虽然正向传递的配方需要在此函数中定义，但应随后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> 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"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> 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 (...)"