Transformers 文档

Gemma3

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

Gemma3

概述

Gemma 3 模型由 Google 在 Gemma 3 Techncial Report 中提出。它是一个视觉-语言模型,由 SigLIP 视觉编码器和 Gemma 2 语言解码器组成,通过多模态线性投影连接。它将图像切割成固定数量的 tokens,方式与 SigLIP 相同,只要图像不超过一定的宽高比。对于超过给定宽高比的图像,它会将图像裁剪成多个较小的 patches,并将它们与基本图像嵌入连接起来。一个特点是该模型在所有图像 tokens 上使用双向注意力。此外,该模型在语言 backbone 中交错使用滑动窗口局部注意力和完全因果注意力,其中每六层是一个完全因果注意力层。

此模型由 Ryan MullinsRaushan Turganbay Arthur ZuckerPedro Cuenca 贡献。

使用提示

  • 对于图像+文本和仅图像输入,请使用 Gemma3ForConditionalGeneration
  • 对于仅文本输入,请使用 Gemma3ForCausalLM 进行生成,以避免加载视觉 tower。
  • 每个样本可以包含多张图像,并且样本之间的图像数量可以不同。但是,请确保将正确批处理的图像传递给 processor,其中每个批次是一个或多个图像的列表。
  • 传递给 processor 的文本应该在任何需要插入图像的地方都有一个 <start_of_image> token。
  • processor 有自己的 apply_chat_template 方法,用于将聊天消息转换为模型输入。请参阅下面的示例,了解有关如何使用它的更多详细信息。

高分辨率图像的图像裁剪

当图像宽高比超过某个值时,该模型支持将图像裁剪成更小的 patches。默认情况下,图像不会被裁剪,只有基本图像会被转发到模型。用户可以设置 do_pan_and_scan=True 来获取每张图像的多个裁剪区域以及基本图像,以提高 DocVQA 或类似需要更高分辨率图像的任务的质量。

Pan and scan 是一种推理时间优化,用于处理宽高比倾斜的图像。启用后,它可以提高与文档理解、信息图表、OCR 等相关的任务的性能。


processor = AutoProcessor.from_pretrained("google/gemma-3-4b-it", padding_side="left")

url = "https://media.istockphoto.com/id/1192867753/photo/cow-in-berchida-beach-siniscola.jpg?s=612x612&w=0&k=20&c=v0hjjniwsMNfJSuKWZuIn8pssmD5h5bSN1peBd1CmH4="
messages = [
    {
        "role": "system",
        "content": [
            {"type": "text", "text": "You are a helpful assistant."}
        ]
    },
    {
        "role": "user", "content": [
            {"type": "image", "url": url},
            {"type": "text", "text": "What is shown in this image?"},
        ]
    },
]
inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
    do_pan_and_scan=True,
).to(model.device)

使用示例

单图像推理

from transformers import AutoProcessor, Gemma3ForConditionalGeneration

model_id = "google/gemma-3-4b-it"
model = Gemma3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")
processor = AutoProcessor.from_pretrained(model_id, padding_side="left")

url = "https://media.istockphoto.com/id/1192867753/photo/cow-in-berchida-beach-siniscola.jpg?s=612x612&w=0&k=20&c=v0hjjniwsMNfJSuKWZuIn8pssmD5h5bSN1peBd1CmH4="
messages = [
    {
        "role": "system",
        "content": [
            {"type": "text", "text": "You are a helpful assistant."}
        ]
    },
    {
        "role": "user", "content": [
            {"type": "image", "url": url},
            {"type": "text", "text": "What is shown in this image?"},
        ]
    },
]
inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
).to(model.device)

output = model.generate(**inputs, max_new_tokens=50)
print(processor.decode(output[0], skip_special_tokens=True)[inputs.input_ids.shape[1]: ])

多图像推理

model_id = "google/gemma-3-4b-it"
model = Gemma3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")
processor = AutoProcessor.from_pretrained(model_id, padding_side="left")

url_cow = "https://media.istockphoto.com/id/1192867753/photo/cow-in-berchida-beach-siniscola.jpg?s=612x612&w=0&k=20&c=v0hjjniwsMNfJSuKWZuIn8pssmD5h5bSN1peBd1CmH4="
url_stop = "https://www.ilankelman.org/stopsigns/australia.jpg"
messages = [
    {
        "role": "system",
        "content": [
            {"type": "text", "text": "You are a helpful assistant."}
        ]
    },
    {
        "role": "user", "content": [
            {"type": "image", "url": url_cow},
            {"type": "image", "url": url_stop},
            {"type": "text", "text": "Are these two images identical?"},
        ]
    },
]
inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
).to(model.device)

output = model.generate(**inputs, max_new_tokens=50)
print(processor.decode(output[0], skip_special_tokens=True)[inputs.input_ids.shape[1]: ])

仅文本推理

您可以使用 VLM 进行纯文本生成,方法是在输入中省略图像。但是,您也可以如下所示以纯文本模式加载模型。当您只需要 LLM 功能时,这将跳过加载视觉 tower 并节省资源。

from transformers import AutoTokenizer, Gemma3ForCausalLM

model_id = "google/gemma-3-1b-it"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = Gemma3ForCausalLM.from_pretrained(model_id, device_map="auto")

input_ids = tokenizer("Write me a poem about Machine Learning.", return_tensors="pt").to(model.device)

outputs = model.generate(**input_ids, max_new_tokens=100)
text = tokenizer.batch_decode(outputs, skip_special_tokens=True)

print(text)

Gemma3ImageProcessor

class transformers.Gemma3ImageProcessor

< >

( do_resize: bool = True size: typing.Dict[str, int] = None resample: Resampling = <Resampling.BILINEAR: 2> 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 = None do_pan_and_scan: bool = None pan_and_scan_min_crop_size: int = None pan_and_scan_max_num_crops: int = None pan_and_scan_min_ratio_to_activate: float = None **kwargs )

参数

  • do_resize (bool, *可选*, 默认为 True) — 是否将图像的(高度、宽度)尺寸调整为指定的 size。可以被 preprocess 方法中的 do_resize 覆盖。
  • size (Dict[str, int] 可选, 默认为 {"height" -- 224, "width": 224}): 调整大小后图像的尺寸。可以被 preprocess 方法中的 size 参数覆盖。
  • resample (PILImageResampling, 可选, 默认为 Resampling.BILINEAR) — 如果调整图像大小,则使用的重采样滤波器。可以被 preprocess 方法中的 resample 参数覆盖。
  • do_rescale (bool, 可选, 默认为 True) — 是否通过指定的比例因子 rescale_factor 重新缩放图像。可以被 preprocess 方法中的 do_rescale 参数覆盖。
  • rescale_factor (intfloat, 可选, 默认为 1/255) — 如果重新缩放图像,则使用的比例因子。可以被 preprocess 方法中的 rescale_factor 参数覆盖。
  • do_normalize (bool, 可选, 默认为 True) — 是否通过指定的均值和标准差来标准化图像。可以被 preprocess 方法中的 do_normalize 参数覆盖。
  • image_mean (floatList[float], 可选, 默认为 [0.5, 0.5, 0.5]) — 如果标准化图像,则使用的均值。这是一个浮点数或浮点数列表,其长度等于图像中的通道数。可以被 preprocess 方法中的 image_mean 参数覆盖。
  • image_std (floatList[float], 可选, 默认为 [0.5, 0.5, 0.5]) — 如果标准化图像,则使用的标准差。这是一个浮点数或浮点数列表,其长度等于图像中的通道数。可以被 preprocess 方法中的 image_std 参数覆盖。 可以被 preprocess 方法中的 image_std 参数覆盖。
  • do_convert_rgb (bool, 可选, 默认为 True) — 是否将图像转换为 RGB 格式。
  • do_pan_and_scan (bool, 可选) — 是否对图像应用 pan_and_scan
  • pan_and_scan_min_crop_size (int, 可选) — pan and scan 中每个裁剪区域的最小尺寸。
  • pan_and_scan_max_num_crops (int, 可选) — pan and scan 中每个图像的最大裁剪数量。
  • pan_and_scan_min_ratio_to_activate (float, 可选) — 激活 pan and scan 的最小宽高比。

构造 SigLIP 图像处理器。

pan_and_scan

< >

( image: ndarray pan_and_scan_min_crop_size: int pan_and_scan_max_num_crops: int pan_and_scan_min_ratio_to_activate: float data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None )

参数

  • image (np.ndarray) — 要调整大小的图像。
  • pan_and_scan_min_crop_size (int, 可选) — pan and scan 中每个裁剪区域的最小尺寸。
  • pan_and_scan_max_num_crops (int, 可选) — pan and scan 中每个图像的最大裁剪数量。
  • pan_and_scan_min_ratio_to_activate (float, 可选) — 激活 pan and scan 的最小宽高比。
  • data_format (strChannelDimension, 可选) — 图像的通道维度格式。如果未提供,则与输入图像相同。
  • input_data_format (ChannelDimensionstr, 可选) — 输入图像的通道维度格式。如果未提供,则会进行推断。

当宽高比超过最小允许比率时,通过裁剪成更小的图像来进行 Pan and Scan 图像处理。

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: 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 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 do_convert_rgb: bool = None do_pan_and_scan: bool = None pan_and_scan_min_crop_size: int = None pan_and_scan_max_num_crops: int = None pan_and_scan_min_ratio_to_activate: float = None )

参数

  • images (ImageInput) — 要预处理的图像。 期望是像素值范围从 0 到 255 的单个或一批图像。如果传入像素值在 0 和 1 之间的图像,请设置 do_rescale=False
  • do_resize (bool, 可选, 默认为 self.do_resize) — 是否调整图像大小。
  • size (Dict[str, int], 可选, 默认为 self.size) — 调整大小后图像的尺寸。
  • resample (int, 可选, 默认为 self.resample) — 如果调整图像大小,则使用的重采样滤波器。这可以是枚举 PILImageResampling 之一。仅在 do_resize 设置为 True 时有效。
  • do_rescale (bool, optional, defaults to self.do_rescale) — 是否对图像进行重新缩放。
  • rescale_factor (float, optional, defaults to self.rescale_factor) — 重新缩放因子,如果 do_rescale 设置为 True,则通过该因子重新缩放图像。
  • do_normalize (bool, optional, defaults to self.do_normalize) — 是否对图像进行归一化。
  • image_mean (floatList[float], optional, defaults to self.image_mean) — 用于归一化的图像均值。仅当 do_normalize 设置为 True 时才生效。
  • image_std (floatList[float], optional, defaults to self.image_std) — 用于归一化的图像标准差。仅当 do_normalize 设置为 True 时才生效。
  • return_tensors (strTensorType, optional) — 返回的张量类型。可以是以下之一:
    • 未设置:返回 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, optional, defaults to ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST:图像格式为 (height, width, num_channels)。
    • 未设置:使用输入图像的通道维度格式。
  • input_data_format (ChannelDimensionstr, optional) — 输入图像的通道维度格式。如果未设置,则通道维度格式从输入图像推断。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST:图像格式为 (height, width, num_channels)。
    • "none"ChannelDimension.NONE:图像格式为 (height, width)。
  • do_convert_rgb (bool, optional, defaults to self.do_convert_rgb) — 是否将图像转换为 RGB 格式。
  • do_pan_and_scan (bool, optional, defaults to self.do_convert_rgb) — 是否对图像应用 pan_and_scan
  • pan_and_scan_min_crop_size (int, optional, defaults to self.pan_and_scan_min_crop_size) — pan and scan 中每个裁剪区域的最小尺寸。
  • pan_and_scan_max_num_crops (int, optional, defaults to self.pan_and_scan_max_num_crops) — pan and scan 中每个图像的最大裁剪区域数量。
  • pan_and_scan_min_ratio_to_activate (float, optional, defaults to self.pan_and_scan_min_ratio_to_activate) — 激活 pan and scan 的最小宽高比。

预处理单张图像或一批图像。

Gemma3ImageProcessorFast

class transformers.Gemma3ImageProcessorFast

< >

( **kwargs: typing_extensions.Unpack[transformers.models.gemma3.image_processing_gemma3_fast.Gemma3FastImageProcessorKwargs] )

参数

  • do_resize (bool, optional, defaults to self.do_resize) — 是否将图像的 (height, width) 维度调整为指定的 size 大小。可以被 preprocess 方法中的 do_resize 参数覆盖。
  • size (dict, optional, defaults to self.size) — 调整大小后输出图像的尺寸。可以被 preprocess 方法中的 size 参数覆盖。
  • default_to_square (bool, optional, defaults to self.default_to_square) — 如果 size 是整数,是否在调整大小时默认使用正方形图像。
  • resample (PILImageResampling, optional, defaults to self.resample) — 如果调整图像大小,则使用的重采样滤波器。仅当 do_resize 设置为 True 时才生效。可以被 preprocess 方法中的 resample 参数覆盖。
  • do_center_crop (bool, optional, defaults to self.do_center_crop) — 是否将图像中心裁剪为指定的 crop_size 大小。可以被 preprocess 方法中的 do_center_crop 覆盖。
  • crop_size (Dict[str, int] optional, defaults to self.crop_size) — 应用 center_crop 后输出图像的尺寸。可以被 preprocess 方法中的 crop_size 覆盖。
  • do_rescale (bool, optional, defaults to self.do_rescale) — 是否按照指定的比例 rescale_factor 重新缩放图像。可以被 preprocess 方法中的 do_rescale 参数覆盖。
  • rescale_factor (intfloat, optional, defaults to self.rescale_factor) — 如果重新缩放图像,则使用的缩放因子。仅当 do_rescale 设置为 True 时才生效。可以被 preprocess 方法中的 rescale_factor 参数覆盖。
  • do_normalize (bool, optional, defaults to self.do_normalize) — 是否对图像进行归一化。可以被 preprocess 方法中的 do_normalize 参数覆盖。可以被 preprocess 方法中的 do_normalize 参数覆盖。
  • image_mean (floatList[float], optional, defaults to self.image_mean) — 如果要归一化图像,则使用的均值。这是一个浮点数或浮点数列表,其长度等于图像中的通道数。可以被 preprocess 方法中的 image_mean 参数覆盖。可以被 preprocess 方法中的 image_mean 参数覆盖。
  • image_std (floatList[float], optional, defaults to self.image_std) — 如果要归一化图像,则使用的标准差。这是一个浮点数或浮点数列表,其长度等于图像中的通道数。可以被 preprocess 方法中的 image_std 参数覆盖。可以被 preprocess 方法中的 image_std 参数覆盖。
  • do_convert_rgb (bool, optional, defaults to self.do_convert_rgb) — 是否将图像转换为 RGB 格式。
  • return_tensors (strTensorType, optional, defaults to self.return_tensors) — 如果设置为 `pt`,则返回堆叠的张量,否则返回张量列表。
  • data_format (ChannelDimensionstr, optional, defaults to self.data_format) — 仅支持 ChannelDimension.FIRST。为了与慢速处理器兼容而添加。
  • input_data_format (ChannelDimensionstr, optional, defaults to self.input_data_format) — 输入图像的通道维度格式。如果未设置,则通道维度格式从输入图像推断。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST:图像格式为 (height, width, num_channels)。
    • "none"ChannelDimension.NONE:图像格式为 (height, width)。
  • device (torch.device, 可选, 默认为 self.device) — 处理图像的设备。如果未设置,则设备从输入图像推断。
  • do_pan_and_scan (bool, 可选) — 是否对图像应用 pan_and_scan
  • pan_and_scan_min_crop_size (int, 可选) — 平移和扫描中每个裁剪的最小尺寸。
  • pan_and_scan_max_num_crops (int, 可选) — 平移和扫描中每张图像的最大裁剪数量。
  • pan_and_scan_min_ratio_to_activate (float, 可选) — 激活平移和扫描的最小宽高比。

构建快速 ConvNeXT 图像处理器。基于 SiglipImageProcessor,并结合了 Pan adn Scan 裁剪方法。

pan_and_scan

< >

( image: torch.Tensor pan_and_scan_min_crop_size: int pan_and_scan_max_num_crops: int pan_and_scan_min_ratio_to_activate: float )

参数

  • image (torch.Tensor) — 要调整大小的图像。
  • pan_and_scan_min_crop_size (int, 可选) — 平移和扫描中每个裁剪的最小尺寸。
  • pan_and_scan_max_num_crops (int, 可选) — 平移和扫描中每张图像的最大裁剪数量。
  • pan_and_scan_min_ratio_to_activate (float, 可选) — 激活平移和扫描的最小宽高比。

当宽高比超过允许的最小比率时,通过裁剪成较小的图像来平移和扫描图像。

preprocess

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] **kwargs: typing_extensions.Unpack[transformers.models.gemma3.image_processing_gemma3_fast.Gemma3FastImageProcessorKwargs] )

参数

  • images (ImageInput) — 要预处理的图像。 期望是像素值范围从 0 到 255 的单张或一批图像。如果传入的图像像素值在 0 到 1 之间,请设置 do_rescale=False
  • do_resize (bool, 可选, 默认为 self.do_resize) — 是否调整图像大小。
  • size (Dict[str, int], 可选, 默认为 self.size) — 描述模型的最大输入尺寸。
  • resample (PILImageResamplingInterpolationMode, 可选, 默认为 self.resample) — 如果在调整图像大小时使用的重采样过滤器。 这可以是枚举 PILImageResampling 之一。 仅在 do_resize 设置为 True 时有效。
  • do_center_crop (bool, 可选, 默认为 self.do_center_crop) — 是否对图像进行中心裁剪。
  • crop_size (Dict[str, int], 可选, 默认为 self.crop_size) — 应用 center_crop 后输出图像的大小。
  • 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, 可选, 默认为 self.return_tensors) — 如果设置为 `pt`,则返回堆叠的张量,否则返回张量列表。
  • data_format (ChannelDimensionstr, 可选, 默认为 self.data_format) — 仅支持 ChannelDimension.FIRST。 为了与慢速处理器兼容而添加。
  • input_data_format (ChannelDimensionstr, 可选, 默认为 self.input_data_format) — 输入图像的通道维度格式。 如果未设置,则通道维度格式从输入图像推断。 可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:(num_channels, height, width) 格式的图像。
    • "channels_last"ChannelDimension.LAST:(height, width, num_channels) 格式的图像。
    • "none"ChannelDimension.NONE:(height, width) 格式的图像。
  • device (torch.device, 可选, 默认为 self.device) — 处理图像的设备。如果未设置,则设备从输入图像推断。 do_pan_and_scan (bool, 可选): 是否对图像应用 pan_and_scan。 pan_and_scan_min_crop_size (int, 可选): 平移和扫描中每个裁剪的最小尺寸。 pan_and_scan_max_num_crops (int, 可选): 平移和扫描中每张图像的最大裁剪数量。 pan_and_scan_min_ratio_to_activate (float, 可选): 激活平移和扫描的最小宽高比。

预处理单张图像或一批图像。

Gemma3Processor

class transformers.Gemma3Processor

< >

( image_processor tokenizer chat_template = None image_seq_length: int = 256 **kwargs )

batch_decode

< >

( *args **kwargs )

This method forwards all its arguments to GemmaTokenizerFast’s batch_decode(). Please refer to the docstring of this method for more information.

decode

< >

( *args **kwargs )

This method forwards all its arguments to GemmaTokenizerFast’s decode(). Please refer to the docstring of this method for more information.

Gemma3TextConfig

class transformers.Gemma3TextConfig

< >

( vocab_size = 262208 hidden_size = 2304 intermediate_size = 9216 num_hidden_layers = 26 num_attention_heads = 8 num_key_value_heads = 4 head_dim = 256 hidden_activation = 'gelu_pytorch_tanh' max_position_embeddings = 131072 initializer_range = 0.02 rms_norm_eps = 1e-06 use_cache = True pad_token_id = 0 eos_token_id = 1 bos_token_id = 2 tie_word_embeddings = True rope_theta = 1000000.0 attention_bias = False attention_dropout = 0.0 query_pre_attn_scalar = 256 sliding_window = 4096 final_logit_softcapping = None attn_logit_softcapping = None cache_implementation = 'hybrid' rope_scaling = None rope_local_base_freq = 10000.0 sliding_window_pattern = 6 **kwargs )

参数

  • vocab_size (int, 可选, 默认为 262208) — Gemma3Text 模型的词汇表大小。定义了调用 Gemma3TextModel 时可以通过 inputs_ids 传递的不同 tokens 的数量。
  • hidden_size (int, 可选, 默认为 2304) — 隐藏层表示的维度。
  • intermediate_size (int, 可选, 默认为 9216) — MLP 表示的维度。
  • num_hidden_layers (int, 可选, 默认为 26) — Transformer 解码器中隐藏层的数量。
  • num_attention_heads (int, 可选, 默认为 8) — Transformer 解码器中每个注意力层的注意力头数。
  • num_key_value_heads (int, 可选, 默认为 4) — 这是应该用于实现分组查询注意力 (Grouped Query Attention) 的键值头 (key_value heads) 的数量。如果 num_key_value_heads=num_attention_heads,模型将使用多头注意力 (MHA);如果 num_key_value_heads=1,模型将使用多查询注意力 (MQA);否则将使用 GQA。当将多头检查点转换为 GQA 检查点时,每个组的键和值头应通过平均池化该组内的所有原始头来构建。有关更多详细信息,请查看 本文。如果未指定,则默认为 num_attention_heads
  • head_dim (int, 可选, 默认为 256) — 注意力头维度。
  • hidden_activation (strfunction, 可选, 默认为 "gelu_pytorch_tanh") — 解码器中的非线性激活函数(函数或字符串)。如果未指定,则默认为 "gelu_pytorch_tanh""gelu_pytorch_tanh" 使用 "gelu" 激活函数的近似值。
  • max_position_embeddings (int, 可选, 默认为 131072) — 此模型可能使用的最大序列长度。
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  • rms_norm_eps (float, 可选, 默认为 1e-06) — rms 归一化层使用的 epsilon 值。
  • use_cache (bool, 可选, 默认为 True) — 模型是否应返回最后一个键/值注意力(并非所有模型都使用)。仅当 config.is_decoder=True 时相关。
  • pad_token_id (int, 可选, 默认为 0) — 填充 token ID。
  • eos_token_id (int, 可选, 默认为 1) — 流结束 token ID。
  • bos_token_id (int, 可选, 默认为 2) — 流开始 token ID。
  • tie_word_embeddings (bool, 可选, 默认为 True) — 是否绑定权重嵌入
  • rope_theta (float, 可选, 默认为 1000000.0) — RoPE 嵌入的基本周期。
  • attention_bias (bool, 默认为 False, 可选, 默认为 False) — 在自注意力期间,是否在查询、键、值和输出投影层中使用偏置。
  • attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。
  • query_pre_attn_scalar (float, 可选, 默认为 256) — 注意力分数上使用的缩放因子。
  • sliding_window (int, 可选, 默认为 4096) — 在 Gemma3Text 中,每隔一层使用滑动窗口注意力机制。这是滑动窗口的大小。
  • final_logit_softcapping (float, 可选) — 在 logits 上应用 tanh 软截断时的缩放因子。
  • attn_logit_softcapping (float, 可选) — 在注意力分数上应用 tanh 软截断时的缩放因子。
  • cache_implementation (str, 可选, 默认为 "hybrid") — 与 generate 一起使用的缓存类型。
  • 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’。用于设置线性 ramp 函数中外推(仅限)边界的参数。 如果未指定,则默认为 32。 beta_slow (float, 可选): 仅用于 ‘yarn’。用于设置线性 ramp 函数中内插(仅限)边界的参数。 如果未指定,则默认为 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 高频分量的缩放因子。
  • rope_local_base_freq (float, 可选, 默认为 10000.0) — 用于局部注意力的 RoPE 嵌入的基 period。
  • sliding_window_pattern (int, 可选, 默认为 6) — 滑动窗口注意力的模式。

这是用于存储 Gemma3TextModel 配置的配置类。它用于根据指定的参数实例化 Gemma3Text 模型,定义模型架构。使用默认值实例化配置将产生与 Gemma3Text-7B 相似的配置。例如:google/gemma3_text-7b 配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

>>> from transformers import Gemma3TextModel, Gemma3TextConfig
>>> # Initializing a Gemma3Text gemma3_text-7b style configuration
>>> configuration = Gemma3TextConfig()
>>> # Initializing a model from the gemma3_text-7b style configuration
>>> model = Gemma3TextModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
rope_local_base_freq (float, *可选*, 默认为 10000.0): 用于局部注意力的 RoPE 嵌入的基 period。 sliding_window_pattern (`int`, *可选*, 默认为 6): 滑动窗口注意力的模式。

Gemma3Config

class transformers.Gemma3Config

< >

( text_config: typing.Optional[transformers.models.gemma3.configuration_gemma3.Gemma3TextConfig] = None vision_config: typing.Optional[transformers.models.siglip.configuration_siglip.SiglipVisionConfig] = None mm_tokens_per_image: int = 256 boi_token_index: int = 255999 eoi_token_index: int = 256000 image_token_index: int = 262144 initializer_range: float = 0.02 **kwargs )

参数

  • text_config (Union[Gemma3TextConfig, dict], 可选) — 文本骨干网络的配置对象。
  • vision_config (Union[AutoConfig, dict], 可选) — 自定义视觉配置或字典。
  • mm_tokens_per_image (int, 可选, 默认为 256) — 每个图像嵌入的 token 数量。
  • boi_token_index (int, 可选, 默认为 255999) — 用于包裹图像提示的 begin-of-image token 索引。
  • eoi_token_index (int, 可选, 默认为 256000) — 用于包裹图像提示的 end-of-image token 索引。
  • image_token_index (int, 可选, 默认为 262144) — 用于编码图像提示的图像 token 索引。
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

这是用于存储 Gemma3ForConditionalGeneration 配置的配置类。它用于根据指定的参数实例化 Gemma3ForConditionalGeneration,定义模型架构。使用默认值实例化配置将产生与 PaliGemma-2B 相似的配置。

例如:google/gemma-3-4b

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

示例

>>> from transformers import Gemma3ForConditionalGeneration, Gemma3Config, SiglipVisionConfig, Gemma3TextConfig

>>> # Initializing a Siglip-like vision config
>>> vision_config = SiglipVisionConfig()

>>> # Initializing a Gemma3 Text config
>>> text_config = Gemma3TextConfig()

>>> # Initializing a Gemma3 gemma-3-4b style configuration
>>> configuration = Gemma3Config(vision_config, text_config)

>>> # Initializing a model from the gemma-3-4b style configuration
>>> model = Gemma3TextConfig(configuration)

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

Gemma3TextModel

class transformers.Gemma3TextModel

< >

( config: Gemma3TextConfig )

参数

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

裸机 Gemma3Text 模型,输出原始隐藏状态,顶部没有任何特定的 head。 此模型继承自 PreTrainedModel。 查看超类文档以获取库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 head 等)。

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

Transformer 解码器,由 config.num_hidden_layers 层组成。 每层都是一个 Gemma3TextDecoderLayer

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[transformers.cache_utils.HybridCache] = 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 last_cache_position: typing.Optional[int] = None **flash_attn_kwargs: typing_extensions.Unpack[transformers.modeling_flash_attention_utils.FlashAttentionKwargs] )

参数

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

    索引可以使用 AutoTokenizer 获得。 请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call() 了解详情。

    什么是 input IDs?

  • attention_mask (torch.Tensor,形状为 (batch_size, sequence_length), 可选) — 用于避免在 padding token 索引上执行注意力的 Mask。 Mask 值在 [0, 1] 中选择:

    • 1 表示 token 未被 mask
    • 0 表示 token 已被 mask

    什么是 attention masks?

    索引可以使用 AutoTokenizer 获得。 请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call() 了解详情。

    如果使用 past_key_values,则可以选择仅输入最后一个 input_ids(请参阅 past_key_values)。

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

    • 1 表示 head 未被 mask
    • 0 表示 head 已被 mask
  • position_ids (torch.LongTensor,形状为 (batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列 token 的位置索引。 在范围 [0, config.n_positions - 1] 中选择。

    什么是 position IDs?

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

    允许两种格式:

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

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

    如果使用 past_key_values,用户可以选择仅输入最后一次的 input_ids(那些没有将其过去键值状态提供给此模型的输入),形状为 (batch_size, 1),而不是形状为 (batch_size, sequence_length) 的所有 input_ids

  • inputs_embeds (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更灵活地控制如何将 input_ids 索引转换为关联的向量,这将非常有用。
  • 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 相反,此张量不受填充的影响。 它用于在正确的位置更新缓存并推断完整的序列长度。

The Gemma3TextModel forward 方法,覆盖了 __call__ 特殊方法。

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

Gemma3ForCausalLM

class transformers.Gemma3ForCausalLM

< >

( config: Gemma3TextConfig )

forward

< >

( 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.HybridCache] = 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 **loss_kwargs ) transformers.modeling_outputs.CausalLMOutputWithPasttuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

  • attention_mask (torch.Tensor, 形状为 (batch_size, sequence_length), 可选) — 掩码,以避免对填充令牌索引执行注意力机制。 在 [0, 1] 中选择的掩码值:

    • 1 表示未掩码的令牌,
    • 0 表示已掩码的令牌。

    什么是注意力掩码?

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

    如果使用 past_key_values,则可以选择仅输入最后一次的 input_ids(请参阅 past_key_values)。

    如果您想更改填充行为,则应阅读 modeling_opt._prepare_decoder_attention_mask 并根据您的需求进行修改。 有关默认策略的更多信息,请参见 本文 中的图 1。

    • 1 表示头未被掩码
    • 0 表示头已被掩码
  • position_ids (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列标记的位置索引。 在范围 [0, config.n_positions - 1] 中选择。

    什么是位置 ID?

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

    允许两种格式:

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

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

    如果使用 past_key_values,用户可以选择仅输入最后一次的 input_ids(那些没有将其过去键值状态提供给此模型的输入),形状为 (batch_size, 1),而不是形状为 (batch_size, sequence_length) 的所有 input_ids

  • inputs_embeds (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更灵活地控制如何将 input_ids 索引转换为关联的向量,这将非常有用。
  • 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 (inttorch.Tensor, 可选) — 如果是 int 类型,则计算最后 logits_to_keep 个 token 的 logits。 如果是 0,则计算所有 input_ids 的 logits (特殊情况)。 生成时只需要最后一个 token 的 logits,并且仅为该 token 计算 logits 可以节省内存,这对于长序列或大词汇表大小来说非常重要。 如果是 torch.Tensor 类型,则必须是对应于序列长度维度中要保留的索引的 1D 张量。 当使用 packed tensor 格式(批次和序列长度的单个维度)时,这非常有用。

返回值

transformers.modeling_outputs.CausalLMOutputWithPasttuple(torch.FloatTensor)

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

  • 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 时返回) — tuple(torch.FloatTensor) 的元组,长度为 config.n_layers,每个元组有 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 之后的注意力权重,用于计算自注意力头中的加权平均值。

Gemma3ForCausalLM 的 forward 方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, Gemma3ForCausalLM

>>> model = Gemma3ForCausalLM.from_pretrained("google/gemma-2-9b")
>>> tokenizer = AutoTokenizer.from_pretrained("google/gemma-2-9b")

>>> prompt = "What is your favorite condiment?"
>>> inputs = tokenizer(prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"What is your favorite condiment?"

Gemma3ForConditionalGeneration

class transformers.Gemma3ForConditionalGeneration

< >

( config: Gemma3Config )

参数

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

GEMMA3 模型,由视觉骨干网络和语言模型组成。 此模型继承自 PreTrainedModel。 查看超类文档以获取库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝头等)。

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

forward

< >

( input_ids: LongTensor = None pixel_values: FloatTensor = 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 token_type_ids: typing.Optional[torch.LongTensor] = None cache_position: typing.Optional[torch.LongTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 **lm_kwargs ) transformers.models.gemma3.modeling_gemma3.Gemma3CausalLMOutputWithPasttuple(torch.FloatTensor)

参数

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

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

    什么是输入 IDs?

  • attention_mask (形状为 (batch_size, sequence_length)torch.Tensor, 可选) — 用于避免在 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 (形状为 (batch_size, sequence_length)torch.LongTensor, 可选) — 位置嵌入中每个输入序列 token 的位置索引。 在 [0, config.n_positions - 1] 范围内选择。

    什么是位置 IDs?

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

    允许两种格式:

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

    模型将输出与作为输入馈送的缓存格式相同的格式。 如果未传递 past_key_values,则将返回旧版缓存格式。

    如果使用 past_key_values,则用户可以选择仅输入最后一个 input_ids(那些没有将其 past key value 状态提供给此模型的)形状为 (batch_size, 1) 而不是所有形状为 (batch_size, sequence_length)input_ids

  • 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, 可选) — 是否返回所有注意力层的 attention 张量。 有关更多详细信息,请参见返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参见返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
  • cache_position (形状为 (sequence_length)torch.LongTensor, 可选) — 描述输入序列 token 在序列中位置的索引。 与 position_ids 相反,此张量不受 padding 的影响。 它用于在正确的位置更新缓存并推断完整的序列长度。
  • labels (形状为 (batch_size, sequence_length)torch.LongTensor, 可选) — 用于计算 masked language modeling loss 的标签。 索引应为 [0, ..., config.text_config.vocab_size] 或 -100 (请参阅 input_ids 文档字符串)。 索引设置为 -100 的 token 将被忽略(掩盖),loss 仅针对标签在 [0, ..., config.text_config.vocab_size] 中的 token 计算。
  • logits_to_keep (inttorch.Tensor, 可选) — 如果是 int 类型,则计算最后 logits_to_keep 个 token 的 logits。 如果是 0,则计算所有 input_ids 的 logits (特殊情况)。 生成时只需要最后一个 token 的 logits,并且仅为该 token 计算 logits 可以节省内存,这对于长序列或大词汇表大小来说非常重要。 如果是 torch.Tensor 类型,则必须是对应于序列长度维度中要保留的索引的 1D 张量。 当使用 packed tensor 格式(批次和序列长度的单个维度)时,这非常有用。

返回值

transformers.models.gemma3.modeling_gemma3.Gemma3CausalLMOutputWithPasttuple(torch.FloatTensor)

一个 transformers.models.gemma3.modeling_gemma3.Gemma3CausalLMOutputWithPast 或一个 torch.FloatTensor 的元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时),包含各种元素,具体取决于配置 (Gemma3Config) 和输入。

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

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

  • past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递 use_cache=True 或当 config.use_cache=True 时返回) — tuple(torch.FloatTensor) 的元组,长度为 config.n_layers,每个元组有 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 之后的注意力权重,用于计算自注意力头中的加权平均值。

  • image_hidden_states (torch.FloatTensor, 可选) — 形状为 (batch_size, sequence_length, hidden_size)torch.FloatTensor。 由视觉编码器在投影最后一个隐藏状态后生成的模型的 image_hidden_states。

Gemma3ForConditionalGeneration 的 forward 方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, Gemma3ForConditionalGeneration

>>> model = Gemma3ForConditionalGeneration.from_pretrained("google/Gemma3-test-224px-hf")
>>> processor = AutoProcessor.from_pretrained("google/Gemma3-test-224px-hf")

>>> prompt = "answer en Where is the cow standing?"
>>> url = "https://huggingface.co/gv-hf/Gemma3-test-224px-hf/resolve/main/cow_beach_1.png"
>>> image = Image.open(requests.get(url, stream=True).raw)

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

>>> # Generate
>>> generate_ids = model.generate(**inputs, max_length=30)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"answer en Where is the cow standing?\nbeach"
< > 在 GitHub 上更新