Transformers documentation

InternVL

Transformers

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

该模型于 2025-04-14 在 HF papers 上发布，并于 2025-04-18 贡献至 Hugging Face Transformers。

InternVL

InternVL3 视觉语言模型系列在 InternVL3: Exploring Advanced Training and Test-Time Recipes for Open-Source Multimodal Models 中发布。

该论文的摘要如下：

我们推出了 InternVL3，这是 InternVL 系列的一次重大进展，采用了原生的多模态预训练范式。InternVL3 并非将纯文本大语言模型（LLM）改造为支持视觉输入的多模态大语言模型（MLLM），而是在单一预训练阶段中，同时从多样化的多模态数据和纯文本语料中联合习得多模态与语言能力。这种统一的训练范式有效解决了传统 MLLM 事后训练流程中常见的复杂性和对齐挑战。为了进一步提升性能和可扩展性，InternVL3 引入了可变视觉位置编码（V2PE）以支持扩展的多模态上下文，采用了监督微调（SFT）和混合偏好优化（MPO）等先进的后训练技术，并结合了测试时扩展策略以及优化的训练基础设施。广泛的实证评估表明，InternVL3 在多种多模态任务上均展现出卓越的性能。特别是，InternVL3-78B 在 MMMU 基准测试中取得了 72.2 分，在开源 MLLM 中树立了新的最先进水平。其能力与包括 ChatGPT-4o、Claude 3.5 Sonnet 和 Gemini 2.5 Pro 在内的领先专有模型相比依然极具竞争力，同时保持了强大的纯语言能力。本着开放科学的原则，我们将公开发布训练数据和模型权重，以促进下一代 MLLM 的进一步研究与开发。

Overview of InternVL3 models architecture, which is the same as InternVL2.5. Taken from the original checkpoint. drawing

Comparison of InternVL3 performance on OpenCompass against other SOTA VLLMs. Taken from the original checkpoint.

该模型由 yonigozlan 贡献。原始代码可在此处找到。

在 from_pretrained() 中设置 use_kernels=True，即可用 Hub 上的优化内核替换受支持的层。有关详细信息，请参阅加载内核。

使用示例

使用 Pipeline 进行推理

以下是如何使用 image-text-to-text 流水线，仅用几行代码即可对 InternVL3 模型执行推理：

from transformers import pipeline


messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "image",
                "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg",
            },
            {"type": "text", "text": "Describe this image."},
        ],
    },
]

pipe = pipeline("image-text-to-text", model="OpenGVLab/InternVL3-1B-hf")
outputs = pipe(text=messages, max_new_tokens=50, return_full_text=False)
outputs[0]["generated_text"]
'The image showcases a vibrant scene of nature, featuring several flowers and a bee. \n\n1. **Foreground Flowers**: \n   - The primary focus is on a large, pink cosmos flower with a prominent yellow center. The petals are soft and slightly r'

在单张图像上进行推理

本示例演示了如何使用聊天模板在 InternVL 模型上对单张图像执行推理。

请注意，该模型是使用特定的聊天提示格式进行训练的。请使用 processor.apply_chat_template(my_conversation_dict) 来正确格式化您的提示。


from transformers import AutoModelForImageTextToText, AutoProcessor


model_checkpoint = "OpenGVLab/InternVL3-1B-hf"
processor = AutoProcessor.from_pretrained(model_checkpoint)
model = AutoModelForImageTextToText.from_pretrained(model_checkpoint, device_map="auto")

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "http://images.cocodataset.org/val2017/000000039769.jpg"},
            {"type": "text", "text": "Please describe the image explicitly."},
        ],
    }
]

inputs = processor.apply_chat_template(messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(model.device)

generate_ids = model.generate(**inputs, max_new_tokens=50)
decoded_output = processor.decode(generate_ids[0, inputs["input_ids"].shape[1] :], skip_special_tokens=True)

decoded_output
'The image shows two cats lying on a pink blanket. The cat on the left is a tabby with a mix of brown, black, and white fur, and it appears to be sleeping with its head resting on the blanket. The cat on the'

仅文本生成

本示例展示了如何在不提供任何图像输入的情况下，使用 InternVL 模型生成文本。


from transformers import AutoModelForImageTextToText, AutoProcessor


model_checkpoint = "OpenGVLab/InternVL3-1B-hf"
processor = AutoProcessor.from_pretrained(model_checkpoint)
model = AutoModelForImageTextToText.from_pretrained(model_checkpoint, device_map="auto")

messages = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "Write a haiku"},
        ],
    }
]

inputs = processor.apply_chat_template(messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(model.device)

generate_ids = model.generate(**inputs, max_new_tokens=50)
decoded_output = processor.decode(generate_ids[0, inputs["input_ids"].shape[1] :], skip_special_tokens=True)

print(decoded_output)
"Whispers of dawn,\nSilent whispers of the night,\nNew day's light begins."

批量图像和文本输入

InternVL 模型还支持批量图像和文本输入。


from transformers import AutoModelForImageTextToText, AutoProcessor


model_checkpoint = "OpenGVLab/InternVL3-1B-hf"
processor = AutoProcessor.from_pretrained(model_checkpoint)
model = AutoModelForImageTextToText.from_pretrained(model_checkpoint, device_map="auto")

messages = [
    [
        {
            "role": "user",
            "content": [
                {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/llava_view.jpg"},
                {"type": "text", "text": "Write a haiku for this image"},
            ],
        },
    ],
    [
        {
            "role": "user",
            "content": [
                {"type": "image", "url": "https://www.ilankelman.org/stopsigns/australia.jpg"},
                {"type": "text", "text": "Describe this image"},
            ],
        },
    ],
]


inputs = processor.apply_chat_template(messages, padding=True, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(model.device)

output = model.generate(**inputs, max_new_tokens=25)

decoded_outputs = processor.batch_decode(output, skip_special_tokens=True)
decoded_outputs
["user\n\nWrite a haiku for this image\nassistant\nSilky lake,  \nWooden pier,  \nNature's peace.",
 'user\n\nDescribe this image\nassistant\nThe image shows a street scene with a traditional Chinese archway, known as a "Chinese Gate" or "Chinese Gate of']

批量多图像输入

此 InternVL 模型实现支持批量处理文本-图像输入，且允许每条文本对应不同数量的图像。

from transformers import AutoProcessor, AutoModelForImageTextToText
import torch

model_checkpoint = "OpenGVLab/InternVL3-1B-hf"
processor = AutoProcessor.from_pretrained(model_checkpoint)
model = AutoModelForImageTextToText.from_pretrained(model_checkpoint, device_map="auto")

messages = [
    [
        {
            "role": "user",
            "content": [
                {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/llava_view.jpg"},
                {"type": "text", "text": "Write a haiku for this image"},
            ],
        },
    ],
    [
        {
            "role": "user",
            "content": [
                {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/statue_of_liberty.jpg"},
                {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/dreamstime_golden_gate_flowers.jpg"},
                {"type": "text", "text": "These images depict two different landmarks. Can you identify them?"},
            ],
        },
    ],
]

inputs = processor.apply_chat_template(messages, padding=True, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(model.device)

output = model.generate(**inputs, max_new_tokens=25)

decoded_outputs = processor.batch_decode(output, skip_special_tokens=True)
decoded_outputs
["user\n\nWrite a haiku for this image\nassistant\nSilky lake,  \nWooden pier,  \nNature's peace.",
 'user\n\n\nThese images depict two different landmarks. Can you identify them?\nassistant\nYes, these images depict the Statue of Liberty and the Golden Gate Bridge.']

视频输入

InternVL 模型也可以处理视频输入。下面是一个使用聊天模板对视频输入进行推理的示例。

from transformers import AutoModelForImageTextToText, AutoProcessor, BitsAndBytesConfig


model_checkpoint = "OpenGVLab/InternVL3-8B-hf"
quantization_config = BitsAndBytesConfig(load_in_4bit=True)
processor = AutoProcessor.from_pretrained(model_checkpoint)
model = AutoModelForImageTextToText.from_pretrained(model_checkpoint, quantization_config=quantization_config, device_map="auto")

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "video",
                "url": "https://huggingface.co/datasets/hf-internal-testing/fixtures_videos/resolve/main/tennis.mp4",
            },
            {"type": "text", "text": "What type of shot is the man performing?"},
        ],
    }
]
inputs = processor.apply_chat_template(
    messages,
    return_tensors="pt",
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    num_frames=8,
).to(model.device)

output = model.generate(**inputs, max_new_tokens=25)

decoded_output = processor.decode(output[0, inputs["input_ids"].shape[1] :], skip_special_tokens=True)
decoded_output
'The man is performing a forehand shot.'

交错的图像和视频输入

本示例展示了如何使用聊天模板处理包含交错图像和视频输入的批量聊天对话。

from transformers import AutoProcessor, AutoModelForImageTextToText, BitsAndBytesConfig
import torch

model_checkpoint = "OpenGVLab/InternVL3-1B-hf"
processor = AutoProcessor.from_pretrained(model_checkpoint)
model = AutoModelForImageTextToText.from_pretrained(model_checkpoint, device_map="auto")

messages = [
    [
        {
            "role": "user",
            "content": [
                {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/statue_of_liberty.jpg"},
                {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/dreamstime_golden_gate_flowers.jpg"},
                {"type": "text", "text": "These images depict two different landmarks. Can you identify them?"},
            ],
        },
    ],
    [
        {
            "role": "user",
            "content": [
                {"type": "video", "url": "https://huggingface.co/datasets/hf-internal-testing/fixtures_videos/resolve/main/tennis.mp4"},
                {"type": "text", "text": "What type of shot is the man performing?"},
            ],
        },
    ],
    [
        {
            "role": "user",
            "content": [
                {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/llava_view.jpg"},
                {"type": "text", "text": "Write a haiku for this image"},
            ],
        },
    ],
]
inputs = processor.apply_chat_template(
    messages,
    padding=True,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=25)

decoded_outputs = processor.batch_decode(outputs, skip_special_tokens=True)
decoded_outputs
['user\n\n\nThese images depict two different landmarks. Can you identify them?\nassistant\nThe images depict the Statue of Liberty and the Golden Gate Bridge.',
 'user\nFrame1: \nFrame2: \nFrame3: \nFrame4: \nFrame5: \nFrame6: \nFrame7: \nFrame8: \nWhat type of shot is the man performing?\nassistant\nA forehand shot',
 "user\n\nWrite a haiku for this image\nassistant\nSilky lake,  \nWooden pier,  \nNature's peace."]

InternVLVisionConfig

class transformers.InternVLVisionConfig

< source >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 1024num_hidden_layers: int = 24num_attention_heads: int = 16attention_bias: bool = Falseuse_qk_norm: bool = Falseintermediate_size: int = 4096hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.0attention_dropout: float | int = 0.0projection_dropout: float | int = 0.0initializer_range: float = 0.02norm_type: str = 'layer_norm'layer_norm_eps: float = 1e-06image_size: int | list[int] | tuple[int, ...] = (448, 448)patch_size: int | list[int] | tuple[int, ...] = (14, 14)num_channels: int = 3use_mask_token: bool = Falseuse_absolute_position_embeddings: bool = Truelayer_scale_init_value: float = 0.1use_mean_pooling: bool = True )

参数

hidden_size (int，可选，默认为 1024) — 隐藏表示的维度。
num_hidden_layers (int，可选，默认为 24) — Transformer 解码器中的隐藏层数量。
num_attention_heads (int，可选，默认为 16) — Transformer 解码器中每个注意力层的注意力头数量。
attention_bias (bool，可选，默认为 False) — 在自注意力机制中，是否在 query、key、value 和 output 投影层中使用偏置。
use_qk_norm (bool，可选，默认为 False) — 是否在注意力机制中使用查询-键归一化。
intermediate_size (int，可选，默认为 4096) — MLP 表示的维度。
hidden_act (str，可选，默认为 gelu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、 "relu"、"silu" 等。
hidden_dropout_prob (Union[float, int]，可选，默认为 0.0) — 嵌入层、编码器和池化层中所有全连接层的 dropout 概率。
attention_dropout (Union[float, int]，可选，默认为 0.0) — 注意力概率的 dropout 比率。
projection_dropout (float，可选，默认值为 0.0) — 投影层的 Dropout 概率。
initializer_range (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
norm_type (str, 可选，默认为 "layer_norm") — 编码器中使用的归一化类型。可以是 "layer_norm" 或 "rms_norm"。
layer_norm_eps (float，可选，默认为 1e-06) — 层归一化层所使用的 epsilon 值。
image_size (Union[int, list[int], tuple[int, ...]]，可选，默认为 (448, 448)) — 每张图片的尺寸（分辨率）。
patch_size (Union[int, list[int], tuple[int, ...]]，可选，默认为 (14, 14)) — 每个 patch 的大小（分辨率）。
num_channels (int，可选，默认为 3) — 输入通道的数量。
use_mask_token (bool，可选，默认为 False) — 是否使用掩码标记进行掩码图像建模
use_absolute_position_embeddings (bool，可选，默认为 True) — 是否使用绝对位置嵌入。
layer_scale_init_value (float，可选，默认为 0.1) — 自注意力层中使用的缩放值。基础模型使用 0.1，大型模型使用 1e-6。设置为 0 可禁用层缩放。
use_mean_pooling (bool，可选，默认为 True) — 在应用分类头之前，是否对 patch 的最终隐藏状态进行平均池化，而不是使用 CLS token 的最终隐藏状态。

这是用于存储 InternVLModel 配置的类。它根据指定的参数实例化 Internvl 模型，并定义模型架构。使用默认值实例化配置将得到与 OpenGVLab/InternVL3-1B-hf 类似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。

示例：

>>> from transformers import InternVLVisionConfig, InternVLVisionModel

>>> # Initializing a InternVLVisionModel OpenGVLab/InternVL3-1B-hf style configuration
>>> configuration = InternVLVisionConfig()

>>> # Initializing a model (with random weights) from the OpenGVLab/InternVL3-1B-hf configuration
>>> model = InternVLVisionModel(configuration)

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

InternVLConfig

class transformers.InternVLConfig

< source >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneimage_token_id: int = 151667image_seq_length: int = 256downsample_ratio: float = 0.5projector_hidden_act: str = 'gelu'vision_feature_layer: int | list[int] = -1vision_feature_select_strategy: str = 'default'tie_word_embeddings: bool = True )

参数

vision_config (Union[dict, ~configuration_utils.PreTrainedConfig]，可选) — 视觉骨干网络的配置对象或字典。
text_config (Union[dict, ~configuration_utils.PreTrainedConfig]，可选) — 文本骨干网络的配置对象或字典。
image_token_id (int，可选，默认为 151667) — 用作输入图像占位符的图像 token 索引。
image_seq_length (int，可选，默认为 256) — 单个图像嵌入的序列长度。
downsample_ratio (float，可选，默认值为 0.5) — 用于对图像进行下采样的比例因子。
projector_hidden_act (str, 可选, 默认为 gelu) — 多模态投影器使用的激活函数。
vision_feature_layer (Union[int, list[int]]，可选，默认为 -1) — 用于选择视觉特征的层索引。如果提供了多个索引，则会将对应索引的视觉特征拼接起来，以形成视觉特征。
vision_feature_select_strategy (str，可选，默认为 default) — 用于从视觉主干网络中选择视觉特征的特征选择策略。
tie_word_embeddings (bool，可选，默认为 True) — 是否根据模型的 tied_weights_keys 映射来绑定权重嵌入。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。

示例：

>>> from transformers import InternVLForConditionalGeneration, InternVLConfig

>>> # Initializing a InternVL style configuration
>>> configuration = InternVLConfig()

>>> # Initializing a model (with random weights) from the OpenGVLab/InternVL3-1B-hf configuration
>>> model = InternVLForConditionalGeneration(configuration)

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

InternVLVisionModel

类 transformers.InternVLVisionModel

< source >

( config: InternVLVisionConfig )

参数

config (InternVLVisionConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

未添加任何特定头部的裸 Internvl 模型，直接输出原始隐藏状态。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< source >

( pixel_values: Tensorbool_masked_pos: typing.Optional[torch.BoolTensor] = None**kwargs ) → InternVLVisionModelOutputWithPooling or tuple(torch.FloatTensor)

参数

pixel_values (torch.Tensor，形状为 (batch_size, num_channels, image_size, image_size)) — 对应输入图像的张量。可以使用 GotOcr2ImageProcessor 获取像素值。有关详细信息，请参阅 GotOcr2ImageProcessor.call()（InternVLProcessor 使用 GotOcr2ImageProcessor 处理图像）。
bool_masked_pos（形状为 (batch_size, num_patches) 的 torch.BoolTensor，可选）— 布尔掩码位置。指示哪些 patch 被掩码（1），哪些未被掩码（0）。

返回值

InternVLVisionModelOutputWithPooling 或 tuple(torch.FloatTensor)

InternVLVisionModelOutputWithPooling 或 torch.FloatTensor 元组（如果传入 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（InternVLConfig）和输入。

InternVLVisionModel 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

last_hidden_state（形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor）— 模型最后一层输出的隐藏状态序列。
pooler_output（形状为 (batch_size, hidden_size) 的 torch.FloatTensor）— 如果 config.use_mean_pooling 设置为 True，则为 patch token 最后一层隐藏状态的平均值（不包括 [CLS] token）。如果设置为 False，则返回 [CLS] token 的最终隐藏状态。
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 之后的权重，用于在自注意力头中计算加权平均值。

InternVLModel

class transformers.InternVLModel

< source >

( config: InternVLConfig )

参数

config (InternVLConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

InternVL 模型由视觉主干网络和语言模型组成，不包含语言建模头。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.FloatTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonevision_feature_layer: int | list[int] | None = Nonevision_feature_select_strategy: str | None = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → InternVLModelOutputWithPast or tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, image_size, image_size)，可选) — 与输入图像对应的张量。可以使用 GotOcr2ImageProcessor 获取像素值。有关详细信息，请参阅 GotOcr2ImageProcessor.call()（InternVLProcessor 使用 GotOcr2ImageProcessor 处理图像）。
attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
什么是注意力掩码？
position_ids (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 [0, config.n_positions - 1].
什么是位置 ID？
past_key_values (~cache_utils.Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由 past_key_values 在解码的先前阶段返回，当 use_cache=True 或 config.use_cache=True.
仅允许将 Cache 实例作为输入，请参阅我们的 kv cache 指南。如果未传入 past_key_values，则默认会初始化 DynamicCache。

模型将输出与输入相同的缓存格式。

如果使用了 past_key_values，用户应仅输入未处理的 input_ids（即未向该模型提供其过去键值状态的那些），其形状为 (batch_size, unprocessed_length)，而不是形状为 (batch_size, sequence_length) 的全部 input_ids。
inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
vision_feature_layer (Union[int, list[int]], 可选) — 用于选择视觉特征的层索引。如果提供了多个索引，则会将对应索引的视觉特征拼接起来，以形成视觉特征。
vision_feature_select_strategy (str, 可选) — 用于从视觉主干网络中选择视觉特征的特征选择策略。可以是 "default" 或 "full" 之一。
mm_encoder_outputs (dict[str, ~modeling_outputs.BaseModelOutputWithPooling], 可选) — 一个字典，其中键为支持的模态，值为该模态的编码输出。每个编码输出是一个元组，由 (pooler_output、可选：last_hidden_states、可选：hidden_states、可选：attentions) pooler_output，形状为 (batch_size, sequence_length, hidden_size)，可选) 组成，它是编码器融合到文本嵌入中的多模态特征序列。

返回值

InternVLModelOutputWithPast 或 tuple(torch.FloatTensor)

InternVLModelOutputWithPast 或 torch.FloatTensor 元组（如果传入 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（InternVLConfig）和输入。

InternVLModel 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

last_hidden_state（形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor）— 模型最后一层输出的隐藏状态序列。

如果使用了 past_key_values，则仅输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。
past_key_values（Cache，可选，在传入 use_cache=True 或 config.use_cache=True 时返回）—— 它是一个 Cache 实例。更多详情，请参阅我们的 kv cache 指南。

包含预计算的隐藏状态（自注意力块中的键和值），可用于（参见 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 (torch.FloatTensor，可选) — 大小为 (batch_size, num_images, sequence_length, hidden_size) 的 torch.FloatTensor。由视觉编码器生成的模型 image_hidden_states，并在投影最后一个隐藏状态之后得到。

get_image_features

< source >

( pixel_values: FloatTensorvision_feature_layer: int | list[int] | None = Nonevision_feature_select_strategy: str | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

pixel_values（形状为 (batch_size, channels, height, width) 的 torch.FloatTensor）— 与输入图像对应的张量。
vision_feature_layer (int 或 list[int]) — 用于提取特征的层索引或层索引列表。
vision_feature_layer (Union[int, list[int]], 可选) — 用于选择视觉特征的层索引。如果提供了多个索引，则会将对应索引的视觉特征拼接起来，以形成视觉特征。
vision_feature_select_strategy (str, 可选) — 用于从视觉主干网络中选择视觉特征的特征选择策略。可以是 "default" 或 "full" 之一。

返回值

BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)

一个 BaseModelOutputWithPooling 或 torch.FloatTensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（InternVLConfig）和输入。

从视觉塔获取图像的最后隐藏状态，并应用多模态投影。

last_hidden_state（形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor）— 模型最后一层输出的隐藏状态序列。
pooler_output (torch.FloatTensor，形状为 (batch_size, hidden_size)) — 序列中第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后的结果。例如，对于 BERT 系列模型，这返回的是分类 token 经过线性层和 tanh 激活函数处理后的结果。线性层的权重是在预训练期间通过下一句预测（分类）目标进行训练的。
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 之后的权重，用于在自注意力头中计算加权平均值。

InternVLForConditionalGeneration

class transformers.InternVLForConditionalGeneration

< source >

( config: InternVLConfig )

参数

config (InternVLConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

由视觉骨干网络和语言模型组成的 INTERNVL 模型。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.FloatTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonevision_feature_layer: int | list[int] | None = Nonevision_feature_select_strategy: str | None = Nonelabels: typing.Optional[torch.LongTensor] = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0image_sizes: typing.Optional[torch.Tensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → InternVLCausalLMOutputWithPast or tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, image_size, image_size)，可选) — 对应输入图像的张量。可以使用 GotOcr2ImageProcessor 获取像素值。有关详细信息，请参阅 GotOcr2ImageProcessor.call()（InternVLProcessor 使用 GotOcr2ImageProcessor 处理图像）。
attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
什么是注意力掩码？
position_ids (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 [0, config.n_positions - 1].
什么是位置 ID？
past_key_values (~cache_utils.Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由 past_key_values 在解码的先前阶段返回，当 use_cache=True 或 config.use_cache=True.
仅允许将 Cache 实例作为输入，请参阅我们的 kv cache 指南。如果未传入 past_key_values，则默认会初始化 DynamicCache。

模型将输出与输入相同的缓存格式。

如果使用了 past_key_values，用户应仅输入未处理的 input_ids（即未向该模型提供其过去键值状态的那些），其形状为 (batch_size, unprocessed_length)，而不是形状为 (batch_size, sequence_length) 的全部 input_ids。
inputs_embeds (torch.FloatTensor，形状为 (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（参见 input_ids 的文档字符串）。索引值设为 -100 的 token 将被忽略（即被掩码），损失仅针对标签位于 [0, ..., config.vocab_size] 范围内的 token 进行计算。
logits_to_keep (Union[int, torch.Tensor], 可选，默认为 0) — 如果为 int，则计算最后 logits_to_keep 个 token 的 logits。如果为 0，则计算所有 input_ids 的 logits（特殊情况）。生成过程只需要最后一个 token 的 logits，仅针对该 token 进行计算可以节省内存，对于长序列或大词汇量而言，这种节省相当显著。如果为 torch.Tensor，则必须是一维张量，对应于序列长度维度中需要保留的索引。这在使用打包张量格式（将批次和序列长度合并为单一维度）时非常有用。
image_sizes（形状为 (batch_size, 2) 的 torch.Tensor，可选） — 批次中各图像的尺寸，每张图像表示为 (height, width)。
mm_encoder_outputs (dict[str, ~modeling_outputs.BaseModelOutputWithPooling], 可选) — 一个字典，其中键为支持的模态，值为该模态的编码输出。每个编码输出是一个元组，由 (pooler_output、可选：last_hidden_states、可选：hidden_states、可选：attentions) pooler_output，形状为 (batch_size, sequence_length, hidden_size)，可选) 组成，它是编码器融合到文本嵌入中的多模态特征序列。

返回值

InternVLCausalLMOutputWithPast 或 tuple(torch.FloatTensor)

InternVLCausalLMOutputWithPast 或 torch.FloatTensor 元组（如果传入 return_dict=False 或 config.return_dict=False），包含根据配置（InternVLConfig）和输入而定的各种元素。

InternVLForConditionalGeneration 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

loss (torch.FloatTensor，形状为 (1,)，可选，在提供 labels 时返回) — 语言建模损失（用于下一个 token 预测）。
logits（形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor）— 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。
past_key_values（Cache，可选，在传入 use_cache=True 或 config.use_cache=True 时返回）—— 它是一个 Cache 实例。更多详情，请参阅我们的 kv cache 指南。

包含预计算的隐藏状态（自注意力块中的键和值），可用于（参见 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 (torch.FloatTensor，可选) — 大小为 (batch_size, num_images, sequence_length, hidden_size) 的 torch.FloatTensor。由视觉编码器生成的模型 image_hidden_states，并在投影最后一个隐藏状态之后得到。

示例：

>>> import torch
>>> from transformers import AutoProcessor, AutoModelForImageTextToText

>>> torch_device = "cuda"
>>> processor = AutoProcessor.from_pretrained("OpenGVLab/InternVL3-1B-hf")
>>> model = AutoModelForImageTextToText.from_pretrained(
...     "OpenGVLab/InternVL3-1B-hf", dtype=torch.bfloat16, device_map=torch_device
... )

>>> messages = [
...     {
...         "role": "user",
...         "content": [
...             {
...                 "type": "image",
...                 "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/statue_of_liberty.jpg",
...             },
...             {
...                 "type": "image",
...                 "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/dreamstime_golden_gate_flowers.jpg",
...             },
...             {"type": "text", "text": "These images depict two different landmarks. Can you identify them?"},
...         ],
...     },
... ]

>>> inputs = processor.apply_chat_template(messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(torch_device)
>>> generate_ids = model.generate(**inputs, max_new_tokens=200)
>>> print(processor.decode(generate_ids[0, inputs["input_ids"].shape[1] :], skip_special_tokens=True))
The images depict the Statue of Liberty and the Golden Gate Bridge.

get_image_features

< source >

参数

pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, image_size, image_size)) — 对应输入图像的张量。可以使用 GotOcr2ImageProcessor 获取像素值。有关详细信息，请参阅 GotOcr2ImageProcessor.call()（InternVLProcessor 使用 GotOcr2ImageProcessor 处理图像）。
vision_feature_layer (Union[int, list[int]], 可选) — 用于选择视觉特征的层索引。如果提供了多个索引，则会将对应索引的视觉特征拼接起来，以形成视觉特征。
vision_feature_select_strategy (str, 可选) — 用于从视觉主干网络中选择视觉特征的特征选择策略。可以是 "default" 或 "full" 之一。

返回值

BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)

last_hidden_state（形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor）— 模型最后一层输出的隐藏状态序列。
pooler_output (torch.FloatTensor，形状为 (batch_size, hidden_size)) — 序列中第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后的结果。例如，对于 BERT 系列模型，这返回的是分类 token 经过线性层和 tanh 激活函数处理后的结果。线性层的权重是在预训练期间通过下一句预测（分类）目标进行训练的。
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 之后的权重，用于在自注意力头中计算加权平均值。

示例：

>>> from PIL import Image
>>> from transformers import AutoProcessor, InternVLForConditionalGeneration

>>> model = InternVLForConditionalGeneration.from_pretrained("OpenGVLab/InternVL3-1B-hf")
>>> processor = AutoProcessor.from_pretrained("OpenGVLab/InternVL3-1B-hf")

>>> messages = [
...     {
...         "role": "user", "content": [
...             {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
...             {"type": "text", "text": "Where is the cat standing?"},
...         ]
...     },
... ]

>>> inputs = processor.apply_chat_template(
...     messages,
...     tokenize=True,
...     return_dict=True,
...     return_tensors="pt",
...     add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]

InternVLProcessor

class transformers.InternVLProcessor

< source >

( image_processor = Nonetokenizer = Nonevideo_processor = Noneimage_seq_length: int = 256chat_template = None**kwargs )

参数

image_processor (GotOcr2ImageProcessor) — 图像处理器是必需的输入。
tokenizer (Qwen2Tokenizer) — 分词器是必需的输入。
video_processor (InternVLVideoProcessor) — 视频处理器是必需的输入。
image_seq_length (int，可选，默认为 256) — 每个图像块使用的图像 token 数量。应将其设置为： image_seq_length = (config.image_size // config.patch_size) 2 * (config.scale_factor2)
chat_template (str) — 一个 Jinja 模板，用于将聊天中的消息列表转换为可分词的字符串。

构造一个 InternVLProcessor，它将图像处理器、分词器和视频处理器封装为单一处理器。

InternVLProcessor 提供了 GotOcr2ImageProcessor、Qwen2Tokenizer 和 InternVLVideoProcessor 的所有功能。有关更多信息，请参阅 ~GotOcr2ImageProcessor、~Qwen2Tokenizer 和 ~InternVLVideoProcessor。

call

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: str | list[str] | list[list[str]] | None = Nonevideos: 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**kwargs: *<class 'transformers.models.internvl.processing_internvl.InternVLProcessorKwargs'> ) → BatchFeature

参数

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]]], 可选) — 要预处理的视频。期望输入单个视频或一批视频，其像素值范围为 0 到 255。如果传入的像素值在 0 到 1 之间，请设置 do_rescale=False。
return_tensors (str 或 TensorType, 可选) — 如果设置，将返回特定框架的张量。可接受的值为：
- 'pt'：返回 PyTorch torch.Tensor 对象。
- 'np'：返回 NumPy np.ndarray 对象。
**kwargs (ProcessingKwargs，可选) — 每种模态（文本、图像、视频、音频）的额外处理选项。模型特定参数已在上方列出；有关支持参数的完整列表，请参阅 TypedDict 类。

返回值

BatchFeature

一个包含以下字段的 BatchFeature：

input_ids — 要输入模型的 token id 列表。当 text 不为 None 时返回。
attention_mask — 一个索引列表，指定模型应关注哪些 token（当 return_attention_mask=True，或当 “attention_mask” 位于 self.model_input_names 中且 text 不为 None 时）。
pixel_values — 输入模型的像素值。当 images 不为 None 时返回。

InternVLVideoProcessor

class transformers.InternVLVideoProcessor

< source >

( **kwargs: *<class 'transformers.models.internvl.video_processing_internvl.InternVLVideoProcessorInitKwargs'> )

参数

**kwargs (InternVLVideoProcessorInitKwargs，可选) — 每种模态（文本、图像、视频、音频）的额外处理选项。模型特定参数已在上方列出；完整的受支持参数列表请参阅 TypedDict 类。

构建一个 InternVLVideoProcessor 视频处理器。

sample_frames

< source >

参数

metadata (VideoMetadata) — 视频的元数据，包含总时长、帧率（fps）和总帧数等信息。
num_frames (int, 可选) — 要采样的最大帧数。默认为 self.num_frames。
fps (int 或 float，可选) — 每秒采样的目标帧数。默认为 self.fps。
initial_shift (bool、float 或 int，默认为 self.initial_shift) — 在采样帧时应用的初始偏移量。如果为 True，则设置偏移量，使帧从视频的中间部分进行采样。

返回值

torch.Tensor

用于采样视频帧的索引。

默认采样函数，在 0 到总帧数之间均匀采样指定数量的帧。如果同时传入 fps 和元数据，则按 fps 帧/秒均匀采样。参数 num_frames 和 fps 互斥。

Update on GitHub

←InstructBlipVideo Janus→