Transformers 文档
Emu3
并获得增强的文档体验
开始
Emu3
概述
Emu3 模型在论文 Emu3: Next-Token Prediction is All You Need 中被提出，作者为 Xinlong Wang, Xiaosong Zhang, Zhengxiong Luo, Quan Sun, Yufeng Cui, Jinsheng Wang, Fan Zhang, Yueze Wang, Zhen Li, Qiying Yu, Yingli Zhao, Yulong Ao, Xuebin Min, Tao Li, Boya Wu, Bo Zhao, Bowen Zhang, Liangdong Wang, Guang Liu, Zheqi He, Xi Yang, Jingjing Liu, Yonghua Lin, Tiejun Huang, Zhongyuan Wang。
Emu3 是一个多模态 LLM，它使用向量量化将图像标记化为离散的 tokens。离散化的图像 tokens 随后与文本 token ids 融合，用于图像和文本生成。该模型还可以通过预测图像 token ids 来生成图像。
该论文的摘要如下
虽然下一个 token 预测被认为是通往通用人工智能的有希望的道路，但它在多模态任务中一直难以取得优异表现，这些任务仍然由扩散模型（例如 Stable Diffusion）和组合方法（例如 CLIP 与 LLM 结合）主导。在本文中，我们介绍了 Emu3，一套新的最先进的多模态模型，仅使用下一个 token 预测进行训练。通过将图像、文本和视频标记化为离散空间，我们在多模态序列的混合上从头开始训练单个 transformer。Emu3 在生成和感知任务中都优于几个成熟的特定任务模型，超越了 SDXL 和 LLaVA-1.6 等旗舰模型，同时消除了对扩散或组合架构的需求。Emu3 还能够通过预测视频序列中的下一个 token 来生成高保真视频。我们通过专注于 tokens 简化了复杂的多模态模型设计，从而在训练和推理过程中释放了巨大的扩展潜力。我们的结果表明，下一个 token 预测是构建超越语言的通用多模态智能的有希望的道路。我们开源了关键技术和模型，以支持该方向的进一步研究。
提示
我们建议用户在批量生成之前设置
processor.tokenizer.padding_side = "left"，因为它能带来更准确的结果。请注意，该模型已使用特定的提示格式进行聊天训练。使用
processor.apply_chat_template(my_conversation_dict)来正确格式化您的提示。Emu3 有两个不同的检查点，分别用于图像生成和文本生成，请确保在加载模型时使用正确的检查点。为了生成图像，建议使用
prefix_constraints，以便生成的 tokens 仅从可能的图像 tokens 中采样。请参阅下面的用法示例了解更多信息。
Transformers 中的 Emu3 实现使用特殊的图像 token 来指示在何处合并图像嵌入。特殊的图像 token 并不是新的，而是使用了一个保留的 token：<|extra_0|>。您必须在提示中添加 `
此模型由 RaushanTurganbay 贡献。原始代码可以在这里找到。
用法示例
文本生成推理
以下是如何加载模型并在半精度 (torch.bfloat16) 下执行推理，以从文本或文本和图像输入生成文本输出
from transformers import Emu3Processor, Emu3ForConditionalGeneration
import torch
from PIL import Image
import requests
processor = Emu3Processor.from_pretrained("BAAI/Emu3-Chat-hf")
model = Emu3ForConditionalGeneration.from_pretrained("BAAI/Emu3-Chat-hf", 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))图像生成推理
Emu3 还可以从文本输入生成图像。以下是如何操作的方法
processor = Emu3Processor.from_pretrained("BAAI/Emu3-Gen-hf")
model = Emu3ForConditionalGeneration.from_pretrained("BAAI/Emu3-Gen-hf", torch_dtype="bfloat16", device_map="auto", attn_implementation="flash_attention_2")
inputs = processor(
text=["a portrait of young girl. masterpiece, film grained, best quality.", "a dog running under the rain"],
padding=True,
return_tensors="pt",
return_for_image_generation=True,
)
inputs = inputs.to(device="cuda:0", dtype=torch.bfloat16)
neg_prompt = "lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry."
neg_inputs = processor(text=[neg_prompt] * 2, return_tensors="pt").to(device="cuda:0")
image_sizes = inputs.pop("image_sizes")
HEIGHT, WIDTH = image_sizes[0]
VISUAL_TOKENS = model.vocabulary_mapping.image_tokens
def prefix_allowed_tokens_fn(batch_id, input_ids):
height, width = HEIGHT, WIDTH
visual_tokens = VISUAL_TOKENS
image_wrapper_token_id = torch.tensor([processor.tokenizer.image_wrapper_token_id], device=model.device)
eoi_token_id = torch.tensor([processor.tokenizer.eoi_token_id], device=model.device)
eos_token_id = torch.tensor([processor.tokenizer.eos_token_id], device=model.device)
pad_token_id = torch.tensor([processor.tokenizer.pad_token_id], device=model.device)
eof_token_id = torch.tensor([processor.tokenizer.eof_token_id], device=model.device)
eol_token_id = processor.tokenizer.encode("<|extra_200|>", return_tensors="pt")[0]
position = torch.nonzero(input_ids == image_wrapper_token_id, as_tuple=True)[0][0]
offset = input_ids.shape[0] - position
if offset % (width + 1) == 0:
return (eol_token_id, )
elif offset == (width + 1) * height + 1:
return (eof_token_id, )
elif offset == (width + 1) * height + 2:
return (eoi_token_id, )
elif offset == (width + 1) * height + 3:
return (eos_token_id, )
elif offset > (width + 1) * height + 3:
return (pad_token_id, )
else:
return visual_tokens
out = model.generate(
**inputs,
max_new_tokens=50_000, # make sure to have enough tokens for one image
prefix_allowed_tokens_fn=prefix_allowed_tokens_fn,
return_dict_in_generate=True,
negative_prompt_ids=neg_inputs.input_ids, # indicate for Classifier-Free Guidance
negative_prompt_attention_mask=neg_inputs.attention_mask,
)
image = model.decode_image_tokens(out.sequences[:, inputs.input_ids.shape[1]: ], height=HEIGHT, width=WIDTH)
images = processor.postprocess(list(image.float()), return_tensors="PIL.Image.Image") # internally we convert to np but it's not supported in bf16 precision
for i, image in enumerate(images['pixel_values']):
image.save(f"result{i}.png")
Emu3Config
class transformers.Emu3Config
< 源码 >( vq_config: typing.Union[typing.Dict, transformers.models.emu3.configuration_emu3.Emu3VQVAEConfig] = None text_config: typing.Union[typing.Dict, transformers.models.emu3.configuration_emu3.Emu3TextConfig] = None vocabulary_map: typing.Dict[int, int] = None **kwargs )
这是用于存储 Emu3Model 配置的配置类。它用于根据指定的参数实例化 emu3 模型，定义模型架构。使用默认值实例化配置将产生类似于 Emu3-community/Emu3-Chat-hf 的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。
Emu3VQVAEConfig
class transformers.Emu3VQVAEConfig
< 源码 >( codebook_size: int = 32768 embed_dim: int = 4 latent_channels: int = 4 double_latent: bool = False in_channels: int = 3 out_channels: int = 3 temporal_downsample_factor: int = 4 base_channels: int = 256 channel_multiplier: typing.List[int] = [1, 2, 2, 4] num_res_blocks: int = 2 attn_resolutions: typing.List[int] = [3] hidden_size: int = 1024 num_attention_heads: int = 1 attention_dropout: float = 0.0 **kwargs )
参数
- codebook_size (
int, optional, defaults to 32768) — VQ 模型的代码本大小。 - embed_dim (
int, optional, defaults to 4) — 代码本中量化向量的维度。 - latent_channels (
int, optional, defaults to 4) — 编码器输出通道和解码器输入通道的维度。 - double_latent (
bool, optional, defaults toFalse) — 是否将编码器的输出维度加倍。 - in_channels (
int, optional, defaults to 3) — 编码器的输入通道数。 - out_channels (
int, optional, defaults to 3) — 解码器的输出通道数。 - temporal_downsample_factor (
int, optional, defaults to 4) — 时间下采样因子。 - base_channels (
int, optional, defaults to 256) — 中间模块的基本通道数。 - channel_multiplier (
List[int], optional, defaults to[1, 2, 2, 4]) — 中间模块的通道缩放因子。 - num_res_blocks (
int, optional, defaults to 2) — 每个阶段的残差块数量。 - attn_resolutions (
List[int], optional, defaults to[3]) — 应用注意力的阶段索引。 - hidden_size (
int, optional, defaults to 1024) — 注意力层中隐藏层表示的维度。 - num_attention_heads (
int, optional, defaults to 1) — 每个注意力层的注意力头数。 - attention_dropout (
float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。
这是用于存储 Emu3VQVAE 配置的配置类。它用于根据指定的参数实例化 VQ-VAE 模型，定义模型架构。使用默认值实例化配置将产生 Emu3 论文中提出的 VQ 模型的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。
>>> from transformers import Emu3VQVAE, Emu3VQVAEConfig
>>> # Initializing a video VQ model of Emu3 configuration
>>> configuration = Emu3VQVAEConfig()
>>> # Initializing a model from the Emu3 VQ model style configuration
>>> model = Emu3VQVAE(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configEmu3TextConfig
class transformers.Emu3TextConfig
< source >( vocab_size: int = 184622 hidden_size: int = 4096 intermediate_size: int = 14336 num_hidden_layers: int = 32 num_attention_heads: int = 32 num_key_value_heads: typing.Optional[int] = 8 hidden_act: str = 'silu' max_position_embeddings: int = 9216 rms_norm_eps: float = 1e-05 use_cache: bool = True pad_token_id: int = 151643 bos_token_id: int = 151849 eos_token_id: int = 151850 tie_word_embeddings: bool = False rope_theta: float = 1000000.0 rope_scaling: typing.Optional = None mlp_bias = False attention_bias = False attention_dropout: float = 0.1 initializer_range: float = 0.02 **kwargs )
参数
- vocab_size (
int, optional, defaults to 184622) — Emu3 模型的词汇表大小。定义了调用Emu3Model时传递的inputs_ids可以表示的不同 token 的数量。 - hidden_size (
int, optional, defaults to 4096) — 隐藏层表示的维度。 - intermediate_size (
int, optional, defaults to 14336) — MLP 表示的维度。 - num_hidden_layers (
int, optional, defaults to 32) — Transformer 解码器中隐藏层的数量。 - num_attention_heads (
int, optional, defaults to 32) — Transformer 解码器中每个注意力层的注意力头数。 - num_key_value_heads (
int, optional, defaults to 8) — 这是应用于实现 Grouped Query Attention 的 key_value 头部的数量。 如果num_key_value_heads=num_attention_heads，模型将使用 Multi Head Attention (MHA)；如果num_key_value_heads=1，模型将使用 Multi Query Attention (MQA)；否则将使用 GQA。 当将多头检查点转换为 GQA 检查点时，每个组 key 和 value 头部应通过对该组内所有原始头部进行平均池化来构建。 有关更多详细信息，请查看[本文](https://arxiv.org/pdf/2305.13245.pdf)。 如果未指定，则默认为num_attention_heads。 - hidden_act (
strorfunction, optional, defaults to"silu") — 解码器中的非线性激活函数（函数或字符串）。 - max_position_embeddings (
int, optional, defaults to 9216) — 此模型可能使用的最大序列长度。Emu 支持最多 9216 个 token, - rms_norm_eps (
float, optional, defaults to 1e-05) — rms 归一化层使用的 epsilon 值。 - use_cache (
bool, 可选, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅当config.is_decoder=True时相关。 - pad_token_id (
int, 可选, 默认为 151643) — Padding token id. （填充 token id）。 - bos_token_id (
int, 可选, 默认为 151849) — Beginning of stream token id. （流开始 token id）。 - eos_token_id (
int, 可选, 默认为 151850) — End of stream token id. （流结束 token id）。 - tie_word_embeddings (
bool, 可选, 默认为False) — 是否绑定权重嵌入 - rope_theta (
float, 可选, 默认为 1000000.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 嵌入的缩放因子。在大多数缩放类型中，x 的factor将使模型能够处理长度为 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 高频分量的缩放因子。 - mlp_bias (
bool, 可选, 默认为False) — 是否在 MLP 层中的 up_proj、down_proj 和 gate_proj 层中使用偏置。 - attention_bias (
bool, 可选, 默认为False) — 是否在自注意力期间的 query、key、value 和输出投影层中使用偏置。 - attention_dropout (
float, 可选, 默认为 0.1) — 注意力概率的 dropout 比率。 - initializer_range (
float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
这是用于存储 Emu3TextModel 配置的配置类。它用于根据指定的参数实例化 emu3 模型，定义模型架构。使用默认值实例化配置将产生与 Emu3-community/Emu3-Chat-hf 类似的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。
>>> from transformers import Emu3Model, Emu3Config
>>> # Initializing a Emu3-community/Emu3-Chat-hf style configuration
>>> configuration = Emu3Config()
>>> # Initializing a model from the Emu3-community/Emu3-Chat-hf style configuration
>>> model = Emu3Model(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configEmu3Processor
class transformers.Emu3Processor
< source >( image_processor tokenizer chat_template = None **kwargs )
参数
- image_processor (Emu3ImageProcessor) — 图像处理器是必需的输入。
- tokenizer (
Emu3TokenizerFast) — 分词器是必需的输入。 - chat_template (
str, 可选) — Jinja 模板，用于将聊天中的消息列表转换为可分词的字符串。
构建一个 Emu3 处理器，它将 Emu3 图像处理器和一个 GPT2 分词器包装到一个处理器中。
Emu3Processor 提供了 Emu3ImageProcessor 和 GPT2TokenizerFast 的所有功能。有关更多信息，请参阅 __call__() 和 decode()。
此方法将其所有参数转发到 Emu3TokenizerFast 的 batch_decode()。有关更多信息，请参阅此方法的文档字符串。
此方法将其所有参数转发到 Emu3TokenizerFast 的 decode()。有关更多信息，请参阅此方法的文档字符串。
Emu3ImageProcessor
class transformers.Emu3ImageProcessor
< source >( do_resize: bool = True resample: Resampling = <Resampling.BICUBIC: 3> do_rescale: bool = True rescale_factor: typing.Union[int, float] = 0.00392156862745098 do_normalize: bool = True image_mean: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None do_convert_rgb: bool = True do_pad: bool = True min_pixels: int = 262144 max_pixels: int = 1048576 spatial_factor: int = 8 **kwargs )
参数
- do_resize (
bool, 可选, 默认为True) — 是否调整图像的（高度，宽度）尺寸。 - resample (
PILImageResampling, 可选, 默认为Resampling.BICUBIC) — 调整图像大小时使用的重采样滤波器。 - do_rescale (
bool, 可选, 默认为True) — 是否按指定的比例rescale_factor重新缩放图像。 - rescale_factor (
int或float, 可选, 默认为1/255) — 如果重新缩放图像，则使用的缩放因子。 - do_normalize (
bool, 可选, 默认为True) — 是否对图像进行归一化。 - image_mean (
float或List[float], 可选, 默认为[0.48145466, 0.4578275, 0.40821073]) — 如果要对图像进行归一化，则使用的均值。这可以是浮点数或每个图像通道的浮点数列表。 - image_std (
float或List[float], 可选, 默认为[0.26862954, 0.26130258, 0.27577711]) — 如果要对图像进行归一化，则使用的标准差。这可以是浮点数或每个图像通道的浮点数列表。 - do_convert_rgb (
bool, 可选, 默认为True) — 是否将图像转换为 RGB 格式。 - do_pad (
bool, 可选, 默认为True) — 是否填充图像。如果为True，则会将批次中图像的 patch 维度填充到批次中最大的 patch 数量。填充将应用于底部和右侧，使用零值。 - min_pixels (
int, 可选, 默认为512 * 512) — 调整图像大小的最小像素数。 - max_pixels (
int, 可选, 默认为1024 * 1024) — 调整图像大小的最大像素数。 - spatial_factor (
int, 可选, 默认为 8) — 图像在特征提取阶段将被下采样的空间下采样因子
构建一个 Emu3 图像处理器，该处理器根据原始图像动态调整图像大小。
preprocess
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] do_resize: bool = None size: typing.Dict[str, int] = None resample: Resampling = None do_rescale: bool = None rescale_factor: float = None do_normalize: bool = None image_mean: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None do_convert_rgb: bool = None do_pad: bool = True 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_rescale (
bool, 可选, 默认为self.do_rescale) — 是否重新缩放图像。 - rescale_factor (
float, 可选, 默认为self.rescale_factor) — 如果do_rescale设置为True，则用于重新缩放图像的缩放因子。 - do_normalize (
bool, 可选, 默认为self.do_normalize) — 是否对图像进行归一化。 - image_mean (
float或List[float], 可选, 默认为self.image_mean) — 用于归一化的图像均值。 仅当do_normalize设置为True时才有效。 - image_std (
float或List[float], 可选, 默认为self.image_std) — 用于归一化的图像标准差。 仅当do_normalize设置为True时才有效。 - do_convert_rgb (
bool, 可选, 默认为self.do_convert_rgb) — 是否将图像转换为 RGB 格式。 - do_pad (
bool, 可选, 默认为True) — 是否填充图像。如果为True，则会将批次中图像的 patch 维度填充到批次中最大的 patch 数量。填充将应用于底部和右侧，使用零值。 - return_tensors (
str或TensorType, 可选) — 返回的张量类型。 可以是以下之一：- Unset: 返回
np.ndarray列表。 TensorType.TENSORFLOW或'tf': 返回tf.Tensor类型的批次。TensorType.PYTORCH或'pt': 返回torch.Tensor类型的批次。TensorType.NUMPY或'np': 返回np.ndarray类型的批次。TensorType.JAX或'jax': 返回jax.numpy.ndarray类型的批次。
- Unset: 返回
- data_format (
ChannelDimension或str, 可选, 默认为ChannelDimension.FIRST) — 输出图像的通道维度格式。 可以是以下之一："channels_first"或ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。"channels_last"或ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。- Unset: 使用输入图像的通道维度格式。
- input_data_format (
ChannelDimension或str, 可选) — 输入图像的通道维度格式。 如果未设置，则通道维度格式将从输入图像推断。 可以是以下之一："channels_first"或ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。"channels_last"或ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。"none"或ChannelDimension.NONE: 图像格式为 (height, width)。
Emu3VQVAE
class transformers.Emu3VQVAE
< source >( config: Emu3VQVAEConfig )
参数
- config (Emu3VQVAEConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法来加载模型权重。
Emu3 中使用的 VQ-VAE 模型，用于将图像编码/解码为离散 tokens。 该模型遵循来自 Oran Gafni, Adam Polyak, Oron Ashual, Shelly Sheynin, Devi Parikh, 和 Yaniv Taigman 的 “Make-a-scene: Scene-based text-to-image generation with human priors” 论文。
此模型继承自 PreTrainedModel。 查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch Module，并参阅 PyTorch 文档，了解与通用用法和行为相关的所有事项。
定义每次调用时执行的计算。
应由所有子类重写。
虽然前向传播的配方需要在该函数内定义，但是应该调用 Module 实例而不是此函数，因为前者会处理已注册的钩子，而后者会静默地忽略它们。
Emu3TextModel
class transformers.Emu3TextModel
< source >( config: Emu3Config )
参数
- config (Emu3Config) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
- config — Emu3TextConfig
输出原始隐藏状态且不带任何特定头部层的裸 Emu3Text 模型。此模型继承自 PreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch Module，并参阅 PyTorch 文档，了解与通用用法和行为相关的所有事项。
Transformer 解码器，由 config.num_hidden_layers 层组成。每一层都是一个 Emu3TextDecoderLayer。
forward
< source >( input_ids: 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 return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None **flash_attn_kwargs: typing_extensions.Unpack[transformers.modeling_flash_attention_utils.FlashAttentionKwargs] )
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。如果您提供 padding，默认情况下 padding 将被忽略。索引可以使用 AutoTokenizer 获得。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详情。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的掩码。掩码值在[0, 1]中选择：- 1 表示 未被掩盖 的 token，
- 0 表示 被掩盖 的 token。
索引可以使用 AutoTokenizer 获得。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详情。
如果使用
past_key_values，则可以选择仅输入最后一个input_ids（请参阅past_key_values）。如果您想更改 padding 行为，您应该阅读
modeling_opt._prepare_decoder_attention_mask并根据您的需要进行修改。有关默认策略的更多信息，请参见 论文 中的图 1。- 1 表示 head 未被掩盖，
- 0 表示 head 被掩盖。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列 token 在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。 - past_key_values (
Cache, 可选) — 预先计算的隐藏状态（自注意力模块和交叉注意力模块中的键和值），可用于加速顺序解码。这通常包括模型在前一解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。必须是 Cache 实例的实例，请参阅我们的 kv cache 指南。
模型将输出与输入相同的缓存类型。如果未传递
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索引转换为关联的向量，这将非常有用。 - use_cache (
bool，可选) — 如果设置为True，则返回past_key_values键值状态，并且可以用于加速解码（请参阅past_key_values）。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attention 张量。 有关更多详细信息，请参见返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。 - cache_position (
torch.LongTensor，形状为(sequence_length)，可选) — 索引，描述输入序列 token 在序列中的位置。与position_ids相反，此张量不受 padding 的影响。它用于在正确的位置更新缓存，并推断完整序列长度。
Emu3TextModel 的 forward 方法，覆盖了 __call__ 特殊方法。
虽然前向传播的配方需要在该函数内定义，但是应该调用 Module 实例而不是此函数，因为前者会处理预处理和后处理步骤，而后者会静默地忽略它们。
Emu3ForCausalLM
forward
< source >( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Union[typing.List[torch.FloatTensor], transformers.cache_utils.Cache, NoneType] = 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 cache_position: typing.Optional[torch.LongTensor] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 **kwargs: typing_extensions.Unpack[transformers.models.emu3.modeling_emu3.KwargsForCausalLM] ) → transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。如果您提供 padding，默认情况下 padding 将被忽略。索引可以使用 AutoTokenizer 获得。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详情。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的掩码。掩码值在[0, 1]中选择：- 1 表示 未被掩盖 的 token，
- 0 表示 被掩盖 的 token。
索引可以使用 AutoTokenizer 获得。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详情。
如果使用
past_key_values，则可以选择仅输入最后一个input_ids（请参阅past_key_values）。如果您想更改 padding 行为，您应该阅读
modeling_opt._prepare_decoder_attention_mask并根据您的需要进行修改。有关默认策略的更多信息，请参见 论文 中的图 1。- 1 表示 head 未被掩盖，
- 0 表示 head 被掩盖。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 tokens 的位置索引。在范围[0, config.n_positions - 1]中选择。 - past_key_values (
Cache，可选) — 预先计算的隐藏状态（自注意力模块和交叉注意力模块中的键和值），可以用于加速顺序解码。这通常包含模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。必须是
Cache实例，请参阅我们的 Cache 实例，请参阅我们的 kv 缓存指南。模型将输出与作为输入提供的缓存类型相同的缓存类型。如果未传递
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索引转换为关联的向量，这将非常有用。 - 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)，可选) — 描述输入序列 tokens 在序列中位置的索引。与position_ids相反，此张量不受填充的影响。它用于在正确的位置更新缓存并推断完整的序列长度。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应为[0, ..., config.vocab_size]或 -100（请参阅input_ids文档字符串）。索引设置为-100的 tokens 将被忽略（掩码），损失仅针对标签在[0, ..., config.vocab_size]中的 tokens 计算。 - logits_to_keep (
int或torch.Tensor，可选) — 如果是int，则计算最后logits_to_keep个 tokens 的 logits。如果为0，则计算所有input_ids的 logits（特殊情况）。生成只需要最后一个 token logits，并且仅针对该 token 计算它们可以节省内存，这对于长序列或大型词汇表大小而言变得非常重要。如果是torch.Tensor，则必须是与序列长度维度中要保留的索引相对应的 1D 张量。当使用 packed tensor 格式（批次和序列长度的单维度）时，这很有用。
返回
transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
transformers.modeling_outputs.CausalLMOutputWithPast 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包括各种元素，具体取决于配置 (Emu3TextConfig) 和输入。
-
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)。模型在每层输出端的隐藏状态，加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
Emu3ForCausalLM forward 方法，覆盖了 __call__ 特殊方法。
虽然前向传播的配方需要在该函数内定义，但是应该调用 Module 实例而不是此函数，因为前者会处理预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import Emu3Processor, Emu3ForConditionalGeneration
>>> import torch
>>> import requests
>>> from PIL import Image
>>> model = Emu3ForCausalLM.from_pretrained("BAAI/Emu3-Chat-hf", torch_dtype=torch.bfloat16)
>>> processor = Emu3Processor.from_pretrained("BAAI/Emu3-Chat-hf")
>>> inputs = processor(text=["Can you write me a poem about winter."], return_tensors="pt").to(model.device)
>>> generated_ids = model.generate(**inputs, max_new_tokens=100, do_sample=False)
>>> processor.batch_decode(generated_ids, skip_special_tokens=True)[0]Emu3ForConditionalGeneration
forward
< source >( input_ids: LongTensor = None pixel_values: FloatTensor = None image_sizes: Tensor = 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 labels: typing.Optional[torch.LongTensor] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 ) → transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果您提供填充，默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。 有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 。
- pixel_values (
torch.FloatTensor，形状为(batch_size, max_num_images, max_num_tiles, channels, image_size, image_size))-- 与输入图像相对应的张量。像素值可以使用 [AutoImageProcessor](/docs/transformers/v4.50.0/en/model_doc/auto#transformers.AutoImageProcessor) 获得。 有关详细信息，请参见 [Emu3ImageProcessor.__call__()](/docs/transformers/v4.50.0/en/model_doc/vilt#transformers.ViltFeatureExtractor.__call__) ([`Emu3Processor`] 使用 Emu3ImageProcessor 处理图像)。 - image_sizes (
torch.LongTensor，形状为(batch_size, 2)) — 批次中图像的大小，对于每个图像均为 (高度，宽度)。 图像大小可以使用 [AutoImageProcessor](/docs/transformers/v4.50.0/en/model_doc/auto#transformers.AutoImageProcessor) 获得。 有关详细信息，请参见 Emu3ImageProcessor.call() ([`Emu3Processor`] 使用 Emu3ImageProcessor 处理图像)。 - attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 掩码，以避免对填充 token 索引执行注意力机制。在[0, 1]中选择的掩码值：- 1 表示 未被掩码 的 tokens，
- 0 表示 已被掩码 的 tokens。
可以使用 AutoTokenizer 获取索引。 有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 。
如果使用
past_key_values，则可以选择仅输入最后一次的input_ids（请参阅past_key_values）。如果要更改填充行为，则应阅读
modeling_opt._prepare_decoder_attention_mask并根据您的需求进行修改。 有关默认策略的更多信息，请参见 论文 中的图 1。- 1 表示 head 未被掩码，
- 0 表示 head 已被掩码。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 tokens 的位置索引。在范围[0, config.n_positions - 1]中选择。 - past_key_values (
Cache或tuple(tuple(torch.FloatTensor))，可选) — 预先计算的隐藏状态（自注意力模块和交叉注意力模块中的键和值），可以用于加速顺序解码。这通常包含模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。必须是
Cache实例，请参阅我们的 Cache 实例，请参阅我们的 kv 缓存指南。模型将输出与作为输入提供的缓存格式相同的缓存格式。如果未传递
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索引转换为关联的向量，这将非常有用。 - 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相反，此张量不受填充的影响。 它用于在正确的位置更新缓存，并推断完整的序列长度。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。 索引应为[0, ..., config.vocab_size]或 -100（请参阅input_ids文档字符串）。 索引设置为-100的标记将被忽略（掩码），损失仅针对标签在[0, ..., config.vocab_size]中的标记计算。 - logits_to_keep (
int或torch.Tensor，可选) — 如果是int，则计算最后logits_to_keep个标记的 logits。 如果为0，则计算所有input_ids的 logits（特殊情况）。 生成只需要最后一个标记 logits，并且仅针对该标记计算它们可以节省内存，这对于长序列或大词汇量大小而言变得非常重要。 如果是torch.Tensor，则必须是与序列长度维度中要保留的索引相对应的 1D 张量。 当使用打包张量格式（批次和序列长度的单个维度）时，这很有用。
返回
transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.CausalLMOutputWithPast 或一个 torch.FloatTensor 元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，其中包含各种元素，具体取决于配置 (Emu3Config) 和输入。
-
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)。模型在每层输出端的隐藏状态，加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
Emu3ForConditionalGeneration forward 方法，覆盖了 __call__ 特殊方法。
虽然前向传播的配方需要在该函数内定义，但是应该调用 Module 实例而不是此函数，因为前者会处理预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import Emu3Processor, Emu3ForConditionalGeneration
>>> import torch
>>> import requests
>>> from PIL import Image
>>> model = Emu3ForConditionalGeneration.from_pretrained("BAAI/Emu3-Chat-hf", torch_dtype=torch.bfloat16)
>>> processor = Emu3Processor.from_pretrained("BAAI/Emu3-Chat-hf")
>>> conversation = [
... {
... "role": "system",
... "content": [
... {"type": "text", "text": "You are a helpful assistant."},
... ],
... },
... {
... "role": "user",
... "content": [
... {"type": "image"},
... {"type": "text", "text": "Please describe the image."},
... ],
... },
... ]
>>> prompt = processor.apply_chat_template(conversation, add_generation_prompt=True)
>>> image = Image.open(requests.get("https://www.ilankelman.org/stopsigns/australia.jpg", stream=True).raw)
>>> inputs = processor(images=[image], 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]