# FLAVA

## 概述

FLAVA 模型由 Amanpreet Singh、Ronghang Hu、Vedanuj Goswami、Guillaume Couairon、Wojciech Galuba、Marcus Rohrbach 和 Douwe Kiela 在 [FLAVA: A Foundational Language And Vision Alignment Model](https://huggingface.co/papers/2112.04482) 中提出，并被 CVPR 2022 接收。

该论文旨在构建一个统一的单一基础模型，使其能够跨视觉、语言以及视觉-语言多模态任务运行。

该论文的摘要如下：

*最先进的视觉及视觉-语言模型依赖于大规模视觉-语言预训练，以在多种下游任务上取得良好性能。通常，此类模型要么是跨模态（对比式）的，要么是多模态（早期融合）的，但很少两者兼备；并且它们往往只针对特定的模态或任务。一个有前景的方向是使用单一的、整体的通用模型作为“基础”，同时面向所有模态——一个真正的视觉与语言基础模型应当在视觉任务、语言任务以及跨模态和多模态的视觉-语言任务上均表现出色。我们提出了 FLAVA 作为这样一个模型，并在涵盖这些目标模态的 35 项广泛任务上展示了令人印象深刻的性能。*

该模型由 [aps](https://huggingface.co/aps) 贡献。原始代码可在[此处](https://github.com/facebookresearch/multimodal/tree/main/examples/flava)找到。

## FlavaConfig[[transformers.FlavaConfig]]

#### transformers.FlavaConfig[[transformers.FlavaConfig]]

```python
transformers.FlavaConfig(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, image_config: dict[str, typing.Any] | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict[str, typing.Any] | transformers.configuration_utils.PreTrainedConfig | None = None, multimodal_config: dict[str, typing.Any] | transformers.configuration_utils.PreTrainedConfig | None = None, image_codebook_config: dict[str, typing.Any] | transformers.configuration_utils.PreTrainedConfig | None = None, hidden_size: int = 768, layer_norm_eps: float = 1e-12, projection_dim: int = 768, init_codebook: bool = True, logit_scale_init_value: float = 2.6592, initializer_range: float = 0.02, ce_ignore_index: int = -100, mim_weight: float = 1.0, mlm_weight: float = 1.0, global_contrastive_weight: float = 1.0, itm_weight: float = 1.0, mmm_image_weight: float = 1.0, mmm_text_weight: float = 1.0, global_backprop_contrastive: bool = True, skip_unmasked_multimodal_encoder: bool = True, return_loss: bool = True, tie_word_embeddings: bool = True, initializer_factor: float = 1.0)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/configuration_flava.py#L185)

**参数：**

image_config (`dict`, *可选*) : 用于初始化 [FlavaImageConfig](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageConfig) 的配置选项字典。

text_config (`Union[dict[str, Any], ~configuration_utils.PreTrainedConfig]`, *可选*) : 文本骨干网络的配置对象或字典。

multimodal_config (`dict`, *可选*) : 用于初始化 [FlavaMultimodalConfig](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaMultimodalConfig) 的配置选项字典。

image_codebook_config (`dict`, *可选*) : 用于初始化 `FlavaCodebookConfig` 的配置选项字典。

hidden_size (`int`，*可选*，默认为 `768`)：隐藏表示的维度。

layer_norm_eps (`float`, *可选*，默认为 `1e-12`)：层归一化层所使用的 epsilon。

projection_dim (`int`，*可选*，默认为 `768`)：文本和视觉投影层的维度。

init_codebook (`bool`, *可选*, 默认为 `True`) : 是否初始化码本

logit_scale_init_value (`float`, *可选*，默认为 2.6592)：*logit_scale* 参数的初始值。默认值遵循原始 FLAVA/CLIP 实现。

initializer_range (`float`，*可选*，默认值为 `0.02`)：用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

ce_ignore_index (`int`，*可选*，默认为 -100)：要忽略的交叉熵索引。

mim_weight (`float`, *可选*，默认为 1.0)：分配给 MIM（Masked Image Modeling）单模态损失的权重

mlm_weight (`float`, *可选*，默认为 1.0)：分配给 MLM（Masked Language Modeling）单模态损失的权重

global_contrastive_weight (`float`, *可选*, 默认值为 1.0) : 分配给全局对比交叉对齐损失的权重。

itm_weight (`float`, *可选*, 默认值为 1.0) : 分配给图文匹配多模态损失的权重。

mmm_image_weight (`float`, *可选*, 默认为 1.0) : 分配给 MMM 损失中图像部分的权重。

mmm_text_weight (`float`, *可选*, 默认值为 1.0) : 分配给 MMM 损失文本部分的权重。

global_backprop_contrastive (`bool`, *可选*, 默认为 `True`) : 是否在对数损失中使用全局反向传播，贯穿所有工作进程。

skip_unmasked_multimodal_encoder (`bool`，*可选*，默认为 `True`)：是否跳过运行其输出未被 FLAVA 损失使用的未掩码多模态编码器。

return_loss (`bool`，*可选*，默认为 `True`)：是否返回损失

tie_word_embeddings (`bool`，*可选*，默认为 `True`)：是否根据模型的 `tied_weights_keys` 映射来绑定权重嵌入。

initializer_factor (`float`, *可选*，默认为 `1.0`)：用于初始化所有权重矩阵的系数（应保持为 1，内部用于初始化测试）。

这是用于存储 FlavaModel 配置的类。它根据指定的参数实例化 Flava 模型，并定义模型架构。使用默认值实例化配置将生成与 [facebook/flava-full](https://huggingface.co/facebook/flava-full) 类似的配置。

配置对象继承自 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。

示例：

```python
>>> from transformers import FlavaConfig, FlavaModel, FlavaForPreTraining

>>> # Initializing a FlavaConfig with style configuration
>>> configuration = FlavaConfig()

>>> # Initializing a FlavaModel and FlavaForPreTraining model (with random weights) from the style configuration
>>> model = FlavaModel(configuration)
>>> model_pre = FlavaForPreTraining(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
>>> configuration_pre = model_pre.config
```

## FlavaTextConfig[[transformers.FlavaTextConfig]]

#### transformers.FlavaTextConfig[[transformers.FlavaTextConfig]]

```python
transformers.FlavaTextConfig(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, vocab_size: int = 30522, type_vocab_size: int = 2, max_position_embeddings: int = 512, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.0, attention_probs_dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, qkv_bias: bool = True)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/configuration_flava.py#L71)

**参数：**

vocab_size (`int`，*可选*，默认值为 `30522`)：模型的词汇表大小。定义了 `input_ids` 可以表示的不同 token 数量。

type_vocab_size (`int`，*可选*，默认为 `2`)：`token_type_ids` 的词汇表大小。

max_position_embeddings (`int`，*可选*，默认值为 `512`)：该模型可能使用的最大序列长度。

hidden_size (`int`，*可选*，默认为 `768`)：隐藏表示的维度。

num_hidden_layers (`int`，*可选*，默认为 `12`)：Transformer 解码器中的隐藏层数。

num_attention_heads (`int`，*可选*，默认为 `12`)：Transformer 解码器中每个注意力层的注意力头数量。

intermediate_size (`int`，*可选*，默认值为 `3072`)：MLP 表示的维度。

hidden_act (`str`，*可选*，默认为 `gelu`)：解码器中的非线性激活函数（函数或字符串）。例如，`"gelu"`、`"relu"`、`"silu"` 等。

hidden_dropout_prob (`Union[float, int]`，*可选*，默认值为 `0.0`)：嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

attention_probs_dropout_prob (`Union[float, int]`，*可选*，默认值为 `0.0`)：注意力概率的 dropout 比率。

initializer_range (`float`，*可选*，默认值为 `0.02`)：用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

layer_norm_eps (`float`, *可选*，默认为 `1e-12`)：层归一化层所使用的 epsilon。

pad_token_id (`int`，*可选*，默认为 `0`)：词表中用于填充的 Token ID。

qkv_bias (`bool`，*可选*，默认为 `True`)：是否向查询、键和值添加偏置。

这是用于存储 FlavaModel 配置的类。它根据指定的参数实例化 Flava 模型，并定义模型架构。使用默认值实例化配置将生成与 [facebook/flava-full](https://huggingface.co/facebook/flava-full) 类似的配置。

配置对象继承自 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。

示例：

```python
>>> from transformers import FlavaTextConfig, FlavaTextModel

>>> # Initializing a FlavaTextModel with  style configuration
>>> configuration = FlavaTextConfig()

>>> # Initializing a FlavaTextModel model (with random weights) from the style configuration
>>> model = FlavaTextModel(configuration)

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

## FlavaImageConfig[[transformers.FlavaImageConfig]]

#### transformers.FlavaImageConfig[[transformers.FlavaImageConfig]]

```python
transformers.FlavaImageConfig(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, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.0, attention_probs_dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, image_size: int | list[int] | tuple[int, int] = 224, patch_size: int | list[int] | tuple[int, int] = 16, num_channels: int = 3, qkv_bias: bool = True, mask_token: bool = True, vocab_size: int = 8192)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/configuration_flava.py#L29)

**参数：**

hidden_size (`int`，*可选*，默认为 `768`)：隐藏表示的维度。

num_hidden_layers (`int`，*可选*，默认为 `12`)：Transformer 解码器中的隐藏层数。

num_attention_heads (`int`，*可选*，默认为 `12`)：Transformer 解码器中每个注意力层的注意力头数量。

intermediate_size (`int`，*可选*，默认值为 `3072`)：MLP 表示的维度。

hidden_act (`str`，*可选*，默认为 `gelu`)：解码器中的非线性激活函数（函数或字符串）。例如，`"gelu"`、`"relu"`、`"silu"` 等。

hidden_dropout_prob (`Union[float, int]`，*可选*，默认值为 `0.0`)：嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

attention_probs_dropout_prob (`Union[float, int]`，*可选*，默认值为 `0.0`)：注意力概率的 dropout 比率。

initializer_range (`float`，*可选*，默认值为 `0.02`)：用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

layer_norm_eps (`float`, *可选*，默认为 `1e-12`)：层归一化层所使用的 epsilon。

image_size (`Union[int, list[int], tuple[int, int]]`，*可选*，默认为 `224`)：每张图片的尺寸（分辨率）。

patch_size (`Union[int, list[int], tuple[int, int]]`，*可选*，默认为 `16`)：每个 patch 的大小（分辨率）。

num_channels (`int`，*可选*，默认为 `3`)：输入通道数。

qkv_bias (`bool`，*可选*，默认为 `True`)：是否向查询、键和值添加偏置。

mask_token (`bool`, *可选*, 默认为 `True`) : 是否使用掩码 token。用于 FLAVA 的 MIM（Masked Image Modeling）损失。

vocab_size (`int`，*可选*，默认为 `8192`)：模型的词汇表大小。定义了 `input_ids` 可以表示的不同 token 数量。

这是用于存储 FlavaModel 配置的类。它根据指定的参数实例化 Flava 模型，并定义模型架构。使用默认值实例化配置将生成与 [facebook/flava-full](https://huggingface.co/facebook/flava-full) 类似的配置。

配置对象继承自 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。

示例：

```python
>>> from transformers import FlavaImageConfig, FlavaImageModel

>>> # Initializing a FlavaImageModel with  style configuration
>>> configuration = FlavaImageConfig()

>>> # Initializing a FlavaImageModel model (with random weights) from the style configuration
>>> model = FlavaImageModel(configuration)

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

## FlavaMultimodalConfig[[transformers.FlavaMultimodalConfig]]

#### transformers.FlavaMultimodalConfig[[transformers.FlavaMultimodalConfig]]

```python
transformers.FlavaMultimodalConfig(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, hidden_size: int = 768, num_hidden_layers: int = 6, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.0, attention_probs_dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, qkv_bias: bool = True, use_cls_token: bool = True)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/configuration_flava.py#L109)

**参数：**

hidden_size (`int`，*可选*，默认为 `768`)：隐藏表示的维度。

num_hidden_layers (`int`，*可选*，默认为 `6`)：Transformer 解码器中的隐藏层数。

num_attention_heads (`int`，*可选*，默认为 `12`)：Transformer 解码器中每个注意力层的注意力头数量。

intermediate_size (`int`，*可选*，默认值为 `3072`)：MLP 表示的维度。

hidden_act (`str`，*可选*，默认为 `gelu`)：解码器中的非线性激活函数（函数或字符串）。例如，`"gelu"`、`"relu"`、`"silu"` 等。

hidden_dropout_prob (`Union[float, int]`，*可选*，默认值为 `0.0`)：嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

attention_probs_dropout_prob (`Union[float, int]`，*可选*，默认值为 `0.0`)：注意力概率的 dropout 比率。

initializer_range (`float`，*可选*，默认值为 `0.02`)：用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

layer_norm_eps (`float`, *可选*，默认为 `1e-12`)：层归一化层所使用的 epsilon。

qkv_bias (`bool`，*可选*，默认为 `True`)：是否向查询、键和值添加偏置。

use_cls_token (`bool`，*可选*，默认为 `True`)：是否使用额外的 CLS token 用于多模态设置。通常 FLAVA 模型需要此设置。

这是用于存储 FlavaModel 配置的类。它根据指定的参数实例化 Flava 模型，并定义模型架构。使用默认值实例化配置将生成与 [facebook/flava-full](https://huggingface.co/facebook/flava-full) 类似的配置。

配置对象继承自 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。

示例：

```python
>>> from transformers import FlavaMultimodalConfig, FlavaMultimodalModel

>>> # Initializing a FlavaMultimodalModel with  style configuration
>>> configuration = FlavaMultimodalConfig()

>>> # Initializing a FlavaMultimodalModel model (with random weights) from the style configuration
>>> model = FlavaMultimodalModel(configuration)

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

## FlavaImageCodebookConfig[[transformers.FlavaImageCodebookConfig]]

#### transformers.FlavaImageCodebookConfig[[transformers.FlavaImageCodebookConfig]]

```python
transformers.FlavaImageCodebookConfig(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, num_groups: int = 4, input_channels: int = 3, num_blocks_per_group: int = 2, hidden_size: int = 256, vocab_size: int = 8192, freeze: bool = True, initializer_range: float = 0.02)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/configuration_flava.py#L147)

**参数：**

num_groups (`int`，*可选*，默认为 4)：要创建的组数。目前，此参数不会影响模型，仅用于一些内部计算和估算。

input_channels (`int`，*可选*，默认为 `3`)：输入通道数。

num_blocks_per_group (`int`，*可选*，默认为 2)：每组中基于卷积的块数量。

hidden_size (`int`，*可选*，默认为 `256`)：隐藏表示的维度。

vocab_size (`int`，*可选*，默认为 `8192`)：模型的词汇表大小。定义了 `input_ids` 可以表示的不同 token 数量。

freeze (`bool`，默认为 `True`)：是否冻结模型的权重。

initializer_range (`float`，*可选*，默认值为 `0.02`)：用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

这是用于存储 FlavaModel 配置的类。它根据指定的参数实例化 Flava 模型，并定义模型架构。使用默认值实例化配置将生成与 [facebook/flava-full](https://huggingface.co/facebook/flava-full) 类似的配置。

配置对象继承自 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。

示例：

```python
>>> from transformers import FlavaImageCodebookConfig, FlavaImageCodebook

>>> # Initializing a FlavaImageCodebook with style configuration
>>> configuration = FlavaImageCodebookConfig()

>>> # Initializing a FlavaImageCodebook model (with random weights) from the style configuration
>>> model = FlavaImageCodebook(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
```

## FlavaProcessor[[transformers.FlavaProcessor]]

#### transformers.FlavaProcessor[[transformers.FlavaProcessor]]

```python
transformers.FlavaProcessor(image_processor = None, tokenizer = None, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/processing_flava.py#L23)

**参数：**

image_processor (`FlavaImageProcessor`)：图像处理器是必需的输入。

tokenizer (`BertTokenizer`)：分词器是必需的输入。

构建一个 FlavaProcessor，它将图像处理器和分词器封装为单一处理器。

[FlavaProcessor](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaProcessor) 提供了 [FlavaImageProcessor](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageProcessor) 和 [BertTokenizer](/docs/transformers/v5.23.0/zh/model_doc/lxmert#transformers.BertTokenizer) 的所有功能。有关更多信息，请参阅 [~FlavaImageProcessor](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageProcessor) 和 [~BertTokenizer](/docs/transformers/v5.23.0/zh/model_doc/lxmert#transformers.BertTokenizer)。

#### __调用__[[transformers.FlavaProcessor.__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: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/processing_utils.py#L670)

**参数：**

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_mm_token_type_ids (`bool`, *kwargs*) : 是否返回多模态 token 类型 ID，以指示多模态占位符 token 的位置。

return_text_replacement_offsets (`bool`, *kwargs*) : 是否返回每个多模态占位符及其替换项的字符偏移量。

return_tensors (`str` 或 [TensorType](/docs/transformers/v5.23.0/zh/internal/file_utils#transformers.TensorType)，*可选*)：如果设置，将返回特定框架的张量。可接受的值为： - `'pt'`：返回 PyTorch `torch.Tensor` 对象。 - `'np'`：返回 NumPy `np.ndarray` 对象。

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.23.0/zh/main_classes/processors#transformers.ProcessingKwargs), *可选*) : 针对每种模态（文本、图像、视频、音频）的额外处理选项。模型特定参数已在上方列出；有关支持参数的完整列表，请参阅 TypedDict 类。

## FlavaImageProcessor[[transformers.FlavaImageProcessor]]

#### transformers.FlavaImageProcessor[[transformers.FlavaImageProcessor]]

```python
transformers.FlavaImageProcessor(**kwargs: *<class 'transformers.models.flava.image_processing_flava.FlavaImageProcessorKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/image_processing_flava.py#L213)

**参数：**

do_convert_rgb (`bool`, *kwargs*, *可选*) : 是否将图像转换为 RGB。

do_resize (`bool`, *kwargs*, *可选*, 默认为 `True`) : 是否调整图像大小。

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*，默认为 `{'height' : 224, 'width': 224}`)：描述输入到模型的最大尺寸。

default_to_square (`bool`，*kwargs*，*可选*，默认为 `True`)：当 size 为整数时，是否在调整大小时默认使用正方形图像。

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*，默认为 `{'height' : 224, 'width': 224}`)：应用 `center_crop` 后输出图像的尺寸。

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*，默认值为 `3`) : 如果调整图像大小，则使用的重采样滤波器。它可以是枚举 `PILImageResampling` 中的一个值。仅当 `do_resize` 设置为 `True` 时才会生效。

do_rescale (`bool`, *kwargs*, *可选*，默认为 `True`)：是否对图像进行重新缩放。

rescale_factor (`float`, *kwargs*, *可选*，默认为 `0.00392156862745098`) : 当 `do_rescale` 设置为 `True` 时，用于对图像进行缩放的缩放因子。

do_normalize (`bool`，*kwargs*，*可选*，默认为 `True`)：是否对图像进行归一化。

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *可选*，默认为 `[0.48145466, 0.4578275, 0.40821073]`) : 用于归一化的图像均值。仅当 `do_normalize` 设置为 `True` 时生效。

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *可选*，默认为 `[0.26862954, 0.26130258, 0.27577711]`) : 用于归一化的图像标准差。仅当 `do_normalize` 设置为 `True` 时生效。

do_pad (`bool`, *kwargs*, *可选*) : 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 用于将图像填充到的尺寸，格式为 `{"height": int, "width" int}`。该尺寸必须大于预处理中提供的任何图像尺寸。如果未提供 `pad_size`，图像将被填充到批次中最大的高度和宽度。仅在 `do_pad=True.` 时应用。

do_center_crop (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否对图像进行居中裁剪。

data_format (`Union[str, ~image_utils.ChannelDimension]`，*kwargs*，*可选*)：仅支持 `ChannelDimension.FIRST`。为兼容旧版处理器而添加。

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *可选*) : 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一： - `"channels_first"` 或 `ChannelDimension.FIRST`：图像为 (num_channels, height, width) 格式。 - `"channels_last"` 或 `ChannelDimension.LAST`：图像为 (height, width, num_channels) 格式。 - `"none"` 或 `ChannelDimension.NONE`：图像为 (height, width) 格式。

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*)：用于处理视频的设备。如果未设置，则从输入视频中推断设备。

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : 如果设置为 `'pt'`，则返回堆叠的张量，否则返回张量列表。

disable_grouping (`bool`, *kwargs*, *可选*) : 是否禁用按尺寸对图像进行分组，从而逐个处理图像而非批量处理。如果为 None，则当图像位于 CPU 上时设置为 True，否则设置为 False。此选择基于经验观察，详见此处：https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *可选*) : 输入中每张图片所使用的图像 token 数量。为向后兼容而添加，但在未来的模型中，应将其设置为处理器的属性。

return_image_mask (`bool`, *kwargs*, *可选*，默认为 `False`) : 是否返回图像掩码。可通过 `preprocess` 中的 `return_image_mask` 参数覆盖。

input_size_patches (`int`, *kwargs*, *可选*，默认为 `14`)：图像在高度和宽度方向上的 patch 数量。14x14 = 总共 196 个 patch。可通过 `preprocess` 中的 `input_size_patches` 参数覆盖。

total_mask_patches (`int`, *kwargs*, *可选*，默认为 `75`)：应被掩码的 patch 总数。可被 `preprocess` 中的 `total_mask_patches` 参数覆盖。

mask_group_min_patches (`int`, *kwargs*, *可选*，默认为 `16`)：应被掩码的最少 patch 数量。可被 `preprocess` 中的 `mask_group_min_patches` 参数覆盖。

mask_group_max_patches (`int`, *kwargs*, *可选*) : 应被掩码的最大 patch 数量。可被 `preprocess` 中的 `mask_group_max_patches` 参数覆盖。

mask_group_min_aspect_ratio (`float`, *kwargs*, *可选*，默认为 `0.3`)：掩码窗口的最小宽高比。可通过 `preprocess` 中的 `mask_group_min_aspect_ratio` 参数覆盖。

mask_group_max_aspect_ratio (`float`, *kwargs*, *可选*) : 掩码窗口的最大宽高比。可被 `preprocess` 中的 `mask_group_max_aspect_ratio` 参数覆盖。

return_codebook_pixels (`bool`, *kwargs*, *可选*，默认为 `False`) : 是否返回码本像素值。

codebook_do_resize (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否将用于码本（codebook）的输入调整到特定尺寸。可通过 `preprocess` 中的 `codebook_do_resize` 参数覆盖。`codebook_size`。

codebook_size (`dict[str, *kwargs*, int]`，*可选*，默认为 `{"height" : 224, "width": 224}`)：将输入的代码本调整到指定大小。可被 `preprocess` 中的 `codebook_size` 参数覆盖。

codebook_resample (`PILImageResampling`，*kwargs*，*可选*，默认为 `PILImageResampling.LANCZOS`)：在对码本图像进行缩放时使用的重采样滤波器。在 torchvision < 0.27 中，torch Tensor 不支持 LANCZOS，因此使用 BICUBIC 作为最接近的替代方案。可以通过 `preprocess` 中的 `codebook_resample` 参数进行覆盖。

codebook_do_center_crop (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否在中心裁剪输入以用于 codebook。如果输入在任意边缘上的尺寸小于 `codebook_crop_size`，则图像会用 0 填充，然后进行中心裁剪。可以通过 `preprocess` 中的 `codebook_do_center_crop` 参数覆盖此设置。

codebook_crop_size (`dict[str, *kwargs*, int]`，*可选*，默认为 `{"height" : 224, "width": 224}`)：应用中心裁剪时，码本输入所需的输出尺寸。可通过 `preprocess` 中的 `codebook_crop_size` 参数进行覆盖。

codebook_do_rescale (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否使用指定的缩放因子 `codebook_rescale_factor` 对码本输入进行重新缩放。可通过 `preprocess` 中的 `codebook_do_rescale` 参数覆盖。

codebook_rescale_factor (`int`、*kwargs* 或 `float`，*optional*，默认为 `1/255`)：定义在对码本图像进行重新缩放时使用的缩放因子。可通过 `preprocess` 中的 `codebook_rescale_factor` 参数进行覆盖。

codebook_do_map_pixels (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否将 codebook 输入的像素值映射到 (1 - 2e)x + e。可通过 `preprocess` 中的 `codebook_do_map_pixels` 参数覆盖。

codebook_do_normalize (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否使用 `codebook_image_mean` 和 `codebook_image_std` 对码本输入进行归一化。可通过 `preprocess` 中的 `codebook_do_normalize` 参数覆盖。

codebook_image_mean (`Optional[Union[float, *kwargs*, Iterable[float]]]`，*可选*，默认为 `[0, 0, 0]`)：用于对码本图像进行归一化时，每个通道的均值序列。可通过 `preprocess` 中的 `codebook_image_mean` 参数进行覆盖。

codebook_image_std (`Optional[Union[float, *kwargs*, Iterable[float]]]`，*可选*，默认为 `[0.5, 0.5, 0.5]`)：用于对码本图像进行归一化时，每个通道的标准差序列。可通过 `preprocess` 中的 `codebook_image_std` 参数覆盖。

构建一个 FlavaImageProcessor 图像处理器。

#### preprocess[[transformers.FlavaImageProcessor.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *<class 'transformers.models.flava.image_processing_flava.FlavaImageProcessorKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/image_processing_flava.py#L250)

**参数：**

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`。

do_convert_rgb (`bool`, *kwargs*, *可选*) : 是否将图像转换为 RGB。

do_resize (`bool`，*kwargs*，*可选*)：是否调整图像大小。

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*)：描述模型的最大输入维度。

default_to_square (`bool`, *kwargs*, *可选*) : 当 size 为 int 时，是否在调整大小时默认使用正方形图像。

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 应用 `center_crop` 后输出图像的尺寸。

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : 如果调整图像大小，则使用的重采样滤波器。它可以是枚举 `PILImageResampling` 中的一个值。仅当 `do_resize` 设置为 `True` 时才会生效。

do_rescale (`bool`, *kwargs*, *可选*) : 是否对图像进行重新缩放。

rescale_factor (`float`, *kwargs*, *可选*) : 当 `do_rescale` 设置为 `True` 时，用于对图像进行缩放的缩放因子。

do_normalize (`bool`, *kwargs*, *可选*) : 是否对图像进行归一化。

image_mean (`Union[float, list[float], tuple[float, ...]]`，*kwargs*，*可选*)：用于归一化的图像均值。仅当 `do_normalize` 设置为 `True` 时生效。

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *可选*) : 用于归一化的图像标准差。仅当 `do_normalize` 设置为 `True` 时生效。

do_pad (`bool`, *kwargs*, *可选*) : 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 用于将图像填充到的尺寸，格式为 `{"height": int, "width" int}`。该尺寸必须大于预处理中提供的任何图像尺寸。如果未提供 `pad_size`，图像将被填充到批次中最大的高度和宽度。仅在 `do_pad=True.` 时应用。

do_center_crop (`bool`, *kwargs*, *可选*) : 是否对图像进行居中裁剪。

data_format (`Union[str, ~image_utils.ChannelDimension]`，*kwargs*，*可选*)：仅支持 `ChannelDimension.FIRST`。为兼容旧版处理器而添加。

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *可选*) : 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一： - `"channels_first"` 或 `ChannelDimension.FIRST`：图像为 (num_channels, height, width) 格式。 - `"channels_last"` 或 `ChannelDimension.LAST`：图像为 (height, width, num_channels) 格式。 - `"none"` 或 `ChannelDimension.NONE`：图像为 (height, width) 格式。

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*)：用于处理视频的设备。如果未设置，则从输入视频中推断设备。

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : 如果设置为 `'pt'`，则返回堆叠的张量，否则返回张量列表。

disable_grouping (`bool`, *kwargs*, *可选*) : 是否禁用按尺寸对图像进行分组，从而逐个处理图像而非批量处理。如果为 None，则当图像位于 CPU 上时设置为 True，否则设置为 False。此选择基于经验观察，详见此处：https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *可选*) : 输入中每张图片所使用的图像 token 数量。为向后兼容而添加，但在未来的模型中，应将其设置为处理器的属性。

return_image_mask (`bool`, *kwargs*, *可选*，默认为 `False`) : 是否返回图像掩码。可通过 `preprocess` 中的 `return_image_mask` 参数覆盖。

input_size_patches (`int`, *kwargs*, *可选*，默认为 `14`)：图像在高度和宽度方向上的 patch 数量。14x14 = 总共 196 个 patch。可通过 `preprocess` 中的 `input_size_patches` 参数覆盖。

total_mask_patches (`int`, *kwargs*, *可选*，默认为 `75`)：应被掩码的 patch 总数。可被 `preprocess` 中的 `total_mask_patches` 参数覆盖。

mask_group_min_patches (`int`, *kwargs*, *可选*，默认为 `16`)：应被掩码的最少 patch 数量。可被 `preprocess` 中的 `mask_group_min_patches` 参数覆盖。

mask_group_max_patches (`int`, *kwargs*, *可选*) : 应被掩码的最大 patch 数量。可被 `preprocess` 中的 `mask_group_max_patches` 参数覆盖。

mask_group_min_aspect_ratio (`float`, *kwargs*, *可选*，默认为 `0.3`)：掩码窗口的最小宽高比。可通过 `preprocess` 中的 `mask_group_min_aspect_ratio` 参数覆盖。

mask_group_max_aspect_ratio (`float`, *kwargs*, *可选*) : 掩码窗口的最大宽高比。可被 `preprocess` 中的 `mask_group_max_aspect_ratio` 参数覆盖。

return_codebook_pixels (`bool`, *kwargs*, *可选*，默认为 `False`) : 是否返回码本像素值。

codebook_do_resize (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否将用于码本（codebook）的输入调整到特定尺寸。可通过 `preprocess` 中的 `codebook_do_resize` 参数覆盖。`codebook_size`。

codebook_size (`dict[str, *kwargs*, int]`，*可选*，默认为 `{"height" : 224, "width": 224}`)：将输入的代码本调整到指定大小。可被 `preprocess` 中的 `codebook_size` 参数覆盖。

codebook_resample (`PILImageResampling`，*kwargs*，*可选*，默认为 `PILImageResampling.LANCZOS`)：在对码本图像进行缩放时使用的重采样滤波器。在 torchvision < 0.27 中，torch Tensor 不支持 LANCZOS，因此使用 BICUBIC 作为最接近的替代方案。可以通过 `preprocess` 中的 `codebook_resample` 参数进行覆盖。

codebook_do_center_crop (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否在中心裁剪输入以用于 codebook。如果输入在任意边缘上的尺寸小于 `codebook_crop_size`，则图像会用 0 填充，然后进行中心裁剪。可以通过 `preprocess` 中的 `codebook_do_center_crop` 参数覆盖此设置。

codebook_crop_size (`dict[str, *kwargs*, int]`，*可选*，默认为 `{"height" : 224, "width": 224}`)：应用中心裁剪时，码本输入所需的输出尺寸。可通过 `preprocess` 中的 `codebook_crop_size` 参数进行覆盖。

codebook_do_rescale (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否使用指定的缩放因子 `codebook_rescale_factor` 对码本输入进行重新缩放。可通过 `preprocess` 中的 `codebook_do_rescale` 参数覆盖。

codebook_rescale_factor (`int`、*kwargs* 或 `float`，*optional*，默认为 `1/255`)：定义在对码本图像进行重新缩放时使用的缩放因子。可通过 `preprocess` 中的 `codebook_rescale_factor` 参数进行覆盖。

codebook_do_map_pixels (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否将 codebook 输入的像素值映射到 (1 - 2e)x + e。可通过 `preprocess` 中的 `codebook_do_map_pixels` 参数覆盖。

codebook_do_normalize (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否使用 `codebook_image_mean` 和 `codebook_image_std` 对码本输入进行归一化。可通过 `preprocess` 中的 `codebook_do_normalize` 参数覆盖。

codebook_image_mean (`Optional[Union[float, *kwargs*, Iterable[float]]]`，*可选*，默认为 `[0, 0, 0]`)：用于对码本图像进行归一化时，每个通道的均值序列。可通过 `preprocess` 中的 `codebook_image_mean` 参数进行覆盖。

codebook_image_std (`Optional[Union[float, *kwargs*, Iterable[float]]]`，*可选*，默认为 `[0.5, 0.5, 0.5]`)：用于对码本图像进行归一化时，每个通道的标准差序列。可通过 `preprocess` 中的 `codebook_image_std` 参数覆盖。

**返回：** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- 由 __call__ 方法返回的列表/数组/张量字典（例如 'pixel_values'）。
- **tensor_type** (`Union[None, str, TensorType]`，*可选*) -- 您可以在此处指定 tensor_type，以便在初始化时将 PyTorch/Numpy 张量中的整数列表进行转换。

## FlavaImageProcessorPil[[transformers.FlavaImageProcessorPil]]

#### transformers.FlavaImageProcessorPil[[transformers.FlavaImageProcessorPil]]

```python
transformers.FlavaImageProcessorPil(**kwargs: *<class 'transformers.models.flava.image_processing_pil_flava.FlavaImageProcessorKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/image_processing_pil_flava.py#L227)

**参数：**

do_convert_rgb (`bool`, *kwargs*, *可选*) : 是否将图像转换为 RGB。

do_resize (`bool`, *kwargs*, *可选*, 默认为 `True`) : 是否调整图像大小。

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*，默认为 `{'height' : 224, 'width': 224}`)：描述输入到模型的最大尺寸。

default_to_square (`bool`，*kwargs*，*可选*，默认为 `True`)：当 size 为整数时，是否在调整大小时默认使用正方形图像。

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*，默认为 `{'height' : 224, 'width': 224}`)：应用 `center_crop` 后输出图像的尺寸。

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*，默认值为 `3`) : 如果调整图像大小，则使用的重采样滤波器。它可以是枚举 `PILImageResampling` 中的一个值。仅当 `do_resize` 设置为 `True` 时才会生效。

do_rescale (`bool`, *kwargs*, *可选*，默认为 `True`)：是否对图像进行重新缩放。

rescale_factor (`float`, *kwargs*, *可选*，默认为 `0.00392156862745098`) : 当 `do_rescale` 设置为 `True` 时，用于对图像进行缩放的缩放因子。

do_normalize (`bool`，*kwargs*，*可选*，默认为 `True`)：是否对图像进行归一化。

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *可选*，默认为 `[0.48145466, 0.4578275, 0.40821073]`) : 用于归一化的图像均值。仅当 `do_normalize` 设置为 `True` 时生效。

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *可选*，默认为 `[0.26862954, 0.26130258, 0.27577711]`) : 用于归一化的图像标准差。仅当 `do_normalize` 设置为 `True` 时生效。

do_pad (`bool`, *kwargs*, *可选*) : 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 用于将图像填充到的尺寸，格式为 `{"height": int, "width" int}`。该尺寸必须大于预处理中提供的任何图像尺寸。如果未提供 `pad_size`，图像将被填充到批次中最大的高度和宽度。仅在 `do_pad=True.` 时应用。

do_center_crop (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否对图像进行居中裁剪。

data_format (`Union[str, ~image_utils.ChannelDimension]`，*kwargs*，*可选*)：仅支持 `ChannelDimension.FIRST`。为兼容旧版处理器而添加。

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *可选*) : 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一： - `"channels_first"` 或 `ChannelDimension.FIRST`：图像为 (num_channels, height, width) 格式。 - `"channels_last"` 或 `ChannelDimension.LAST`：图像为 (height, width, num_channels) 格式。 - `"none"` 或 `ChannelDimension.NONE`：图像为 (height, width) 格式。

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*)：用于处理视频的设备。如果未设置，则从输入视频中推断设备。

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : 如果设置为 `'pt'`，则返回堆叠的张量，否则返回张量列表。

disable_grouping (`bool`, *kwargs*, *可选*) : 是否禁用按尺寸对图像进行分组，从而逐个处理图像而非批量处理。如果为 None，则当图像位于 CPU 上时设置为 True，否则设置为 False。此选择基于经验观察，详见此处：https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *可选*) : 输入中每张图片所使用的图像 token 数量。为向后兼容而添加，但在未来的模型中，应将其设置为处理器的属性。

return_image_mask (`bool`, *kwargs*, *可选*，默认为 `False`) : 是否返回图像掩码。可通过 `preprocess` 中的 `return_image_mask` 参数覆盖。

input_size_patches (`int`, *kwargs*, *可选*，默认为 `14`)：图像在高度和宽度方向上的 patch 数量。14x14 = 总共 196 个 patch。可通过 `preprocess` 中的 `input_size_patches` 参数覆盖。

total_mask_patches (`int`, *kwargs*, *可选*，默认为 `75`)：应被掩码的 patch 总数。可被 `preprocess` 中的 `total_mask_patches` 参数覆盖。

mask_group_min_patches (`int`, *kwargs*, *可选*，默认为 `16`)：应被掩码的最少 patch 数量。可被 `preprocess` 中的 `mask_group_min_patches` 参数覆盖。

mask_group_max_patches (`int`, *kwargs*, *可选*) : 应被掩码的最大 patch 数量。可被 `preprocess` 中的 `mask_group_max_patches` 参数覆盖。

mask_group_min_aspect_ratio (`float`, *kwargs*, *可选*，默认为 `0.3`)：掩码窗口的最小宽高比。可通过 `preprocess` 中的 `mask_group_min_aspect_ratio` 参数覆盖。

mask_group_max_aspect_ratio (`float`, *kwargs*, *可选*) : 掩码窗口的最大宽高比。可被 `preprocess` 中的 `mask_group_max_aspect_ratio` 参数覆盖。

return_codebook_pixels (`bool`, *kwargs*, *可选*，默认为 `False`) : 是否返回码本像素值。

codebook_do_resize (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否将用于码本（codebook）的输入调整到特定尺寸。可通过 `preprocess` 中的 `codebook_do_resize` 参数覆盖。`codebook_size`。

codebook_size (`dict[str, *kwargs*, int]`，*可选*，默认为 `{"height" : 224, "width": 224}`)：将输入的代码本调整到指定大小。可被 `preprocess` 中的 `codebook_size` 参数覆盖。

codebook_resample (`PILImageResampling`，*kwargs*，*可选*，默认为 `PILImageResampling.LANCZOS`)：在对码本图像进行缩放时使用的重采样滤波器。在 torchvision < 0.27 中，torch Tensor 不支持 LANCZOS，因此使用 BICUBIC 作为最接近的替代方案。可以通过 `preprocess` 中的 `codebook_resample` 参数进行覆盖。

codebook_do_center_crop (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否在中心裁剪输入以用于 codebook。如果输入在任意边缘上的尺寸小于 `codebook_crop_size`，则图像会用 0 填充，然后进行中心裁剪。可以通过 `preprocess` 中的 `codebook_do_center_crop` 参数覆盖此设置。

codebook_crop_size (`dict[str, *kwargs*, int]`，*可选*，默认为 `{"height" : 224, "width": 224}`)：应用中心裁剪时，码本输入所需的输出尺寸。可通过 `preprocess` 中的 `codebook_crop_size` 参数进行覆盖。

codebook_do_rescale (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否使用指定的缩放因子 `codebook_rescale_factor` 对码本输入进行重新缩放。可通过 `preprocess` 中的 `codebook_do_rescale` 参数覆盖。

codebook_rescale_factor (`int`、*kwargs* 或 `float`，*optional*，默认为 `1/255`)：定义在对码本图像进行重新缩放时使用的缩放因子。可通过 `preprocess` 中的 `codebook_rescale_factor` 参数进行覆盖。

codebook_do_map_pixels (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否将 codebook 输入的像素值映射到 (1 - 2e)x + e。可通过 `preprocess` 中的 `codebook_do_map_pixels` 参数覆盖。

codebook_do_normalize (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否使用 `codebook_image_mean` 和 `codebook_image_std` 对码本输入进行归一化。可通过 `preprocess` 中的 `codebook_do_normalize` 参数覆盖。

codebook_image_mean (`Optional[Union[float, *kwargs*, Iterable[float]]]`，*可选*，默认为 `[0, 0, 0]`)：用于对码本图像进行归一化时，每个通道的均值序列。可通过 `preprocess` 中的 `codebook_image_mean` 参数进行覆盖。

codebook_image_std (`Optional[Union[float, *kwargs*, Iterable[float]]]`，*可选*，默认为 `[0.5, 0.5, 0.5]`)：用于对码本图像进行归一化时，每个通道的标准差序列。可通过 `preprocess` 中的 `codebook_image_std` 参数覆盖。

构建一个 FlavaImageProcessor 图像处理器。

#### preprocess[[transformers.FlavaImageProcessorPil.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *<class 'transformers.models.flava.image_processing_pil_flava.FlavaImageProcessorKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/image_processing_pil_flava.py#L264)

**参数：**

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`。

do_convert_rgb (`bool`, *kwargs*, *可选*) : 是否将图像转换为 RGB。

do_resize (`bool`，*kwargs*，*可选*)：是否调整图像大小。

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*)：描述模型的最大输入维度。

default_to_square (`bool`, *kwargs*, *可选*) : 当 size 为 int 时，是否在调整大小时默认使用正方形图像。

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 应用 `center_crop` 后输出图像的尺寸。

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : 如果调整图像大小，则使用的重采样滤波器。它可以是枚举 `PILImageResampling` 中的一个值。仅当 `do_resize` 设置为 `True` 时才会生效。

do_rescale (`bool`, *kwargs*, *可选*) : 是否对图像进行重新缩放。

rescale_factor (`float`, *kwargs*, *可选*) : 当 `do_rescale` 设置为 `True` 时，用于对图像进行缩放的缩放因子。

do_normalize (`bool`, *kwargs*, *可选*) : 是否对图像进行归一化。

image_mean (`Union[float, list[float], tuple[float, ...]]`，*kwargs*，*可选*)：用于归一化的图像均值。仅当 `do_normalize` 设置为 `True` 时生效。

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *可选*) : 用于归一化的图像标准差。仅当 `do_normalize` 设置为 `True` 时生效。

do_pad (`bool`, *kwargs*, *可选*) : 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 用于将图像填充到的尺寸，格式为 `{"height": int, "width" int}`。该尺寸必须大于预处理中提供的任何图像尺寸。如果未提供 `pad_size`，图像将被填充到批次中最大的高度和宽度。仅在 `do_pad=True.` 时应用。

do_center_crop (`bool`, *kwargs*, *可选*) : 是否对图像进行居中裁剪。

data_format (`Union[str, ~image_utils.ChannelDimension]`，*kwargs*，*可选*)：仅支持 `ChannelDimension.FIRST`。为兼容旧版处理器而添加。

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *可选*) : 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一： - `"channels_first"` 或 `ChannelDimension.FIRST`：图像为 (num_channels, height, width) 格式。 - `"channels_last"` 或 `ChannelDimension.LAST`：图像为 (height, width, num_channels) 格式。 - `"none"` 或 `ChannelDimension.NONE`：图像为 (height, width) 格式。

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*)：用于处理视频的设备。如果未设置，则从输入视频中推断设备。

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : 如果设置为 `'pt'`，则返回堆叠的张量，否则返回张量列表。

disable_grouping (`bool`, *kwargs*, *可选*) : 是否禁用按尺寸对图像进行分组，从而逐个处理图像而非批量处理。如果为 None，则当图像位于 CPU 上时设置为 True，否则设置为 False。此选择基于经验观察，详见此处：https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *可选*) : 输入中每张图片所使用的图像 token 数量。为向后兼容而添加，但在未来的模型中，应将其设置为处理器的属性。

return_image_mask (`bool`, *kwargs*, *可选*，默认为 `False`) : 是否返回图像掩码。可通过 `preprocess` 中的 `return_image_mask` 参数覆盖。

input_size_patches (`int`, *kwargs*, *可选*，默认为 `14`)：图像在高度和宽度方向上的 patch 数量。14x14 = 总共 196 个 patch。可通过 `preprocess` 中的 `input_size_patches` 参数覆盖。

total_mask_patches (`int`, *kwargs*, *可选*，默认为 `75`)：应被掩码的 patch 总数。可被 `preprocess` 中的 `total_mask_patches` 参数覆盖。

mask_group_min_patches (`int`, *kwargs*, *可选*，默认为 `16`)：应被掩码的最少 patch 数量。可被 `preprocess` 中的 `mask_group_min_patches` 参数覆盖。

mask_group_max_patches (`int`, *kwargs*, *可选*) : 应被掩码的最大 patch 数量。可被 `preprocess` 中的 `mask_group_max_patches` 参数覆盖。

mask_group_min_aspect_ratio (`float`, *kwargs*, *可选*，默认为 `0.3`)：掩码窗口的最小宽高比。可通过 `preprocess` 中的 `mask_group_min_aspect_ratio` 参数覆盖。

mask_group_max_aspect_ratio (`float`, *kwargs*, *可选*) : 掩码窗口的最大宽高比。可被 `preprocess` 中的 `mask_group_max_aspect_ratio` 参数覆盖。

return_codebook_pixels (`bool`, *kwargs*, *可选*，默认为 `False`) : 是否返回码本像素值。

codebook_do_resize (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否将用于码本（codebook）的输入调整到特定尺寸。可通过 `preprocess` 中的 `codebook_do_resize` 参数覆盖。`codebook_size`。

codebook_size (`dict[str, *kwargs*, int]`，*可选*，默认为 `{"height" : 224, "width": 224}`)：将输入的代码本调整到指定大小。可被 `preprocess` 中的 `codebook_size` 参数覆盖。

codebook_resample (`PILImageResampling`，*kwargs*，*可选*，默认为 `PILImageResampling.LANCZOS`)：在对码本图像进行缩放时使用的重采样滤波器。在 torchvision < 0.27 中，torch Tensor 不支持 LANCZOS，因此使用 BICUBIC 作为最接近的替代方案。可以通过 `preprocess` 中的 `codebook_resample` 参数进行覆盖。

codebook_do_center_crop (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否在中心裁剪输入以用于 codebook。如果输入在任意边缘上的尺寸小于 `codebook_crop_size`，则图像会用 0 填充，然后进行中心裁剪。可以通过 `preprocess` 中的 `codebook_do_center_crop` 参数覆盖此设置。

codebook_crop_size (`dict[str, *kwargs*, int]`，*可选*，默认为 `{"height" : 224, "width": 224}`)：应用中心裁剪时，码本输入所需的输出尺寸。可通过 `preprocess` 中的 `codebook_crop_size` 参数进行覆盖。

codebook_do_rescale (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否使用指定的缩放因子 `codebook_rescale_factor` 对码本输入进行重新缩放。可通过 `preprocess` 中的 `codebook_do_rescale` 参数覆盖。

codebook_rescale_factor (`int`、*kwargs* 或 `float`，*optional*，默认为 `1/255`)：定义在对码本图像进行重新缩放时使用的缩放因子。可通过 `preprocess` 中的 `codebook_rescale_factor` 参数进行覆盖。

codebook_do_map_pixels (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否将 codebook 输入的像素值映射到 (1 - 2e)x + e。可通过 `preprocess` 中的 `codebook_do_map_pixels` 参数覆盖。

codebook_do_normalize (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否使用 `codebook_image_mean` 和 `codebook_image_std` 对码本输入进行归一化。可通过 `preprocess` 中的 `codebook_do_normalize` 参数覆盖。

codebook_image_mean (`Optional[Union[float, *kwargs*, Iterable[float]]]`，*可选*，默认为 `[0, 0, 0]`)：用于对码本图像进行归一化时，每个通道的均值序列。可通过 `preprocess` 中的 `codebook_image_mean` 参数进行覆盖。

codebook_image_std (`Optional[Union[float, *kwargs*, Iterable[float]]]`，*可选*，默认为 `[0.5, 0.5, 0.5]`)：用于对码本图像进行归一化时，每个通道的标准差序列。可通过 `preprocess` 中的 `codebook_image_std` 参数覆盖。

**返回：** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- 由 __call__ 方法返回的列表/数组/张量字典（例如 'pixel_values'）。
- **tensor_type** (`Union[None, str, TensorType]`，*可选*) -- 您可以在此处指定 tensor_type，以便在初始化时将 PyTorch/Numpy 张量中的整数列表进行转换。

## FlavaForPreTraining[[transformers.FlavaForPreTraining]]

#### transformers.FlavaForPreTraining[[transformers.FlavaForPreTraining]]

```python
transformers.FlavaForPreTraining(config: FlavaConfig, image_codebook: typing.Optional[torch.nn.Module] = None)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/modeling_flava.py#L1502)

**参数：**

config ([FlavaConfig](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化并不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

image_codebook (`torch.nn.Module`, *可选*) : 如果传入该参数，图像码本将被设置为该模块。否则，将首先使用配置中定义的 image_codebook_config 作为第一个参数进行初始化。

用于预训练的 FLAVA 模型，输出损失、嵌入、logits 和 transformer 输出。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/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.FlavaForPreTraining.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, input_ids_masked: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, codebook_pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, bool_masked_pos: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, image_attention_mask: typing.Optional[torch.Tensor] = None, skip_unmasked_multimodal_encoder: bool | None = None, mlm_labels: typing.Optional[torch.Tensor] = None, mim_labels: typing.Optional[torch.Tensor] = None, itm_labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool = True, return_dict: bool | None = None, return_loss: bool | None = None, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/modeling_flava.py#L1551)

**参数：**

input_ids (`torch.LongTensor`，形状为 `(batch_size, text_seq_len)`)：输入序列词元在词汇表中的索引。可以使用 [AutoTokenizer](/docs/transformers/v5.23.0/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

input_ids_masked (`torch.LongTensor`，形状为 `(batch_size, text_seq_len)`)：输入序列词元在词汇表中的索引。这些是原始任务的掩码版本，用于 MLM。可以使用 [AutoTokenizer](/docs/transformers/v5.23.0/zh/model_doc/auto#transformers.AutoTokenizer) 配合 `DataCollatorForMaskedLanguageModeling` 获取这些索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, image_size, image_size)`，*可选*) : 与输入图像对应的张量。可以使用 [FlavaImageProcessor](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageProcessor) 获取像素值。有关详细信息，请参阅 [FlavaImageProcessor.__call__()](/docs/transformers/v5.23.0/zh/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__)（[FlavaProcessor](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaProcessor) 使用 [FlavaImageProcessor](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageProcessor) 来处理图像）。

codebook_pixel_values (`torch.Tensor`，形状为 `(batch_size, num_image_patches, patch_size, patch_size, 3)`，*可选*)：用于计算掩码图像建模中图像码本标签的图像块像素值。

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`，形状为 `(batch_size, text_seq_len)`，*可选*)：用于指示输入中第一和第二部分的段标记索引。索引选自 `[0, 1]`：- 0 对应 *句子 A* 标记，- 1 对应 *句子 B* 标记。[什么是标记类型 ID？](../glossary#token-type-ids)

bool_masked_pos (`torch.BoolTensor`，形状为 `(batch_size, image_num_patches)`)：布尔掩码位置。指示哪些 patch 被掩码（1），哪些未被掩码（0）。

position_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

image_attention_mask (`torch.Tensor`，形状为 `(batch_size, image_num_patches)`，*可选*)：用于避免对图像中填充标记索引执行注意力机制的掩码。掩码值选自 `[0, 1]`：- 对于**未掩码**的标记，值为 1；- 对于**已掩码**的标记，值为 0。[什么是注意力掩码？](../glossary#attention-mask)

skip_unmasked_multimodal_encoder (`*bool*`, *可选*) : 对于未掩码的输入，跳过多模态编码器的任何计算。目前，FLAVA 预训练不需要未掩码的多模态嵌入或输出。

mlm_labels (`torch.LongTensor`，形状为 `(batch_size, text_seq_len)`，*可选*)：用于计算从左到右的语言和多模态掩码建模损失（下一个词预测）的标签。索引应在 `[-100, 0, ..., text_config.vocab_size - 1]` 范围内（参见 `input_ids` 的文档字符串）。索引设置为 `-100` 的令牌将被忽略（掩码），损失仅针对标签在 `[0, ..., text_config.vocab_size - 1]` 范围内的令牌进行计算。

mim_labels (`torch.LongTensor`，形状为 `(batch_size, image_num_patches)`，*可选*) : 用于计算图像和多模态掩码建模损失的标签。索引应在 `[-100, 0, ..., image_config.vocab_size - 1]` 范围内。索引设置为 `-100` 的令牌将被忽略（掩码），损失仅针对标签在 `[0, ..., image_config.vocab_size - 1]` 范围内的令牌进行计算。如果未传入，则使用分配给模型的图像码本自动生成。默认情况下，它使用 [FlavaImageCodebook](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageCodebook)。请参阅 [FlavaImageCodebook](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageCodebook) 以了解如何生成 mim_labels。

itm_labels (`torch.LongTensor`，形状为 `(batch_size, 1)`，*可选*)：用于计算图文匹配损失的标签。0 表示配对不匹配，1 表示配对匹配。标签为 0 的配对在计算 MMM 和全局对比损失时也会被跳过。

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

output_hidden_states (`bool`，*可选*，默认为 `True`)：是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量中的 `hidden_states`。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

return_loss (`bool`，*可选*，默认为 None)：是否返回计算出的损失。

**返回：** `FlavaForPreTrainingOutput` 或 `tuple(torch.Tensor)`

`FlavaForPreTrainingOutput` 或 `torch.Tensor` 元组（如果传入 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[FlavaConfig](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaConfig)）和输入。

[FlavaForPreTraining](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaForPreTraining) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **loss** (`torch.Tensor`，*可选*，当 `return_loss` 为 True 时返回) -- 为该模型计算的总损失。
- **loss_info** (`~models.flava.modeling_flava.FlavaLosses`，*可选*) -- FLAVA 预训练损失的详细信息。有关键值的信息，请参见 `FlavaLosses` 类的描述。
- **image_embeddings**（形状为 `(batch_size, output_dim)` 的 `torch.Tensor`，*可选*，当存在 `pixel_values` 时返回）-- 图像嵌入，基本上是 [FlavaImageModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageModel) 的池化输出。
- **image_output** (`BaseModelOutputWithPooling`，*可选*，当存在 `pixel_values` 时返回) -- [FlavaImageModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageModel) 的输出。
- **text_embeddings**（形状为 `(batch_size, output_dim)` 的 `torch.Tensor`，*可选*，当存在 `input_ids` 时返回）-- 文本嵌入，基本上是 [FlavaTextModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaTextModel) 的池化输出。
- **text_output**（`BaseModelOutputWithPooling`，*可选*，当存在 `input_ids` 时返回）-- [FlavaTextModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaTextModel) 的输出。
- **multimodal_embeddings** (`torch.Tensor`，形状为 `(batch_size, output_dim)`，*可选*，当 `input_ids` 和 `pixel_values` 存在且 `skip_unmasked_multimodal_encoder` 为 `None` 或 `False` 时返回) -- 多模态嵌入，基本上是 [FlavaTextModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaTextModel) 的池化输出。
- **multimodal_output**（`BaseModelOutputWithPooling`，当 `input_ids` 和 `pixel_values` 存在且 `skip_unmasked_multimodal_encoder` 为 `None` 或 `False` 时返回）-- [FlavaMultimodalModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaMultimodalModel) 的输出。
- **image_masked_embeddings**（形状为 `(batch_size, output_dim)` 的 `torch.Tensor`，*可选*，当存在 `pixel_values` 时返回）-- 图像嵌入，基本上是 [FlavaImageModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageModel) 的池化输出。使用 `bool_masked_pos` 来创建掩码图像。
- **image_masked_output** (`BaseModelOutputWithPooling`，*可选*，当存在 `pixel_values` 时返回) -- [FlavaImageModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageModel) 的输出。使用 `bool_masked_pos` 创建掩码图像。
- **text_masked_embeddings**（形状为 `(batch_size, output_dim)` 的 `torch.Tensor`，*可选*，当存在 `input_ids_masked` 时返回）-- 文本嵌入，基本上是 [FlavaTextModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaTextModel) 的池化输出。
- **text_masked_output**（`BaseModelOutputWithPooling`，*可选*，当存在 `input_ids_masked` 时返回）-- [FlavaTextModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaTextModel) 的输出。
- **multimodal_masked_embeddings**（形状为 `(batch_size, output_dim)` 的 `torch.Tensor`，*可选*，当存在 `input_ids` 和 `pixel_values` 时返回）-- 多模态嵌入，基本上是 [FlavaTextModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaTextModel) 的池化输出。
- **multimodal_masked_output**（`BaseModelOutputWithPooling`，*可选*，当存在 `input_ids_masked` 和 `pixel_values` 时返回）-- [FlavaMultimodalModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaMultimodalModel) 的输出。
- **mim_logits** (`torch.Tensor`，形状为 `(batch_size, num_image_patches, image_vocab_size)` 或 `(total_masked_patches, image_vocab_size)`，*可选*，当存在 `pixel_values` 且不存在 `input_ids_masked` 时返回) -- MIM 单模态损失的 logits。使用 `bool_masked_pos` 获取被掩码的 patch。当 `bool_masked_pos` 中部分 patch 被掩码时，返回展平后的输出。
- **mlm_logits**（形状为 `(batch_size, text_seq_length, text_vocab_size)` 或 `(total_masked_seq_length, text_vocab_size)` 的 `torch.Tensor`，*可选*，当存在 `input_ids_masked` 且不存在 `pixel_values` 时返回）-- MLM 单模态损失的 logits。当 `input_ids_masked` 中部分 token 被掩码时，返回展平后的输出。
- **itm_logits**（形状为 `(batch_size, 2)` 的 `torch.Tensor`，*可选*，当存在 `input_ids_masked` 和 `pixel_values` 时返回）-- ITM 损失的 logits。请注意，在 FLAVA 中，ITM 损失是在掩码对上计算的。
- **contrastive_logits_per_image**（形状为 `(image_batch_size, text_batch_size)` 的 `torch.Tensor`）-- `image_embeddings` 与 `text_embeddings` 之间的缩放点积分数，但分别经过了 FLAVA 的 `image_projection` 和 `text_projection` 层。这表示图文相似度分数。该分数在未掩码的图像和文本上计算得出。
- **contrastive_logits_per_text**（形状为 `(text_batch_size, image_batch_size)` 的 `torch.Tensor`）-- `text_embeddings` 与 `image_embeddings` 之间的缩放点积分数，但分别经过了 FLAVA 的 `text_projection` 和 `image_projection` 层。此分数在未掩码的图像和文本上计算。
- **mmm_image_logits** (`torch.Tensor`，形状为 `(batch_size, num_image_patches, image_vocab_size)` 或 `(total_masked_patches, image_vocab_size)`，*可选*，当存在 `pixel_values` 和 `input_ids_masked` 时返回) -- MMM 图像多模态损失的 logits。使用 `bool_masked_pos` 获取被掩码的 patch。当 `bool_masked_pos` 中部分 patch 被掩码时，返回展平后的输出。
- **mmm_text_logits**（形状为 `(batch_size, text_seq_length, text_vocab_size)` 或 `(total_masked_seq_length, text_vocab_size)` 的 `torch.Tensor`，*可选*，当存在 `pixel_values` 和 `input_ids_masked` 时返回） -- MMM 文本多模态损失的 logits。当 `input_ids_masked` 中部分 token 被掩码时，返回展平后的输出。

示例：
```python
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import FlavaForPreTraining, AutoProcessor

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> model = FlavaForPreTraining.from_pretrained("facebook/flava-full")
>>> processor = AutoProcessor.from_pretrained("facebook/flava-full")

>>> text = ["a photo of a cat"]

>>> inputs = processor(
...     images=[image],
...     text=text,
...     return_masks=True,
...     return_codebook_pixels=True,
...     padding=True,
...     max_length=77,
...     return_tensors="pt",
... )

>>> output = model(**inputs)
```

## FlavaModel[[transformers.FlavaModel]]

#### transformers.FlavaModel[[transformers.FlavaModel]]

```python
transformers.FlavaModel(config: FlavaConfig)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/modeling_flava.py#L935)

**参数：**

config ([FlavaConfig](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化并不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

未添加任何特定头部的裸 Flava 模型，直接输出原始隐藏状态。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/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.FlavaModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, bool_masked_pos: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, image_attention_mask: typing.Optional[torch.Tensor] = None, skip_multimodal_encoder: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool = True, return_dict: bool | None = None, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/modeling_flava.py#L1078)

**参数：**

input_ids (`torch.LongTensor`，形状为 `(batch_size, image_num_patches + text_seq_len)`)：输入序列标记在词汇表中的索引。可以使用 [AutoTokenizer](/docs/transformers/v5.23.0/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, image_size, image_size)`，*可选*) : 与输入图像对应的张量。可以使用 [FlavaImageProcessor](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageProcessor) 获取像素值。有关详细信息，请参阅 [FlavaImageProcessor.__call__()](/docs/transformers/v5.23.0/zh/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__)（[FlavaProcessor](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaProcessor) 使用 [FlavaImageProcessor](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageProcessor) 来处理图像）。

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`，形状为 `(batch_size, image_num_patches + text_seq_len)`，*可选*)：用于指示输入中第一和第二部分的段标记索引。索引选自 `[0, 1]`：- 0 对应 *句子 A* 标记，- 1 对应 *句子 B* 标记。[什么是标记类型 ID？](../glossary#token-type-ids)

bool_masked_pos (`torch.BoolTensor`，形状为 `(batch_size, image_num_patches)`)：布尔掩码位置。指示哪些 patch 被掩码（1），哪些未被掩码（0）。

position_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

image_attention_mask (`torch.Tensor`，形状为 `(batch_size, image_num_patches)`，*可选*) : 用于避免对图像输入中的填充像素值执行注意力机制的掩码。掩码值取自 `[0, 1]`：- 1 表示真实的像素值（即 **未掩码**），- 0 表示填充的像素值（即 **已掩码**）。

skip_multimodal_encoder (`*bool*`, *可选*) : 跳过多模态编码器的任何计算。如果不会使用多模态编码，则很有用。

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

output_hidden_states (`bool`，*可选*，默认为 `True`)：是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量中的 `hidden_states`。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** `FlavaModelOutput` 或 `tuple(torch.Tensor)`

`FlavaModelOutput` 或 `torch.Tensor` 元组（如果传入 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[FlavaConfig](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaConfig)）和输入。

[FlavaModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaModel) 的 forward 方法会重写 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **image_embeddings**（形状为 `(batch_size, output_dim)` 的 `torch.Tensor`，*可选*，当存在 `pixel_values` 时返回）-- 图像嵌入，基本上是 [FlavaImageModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageModel) 的池化输出。
- **image_output** (`BaseModelOutputWithPooling`，*可选*，当存在 `pixel_values` 时返回) -- [FlavaImageModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageModel) 的输出。
- **text_embeddings**（形状为 `(batch_size, output_dim)` 的 `torch.Tensor`，*可选*，当存在 `input_ids` 时返回）-- 文本嵌入，基本上是 [FlavaTextModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaTextModel) 的池化输出。
- **text_output**（`BaseModelOutputWithPooling`，*可选*，当存在 `input_ids` 时返回）-- [FlavaTextModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaTextModel) 的输出。
- **multimodal_embeddings** (`torch.Tensor`，形状为 `(batch_size, output_dim)`，*可选*，当 `input_ids` 和 `pixel_values` 存在且 `skip_multimodal_encoder` 为 `None` 或 `False` 时返回) -- 多模态嵌入，基本上是 [FlavaTextModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaTextModel) 的池化输出。
- **multimodal_output**（`BaseModelOutputWithPooling`，当 `input_ids` 和 `pixel_values` 存在且 `skip_multimodal_encoder` 为 `None` 或 `False` 时返回）-- [FlavaMultimodalModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaMultimodalModel) 的输出。

示例：

```python
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoProcessor, FlavaModel

>>> model = FlavaModel.from_pretrained("facebook/flava-full")
>>> processor = AutoProcessor.from_pretrained("facebook/flava-full")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> inputs = processor(text=["a photo of a cat"], images=image, return_tensors="pt", padding=True)

>>> outputs = model(**inputs)

>>> image_embeddings = outputs.image_embeddings
>>> text_embeddings = outputs.text_embeddings
>>> multimodal_embeddings = outputs.multimodal_embeddings

>>> outputs.image_embeddings.shape
torch.Size([1, 197, 768])

>>> text_embeddings.shape
torch.Size([1, 7, 768])

>>> multimodal_embeddings.shape
torch.Size([1, 205, 768])
```

#### get_text_features[[transformers.FlavaModel.get_text_features]]

```python
get_text_features(input_ids: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/modeling_flava.py#L981)

**参数：**

input_ids (`torch.LongTensor`，形状为 `(batch_size, text_seq_length)`)：输入序列词元在词汇表中的索引。可以使用 [AutoTokenizer](/docs/transformers/v5.23.0/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`，形状为 `(batch_size, text_seq_length)`，*可选*)：用于指示输入中第一和第二部分的段标记索引。索引选自 `[0, 1]`：- 0 对应 *句子 A* 标记，- 1 对应 *句子 B* 标记。[什么是标记类型 ID？](../glossary#token-type-ids)

position_ids （`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*）：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

**返回：** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `tuple(torch.Tensor)`

一个 [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[FlavaConfig](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaConfig)）和输入。

- **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
>>> import torch
>>> from transformers import AutoProcessor, FlavaModel

>>> model = FlavaModel.from_pretrained("{0}")
>>> processor = AutoProcessor.from_pretrained("{0}")

>>> inputs = processor(
...     text=["a photo of a cat", "a photo of a dog"], max_length=77, padding="max_length", return_tensors="pt"
... )
>>> with torch.inference_mode():
...     text_features = model.get_text_features(**inputs)
```

#### get_image_features[[transformers.FlavaModel.get_image_features]]

```python
get_image_features(pixel_values: Tensor, bool_masked_pos: typing.Optional[torch.BoolTensor] = None, interpolate_pos_encoding: bool | None = None, attention_mask: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/modeling_flava.py#L1032)

**参数：**

pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, image_size, image_size)`)：与输入图像对应的张量。可以使用 [FlavaImageProcessor](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageProcessor) 获取像素值。有关详细信息，请参阅 [FlavaImageProcessor.__call__()](/docs/transformers/v5.23.0/zh/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__)（[FlavaProcessor](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaProcessor) 使用 [FlavaImageProcessor](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageProcessor) 处理图像）。

bool_masked_pos (`torch.BoolTensor`，形状为 `(batch_size, image_num_patches)`)：布尔掩码位置。指示哪些 patch 被掩码（1），哪些未被掩码（0）。

interpolate_pos_encoding (`bool`, *可选*) : 是否对预训练的位置编码进行插值。

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

**返回：** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `tuple(torch.Tensor)`

一个 [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[FlavaConfig](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaConfig)）和输入。

- **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
>>> import torch
>>> from transformers import AutoProcessor, FlavaModel
>>> from transformers.image_utils import load_image

>>> model = FlavaModel.from_pretrained("{0}")
>>> processor = AutoProcessor.from_pretrained("{0}")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = load_image(url)

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

>>> with torch.inference_mode():
...     image_features = model.get_image_features(**inputs)
```

## FlavaImageCodebook[[transformers.FlavaImageCodebook]]

#### transformers.FlavaImageCodebook[[transformers.FlavaImageCodebook]]

```python
transformers.FlavaImageCodebook(config: FlavaImageCodebookConfig, **kwargs: Any)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/modeling_flava.py#L1289)

**参数：**

config ([FlavaImageCodebookConfig](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageCodebookConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化并不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

FLAVA 的图像码本模型受 DALL-E 原始编码器的启发。它输出原始隐藏状态，并可用于基于 DALL-E 的词表为图像生成图像 token。用于为 MIM 生成标签。使用 `get_codebook_indices` 获取图像的图像 token。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/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.FlavaImageCodebook.forward]]

```python
forward(pixel_values: Tensor, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/modeling_flava.py#L1374)

#### get_codebook_indices[[transformers.FlavaImageCodebook.get_codebook_indices]]

```python
get_codebook_indices(pixel_values: Tensor)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/modeling_flava.py#L1340)

#### get_codebook_probs[[transformers.FlavaImageCodebook.get_codebook_probs]]

```python
get_codebook_probs(pixel_values: Tensor)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/modeling_flava.py#L1370)

## FlavaTextModel[[transformers.FlavaTextModel]]

#### transformers.FlavaTextModel[[transformers.FlavaTextModel]]

```python
transformers.FlavaTextModel(config: FlavaTextConfig, add_pooling_layer: bool = True)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/modeling_flava.py#L759)

**参数：**

config ([FlavaTextConfig](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaTextConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化并不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

add_pooling_layer (`bool`，*可选*，默认为 `True`)：是否添加池化层

未添加任何特定头部的裸 Flava Text Model，直接输出原始隐藏状态。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/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.FlavaTextModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/modeling_flava.py#L787)

**参数：**

input_ids (`torch.LongTensor`，形状为 `(batch_size, text_seq_length)`)：输入序列词元在词汇表中的索引。可以使用 [AutoTokenizer](/docs/transformers/v5.23.0/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`，形状为 `(batch_size, text_seq_length)`，*可选*)：用于指示输入中第一和第二部分的段标记索引。索引选自 `[0, 1]`：- 0 对应 *句子 A* 标记，- 1 对应 *句子 B* 标记。[什么是标记类型 ID？](../glossary#token-type-ids)

position_ids （`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*）：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

output_hidden_states (`bool`, *可选*) : 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 `hidden_states`。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `tuple(torch.Tensor)`

一个 [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[FlavaConfig](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaConfig)）和输入。

[FlavaTextModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaTextModel) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **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 后的注意力权重，用于在自注意力头中计算加权平均值。

## FlavaImageModel[[transformers.FlavaImageModel]]

#### transformers.FlavaImageModel[[transformers.FlavaImageModel]]

```python
transformers.FlavaImageModel(config: FlavaImageConfig, add_pooling_layer: bool = True)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/modeling_flava.py#L677)

**参数：**

config ([FlavaImageConfig](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageConfig))：包含模型所有参数的模型配置类。通过配置文件进行初始化并不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

add_pooling_layer (`bool`，*可选*，默认为 `True`)：是否添加池化层

未添加任何特定头部的裸 Flava 模型，直接输出原始隐藏状态。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/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.FlavaImageModel.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, bool_masked_pos: typing.Optional[torch.BoolTensor] = None, interpolate_pos_encoding: bool | None = None, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/modeling_flava.py#L707)

**参数：**

pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, image_size, image_size)`，*可选*) : 与输入图像对应的张量。可以使用 [FlavaImageProcessor](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageProcessor) 获取像素值。有关详细信息，请参阅 [FlavaImageProcessor.__call__()](/docs/transformers/v5.23.0/zh/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__)（[FlavaProcessor](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaProcessor) 使用 [FlavaImageProcessor](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageProcessor) 来处理图像）。

bool_masked_pos (`torch.BoolTensor`，形状为 `(batch_size, image_num_patches)`)：布尔掩码位置。指示哪些 patch 被掩码（1），哪些未被掩码（0）。

interpolate_pos_encoding (`bool`, *可选*) : 是否对预训练的位置编码进行插值。

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

output_hidden_states (`bool`, *可选*) : 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 `hidden_states`。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `tuple(torch.Tensor)`

一个 [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[FlavaConfig](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaConfig)）和输入。

[FlavaImageModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaImageModel) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **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 后的注意力权重，用于在自注意力头中计算加权平均值。

## FlavaMultimodalModel[[transformers.FlavaMultimodalModel]]

#### transformers.FlavaMultimodalModel[[transformers.FlavaMultimodalModel]]

```python
transformers.FlavaMultimodalModel(config: FlavaMultimodalConfig, add_pooling_layer = True)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/modeling_flava.py#L855)

**参数：**

config ([FlavaMultimodalConfig](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaMultimodalConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化并不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

add_pooling_layer (`bool`，*可选*，默认为 `True`)：是否添加池化层

未添加任何特定头部的裸 Flava 模型，直接输出原始隐藏状态。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/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.FlavaMultimodalModel.forward]]

```python
forward(hidden_states: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flava/modeling_flava.py#L879)

**参数：**

hidden_states (`torch.Tensor`，形状为 `(batch_size, image_num_patches + text_seq_len, hidden_size)`)：单模态编码器的拼接隐藏状态。

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

output_hidden_states (`bool`, *可选*) : 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 `hidden_states`。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `tuple(torch.Tensor)`

一个 [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[FlavaConfig](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaConfig)）和输入。

[FlavaMultimodalModel](/docs/transformers/v5.23.0/zh/model_doc/flava#transformers.FlavaMultimodalModel) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **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 后的注意力权重，用于在自注意力头中计算加权平均值。