IDEFICS

概述

IDEFICS 模型在 Hugo Laurençon, Lucile Saulnier, Léo Tronchon, Stas Bekman, Amanpreet Singh, Anton Lozhkov, Thomas Wang, Siddharth Karamcheti, Alexander M. Rush, Douwe Kiela, Matthieu Cord, Victor Sanh 提出的 OBELICS: 一个开放式网络规模的交错图像-文本文档过滤数据集中被提出。

论文摘要如下：

在交错图像和文本的自然文档上训练的大型多模态模型，在各种需要对一张或多张图像进行推理以生成文本的多模态基准测试上，其性能优于在图像-文本对上训练的模型。然而，用于训练这些模型的数据集尚未发布，并且收集过程也未完全指定。我们引入了 OBELICS 数据集，这是一个开放式网络规模的交错图像-文本文档过滤数据集，包含从 Common Crawl 中提取的 1.41 亿个网页，3.53 亿个相关图像，以及 1150 亿个文本标记。我们描述了数据集创建过程，提供了全面的过滤规则，并对数据集内容进行了分析。为了展示 OBELICS 的可行性，我们使用该数据集训练了一个 800 亿参数的视觉和语言模型，并在各种多模态基准测试上获得了有竞争力的性能。我们发布了用于复现数据集的代码以及数据集本身。

此模型由 HuggingFaceM4 贡献。原始代码可以在此处找到。(TODO：尚未有公开链接)。

Transformers 中的 IDEFICS 建模代码用于预训练 IDEFICS 模型的微调和推理。

要从头开始训练新的 IDEFICS 模型，请使用 m4 代码库（一旦公开将提供链接）

IdeficsConfig

class transformers.IdeficsConfig

< 来源 >

( vocab_size = 32000 additional_vocab_size = 0 hidden_size = 4096 intermediate_size = 11008 num_hidden_layers = 32 num_attention_heads = 32 dropout = 0.0 hidden_act = 'silu' initializer_range = 0.02 alpha_initializer = 'zeros' alphas_initializer_range = 0.0 alpha_type = 'float' rms_norm_eps = 1e-06 use_cache = True pad_token_id = 0 bos_token_id = 1 eos_token_id = 2 tie_word_embeddings = False cross_layer_interval = 1 qk_layer_norms = False freeze_text_layers = True freeze_text_module_exceptions = [] freeze_lm_head = False freeze_vision_layers = True freeze_vision_module_exceptions = [] use_resampler = False vision_config = None perceiver_config = None **kwargs )

参数

additional_vocab_size (int, 可选, 默认为 0) — 模型的额外词汇量大小，通常用于特殊的“”标记。额外词汇标记始终可训练，而常规词汇标记可冻结或不冻结。
vocab_size (int, 可选, 默认为 32000) — Idefics 模型的词汇量大小。定义了调用 ~IdeficsModel 时传入的 inputs_ids 可以表示的不同标记的数量。
hidden_size (int, 可选, 默认为 4096) — 隐藏表示的维度。
intermediate_size (int, 可选, 默认为 11008) — MLP 表示的维度。
num_hidden_layers (int, 可选, 默认为 32) — Transformer 编码器中的隐藏层数量。
num_attention_heads (int, 可选, 默认为 32) — Transformer 编码器中每个注意力层的注意力头数量。
dropout (float, 可选, 默认为 0.0) — 用于嵌入、编码器和池化器中所有全连接层的 dropout 概率。
hidden_act (str 或 function, 可选, 默认为 "silu") — 解码器中的非线性激活函数（函数或字符串）。
initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
alpha_initializer (str, 可选, 默认为 "zeros") — alphas 的初始化类型。
alphas_initializer_range (float, 可选, 默认为 0.0) — 用于初始化门控交叉注意力中 alphas 的 truncated_normal_initializer 的标准差。
alpha_type (str, 可选, 默认为 "float") — 门控 alphas 应该是向量还是单个浮点数。
rms_norm_eps (float, 可选, 默认为 1e-6) — rms 归一化层使用的 epsilon。
use_cache (bool, 可选, 默认为 True) — 模型是否应返回上次的 key/values attention（并非所有模型都使用）。仅在 config.is_decoder=True 时相关。
pad_token_id (int, 可选, 默认为 0) — 填充标记 ID。
bos_token_id (int, 可选, 默认为 1) — 流开始标记 ID。
eos_token_id (int, 可选, 默认为 2) — 流结束标记 ID。
tie_word_embeddings(bool, 可选, 默认为 False) — 是否绑定词嵌入。
cross_layer_interval (int, 可选, 默认为 1) — 交叉注意力（从文本到图像）层的间隔。
qk_layer_norms (bool, 可选, 默认为 False) — 是否在 q 和 k 之后添加层归一化。
freeze_text_layers (bool, 可选, 默认为 True) — 是否冻结文本层。
freeze_text_module_exceptions (bool, 可选, 默认为 []) — 当 freeze_text_layers 为 True 时，冻结文本层的例外情况。
freeze_lm_head (bool, 可选, 默认为 False) — 是否冻结 lm 头。
freeze_vision_layers (bool, 可选, 默认为 True) — 是否冻结视觉层。
freeze_vision_module_exceptions (bool, 可选, 默认为 []) — 当 freeze_vision_layers 为 True 时，冻结视觉层的例外情况。
use_resampler (bool, 可选, 默认为 False) — 是否使用重采样器。
vision_config (IdeficsVisionConfig, 可选) — 自定义视觉配置或字典。
perceiver_config (IdeficsPerceiverConfig, 可选) — 自定义感知器配置或字典。

这是用于存储 IdeficsModel 配置的配置类。它用于根据指定的参数实例化 Idefics 模型，定义模型架构。使用默认值实例化配置将产生与 Idefics-9B 类似的配置。

例如：HuggingFaceM4/idefics-9b

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

示例

>>> from transformers import IdeficsModel, IdeficsConfig

>>> # Initializing a Idefics idefics-9b style configuration
>>> configuration = IdeficsConfig()

>>> # Initializing a model from the idefics-9b style configuration
>>> model = IdeficsModel(configuration)

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

IdeficsModel

class transformers.IdeficsModel

< 来源 >

( config: IdeficsConfig )

参数

config (IdeficsConfig) — 包含模型所有参数的模型配置类。使用配置文件实例化不会加载与模型相关的权重，只加载配置。有关加载模型权重的详细信息，请查看 from_pretrained() 方法。

纯 Idefics 模型，输出原始隐藏状态，不带任何特定头部。

此模型继承自 PreTrainedModel。有关库为所有模型实现的通用方法（如下载或保存、调整输入嵌入大小、修剪头部等），请查看超类文档。

此模型也是 PyTorch torch.nn.Module 的子类。将其作为常规 PyTorch 模块使用，并参考 PyTorch 文档中所有与通用用法和行为相关的事项。

前向传播

< 来源 >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[list[torch.FloatTensor]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None image_encoder_embeddings: typing.Optional[torch.FloatTensor] = None perceiver_embeddings: typing.Optional[torch.FloatTensor] = None image_attention_mask: typing.Optional[torch.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: typing.Optional[bool] = False return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None **kwargs: typing_extensions.Unpack[transformers.modeling_flash_attention_utils.FlashAttentionKwargs] ) → transformers.models.idefics.modeling_idefics.IdeficsBaseModelOutputWithPast 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。

索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
attention_mask (torch.Tensor, 形状为 (batch_size, sequence_length), 可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择范围为 [0, 1]：
- 未被掩盖的标记为 1，
- 被掩盖的标记为 0。
什么是注意力掩码？
position_ids (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.n_positions - 1]。

什么是位置 ID？
past_key_values (list[torch.FloatTensor], 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码上一阶段返回的 past_key_values，当 use_cache=True 或 config.use_cache=True 时。

允许两种格式：
- 一个 Cache 实例，请参阅我们的 kv 缓存指南；
- 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组包含 2 个张量，形状为 (batch_size, num_heads, sequence_length, embed_size_per_head))。这也被称为旧版缓存格式。
模型将输出与作为输入提供的缓存格式相同的缓存格式。如果未传入 past_key_values，则将返回旧版缓存格式。

如果使用 past_key_values，用户可以选择只输入最后一个 input_ids（那些没有将其过去的键值状态提供给此模型的）的形状 (batch_size, 1)，而不是所有 input_ids 的形状 (batch_size, sequence_length)。
inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选参数，可以直接传入嵌入式表示，而不是传入 input_ids。如果你想对如何将 input_ids 索引转换为相关向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, image_size, image_size)，可选) — 对应于输入图像的张量。像素值可以使用 {image_processor_class} 获取。有关详细信息，请参见 {image_processor_class}.__call__（{processor_class} 使用 {image_processor_class} 处理图像）。
image_encoder_embeddings (torch.FloatTensor，可选) — 图像编码器的输出。
perceiver_embeddings (torch.FloatTensor，可选) — 感知器重采样器的输出。
image_attention_mask (torch.LongTensor，可选) — 用于图像编码器的注意力掩码。
use_cache (bool，可选) — 如果设置为 True，则返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。
interpolate_pos_encoding (bool，可选，默认为 False) — 是否插值预训练的位置编码。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
cache_position (torch.LongTensor，形状为 (sequence_length)，可选) — 表示输入序列标记在序列中位置的索引。与 position_ids 不同，此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。

transformers.models.idefics.modeling_idefics.IdeficsBaseModelOutputWithPast 或 tuple(torch.FloatTensor)

一个 transformers.models.idefics.modeling_idefics.IdeficsBaseModelOutputWithPast 或一个 torch.FloatTensor 的元组（如果传入 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (IdeficsConfig) 和输入。

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

如果使用了 past_key_values，则只输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。
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) 的张量），如果 config.is_encoder_decoder=True，则可选包含 2 个额外形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的张量。

包含预计算的隐藏状态（自注意力块中的键和值，如果 config.is_encoder_decoder=True 则可选包含交叉注意力块中的键和值），可用于（参见 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)。

模型由视觉编码器生成，可选由感知器生成的图像隐藏状态

IdeficsModel forward 方法，覆盖 __call__ 特殊方法。

尽管前向传播的配方需要在此函数中定义，但此后应调用 Module 实例，而不是此函数，因为前者负责运行预处理和后处理步骤，而后者则默默忽略它们。

IdeficsForVisionText2Text

class transformers.IdeficsForVisionText2Text

< source >

( config vision_model = None )

前向传播

< source >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[list[torch.FloatTensor]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None image_encoder_embeddings: typing.Optional[torch.FloatTensor] = None perceiver_embeddings: typing.Optional[torch.FloatTensor] = None image_attention_mask: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: typing.Optional[bool] = False return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None **kwargs: typing_extensions.Unpack[transformers.models.idefics.modeling_idefics.KwargsForCausalLM] ) → transformers.models.idefics.modeling_idefics.IdeficsCausalLMOutputWithPast 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是 input IDs？
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值选择范围为 [0, 1]：
- 1 表示未被掩盖的标记，
- 0 表示被掩盖的标记。
什么是注意力掩码？
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.n_positions - 1]。

什么是位置 ID？
past_key_values (list[torch.FloatTensor]，可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码上一阶段返回的 past_key_values，当 use_cache=True 或 config.use_cache=True 时。

允许两种格式：
- 一个 Cache 实例，参见我们的 kv 缓存指南；
- 一个 tuple(torch.FloatTensor) 的元组，长度为 config.n_layers，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也称为旧版缓存格式。
模型将输出与输入相同的缓存格式。如果未传入 past_key_values，则将返回旧版缓存格式。

如果使用 past_key_values，用户可以选择只输入形状为 (batch_size, 1) 的最后一个 input_ids（那些没有将其过去的键值状态提供给此模型的），而不是形状为 (batch_size, sequence_length) 的所有 input_ids。
inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选参数，可以直接传入嵌入式表示，而不是传入 input_ids。如果你想对如何将 input_ids 索引转换为相关向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, image_size, image_size)，可选) — 对应于输入图像的张量。像素值可以使用 {image_processor_class} 获取。有关详细信息，请参见 {image_processor_class}.__call__（{processor_class} 使用 {image_processor_class} 处理图像）。
image_encoder_embeddings (torch.FloatTensor，可选) — 图像编码器的输出。
perceiver_embeddings (torch.FloatTensor，可选) — 感知器重采样器的输出。
image_attention_mask (torch.LongTensor，可选) — 图像编码器的注意力掩码。
labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应在 [0, ..., config.vocab_size] 或 -100 之间（参见 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（掩码），损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算。
use_cache (bool，可选) — 如果设置为 True，则返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。
interpolate_pos_encoding (bool，可选，默认为 False) — 是否插值预训练的位置编码。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
cache_position (torch.LongTensor，形状为 (sequence_length)，可选) — 表示输入序列标记在序列中位置的索引。与 position_ids 不同，此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。

transformers.models.idefics.modeling_idefics.IdeficsCausalLMOutputWithPast 或 tuple(torch.FloatTensor)

一个 transformers.models.idefics.modeling_idefics.IdeficsCausalLMOutputWithPast 或一个 torch.FloatTensor 的元组（如果传入 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (IdeficsConfig) 和输入。

loss (torch.FloatTensor 形状为 (1,)，可选，当提供 labels 时返回) — 语言建模损失（用于下一个 token 预测）。
logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 语言建模头部的预测分数（SoftMax 之前的每个词汇标记的分数）。
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) 的张量）

包含预计算的隐藏状态（自注意力块中的键和值），可用于（参见 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)。

模型由视觉编码器生成，可选由感知器生成的图像隐藏状态

IdeficsForVisionText2Text forward 方法，覆盖 __call__ 特殊方法。

示例

>>> from transformers import AutoProcessor, IdeficsForVisionText2Text

>>> model = IdeficsForVisionText2Text.from_pretrained("HuggingFaceM4/idefics-9b")
>>> processor = AutoProcessor.from_pretrained("HuggingFaceM4/idefics-9b")

>>> dogs_image_url_1 = "https://huggingface.co/datasets/hf-internal-testing/fixtures_nlvr2/raw/main/image1.jpeg"
>>> dogs_image_url_2 = "https://huggingface.co/datasets/hf-internal-testing/fixtures_nlvr2/raw/main/image2.jpeg"

>>> prompts = [
...     [
...         "User:",
...         dogs_image_url_1,
...         "Describe this image.\nAssistant: An image of two dogs.\n",
...         "User:",
...         dogs_image_url_2,
...         "Describe this image.\nAssistant:",
...     ]
... ]
>>> inputs = processor(prompts, return_tensors="pt")
>>> generate_ids = model.generate(**inputs, max_new_tokens=6)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)

TFIdeficsModel

class transformers.TFIdeficsModel

< source >

( config: IdeficsConfig *inputs **kwargs )

调用

< source >

( input_ids: TFModelInputType | None = None attention_mask: Optional[tf.Tensor] = None position_ids: Optional[tf.Tensor] = None past_key_values: Optional[list[tf.Tensor]] = None inputs_embeds: Optional[tf.Tensor] = None pixel_values: Optional[tf.Tensor] = None image_encoder_embeddings: Optional[tf.Tensor] = None perceiver_embeddings: Optional[tf.Tensor] = None image_attention_mask: Optional[tf.Tensor] = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None interpolate_pos_encoding: Optional[bool] = False return_dict: Optional[bool] = None training: Optional[bool] = None )

TFIdeficsForVisionText2Text

class transformers.TFIdeficsForVisionText2Text

< source >

( config vision_model = None **kwargs )

调用

< source >

( input_ids: TFModelInputType | None = None attention_mask: Optional[tf.Tensor] = None position_ids: Optional[tf.Tensor] = None past_key_values: Optional[list[tf.Tensor]] = None inputs_embeds: Optional[tf.Tensor] = None pixel_values: Optional[tf.Tensor] = None image_encoder_embeddings: Optional[tf.Tensor] = None perceiver_embeddings: Optional[tf.Tensor] = None image_attention_mask: Optional[tf.Tensor] = None labels: Optional[tf.Tensor] = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None interpolate_pos_encoding: Optional[bool] = False return_dict: Optional[bool] = None training = False ) → transformers.models.idefics.modeling_tf_idefics.TFIdeficsCausalLMOutputWithPast 或 tuple(tf.Tensor)

参数

input_ids (tf.Tensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。如果提供，默认情况下会忽略填充。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是 input IDs？
attention_mask (tf.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 (tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.n_positions - 1]。什么是位置 ID？
past_key_values (tuple(tuple(tf.Tensor))，可选，当传入 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(tf.Tensor) 元组，每个元组包含 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, sequence_length) 的所有 decoder_input_ids。
inputs_embeds (tf.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选参数，可以直接传入嵌入式表示，而不是传入 input_ids。如果你想对如何将 input_ids 索引转换为相关向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
use_cache (bool，可选) — 如果设置为 True，则返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
labels (形状为 (batch_size, sequence_length) 的 tf.Tensor，可选) — 用于计算掩码语言建模损失的标签。索引应为 [0, ..., config.vocab_size] 或 -100 (参见 input_ids 文档字符串)。索引设置为 -100 的标记将被忽略（掩码），损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算。

transformers.models.idefics.modeling_tf_idefics.TFIdeficsCausalLMOutputWithPast 或 tuple(tf.Tensor)

一个 transformers.models.idefics.modeling_tf_idefics.TFIdeficsCausalLMOutputWithPast 或一个 tf.Tensor 元组 (如果传入 return_dict=False 或当 config.return_dict=False 时)，包含根据配置 (IdeficsConfig) 和输入的不同元素。

loss (形状为 (1,) 的 tf.Tensor，可选，当提供 labels 时返回) — 语言建模损失 (用于下一标记预测)。
logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言模型头部的预测分数（SoftMax 之前每个词汇标记的分数）。
past_key_values (tuple(tuple(tf.Tensor))，可选，当传入 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(tf.Tensor) 元组，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量)。

包含预计算的隐藏状态（自注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。
hidden_states (tuple(tf.Tensor)，可选，当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组 (一个用于嵌入层的输出，如果模型有嵌入层，+ 一个用于每层的输出)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(tf.Tensor)，可选，当传入 output_attentions=True 或当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组 (每层一个)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
image_hidden_states (tuple(tf.Tensor)，可选) — 形状为 (batch_size, num_images, sequence_length, hidden_size) 的 tf.Tensor 元组 (一个用于图像嵌入的输出)。

模型由视觉编码器生成，可选由感知器生成的图像隐藏状态

TFIdeficsForVisionText2Text 的前向方法，覆盖了 __call__ 特殊方法。

示例

>> from transformers import AutoTokenizer, TFIdeficsForVisionText2Text

>> model = TFIdeficsForVisionText2Text.from_pretrained("HuggingFaceM4/idefics-9b")
>> tokenizer = AutoTokenizer.from_pretrained("HuggingFaceM4/idefics-9b")

>> prompt = "Hey, are you consciours? Can you talk to me?"
>> inputs = tokenizer(prompt, return_tensors="tf")

>> # Generate
>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Hey, are you consciours? Can you talk to me?\nI'm not consciours, but I can talk to you."

IdeficsImageProcessor

class transformers.IdeficsImageProcessor

< source >

( image_size: int = 224 image_mean: typing.Union[float, list[float], NoneType] = None image_std: typing.Union[float, list[float], NoneType] = None image_num_channels: typing.Optional[int] = 3 do_rescale: bool = True rescale_factor: typing.Union[int, float] = 0.00392156862745098 **kwargs )

参数

image_size (int，可选，默认为 224) — 将图片大小调整为该值。
image_mean (float 或 list[float]，可选，默认为 IDEFICS_STANDARD_MEAN) — 如果对图像进行归一化，则使用的均值。这是一个浮点数或浮点数列表，其长度与图像中的通道数相同。可以通过 preprocess 方法中的 image_mean 参数覆盖。
image_std (float 或 list[float]，可选，默认为 IDEFICS_STANDARD_STD) — 如果对图像进行归一化，则使用的标准差。这是一个浮点数或浮点数列表，其长度与图像中的通道数相同。可以通过 preprocess 方法中的 image_std 参数覆盖。
image_num_channels (int，可选，默认为 3) — 图像通道数。
do_rescale (bool，可选，默认为 True) — 是否按指定的缩放因子 rescale_factor 重新缩放图像。可以通过 preprocess 方法中的 do_rescale 覆盖。
rescale_factor (int 或 float，可选，默认为 1/255) — 如果对图像进行重新缩放，则使用的缩放因子。可以通过 preprocess 方法中的 rescale_factor 覆盖。

构建 Idefics 图像处理器。

预处理

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] image_num_channels: typing.Optional[int] = 3 image_size: typing.Optional[dict[str, int]] = None image_mean: typing.Union[float, list[float], NoneType] = None image_std: typing.Union[float, list[float], NoneType] = None transform: typing.Optional[typing.Callable] = None do_rescale: typing.Optional[bool] = None rescale_factor: typing.Optional[float] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = <TensorType.PYTORCH: 'pt'> **kwargs )

参数

images (ImageInput) — 要预处理的图像列表。
image_size (int，可选，默认为 self.image_size) — 将图片大小调整为该值。
image_num_channels (int，可选，默认为 self.image_num_channels) — 图像通道数。
image_mean (float 或 list[float]，可选，默认为 IDEFICS_STANDARD_MEAN) — 如果对图像进行归一化，则使用的均值。这是一个浮点数或浮点数列表，其长度与图像中的通道数相同。可以通过 preprocess 方法中的 image_mean 参数覆盖。
image_std (float 或 list[float]，可选，默认为 IDEFICS_STANDARD_STD) — 如果对图像进行归一化，则使用的标准差。这是一个浮点数或浮点数列表，其长度与图像中的通道数相同。可以通过 preprocess 方法中的 image_std 参数覆盖。
transform (Callable，可选，默认为 None) — 可以传入一个自定义的转换函数，接受单个图像用于训练。例如，torchvision.Compose 可用于组合多个转换。如果为 None - 则假定为推理模式 - 然后将一套推理专用转换应用于图像。
do_rescale (bool，可选，默认为 True) — 是否按指定的缩放因子 rescale_factor 重新缩放图像。可以通过 preprocess 方法中的 do_rescale 覆盖。
rescale_factor (int 或 float，可选，默认为 1/255) — 如果对图像进行重新缩放，则使用的缩放因子。可以通过 preprocess 方法中的 rescale_factor 覆盖。

预处理一批图像。

IdeficsProcessor

class transformers.IdeficsProcessor

< source >

( image_processor tokenizer = None image_size = 224 add_end_of_utterance_token = None **kwargs )

参数

image_processor (IdeficsImageProcessor) — 一个 IdeficsImageProcessor 实例。图像处理器是必需输入。
tokenizer (LlamaTokenizerFast) — 一个 LlamaTokenizerFast 实例。分词器是必需输入。
image_size (int，可选，默认为 224) — 图像尺寸 (假定为方形图像)。
add_end_of_utterance_token (str，可选) — 表示话语结束的标记的字符串表示。

构建一个 IDEFICS 处理器，它将 LLama 分词器和 IDEFICS 图像处理器封装到一个处理器中。

IdeficsProcessor 提供了 IdeficsImageProcessor 和 LlamaTokenizerFast 的所有功能。有关更多信息，请参阅 **call**() 和 decode() 的文档字符串。

call

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], list[typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]], str, list[str], list[list[str]]] = None text: typing.Union[str, list[str], list[list[str]], list[list[list[str]]]] = None audio = None videos = None **kwargs: typing_extensions.Unpack[transformers.models.idefics.processing_idefics.IdeficsProcessorKwargs] ) → 一个包含条目的字典

参数

images (Union[ImageInput, list[ImageInput], str, list[str], list[list[str]]]) — 单个图像或批量图像列表 - 当文本仅包含文本提示时，可以传入此参数以使用图像-文本-文本行为。
text (Union[list[TextInput], [list[list[TextInput]]]]) — 单个提示或批量提示列表 - 请参阅参数文档部分结束后的详细说明。
return_tensors (str 或 TensorType，可选，默认为 TensorType.PYTORCH) — 返回张量的类型。可以是以下之一：
- TensorType.PYTORCH 或 'pt'：返回 torch.Tensor 类型的批处理。

一个包含条目的字典

input_ids、attention_mask、pixel_values、image_attention_mask，可以直接传递给 model.generate

此方法接收由文本和图像组成的批处理或非批处理提示，并将它们转换为模型训练所用的提示，并准备图像像素值供模型处理。

详细解释

text 中的每个条目都是一个可以直接传递的文本，或一个将被处理的图像。

图像可以是图像对象（PIL.Image）或可以从中检索图像的 URL。

当处理器遇到图像时，它将在提示中注入条目。

示例

checkpoint = "HuggingFaceM4/idefics-9b"
processor = AutoProcessor.from_pretrained(checkpoint)
url = "https://hips.hearstapps.com/hmg-prod/images/cute-photos-of-cats-in-grass-1593184777.jpg"
img = processor.image_processor.fetch_images([url])[0]

prompts = [
    "User:",
    img,
    "Describe this image.
t: An image of two kittens in grass.

    "User:",
    "https://hips.hearstapps.com/hmg-prod/images/dog-puns-1581708208.jpg",
    "Describe this image.
t:",
]

inputs = processor(text=prompts, return_tensors="pt")
generated_ids = model.generate(**inputs, max_length=100)
generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]

在此示例中，prompts 将转换为

<s>User:<fake_token_around_image><image><fake_token_around_image>Describe this image.
Assistant: An image of two kittens in grass.
User:<fake_token_around_image><image><fake_token_around_image>Describe this image.
Assistant:'

这两个图像将使用 IdeficsImageProcessor.**call**() 方法进行处理，并放置在返回值的 pixel_values 字典条目中。

此示例还展示了图像可以作为对象或作为文本 URL 传递。可以看出，第一个图像作为对象传递，第二个图像作为 URL 传递。

进行训练

image_transform = transforms.Compose(
    [
        transforms.RandomResizedCrop(
            (w, h), scale=(0.9, 1.0), interpolation=transforms.InterpolationMode.BICUBIC
        ),
        transforms.ToTensor(),
        transforms.Normalize(mean=self.image_mean, std=self.image_std),
    ]
)
inputs = processor(text=prompts, transform=image_transform, return_tensors="pt")

为了帮助调试提示生成，请启用 debug=True，它将显示正在发生的情况。

< > 在 GitHub 上更新