Transformers documentation

MiniCPM-V

Transformers

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-09-16 在 HF papers 上发布，并于 2026-04-28 贡献至 Hugging Face Transformers。

MiniCPM-V

MiniCPM-V 是由 OpenBMB 开发的一系列高效多模态大语言模型。MiniCPM-V 4.6 架构采用带有窗口注意力合并器的 SigLIP 视觉编码器，以及 Qwen3.5 语言模型主干，支持 4x 和 16x 视觉下采样模式。

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

使用示例

使用 Pipeline 进行推理

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="openbmb/MiniCPM-V-4_6")
outputs = pipe(text=messages, max_new_tokens=50, return_full_text=False)
outputs[0]["generated_text"]

在单张图像上进行推理

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

from transformers import AutoProcessor, AutoModelForImageTextToText

model_checkpoint = "openbmb/MiniCPM-V-4_6"
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/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
            {"type": "text", "text": "Describe this image."},
        ],
    }
]

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

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

下采样模式

MiniCPM-V 4.6 支持两种视觉下采样模式：

16x（默认）：更激进的降采样，更少的视觉 token，更快的推理速度。
4x：下采样更少，视觉 token 更多，更适合细节丰富的任务。

您可以通过在 processor_kwargs 和 model.generate 中传入 downsample_mode 来在运行时更改下采样模式：

inputs = processor.apply_chat_template(
    messages, add_generation_prompt=True, tokenize=True,
    return_dict=True, return_tensors="pt",
    processor_kwargs={"downsample_mode": "4x"},
).to(model.device, dtype=model.dtype)

output = model.generate(**inputs, max_new_tokens=100, downsample_mode="4x")

思考模式

该模型支持由聊天模板中的 enable_thinking 控制的思考模式。启用后，模型会在给出最终答案之前生成内部推理过程：

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

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

要禁用思考（评估时的默认设置）：

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

图像处理后端

MiniCPM-V 4.6 提供两种图像处理后端：

torchvision（默认）：使用 torchvision.transforms 进行图像缩放。
pil：使用 PIL.Image.resize，与原始实现保持一致。

要使用 PIL 后端：

from transformers import AutoProcessor, AutoImageProcessor

processor = AutoProcessor.from_pretrained(model_checkpoint)
processor.image_processor = AutoImageProcessor.from_pretrained(model_checkpoint, backend="pil")

视频推理

MiniCPM-V 4.6 支持视频理解。

messages = [
    {
        "role": "user",
        "content": [
            {"type": "video", "video": "path/to/video.mp4"},
            {"type": "text", "text": "Describe what happens in this video."},
        ],
    }
]

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

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

如果您已经有了渲染后的提示字符串，也可以直接调用 processor(text=..., videos=[...])。

MiniCPMV4_6Config

class transformers.MiniCPMV4_6Config

< 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 = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneinsert_layer_id: int = 6image_size: int = 448drop_vision_last_layer: bool = Falseimage_token_id: int | None = Nonevideo_token_id: int | None = Nonetie_word_embeddings: bool = Falsedownsample_mode: str = '16x'merge_kernel_size: tuple[int, int] | list[int] = (2, 2)merger_times: int = 1 )

参数

text_config (Union[dict, ~configuration_utils.PreTrainedConfig]，可选) — 文本骨干网络的配置对象或字典。
vision_config (Union[dict, ~configuration_utils.PreTrainedConfig]，可选) — 视觉骨干网络的配置对象或字典。
insert_layer_id (int，可选，默认为 6) — 应用窗口注意力合并器的视觉编码器层索引。
image_size (int，可选，默认为 448) — 图像预处理的基准分辨率。
drop_vision_last_layer（bool，可选，默认为 False） — 是否移除视觉编码器的最后一层。
image_token_id (int, 可选) — 用作图像占位符的 Token id。
video_token_id (int, 可选) — 用作视频占位符的 Token id。
tie_word_embeddings (bool，可选，默认为 False) — 是否根据模型的 tied_weights_keys 映射来绑定权重嵌入。
downsample_mode (str，可选，默认为 "16x") — 视觉 token 的下采样比例。"4x" 会保留 4 倍数量的 token。
merge_kernel_size (tuple[int, int]，可选，默认为 (2, 2)) — 用于在 Merger 中合并相邻视觉 patch 的卷积核大小 (h, w)。
merger_times (int，可选，默认为 1) — Merger 中迭代合并轮次的数量。

这是用于存储 MiniCPMV4_6Model 配置的类。它根据指定的参数实例化 Minicpmv4 6 模型，并定义模型架构。使用默认值实例化配置将得到与 openbmb/MiniCPM-V-4.6 类似的配置。

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

MiniCPMV4_6VisionConfig

class transformers.MiniCPMV4_6VisionConfig

< 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 = 768intermediate_size: int = 3072num_hidden_layers: int = 12num_attention_heads: int = 12num_channels: int = 3image_size: int | list[int] | tuple[int, int] = 224patch_size: int | list[int] | tuple[int, int] = 16hidden_act: str = 'gelu_pytorch_tanh'layer_norm_eps: float = 1e-06attention_dropout: float | int = 0.0insert_layer_id: int = 6window_kernel_size: tuple[int, int] | list[int] = (2, 2) )

参数

hidden_size (int，可选，默认为 768) — 隐藏表示的维度。
intermediate_size (int，可选，默认为 3072) — MLP 表示的维度。
num_hidden_layers (int, 可选, 默认为 12) — Transformer 解码器中的隐藏层数量。
num_attention_heads (int，可选，默认为 12) — Transformer 解码器中每个注意力层的注意力头数量。
num_channels (int，可选，默认为 3) — 输入通道的数量。
image_size (Union[int, list[int], tuple[int, int]]，可选，默认为 224) — 每张图片的尺寸（分辨率）。
patch_size (Union[int, list[int], tuple[int, int]]，可选，默认为 16) — 每个 patch 的大小（分辨率）。
hidden_act (str，可选，默认为 gelu_pytorch_tanh) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、 "relu"、"silu" 等。
layer_norm_eps (float，可选，默认为 1e-06) — 层归一化层所使用的 epsilon 值。
attention_dropout (Union[float, int]，可选，默认为 0.0) — 注意力概率的 dropout 比率。
insert_layer_id (int，可选，默认为 6) — 应用窗口注意力合并器的视觉编码器层索引。
window_kernel_size (tuple[int, int]，可选，默认为 (2, 2)) — 中间窗口注意力合并器的窗口大小 (h, w)。

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

MiniCPMV4_6Model

class transformers.MiniCPMV4_6Model

< source >

( config: MiniCPMV4_6Config )

参数

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

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

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

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

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonetarget_sizes: typing.Optional[torch.IntTensor] = Nonepixel_values_videos: typing.Optional[torch.Tensor] = Nonetarget_sizes_videos: typing.Optional[torch.IntTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: list[torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Nonedownsample_mode: str | None = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.Tensor)

参数

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

什么是输入 ID？
pixel_values (torch.Tensor, 可选) — 图像的像素值补丁，采用 NaViT 打包格式。
target_sizes (torch.IntTensor，可选) — 每张图片的高度和宽度（以 patch 为单位）。
pixel_values_videos (torch.Tensor, 可选) — 视频帧的像素值补丁，采用 NaViT 打包格式。
target_sizes_videos (torch.IntTensor, 可选) — 每个视频帧的高度和宽度（以 patch 为单位）。
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 (list[torch.Tensor], 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由 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（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
use_cache (bool，可选) — 如果设置为 True，则会返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
downsample_mode (str，可选) — "4x" 保留 4 倍数量的视觉 token；默认值 "16x" 应用完全合并。
mm_encoder_outputs (dict[str, ~modeling_outputs.BaseModelOutputWithPooling], 可选) — 一个字典，其中键为支持的模态，值为该模态的编码输出。每个编码输出是一个元组，由 (pooler_output、可选：last_hidden_states、可选：hidden_states、可选：attentions) pooler_output，形状为 (batch_size, sequence_length, hidden_size)，可选) 组成，它是编码器融合到文本嵌入中的多模态特征序列。

返回值

BaseModelOutputWithPast 或 tuple(torch.Tensor)

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

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

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

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

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

包含预计算的隐藏状态（自注意力块中的键和值，以及如果 config.is_encoder_decoder=True 则还包括交叉注意力块中的键和值），可用于（参见 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 之后的权重，用于在自注意力头中计算加权平均值。

get_image_features

< source >

( pixel_values: Tensortarget_sizes: IntTensordownsample_mode: str | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

参数

pixel_values (torch.Tensor，形状为 (batch_size, num_channels, image_size, image_size)) — 与输入图像对应的张量。可以使用 MiniCPMV4_6ImageProcessor 获取像素值。有关详细信息，请参阅 MiniCPMV4_6ImageProcessor.call()（MiniCPMV4_6Processor 使用 MiniCPMV4_6ImageProcessor 来处理图像）。
target_sizes（形状为 (num_images, 2) 的 torch.IntTensor）— 每张图片的高度和宽度（以 patch 为单位）。
downsample_mode (str, 可选) — 当设置为 "4x" 时，会跳过中间的 vit_merger，从而使每张图像保留 4× 倍的视觉 token。默认的 "16x" 模式会应用完整的合并流程。

返回值

BaseModelOutputWithPooling 或 tuple(torch.Tensor)

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

提取图像特征：视觉编码器，插入合并器，然后是 MLP 合并器。

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

MiniCPMV4_6ForConditionalGeneration

class transformers.MiniCPMV4_6ForConditionalGeneration

< source >

( config: MiniCPMV4_6Config )

参数

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

用于基于其他模态（例如图像-文本到文本生成）进行 token 生成的 Minicpmv4 6 模型。

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

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

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonetarget_sizes: typing.Optional[torch.IntTensor] = Nonepixel_values_videos: typing.Optional[torch.Tensor] = Nonetarget_sizes_videos: typing.Optional[torch.IntTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: list[torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonedownsample_mode: str | None = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithPast or tuple(torch.Tensor)

参数

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

什么是输入 ID？
pixel_values (torch.Tensor, 可选) — 图像的像素值补丁，采用 NaViT 打包格式。
target_sizes (torch.IntTensor，可选) — 每张图片的高度和宽度（以 patch 为单位）。
pixel_values_videos (torch.Tensor, 可选) — 视频帧的像素值补丁，采用 NaViT 打包格式。
target_sizes_videos (torch.IntTensor, 可选) — 每个视频帧的高度和宽度（以 patch 为单位）。
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 (list[torch.Tensor], 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由 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（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引值应在 [0, ..., config.vocab_size] 范围内，或为 -100（参见 input_ids 的文档字符串）。索引值设为 -100 的 token 将被忽略（即被掩码），损失仅针对标签位于 [0, ..., config.vocab_size] 范围内的 token 进行计算。
use_cache (bool，可选) — 如果设置为 True，则会返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
downsample_mode (str，可选) — "4x" 保留 4 倍数量的视觉 token；默认值 "16x" 应用完全合并。
mm_encoder_outputs (dict[str, ~modeling_outputs.BaseModelOutputWithPooling], 可选) — 一个字典，其中键为支持的模态，值为该模态的编码输出。每个编码输出是一个元组，由 (pooler_output、可选：last_hidden_states、可选：hidden_states、可选：attentions) pooler_output，形状为 (batch_size, sequence_length, hidden_size)，可选) 组成，它是编码器融合到文本嵌入中的多模态特征序列。

返回值

CausalLMOutputWithPast 或 tuple(torch.Tensor)

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

MiniCPMV4_6ForConditionalGeneration 的 forward 方法会重写 __call__ 特殊方法。

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

loss (torch.Tensor，形状为 (1,)，可选，当提供 labels 时返回) — 语言建模损失（用于下一个 token 预测）。
logits（形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.Tensor）— 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。
past_key_values（Cache，可选，在传入 use_cache=True 或 config.use_cache=True 时返回）—— 它是一个 Cache 实例。更多详情，请参阅我们的 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 之后的权重，用于在自注意力头中计算加权平均值。

示例：

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

>>> model = MiniCPMV4_6ForConditionalGeneration.from_pretrained("openbmb/MiniCPM-V-4.6")
>>> processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-V-4.6")

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

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

get_image_features

< source >

( *args**kwargs ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

返回值

BaseModelOutputWithPooling 或 tuple(torch.Tensor)

提取图像特征：视觉编码器，插入合并器，然后是 MLP 合并器。

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

示例：

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

>>> model = MiniCPMV4_6ForConditionalGeneration.from_pretrained("openbmb/MiniCPM-V-4.6")
>>> processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-V-4.6")

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

MiniCPMV4_6Processor

class transformers.MiniCPMV4_6Processor

< source >

( image_processor = Nonevideo_processor = Nonetokenizer = Nonechat_template = None**kwargs )

参数

image_processor (MiniCPMV4_6ImageProcessor) — 图像处理器是必需的输入。
video_processor (MiniCPMV4_6VideoProcessor) — 视频处理器是必需的输入。
tokenizer (TokenizersBackend) — 分词器是必需的输入。
chat_template (str) — 一个 Jinja 模板，用于将聊天中的消息列表转换为可分词的字符串。

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

MiniCPMV4_6Processor 提供了 MiniCPMV4_6ImageProcessor、MiniCPMV4_6VideoProcessor 和 TokenizersBackend 的所有功能。有关更多信息，请参阅 ~MiniCPMV4_6ImageProcessor、~MiniCPMV4_6VideoProcessor 和 ~TokenizersBackend。

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.minicpmv4_6.processing_minicpmv4_6.MiniCPMV4_6ProcessorKwargs'> )

参数

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]]], optional) — The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings (pretokenized string). If you pass a pretokenized input, set is_split_into_words=True to avoid ambiguity with batched inputs.
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。
return_mm_token_type_ids (bool, kwargs) — 是否返回多模态 token 类型 id，以指示多模态占位符 token 的位置。
return_text_replacement_offsets (bool, kwargs) — 是否返回每个多模态占位符及其替换内容的字符偏移量。
use_image_id (bool, kwargs, optional) — 是否在每个图像占位符前添加图像 ID 标签（<image_id>N</image_id>）。如果未设置，则默认为图像处理器的 use_image_id。
return_tensors (str 或 [~utils.TensorType], ，可选) — 如果设置，将返回特定框架的张量。可接受的值为：
- ‘pt’：返回 PyTorch torch.Tensor 对象。
- ‘np’：返回 NumPy np.ndarray 对象。
**kwargs ([ProcessingKwargs], 可选) — 每种模态（文本、图像、视频、音频）的额外处理选项。模型特定参数已在上方列出；有关支持参数的完整列表，请参阅 TypedDict 类。

MiniCPMV4_6ImageProcessor

class transformers.MiniCPMV4_6ImageProcessor

< source >

( **kwargs: *<class 'transformers.models.minicpmv4_6.image_processing_minicpmv4_6.MiniCPMV4_6ImageProcessorKwargs'> )

参数

do_convert_rgb (bool，kwargs，可选，默认为 True) — 是否将图像转换为 RGB。
do_resize (bool，kwargs，可选，默认为 True) — 是否调整图像大小。
size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — 描述模型的最大输入维度。
default_to_square (bool，kwargs，可选，默认为 True) — 当 size 为整数时，是否在调整大小时默认使用正方形图像。
crop_size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — 应用 center_crop 后输出图像的尺寸。
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs，默认为 3) — 在对图像进行缩放时使用的重采样滤波器。它可以是枚举 PILImageResampling 中的一个值。仅当 do_resize 设置为 True 时才会生效。
do_rescale (bool，kwargs，可选，默认为 True) — 是否对图像进行重新缩放。
rescale_factor (float，kwargs，可选，默认为 0.00392156862745098) — 当 do_rescale 设置为 True 时，用于对图像进行缩放的缩放因子。
do_normalize (bool，kwargs，可选，默认为 True) — 是否对图像进行归一化。
image_mean (Union[float, list[float], tuple[float, …]], kwargs, 可选，默认为 [0.5, 0.5, 0.5]) — 用于归一化的图像均值。仅当 do_normalize 设置为 True 时生效。
image_std (Union[float, list[float], tuple[float, …]], kwargs, 可选，默认为 [0.5, 0.5, 0.5]) — 用于归一化的图像标准差。仅当 do_normalize 设置为 True 时生效。
do_pad (bool, kwargs, optional) — 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。
pad_size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — 用于填充图像的 {“height”: int, “width” int} 尺寸。该尺寸必须大于为预处理提供的任何图像尺寸。如果未提供 pad_size，图像将被填充到批次中最大的高度和宽度。仅在 do_pad=True 时应用。
do_center_crop (bool, kwargs, 可选) — 是否对图像进行中心裁剪。
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) — 用于处理视频的设备。如果未设置，则从输入视频中推断设备。
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — 如果设置为 ‘pt’，则返回堆叠的张量，否则返回张量列表。
disable_grouping (bool，kwargs，可选) — 是否禁用按尺寸对图像进行分组，从而单独处理图像而非批量处理。如果为 None，则当图像位于 CPU 上时设置为 True，否则设置为 False。此选择基于经验观察，详见此处：https://github.com/huggingface/transformers/pull/38157
image_seq_length (int, kwargs, 可选) — 输入中每张图片所使用的图像 token 数量。为向后兼容而添加，但在未来的模型中，应将其设置为处理器的属性。
max_slice_nums (int，kwargs，可选，默认值为 9) — 分割高分辨率图像时的最大切片数量。
scale_resolution (int，kwargs，可选，默认值为 448) — 单个切片的分辨率。
patch_size (int, kwargs, 可选，默认为 14) — 视觉编码器的空间块大小。
slice_mode (bool，kwargs，可选，默认为 True) — 是否将图像分割为多个切片以提高分辨率。
downsample_mode（str，kwargs，可选，默认为 “16x”） — 视觉 token 下采样模式。“16x” 应用完全合并；“4x” 保留 4 倍数量的 token。
use_image_id (bool，kwargs，可选，默认为 True) — 是否在每个图像占位符之前添加图像 ID 标签（<image_id>N</image_id>）。该参数由 Processor 用于生成占位符，而非由图像处理流水线本身使用。

构建一个 MiniCPMV4_6ImageProcessor 图像处理器。

预处理

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]**kwargs: *<class 'transformers.models.minicpmv4_6.image_processing_minicpmv4_6.MiniCPMV4_6ImageProcessorKwargs'> ) → ~image_processing_base.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。
do_convert_rgb (bool, kwargs, 可选) — 是否将图像转换为 RGB。
do_resize (bool，kwargs，可选) — 是否调整图像大小。
size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — 描述模型的最大输入维度。
default_to_square (bool，kwargs，可选) — 当 size 为整数时，是否在调整大小时默认使用正方形图像。
crop_size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — 应用 center_crop 后输出图像的尺寸。
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — 如果调整图像大小，则使用的重采样滤波器。可以是枚举 PILImageResampling 中的一个值。仅当 do_resize 设置为 True 时生效。
do_rescale (bool, kwargs, 可选) — 是否对图像进行重新缩放。
rescale_factor (float, kwargs, optional) — 如果 do_rescale 设置为 True，则用于对图像进行缩放的缩放因子。
do_normalize (bool，kwargs，可选) — 是否对图像进行归一化。
image_mean (Union[float, list[float], tuple[float, …]], kwargs, optional) — 用于归一化的图像均值。仅当 do_normalize 设置为 True 时生效。
image_std (Union[float, list[float], tuple[float, …]], kwargs, optional) — 用于归一化的图像标准差。仅当 do_normalize 设置为 True 时生效。
do_pad (bool, kwargs, optional) — 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。
pad_size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — 用于填充图像的 {“height”: int, “width” int} 尺寸。该尺寸必须大于为预处理提供的任何图像尺寸。如果未提供 pad_size，图像将被填充到批次中最大的高度和宽度。仅在 do_pad=True 时应用。
do_center_crop (bool, kwargs, 可选) — 是否对图像进行中心裁剪。
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) — 用于处理视频的设备。如果未设置，则从输入视频中推断设备。
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — 如果设置为 ‘pt’，则返回堆叠的张量，否则返回张量列表。
disable_grouping (bool，kwargs，可选) — 是否禁用按尺寸对图像进行分组，从而单独处理图像而非批量处理。如果为 None，则当图像位于 CPU 上时设置为 True，否则设置为 False。此选择基于经验观察，详见此处：https://github.com/huggingface/transformers/pull/38157
image_seq_length (int, kwargs, 可选) — 输入中每张图片所使用的图像 token 数量。为向后兼容而添加，但在未来的模型中，应将其设置为处理器的属性。
max_slice_nums (int，kwargs，可选，默认值为 9) — 分割高分辨率图像时的最大切片数量。
scale_resolution (int，kwargs，可选，默认值为 448) — 单个切片的分辨率。
patch_size (int, kwargs, 可选，默认为 14) — 视觉编码器的空间块大小。
slice_mode (bool，kwargs，可选，默认为 True) — 是否将图像分割为多个切片以提高分辨率。
downsample_mode（str，kwargs，可选，默认为 “16x”） — 视觉 token 下采样模式。“16x” 应用完全合并；“4x” 保留 4 倍数量的 token。
use_image_id (bool，kwargs，可选，默认为 True) — 是否在每个图像占位符之前添加图像 ID 标签（<image_id>N</image_id>）。该参数由 Processor 用于生成占位符，而非由图像处理流水线本身使用。

返回值

~image_processing_base.BatchFeature

data (dict) — 由 call 方法返回的列表/数组/张量字典（例如 ‘pixel_values’）。
tensor_type (Union[None, str, TensorType]，可选) — 您可以在此处指定 tensor_type，以便在初始化时将 PyTorch/Numpy 张量中的整数列表进行转换。

MiniCPMV4_6ImageProcessorPil

class transformers.MiniCPMV4_6ImageProcessorPil

< source >

( **kwargs: *<class 'transformers.models.minicpmv4_6.image_processing_pil_minicpmv4_6.MiniCPMV4_6ImageProcessorPilKwargs'> )

参数

**kwargs (MiniCPMV4_6ImageProcessorPilKwargs，可选) — 额外的图像预处理选项。模型特定的 kwargs 已在上方列出；有关支持参数的完整列表，请参阅 TypedDict 类。

构建一个 MiniCPMV4_6ImageProcessor 图像处理器。

预处理

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]**kwargs: *<class 'transformers.models.minicpmv4_6.image_processing_pil_minicpmv4_6.MiniCPMV4_6ImageProcessorPilKwargs'> ) → ~image_processing_base.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。
return_tensors (str 或 TensorType，可选) — 如果设置为 'pt'，则返回堆叠的张量，否则返回张量列表。
**kwargs (MiniCPMV4_6ImageProcessorPilKwargs，可选) — 额外的图像预处理选项。模型特定的 kwargs 已在上方列出；有关支持参数的完整列表，请参阅 TypedDict 类。

返回值

~image_processing_base.BatchFeature

data (dict) — 由 call 方法返回的列表/数组/张量字典（如 ‘pixel_values’ 等）。
tensor_type (Union[None, str, TensorType], 可选) — 您可以在此处指定 tensor_type，以便在初始化时将 PyTorch/Numpy 张量中的整数列表进行转换。

MiniCPMV4_6VideoProcessor

class transformers.MiniCPMV4_6VideoProcessor

< source >

( **kwargs: *<class 'transformers.models.minicpmv4_6.video_processing_minicpmv4_6.MiniCPMV4_6VideoProcessorKwargs'> )

参数

do_convert_rgb (bool，kwargs，可选，默认为 True) — 是否将图像转换为 RGB。
do_resize (bool，kwargs，可选，默认为 True) — 是否调整图像大小。
size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — 描述模型的最大输入维度。
default_to_square (bool，kwargs，可选，默认为 True) — 当 size 为整数时，是否在调整大小时默认使用正方形图像。
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs，默认为 3) — 在对图像进行缩放时使用的重采样滤波器。它可以是枚举 PILImageResampling 中的一个值。仅当 do_resize 设置为 True 时才会生效。
do_rescale (bool，kwargs，可选，默认为 True) — 是否对图像进行重新缩放。
rescale_factor (float，kwargs，可选，默认为 0.00392156862745098) — 当 do_rescale 设置为 True 时，用于对图像进行缩放的缩放因子。
do_normalize (bool，kwargs，可选，默认为 True) — 是否对图像进行归一化。
image_mean (Union[float, list[float], tuple[float, …]], kwargs, 可选，默认为 [0.5, 0.5, 0.5]) — 用于归一化的图像均值。仅当 do_normalize 设置为 True 时生效。
image_std (Union[float, list[float], tuple[float, …]], kwargs, 可选，默认为 [0.5, 0.5, 0.5]) — 用于归一化的图像标准差。仅当 do_normalize 设置为 True 时生效。
do_center_crop (bool, kwargs, 可选) — 是否对图像进行中心裁剪。
do_pad (bool, kwargs, optional) — 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。
crop_size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — 应用 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，可选，默认为 True) — 是否在处理前从视频中采样帧，还是处理整个视频。
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，可选，默认为 False) — 是否返回视频元数据。视频元数据是一个包含视频时长、帧率、解码后端等信息的对象。
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — 如果设置，将返回特定框架的张量。可接受的值为：
- ‘pt’：返回 PyTorch torch.Tensor 对象。
- ‘np’：返回 NumPy np.ndarray 对象。
max_num_frames (int, kwargs, 可选，默认为 128) — 每个视频要采样的主帧最大数量。
stack_frames (int, kwargs, 可选，默认为 1) — 每秒堆叠的子帧数。1 表示禁用堆叠。
max_slice_nums (int，kwargs，可选，默认值为 9) — 分割高分辨率图像时的最大切片数量。
scale_resolution (int，kwargs，可选，默认值为 448) — 单个切片的分辨率。
patch_size (int, kwargs, 可选，默认为 14) — 视觉编码器的空间块大小。
slice_mode (bool，kwargs，可选，默认为 True) — 是否将图像分割为多个切片以提高分辨率。
downsample_mode（str，kwargs，可选，默认为 “16x”） — 视觉 token 下采样模式。“16x” 应用完全合并；“4x” 保留 4 倍数量的 token。
use_image_id (bool，kwargs，可选，默认为 True) — 是否在每个图像占位符之前添加图像 ID 标签（<image_id>N</image_id>）。该参数由 Processor 用于生成占位符，而非由图像处理流水线本身使用。
**kwargs ([ProcessingKwargs], 可选) — 每种模态（文本、图像、视频、音频）的额外处理选项。模型特定参数已在上方列出；有关支持参数的完整列表，请参阅 TypedDict 类。

构建一个 MiniCPMV4_6VideoProcessor 视频处理器。

预处理

< source >

( 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]]]**kwargs: *<class 'transformers.processing_utils.VideosKwargs'> ) → ~image_processing_base.BatchFeature

参数

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。
do_convert_rgb (bool，kwargs，可选) — 是否将图像转换为 RGB。
do_resize (bool，kwargs，可选) — 是否调整图像大小。
size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — 描述模型的最大输入维度。
default_to_square (bool, kwargs, 可选) — 当 size 为整数时，是否在调整大小时默认使用正方形图像。
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — 如果调整图像大小，则使用的重采样滤波器。可以是枚举 PILImageResampling 中的一个值。仅当 do_resize 设置为 True 时生效。
do_rescale (bool，kwargs，可选) — 是否对图像进行重新缩放。
rescale_factor (float, kwargs, 可选) — 如果 do_rescale 设置为 True，则用于对图像进行缩放的缩放因子。
do_normalize (bool，kwargs，可选) — 是否对图像进行归一化。
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, 可选) — 用于归一化的图像均值。仅当 do_normalize 设置为 True 时生效。
image_std (Union[float, list[float], tuple[float, ...]], kwargs, 可选) — 用于归一化的图像标准差。仅当 do_normalize 设置为 True 时生效。
do_center_crop (bool，kwargs，可选) — 是否对图像进行中心裁剪。
do_pad (bool, kwargs, 可选) — 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。
crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — 应用 center_crop 后输出图像的尺寸。
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, 可选) — 仅支持 ChannelDimension.FIRST。为兼容旧版处理器而添加。
input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, 可选) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一：
- "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, 可选) — 是否在处理前对视频进行帧采样，还是处理整个视频。
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, 可选) — 是否返回视频元数据。视频元数据是一个包含视频时长、帧率、解码后端等信息的对象。
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — 如果设置为 'pt'，则返回堆叠的张量，否则返回张量列表。

返回值

~image_processing_base.BatchFeature

data (dict) — 由 call 方法返回的列表/数组/张量字典（如 ‘pixel_values’ 等）。
tensor_type (Union[None, str, TensorType], 可选) — 您可以在此处指定 tensor_type，以便在初始化时将 PyTorch/Numpy 张量中的整数列表进行转换。

Update on GitHub