Transformers 文档
Emu3
并获得增强的文档体验
开始使用
Emu3
概述
Emu3 模型由 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: Next-Token Prediction is All You Need 中提出。
Emu3 是一种多模态大型语言模型(LLM),它使用向量量化将图像标记化为离散的 token。离散化的图像 token 随后与文本 token ID 融合,用于图像和文本生成。该模型还可以通过预测图像 token ID 来生成图像。
论文摘要如下:
虽然下一 token 预测被认为是实现通用人工智能的有前途的途径,但它在多模态任务中一直难以表现出色,这些任务仍然由扩散模型(如 Stable Diffusion)和组合方法(如 CLIP 与 LLM 结合)主导。在本文中,我们介绍了 Emu3,一套仅通过下一 token 预测训练的最新多模态模型。通过将图像、文本和视频标记化为离散空间,我们从头开始训练一个 Transformer,并将其应用于多模态序列的混合。Emu3 在生成和感知任务中均优于多个成熟的特定任务模型,超越了 SDXL 和 LLaVA-1.6 等旗舰模型,同时消除了对扩散或组合架构的需求。Emu3 还能够通过预测视频序列中的下一 token 来生成高保真视频。我们通过专注于一个核心点——token,简化了复杂的多模态模型设计,为训练和推理阶段的扩展释放了巨大潜力。我们的结果表明,下一 token 预测是构建超越语言的通用多模态智能的有前途的途径。我们开源了关键技术和模型,以支持这一方向的进一步研究。
技巧
我们建议用户在进行批处理生成之前设置
processor.tokenizer.padding_side = "left"
,因为这会带来更准确的结果。请注意,该模型已使用特定的提示格式进行聊天训练。使用
processor.apply_chat_template(my_conversation_dict)
来正确格式化您的提示。Emu3 针对图像生成和文本生成有两个不同的检查点,请确保在加载模型时使用正确的检查点。为了生成图像,建议使用
prefix_constraints
,以便生成的 token 只从可能的图像 token 中采样。更多使用示例请参见下文。
Transformers 中的 Emu3 实现使用一个特殊的图像 token 来指示在哪里合并图像嵌入。这个特殊的图像 token 并不是新的,它使用了一个保留 token:<|extra_0|>
。您必须在提示中图像应该嵌入的位置添加 <image>
才能正确生成。
此模型由 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[dict, transformers.models.emu3.configuration_emu3.Emu3VQVAEConfig] = None text_config: typing.Union[dict, transformers.models.emu3.configuration_emu3.Emu3TextConfig] = None vocabulary_map: typing.Optional[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: list = [1, 2, 2, 4] num_res_blocks: int = 2 attn_resolutions: list = [3] hidden_size: int = 1024 num_attention_heads: int = 1 attention_dropout: float = 0.0 **kwargs )
参数
- codebook_size (
int
, 可选, 默认为 32768) — VQ 模型的码本大小。 - 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 (
list[int]
, 可选, 默认为[1, 2, 2, 4]
) — 中间块的通道缩放因子。 - num_res_blocks (
int
, 可选, 默认为 2) — 每个阶段的残差块数量。 - attn_resolutions (
list[int]
, 可选, 默认为[3]
) — 应用注意力机制的阶段索引。 - hidden_size (
int
, 可选, 默认为 1024) — 注意力层中隐藏表示的维度。 - num_attention_heads (
int
, 可选, 默认为 1) — 每个注意力层的注意力头数量。 - attention_dropout (
float
, 可选, 默认为 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.config
Emu3TextConfig
class transformers.Emu3TextConfig
< 来源 >( 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
, 可选, 默认为 184622) — Emu3 模型的词汇表大小。定义了调用 Emu3Model 时传递的inputs_ids
可以表示的不同 token 的数量 - hidden_size (
int
, 可选, 默认为 4096) — 隐藏表示的维度。 - intermediate_size (
int
, 可选, 默认为 14336) — MLP 表示的维度。 - num_hidden_layers (
int
, 可选, 默认为 32) — Transformer 解码器中的隐藏层数量。 - num_attention_heads (
int
, 可选, 默认为 32) — Transformer 解码器中每个注意力层的注意力头数量。 - num_key_value_heads (
int
, 可选, 默认为 8) — 用于实现分组查询注意力(Grouped Query Attention)的 key_value 头数量。如果num_key_value_heads=num_attention_heads
,模型将使用多头注意力 (MHA);如果num_key_value_heads=1
,模型将使用多查询注意力 (MQA);否则,将使用 GQA。在将多头检查点转换为 GQA 检查点时,每个组的键和值头应通过对其组内的所有原始头进行均值池化来构建。更多详细信息,请查看 [此论文](https://huggingface.co/papers/2305.13245)。如果未指定,则默认为num_attention_heads
。 - hidden_act (
str
或function
, 可选, 默认为"silu"
) — 解码器中的非线性激活函数(函数或字符串)。 - max_position_embeddings (
int
, 可选, 默认为 9216) — 该模型可能使用的最大序列长度。Emu 支持高达 9216 个 token。 - rms_norm_eps (
float
, 可选, 默认为 1e-05) — RMS 归一化层使用的 epsilon 值。 - use_cache (
bool
, 可选, 默认为True
) — 模型是否应返回最后一个 key/values attention(并非所有模型都使用)。仅当config.is_decoder=True
时才相关。 - pad_token_id (
int
, 可选, 默认为 151643) — 填充 token ID。 - bos_token_id (
int
, 可选, 默认为 151849) — 流起始 token ID。 - eos_token_id (
int
, 可选, 默认为 151850) — 流结束 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 将使模型能够处理长度为 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
) — 在自注意力过程中,查询、键、值和输出投影层是否使用偏置。 - 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.config
Emu3Processor
class transformers.Emu3Processor
< 源文件 >( 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()。有关更多信息,请参阅此方法的文档字符串。
Emu3ImageProcessor
class transformers.Emu3ImageProcessor
< 源文件 >( 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, list[float], NoneType] = None image_std: typing.Union[float, 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
,将批次中图像的补丁维度填充到批次中最大补丁数量。填充将应用于底部和右侧,填充值为零。 - min_pixels (
int
, 可选, 默认为512 * 512
) — 用于调整图像大小的最小像素数。 - max_pixels (
int
, 可选, 默认为1024 * 1024
) — 用于调整图像大小的最大像素数。 - spatial_factor (
int
, 可选, 默认为 8) — 图像在特征提取阶段将被下采样的空间下采样因子。
构建一个 Emu3 图像处理器,它根据原始图像动态调整图像大小。
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_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 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
,将批次中图像的补丁维度填充到批次中最大补丁数量。填充将应用于底部和右侧,填充值为零。 - return_tensors (
str
或TensorType
, 可选) — 要返回的张量类型。可以是以下之一:- 未设置:返回
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 (
ChannelDimension
或str
, 可选, 默认为ChannelDimension.FIRST
) — 输出图像的通道维度格式。可以是以下之一:"channels_first"
或ChannelDimension.FIRST
:图像格式为 (num_channels, height, width)。"channels_last"
或ChannelDimension.LAST
:图像格式为 (height, width, num_channels)。- 未设置:使用输入图像的通道维度格式。
- 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
< 源文件 >( config: Emu3VQVAEConfig )
参数
- config (Emu3VQVAEConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化并不会加载与模型相关的权重,只加载配置。请查看 from_pretrained() 方法来加载模型权重。
Emu3 中用于将图像编码/解码为离散 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 文档以获取所有与通用用法和行为相关的事项。
定义每次调用时执行的计算。
应由所有子类覆盖。
尽管前向传播的配方需要在该函数中定义,但之后应该调用 Module
实例而不是它,因为前者负责运行注册的钩子,而后者则默默地忽略它们。
Emu3TextModel
class transformers.Emu3TextModel
< source >( config: Emu3Config )
参数
- config (Emu3Config) — 模型的配置类,包含模型的所有参数。使用配置文件初始化并不会加载与模型相关的权重,只加载配置。请查看 from_pretrained() 方法来加载模型权重。
裸 Emu3 文本模型,直接输出原始隐藏状态,不带任何特定头部。
此模型继承自 PreTrainedModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头等)。
此模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并参考 PyTorch 文档以获取所有与通用用法和行为相关的事项。
forward
< source >( 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.BaseModelOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
,形状为(batch_size, sequence_length)
,可选) — 词汇表中输入序列标记的索引。默认情况下,填充将被忽略。索引可以使用 AutoTokenizer 获取。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- 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]
。 - past_key_values (
~cache_utils.Cache
,可选) — 预计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。这通常包括模型在解码上一阶段返回的past_key_values
,当use_cache=True
或config.use_cache=True
时。允许两种格式:
- 一个 Cache 实例,参见我们的 kv cache 指南;
- 一个长度为
config.n_layers
的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)
,而不是所有input_ids
形状为(batch_size, sequence_length)
。 - 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
。 - cache_position (
torch.LongTensor
,形状为(sequence_length)
,可选) — 指示输入序列标记在序列中位置的索引。与position_ids
不同,此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。
返回
transformers.modeling_outputs.BaseModelOutputWithPast 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutputWithPast 或一个 torch.FloatTensor
元组(如果传入 return_dict=False
或 config.return_dict=False
),包含根据配置 (Emu3Config) 和输入的不同元素。
-
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
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入层输出,如果模型有嵌入层,+ 一个用于每个层的输出)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
,可选,当传入output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每个层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
Emu3TextModel 的 forward 方法,覆盖了 __call__
特殊方法。
尽管前向传递的实现需要在该函数中定义,但随后应调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
Emu3Model
通过上采样使用 VQGAN 模块将生成的图像标记解码为连续像素值。
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 **kwargs: typing_extensions.Unpack[transformers.modeling_flash_attention_utils.FlashAttentionKwargs] ) → transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)
的torch.LongTensor
) — 词汇表中输入序列标记的索引。默认情况下,填充将被忽略。索引可以使用 AutoTokenizer 获取。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- pixel_values (形状为
(batch_size, num_channels, image_size, image_size)
的torch.FloatTensor
) — 对应于输入图像的张量。像素值可以使用{image_processor_class}
获取。有关详细信息,请参见{image_processor_class}.__call__
({processor_class}
使用{image_processor_class}
处理图像)。 - image_sizes (形状为
(batch_size, 2)
的torch.LongTensor
) — 批处理中图像的大小,每个图像为(高度,宽度)。图像大小可以使用 AutoImageProcessor 获取。有关详细信息,请参见 Emu3ImageProcessor.call() ([]Emu3Processor
] 使用 Emu3ImageProcessor 处理图像)。 - attention_mask (形状为
(batch_size, sequence_length)
的torch.Tensor
,可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选择在[0, 1]
之间:- 1 表示 未被掩盖 的标记,
- 0 表示 被掩盖 的标记。
- position_ids (形状为
(batch_size, sequence_length)
的torch.LongTensor
,可选) — 输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]
。 - past_key_values (
~cache_utils.Cache
,可选) — 预计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。这通常包括模型在解码上一阶段返回的past_key_values
,当use_cache=True
或config.use_cache=True
时。允许两种格式:
- 一个 Cache 实例,参见我们的 kv cache 指南;
- 一个长度为
config.n_layers
的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)
,而不是所有input_ids
形状为(batch_size, sequence_length)
。 - inputs_embeds (形状为
(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选) — (可选)不传递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 (形状为
(sequence_length)
的torch.LongTensor
,可选) — 指示输入序列标记在序列中位置的索引。与position_ids
不同,此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。
返回
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 (形状为
(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
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入层输出,如果模型有嵌入层,+ 一个用于每个层的输出)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
,可选,当传入output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每个层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
Emu3Model 的 forward 方法,覆盖了 __call__
特殊方法。
尽管前向传递的实现需要在该函数中定义,但随后应调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
使用 VQGAN 模块将图像标记化为离散标记,并使用文本嵌入层嵌入它们。
使用 VQGAN 模块将图像标记化为离散标记。将获得的图像标记转换为 BPE 标记并用“boi”和“eoi”特殊标记包装。
Emu3ForCausalLM
class transformers.Emu3ForCausalLM
< source >( config )
参数
- config (Emu3ForCausalLM) — 模型的配置类,包含模型的所有参数。使用配置文件初始化并不会加载与模型相关的权重,只加载配置。请查看 from_pretrained() 方法来加载模型权重。
用于因果语言建模的 Emu3 模型。
此模型继承自 PreTrainedModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头等)。
此模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并参考 PyTorch 文档以获取所有与通用用法和行为相关的事项。
forward
< source >( 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.emu3.modeling_emu3.KwargsForCausalLM] ) → transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)
的torch.LongTensor
,可选) — 词汇表中输入序列标记的索引。默认情况下,填充将被忽略。索引可以使用 AutoTokenizer 获取。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)
的torch.Tensor
,可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选择在[0, 1]
之间:- 1 表示 未被掩盖 的标记,
- 0 表示 被掩盖 的标记。
- position_ids (形状为
(batch_size, sequence_length)
的torch.LongTensor
,可选) — 输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]
。 - past_key_values (
~cache_utils.Cache
,可选) — 预计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。这通常包括模型在解码上一阶段返回的past_key_values
,当use_cache=True
或config.use_cache=True
时。允许两种格式:
- 一个 Cache 实例,参见我们的 kv cache 指南;
- 一个长度为
config.n_layers
的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)
,而不是所有input_ids
形状为(batch_size, sequence_length)
。 - inputs_embeds (形状为
(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选) — (可选)不传递input_ids
,而是直接传递嵌入表示。如果您希望对如何将input_ids
索引转换为相关向量具有比模型内部嵌入查找矩阵更多的控制,这将很有用。 - labels (形状为
(batch_size, sequence_length)
的torch.LongTensor
,可选) — 用于计算掩码语言建模损失的标签。索引应在[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,对应于序列长度维度中要保留的索引。这在使用 packed tensor 格式(批次和序列长度的单维度)时很有用。
返回
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 (形状为
(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
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入层输出,如果模型有嵌入层,+ 一个用于每个层的输出)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
,可选,当传入output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每个层一个)。注意力 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
< 来源 >( 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 **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)
) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。索引可以通过
AutoTokenizer
获取。有关详细信息,请参见PreTrainedTokenizer.encode()
和PreTrainedTokenizer.__call__()
。 - pixel_values (
torch.FloatTensor
,形状为(batch_size, num_channels, image_size, image_size)
) — 对应于输入图像的张量。像素值可以使用{image_processor_class}
获取。有关详细信息,请参见{image_processor_class}.__call__
({processor_class}
使用{image_processor_class}
处理图像)。 - image_sizes (
torch.LongTensor
,形状为(batch_size, 2)
) — 批次中图像的大小,每个图像为 (高度, 宽度)。图像大小可以通过AutoImageProcessor
获取。有关详细信息,请参见Emu3ImageProcessor.__call__()
([Emu3Processor
] 使用Emu3ImageProcessor
处理图像)。 - 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]
。 - past_key_values (
~cache_utils.Cache
, 可选) — 预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。这通常包括模型在解码上一阶段返回的past_key_values
,当use_cache=True
或config.use_cache=True
时。允许两种格式:
Cache
实例,请参阅我们的 kv 缓存指南;- 长度为
config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组包含两个形状为(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
不同,此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。 - labels (
torch.LongTensor
,形状为(batch_size, sequence_length)
,可选) — 用于计算掩码语言建模损失的标签。索引应在[0, ..., config.vocab_size]
或 -100 之间(参见input_ids
文档字符串)。索引设置为-100
的标记将被忽略(掩码),损失仅针对标签在[0, ..., config.vocab_size]
中的标记计算。 - logits_to_keep (
Union[int, torch.Tensor]
,默认为0
) — 如果是int
,则计算最后logits_to_keep
个标记的 logits。如果为0
,则计算所有input_ids
的 logits(特殊情况)。生成时只需要最后一个标记的 logits,只为该标记计算可以节省内存,这对于长序列或大词汇量来说非常重要。如果为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
),包含根据配置 (Emu3Config) 和输入的不同元素。
-
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
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入层输出,如果模型有嵌入层,+ 一个用于每个层的输出)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
,可选,当传入output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每个层一个)。注意力 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]