Transformers 文档

Aria

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

PyTorch FlashAttention SDPA

Aria

Aria 是一个多模态混合专家 (MoE) 模型。该模型的目标是开源一个从头开始创建多模态原生模型的训练方法。Aria 对每个视觉和文本标记分别具有 39 亿和 35 亿个激活参数。文本由 MoE 解码器处理,视觉输入由轻量级视觉编码器处理。它分 4 个阶段进行训练:语言预训练、多模态预训练、多模态长上下文预训练和多模态后训练。

你可以在 Aria 组织下找到所有原始的 Aria 检查点。

单击右侧边栏中的 Aria 模型,了解更多关于如何将 Aria 应用于不同多模态任务的示例。

下面的示例演示了如何使用 PipelineAutoModel 类根据图像生成文本。

流水线
自动模型
import torch
from transformers import pipeline

pipeline = pipeline(
    "image-to-text",
    model="rhymes-ai/Aria",
    device=0,
    torch_dtype=torch.bfloat16
)
pipeline(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg",
    text="What is shown in this image?"
)

量化通过以较低精度表示权重来减少大型模型的内存负担。有关更多可用量化后端,请参阅量化概述。

下面的示例使用 torchao 将权重仅量化为 int4,并使用 rhymes-ai/Aria-sequential_mlp 检查点。该检查点将分组的 GEMM 替换为 torch.nn.Linear 层,以便于量化。

# pip install torchao
import torch
from transformers import TorchAoConfig, AutoModelForCausalLM, AutoProcessor

quantization_config = TorchAoConfig("int4_weight_only", group_size=128)
model = AutoModelForCausalLM.from_pretrained(
    "rhymes-ai/Aria-sequential_mlp",
    torch_dtype=torch.bfloat16,
    device_map="auto",
    quantization_config=quantization_config
)
processor = AutoProcessor.from_pretrained(
    "rhymes-ai/Aria-sequential_mlp",
)

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

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

output = model.generate(
    **inputs,
    max_new_tokens=15,
    stop_strings=["<|im_end|>"],
    tokenizer=processor.tokenizer,
    do_sample=True,
    temperature=0.9,
)
output_ids = output[0][inputs["input_ids"].shape[1]:]
response = processor.decode(output_ids, skip_special_tokens=True)
print(response)

AriaImageProcessor

class transformers.AriaImageProcessor

< >

( image_mean: typing.Optional[list[float]] = None image_std: typing.Optional[list[float]] = None max_image_size: int = 980 min_image_size: int = 336 split_resolutions: typing.Optional[list[tuple[int, int]]] = None split_image: typing.Optional[bool] = False do_convert_rgb: typing.Optional[bool] = True do_rescale: bool = True rescale_factor: typing.Union[int, float] = 0.00392156862745098 do_normalize: typing.Optional[bool] = True resample: Resampling = <Resampling.BICUBIC: 3> **kwargs )

参数

  • image_mean (list, 可选,默认为 [0.5, 0.5, 0.5]) — 用于归一化的均值。
  • image_std (list, 可选,默认为 [0.5, 0.5, 0.5]) — 用于归一化的标准差值。
  • max_image_size (int, 可选,默认为 980) — 最大图像尺寸。
  • min_image_size (int, 可选,默认为 336) — 最小图像尺寸。
  • split_resolutions (list, 可选,默认为以元组形式表示的最佳分辨率列表) — 用于分割图像的最佳分辨率。
  • split_image (bool, 可选,默认为 False) — 是否分割图像。
  • do_convert_rgb (bool, 可选,默认为 True) — 是否将图像转换为 RGB。
  • do_rescale (bool, 可选,默认为 True) — 是否通过指定的缩放因子 rescale_factor 重新缩放图像。可在 preprocess 方法中被 do_rescale 覆盖。
  • rescale_factor (intfloat, 可选,默认为 1/255) — 如果重新缩放图像,使用的缩放因子。可在 preprocess 方法中被 rescale_factor 覆盖。
  • do_normalize (bool, 可选,默认为 True) — 是否归一化图像。
  • resample (PILImageResampling, 可选,默认为 BICUBIC) — 如果调整图像大小,使用的重采样滤波器。

Aria 模型的视觉处理器,用于处理图像预处理。初始化 AriaImageProcessor。

get_image_patches

< >

( image: <built-in function array> grid_pinpoints: list patch_size: int resample: Resampling data_format: ChannelDimension input_data_format: ChannelDimension ) list[np.array]

参数

  • image (np.array) — 要处理的输入图像。
  • grid_pinpoints (list[tuple[int, int]]) — 一系列可能的分辨率,以元组形式表示。
  • patch_size (int) — 用于将图像分割成块的大小。
  • resample (PILImageResampling) — 如果调整图像大小,使用的重采样滤波器。
  • data_format (ChannelDimensionstr) — 输出图像的通道维度格式。
  • input_data_format (ChannelDimensionstr) — 输入图像的通道维度格式。

返回

list[np.array]

包含处理后图像块的 NumPy 数组列表。

通过将图像分割成块来处理具有可变分辨率的图像。

get_number_of_image_patches

< >

( height: int width: int images_kwargs = None ) int

参数

  • height (int) — 输入图像的高度。
  • width (int) — 输入图像的宽度。
  • images_kwargs (dict, 可选) — 用于覆盖图像处理器默认值的任何关键字参数。

返回

int

每张图像的块数。

一个实用工具,返回给定图像大小的图像块数。

pad

< >

( image: ndarray padding: typing.Union[int, tuple[int, int], collections.abc.Iterable[tuple[int, int]]] mode: PaddingMode = <PaddingMode.CONSTANT: 'constant'> constant_values: typing.Union[float, collections.abc.Iterable[float]] = 0.0 data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None ) np.ndarray

参数

  • image (np.ndarray) — 要填充的图像。
  • padding (inttuple[int, int]Iterable[tuple[int, int]]) — 应用于高度、宽度轴边缘的填充。可以是以下三种格式之一:
    • ((before_height, after_height), (before_width, after_width)) 每个轴的唯一填充宽度。
    • ((before, after),) 为高度和宽度产生相同的 before 和 after 填充。
    • (pad,) 或 int 是所有轴 before = after = pad 宽度的快捷方式。
  • mode (PaddingMode) — 要使用的填充模式。可以是以下之一:
    • "constant": 使用常量值填充。
    • "reflect": 使用向量在每个轴的第一个和最后一个值上镜像的反射进行填充。
    • "replicate": 使用数组边缘的最后一个值沿每个轴进行复制填充。
    • "symmetric": 使用向量沿数组边缘镜像的反射进行填充。
  • constant_values (floatIterable[float], 可选) — 如果 mode"constant",用于填充的值。
  • data_format (strChannelDimension, 可选) — 输出图像的通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。如果未设置,将使用与输入图像相同的格式。
  • input_data_format (strChannelDimension, 可选) — 输入图像的通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。如果未设置,将使用输入图像的推断格式。

返回

np.ndarray

填充后的图像。

使用指定的 `padding` 和 `mode` 对 `image` 进行填充。填充可以在 ( `height` , `width` ) 维度或 ( `num_patches` ) 维度进行。在第二种情况下,需要输入一个元组的可迭代对象。

preprocess

< >

( 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']]]] image_mean: typing.Union[float, list[float], NoneType] = None image_std: typing.Union[float, list[float], NoneType] = None max_image_size: typing.Optional[int] = None min_image_size: typing.Optional[int] = None split_image: typing.Optional[bool] = None do_convert_rgb: typing.Optional[bool] = None do_rescale: typing.Optional[bool] = None rescale_factor: typing.Optional[float] = None do_normalize: typing.Optional[bool] = None resample: Resampling = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = 'pt' data_format: typing.Optional[transformers.image_utils.ChannelDimension] = <ChannelDimension.FIRST: 'channels_first'> input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None ) BatchFeature

参数

  • images (ImageInput 或 ImageInput 列表) — 输入的图像或图像列表。
  • image_mean (list, 可选, 默认为 [0.5, 0.5, 0.5]) — 用于归一化的均值。
  • image_std (list, 可选, 默认为 [0.5, 0.5, 0.5]) — 用于归一化的标准差值。
  • max_image_size (int, 可选, 默认为 self.max_image_size (980)) — 最大图像尺寸。
  • min_image_size (int, 可选, 默认为 self.min_image_size (336)) — 最小图像尺寸。
  • split_image (bool, 可选, 默认为 self.split_image (False)) — 是否分割图像。
  • do_convert_rgb (bool, 可选, 默认为 self.do_convert_rgb (True)) — 是否将图像转换为RGB格式。
  • do_rescale (bool, 可选, 默认为 self.do_rescale) — 是否对图像进行缩放。
  • rescale_factor (float, 可选, 默认为 self.rescale_factor) — 如果 do_rescale 设置为 True,用于缩放图像的缩放因子。
  • do_normalize (bool, 可选, 默认为 self.do_normalize (True)) — 是否对图像进行归一化。
  • resample (PILImageResampling, 可选, 默认为 self.resample (BICUBIC)) — 如果需要调整图像大小,使用的重采样滤波器。
  • return_tensors (strTensorType, 可选, 默认为 “pt”) — 返回的张量类型。
  • data_format (strChannelDimension, 可选) — 输出图像的通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。如果未设置,将使用与输入图像相同的格式。
  • input_data_format (strChannelDimension, 可选) — 输入图像的通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。如果未设置,将使用推断出的输入图像格式。

返回

批次特征

包含以下内容的 BatchFeature 对象:

  • ‘pixel_values’: 处理后图像像素值的张量。
  • ‘pixel_mask’: 布尔像素掩码。此掩码是一个形状为 (max_image_size, max_image_size) 的二维张量,其中
    • True (1) 值表示属于原始调整大小后图像的像素。
    • False (0) 值表示属于填充部分的像素。此掩码有助于在后续处理步骤中区分实际图像内容和填充区域。
  • ‘num_crops’: 所有图像中的最大裁切数量。

处理一个图像列表。

AriaProcessor

class transformers.AriaProcessor

< >

( image_processor = None tokenizer: typing.Union[transformers.models.auto.tokenization_auto.AutoTokenizer, str] = None chat_template: typing.Optional[str] = None size_conversion: typing.Optional[dict[typing.Union[float, int], int]] = None )

参数

  • image_processor (AriaImageProcessor, 可选) — 用于图像预处理的 AriaImageProcessor。
  • tokenizer (PreTrainedTokenizerBase, 可选) — PreTrainedTokenizerBase 的一个实例。这应与模型的文本模型相对应。分词器是必需的输入。
  • chat_template (str, 可选) — 一个 Jinja 模板,用于将聊天中的消息列表转换为可分词的字符串。
  • size_conversion (Dict, 可选) — 一个指示图像尺寸转换的字典。

AriaProcessor 是 Aria 模型的处理器,它封装了 Aria 图像预处理器和 LLama 慢速分词器。

batch_decode

< >

( *args **kwargs )

此方法将其所有参数转发给 LlamaTokenizerFast 的 batch_decode()。请参阅该方法的文档字符串以获取更多信息。

decode

< >

( *args **kwargs )

此方法将其所有参数转发给 LlamaTokenizerFast 的 decode()。有关更多信息,请参阅此方法的文档字符串。

AriaTextConfig

class transformers.AriaTextConfig

< >

( vocab_size = 32000 hidden_size = 4096 intermediate_size: int = 4096 num_hidden_layers = 32 num_attention_heads = 32 num_key_value_heads = None hidden_act = 'silu' max_position_embeddings = 2048 initializer_range = 0.02 rms_norm_eps = 1e-06 use_cache = True pad_token_id = 2 bos_token_id = 1 eos_token_id = 2 pretraining_tp = 1 tie_word_embeddings = False rope_theta = 10000.0 rope_scaling = None attention_bias = False attention_dropout = 0.0 mlp_bias = False head_dim = None moe_num_experts: int = 8 moe_topk: int = 2 moe_num_shared_experts: int = 2 **kwargs )

参数

  • vocab_size (int, 可选, 默认为 32000) — LLaMA 模型的词汇表大小。定义了在调用 LlamaModel 时传入的 `inputs_ids` 可以表示的不同标记的数量。
  • hidden_size (int, 可选, 默认为 4096) — 隐藏表示的维度。
  • intermediate_size (int, 可选, 默认为 4096) — MLP 表示的大小。
  • num_hidden_layers (int, 可选, 默认为 32) — Transformer 解码器中的隐藏层数量。
  • num_attention_heads (int, 可选, 默认为 32) — Transformer 解码器中每个注意力层的注意力头数量。
  • num_key_value_heads (int, 可选) — 这是用于实现分组查询注意力(Grouped Query Attention)的键值头数量。如果 `num_key_value_heads=num_attention_heads`,模型将使用多头注意力(MHA);如果 `num_key_value_heads=1`,模型将使用多查询注意力(MQA);否则使用 GQA。将多头检查点转换为 GQA 检查点时,每个组的键和值头应通过对该组内所有原始头进行均值池化来构建。更多细节,请参阅这篇论文。如果未指定,将默认为 `num_attention_heads`。
  • hidden_act (strfunction, 可选, 默认为 "silu") — 解码器中的非线性激活函数(函数或字符串)。
  • max_position_embeddings (int, 可选, 默认为 2048) — 该模型可能使用的最大序列长度。Llama 1 支持最多 2048 个标记,Llama 2 支持最多 4096 个,CodeLlama 支持最多 16384 个。
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • rms_norm_eps (float, 可选, 默认为 1e-06) — rms 归一化层使用的 epsilon 值。
  • use_cache (bool, 可选, 默认为 True) — 模型是否应返回最后一个键/值注意力(并非所有模型都使用)。仅当 `config.is_decoder=True` 时相关。
  • pad_token_id (int, 可选, 默认为 2) — 填充标记 ID。
  • bos_token_id (int, 可选, 默认为 1) — 流开始标记 ID。
  • eos_token_id (int, 可选, 默认为 2) — 流结束标记 ID。
  • pretraining_tp (int, 可选, 默认为 1) — 实验性功能。预训练期间使用的张量并行等级。请参阅此文档以了解更多信息。此值对于确保预训练结果的精确可复现性是必需的。请参阅此问题
  • tie_word_embeddings (bool, 可选, 默认为 False) — 是否绑定词嵌入权重
  • rope_theta (float, 可选, 默认为 10000.0) — RoPE 嵌入的基础周期。
  • rope_scaling (Dict, 可选) — 包含 RoPE 嵌入缩放配置的字典。注意:如果你应用了新的 rope 类型并且希望模型能在更长的 `max_position_embeddings` 上工作,我们建议你相应地更新此值。预期内容:`rope_type` (str):要使用的 RoPE 的子变体。可以是 [‘default’, ‘linear’, ‘dynamic’, ‘yarn’, ‘longrope’, ‘llama3’] 之一,其中 ‘default’ 是原始的 RoPE 实现。`factor` (float, *可选*):用于除 ‘default’ 之外的所有 rope 类型。应用于 RoPE 嵌入的缩放因子。在大多数缩放类型中,`factor` 为 x 将使模型能够处理长度为 x * 原始最大预训练长度的序列。`original_max_position_embeddings` (int, *可选*):用于 ‘dynamic’、‘longrope’ 和 ‘llama3’。预训练期间使用的原始最大位置嵌入。`attention_factor` (float, *可选*):用于 ‘yarn’ 和 ‘longrope’。应用于注意力计算的缩放因子。如果未指定,它将默认为实现推荐的值,使用 `factor` 字段来推断建议值。`beta_fast` (float, *可选*):仅用于 ‘yarn’。用于设置线性斜坡函数中(仅)外推边界的参数。如果未指定,默认为 32。`beta_slow` (float, *可选*):仅用于 ‘yarn’。用于设置线性斜坡函数中(仅)内插边界的参数。如果未指定,默认为 1。`short_factor` (list[float], *可选*):仅用于 ‘longrope’。应用于短上下文(< `original_max_position_embeddings`)的缩放因子。必须是一个数字列表,其长度与隐藏大小除以注意力头数再除以 2 相同。`long_factor` (list[float], *可选*):仅用于 ‘longrope’。应用于长上下文(> `original_max_position_embeddings`)的缩放因子。必须是一个数字列表,其长度与隐藏大小除以注意力头数再除以 2 相同。`low_freq_factor` (float, *可选*):仅用于 ‘llama3’。应用于 RoPE 低频分量的缩放因子。`high_freq_factor` (float, *可选*):仅用于 ‘llama3’。应用于 RoPE 高频分量的缩放因子。
  • attention_bias (bool, 可选, 默认为 False) — 在自注意力期间是否在查询、键、值和输出投影层中使用偏置。
  • attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。
  • mlp_bias (bool, optional, 默认为 False) — 是否在 MLP 层的 up_proj、down_proj 和 gate_proj 层中使用偏置。
  • head_dim (int, optional) — 注意力头的维度。如果为 None,则默认为 hidden_size // num_heads
  • moe_num_experts (int, optional, 默认为 8) — MoE 层中的专家数量。
  • moe_topk (int, optional, 默认为 2) — 为每个词元(token)路由到的顶尖专家数量。
  • moe_num_shared_experts (int, optional, 默认为 2) — 共享专家的数量。

此类处理 Aria 模型文本组件的配置。使用默认值实例化配置将产生与 Aria rhymes-ai/Aria 架构模型类似的配置。此类扩展了 LlamaConfig,以包含特定于混合专家(Mixture of Experts, MoE)架构的附加参数。

AriaConfig

class transformers.AriaConfig

< >

( vision_config = None vision_feature_layer: int = -1 text_config: AriaTextConfig = None projector_patch_to_query_dict: typing.Optional[dict] = None image_token_index: int = 9 initializer_range: float = 0.02 **kwargs )

参数

  • vision_config (AriaVisionConfigdict, optional) — 视觉组件的配置。
  • vision_feature_layer (int, optional, 默认为 -1) — 用于选择视觉特征的层的索引。
  • text_config (AriaTextConfigdict, optional) — 文本组件的配置。
  • projector_patch_to_query_dict (dict, optional) — 图像块(patch)大小到查询维度的映射。
  • image_token_index (int, optional, 默认为 9) — 用于表示图像词元(token)的索引。
  • initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态分布初始化器的标准差。
  • model_type (str) — 模型类型,设置为 "aria"
  • image_token_index (int) — 用于表示图像词元(token)的索引。
  • projector_patch_to_query_dict (dict) — 图像块(patch)大小到查询维度的映射。
  • vision_config (AriaVisionConfig) — 视觉组件的配置。
  • text_config (AriaTextConfig) — 文本组件的配置。

此类处理 Aria 模型的视觉和文本组件的配置,以及用于图像词元处理和投影仪映射的附加参数。使用默认值实例化配置将产生与 Aria rhymes-ai/Aria 架构模型类似的配置。

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

AriaTextModel

class transformers.AriaTextModel

< >

( config: AriaTextConfig )

参数

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

基础的 Aria 文本模型,输出原始的隐藏状态,没有任何特定的头部。

此模型继承自 PreTrainedModel。请查看超类文档以了解该库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规 PyTorch 模块一样使用它,并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( 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[transformers.cache_utils.Cache] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None **flash_attn_kwargs: typing_extensions.Unpack[transformers.modeling_flash_attention_utils.FlashAttentionKwargs] ) transformers.modeling_outputs.BaseModelOutputWithPasttuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)optional) — 词汇表中输入序列词元(token)的索引。默认情况下将忽略填充。

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

    什么是输入 ID?

  • attention_mask (torch.Tensor,形状为 (batch_size, sequence_length)optional) — 用于避免对填充词元索引执行注意力计算的掩码。掩码值选自 [0, 1]

    • 1 表示词元未被掩码
    • 0 表示词元已被掩码

    什么是注意力掩码?

  • position_ids (torch.LongTensor,形状为 (batch_size, sequence_length)optional) — 每个输入序列词元在位置嵌入中的位置索引。选自范围 [0, config.n_positions - 1]

    什么是位置 ID?

  • past_key_values (~cache_utils.Cache, optional) — 预先计算的隐藏状态(自注意力和交叉注意力块中的键和值),可用于加速序列解码。这通常包括在解码的先前阶段,当 use_cache=Trueconfig.use_cache=True 时由模型返回的 past_key_values

    允许两种格式:

    • 一个 Cache 实例,请参阅我们的 KV 缓存指南
    • 长度为 config.n_layerstuple(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),而不是所有形状为 (batch_size, sequence_length)input_ids

  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size)optional) — 可选地,你可以选择直接传递嵌入表示,而不是传递 input_ids。如果你希望比模型内部的嵌入查找矩阵更能控制如何将 input_ids 索引转换为相关向量,这将非常有用。
  • use_cache (bool, optional) — 如果设置为 True,将返回 past_key_values 键值状态,并可用于加速解码(请参阅 past_key_values)。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • cache_position (torch.LongTensor,形状为 (sequence_length)optional) — 描述输入序列词元在序列中位置的索引。与 position_ids 不同,此张量不受填充影响。它用于在正确的位置更新缓存并推断完整的序列长度。

返回

transformers.modeling_outputs.BaseModelOutputWithPasttuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPast 或一个 `torch.FloatTensor` 元组(如果传递了 `return_dict=False` 或 `config.return_dict=False`),根据配置(AriaConfig)和输入包含各种元素。

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

    如果使用了 past_key_values,则只输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。

  • past_key_values (Cache, optional, 在传递 use_cache=Trueconfig.use_cache=True 时返回) — 这是一个 Cache 实例。有关更多详细信息,请参阅我们的 KV 缓存指南

    包含预先计算的隐藏状态(自注意力块中的键和值,如果 `config.is_encoder_decoder=True`,则还包括交叉注意力块中的键和值),可用于(参见 `past_key_values` 输入)加速序列解码。

  • hidden_states (tuple(torch.FloatTensor), optional, 在传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(如果模型有嵌入层,一个是嵌入层的输出,+ 每个层一个输出),形状为 (batch_size, sequence_length, hidden_size)

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor), optional, 在传递 output_attentions=Trueconfig.output_attentions=True 时返回) — `torch.FloatTensor` 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

AriaTextModel 的 forward 方法覆盖了 `__call__` 特殊方法。

虽然前向传播的配方需要在此函数内定义,但之后应调用 `Module` 实例而不是此函数,因为前者负责运行前后处理步骤,而后者会静默忽略它们。

AriaModel

class transformers.AriaModel

< >

( config: AriaConfig )

参数

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

Aria 模型由一个视觉主干网络和一个语言模型组成,不带语言建模头。

此模型继承自 PreTrainedModel。请查看超类文档以了解该库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规 PyTorch 模块一样使用它,并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( input_ids: LongTensor = None pixel_values: FloatTensor = None pixel_mask: 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 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 **kwargs: typing_extensions.Unpack[transformers.modeling_flash_attention_utils.FlashAttentionKwargs] ) transformers.models.aria.modeling_aria.AriaModelOutputWithPasttuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列词元(token)的索引。默认情况下将忽略填充。

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

    什么是输入 ID?

  • pixel_values (torch.FloatTensor,形状为 (batch_size, num_channels, image_size, image_size)) — 对应于输入图像的张量。像素值可以使用 {image_processor_class} 获取。有关详细信息,请参阅 {image_processor_class}.__call__{processor_class} 使用 {image_processor_class} 处理图像)。
  • pixel_mask (torch.LongTensor,形状为 (batch_size, height, width)) — 用于避免对填充像素值执行注意力计算的掩码。掩码值选自 [0, 1]

    • 1 表示像素是真实的(即未被掩码),
    • 0 表示像素是填充的(即已被掩码)。

    什么是注意力掩码?

  • attention_mask (torch.Tensor,形状为 (batch_size, sequence_length)optional) — 用于避免对填充词元索引执行注意力计算的掩码。掩码值选自 [0, 1]

    • 1 表示词元未被掩码
    • 0 表示词元已被掩码

    什么是注意力掩码?

  • position_ids (torch.LongTensor,形状为 (batch_size, sequence_length)optional) — 每个输入序列词元在位置嵌入中的位置索引。选自范围 [0, config.n_positions - 1]

    什么是位置 ID?

  • past_key_values (list[torch.FloatTensor], optional) — 预先计算的隐藏状态(自注意力和交叉注意力块中的键和值),可用于加速序列解码。这通常包括在解码的先前阶段,当 use_cache=Trueconfig.use_cache=True 时由模型返回的 past_key_values

    允许两种格式:

    • 一个 Cache 实例,请参阅我们的 KV 缓存指南
    • 长度为 config.n_layerstuple(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),而不是所有形状为 (batch_size, sequence_length)input_ids

  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size)optional) — 可选地,你可以选择直接传递嵌入表示,而不是传递 input_ids。如果你希望比模型内部的嵌入查找矩阵更能控制如何将 input_ids 索引转换为相关向量,这将非常有用。
  • use_cache (bool, optional) — 如果设置为 True,将返回 past_key_values 键值状态,并可用于加速解码(请参阅 past_key_values)。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通的元组。
  • cache_position (torch.LongTensor,形状为 (sequence_length)optional) — 描述输入序列词元在序列中位置的索引。与 position_ids 不同,此张量不受填充影响。它用于在正确的位置更新缓存并推断完整的序列长度。

返回

transformers.models.aria.modeling_aria.AriaModelOutputWithPasttuple(torch.FloatTensor)

一个 transformers.models.aria.modeling_aria.AriaModelOutputWithPast 或一个 `torch.FloatTensor` 元组(如果传递了 `return_dict=False` 或 `config.return_dict=False`),根据配置(AriaConfig)和输入包含各种元素。

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

  • past_key_values (tuple(tuple(torch.FloatTensor)), optional, 在传递 use_cache=Trueconfig.use_cache=True 时返回) — 长度为 config.n_layerstuple(tuple(torch.FloatTensor)),其中每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。

    包含预计算的隐藏状态(自注意力块中的键和值),可用于(参见 past_key_values 输入)加速顺序解码。

  • hidden_states (tuple[torch.FloatTensor, ...], optional, 在传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(如果模型有嵌入层,一个是嵌入层的输出,+ 每个层一个输出),形状为 (batch_size, sequence_length, hidden_size)

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple[torch.FloatTensor, ...], optional, 在传递 output_attentions=Trueconfig.output_attentions=True 时返回) — `torch.FloatTensor` 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

  • image_hidden_states (torch.FloatTensor, optional) — 大小为 (batch_size, num_images, sequence_length, hidden_size)torch.FloatTensor。由视觉编码器生成并在投影最后一个隐藏状态后得到的模型的 image_hidden_states。

AriaModel 的 forward 方法覆盖了 `__call__` 特殊方法。

虽然前向传播的配方需要在此函数内定义,但之后应调用 `Module` 实例而不是此函数,因为前者负责运行前后处理步骤,而后者会静默忽略它们。

get_image_features

< >

( pixel_values: FloatTensor pixel_mask: typing.Optional[torch.FloatTensor] = None vision_feature_layer: int = -1 ) image_features (torch.Tensor)

参数

  • pixel_values (torch.FloatTensor],形状为 (batch_size, channels, height, width)) — 对应于输入图像的张量。
  • pixel_mask (torch.FloatTensor], 可选) — 对应于输入图像掩码的张量。
  • vision_feature_layer (Union[int, list[int]], 可选) — 用于选择视觉特征的层的索引。如果提供了多个索引,则相应索引的视觉特征将被连接起来形成视觉特征。

返回

image_features (torch.Tensor)

形状为 (num_images, image_length, embed_dim) 的图像特征张量。

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

AriaTextForCausalLM

class transformers.AriaTextForCausalLM

< >

( config: AriaTextConfig )

参数

  • config (AriaTextConfig) — 模型配置类,包含模型的所有参数。使用配置文件进行初始化不会加载与模型相关的权重,只会加载配置。请查看 from_pretrained() 方法来加载模型权重。

用于因果语言建模的 Aria 模型。

此模型继承自 PreTrainedModel。请查看超类文档以了解该库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规 PyTorch 模块一样使用它,并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( 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[transformers.cache_utils.Cache] = None inputs_embeds: typing.Optional[torch.FloatTensor] = 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 cache_position: typing.Optional[torch.LongTensor] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 **kwargs: typing_extensions.Unpack[transformers.models.aria.modeling_aria.KwargsForCausalLM] ) transformers.modeling_outputs.CausalLMOutputWithPasttuple(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 (~cache_utils.Cache, 可选) — 预先计算的隐藏状态(自注意力和交叉注意力块中的键和值),可用于加速顺序解码。这通常包括在解码的前一阶段,当 use_cache=Trueconfig.use_cache=True 时,模型返回的 past_key_values

    允许两种格式:

    • Cache 实例,请参阅我们的 kv 缓存指南
    • 长度为 config.n_layerstuple(torch.FloatTensor) 元组,每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也称为旧版缓存格式。

    模型将输出与输入相同的缓存格式。如果没有传递 past_key_values,将返回旧版缓存格式。

    如果使用 past_key_values,用户可以选择只输入最后一个 input_ids(那些没有为其提供过去键值状态的标记),形状为 (batch_size, 1),而不是所有形状为 (batch_size, sequence_length)input_ids

  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您想比模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为相关向量,这将非常有用。
  • 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
  • cache_position (torch.LongTensor,形状为 (sequence_length), 可选) — 描绘输入序列标记在序列中位置的索引。与 position_ids 相反,此张量不受填充影响。它用于在正确的位置更新缓存并推断完整的序列长度。
  • logits_to_keep (Union[int, torch.Tensor], 默认为 0) — 如果是 int,则计算最后 logits_to_keep 个标记的 logits。如果为 0,则计算所有 input_ids 的 logits(特殊情况)。生成时只需要最后一个标记的 logits,仅为此标记计算可以节省内存,这对于长序列或大词汇表大小来说非常重要。如果是一个 torch.Tensor,必须是 1D 的,对应于在序列长度维度中要保留的索引。这在使用打包张量格式(批处理和序列长度的单个维度)时很有用。

返回

transformers.modeling_outputs.CausalLMOutputWithPasttuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutputWithPast 或一个 `torch.FloatTensor` 元组(如果传递了 `return_dict=False` 或当 `config.return_dict=False` 时),根据配置(AriaConfig)和输入,包含各种元素。

  • loss (torch.FloatTensor 形状为 (1,)可选,当提供 labels 时返回) — 语言建模损失(用于下一个 token 预测)。

  • logits (形状为 (batch_size, sequence_length, config.vocab_size)torch.FloatTensor) — 语言建模头部的预测分数(SoftMax 之前的每个词汇标记的分数)。

  • past_key_values (Cache, optional, 在传递 use_cache=Trueconfig.use_cache=True 时返回) — 这是一个 Cache 实例。有关更多详细信息,请参阅我们的 KV 缓存指南

    包含预计算的隐藏状态(自注意力块中的键和值),可用于(参见 past_key_values 输入)加速顺序解码。

  • hidden_states (tuple(torch.FloatTensor), optional, 在传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(如果模型有嵌入层,一个是嵌入层的输出,+ 每个层一个输出),形状为 (batch_size, sequence_length, hidden_size)

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor), optional, 在传递 output_attentions=Trueconfig.output_attentions=True 时返回) — `torch.FloatTensor` 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

AriaTextForCausalLM 的前向方法会覆盖 __call__ 特殊方法。

虽然前向传播的配方需要在此函数内定义,但之后应调用 `Module` 实例而不是此函数,因为前者负责运行前后处理步骤,而后者会静默忽略它们。

示例

>>> from transformers import AutoTokenizer, AriaTextForCausalLM

>>> model = AriaTextForCausalLM.from_pretrained("meta-aria_text/AriaText-2-7b-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("meta-aria_text/AriaText-2-7b-hf")

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

>>> # 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 conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."

AriaForConditionalGeneration

class transformers.AriaForConditionalGeneration

< >

( config: AriaConfig )

参数

  • config (AriaConfig) — 模型配置类,包含模型的所有参数。使用配置文件进行初始化不会加载与模型相关的权重,只会加载配置。请查看 from_pretrained() 方法来加载模型权重。

用于条件生成任务的 Aria 模型。

该模型结合了视觉塔、多模态投影器和语言模型,以执行涉及图像和文本输入的任务。

此模型继承自 PreTrainedModel。请查看超类文档以了解该库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规 PyTorch 模块一样使用它,并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( input_ids: LongTensor = None pixel_values: FloatTensor = None pixel_mask: 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 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 logits_to_keep: typing.Union[int, torch.Tensor] = 0 cache_position: typing.Optional[torch.LongTensor] = None **kwargs: typing_extensions.Unpack[transformers.models.aria.modeling_aria.KwargsForCausalLM] ) transformers.models.aria.modeling_aria.AriaCausalLMOutputWithPasttuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

  • pixel_values (torch.FloatTensor,形状为 (batch_size, num_channels, image_size, image_size)) — 对应于输入图像的张量。可以使用 {image_processor_class} 获取像素值。有关详细信息,请参阅 {image_processor_class}.__call__ ({processor_class} 使用 {image_processor_class} 处理图像)。
  • pixel_mask (torch.LongTensor,形状为 (batch_size, height, width)) — 用于避免对填充像素值执行注意力计算的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示像素是真实的 (即 未被掩码),
    • 0 表示像素是填充的 (即 被掩码)。

    什么是注意力掩码?

  • 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], 可选) — 预先计算的隐藏状态(自注意力和交叉注意力块中的键和值),可用于加速顺序解码。这通常包括在解码的前一阶段,当 use_cache=Trueconfig.use_cache=True 时,模型返回的 past_key_values

    允许两种格式:

    • Cache 实例,请参阅我们的 kv 缓存指南
    • 长度为 config.n_layerstuple(torch.FloatTensor) 元组,每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也称为旧版缓存格式。

    模型将输出与输入相同的缓存格式。如果没有传递 past_key_values,将返回旧版缓存格式。

    如果使用 past_key_values,用户可以选择只输入最后一个 input_ids(那些没有为其提供过去键值状态的标记),形状为 (batch_size, 1),而不是所有形状为 (batch_size, sequence_length)input_ids

  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您想比模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为相关向量,这将非常有用。
  • labels (torch.LongTensor,形状为 (batch_size, sequence_length), 可选) — 用于计算掩码语言建模损失的标签。索引应在 [0, ..., config.vocab_size]model.image_token_id 中(其中 model 是您的 AriaForConditionalGeneration 实例)。索引设置为 model.image_token_id 的标记将被忽略(掩码),损失仅对标签在 [0, ..., config.vocab_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 而不是一个普通的元组。
  • logits_to_keep (Union[int, torch.Tensor], 默认为 0) — 如果是 int,则计算最后 logits_to_keep 个标记的 logits。如果为 0,则计算所有 input_ids 的 logits(特殊情况)。生成时只需要最后一个标记的 logits,仅为此标记计算可以节省内存,这对于长序列或大词汇表大小来说非常重要。如果是一个 torch.Tensor,必须是 1D 的,对应于在序列长度维度中要保留的索引。这在使用打包张量格式(批处理和序列长度的单个维度)时很有用。
  • cache_position (torch.LongTensor,形状为 (sequence_length), 可选) — 描绘输入序列标记在序列中位置的索引。与 position_ids 相反,此张量不受填充影响。它用于在正确的位置更新缓存并推断完整的序列长度。

返回

transformers.models.aria.modeling_aria.AriaCausalLMOutputWithPasttuple(torch.FloatTensor)

一个 transformers.models.aria.modeling_aria.AriaCausalLMOutputWithPast 或一个 `torch.FloatTensor` 元组(如果传递了 `return_dict=False` 或当 `config.return_dict=False` 时),根据配置(AriaConfig)和输入,包含各种元素。

  • loss (torch.FloatTensor 形状为 (1,)可选,当提供 labels 时返回) — 语言建模损失(用于下一个 token 预测)。

  • logits (形状为 (batch_size, sequence_length, config.vocab_size)torch.FloatTensor) — 语言建模头部的预测分数(SoftMax 之前的每个词汇标记的分数)。

  • past_key_values (tuple(tuple(torch.FloatTensor)), optional, 在传递 use_cache=Trueconfig.use_cache=True 时返回) — 长度为 config.n_layerstuple(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=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组 (如果模型有嵌入层,则一个用于嵌入层的输出,+ 一个用于每个层的输出),形状为 (batch_size, sequence_length, hidden_size)

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple[torch.FloatTensor], 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 的元组 (每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

  • image_hidden_states (torch.FloatTensor, optional) — 大小为 (batch_size, num_images, sequence_length, hidden_size)torch.FloatTensor。由视觉编码器生成并在投影最后一个隐藏状态后得到的模型的 image_hidden_states。

AriaForConditionalGeneration 的前向方法会覆盖 __call__ 特殊方法。

虽然前向传播的配方需要在此函数内定义,但之后应调用 `Module` 实例而不是此函数,因为前者负责运行前后处理步骤,而后者会静默忽略它们。

示例

>>> import requests
>>> import torch
>>> from PIL import Image
>>> from io import BytesIO

>>> from transformers import AutoProcessor, AutoModel
>>> 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("Rhymes-AI/Aria")
>>> model = AutoModel.from_pretrained("Rhymes-AI/Aria", torch_dtype=torch.bfloat16, device_map="auto")

>>> # Create inputs
>>> messages = [
...     {
...         "role": "user",
...         "content": [
...             {"type": "image"},
...             {"type": "text", "text": "In this image, we can see the city of New York, and more specifically the Statue of Liberty."},
...             {"type": "image"},
...             {"type": "text", "text": "What can we see in this image?"},
...         ]
...     },
...     {
...         "role": "user",
...         "content": [
...             {"type": "image"},
...             {"type": "text", "text": "In which city is that bridge located?"},
...         ]
...     }
... ]

>>> prompts = [processor.apply_chat_template([message], add_generation_prompt=True) for message in messages]
>>> images = [[image1, image2], [image3]]
>>> inputs = processor(text=prompts, images=images, padding=True, return_tensors="pt").to(model.device)

>>> # Generate
>>> generated_ids = model.generate(**inputs, max_new_tokens=256)
>>> generated_texts = processor.batch_decode(generated_ids, skip_special_tokens=True)

>>> print(generated_texts[0])
Assistant: There are buildings, trees, lights, and water visible in this image.

>>> print(generated_texts[1])
Assistant: The bridge is in San Francisco.
< > 在 GitHub 上更新