Transformers 文档
AyaVision
并获取增强的文档体验
开始使用
AyaVision
概述
Aya Vision 8B 和 32B 模型是由 Cohere For AI 开发的先进的多语言多模态模型。它们基于 Aya Expanse 的配方构建，以处理视觉和文本信息，同时不影响原始模型强大的多语言文本性能。
Aya Vision 8B 结合了 Siglip2-so400-384-14 视觉编码器和 Cohere CommandR-7B 语言模型，并通过 Aya Expanse 配方进一步进行后训练，创建了一个强大的视觉-语言模型，能够理解图像并生成 23 种语言的文本。而 Aya Vision 32B 则使用 Aya Expanse 32B 作为语言模型。
Aya Vision 的主要功能包括
- 23 种语言的多模态能力
- 从 CommandR-7B 继承而来的强大的纯文本多语言能力，并通过 Aya Expanse 配方和 Aya Expanse 32B 进行后训练
- 使用 Siglip2-so400-384-14 视觉编码器实现高质量的视觉理解
- 23 种语言的视觉和文本信息的无缝集成。
提示
- Aya Vision 是一个多模态模型，它以图像和文本作为输入，并生成文本作为输出。
- 图像使用模板化输入中的
<image>标签表示。 - 为了获得最佳效果，请使用处理器的
apply_chat_template方法来正确格式化您的输入。 - 该模型可以在单个对话中处理多个图像。
- Aya Vision 可以理解和生成 23 种语言的文本，使其适用于多语言多模态应用。
此模型由 saurabhdash 和 yonigozlan 贡献。
使用方法
以下是如何使用 Aya Vision 进行推理
from transformers import AutoProcessor, AutoModelForImageTextToText
import torch
model_id = "CohereForAI/aya-vision-8b"
torch_device = "cuda:0"
# Use fast image processor
processor = AutoProcessor.from_pretrained(model_id, use_fast=True)
model = AutoModelForImageTextToText.from_pretrained(
model_id, device_map=torch_device, torch_dtype=torch.float16
)
# Format message with the aya-vision chat template
messages = [
{"role": "user",
"content": [
{"type": "image", "url": "https://pbs.twimg.com/media/Fx7YvfQWYAIp6rZ?format=jpg&name=medium"},
{"type": "text", "text": "चित्र में लिखा पाठ क्या कहता है?"},
]},
]
# Process image on CUDA
inputs = processor.apply_chat_template(
messages, padding=True, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", device=torch_device
).to(model.device)
gen_tokens = model.generate(
**inputs,
max_new_tokens=300,
do_sample=True,
temperature=0.3,
)
gen_text = print(processor.tokenizer.decode(gen_tokens[0][inputs.input_ids.shape[1]:], skip_special_tokens=True))Pipeline
from transformers import pipeline
pipe = pipeline(model="CohereForAI/aya-vision-8b", task="image-text-to-text", device_map="auto")
# Format message with the aya-vision chat template
messages = [
{"role": "user",
"content": [
{"type": "image", "url": "https://media.istockphoto.com/id/458012057/photo/istanbul-turkey.jpg?s=612x612&w=0&k=20&c=qogAOVvkpfUyqLUMr_XJQyq-HkACXyYUSZbKhBlPrxo="},
{"type": "text", "text": "Bu resimde hangi anıt gösterilmektedir?"},
]},
]
outputs = pipe(text=messages, max_new_tokens=300, return_full_text=False)
print(outputs)多图和批量输入
Aya Vision 可以在单个对话中处理多个图像。以下是如何将它与多个图像一起使用
from transformers import AutoProcessor, AutoModelForImageTextToText
import torch
model_id = "CohereForAI/aya-vision-8b"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForImageTextToText.from_pretrained(
model_id, device_map="cuda:0", torch_dtype=torch.float16
)
# Example with multiple images in a single message
messages = [
{
"role": "user",
"content": [
{
"type": "image",
"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg",
},
{
"type": "image",
"url": "https://thumbs.dreamstime.com/b/golden-gate-bridge-san-francisco-purple-flowers-california-echium-candicans-36805947.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)
gen_tokens = model.generate(
**inputs,
max_new_tokens=300,
do_sample=True,
temperature=0.3,
)
gen_text = processor.tokenizer.decode(gen_tokens[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(gen_text)对于处理批量输入（一次处理多个对话）
from transformers import AutoProcessor, AutoModelForImageTextToText
import torch
model_id = "CohereForAI/aya-vision-8b"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForImageTextToText.from_pretrained(
model_id, device_map="cuda:0", torch_dtype=torch.float16
)
# Prepare two different conversations
batch_messages = [
# First conversation with a single image
[
{
"role": "user",
"content": [
{"type": "image", "url": "https://llava-vl.github.io/static/images/view.jpg"},
{"type": "text", "text": "Write a haiku for this image"},
],
},
],
# Second conversation with multiple images
[
{
"role": "user",
"content": [
{
"type": "image",
"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg",
},
{
"type": "image",
"url": "https://thumbs.dreamstime.com/b/golden-gate-bridge-san-francisco-purple-flowers-california-echium-candicans-36805947.jpg",
},
{
"type": "text",
"text": "These images depict two different landmarks. Can you identify them?",
},
],
},
],
]
# Process each conversation separately and combine into a batch
batch_inputs = processor.apply_chat_template(
batch_messages,
padding=True,
add_generation_prompt=True,
tokenize=True,
return_dict=True,
return_tensors="pt"
).to(model.device)
# Generate responses for the batch
batch_outputs = model.generate(
**batch_inputs,
max_new_tokens=300,
do_sample=True,
temperature=0.3,
)
# Decode the generated responses
for i, output in enumerate(batch_outputs):
response = processor.tokenizer.decode(
output[batch_inputs.input_ids.shape[1]:],
skip_special_tokens=True
)
print(f"Response {i+1}:\n{response}\n")AyaVisionProcessor
class transformers.AyaVisionProcessor
< source >( image_processor = None tokenizer = None patch_size: int = 28 img_size: int = 364 image_token = '<image>' downsample_factor: int = 1 start_of_img_token = '<|START_OF_IMG|>' end_of_img_token = '<|END_OF_IMG|>' img_patch_token = '<|IMG_PATCH|>' img_line_break_token = '<|IMG_LINE_BREAK|>' tile_token = 'TILE' tile_global_token = 'TILE_GLOBAL' chat_template = None **kwargs )
参数
- image_processor (AutoImageProcessor, 可选) — 图像处理器是必需的输入。
- tokenizer ([
PreTrainedTokenizer,PreTrainedTokenizerFast], 可选) — 分词器是必需的输入。 - patch_size (
int, 可选, 默认为 28) — 用于分词的图像块的大小。 - img_size (
int, 可选, 默认为 364) — 要分词的图像的大小。这应与提供给图像处理器的大小相对应。 - image_token (
str, 可选, 默认为"<image>") — 用于表示文本中图像的标记。 - downsample_factor (
int, 可选, 默认为 1) — 用于缩放图像块大小的因子。 - start_of_img_token (
str, 可选, 默认为"<|START_OF_IMG|>") — 用于表示文本中图像开始的标记。 - end_of_img_token (
str, 可选, 默认为"<|END_OF_IMG|>") — 用于表示文本中图像结束的标记。 - img_patch_token (
str, 可选, 默认为"<|IMG_PATCH|>") — 用于表示文本中图像块的标记。 - img_line_break_token (
str, 可选, 默认为"<|IMG_LINE_BREAK|>") — 用于表示文本中换行符的 token。 - tile_token (
str, 可选, 默认为"TILE") — 用于表示文本中图像块的 token。 - tile_global_token (
str, 可选, 默认为"TILE_GLOBAL") — 用于表示文本中封面图像的 token。 - chat_template (
str, 可选) — 一个 Jinja 模板，用于将聊天中的消息列表转换为可标记化的字符串。
构建一个 AyaVision 处理器，它将 AutoImageProcessor 和 PretrainedTokenizerFast tokenizer 封装到一个单一的处理器中，该处理器继承了图像处理器和 tokenizer 的功能。 有关更多信息，请参阅 __call__() 和 decode()。
此方法将其所有参数转发到 PreTrainedTokenizerFast 的 batch_decode()。 有关更多信息，请参阅此方法的文档字符串。
此方法将其所有参数转发到 PreTrainedTokenizerFast 的 decode()。 有关更多信息，请参阅此方法的文档字符串。
AyaVisionConfig
class transformers.AyaVisionConfig
< source >( vision_config = None text_config = None vision_feature_select_strategy = 'full' vision_feature_layer = -1 downsample_factor = 2 adapter_layer_norm_eps = 1e-06 image_token_index = 255036 **kwargs )
参数
- vision_config (
Union[AutoConfig, dict], 可选, 默认为CLIPVisionConfig) — 视觉骨干网络的配置对象或字典。 - text_config (
Union[AutoConfig, dict], 可选, 默认为LlamaConfig) — 文本骨干网络的配置对象或字典。 - vision_feature_select_strategy (
str, 可选, 默认为"full") — 用于从视觉骨干网络中选择视觉特征的特征选择策略。 可以是"default"或"full"之一。 如果为"default"，则从视觉特征中删除 CLS token。 如果为"full"，则使用完整的视觉特征。 - vision_feature_layer (
int, 可选, 默认为 -1) — 用于选择视觉特征的层索引。 - downsample_factor (
int, 可选, 默认为 2) — 应用于视觉特征的下采样因子。 - adapter_layer_norm_eps (
float, 可选, 默认为 1e-06) — 适配器中层归一化使用的 epsilon 值。 - image_token_index (
int, 可选, 默认为 255036) — 用于编码图像提示的图像 token 索引。
这是用于存储 AyaVisionForConditionalGeneration 配置的配置类。 它用于根据指定的参数实例化 AyaVision 模型，从而定义模型架构。 使用默认值实例化配置将产生与 AyaVision 类似的配置。 例如： CohereForAI/aya-vision-8b
配置对象继承自 PretrainedConfig，可用于控制模型输出。 有关更多信息，请阅读 PretrainedConfig 中的文档。
AyaVisionForConditionalGeneration
class transformers.AyaVisionForConditionalGeneration
< source >( config: AyaVisionConfig )
参数
- config (AyaVisionConfig 或
AyaVisionVisionConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，只会加载配置。 查看 from_pretrained() 方法以加载模型权重。
AyaVision 模型由视觉骨干网络和语言模型组成。 此模型继承自 PreTrainedModel。 查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: LongTensor = None pixel_values: FloatTensor = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[typing.List[torch.FloatTensor]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None vision_feature_layer: typing.Union[int, typing.List[int], NoneType] = None vision_feature_select_strategy: typing.Optional[str] = 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 return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 image_sizes: Tensor = None **lm_kwargs ) → transformers.models.aya_vision.modeling_aya_vision.AyaVisionCausalLMOutputWithPast or tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor) — 词汇表中输入序列 token 的索引。 默认情况下，如果您提供填充，则会忽略填充。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- pixel_values (形状为 `(batch_size, num_channels, image_size, image_size)` 的
torch.FloatTensor) — 与输入图像对应的张量。 像素值可以使用 AutoImageProcessor 获得。 有关详细信息，请参阅 GotOcr2ImageProcessor.call()。 AyaVisionProcessor 使用 GotOcr2ImageProcessor 处理图像。 - attention_mask (形状为
(batch_size, sequence_length)的torch.Tensor, 可选) — 掩码，以避免在填充 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 表示 head 未被掩码，
- 0 表示 head 被掩码。
- position_ids (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 位置嵌入中每个输入序列 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，用户可以选择仅输入形状为(batch_size, 1)的最后一个decoder_input_ids（那些没有将其过去键值状态提供给此模型的），而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。 - inputs_embeds (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor, 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将input_ids索引转换为关联向量，这将非常有用。 - vision_feature_layer (
Union[int, List[int]], 可选, 默认为 -2) — 用于选择视觉特征的层索引。如果提供了多个索引，则会将相应索引的视觉特征连接起来以形成视觉特征。 - vision_feature_select_strategy (
str, 可选, 默认为"default") — 用于从视觉骨干网络中选择视觉特征的特征选择策略。可以是"default"或"full"之一。 - use_cache (
bool, 可选) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参见返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 - cache_position (形状为
(sequence_length)的torch.LongTensor, 可选) — 描述输入序列 token 在序列中位置的索引。与position_ids相反，此张量不受 padding 的影响。它用于在正确的位置更新缓存，并推断完整的序列长度。 - labels (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 用于计算掩码语言建模损失的标签。索引应为[0, ..., config.vocab_size]或 -100（请参阅input_ids文档字符串）。索引设置为-100的 token 将被忽略（掩码），损失仅针对标签在[0, ..., config.vocab_size]中的 token 计算。 - logits_to_keep (
int或torch.Tensor, 可选) — 如果是int，则计算最后logits_to_keep个 token 的 logits。 如果为0，则计算所有input_ids的 logits（特殊情况）。 仅生成最后一个 token 的 logits 是必需的，并且仅针对该 token 计算它们可以节省内存，这对于长序列或大词汇量来说变得非常重要。 如果是torch.Tensor，则必须是与序列长度维度中要保留的索引相对应的 1D 张量。 这在使用 packed tensor 格式（批次和序列长度的单维度）时非常有用。
返回
transformers.models.aya_vision.modeling_aya_vision.AyaVisionCausalLMOutputWithPast 或 tuple(torch.FloatTensor)
一个 transformers.models.aya_vision.modeling_aya_vision.AyaVisionCausalLMOutputWithPast 或 torch.FloatTensor 元组（如果传递 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (AyaVisionConfig) 和输入。
-
loss (形状为
(1,)的torch.FloatTensor, 可选, 当提供labels时返回) — 语言建模损失（用于下一个 token 预测）。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。 -
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 (
torch.FloatTensor, 可选) — 形状为(batch_size, num_images, sequence_length, hidden_size)的torch.FloatTensor。 由视觉编码器生成并在投影最后一个隐藏状态之后的模型的 image_hidden_states。
AyaVisionForConditionalGeneration 前向方法，覆盖了 __call__ 特殊方法。
尽管前向传播的配方需要在该函数内定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoProcessor, AyaVisionForConditionalGeneration
>>> import torch
>>> torch_device = "cuda:0"
>>> processor = AutoProcessor.from_pretrained("CohereForAI/aya-vision-8b", use_fast=True)
>>> model = AyaVisionForConditionalGeneration.from_pretrained("CohereForAI/aya-vision-8b", device_map=torch_device)
>>> messages = [
... {
... "role": "user",
... "content": [
... {
... "type": "image",
... "url": "https://pbs.twimg.com/media/Fx7YvfQWYAIp6rZ?format=jpg&name=medium",
... },
... {"type": "text", "text": "चित्र में लिखा पाठ क्या कहता है?"},
... ],
... }
... ]
>>> inputs = processor.apply_chat_template(
... messages, padding=True, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", device=torch_device
... ).to(model.device)
>>> gen_tokens = model.generate(**inputs, max_new_tokens=300, do_sample=True, temperature=0.3)
>>> processor.tokenizer.decode(gen_tokens[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)