Transformers 文档
Gemma3
并获得增强的文档体验
开始使用
Gemma3
概述
Gemma 3 模型由 Google 在 Gemma 3 Techncial Report 中提出。它是一个视觉-语言模型,由 SigLIP 视觉编码器和 Gemma 2 语言解码器组成,通过多模态线性投影连接。它将图像切割成固定数量的 tokens,方式与 SigLIP 相同,只要图像不超过一定的宽高比。对于超过给定宽高比的图像,它会将图像裁剪成多个较小的 patches,并将它们与基本图像嵌入连接起来。一个特点是该模型在所有图像 tokens 上使用双向注意力。此外,该模型在语言 backbone 中交错使用滑动窗口局部注意力和完全因果注意力,其中每六层是一个完全因果注意力层。
此模型由 Ryan Mullins、Raushan Turganbay Arthur Zucker 和 Pedro 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 (
int
或float
, 可选, 默认为1/255
) — 如果重新缩放图像,则使用的比例因子。可以被preprocess
方法中的rescale_factor
参数覆盖。 - do_normalize (
bool
, 可选, 默认为True
) — 是否通过指定的均值和标准差来标准化图像。可以被preprocess
方法中的do_normalize
参数覆盖。 - image_mean (
float
或List[float]
, 可选, 默认为[0.5, 0.5, 0.5]
) — 如果标准化图像,则使用的均值。这是一个浮点数或浮点数列表,其长度等于图像中的通道数。可以被preprocess
方法中的image_mean
参数覆盖。 - image_std (
float
或List[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 (
str
或ChannelDimension
, 可选) — 图像的通道维度格式。如果未提供,则与输入图像相同。 - input_data_format (
ChannelDimension
或str
, 可选) — 输入图像的通道维度格式。如果未提供,则会进行推断。
当宽高比超过最小允许比率时,通过裁剪成更小的图像来进行 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 toself.do_rescale
) — 是否对图像进行重新缩放。 - rescale_factor (
float
, optional, defaults toself.rescale_factor
) — 重新缩放因子,如果do_rescale
设置为True
,则通过该因子重新缩放图像。 - do_normalize (
bool
, optional, defaults toself.do_normalize
) — 是否对图像进行归一化。 - image_mean (
float
或List[float]
, optional, defaults toself.image_mean
) — 用于归一化的图像均值。仅当do_normalize
设置为True
时才生效。 - image_std (
float
或List[float]
, optional, defaults toself.image_std
) — 用于归一化的图像标准差。仅当do_normalize
设置为True
时才生效。 - return_tensors (
str
或TensorType
, 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 (
ChannelDimension
或str
, optional, defaults toChannelDimension.FIRST
) — 输出图像的通道维度格式。可以是以下之一:"channels_first"
或ChannelDimension.FIRST
:图像格式为 (num_channels, height, width)。"channels_last"
或ChannelDimension.LAST
:图像格式为 (height, width, num_channels)。- 未设置:使用输入图像的通道维度格式。
- input_data_format (
ChannelDimension
或str
, 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 toself.do_convert_rgb
) — 是否将图像转换为 RGB 格式。 - do_pan_and_scan (
bool
, optional, defaults toself.do_convert_rgb
) — 是否对图像应用pan_and_scan
。 - pan_and_scan_min_crop_size (
int
, optional, defaults toself.pan_and_scan_min_crop_size
) — pan and scan 中每个裁剪区域的最小尺寸。 - pan_and_scan_max_num_crops (
int
, optional, defaults toself.pan_and_scan_max_num_crops
) — pan and scan 中每个图像的最大裁剪区域数量。 - pan_and_scan_min_ratio_to_activate (
float
, optional, defaults toself.pan_and_scan_min_ratio_to_activate
) — 激活 pan and scan 的最小宽高比。
预处理单张图像或一批图像。
Gemma3ImageProcessorFast
class transformers.Gemma3ImageProcessorFast
< source >( **kwargs: typing_extensions.Unpack[transformers.models.gemma3.image_processing_gemma3_fast.Gemma3FastImageProcessorKwargs] )
参数
- do_resize (
bool
, optional, defaults toself.do_resize
) — 是否将图像的 (height, width) 维度调整为指定的size
大小。可以被preprocess
方法中的do_resize
参数覆盖。 - size (
dict
, optional, defaults toself.size
) — 调整大小后输出图像的尺寸。可以被preprocess
方法中的size
参数覆盖。 - default_to_square (
bool
, optional, defaults toself.default_to_square
) — 如果 size 是整数,是否在调整大小时默认使用正方形图像。 - resample (
PILImageResampling
, optional, defaults toself.resample
) — 如果调整图像大小,则使用的重采样滤波器。仅当do_resize
设置为True
时才生效。可以被preprocess
方法中的resample
参数覆盖。 - do_center_crop (
bool
, optional, defaults toself.do_center_crop
) — 是否将图像中心裁剪为指定的crop_size
大小。可以被preprocess
方法中的do_center_crop
覆盖。 - crop_size (
Dict[str, int]
optional, defaults toself.crop_size
) — 应用center_crop
后输出图像的尺寸。可以被preprocess
方法中的crop_size
覆盖。 - do_rescale (
bool
, optional, defaults toself.do_rescale
) — 是否按照指定的比例rescale_factor
重新缩放图像。可以被preprocess
方法中的do_rescale
参数覆盖。 - rescale_factor (
int
或float
, optional, defaults toself.rescale_factor
) — 如果重新缩放图像,则使用的缩放因子。仅当do_rescale
设置为True
时才生效。可以被preprocess
方法中的rescale_factor
参数覆盖。 - do_normalize (
bool
, optional, defaults toself.do_normalize
) — 是否对图像进行归一化。可以被preprocess
方法中的do_normalize
参数覆盖。可以被preprocess
方法中的do_normalize
参数覆盖。 - image_mean (
float
或List[float]
, optional, defaults toself.image_mean
) — 如果要归一化图像,则使用的均值。这是一个浮点数或浮点数列表,其长度等于图像中的通道数。可以被preprocess
方法中的image_mean
参数覆盖。可以被preprocess
方法中的image_mean
参数覆盖。 - image_std (
float
或List[float]
, optional, defaults toself.image_std
) — 如果要归一化图像,则使用的标准差。这是一个浮点数或浮点数列表,其长度等于图像中的通道数。可以被preprocess
方法中的image_std
参数覆盖。可以被preprocess
方法中的image_std
参数覆盖。 - do_convert_rgb (
bool
, optional, defaults toself.do_convert_rgb
) — 是否将图像转换为 RGB 格式。 - return_tensors (
str
或TensorType
, optional, defaults toself.return_tensors
) — 如果设置为 `pt`,则返回堆叠的张量,否则返回张量列表。 - data_format (
ChannelDimension
或str
, optional, defaults toself.data_format
) — 仅支持ChannelDimension.FIRST
。为了与慢速处理器兼容而添加。 - input_data_format (
ChannelDimension
或str
, optional, defaults toself.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
< source >( 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
< source >( 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 (
PILImageResampling
或InterpolationMode
, 可选, 默认为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 (
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 格式。 - return_tensors (
str
或TensorType
, 可选, 默认为self.return_tensors
) — 如果设置为 `pt`,则返回堆叠的张量,否则返回张量列表。 - data_format (
ChannelDimension
或str
, 可选, 默认为self.data_format
) — 仅支持ChannelDimension.FIRST
。 为了与慢速处理器兼容而添加。 - input_data_format (
ChannelDimension
或str
, 可选, 默认为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
< source >( image_processor tokenizer chat_template = None image_seq_length: int = 256 **kwargs )
This method forwards all its arguments to GemmaTokenizerFast’s batch_decode(). Please refer to the docstring of this method for more information.
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
< source >( 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 (
str
或function
, 可选, 默认为"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
Gemma3Config
class transformers.Gemma3Config
< source >( 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 相似的配置。
配置对象继承自 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
< source >( 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
< 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.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() 了解详情。
- attention_mask (
torch.Tensor
,形状为(batch_size, sequence_length)
, 可选) — 用于避免在 padding token 索引上执行注意力的 Mask。 Mask 值在[0, 1]
中选择:- 1 表示 token 未被 mask,
- 0 表示 token 已被 mask。
索引可以使用 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]
中选择。 - past_key_values (
Cache
或tuple(tuple(torch.FloatTensor))
, 可选) — 预先计算的隐藏状态(自注意力模块和交叉注意力模块中的键和值),可用于加速顺序解码。这通常包含模型在先前解码阶段返回的past_key_values
,当use_cache=True
或config.use_cache=True
时。允许两种格式:
- Cache 实例,请参阅我们的 kv 缓存指南;
- 长度为
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)
,而不是形状为(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
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.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.CausalLMOutputWithPast 或 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 表示已掩码的令牌。
可以使用 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]
中选择。 - past_key_values (
Cache
或tuple(tuple(torch.FloatTensor))
, 可选) — 预先计算的隐藏状态(自注意力模块和交叉注意力模块中的键和值),可用于加速顺序解码。这通常包含模型在先前解码阶段返回的past_key_values
,当use_cache=True
或config.use_cache=True
时。允许两种格式:
- Cache 实例,请参阅我们的 kv 缓存指南;
- 长度为
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)
,而不是形状为(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
个 token 的 logits。 如果是0
,则计算所有input_ids
的 logits (特殊情况)。 生成时只需要最后一个 token 的 logits,并且仅为该 token 计算 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
时),包含各种元素,具体取决于配置 (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
< source >( config: Gemma3Config )
参数
- config (Gemma3Config) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重,仅加载配置。 查看 from_pretrained() 方法来加载模型权重。
GEMMA3 模型,由视觉骨干网络和语言模型组成。 此模型继承自 PreTrainedModel。 查看超类文档以获取库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝头等)。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块,并参考 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( 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.Gemma3CausalLMOutputWithPast
或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)
的torch.LongTensor
) — 词汇表中输入序列 token 的索引。 默认情况下,如果您提供 padding,则会被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- 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]
范围内选择。 - past_key_values (
Cache
或tuple(tuple(torch.FloatTensor))
, 可选) — 预先计算的隐藏状态(自注意力模块和交叉注意力模块中的键和值),可以用于加速顺序解码。 这通常包括模型在先前解码阶段返回的past_key_values
,当use_cache=True
或config.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 (
int
或torch.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.Gemma3CausalLMOutputWithPast
或 tuple(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"