# Florence-2 ## 概述 [Florence-2](https://huggingface.co/papers/2311.06242) 是一款先进的视觉基础模型，采用基于提示的方法来处理广泛的视觉及视觉-语言任务。Florence-2 能够解释简单的文本提示，以执行图像描述、目标检测和分割等任务。它利用包含 1.26 亿张图像、共计 54 亿条标注的 FLD-5B 数据集，以掌握多任务学习。该模型的序列到序列架构使其在零样本和微调设置中均表现出色，证明其是一款具有竞争力的视觉基础模型。 您可以在 [Florence-2](https://huggingface.co/models?other=florence-2) 集合中找到所有原始的 Florence-2 检查点。 > [!TIP] > 该模型由 [ducviet00](https://huggingface.co/ducviet00) 贡献。点击右侧边栏中的 Florence-2 模型，以查看将 Florence-2 应用于不同视觉和语言任务的更多示例。 以下示例演示了如何使用 [Pipeline](/docs/transformers/main/zh/main_classes/pipelines#transformers.Pipeline) 或 [AutoModel](/docs/transformers/main/zh/model_doc/auto#transformers.AutoModel) 类执行目标检测。 ```python from transformers import pipeline pipeline = pipeline( "image-text-to-text", model="florence-community/Florence-2-base", device=0, ) pipeline( "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg?download=true", text="" ) ``` ```python import requests from PIL import Image from transformers import AutoProcessor, Florence2ForConditionalGeneration url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg?download=true" image = Image.open(requests.get(url, stream=True).raw).convert("RGB") model = Florence2ForConditionalGeneration.from_pretrained("florence-community/Florence-2-base", device_map="auto") processor = AutoProcessor.from_pretrained("florence-community/Florence-2-base") task_prompt = "" inputs = processor(text=task_prompt, images=image, return_tensors="pt").to(model.device) generated_ids = model.generate( **inputs, max_new_tokens=1024, num_beams=3, ) generated_text = processor.batch_decode(generated_ids, skip_special_tokens=False)[0] image_size = image.size parsed_answer = processor.post_process_generation(generated_text, task=task_prompt, image_size=image_size) print(parsed_answer) ``` 量化通过以较低精度表示权重来降低大模型的内存负担。有关更多可用的量化后端，请参阅 [量化](../quantization/overview) 概述。 以下示例使用 [bitsandbytes](../quantization/bitsandbytes) 将模型量化为 4-bit。 ```python # pip install bitsandbytes import requests import torch from PIL import Image from transformers import AutoProcessor, BitsAndBytesConfig, Florence2ForConditionalGeneration quantization_config = BitsAndBytesConfig(load_in_4bit=True) model = Florence2ForConditionalGeneration.from_pretrained( "florence-community/Florence-2-base", device_map="auto", quantization_config=quantization_config ) processor = AutoProcessor.from_pretrained("florence-community/Florence-2-base") url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg?download=true" image = Image.open(requests.get(url, stream=True).raw).convert("RGB") task_prompt = "" inputs = processor(text=task_prompt, images=image, return_tensors="pt").to(model.device, torch.bfloat16) generated_ids = model.generate( **inputs, max_new_tokens=1024, num_beams=3, ) generated_text = processor.batch_decode(generated_ids, skip_special_tokens=False)[0] image_size = image.size parsed_answer = processor.post_process_generation(generated_text, task=task_prompt, image_size=image_size) print(parsed_answer) ``` ## 备注 - Florence-2 是一个基于提示的模型。您需要提供一个任务提示来告诉模型要执行什么操作。支持的任务包括： - `` - `` - `` - `` - `` - `` - `` - `` - `` - `` - `` - `` - `` - `` - `` - 模型的原始输出是一个需要解析的字符串。[Florence2Processor](/docs/transformers/main/zh/model_doc/florence2#transformers.Florence2Processor) 提供了一个 `post_process_generation()` 方法，可以将该字符串解析为更易用的格式，例如用于目标检测的边界框和标签。 ## 资源 - [Florence-2 技术报告](https://huggingface.co/papers/2311.06242) - [用于 Florence-2-large 模型推理和可视化的 Jupyter Notebook](https://huggingface.co/microsoft/Florence-2-large/blob/main/sample_inference.ipynb) ## Florence2VisionConfig[[transformers.Florence2VisionConfig]] #### transformers.Florence2VisionConfig[[transformers.Florence2VisionConfig]] ```python transformers.Florence2VisionConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, in_channels: int = 3, depths: list[int] | tuple[int, ...] = (1, 1, 9, 1), patch_size: list[int] | tuple[int, ...] = (7, 3, 3, 3), patch_stride: list[int] | tuple[int, ...] = (4, 2, 2, 2), patch_padding: list[int] | tuple[int, ...] = (3, 1, 1, 1), patch_prenorm: list[bool] | tuple[bool, ...] = (False, True, True, True), embed_dim: list[int] | tuple[int, ...] = (128, 256, 512, 1024), num_heads: list[int] | tuple[int, ...] = (4, 8, 16, 32), num_groups: list[int] | tuple[int, ...] = (4, 8, 16, 32), window_size: int = 12, drop_path_rate: float | int = 0.1, mlp_ratio: float = 4.0, qkv_bias: bool = True, activation_function: str = 'gelu', projection_dim: int = 1024, max_temporal_embeddings: int = 100, max_position_embeddings: int = 50, initializer_range: float = 0.02) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/configuration_florence2.py#L29) **参数：** in_channels (`int`，*可选*，默认为 `3`)：输入通道数。 depths (`Tuple[int]`，*可选*，默认为 `(1, 1, 9, 1)`)：模型的深度。 patch_size (`Union[list[int], tuple[int, ...]]`，*可选*，默认为 `(7, 3, 3, 3)`)：每个 patch 的大小（分辨率）。 patch_stride (`Tuple[int]`，*可选*，默认为 `(4, 2, 2, 2)`)：图像的 patch 步长。 patch_padding (`Tuple[int]`，*可选*，默认为 `(3, 1, 1, 1)`)：图像的补丁填充。 patch_prenorm (`Tuple[bool]`，*可选*，默认为 `(False, True, True, True)`)：是否在 patch embedding 层之前应用层归一化。 embed_dim (`Union[list[int], tuple[int, ...]]`，*可选*，默认为 `(128, 256, 512, 1024)`)：嵌入和隐藏状态的维度。 num_heads (`Union[list[int], tuple[int, ...]]`，*可选*，默认为 `(4, 8, 16, 32)`)：Transformer 解码器中每个注意力层的注意力头数量。 num_groups (`Tuple[int]`，*可选*，默认为 `(4, 8, 16, 32)`)：组的数量。 window_size (`int`，*可选*，默认为 12)：模型的窗口大小。 drop_path_rate (`Union[float, int]`，*可选*，默认为 `0.1`)：用于 patch 融合的 drop path 比率。 mlp_ratio (`float`, *可选*, 默认为 `4.0`) : MLP 隐藏维度与嵌入维度的比率。 qkv_bias (`bool`，*可选*，默认为 `True`)：是否向查询、键和值添加偏置。 activation_function (`str`，*可选*，默认为 `gelu`)：解码器中的非线性激活函数（函数或字符串）。例如，`"gelu"`、`"relu"`、`"silu"` 等。 projection_dim (`int`，*可选*，默认为 `1024`)：文本和视觉投影层的维度。 max_temporal_embeddings (`int`，*可选*，默认为 100)：视觉时间嵌入的配置。 max_position_embeddings (`int`，*可选*，默认为 `50`)：该模型可能使用的最大序列长度。 initializer_range (`float`，*可选*，默认值为 `0.02`)：用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 这是用于存储 Florence2Model 配置的类。它根据指定的参数实例化 Florence2 模型，并定义模型架构。使用默认值实例化配置将生成与 [florence-community/Florence-2-base](https://huggingface.co/florence-community/Florence-2-base) 类似的配置。 配置对象继承自 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。 示例： ```python >>> from transformers import Florence2VisionConfig, Florence2VisionModel >>> # Initializing a Florence2 Vision style configuration >>> configuration = Florence2VisionConfig() >>> # Initializing a model (with random weights) >>> model = Florence2VisionModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Florence2Config[[transformers.Florence2Config]] #### transformers.Florence2Config[[transformers.Florence2Config]] ```python transformers.Florence2Config(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, image_token_id: int = 51289, tie_word_embeddings: bool = True) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/configuration_florence2.py#L85) **参数：** is_encoder_decoder (`bool`，*可选*，默认为 `True`)：模型是否用作编码器/解码器。 text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`，*可选*)：文本骨干网络的配置对象或字典。 vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`，*可选*)：视觉骨干网络的配置对象或字典。 image_token_id (`int`, *可选*, 默认为 `51289`) : 用作输入图像占位符的图像标记索引。 tie_word_embeddings (`bool`，*可选*，默认为 `True`)：是否根据模型的 `tied_weights_keys` 映射来绑定权重嵌入。 这是用于存储 Florence2Model 配置的类。它根据指定的参数实例化 Florence2 模型，并定义模型架构。使用默认值实例化配置将生成与 [florence-community/Florence-2-base](https://huggingface.co/florence-community/Florence-2-base) 类似的配置。 配置对象继承自 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。 示例： ```python >>> from transformers import Florence2ForConditionalGeneration, Florence2Config, CLIPVisionConfig, BartConfig >>> # Initializing a clip-like vision config >>> vision_config = CLIPVisionConfig() >>> # Initializing a Bart config >>> text_config = BartConfig() >>> # Initializing a Florence-2 configuration >>> configuration = Florence2Config(vision_config, text_config) >>> # Initializing a model from the florence-2 configuration >>> model = Florence2ForConditionalGeneration(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Florence2Processor[[transformers.Florence2Processor]] #### transformers.Florence2Processor[[transformers.Florence2Processor]] ```python transformers.Florence2Processor(image_processor = None, tokenizer = None, num_additional_image_tokens: int = 0, post_processor_config: dict | None = None, **kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/processing_florence2.py#L47) **参数：** image_processor (`CLIPImageProcessor`)：图像处理器是必需的输入。 tokenizer (`BartTokenizer`)：分词器是必需的输入。 num_additional_image_tokens (`int`，*可选*，默认为 0)：添加到图像嵌入中的额外标记数量，例如 CLS（+1）。如果主干网络没有附加 CLS 或其他额外标记，则无需设置此参数。 post_processor_config (`dict`, *可选*, 默认为 0) : `Florence2PostProcessor` 的任务特定解析规则，例如正则表达式模式、阈值或禁用标记。 构建一个 Florence2Processor，它将图像处理器和分词器封装为单一处理器。 [Florence2Processor](/docs/transformers/main/zh/model_doc/florence2#transformers.Florence2Processor) 提供了 [CLIPImageProcessor](/docs/transformers/main/zh/model_doc/clip#transformers.CLIPImageProcessor) 和 [BartTokenizer](/docs/transformers/main/zh/model_doc/led#transformers.RobertaTokenizer) 的所有功能。有关更多信息，请参阅 [~CLIPImageProcessor](/docs/transformers/main/zh/model_doc/clip#transformers.CLIPImageProcessor) 和 [~BartTokenizer](/docs/transformers/main/zh/model_doc/led#transformers.RobertaTokenizer)。 #### __调用__[[transformers.Florence2Processor.__call__]] ```python __call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | list[list[str]] | None = None, videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L653) **参数：** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *可选*) : 要预处理的图像。期望输入单张图像或一批图像，其像素值范围为 0 到 255。如果传入的图像像素值在 0 到 1 之间，请设置 `do_rescale=False`。 text (`Union[str, list[str], list[list[str]]]`，*可选*)：要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果传入预分词输入，请设置 `is_split_into_words=True` 以避免与批量输入产生歧义。 videos (`Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]`，*可选*)：要预处理的视频。期望输入单个视频或一批视频，其像素值范围为 0 到 255。如果传入的像素值在 0 到 1 之间，请设置 `do_rescale=False`。 audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`，*可选*)：要准备处理的音频或音频批次。每个音频可以是 NumPy 数组或 PyTorch 张量。对于 NumPy 数组/PyTorch 张量，每个音频的形状应为 (C, T)，其中 C 是通道数，T 是音频的采样长度。 return_tensors (`str` 或 [TensorType](/docs/transformers/main/zh/internal/file_utils#transformers.TensorType)，*可选*)：如果设置，将返回特定框架的张量。可接受的值为： - `'pt'`：返回 PyTorch `torch.Tensor` 对象。 - `'np'`：返回 NumPy `np.ndarray` 对象。 - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/zh/main_classes/processors#transformers.ProcessingKwargs), *可选*) : 针对每种模态（文本、图像、视频、音频）的额外处理选项。模型特定参数已在上方列出；有关支持参数的完整列表，请参阅 TypedDict 类。 ## Florence2Model[[transformers.Florence2Model]] #### transformers.Florence2Model[[transformers.Florence2Model]] ```python transformers.Florence2Model(config: Florence2Config) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L665) **参数：** config ([Florence2Config](/docs/transformers/main/zh/model_doc/florence2#transformers.Florence2Config))：模型配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。 Florence-2 是一个用于图像描述、目标检测和分割的视觉模型。 该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。 该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。 #### forward[[transformers.Florence2Model.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_outputs: list[torch.Tensor] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L714) **参数：** input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids) pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, image_size, image_size)`，*可选*) : 与输入图像对应的张量。可以使用 [CLIPImageProcessor](/docs/transformers/main/zh/model_doc/clip#transformers.CLIPImageProcessor) 获取像素值。有关详细信息，请参阅 [CLIPImageProcessor.__call__()](/docs/transformers/main/zh/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__)（[Florence2Processor](/docs/transformers/main/zh/model_doc/florence2#transformers.Florence2Processor) 使用 [CLIPImageProcessor](/docs/transformers/main/zh/model_doc/clip#transformers.CLIPImageProcessor) 处理图像）。 attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor`，形状为 `(batch_size, target_sequence_length)`，*可选*)：解码器输入序列中词元在词汇表中的索引。 可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。 有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。 [什么是解码器输入 ID？](../glossary#decoder-input-ids) decoder_attention_mask (`torch.LongTensor`，形状为 `(batch_size, target_sequence_length)`，*可选*)：用于避免对特定 token 索引执行注意力机制的掩码。默认情况下，会使用因果掩码，以确保模型只能查看之前的输入来预测未来。 decoder_inputs_embeds (`torch.Tensor`，形状为 `(batch_size, target_sequence_length, hidden_size)`，*可选*)：可选地，您可以选择直接传入嵌入表示，而不是传入 `decoder_input_ids`。如果使用了 `past_key_values`，则只需输入最后一段 `decoder_inputs_embeds`（参见 `past_key_values`）。如果您希望比模型内部的嵌入查找矩阵更精细地控制将 `decoder_input_ids` 索引转换为对应向量的方式，这将非常有用。如果 `decoder_input_ids` 和 `decoder_inputs_embeds` 均未设置，则 `decoder_inputs_embeds` 将取 `inputs_embeds` 的值。 encoder_outputs (`list[torch.Tensor]`, *可选*) : 由 (`last_hidden_state`, *可选*: `hidden_states`, *可选*: `attentions`) 组成的元组。`last_hidden_state` 的形状为 `(batch_size, sequence_length, hidden_size)`，*可选*) 是编码器最后一层输出的隐藏状态序列，用于解码器的交叉注意力机制。 past_key_values (`~cache_utils.Cache`，*可选*)：预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由模型在解码的先前阶段返回的 `past_key_values` 组成，前提是 `use_cache=True` 或 `config.use_cache=True`。 仅允许 [Cache](/docs/transformers/main/zh/internal/generation_utils#transformers.Cache) 实例作为输入，请参阅我们的 [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache)。如果未传入 `past_key_values`，则默认初始化 [DynamicCache](/docs/transformers/main/zh/internal/generation_utils#transformers.DynamicCache)。 模型将输出与输入相同的缓存格式。 如果使用 `past_key_values`，则用户预期仅输入未处理的 `input_ids`（即未向此模型提供其过去键值状态的那些），其形状为 `(batch_size, unprocessed_length)`，而不是形状为 `(batch_size, sequence_length)` 的所有 `input_ids`。 inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，你可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果你希望比模型内部的嵌入查找矩阵更精细地控制如何将 `input_ids` 索引转换为对应的向量，这将非常有用。 use_cache (`bool`，*可选*)：如果设置为 `True`，则会返回 `past_key_values` 键值状态，可用于加速解码（参见 `past_key_values`）。 **返回：** `Florence2Seq2SeqModelOutput` 或 `tuple(torch.Tensor)` `Florence2Seq2SeqModelOutput` 或 `torch.Tensor` 元组（如果传入 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[Florence2Config](/docs/transformers/main/zh/model_doc/florence2#transformers.Florence2Config)）和输入。 [Florence2Model](/docs/transformers/main/zh/model_doc/florence2#transformers.Florence2Model) 的 forward 方法会重写 `__call__` 特殊方法。 尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。 - **last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`）-- 模型解码器最后一层输出的隐藏状态序列。 如果使用了 `past_key_values`，则仅输出形状为 `(batch_size, 1, hidden_size)` 的序列的最后一个隐藏状态。 - **past_key_values**（`EncoderDecoderCache`，*可选*，在传入 `use_cache=True` 或 `config.use_cache=True` 时返回）-- 它是一个 [EncoderDecoderCache](/docs/transformers/main/zh/internal/generation_utils#transformers.EncoderDecoderCache) 实例。更多详情，请参阅我们的 [kv cache 指南](https://huggingface.co/docs/transformers/en/kv_cache)。 包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见 `past_key_values` 输入）加速顺序解码。 - **decoder_hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。 解码器在每一层输出处的隐藏状态，以及可选的初始嵌入输出。 - **decoder_attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。 解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。 - **cross_attentions** (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。 解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。 - **encoder_last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`，*可选*）-- 模型编码器最后一层输出的隐藏状态序列。 - **encoder_hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。 编码器每层输出处的隐藏状态，以及可选的初始嵌入输出。 - **encoder_attentions** (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。 编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。 - **image_hidden_states** (`torch.Tensor`，*可选*) -- 大小为 `(batch_size, num_image_tokens, hidden_size)` 的 `torch.Tensor`。由视觉编码器生成的模型 image_hidden_states，并在投影最后一个隐藏状态之后得到。 #### get_image_features[[transformers.Florence2Model.get_image_features]] ```python get_image_features(pixel_values: Tensor, **kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L674) **参数：** pixel_values (`torch.Tensor`，形状为 `(batch_size, channels, height, width)`)：与输入图像对应的张量。 **返回：** [BaseModelOutputWithPooling](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `tuple(torch.Tensor)` 一个 [BaseModelOutputWithPooling](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[Florence2Config](/docs/transformers/main/zh/model_doc/florence2#transformers.Florence2Config)）和输入。 从视觉塔获取图像的最后隐藏状态，并应用多模态投影。 - **last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`）-- 模型最后一层输出的隐藏状态序列。 - **pooler_output**（形状为 `(batch_size, hidden_size)` 的 `torch.Tensor`）-- 序列中第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后的结果。例如，对于 BERT 系列模型，这返回的是分类 token 经过线性层和 tanh 激活函数处理后的结果。线性层的权重是在预训练期间通过下一句预测（分类）目标训练得到的。 - **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。 模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。 - **attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。 经过注意力 softmax 后的注意力权重，用于在自注意力头中计算加权平均值。 ## Florence2ForConditionalGeneration[[transformers.Florence2ForConditionalGeneration]] #### transformers.Florence2ForConditionalGeneration[[transformers.Florence2ForConditionalGeneration]] ```python transformers.Florence2ForConditionalGeneration(config: Florence2Config) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L807) **参数：** config ([Florence2Config](/docs/transformers/main/zh/model_doc/florence2#transformers.Florence2Config))：模型配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。 Florence-2 是一个用于图像描述、目标检测和分割的视觉模型。 该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。 该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。 #### forward[[transformers.Florence2ForConditionalGeneration.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: list[torch.Tensor] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L828) **参数：** input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids) pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, image_size, image_size)`，*可选*) : 与输入图像对应的张量。可以使用 [CLIPImageProcessor](/docs/transformers/main/zh/model_doc/clip#transformers.CLIPImageProcessor) 获取像素值。有关详细信息，请参阅 [CLIPImageProcessor.__call__()](/docs/transformers/main/zh/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__)（[Florence2Processor](/docs/transformers/main/zh/model_doc/florence2#transformers.Florence2Processor) 使用 [CLIPImageProcessor](/docs/transformers/main/zh/model_doc/clip#transformers.CLIPImageProcessor) 处理图像）。 attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor`，形状为 `(batch_size, target_sequence_length)`，*可选*)：解码器输入序列中词元在词汇表中的索引。 可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。 有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。 [什么是解码器输入 ID？](../glossary#decoder-input-ids) decoder_attention_mask (`torch.LongTensor`，形状为 `(batch_size, target_sequence_length)`，*可选*)：用于避免对特定 token 索引执行注意力机制的掩码。默认情况下，会使用因果掩码，以确保模型只能查看之前的输入来预测未来。 encoder_outputs (`list[torch.Tensor]`, *可选*) : 由 (`last_hidden_state`, *可选*: `hidden_states`, *可选*: `attentions`) 组成的元组。`last_hidden_state` 的形状为 `(batch_size, sequence_length, hidden_size)`，*可选*) 是编码器最后一层输出的隐藏状态序列，用于解码器的交叉注意力机制。 past_key_values (`~cache_utils.Cache`，*可选*)：预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由模型在解码的先前阶段返回的 `past_key_values` 组成，前提是 `use_cache=True` 或 `config.use_cache=True`。 仅允许 [Cache](/docs/transformers/main/zh/internal/generation_utils#transformers.Cache) 实例作为输入，请参阅我们的 [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache)。如果未传入 `past_key_values`，则默认初始化 [DynamicCache](/docs/transformers/main/zh/internal/generation_utils#transformers.DynamicCache)。 模型将输出与输入相同的缓存格式。 如果使用 `past_key_values`，则用户预期仅输入未处理的 `input_ids`（即未向此模型提供其过去键值状态的那些），其形状为 `(batch_size, unprocessed_length)`，而不是形状为 `(batch_size, sequence_length)` 的所有 `input_ids`。 inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，你可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果你希望比模型内部的嵌入查找矩阵更精细地控制如何将 `input_ids` 索引转换为对应的向量，这将非常有用。 decoder_inputs_embeds (`torch.Tensor`，形状为 `(batch_size, target_sequence_length, hidden_size)`，*可选*)：可选地，您可以选择直接传入嵌入表示，而不是传入 `decoder_input_ids`。如果使用了 `past_key_values`，则只需输入最后一段 `decoder_inputs_embeds`（参见 `past_key_values`）。如果您希望比模型内部的嵌入查找矩阵更精细地控制将 `decoder_input_ids` 索引转换为对应向量的方式，这将非常有用。如果 `decoder_input_ids` 和 `decoder_inputs_embeds` 均未设置，则 `decoder_inputs_embeds` 将取 `inputs_embeds` 的值。 labels (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于计算掩码语言建模损失的标签。索引值应在 `[0, ..., config.vocab_size]` 范围内，或为 -100（参见 `input_ids` 的文档字符串）。索引值设为 `-100` 的 token 将被忽略（即被掩码），损失仅针对标签在 `[0, ..., config.vocab_size]` 范围内的 token 进行计算。 use_cache (`bool`，*可选*)：如果设置为 `True`，则会返回 `past_key_values` 键值状态，可用于加速解码（参见 `past_key_values`）。 logits_to_keep (`Union[int, torch.Tensor]`，*可选*，默认为 `0`)：如果为 `int`，则计算最后 `logits_to_keep` 个 token 的 logits。如果为 `0`，则计算所有 `input_ids` 的 logits（特殊情况）。生成过程只需要最后一个 token 的 logits，仅针对该 token 进行计算可以节省内存，对于长序列或大词汇量而言，这种节省相当可观。如果为 `torch.Tensor`，则必须是一维张量，对应于序列长度维度中需要保留的索引。这在使用打包张量格式（将批次和序列长度合并为单一维度）时非常有用。 **返回：** `Florence2Seq2SeqLMOutput` 或 `tuple(torch.Tensor)` `Florence2Seq2SeqLMOutput` 或 `torch.Tensor` 元组（如果传入 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[Florence2Config](/docs/transformers/main/zh/model_doc/florence2#transformers.Florence2Config)）和输入。 [Florence2ForConditionalGeneration](/docs/transformers/main/zh/model_doc/florence2#transformers.Florence2ForConditionalGeneration) 的 forward 方法重写了 `__call__` 特殊方法。 尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。 - **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，当提供 `labels` 时返回) -- 语言建模损失（用于下一个 token 预测）。 - **logits**（形状为 `(batch_size, sequence_length, config.vocab_size)` 的 `torch.Tensor`）-- 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。 - **past_key_values**（`EncoderDecoderCache`，*可选*，在传入 `use_cache=True` 或 `config.use_cache=True` 时返回）-- 它是一个 [EncoderDecoderCache](/docs/transformers/main/zh/internal/generation_utils#transformers.EncoderDecoderCache) 实例。更多详情，请参阅我们的 [kv cache 指南](https://huggingface.co/docs/transformers/en/kv_cache)。 包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见 `past_key_values` 输入）加速顺序解码。 - **decoder_hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。 解码器在每一层输出处的隐藏状态，以及初始嵌入输出。 - **decoder_attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。 解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。 - **cross_attentions** (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。 解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。 - **encoder_last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`，*可选*）-- 模型编码器最后一层输出的隐藏状态序列。 - **encoder_hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。 编码器在每一层输出处的隐藏状态，以及初始嵌入输出。 - **encoder_attentions** (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。 编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。 - **image_hidden_states** (`torch.Tensor`，*可选*) -- 大小为 `(batch_size, num_image_tokens, hidden_size)` 的 `torch.Tensor`。由视觉编码器生成的模型 image_hidden_states，并在投影最后一个隐藏状态之后得到。 示例： ```python >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import AutoProcessor, Florence2ForConditionalGeneration >>> model = Florence2ForConditionalGeneration.from_pretrained("florence-community/Florence-2-large") >>> processor = AutoProcessor.from_pretrained("florence-community/Florence-2-large") >>> prompt = "" >>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> inputs = processor(text=prompt, images=image, return_tensors="pt") >>> # Generate >>> generate_ids = model.generate(**inputs, max_length=100) >>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0] "A green car parked in front of a yellow building." ``` #### get_image_features[[transformers.Florence2ForConditionalGeneration.get_image_features]] ```python get_image_features(pixel_values: Tensor, **kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L822) **参数：** pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, image_size, image_size)`)：与输入图像对应的张量。可以使用 [CLIPImageProcessor](/docs/transformers/main/zh/model_doc/clip#transformers.CLIPImageProcessor) 获取像素值。有关详细信息，请参阅 [CLIPImageProcessor.__call__()](/docs/transformers/main/zh/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__)（[Florence2Processor](/docs/transformers/main/zh/model_doc/florence2#transformers.Florence2Processor) 使用 [CLIPImageProcessor](/docs/transformers/main/zh/model_doc/clip#transformers.CLIPImageProcessor) 处理图像）。 **返回：** [BaseModelOutputWithPooling](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `tuple(torch.Tensor)` 一个 [BaseModelOutputWithPooling](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[Florence2Config](/docs/transformers/main/zh/model_doc/florence2#transformers.Florence2Config)）和输入。 - **last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`）-- 模型最后一层输出的隐藏状态序列。 - **pooler_output**（形状为 `(batch_size, hidden_size)` 的 `torch.Tensor`）-- 序列中第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后的结果。例如，对于 BERT 系列模型，这返回的是分类 token 经过线性层和 tanh 激活函数处理后的结果。线性层的权重是在预训练期间通过下一句预测（分类）目标训练得到的。 - **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。 模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。 - **attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。 经过注意力 softmax 后的注意力权重，用于在自注意力头中计算加权平均值。 示例： ```python >>> from PIL import Image >>> from transformers import AutoProcessor, Florence2ForConditionalGeneration >>> model = Florence2ForConditionalGeneration.from_pretrained("florence-community/Florence-2-base") >>> processor = AutoProcessor.from_pretrained("florence-community/Florence-2-base") >>> messages = [ ... { ... "role": "user", "content": [ ... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"}, ... {"type": "text", "text": "Where is the cat standing?"}, ... ] ... }, ... ] >>> inputs = processor.apply_chat_template( ... messages, ... tokenize=True, ... return_dict=True, ... return_tensors="pt", ... add_generation_prompt=True ... ) >>> # Generate >>> generate_ids = model.generate(**inputs) >>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0] ``` ## Florence2VisionBackbone[[transformers.Florence2VisionBackbone]] #### transformers.Florence2VisionBackbone[[transformers.Florence2VisionBackbone]] ```python transformers.Florence2VisionBackbone(config: Florence2VisionConfig) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L504) **参数：** config ([Florence2VisionConfig](/docs/transformers/main/zh/model_doc/florence2#transformers.Florence2VisionConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化并不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。 Florence2 主干网络。 该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。 该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。 #### forward[[transformers.Florence2VisionBackbone.forward]] ```python forward(hidden_states: Tensor, **kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/florence2/modeling_florence2.py#L551)