Transformers 文档

Chameleon

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

Chameleon

PyTorch FlashAttention SDPA

概述

Chameleon 模型由 META AI Chameleon 团队在 Chameleon: Mixed-Modal Early-Fusion Foundation Models 中提出。Chameleon 是一种视觉-语言模型,它使用向量量化对图像进行标记化,从而使模型能够生成多模态输出。该模型接收图像和文本作为输入,包括交错格式,并生成文本响应。图像生成模块尚未发布。

论文摘要如下:

我们推出了 Chameleon,这是一个基于早期融合令牌的混合模态模型家族,能够理解和生成任意序列的图像和文本。我们概述了一种从头开始的稳定训练方法、一种对齐方案以及一种为早期融合、基于令牌、混合模态设置量身定制的架构参数化。这些模型在一系列综合任务中进行了评估,包括视觉问答、图像字幕、文本生成、图像生成和长形式混合模态生成。Chameleon 展示了广泛而通用的能力,包括在图像字幕任务中达到最先进的性能,在纯文本任务中优于 Llama-2,同时与 Mixtral 8x7B 和 Gemini-Pro 等模型具有竞争力,并在单个模型中执行非平凡的图像生成。根据对新的长形式混合模态生成评估(其中提示或输出包含图像和文本的混合序列)的人工判断,它还匹配或超过了包括 Gemini Pro 和 GPT-4V 在内的更大模型的性能。Chameleon 标志着统一建模完整多模态文档的重大进步。

drawing Chameleon 包含一个向量量化器模块,用于将图像转换为离散令牌。这还允许使用自回归转换器生成图像。摘自原始论文。

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

使用技巧

  • 我们建议用户在计算批处理生成时使用 padding_side="left",因为它能带来更准确的结果。只需确保在生成前将 processor.tokenizer.padding_side = "left" 设置好。

  • 请注意,Chameleon 经过安全对齐调整。如果模型拒绝回答,请考虑提出更具体的问题,而不是开放式问题。

  • Chameleon 以聊天格式生成,这意味着生成的文本将始终是“助手的回答”。您可以通过在调用处理器时传递 return_for_text_completion=True 来启用文本补全生成。

[!NOTE] Transformers 中的 Chameleon 实现使用特殊的图像标记来指示何处合并图像嵌入。对于特殊图像标记,我们没有添加新的,而是使用了保留标记之一:<reserved08707>。您必须在图像应嵌入的位置将 <image> 添加到您的提示中以实现正确生成。

使用示例

单图像推理

Chameleon 是一个门控模型,因此请确保使用令牌访问并登录 Hugging Face Hub。以下是半精度 (torch.bfloat16) 加载模型并执行推理的方法:

from transformers import ChameleonProcessor, ChameleonForConditionalGeneration
import torch
from PIL import Image
import requests

processor = ChameleonProcessor.from_pretrained("facebook/chameleon-7b")
model = ChameleonForConditionalGeneration.from_pretrained("facebook/chameleon-7b", torch_dtype=torch.bfloat16, device_map="cuda")

# prepare image and text prompt
url = 'http://images.cocodataset.org/val2017/000000039769.jpg'
image = Image.open(requests.get(url, stream=True).raw)
prompt = "What do you see in this image?<image>"

inputs = processor(images=image, text=prompt, return_tensors="pt").to(model.device, dtype=torch.bfloat16)

# autoregressively complete prompt
output = model.generate(**inputs, max_new_tokens=50)
print(processor.decode(output[0], skip_special_tokens=True))

多图像推理

Chameleon 可以使用多幅图像作为输入进行推理,其中图像可以属于相同的提示或不同的提示(在批量推理中)。以下是实现方法:

from transformers import ChameleonProcessor, ChameleonForConditionalGeneration
import torch
from PIL import Image
import requests

processor = ChameleonProcessor.from_pretrained("facebook/chameleon-7b")

model = ChameleonForConditionalGeneration.from_pretrained("facebook/chameleon-7b", torch_dtype=torch.bfloat16, device_map="cuda")

# Get three different images
url = "https://www.ilankelman.org/stopsigns/australia.jpg"
image_stop = Image.open(requests.get(url, stream=True).raw)

url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image_cats = Image.open(requests.get(url, stream=True).raw)

url = "https://huggingface.co/microsoft/kosmos-2-patch14-224/resolve/main/snowman.jpg"
image_snowman = Image.open(requests.get(url, stream=True).raw)

# Prepare a batched prompt, where the first one is a multi-image prompt and the second is not
prompts = [
    "What do these images have in common?<image><image>",
    "<image>What is shown in this image?"
]

# We can simply feed images in the order they have to be used in the text prompt
# Each "<image>" token uses one image leaving the next for the subsequent "<image>" tokens
inputs = processor(images=[image_stop, image_cats, image_snowman], text=prompts, padding=True, return_tensors="pt").to(device="cuda", dtype=torch.bfloat16)

# Generate
generate_ids = model.generate(**inputs, max_new_tokens=50)
processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)

模型优化

使用 Bitsandbytes 进行量化

模型可以以 8 位或 4 位加载,这大大减少了内存需求,同时保持了原始模型的性能。首先,确保安装 bitsandbytes,pip install bitsandbytes,并确保可以访问库支持的 GPU/加速器。

bitsandbytes 正在重构以支持 CUDA 以外的多个后端。目前,ROCm (AMD GPU) 和 Intel CPU 实现已成熟,Intel XPU 正在进行中,Apple Silicon 支持预计将在第四季度/第一季度实现。有关安装说明和最新的后端更新,请访问此链接

我们重视您的反馈,以帮助在完整发布之前发现错误!请查看 这些文档 获取更多详细信息和反馈链接。

只需将上面的代码片段更改为

from transformers import ChameleonForConditionalGeneration, BitsAndBytesConfig

# specify how to quantize the model
quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
)

model = ChameleonForConditionalGeneration.from_pretrained("facebook/chameleon-7b", quantization_config=quantization_config, device_map="cuda")

使用 Flash-Attention 2 和 SDPA 进一步加速生成

模型支持 Flash-Attention 2 和 PyTorch 的 torch.nn.functional.scaled_dot_product_attention,可以启用它们进行优化。加载模型时,SDPA 是默认选项。如果要切换到 Flash Attention 2,首先请确保安装 flash-attn。有关该软件包的安装,请参阅原始存储库。只需将上述代码片段更改为:

from transformers import ChameleonForConditionalGeneration

model_id = "facebook/chameleon-7b"
model = ChameleonForConditionalGeneration.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    attn_implementation="flash_attention_2"
).to(0)

ChameleonConfig

class transformers.ChameleonConfig

< >

( vocab_size = 65536 hidden_size = 4096 intermediate_size = 11008 num_hidden_layers = 32 num_attention_heads = 32 num_key_value_heads = 32 hidden_act = 'silu' max_position_embeddings = 4096 initializer_range = 0.02 rms_norm_eps = 1e-05 use_cache = True pad_token_id = None bos_token_id = 1 eos_token_id = 2 tie_word_embeddings = False rope_theta = 10000.0 rope_scaling = None attention_bias = False attention_dropout = 0.0 model_parallel_size = 1 swin_norm = False vq_config = None vocabulary_map = None mlp_bias = False **kwargs )

参数

  • vocab_size (int, optional, 默认为 65536) — Chameleon 模型的词汇表大小。定义了调用 ChameleonModel 时传递的 inputs_ids 可以表示的不同令牌的数量;这包括文本和图像令牌。
  • hidden_size (int, optional, 默认为 4096) — 隐藏表示的维度。
  • intermediate_size (int, optional, 默认为 11008) — MLP 表示的维度。
  • num_hidden_layers (int, optional, 默认为 32) — Transformer 解码器中的隐藏层数量。
  • num_attention_heads (int, optional, 默认为 32) — Transformer 解码器中每个注意力层的注意力头数。
  • num_key_value_heads (int, optional, 默认为 32) — 用于实现分组查询注意力的键值头数。如果 num_key_value_heads=num_attention_heads,模型将使用多头注意力 (MHA),如果 num_key_value_heads=1,模型将使用多查询注意力 (MQA),否则使用 GQA。将多头检查点转换为 GQA 检查点时,每个分组键和值头应通过对其组内的所有原始头进行均值池化来构建。有关更多详细信息,请查看此论文。如果未指定,将默认为 num_attention_heads
  • hidden_act (strfunction, optional, 默认为 "silu") — 解码器中的非线性激活函数(函数或字符串)。
  • max_position_embeddings (int, optional, 默认为 4096) — 此模型可能使用的最大序列长度。Chameleon 支持多达 4096 个令牌。
  • initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  • rms_norm_eps (float, optional, 默认为 1e-05) — rms 归一化层使用的 epsilon。
  • use_cache (bool, optional, 默认为 True) — 模型是否应返回最后一个键/值注意力(并非所有模型都使用)。仅当 config.is_decoder=True 时相关。
  • pad_token_id (int, optional) — 填充令牌 ID。
  • bos_token_id (int, optional, 默认为 1) — 流开始令牌 ID。
  • eos_token_id (int, optional, 默认为 2) — 流结束令牌 ID。
  • tie_word_embeddings (bool, optional, 默认为 False) — 是否绑定词嵌入。
  • rope_theta (float, optional, 默认为 10000.0) — RoPE 嵌入的基期。
  • rope_scaling (Dict, optional) — 包含 RoPE 嵌入缩放配置的字典。目前支持两种缩放策略:线性和动态。它们的缩放因子必须是大于 1 的浮点数。预期格式为 {"type": 策略名称, "factor": 缩放因子}。使用此标志时,请勿将 max_position_embeddings 更新为预期的新最大值。有关这些缩放策略如何表现的更多信息,请参阅以下讨论串:https://www.reddit.com/r/Localchameleon/comments/14mrgpr/dynamically_scaled_rope_further_increases/。这是一个实验性功能,在未来版本中可能会有破坏性的 API 更改。
  • attention_bias (bool, 默认为 False, optional, 默认为 False) — 在自注意力过程中是否在查询、键、值和输出投影层中使用偏差。
  • attention_dropout (float, optional, 默认为 0.0) — 注意力概率的 dropout 比率。
  • model_parallel_size (int, optional, 默认为 1) — 训练模型时使用的分片数量。这将在 qk 层归一化中使用,因为原始 Chameleon 推理在这些层中没有进行归约,并且每个排名都有其自己的偏差。
  • swin_norm (bool, optional, 默认为 False) — 使用 Swin Transformer 归一化。
  • vq_config (dict, optional) — 包含 VQ-VAE 模型配置的 ChameleonVQConfig 实例。
  • vocabulary_map (dict, optional) — 包含来自分词器的词汇表映射的字典。用于从图像输入中获取令牌。
  • mlp_bias (bool, optional, 默认为 False) — 在 MLP 层中的 up_proj、down_proj 和 gate_proj 层中是否使用偏差。

这是用于存储 ChameleonModel 配置的配置类。它用于根据指定参数实例化 Chameleon 模型,定义模型架构。使用默认值实例化配置将生成与 meta/chameleon-7B 类似的配置。

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

>>> from transformers import ChameleonModel, ChameleonConfig

>>> # Initializing a chameleon chameleon-7b style configuration
>>> configuration = ChameleonConfig()

>>> # Initializing a model from the chameleon-7b style configuration
>>> model = ChameleonModel(configuration)

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

ChameleonVQVAEConfig

class transformers.ChameleonVQVAEConfig

< >

( embed_dim: int = 256 num_embeddings: int = 8192 double_latent: bool = False latent_channels: int = 256 resolution: int = 512 in_channels: int = 3 base_channels: int = 128 channel_multiplier: list = [1, 1, 2, 2, 4] num_res_blocks: int = 2 attn_resolutions: typing.Optional[list[int]] = None dropout: float = 0.0 attn_type: str = 'vanilla' initializer_range = 0.02 **kwargs )

参数

  • embed_dim (int, optional, 默认为 256) — 每个嵌入向量的维度。
  • num_embeddings (int, optional, 默认为 8192) — 码本嵌入的数量。
  • double_latent (bool, optional, 默认为 False) — 是否使用双 z 通道。
  • latent_channels (int, 可选, 默认为 256) — 潜在空间的通道数。
  • resolution (int, 可选, 默认为 512) — 输入图像的分辨率。
  • in_channels (int, 可选, 默认为 3) — 输入通道数。
  • base_channels (int, 可选, 默认为 128) — 基本通道数。
  • channel_multiplier (list[int], 可选, 默认为 [1, 1, 2, 2, 4]) — 每个分辨率的通道乘数。
  • num_res_blocks (int, 可选, 默认为 2) — 残差块的数量。
  • attn_resolutions (list[int], 可选) — 应用注意力机制的分辨率。
  • dropout (float, 可选, 默认为 0.0) — Dropout 比率。
  • attn_type (str, 可选, 默认为 "vanilla") — VQ-GAN 编码器中使用的注意力类型。可以是 "vanilla" 或 None。
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态分布初始化器的标准差。

这是一个配置类,用于存储 ChameleonVQModel 的配置。它用于根据指定参数实例化 ChameleonVQModel,从而定义模型架构。配置对象继承自 PretrainedConfig,可用于控制模型输出。有关更多信息,请参阅 PretrainedConfig 的文档。使用默认值实例化配置将产生类似于 meta/chameleon-7B 的 VQModel 配置。

ChameleonProcessor

class transformers.ChameleonProcessor

< >

( image_processor tokenizer image_seq_length: int = 1024 image_token: str = '<image>' )

参数

  • image_processor (ChameleonImageProcessor) — 图像处理器是必需输入。
  • tokenizer (LlamaTokenizerFast) — 分词器是必需输入。
  • image_seq_length (int, 可选, 默认为 1024) — 一个图像嵌入的序列长度。
  • image_token (str, 可选, 默认为 "<image>") — 用于在文本中指示图像的特殊标记。

构建一个 Chameleon 处理器,它将 Chameleon 图像处理器和 Chameleon 分词器封装到一个单独的处理器中。

ChameleonProcessor 提供 ChameleonImageProcessorLlamaTokenizerFast 的所有功能。有关更多信息,请参阅 __call__()decode()

batch_decode

< >

( *args **kwargs )

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

decode

< >

( *args **kwargs )

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

ChameleonImageProcessor

class transformers.ChameleonImageProcessor

< >

( do_resize: bool = True size: typing.Optional[dict[str, int]] = None resample: Resampling = 1 do_center_crop: bool = True crop_size: typing.Optional[dict[str, int]] = None do_rescale: bool = True rescale_factor: typing.Union[int, float] = 0.0078 do_normalize: bool = True image_mean: typing.Union[float, list[float], NoneType] = None image_std: typing.Union[float, list[float], NoneType] = None do_convert_rgb: bool = True **kwargs )

参数

  • do_resize (bool, 可选, 默认为 True) — 是否将图像的 (高度, 宽度) 尺寸调整为指定的 size。可以通过 preprocess 方法中的 do_resize 覆盖。
  • size (dict[str, int] 可选, 默认为 {"shortest_edge" -- 512}): 调整大小后的图像尺寸。图像的最短边调整为 size["shortest_edge"],最长边调整以保持输入长宽比。可以通过 preprocess 方法中的 size 覆盖。
  • resample (PILImageResampling, 可选, 默认为 1) — 如果调整图像大小,使用的重采样过滤器。可以通过 preprocess 方法中的 resample 覆盖。
  • do_center_crop (bool, 可选, 默认为 True) — 是否将图像中心裁剪到指定的 crop_size。可以通过 preprocess 方法中的 do_center_crop 覆盖。
  • crop_size (dict[str, int] 可选, 默认为 {“height” — 512, “width”: 512}): 应用 center_crop 后输出图像的尺寸。可以通过 preprocess 方法中的 crop_size 覆盖。
  • do_rescale (bool, 可选, 默认为 True) — 是否按指定的比例 rescale_factor 重新缩放图像。可以通过 preprocess 方法中的 do_rescale 覆盖。
  • rescale_factor (intfloat, 可选, 默认为 0.0078) — 如果重新缩放图像,使用的缩放因子。可以通过 preprocess 方法中的 rescale_factor 覆盖。
  • do_normalize (bool, 可选, 默认为 True) — 是否对图像进行归一化。可以通过 preprocess 方法中的 do_normalize 覆盖。
  • image_mean (floatlist[float], 可选, 默认为 [1.0, 1.0, 1.0]) — 如果对图像进行归一化,使用的均值。这是一个浮点数或浮点数列表,其长度与图像中的通道数相同。可以通过 preprocess 方法中的 image_mean 参数覆盖。
  • image_std (floatlist[float], 可选, 默认为 [1.0, 1.0, 1.0]) — 如果对图像进行归一化,使用的标准差。这是一个浮点数或浮点数列表,其长度与图像中的通道数相同。可以通过 preprocess 方法中的 image_std 参数覆盖。
  • do_convert_rgb (bool, 可选, 默认为 True) — 是否将图像转换为 RGB。

构建一个 Chameleon 图像处理器。

preprocess

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] do_resize: typing.Optional[bool] = None size: typing.Optional[dict[str, int]] = None resample: Resampling = None do_center_crop: typing.Optional[bool] = None crop_size: typing.Optional[int] = None do_rescale: typing.Optional[bool] = None rescale_factor: typing.Optional[float] = None do_normalize: typing.Optional[bool] = None image_mean: typing.Union[float, list[float], NoneType] = None image_std: typing.Union[float, list[float], NoneType] = None do_convert_rgb: typing.Optional[bool] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None data_format: typing.Optional[transformers.image_utils.ChannelDimension] = <ChannelDimension.FIRST: 'channels_first'> input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None )

参数

  • images (ImageInput) — 要预处理的图像。期望单个或批处理图像,像素值范围从 0 到 255。如果传入的图像像素值在 0 到 1 之间,请设置 do_rescale=False
  • do_resize (bool, 可选, 默认为 self.do_resize) — 是否调整图像大小。
  • size (dict[str, int], 可选, 默认为 self.size) — 调整大小后的图像尺寸。图像的最短边调整为 size["shortest_edge"],最长边调整以保持输入长宽比。
  • resample (int, 可选, 默认为 self.resample) — 如果调整图像大小,使用的重采样过滤器。可以是枚举 PILImageResampling 之一。仅在 do_resize 设置为 True 时有效。
  • do_center_crop (bool, 可选, 默认为 self.do_center_crop) — 是否对图像进行中心裁剪。
  • crop_size (dict[str, int], 可选, 默认为 self.crop_size) — 中心裁剪的尺寸。仅在 do_center_crop 设置为 True 时有效。
  • do_rescale (bool, 可选, 默认为 self.do_rescale) — 是否重新缩放图像。
  • rescale_factor (float, 可选, 默认为 self.rescale_factor) — 如果 do_rescale 设置为 True,用于重新缩放图像的缩放因子。
  • do_normalize (bool, 可选, 默认为 self.do_normalize) — 是否对图像进行归一化。
  • image_mean (floatlist[float], 可选, 默认为 self.image_mean) — 用于归一化的图像均值。仅在 do_normalize 设置为 True 时有效。
  • image_std (floatlist[float], 可选, 默认为 self.image_std) — 用于归一化的图像标准差。仅在 do_normalize 设置为 True 时有效。
  • do_convert_rgb (bool, 可选, 默认为 self.do_convert_rgb) — 是否将图像转换为 RGB。
  • return_tensors (strTensorType, 可选) — 要返回的张量类型。可以是以下之一:
    • 未设置:返回 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 (ChannelDimensionstr, 可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:图像为 (num_channels, height, width) 格式。
    • "channels_last"ChannelDimension.LAST:图像为 (height, width, num_channels) 格式。
    • 未设置:使用输入图像的通道维度格式。
  • input_data_format (ChannelDimensionstr, 可选) — 输入图像的通道维度格式。如果未设置,通道维度格式将从输入图像推断。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:图像为 (num_channels, height, width) 格式。
    • "channels_last"ChannelDimension.LAST:图像为 (height, width, num_channels) 格式。
    • "none"ChannelDimension.NONE:图像为 (height, width) 格式。

预处理一张或一批图像。

ChameleonVQVAE

class transformers.ChameleonVQVAE

< >

( config: ChameleonVQVAEConfig )

参数

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

Chameleon 中用于将图像编码/解码为离散 token 的 VQ-VAE 模型。此模型遵循 Oran Gafni, Adam Polyak, Oron Ashual, Shelly Sheynin, Devi Parikh, and Yaniv Taigman 的论文“Make-a-scene: Scene-based text-to-image generation with human priors”。

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

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

_forward_unimplemented

< >

( *input: typing.Any )

定义每次调用时执行的计算。

应由所有子类覆盖。

尽管前向传播的配方需要在该函数中定义,但之后应该调用 Module 实例而不是它,因为前者负责运行注册的钩子,而后者则默默地忽略它们。

ChameleonModel

class transformers.ChameleonModel

< >

( config: ChameleonConfig )

参数

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

原始的 Chameleon 模型,不带任何特定头部,直接输出原始隐藏状态。

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

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = 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 return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None **kwargs: typing_extensions.Unpack[transformers.modeling_flash_attention_utils.FlashAttentionKwargs] ) transformers.modeling_outputs.BaseModelOutputWithPasttuple(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} 处理图像)。
  • 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可选) — 预计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。这通常包括模型在解码前期返回的 past_key_values,当 use_cache=Trueconfig.use_cache=True 时。

    允许两种格式:

    • 一个 Cache 实例,请参阅我们的 kv cache 指南
    • 一个长度为 config.n_layerstuple(torch.FloatTensor) 元组,每个元组包含 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 索引转换为关联向量拥有比模型内部嵌入查找矩阵更多的控制权,这将很有用。
  • 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 (torch.LongTensor,形状为 (sequence_length)可选) — 描述输入序列标记在序列中位置的索引。与 position_ids 相反,此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。

返回

transformers.modeling_outputs.BaseModelOutputWithPasttuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPast 或一个 torch.FloatTensor 元组(如果传入 return_dict=False 或当 config.return_dict=False 时),包含根据配置 (ChameleonConfig) 和输入的不同元素。

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

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

  • past_key_values (Cache, 可选,当传入 use_cache=True 或当 config.use_cache=True 时返回) — 它是一个 Cache 实例。有关更多详细信息,请参阅我们的 kv cache 指南

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

  • hidden_states (tuple(torch.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 后的注意力权重,用于计算自注意力头中的加权平均值。

ChameleonModel 的 forward 方法,重写了 __call__ 特殊方法。

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

ChameleonForConditionalGeneration

transformers.ChameleonForConditionalGeneration

< >

( config )

参数

Chameleon 模型,顶部带有一个用于输出下一个标记预测的 logits 的头部。

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

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = 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 **kwargs: typing_extensions.Unpack[transformers.models.chameleon.modeling_chameleon.KwargsForCausalLM] ) transformers.modeling_outputs.CausalLMOutputWithPasttuple(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} 处理图像)。
  • 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可选) — 预计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。这通常包括模型在解码前期返回的 past_key_values,当 use_cache=Trueconfig.use_cache=True 时。

    允许两种格式:

    • 一个 Cache 实例,请参阅我们的 kv cache 指南
    • 一个长度为 config.n_layerstuple(torch.FloatTensor) 元组,每个元组包含 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 索引转换为关联向量拥有比模型内部嵌入查找矩阵更多的控制权,这将很有用。
  • 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 相反,此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。

返回

transformers.modeling_outputs.CausalLMOutputWithPasttuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutputWithPast 或一个 torch.FloatTensor 元组(如果传入 return_dict=False 或当 config.return_dict=False 时),包含根据配置 (ChameleonConfig) 和输入的不同元素。

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

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

  • past_key_values (Cache, 可选,当传入 use_cache=True 或当 config.use_cache=True 时返回) — 它是一个 Cache 实例。有关更多详细信息,请参阅我们的 kv cache 指南

    包含预计算的隐藏状态(自注意力块中的键和值),可用于(参见 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 后的注意力权重,用于计算自注意力头中的加权平均值。

ChameleonForConditionalGeneration 的 forward 方法,重写了 __call__ 特殊方法。

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

示例

>>> from transformers import ChameleonProcessor, ChameleonForConditionalGeneration
>>> import torch
>>> import requests
>>> from PIL import Image

>>> model = ChameleonForConditionalGeneration.from_pretrained("facebook/chameleon-7b", torch_dtype=torch.bfloat16)
>>> processor = ChameleonProcessor.from_pretrained("facebook/chameleon-7b")

>>> prompt = "I used to know a lot about constellations when I was younger, but as I grew older, I forgot most of what I knew. These are the only two constellations that I really remember now.<image><image>I would like for you to tell me about 3 more constellations and give me a little bit of history about the constellation."
>>> image = Image.open(requests.get("https://nineplanets.org/wp-content/uploads/2020/12/the-big-dipper-1.jpg", stream=True).raw)
>>> image_2 = Image.open(requests.get("https://www.kxan.com/wp-content/uploads/sites/40/2020/10/ORION.jpg", stream=True).raw)

>>> inputs = processor(images=[image, image_2], text=prompt, return_tensors="pt").to(model.device, torch.bfloat16)

>>> generated_ids = model.generate(**inputs, max_new_tokens=100, do_sample=False)
>>> processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
< > 在 GitHub 上更新