Hugging Face 的标志

Transformers 文档

Fuyu

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

Fuyu

PyTorch

概述

Fuyu 模型由 ADEPT 创建，作者为 Rohan Bavishi、Erich Elsen、Curtis Hawthorne、Maxwell Nye、Augustus Odena、Arushi Somani、Sağnak Taşırlar。

作者介绍了 Fuyu-8B，这是一个仅解码器的多模态模型，基于经典的 transformers 架构，具有查询和键归一化。添加了一个线性编码器，用于从图像输入创建多模态嵌入。

通过将图像 tokens 视为文本 tokens 并使用特殊的图像换行符，模型知道图像行何时结束。图像位置嵌入被移除。这避免了针对各种图像分辨率进行不同训练阶段的需求。Fuyu-8B 拥有 80 亿参数，并根据 CC-BY-NC 许可，因其处理文本和图像的能力、16K 的惊人上下文大小以及整体性能而引人注目。

Fuyu 模型使用 bfloat16 训练，但原始推理使用 float16。Hub 上上传的 checkpoints 使用 torch_dtype = 'float16'，AutoModel API 将使用它将 checkpoints 从 torch.float32 转换为 torch.float16。

在线权重的 dtype 大多无关紧要，除非您在使用 model = AutoModelForCausalLM.from_pretrained("path", torch_dtype = "auto") 初始化模型时使用 torch_dtype="auto"。原因是模型将首先被下载（使用在线 checkpoints 的 dtype），然后它将被转换为 torch 的默认 dtype（变为 torch.float32）。用户应指定他们想要的 torch_dtype，如果他们不指定，则默认为 torch.float32。

不建议在 float16 中微调模型，已知会产生 nan，因此应在 bfloat16 中微调模型。

提示

  • 要转换模型，您需要使用 git clone https://github.com/persimmon-ai-labs/adept-inference 克隆原始存储库，然后获取 checkpoints
git clone https://github.com/persimmon-ai-labs/adept-inference
wget path/to/fuyu-8b-model-weights.tar
tar -xvf fuyu-8b-model-weights.tar
python src/transformers/models/fuyu/convert_fuyu_weights_to_hf.py  --input_dir /path/to/downloaded/fuyu/weights/ --output_dir /output/path \
    --pt_model_path /path/to/fuyu_8b_release/iter_0001251/mp_rank_00/model_optim_rng.pt
    --ada_lib_path /path/to/adept-inference

对于聊天模型

wget https://axtkn4xl5cip.objectstorage.us-phoenix-1.oci.customer-oci.com/n/axtkn4xl5cip/b/adept-public-data/o/8b_chat_model_release.tar
tar -xvf 8b_base_model_release.tar

然后，可以通过以下方式加载模型

from transformers import FuyuConfig, FuyuForCausalLM
model_config = FuyuConfig()
model = FuyuForCausalLM(model_config).from_pretrained('/output/path')

输入需要通过特定的 Processor 传递才能具有正确的格式。一个 processor 需要一个 image_processor 和一个 tokenizer。因此，可以通过以下方式加载输入

from PIL import Image
from transformers import AutoTokenizer
from transformers.models.fuyu.processing_fuyu import FuyuProcessor
from transformers.models.fuyu.image_processing_fuyu import FuyuImageProcessor


tokenizer = AutoTokenizer.from_pretrained('adept-hf-collab/fuyu-8b')
image_processor = FuyuImageProcessor()


processor = FuyuProcessor(image_processor=image_processor, tokenizer=tokenizer)
text_prompt = "Generate a coco-style caption.\\n"

bus_image_url = "https://huggingface.co/datasets/hf-internal-testing/fixtures-captioning/resolve/main/bus.png"
bus_image_pil = Image.open(io.BytesIO(requests.get(bus_image_url).content))
inputs_to_model = processor(images=bus_image_pil, text=text_prompt)

此模型由 Molbap 贡献。原始代码可以在这里找到。

  • Fuyu 使用基于 sentencepiece 的分词器，以及 Unigram 模型。它支持字节回退（bytefallback），该功能仅在快速分词器的 tokenizers==0.14.0 版本中可用。LlamaTokenizer 被用作 sentencepiece 的标准封装器。

  • 作者建议使用以下提示（prompt）进行图像描述生成：f"Generate a coco-style caption.\\n"

FuyuConfig

class transformers.FuyuConfig

< >

( vocab_size = 262144 hidden_size = 4096 intermediate_size = 16384 num_hidden_layers = 36 num_attention_heads = 64 hidden_act = 'relu2' max_position_embeddings = 16384 image_size = 300 patch_size = 30 num_channels = 3 initializer_range = 0.02 layer_norm_eps = 1e-05 use_cache = True tie_word_embeddings = False rope_theta = 25000.0 rope_scaling = None qk_layernorm = True hidden_dropout = 0.0 attention_dropout = 0.0 partial_rotary_factor = 0.5 pad_token_id = None bos_token_id = 1 eos_token_id = 2 text_config = None **kwargs )

参数

  • vocab_size (int, 可选, 默认为 262144) — Fuyu 模型的词汇表大小。定义了在调用 FuyuForCausalLM 时，通过 inputs_ids 能够表示的不同 token 的数量。
  • hidden_size (int, 可选, 默认为 4096) — 隐藏层表示的维度。
  • intermediate_size (int, 可选, 默认为 16384) — MLP 表示的维度。
  • num_hidden_layers (int, 可选, 默认为 36) — Transformer 编码器中隐藏层的数量。
  • num_attention_heads (int, 可选, 默认为 64) — Transformer 编码器中每个注意力层的注意力头数。
  • hidden_act (str 或 function, 可选, 默认为 "relu2") — 解码器中的非线性激活函数（函数或字符串）。
  • max_position_embeddings (int, 可选, 默认为 16384) — 此模型可能使用的最大序列长度。
  • image_size (int, 可选, 默认为 300) — 输入图像尺寸。
  • patch_size (int, 可选, 默认为 30) — 输入视觉 Transformer 编码 patch 的大小。
  • num_channels (int, 可选, 默认为 3) — 输入图像的通道数。
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • layer_norm_eps (float, 可选, 默认为 1e-05) — RMS 归一化层使用的 epsilon 值。
  • use_cache (bool, 可选, 默认为 True) — 模型是否应返回上次的键/值注意力（并非所有模型都使用）。仅在 config.is_decoder=True 时相关。是否绑定权重嵌入。
  • tie_word_embeddings (bool, 可选, 默认为 False) — 是否绑定输入和输出嵌入。
  • rope_theta (float, 可选, 默认为 25000.0) — RoPE 嵌入的基周期。
  • rope_scaling (Dict, 可选) — 包含 RoPE 嵌入缩放配置的字典。目前支持两种缩放策略：linear 和 dynamic。它们的缩放因子必须是大于 1 的浮点数。预期的格式是 {"type": strategy name, "factor": scaling factor}。当使用此标志时，请勿将 max_position_embeddings 更新为预期的新最大值。有关这些缩放策略如何运作的更多信息，请参阅以下帖子：https://www.reddit.com/r/LocalFuyu/comments/14mrgpr/dynamically_scaled_rope_further_increases/。这是一个实验性功能，未来版本中可能会有破坏性的 API 更改。
  • qk_layernorm (bool, 可选, 默认为 True) — 是否在投影隐藏状态后对 Queries 和 Keys 进行归一化。
  • hidden_dropout (float, 可选, 默认为 0.0) — 将 MLP 应用于隐藏状态后的 dropout 比率。
  • attention_dropout (float, 可选, 默认为 0.0) — 计算注意力分数后的 dropout 比率。
  • partial_rotary_factor (float, 可选, 默认为 0.5) — 查询和键中将使用 rotary embedding 的百分比。
  • pad_token_id (int, 可选) — padding token 的 id。
  • bos_token_id (int, 可选, 默认为 1) — beginning-of-sequence token 的 id。
  • eos_token_id (Union[int, List[int]], 可选, 默认为 2) — end-of-sequence token 的 id。可以选择使用列表来设置多个 end-of-sequence token。
  • text_config (dict, 可选) — 用于初始化 language```Aut 的配置选项字典。

这是一个配置类，用于存储 FuyuForCausalLM 的配置。它用于根据指定的参数实例化 Fuyu 模型，定义模型架构。使用默认值实例化配置将产生与 adept/fuyu-8b 相似的配置。

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

>>> from transformers import FuyuConfig

>>> # Initializing a Fuyu fuyu-7b style configuration
>>> configuration = FuyuConfig()

FuyuForCausalLM

class transformers.FuyuForCausalLM

< >

( config: FuyuConfig )

参数

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

Fuyu 模型，带有一个语言建模头，用于以图像补丁和文本为条件的因果语言模型。此模型继承自 PreTrainedModel。请查阅超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

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

forward

< >

( input_ids: LongTensor = None image_patches: Tensor = None image_patches_indices: Tensor = 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 use_cache: typing.Optional[bool] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.modeling_outputs.CausalLMOutputWithPast or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor, 形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果您提供 padding，默认情况下 padding 将被忽略。

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

    什么是输入 IDs？

  • attention_mask (torch.Tensor, 形状为 (batch_size, sequence_length), 可选) — 掩码，用于避免在 padding token 索引上执行 attention。 Mask values selected in [0, 1]:

    • 1 表示 tokens 未被掩码，
    • 0 表示 tokens 已被掩码。

    什么是 attention masks？

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

    如果使用 past_key_values，则可以选择仅输入最后的 decoder_input_ids （请参阅 past_key_values）。

    如果您想更改 padding 行为，您应该阅读 modeling_opt._prepare_decoder_attention_mask 并根据您的需要进行修改。 有关默认策略的更多信息，请参阅 论文 中的图 1。

    • 1 表示 head 未被掩码，
    • 0 表示 head 已被掩码。
  • image_patches (torch.FloatTensor, 形状为 (batch_size, num_total_patches, patch_size_ x patch_size x num_channels), 可选) — 用作连续嵌入的图像补丁。 这些补丁被展平，然后投影到模型的隐藏层大小。
  • image_patches_indices (torch.LongTensor, 形状为 (batch_size, num_total_patches + number_of_newline_tokens + number_of_text_tokens, patch_size_ x patch_size x num_channels ), 可选) — 指示 image_patches 必须插入到 input_embeds 中哪个位置的索引。
  • position_ids (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 每个输入序列 tokens 在位置嵌入中的位置索引。 在范围 [0, config.n_positions - 1] 中选择。

    什么是位置 IDs？

  • 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) 而不是所有形状为 (batch_size, sequence_length) 的 decoder_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, 可选) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是纯元组。
  • labels (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 用于计算掩码语言建模损失的标签。 索引应为 [0, ..., config.text_config.vocab_size] 或 -100（请参阅 input_ids 文档字符串）。 索引设置为 -100 的 tokens 将被忽略（掩码），损失仅针对标签在 [0, ..., config.text_config.vocab_size] 中的 tokens 计算。

返回

transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutputWithPast 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (FuyuConfig) 和输入。

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

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

  • 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) 的张量）

    包含预先计算的隐藏状态（自注意力模块中的键和值），可以用于加速顺序解码（请参阅 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)。

    模型在每一层输出以及可选的初始嵌入输出处的 Hidden-states。

  • attentions (tuple(torch.FloatTensor), 可选, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

FuyuForCausalLM forward 方法，覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import FuyuProcessor, FuyuForCausalLM
>>> from PIL import Image
>>> import requests

>>> processor = FuyuProcessor.from_pretrained("adept/fuyu-8b")
>>> model = FuyuForCausalLM.from_pretrained("adept/fuyu-8b")

>>> url = "https://huggingface.co/datasets/hf-internal-testing/fixtures-captioning/resolve/main/bus.png"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> prompt = "Generate a coco-style caption.\n"

>>> inputs = processor(images=image, text=prompt, return_tensors="pt")
>>> outputs = model(**inputs)

>>> generated_ids = model.generate(**inputs, max_new_tokens=7)
>>> generation_text = processor.batch_decode(generated_ids[:, -7:], skip_special_tokens=True)
>>> print(generation_text[0])
A blue bus parked on the side of a road.

FuyuImageProcessor

class transformers.FuyuImageProcessor

< >

( do_resize: bool = True size: typing.Optional[typing.Dict[str, int]] = None resample: Resampling = <Resampling.BILINEAR: 2> do_pad: bool = True padding_value: float = 1.0 padding_mode: str = 'constant' do_normalize: bool = True image_mean: typing.Union[float, typing.List[float]] = 0.5 image_std: typing.Union[float, typing.List[float]] = 0.5 do_rescale: bool = True rescale_factor: float = 0.00392156862745098 patch_size: typing.Optional[typing.Dict[str, int]] = None **kwargs )

参数

  • do_resize (bool, 可选, 默认为 True) — 是否将图像调整为 size 大小。
  • size (Dict[str, int], 可选, 默认为 {"height" -- 1080, "width": 1920}): 字典格式为 {"height": int, "width": int}，指定输出图像的大小。
  • resample (PILImageResampling, 可选, 默认为 Resampling.BILINEAR) — 调整图像大小时使用的 PILImageResampling 过滤器，例如 PILImageResampling.BILINEAR。
  • do_pad (bool, 可选, 默认为 True) — 是否将图像填充到 size。
  • padding_value (float, 可选, 默认为 1.0) — 用于填充图像的值。
  • padding_mode (str, 可选, 默认为 "constant") — 填充图像时使用的填充模式。
  • do_normalize (bool, 可选, 默认为 True) — 是否标准化图像。
  • image_mean (float, 可选, 默认为 0.5) — 标准化图像时使用的均值。
  • image_std (float, 可选, 默认为 0.5) — 标准化图像时使用的标准差。
  • do_rescale (bool, 可选, 默认为 True) — 是否重新缩放图像。
  • rescale_factor (float, 可选, 默认为 1 / 255) — 重新缩放图像时使用的因子。
  • patch_size (Dict[str, int], 可选, 默认为 {"height" -- 30, "width": 30}): 字典格式为 {"height": int, "width": int}，指定图像块的大小。

此类应处理主 FuyuForCausalLM 之前的图像处理部分。 特别是，它应该处理

  • 处理图像：接收一批图像作为输入。如果图像大小可变，它会根据所需的图像块尺寸调整它们的大小。图像输出始终为 img_h, img_w (1080, 1920)

    然后，它使用 patchify_image 函数将这些图像分割成图像块。

  • 创建图像输入 ID：对于每个图像块，都会给出一个占位符 ID，以标识这些图像块在 token 序列中的位置。对于可变大小的图像，每行图像块都以换行符 ID 结尾。

  • 图像块索引：对于每个图像块，代码都会维护一个索引，指示这些图像块应插入到 token 流中的位置。

__call__

< >

( images **kwargs )

预处理图像或一批图像。

FuyuProcessor

class transformers.FuyuProcessor

< >

( image_processor tokenizer **kwargs )

参数

构建一个 Fuyu 处理器，它将 Fuyu 图像处理器和 Llama 分词器包装成一个单一的处理器。

FuyuProcessor 提供了 FuyuImageProcessor 和 LlamaTokenizerFast 的所有功能。 有关更多信息，请参阅 call() 和 decode()。

__call__

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] = None text: typing.Union[str, typing.List[str], NoneType] = None audio = None videos = None **kwargs: typing_extensions.Unpack[transformers.models.fuyu.processing_fuyu.FuyuProcessorKwargs] ) → FuyuBatchEncoding

参数

  • images (PIL.Image.Image, List[PIL.Image.Image]) — 要准备的图像或一批图像。每个图像可以是 PIL 图像、NumPy 数组或 PyTorch 张量。支持 channels-first 和 channels-last 格式。
  • text (str, List[str]) — 要编码的序列或一批序列。每个序列可以是字符串或字符串列表（预分词字符串）。如果序列以字符串列表（预分词）形式提供，则必须设置 is_split_into_words=True （以消除与一批序列的歧义）。

返回

FuyuBatchEncoding

带有以下字段的 FuyuBatchEncoding

  • input_ids — 要馈送到模型的 token ID 张量。当 text 不为 None 时返回。
  • image_patches — 图像块的张量列表。当 images 不为 None 时返回。
  • image_patches_indices — 模型必须在其中插入图像块嵌入的索引张量。
  • attention_mask — 指定模型应关注哪些 token 的索引列表，当 return_attention_mask=True 时返回。

准备模型的一个或多个序列和图像的主要方法。如果 text 不为 None 以编码文本，此方法将 text 和 kwargs 参数转发到 LlamaTokenizerFast 的 call()。要准备图像，如果 images 不为 None，此方法将 images 和 kwargs 参数转发到 FuyuImageProcessor 的 call()。有关更多信息，请参阅上述两种方法的文档字符串。

< > 在 GitHub 上更新

←Funnel Transformer Gemma→