Idefics2
概述
Idefics2 模型由 Léo Tronchon、Hugo Laurencon 和 Victor Sanh 在 构建视觉语言模型时，哪些因素很重要？ 中提出。相应的博客文章可以在 这里 找到。
Idefics2 是一款开放的多模态模型，它可以接受任意顺序的图像和文本输入，并生成文本输出。该模型可以回答有关图像的问题，描述视觉内容，根据多个图像创作故事，或者在没有视觉输入的情况下充当纯语言模型。它在 IDEFICS-1 的基础上进行了改进，特别是在文档理解、OCR 或视觉推理方面。Idefics2 非常轻量级（80 亿个参数），并且以其原生纵横比和分辨率处理图像，这使得推理效率有所不同。
论文中的摘要如下：
人们对视觉语言模型 (VLM) 的兴趣日益浓厚，这得益于大型语言模型和视觉 transformer 的改进。尽管关于该主题的文献数量众多，但我们观察到，关于 VLM 设计的关键决策往往缺乏充分的论证。我们认为，这些缺乏支持的决策阻碍了该领域的进展，因为它难以确定哪些选择可以提高模型性能。为了解决这个问题，我们围绕预训练模型、架构选择、数据和训练方法进行了广泛的实验。我们对这些发现的整合包括开发 Idefics2，这是一种高效的基础 VLM，具有 80 亿个参数。Idefics2 在其尺寸类别中，在各种多模态基准测试中取得了最先进的性能，并且经常与规模是其四倍的模型相当。我们发布了该模型（基础、指示和聊天），以及用于其训练的数据集。
Idefics2 架构。摘自 原始论文。该模型由 amyeroberts 贡献。原始代码可以在 这里 找到。
使用方法提示
- 每个样本可以包含多个图像，并且图像数量在样本之间可能会有所不同。处理器将对输入进行填充，使其达到批次中图像的最大数量，以便输入模型。
- 处理器有一个
do_image_splitting选项。如果为True，则每个输入图像将被拆分为 4 个子图像，并与原始图像连接起来，形成 5 个图像。这对提高模型性能很有用。确保将processor.image_processor.do_image_splitting设置为False，如果模型不是使用此选项训练的。 - 传递给处理器的
text应具有<image>标记，以便在其中插入图像。如果文本是聊天消息，则在每个话语的末尾加上<end_of_utterance>。 - 处理器有自己的
apply_chat_template方法，用于将聊天消息转换为文本，然后可以将其作为text传递给处理器。
在聊天消息上使用处理器的示例
import requests
from PIL import Image
from transformers import Idefics2Processor, Idefics2ForConditionalGeneration
import torch
device = "cuda" if torch.cuda.is_available() else "cpu"
url_1 = "http://images.cocodataset.org/val2017/000000039769.jpg"
url_2 = "http://images.cocodataset.org/val2017/000000219578.jpg"
image_1 = Image.open(requests.get(url_1, stream=True).raw)
image_2 = Image.open(requests.get(url_2, stream=True).raw)
images = [image_1, image_2]
messages = [{
"role": "user",
"content": [
{"type": "text", "text": "What’s the difference between these two images?"},
{"type": "image"},
{"type": "image"},
],
}]
processor = Idefics2Processor.from_pretrained("HuggingFaceM4/idefics2-8b")
model = Idefics2ForConditionalGeneration.from_pretrained("HuggingFaceM4/idefics2-8b")
model.to(device)
# at inference time, one needs to pass `add_generation_prompt=True` in order to make sure the model completes the prompt
text = processor.apply_chat_template(messages, add_generation_prompt=True)
print(text)
# 'User: What’s the difference between these two images?<image><image><end_of_utterance>\nAssistant:'
inputs = processor(images=images, text=text, return_tensors="pt").to(device)
generated_text = model.generate(**inputs, max_new_tokens=500)
generated_text = processor.batch_decode(generated_text, skip_special_tokens=True)[0]
print("Generated text:", generated_text)- 在训练过程中，确定模型不应该学习哪些标记非常重要。对于 Idefics2，这通常归结为图像和填充标记。这意味着可以按如下方式创建标签：
import requests
from PIL import Image
from transformers import Idefics2Processor, Idefics2ForConditionalGeneration
import torch
url_1 = "http://images.cocodataset.org/val2017/000000039769.jpg"
url_2 = "http://images.cocodataset.org/val2017/000000219578.jpg"
image_1 = Image.open(requests.get(url_1, stream=True).raw)
image_2 = Image.open(requests.get(url_2, stream=True).raw)
images = [image_1, image_2]
messages = [{
"role": "user",
"content": [
{"type": "text", "text": "What’s the difference between these two images?"},
{"type": "image"},
{"type": "image"},
],
},
{
"role": "assistant",
"content": [
{"type": "text", "text": "The difference is that one image is about dogs and the other one about cats."},
],
}]
device = "cuda" if torch.cuda.is_available() else "cpu"
processor = Idefics2Processor.from_pretrained("HuggingFaceM4/idefics2-8b")
model = Idefics2ForConditionalGeneration.from_pretrained("HuggingFaceM4/idefics2-8b")
model.to(device)
text = processor.apply_chat_template(messages, add_generation_prompt=False)
inputs = processor(images=images, text=text, return_tensors="pt").to(device)
labels = inputs.input_ids.clone()
labels[labels == processor.tokenizer.pad_token_id] = -100
labels[labels == model.config.image_token_id] = -100
inputs["labels"] = labels
outputs = model(**inputs)
loss = outputs.loss
loss.backward()请注意，当在用户和助手之间进行的多轮对话上训练 Idefics2 时，通常也会将所有与用户消息相对应的标记设置为 -100。
模型优化：Flash Attention
上面的代码片段展示了没有使用任何优化技巧的推理。但是，可以通过利用 Flash Attention 来大幅提高模型速度，它是一种更快地实现模型内部使用的注意力机制的方法。
首先，确保安装了最新版本的 Flash Attention 2，以包含滑动窗口注意力功能。
pip install -U flash-attn --no-build-isolation
还要确保拥有与 Flash Attention 2 兼容的硬件。在 flash attention 存储库 的官方文档中了解有关它的更多信息。还要确保以半精度加载模型（例如，torch.float16）。
要使用 Flash Attention-2 加载和运行模型，只需更改上面的代码片段，进行如下更改：
model = Idefics2ForConditionalGeneration.from_pretrained(
"HuggingFaceM4/idefics2-8b",
+ torch_dtype=torch.float16,
+ attn_implementation="flash_attention_2",
).to(device)使用量化缩小 Idefics2
由于 Idefics2 模型具有 80 亿个参数，因此以半精度 (float16) 存储将需要大约 16GB 的 GPU RAM，因为每个参数都存储在 2 个字节中。但是，可以使用 量化 来缩小模型的大小。如果模型被量化为 4 位（或每个参数半字节），则只需要大约 3.5GB 的 RAM。
量化模型就像将 quantization_config 传递给模型一样简单。可以使用以下更改来更改上面的代码片段。我们将利用 BitsAndyBytes 量化（但请参考 此页面 了解其他量化方法）。
+ from transformers import BitsAndBytesConfig
+ quantization_config = BitsAndBytesConfig(
+ load_in_4bit=True,
+ bnb_4bit_quant_type="nf4",
+ bnb_4bit_use_double_quant=True,
+ bnb_4bit_compute_dtype=torch.float16
+ )
model = Idefics2ForConditionalGeneration.from_pretrained(
"HuggingFaceM4/idefics2-8b",
+ torch_dtype=torch.float16,
+ quantization_config=quantization_config,
).to(device)资源
以下是一些官方的 Hugging Face 和社区（由 🌎 表示）资源，可以帮助您开始使用 Idefics2。如果您有兴趣提交要包含在此处的资源，请随时打开一个拉取请求，我们将对其进行审核！理想情况下，该资源应展示一些新内容，而不是重复现有资源。
- 有关如何使用 Trainer 在自定义数据集上微调 Idefics2 的笔记本，可以在 这里 找到。它支持完全微调以及（量化）LoRa。
- 有关如何使用 TRL 库微调 Idefics2 的脚本可以在 这里 找到。
- 有关针对 JSON 提取用例微调 Idefics2 的演示笔记本，可以在 这里 找到。 🌎
Idefics2Config
class transformers.Idefics2Config
< 源代码 >( use_cache = True image_token_id = 32001 tie_word_embeddings = False vision_config = None perceiver_config = None text_config = None **kwargs )
参数
- use_cache (
bool, 可选, 默认为True) — 模型是否应该缓存注意力机制的键值对。 - image_token_id (
int, 可选, 默认为 32001) — “图片” token 的 id。 - tie_word_embeddings (
bool, 可选, 默认为False) — 是否将词嵌入与 token 嵌入绑定。 - vision_config (
IdeficsVisionConfig或dict, 可选) — 自定义视觉配置或字典 - perceiver_config (
IdeficsPerceiverConfig或dict, 可选) — 自定义 perceiver 配置或字典 - text_config (
MistralConfig或dict, 可选) — 文本模型的自定义文本配置或字典
这是用来存储 Idefics2Model 配置的配置类。它被用来根据指定的参数实例化 Idefics2 模型，定义模型架构。用默认值实例化一个配置将生成与 Idefics2 HuggingFaceM4/idefics2-8b 架构的模型类似的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 文档以获取更多信息。
Idefics2Model
class transformers.Idefics2Model
< 源代码 >( config: Idefics2Config )
参数
- config (Idefics2Config 或
Idefics2VisionConfig) — 模型配置类，包含模型的所有参数。用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。
包含 SIGLIP 视觉编码器和 Mistral 语言解码器的 Idefics2 模型，该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头等）。
此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解与一般使用和行为相关的所有事项。
正向传播
< 源代码 >( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None pixel_values: Optional = None pixel_attention_mask: Optional = None image_hidden_states: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 输入序列词元的词汇表索引。如果提供填充，默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 用于避免对填充词元索引执行注意的掩码。掩码值选择在[0, 1]中：- 1 表示 未掩码 的词元
- 0 表示 掩码 的词元
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用
past_key_values，则可以选择仅输入最后一个decoder_input_ids（那些没有输入到此模型的过去键值状态的词元）（参见past_key_values），形状为(batch_size, 1)，而不是所有decoder_input_ids，形状为(batch_size, sequence_length)。如果您想更改填充行为，您应该阅读
modeling_opt._prepare_decoder_attention_mask并修改以满足您的需求。有关默认策略的更多信息，请参阅 论文 中的图 1。- 1 表示头部 未掩码
- 0 表示头部 掩码
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列词元在位置嵌入中的位置索引。选择在[0, config.n_positions - 1]范围内。什么是位置 ID？ - past_key_values (
tuple(tuple(torch.FloatTensor)), 可选，在传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(tuple(torch.FloatTensor))，每个元组包含 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量) 以及 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可以用于（参见
past_key_values输入）加快顺序解码速度。如果使用
past_key_values，则用户可以选择仅输入最后一个decoder_input_ids（那些没有输入到此模型的过去键值状态的词元），形状为(batch_size, 1)，而不是所有decoder_input_ids，形状为(batch_size, sequence_length)。 - inputs_embeds (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想比模型的内部嵌入查找矩阵更好地控制如何将input_ids索引转换为关联的向量，这将很有用。 - pixel_values (
torch.FloatTensor形状为(batch_size, num_channels, image_size, image_size)) -- 对应于输入图像的张量。可以使用 [AutoImageProcessor](/docs/transformers/v4.45.2/en/model_doc/auto#transformers.AutoImageProcessor) 获取像素值。有关详细信息，请参阅 [CLIPImageProcessor.__call__()](/docs/transformers/v4.45.2/en/model_doc/videomae#transformers.VideoMAEFeatureExtractor.__call__) ([]LlavaProcessor`] 使用 CLIPImageProcessor 处理图像)。 - pixel_attention_mask (
torch.Tensor形状为(batch_size, image_size, image_size), 可选) — 用于避免对填充像素索引执行注意力的掩码。 - image_hidden_states (
torch.FloatTensor形状为(batch_size, num_channels, image_size, image_size)) — 模态投影和感知器重采样后图像编码器的隐藏状态。 - use_cache (
bool, 可选) — 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
The Idefics2Model 前向方法，覆盖了 __call__ 特殊方法。
虽然前向传递的配方需要在此函数内定义，但应该之后调用 Module 实例，而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
馈送到模型的输入可以具有任意数量的图像。为了解决这个问题，馈送到模型的 pixel_values 具有图像填充 -> (batch_size, max_num_images, 3, max_heights, max_widths)，其中 max_num_images 是批次中批次大小样本中的最大图像数量。
除了在模型入口处填充 pixel_values 之外，不需要填充图像。为了提高效率，我们只通过视觉模型的前向传递真实图像，通过丢弃填充图像，即大小为 (image_batch_size, 3, height, width) 的 pixel_values，其中 image_batch_size 在 num_images_per_sample=[1, 3, 1, 2] 时将为 7，max_num_images 将为 3。
Idefics2ForConditionalGeneration
class transformers.Idefics2ForConditionalGeneration
< source >( config )
参数
- config (Idefics2Config 或
Idefics2VisionConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained() 方法以加载模型权重。
具有语言建模头的 Idefics2 模型。它由一个 SigLIP 视觉编码器组成，顶部有一个语言建模头。该模型继承自 PreTrainedModel。查看超类文档以了解该库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解与一般使用和行为相关的所有事项。
正向传播
< source >( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None pixel_values: Optional = None pixel_attention_mask: Optional = None image_hidden_states: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None num_logits_to_keep: int = 0 ) → transformers.models.idefics2.modeling_idefics2.Idefics2CausalLMOutputWithPast or tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 输入序列 token 在词表中的索引。如果您提供填充，默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length)，可选) — 掩码，避免对填充 token 索引执行注意力。掩码值在[0, 1]中选择：- 1 代表未掩码的 token，
- 0 代表已掩码的 token。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 。
如果使用
past_key_values，则可选地只需要输入最后一个decoder_input_ids（参见past_key_values）。如果您想更改填充行为，您应该阅读
modeling_opt._prepare_decoder_attention_mask并根据您的需要进行修改。有关默认策略的更多信息，请参阅论文 中的图 1。- 1 表示头部未掩码，
- 0 表示头部已掩码。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length)，可选) — 输入序列 token 在位置嵌入中的位置索引。在[0, config.n_positions - 1]范围内选择。 什么是位置 ID？ - past_key_values (
tuple(tuple(torch.FloatTensor))，可选，在传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组包含 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，以及 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加快顺序解码。如果使用
past_key_values，用户可以选择性地仅输入最后一个decoder_input_ids（形状为(batch_size, 1)），而不是所有decoder_input_ids（形状为(batch_size, sequence_length)）。 - inputs_embeds (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入式表示，而不是传递input_ids。如果您想要更多地控制如何将input_ids索引转换为关联的向量，而不是模型的内部嵌入查找矩阵，这将非常有用。 - pixel_values (
torch.FloatTensor形状为(batch_size, num_channels, image_size, image_size)) -- 与输入图像相对应的张量。可以使用 [AutoImageProcessor](/docs/transformers/v4.45.2/en/model_doc/auto#transformers.AutoImageProcessor) 获取像素值。有关详细信息，请参阅 [CLIPImageProcessor.__call__()](/docs/transformers/v4.45.2/en/model_doc/videomae#transformers.VideoMAEFeatureExtractor.__call__) ([]`LlavaProcessor`] 使用 CLIPImageProcessor 处理图像）。 - pixel_attention_mask (
torch.Tensor形状为(batch_size, image_size, image_size)，可选) — 用于避免对填充像素索引执行注意力的掩码。 - image_hidden_states (
torch.FloatTensor形状为(batch_size, num_channels, image_size, image_size)) — 图像编码器在模态投影和感知器重采样之后的隐藏状态。 - use_cache (
bool，可选) — 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。参数 — labels (
torch.LongTensor形状为(batch_size, sequence_length)，可选)：用于计算掩码语言建模损失的标签。索引应在[0, ..., config.vocab_size]或model.image_token_id中（其中model是Idefics2ForConditionalGeneration的实例）。索引设置为model.image_token_id的标记将被忽略（掩码），损失仅针对标签在[0, ..., config.vocab_size]中的标记计算。num_logits_to_keep (
int，可选)：计算最后num_logits_to_keep个标记的 logits。如果为0，则计算所有input_ids的 logits（特殊情况）。生成只需要最后一个标记的 logits，并且仅针对该标记计算 logits 可以节省内存，这对长序列或大型词汇量来说非常重要。
返回
transformers.models.idefics2.modeling_idefics2.Idefics2CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
transformers.models.idefics2.modeling_idefics2.Idefics2CausalLMOutputWithPast 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或者当 config.return_dict=False 时），包括取决于配置 (Idefics2Config) 和输入的各种元素。
- loss (
torch.FloatTensor形状为(1,)，可选，当提供labels时返回) — 语言建模损失（用于下一个标记预测）。 - logits (
torch.FloatTensor形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前的每个词汇标记的分数）。 - past_key_values (
tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或者当config.use_cache=True时返回) — 长度为config.n_layers的tuple(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)。由视觉编码器生成的模型的 image_hidden_states，以及可选的感知器生成的 image_hidden_states
Idefics2ForConditionalGeneration 正向方法，覆盖 __call__ 特殊方法。
虽然前向传递的配方需要在此函数内定义，但应该之后调用 Module 实例，而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> import requests
>>> import torch
>>> from PIL import Image
>>> from io import BytesIO
>>> from transformers import AutoProcessor, AutoModelForVision2Seq
>>> from transformers.image_utils import load_image
>>> # Note that passing the image urls (instead of the actual pil images) to the processor is also possible
>>> image1 = load_image("https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg")
>>> image2 = load_image("https://cdn.britannica.com/59/94459-050-DBA42467/Skyline-Chicago.jpg")
>>> image3 = load_image("https://cdn.britannica.com/68/170868-050-8DDE8263/Golden-Gate-Bridge-San-Francisco.jpg")
>>> processor = AutoProcessor.from_pretrained("HuggingFaceM4/idefics2-8b-base")
>>> model = AutoModelForVision2Seq.from_pretrained("HuggingFaceM4/idefics2-8b-base", device_map="auto")
>>> BAD_WORDS_IDS = processor.tokenizer(["<image>", "<fake_token_around_image>"], add_special_tokens=False).input_ids
>>> EOS_WORDS_IDS = [processor.tokenizer.eos_token_id]
>>> # Create inputs
>>> prompts = [
... "<image>In this image, we can see the city of New York, and more specifically the Statue of Liberty.<image>In this image,",
... "In which city is that bridge located?<image>",
... ]
>>> images = [[image1, image2], [image3]]
>>> inputs = processor(text=prompts, images=images, padding=True, return_tensors="pt").to("cuda")
>>> # Generate
>>> generated_ids = model.generate(**inputs, bad_words_ids=BAD_WORDS_IDS, max_new_tokens=20)
>>> generated_texts = processor.batch_decode(generated_ids, skip_special_tokens=True)
>>> print(generated_texts)
['In this image, we can see the city of New York, and more specifically the Statue of Liberty. In this image, we can see the city of New York, and more specifically the Statue of Liberty.\n\n', 'In which city is that bridge located?\n\nThe bridge is located in the city of Pittsburgh, Pennsylvania.\n\n\nThe bridge is']Idefics2ImageProcessor
class transformers.Idefics2ImageProcessor
< 源代码 >( do_convert_rgb: bool = True do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: float = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_pad: bool = True do_image_splitting: bool = False **kwargs )
参数
- do_convert_rgb (
bool, 可选, 默认为True) — 是否将图像转换为 RGB。 对于输入图像为其他格式（例如 RGBA）的情况，此功能非常有用。 仅在输入图像为 PIL 格式时有效。 - do_resize (
bool, 可选, 默认为True) — 是否调整图像大小。 图像的最长边将调整为 <=size["longest_edge"]，最短边将调整为保持输入纵横比，最小尺寸为size["shortest_edge"]。 - size (
Dict, 可选) — 控制输出图像的大小。 这是一个包含键“shortest_edge”和“longest_edge”的字典。 - resample (
Resampling, 可选, 默认为Resampling.BILINEAR) — 调整图像大小时的重采样过滤器。 - do_rescale (
bool, 可选, 默认为True) — 是否重新调整图像大小。 如果设置为True，图像将重新调整大小，使其像素值介于 0 和 1 之间。 - rescale_factor (
float, 可选, 默认为1/255) — 如果do_rescale设置为True，则重新调整图像大小的重新调整大小因子。 - do_normalize (
bool, 可选, 默认为True) — 是否对图像进行标准化。 如果设置为True，图像将被标准化为平均值为image_mean，标准差为image_std。 - image_mean (
float或List[float], 可选, 默认为IDEFICS_STANDARD_MEAN) — 标准化图像时使用的平均值。 这是一个浮点数或浮点数列表，其长度与图像中通道的数量相同。 可以被preprocess方法中的image_mean参数覆盖。 可以被preprocess方法中的image_mean参数覆盖。 - image_std (
float或List[float], 可选, 默认为IDEFICS_STANDARD_STD) — 标准化图像时使用的标准差。 这是一个浮点数或浮点数列表，其长度与图像中通道的数量相同。 可以被image_std参数覆盖preprocess方法。 可以被image_std参数覆盖preprocess方法。 - do_pad (
bool, 可选, 默认值为True) — 是否将图像填充到批次中的最大高度和宽度以及批次中每个样本的图像数量，以便返回的张量形状为 (批次大小, 最大图像数量, 通道数量, 最大高度, 最大宽度)。 - do_image_splitting (
bool, 可选, 默认值为False) — 是否将图像分割成 4 个相等子图像的序列，并与原始图像连接起来。 该策略最早在 https://arxiv.org/abs/2311.06607 中提出。
构建 Idefics 图像处理器。
预处理
< 源代码 >( 图像: Union do_convert_rgb: Optional = None do_resize: Optional = None 尺寸: Optional = None 重采样: Resampling = None do_rescale: Optional = None 重缩放因子: Optional = None do_normalize: Optional = None 图像均值: Union = None 图像标准差: Union = None do_pad: Optional = None do_image_splitting: Optional = None 返回张量: Union = None 输入数据格式: Optional = None 数据格式: Optional = <ChannelDimension.FIRST: 'channels_first'> )
参数
- 图像 (
ImageInput) — 要预处理的图像列表。 - do_convert_rgb (
bool, 可选, 默认值为self.do_convert_rgb) — 是否将图像转换为 RGB。 - do_resize (
bool, 可选, 默认值为self.do_resize) — 是否调整图像大小。 - 尺寸 (
Dict[str, int], 可选, 默认值为self.size) — 调整大小后图像的尺寸。 图像的最短边被调整为 size[“shortest_edge”]，最长边被调整以保持输入纵横比。 - 重采样 (
int, 可选, 默认值为self.resample) — 如果调整图像大小，要使用的重采样滤波器。 这可以是枚举PILImageResampling中的一个。 只有在do_resize设置为True时才有效。 - do_rescale (
bool, 可选, 默认值为self.do_rescale) — 是否重缩放图像。 - rescale_factor (
float, 可选, 默认值为self.rescale_factor) — 如果do_rescale设置为True，则用于对图像进行重新缩放的缩放因子。 - do_normalize (
bool, 可选, 默认值为self.do_normalize) — 是否对图像进行归一化。 - image_mean (
float或List[float], 可选, 默认值为self.image_mean) — 用于归一化的图像均值。仅在do_normalize设置为True时有效。 - image_std (
float或List[float], 可选, 默认值为self.image_std) — 用于归一化的图像标准差。仅在do_normalize设置为True时有效。 - do_pad (
bool, 可选, 默认值为self.do_pad) — 是否将图像填充到批次中最大的高度和宽度。 - do_image_splitting (
bool, 可选, 默认值为self.do_image_splitting) — 是否将图像分割成 4 个相等的子图像序列，并与原始图像连接在一起。这种策略首先在 https://arxiv.org/abs/2311.06607 中提出。 - return_tensors (
str或TensorType, 可选) — 要返回的张量类型。可以是以下之一：- 未设置：返回一个
np.ndarray列表。 TensorType.TENSORFLOW或'tf'：返回一个tf.Tensor类型的批次。TensorType.PYTORCH或'pt'：返回一个torch.Tensor类型的批次。TensorType.NUMPY或'np'：返回一个np.ndarray类型的批次。TensorType.JAX或'jax'：返回一个jax.numpy.ndarray类型的批次。
- 未设置：返回一个
- data_format (
ChannelDimension或str, 可选, 默认值为ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一："channels_first"或ChannelDimension.FIRST：图像以 (num_channels, height, width) 格式。"channels_last"或ChannelDimension.LAST：图像以 (height, width, num_channels) 格式。- 未设置：使用输入图像的通道维度格式。
- input_data_format (
ChannelDimension或str, 可选) — 输入图像的通道维度格式。如果未设置，则从输入图像推断通道维度格式。可以是以下之一："channels_first"或ChannelDimension.FIRST：图像以 (num_channels, height, width) 格式。"channels_last"或ChannelDimension.LAST：图像以 (height, width, num_channels) 格式。"none"或ChannelDimension.NONE：图像以 (height, width) 格式。
预处理一批图像。
Idefics2Processor
class transformers.Idefics2Processor
< source >参数
__call__
参数
- image_seq_len (
int, 可选) — 图像序列的长度。如果没有提供，将使用默认值。 - padding (
Union[bool, str, PaddingStrategy], 可选, 默认值为False) — 应用于输入 ID 的填充策略。有关更多信息，请参见 PreTrainedTokenizerFast.pad()。 - truncation (
Union[bool, str, TruncationStrategy], 可选) — 应用于输入 ID 的截断策略。有关更多信息，请参见PreTrainedTokenizerFast.truncate。 - max_length (
int, 可选) — 返回列表的最大长度，以及可选的填充/截断长度。有关更多信息，请参见 PreTrainedTokenizerFast.call()。 - is_split_into_words (
bool, 可选, 默认值为False) — 输入文本是否已拆分为单词。如果设置为True，则标记器将跳过标记化过程并假定输入已完成标记化。 - add_special_tokens (
bool, 可选, 默认值为True) — 是否添加特殊标记。有关更多信息，请参见 PreTrainedTokenizerFast.call()。 - return_tensors (
Union[str, TensorType], 可选) — 如果设置，将返回特定框架的张量。有关更多信息，请参见 PreTrainedTokenizerFast.call()。
处理输入提示并返回 BatchEncoding。
示例
>>> import requests
>>> from transformers import Idefics2Processor
>>> from transformers.image_utils import load_image
>>> processor = Idefics2Processor.from_pretrained("HuggingFaceM4/idefics2-8b", image_seq_len=2)
>>> processor.image_processor.do_image_splitting = False # Force as False to simplify the example
>>> url1 = "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
>>> url2 = "https://cdn.britannica.com/59/94459-050-DBA42467/Skyline-Chicago.jpg"
>>> image1, image2 = load_image(url1), load_image(url2)
>>> images = [[image1], [image2]]
>>> text = [
... "<image>In this image, we see",
... "bla bla bla<image>",
... ]
>>> outputs = processor(text=text, images=images, return_tensors="pt", padding=True)
>>> input_ids = outputs.input_ids
>>> input_tokens = processor.tokenizer.batch_decode(input_ids)
>>> print(input_tokens)
['<s><fake_token_around_image><image><image><fake_token_around_image> In this image, we see', '<s> bla bla bla<fake_token_around_image><image><image><fake_token_around_image>']