Transformers documentation
FLAVA
该模型于 2021-12-08 在 HF papers 上发布，并于 2022-05-11 贡献至 Hugging Face Transformers。
FLAVA
概述
FLAVA 模型由 Amanpreet Singh、Ronghang Hu、Vedanuj Goswami、Guillaume Couairon、Wojciech Galuba、Marcus Rohrbach 和 Douwe Kiela 在 FLAVA: A Foundational Language And Vision Alignment Model 中提出，并被 CVPR 2022 接收。
该论文旨在构建一个统一的单一基础模型，使其能够同时处理视觉、语言以及视觉-语言多模态任务。
该论文的摘要如下：
最先进的视觉模型和视觉-语言模型依赖于大规模视觉-语言预训练，以在多种下游任务上取得良好性能。通常，这类模型要么是跨模态（对比式）的，要么是多模态（早期融合）的，但不会同时兼具两者；并且它们往往只针对特定的模态或任务。一个有前景的方向是使用一个单一的、整体的通用模型作为“基础”，同时针对所有模态——一个真正的视觉与语言基础模型应当在视觉任务、语言任务以及跨模态和多模态的视觉-语言任务上均表现出色。我们提出了 FLAVA 作为这样一个模型，并在涵盖这些目标模态的 35 项广泛任务上展示了令人印象深刻的性能。
FlavaConfig
class transformers.FlavaConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneimage_config: dict[str, typing.Any] | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict[str, typing.Any] | transformers.configuration_utils.PreTrainedConfig | None = Nonemultimodal_config: dict[str, typing.Any] | transformers.configuration_utils.PreTrainedConfig | None = Noneimage_codebook_config: dict[str, typing.Any] | transformers.configuration_utils.PreTrainedConfig | None = Nonehidden_size: int = 768layer_norm_eps: float = 1e-12projection_dim: int = 768init_codebook: bool = Truelogit_scale_init_value: float = 2.6592initializer_range: float = 0.02ce_ignore_index: int = -100mim_weight: float = 1.0mlm_weight: float = 1.0global_contrastive_weight: float = 1.0itm_weight: float = 1.0mmm_image_weight: float = 1.0mmm_text_weight: float = 1.0global_backprop_contrastive: bool = Trueskip_unmasked_multimodal_encoder: bool = Truereturn_loss: bool = Truetie_word_embeddings: bool = Trueinitializer_factor: float = 1.0 )
参数
- image_config (
dict, 可选) — 用于初始化 FlavaImageConfig 的配置选项字典。 - text_config (
Union[dict[str, Any], ~configuration_utils.PreTrainedConfig]，可选) — 文本骨干网络的配置对象或字典。 - multimodal_config (
dict, 可选) — 用于初始化 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 类似的配置。
配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。
示例：
>>> 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.configFlavaTextConfig
class transformers.FlavaTextConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 30522type_vocab_size: int = 2max_position_embeddings: int = 512hidden_size: int = 768num_hidden_layers: int = 12num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.0attention_probs_dropout_prob: float | int = 0.0initializer_range: float = 0.02layer_norm_eps: float = 1e-12pad_token_id: int | None = 0qkv_bias: bool = True )
参数
- 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 类似的配置。
配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。
示例：
>>> 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.configFlavaImageConfig
class transformers.FlavaImageConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 768num_hidden_layers: int = 12num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.0attention_probs_dropout_prob: float | int = 0.0initializer_range: float = 0.02layer_norm_eps: float = 1e-12image_size: int | list[int] | tuple[int, int] = 224patch_size: int | list[int] | tuple[int, int] = 16num_channels: int = 3qkv_bias: bool = Truemask_token: bool = Truevocab_size: int = 8192 )
参数
- 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 类似的配置。
配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。
示例：
>>> 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.configFlavaMultimodalConfig
class transformers.FlavaMultimodalConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 768num_hidden_layers: int = 6num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.0attention_probs_dropout_prob: float | int = 0.0initializer_range: float = 0.02layer_norm_eps: float = 1e-12qkv_bias: bool = Trueuse_cls_token: bool = True )
参数
- 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 类似的配置。
配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。
示例：
>>> 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.configFlavaImageCodebookConfig
class transformers.FlavaImageCodebookConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonenum_groups: int = 4input_channels: int = 3num_blocks_per_group: int = 2hidden_size: int = 256vocab_size: int = 8192freeze: bool = Trueinitializer_range: float = 0.02 )
参数
- 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 类似的配置。
配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。
示例：
>>> 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.configFlavaProcessor
class transformers.FlavaProcessor
< source >( image_processor = Nonetokenizer = None**kwargs )
构建一个 FlavaProcessor，它将图像处理器和分词器封装为单一处理器。
FlavaProcessor 提供了 FlavaImageProcessor 和 BertTokenizer 的所有功能。有关更多信息，请参阅 ~FlavaImageProcessor 和 ~BertTokenizer。
__call__
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: str | list[str] | list[list[str]] | None = Nonevideos: 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] = Noneaudio: 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'> )
参数
- 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, 可选) — 如果设置，将返回特定框架的张量。可接受的值为：'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 NumPynp.ndarray对象。
- **kwargs (ProcessingKwargs，可选) — 每种模态（文本、图像、视频、音频）的额外处理选项。模型特定参数已在上方列出；有关支持参数的完整列表，请参阅 TypedDict 类。
FlavaImageProcessor
class transformers.FlavaImageProcessor
< source >( **kwargs: *<class 'transformers.models.flava.image_processing_flava.FlavaImageProcessorKwargs'> )
参数
- 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 为 int 时，是否在调整大小时默认使用正方形图像。 - 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})： 将用于 codebook 的输入调整到指定大小。可被preprocess中的codebook_size参数覆盖。 - codebook_resample (
PILImageResampling, kwargs, 可选，默认为PILImageResampling.LANCZOS) — 在对 codebook 图像进行缩放时使用的重采样滤波器。在 torchvision < 0.27 中，torch Tensor 不支持 LANCZOS，因此使用 BICUBIC 作为最接近的替代方案。可通过preprocess中的codebook_resample参数进行覆盖。 - codebook_do_center_crop (
bool, kwargs, optional, 默认为True) — 是否对用于 codebook 的输入进行中心裁剪。如果输入在任意边缘上的尺寸小于codebook_crop_size，则先用 0 填充图像，然后进行中心裁剪。可以通过preprocess中的codebook_do_center_crop参数进行覆盖。 - codebook_crop_size (
dict[str, *kwargs*, int]，可选，默认为{"height" -- 224, "width": 224})： 在对 codebook 输入应用中心裁剪时，期望的输出尺寸。可被preprocess中的codebook_crop_size参数覆盖。 - codebook_do_rescale (
bool，kwargs，可选，默认为True) — 是否使用指定的缩放因子codebook_rescale_factor对 codebook 的输入进行重新缩放。可以通过preprocess中的codebook_do_rescale参数进行覆盖。 - codebook_rescale_factor (
int、kwargs 或float，可选，默认为1/255) — 定义在对 codebook 图像进行重新缩放时所使用的缩放因子。可被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对 codebook 的输入进行归一化。可通过preprocess中的codebook_do_normalize参数进行覆盖。 - codebook_image_mean (
Optional[Union[float, *kwargs*, Iterable[float]]]，可选，默认为[0, 0, 0]) — 用于对 codebook 图像进行归一化时，各通道的均值序列。可通过preprocess中的codebook_image_mean参数覆盖。 - codebook_image_std (
Optional[Union[float, *kwargs*, Iterable[float]]]，可选，默认为[0.5, 0.5, 0.5]) — 用于对码本图像进行归一化时，各通道的标准差序列。可通过preprocess中的codebook_image_std参数进行覆盖。
构建一个 FlavaImageProcessor 图像处理器。
预处理
< source >( 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'> ) → ~image_processing_base.BatchFeature
参数
- 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 为整数时，是否在调整大小时默认使用正方形图像。 - 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})： 将用于 codebook 的输入调整到指定大小。可被preprocess中的codebook_size参数覆盖。 - codebook_resample (
PILImageResampling, kwargs, 可选，默认为PILImageResampling.LANCZOS) — 在对 codebook 图像进行缩放时使用的重采样滤波器。在 torchvision < 0.27 中，torch Tensor 不支持 LANCZOS，因此使用 BICUBIC 作为最接近的替代方案。可通过preprocess中的codebook_resample参数进行覆盖。 - codebook_do_center_crop (
bool, kwargs, optional, 默认为True) — 是否对用于 codebook 的输入进行中心裁剪。如果输入在任意边缘上的尺寸小于codebook_crop_size，则先用 0 填充图像，然后进行中心裁剪。可以通过preprocess中的codebook_do_center_crop参数进行覆盖。 - codebook_crop_size (
dict[str, *kwargs*, int]，可选，默认为{"height" -- 224, "width": 224})： 在对 codebook 输入应用中心裁剪时，期望的输出尺寸。可被preprocess中的codebook_crop_size参数覆盖。 - codebook_do_rescale (
bool，kwargs，可选，默认为True) — 是否使用指定的缩放因子codebook_rescale_factor对 codebook 的输入进行重新缩放。可以通过preprocess中的codebook_do_rescale参数进行覆盖。 - codebook_rescale_factor (
int、kwargs 或float，可选，默认为1/255) — 定义在对 codebook 图像进行重新缩放时所使用的缩放因子。可被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对 codebook 的输入进行归一化。可通过preprocess中的codebook_do_normalize参数进行覆盖。 - codebook_image_mean (
Optional[Union[float, *kwargs*, Iterable[float]]]，可选，默认为[0, 0, 0]) — 用于对 codebook 图像进行归一化时，各通道的均值序列。可通过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
class transformers.FlavaImageProcessorPil
< source >( **kwargs: *<class 'transformers.models.flava.image_processing_pil_flava.FlavaImageProcessorKwargs'> )
参数
- 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 为 int 时，是否在调整大小时默认使用正方形图像。 - 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})： 将用于 codebook 的输入调整到指定大小。可被preprocess中的codebook_size参数覆盖。 - codebook_resample (
PILImageResampling, kwargs, 可选，默认为PILImageResampling.LANCZOS) — 在对 codebook 图像进行缩放时使用的重采样滤波器。在 torchvision < 0.27 中，torch Tensor 不支持 LANCZOS，因此使用 BICUBIC 作为最接近的替代方案。可通过preprocess中的codebook_resample参数进行覆盖。 - codebook_do_center_crop (
bool, kwargs, optional, 默认为True) — 是否对用于 codebook 的输入进行中心裁剪。如果输入在任意边缘上的尺寸小于codebook_crop_size，则先用 0 填充图像，然后进行中心裁剪。可以通过preprocess中的codebook_do_center_crop参数进行覆盖。 - codebook_crop_size (
dict[str, *kwargs*, int]，可选，默认为{"height" -- 224, "width": 224})： 在对 codebook 输入应用中心裁剪时，期望的输出尺寸。可被preprocess中的codebook_crop_size参数覆盖。 - codebook_do_rescale (
bool，kwargs，可选，默认为True) — 是否使用指定的缩放因子codebook_rescale_factor对 codebook 的输入进行重新缩放。可以通过preprocess中的codebook_do_rescale参数进行覆盖。 - codebook_rescale_factor (
int、kwargs 或float，可选，默认为1/255) — 定义在对 codebook 图像进行重新缩放时所使用的缩放因子。可被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对 codebook 的输入进行归一化。可通过preprocess中的codebook_do_normalize参数进行覆盖。 - codebook_image_mean (
Optional[Union[float, *kwargs*, Iterable[float]]]，可选，默认为[0, 0, 0]) — 用于对 codebook 图像进行归一化时，各通道的均值序列。可通过preprocess中的codebook_image_mean参数覆盖。 - codebook_image_std (
Optional[Union[float, *kwargs*, Iterable[float]]]，可选，默认为[0.5, 0.5, 0.5]) — 用于对码本图像进行归一化时，各通道的标准差序列。可通过preprocess中的codebook_image_std参数进行覆盖。
构建一个 FlavaImageProcessor 图像处理器。
预处理
< source >( 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'> ) → ~image_processing_base.BatchFeature
参数
- 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 为整数时，是否在调整大小时默认使用正方形图像。 - 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})： 将用于 codebook 的输入调整到指定大小。可被preprocess中的codebook_size参数覆盖。 - codebook_resample (
PILImageResampling, kwargs, 可选，默认为PILImageResampling.LANCZOS) — 在对 codebook 图像进行缩放时使用的重采样滤波器。在 torchvision < 0.27 中，torch Tensor 不支持 LANCZOS，因此使用 BICUBIC 作为最接近的替代方案。可通过preprocess中的codebook_resample参数进行覆盖。 - codebook_do_center_crop (
bool, kwargs, optional, 默认为True) — 是否对用于 codebook 的输入进行中心裁剪。如果输入在任意边缘上的尺寸小于codebook_crop_size，则先用 0 填充图像，然后进行中心裁剪。可以通过preprocess中的codebook_do_center_crop参数进行覆盖。 - codebook_crop_size (
dict[str, *kwargs*, int]，可选，默认为{"height" -- 224, "width": 224})： 在对 codebook 输入应用中心裁剪时，期望的输出尺寸。可被preprocess中的codebook_crop_size参数覆盖。 - codebook_do_rescale (
bool，kwargs，可选，默认为True) — 是否使用指定的缩放因子codebook_rescale_factor对 codebook 的输入进行重新缩放。可以通过preprocess中的codebook_do_rescale参数进行覆盖。 - codebook_rescale_factor (
int、kwargs 或float，可选，默认为1/255) — 定义在对 codebook 图像进行重新缩放时所使用的缩放因子。可被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对 codebook 的输入进行归一化。可通过preprocess中的codebook_do_normalize参数进行覆盖。 - codebook_image_mean (
Optional[Union[float, *kwargs*, Iterable[float]]]，可选，默认为[0, 0, 0]) — 用于对 codebook 图像进行归一化时，各通道的均值序列。可通过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
class transformers.FlavaForPreTraining
< source >( config: FlavaConfigimage_codebook: typing.Optional[torch.nn.Module] = None )
参数
- config (FlavaConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
- image_codebook (
torch.nn.Module, 可选) — 如果传入该参数，图像码本将被设置为该值。否则，将首先使用 config 中定义的 image_codebook_config 作为第一个参数进行初始化。
用于预训练的 FLAVA 模型，输出损失、嵌入、logits 和 transformer 输出。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneinput_ids_masked: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonecodebook_pixel_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Nonebool_masked_pos: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneimage_attention_mask: typing.Optional[torch.Tensor] = Noneskip_unmasked_multimodal_encoder: bool | None = Nonemlm_labels: typing.Optional[torch.Tensor] = Nonemim_labels: typing.Optional[torch.Tensor] = Noneitm_labels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool = Truereturn_dict: bool | None = Nonereturn_loss: bool | None = None**kwargs ) → FlavaForPreTrainingOutput or tuple(torch.Tensor)
参数
- input_ids（形状为
(batch_size, text_seq_len)的torch.LongTensor）— 输入序列中各个 token 在词汇表中的索引。可以使用 AutoTokenizer 获取这些索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？ - input_ids_masked（形状为
(batch_size, text_seq_len)的torch.LongTensor）— 输入序列中各 token 在词汇表中的索引。这些是原始任务的掩码版本，用于 MLM。可以使用 AutoTokenizer 配合DataCollatorForMaskedLanguageModeling获取这些索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？ - pixel_values (
torch.Tensor，形状为(batch_size, num_channels, image_size, image_size)，可选) — 与输入图像对应的张量。可以使用 FlavaImageProcessor 获取像素值。有关详细信息，请参阅 FlavaImageProcessor.call()（FlavaProcessor 使用 FlavaImageProcessor 来处理图像）。 - codebook_pixel_values (
torch.Tensor，形状为(batch_size, num_image_patches, patch_size, patch_size, 3)，可选) — 用于计算掩码图像建模中图像码本标签的图像块像素值。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- token_type_ids (
torch.LongTensor形状为(batch_size, text_seq_len), ，可选) — 用于指示输入中第一和第二部分的片段标记索引。索引取值范围为[0, 1]:- 0 对应 sentence A 标记，
- 1 对应于 sentence B 标记。 什么是标记类型 ID？
- bool_masked_pos（形状为
(batch_size, image_num_patches)的torch.BoolTensor）— 布尔掩码位置。指示哪些 patch 被掩码（1），哪些未被掩码（0）。 - position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - image_attention_mask (
torch.Tensor形状为(batch_size, image_num_patches), 可选) — 用于避免对图像中填充 token 索引执行注意力的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被屏蔽的 token，值为 0。 什么是注意力掩码？
- skip_unmasked_multimodal_encoder (
*bool*, 可选) — 对于未掩码的输入，跳过多模态编码器的任何计算。目前，FLAVA 预训练不需要未掩码的多模态嵌入或输出。 - mlm_labels（形状为
(batch_size, text_seq_len)的torch.LongTensor，可选） — 用于计算从左到右的语言和多模态掩码建模损失（下一个词预测）的标签。 索引应在[-100, 0, ..., text_config.vocab_size - 1]范围内（参见input_ids的文档字符串）。索引设置为-100的 token 将被忽略（掩码），损失仅针对标签在[0, ..., text_config.vocab_size - 1]范围内的 token 进行计算。 - mim_labels (
torch.LongTensor，形状为(batch_size, image_num_patches)，可选) — 用于计算图像和多模态掩码建模损失的标签。索引应在[-100, 0, ..., image_config.vocab_size - 1]范围内。索引设置为-100的 token 会被忽略（即被掩码），损失仅针对标签在[0, ..., image_config.vocab_size - 1]范围内的 token 进行计算。如果未传入该参数，则会使用分配给模型的图像码本自动生成。默认情况下，它使用 FlavaImageCodebook。请参阅 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 而不是普通元组。 - return_loss (
bool，可选，默认为 None) — 是否返回计算出的损失。
返回值
FlavaForPreTrainingOutput 或 tuple(torch.Tensor)
FlavaForPreTrainingOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（FlavaConfig）和输入。
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 的池化输出。 - image_output（
BaseModelOutputWithPooling，可选，当存在pixel_values时返回）— FlavaImageModel 的输出。 - text_embeddings（形状为
(batch_size, output_dim)的torch.Tensor，可选，当存在input_ids时返回） — 文本嵌入，基本上是 FlavaTextModel 的池化输出。 - text_output（
BaseModelOutputWithPooling，可选，当存在input_ids时返回）— FlavaTextModel 的输出。 - multimodal_embeddings (
torch.Tensor，形状为(batch_size, output_dim)，可选，当input_ids和pixel_values存在且skip_unmasked_multimodal_encoder为None或False时返回) — 多模态嵌入，基本上是 FlavaTextModel 的池化输出。 - multimodal_output（
BaseModelOutputWithPooling，当input_ids和pixel_values存在且skip_unmasked_multimodal_encoder为None或False时返回）—— FlavaMultimodalModel 的输出。 - image_masked_embeddings（形状为
(batch_size, output_dim)的torch.Tensor，可选，当存在pixel_values时返回） — 图像嵌入，基本上是 FlavaImageModel 的池化输出。使用bool_masked_pos来创建掩码图像。 - image_masked_output（
BaseModelOutputWithPooling，可选，当存在pixel_values时返回） — FlavaImageModel 的输出。使用bool_masked_pos创建掩码图像。 - text_masked_embeddings（形状为
(batch_size, output_dim)的torch.Tensor，可选，当存在input_ids_masked时返回） — 文本嵌入，基本上是 FlavaTextModel 的池化输出。 - text_masked_output（
BaseModelOutputWithPooling，可选，当存在input_ids_masked时返回）— FlavaTextModel 的输出。 - multimodal_masked_embeddings（形状为
(batch_size, output_dim)的torch.Tensor，可选，当存在input_ids和pixel_values时返回）—— 多模态嵌入，基本上是 FlavaTextModel 的池化输出。 - multimodal_masked_output（
BaseModelOutputWithPooling，可选，当存在input_ids_masked和pixel_values时返回）—— 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 被掩码时，返回展平后的输出。
示例：
>>> 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
class transformers.FlavaModel
< source >( config: FlavaConfig )
参数
- config (FlavaConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
未添加任何特定头部的裸 Flava 模型，直接输出原始隐藏状态。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Nonebool_masked_pos: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneimage_attention_mask: typing.Optional[torch.Tensor] = Noneskip_multimodal_encoder: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool = Truereturn_dict: bool | None = None**kwargs ) → FlavaModelOutput or tuple(torch.Tensor)
参数
- input_ids（形状为
(batch_size, image_num_patches + text_seq_len)的torch.LongTensor）— 输入序列中 token 在词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？ - pixel_values (
torch.Tensor，形状为(batch_size, num_channels, image_size, image_size)，可选) — 与输入图像对应的张量。可以使用 FlavaImageProcessor 获取像素值。有关详细信息，请参阅 FlavaImageProcessor.call()（FlavaProcessor 使用 FlavaImageProcessor 来处理图像）。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- token_type_ids (
torch.LongTensor形状为(batch_size, image_num_patches + text_seq_len), 可选) — 用于指示输入中第一和第二部分的分段标记索引。索引取自[0, 1]:- 0 对应 sentence A 标记，
- 1 对应于 sentence B 标记。 什么是标记类型 ID？
- bool_masked_pos（形状为
(batch_size, image_num_patches)的torch.BoolTensor）— 布尔掩码位置。指示哪些 patch 被掩码（1），哪些未被掩码（0）。 - position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - image_attention_mask (
torch.Tensor形状为(batch_size, image_num_patches), 可选) — 用于避免对图像输入中的填充像素值执行注意力机制的掩码。掩码值取自[0, 1]:- 对于像素值为真实值（即未被掩码）的情况，
- 对于填充（即 被屏蔽）的像素值，值为 0。
- skip_multimodal_encoder (
*bool*，可选) — 跳过多模态编码器的任何计算。如果不会使用多模态编码，此参数非常有用。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选，默认为True) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
FlavaModelOutput 或 tuple(torch.Tensor)
FlavaModelOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（FlavaConfig）和输入。
FlavaModel 的 forward 方法会重写 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
- image_embeddings（形状为
(batch_size, output_dim)的torch.Tensor，可选，当存在pixel_values时返回） — 图像嵌入，基本上是 FlavaImageModel 的池化输出。 - image_output（
BaseModelOutputWithPooling，可选，当存在pixel_values时返回）— FlavaImageModel 的输出。 - text_embeddings（形状为
(batch_size, output_dim)的torch.Tensor，可选，当存在input_ids时返回） — 文本嵌入，基本上是 FlavaTextModel 的池化输出。 - text_output（
BaseModelOutputWithPooling，可选，当存在input_ids时返回）— FlavaTextModel 的输出。 - multimodal_embeddings (
torch.Tensor，形状为(batch_size, output_dim)，可选，当input_ids和pixel_values存在且skip_multimodal_encoder为None或False时返回) — 多模态嵌入，基本上是 FlavaTextModel 的池化输出。 - multimodal_output（
BaseModelOutputWithPooling，当input_ids和pixel_values存在且skip_multimodal_encoder为None或False时返回）—— FlavaMultimodalModel 的输出。
示例：
>>> 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
< source >( input_ids: Tensorattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
参数
- input_ids（形状为
(batch_size, text_seq_length)的torch.LongTensor）— 输入序列中各 token 在词汇表中的索引。可以使用 AutoTokenizer 获取这些索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？ - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- token_type_ids (
torch.LongTensor形状为(batch_size, text_seq_length), 可选) — 用于指示输入中第一和第二部分的片段标记索引。索引取自[0, 1]:- 0 对应 sentence A 标记，
- 1 对应于 sentence B 标记。 什么是标记类型 ID？
- position_ids (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1].
返回值
BaseModelOutputWithPooling 或 tuple(torch.Tensor)
一个 BaseModelOutputWithPooling 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（FlavaConfig）和输入。
last_hidden_state（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor）— 模型最后一层输出的隐藏状态序列。pooler_output (
torch.Tensor，形状为(batch_size, hidden_size)) — 序列中第一个 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 之后的权重，用于在自注意力头中计算加权平均值。
示例：
>>> 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
< source >( pixel_values: Tensorbool_masked_pos: typing.Optional[torch.BoolTensor] = Noneinterpolate_pos_encoding: bool | None = Noneattention_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
参数
- pixel_values（形状为
(batch_size, num_channels, image_size, image_size)的torch.Tensor）— 与输入图像对应的张量。可以使用 FlavaImageProcessor 获取像素值。有关详细信息，请参阅 FlavaImageProcessor.call()（FlavaProcessor 使用 FlavaImageProcessor 来处理图像）。 - bool_masked_pos（形状为
(batch_size, image_num_patches)的torch.BoolTensor）— 布尔掩码位置。指示哪些 patch 被掩码（1），哪些未被掩码（0）。 - interpolate_pos_encoding (
bool, 可选) — 是否对预训练的位置编码进行插值。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
返回值
BaseModelOutputWithPooling 或 tuple(torch.Tensor)
一个 BaseModelOutputWithPooling 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（FlavaConfig）和输入。
last_hidden_state（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor）— 模型最后一层输出的隐藏状态序列。pooler_output (
torch.Tensor，形状为(batch_size, hidden_size)) — 序列中第一个 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 之后的权重，用于在自注意力头中计算加权平均值。
示例：
>>> 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
class transformers.FlavaImageCodebook
< source >( config: FlavaImageCodebookConfig**kwargs: Any )
参数
- config (FlavaImageCodebookConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
FLAVA 的图像码本模型受 DALL-E 原始编码器的启发。它输出原始隐藏状态，并可用于基于 DALL-E 的词表为图像生成图像 token。该模型用于为 MIM 生成标签。使用 get_codebook_indices 来获取图像的图像 token。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
FlavaTextModel
class transformers.FlavaTextModel
< source >( config: FlavaTextConfigadd_pooling_layer: bool = True )
参数
- config (FlavaTextConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
- add_pooling_layer (
bool，可选，默认为True) — 是否添加池化层
未添加任何特定头部的裸 Flava Text Model，直接输出原始隐藏状态。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
参数
- input_ids（形状为
(batch_size, text_seq_length)的torch.LongTensor）— 输入序列中各 token 在词汇表中的索引。可以使用 AutoTokenizer 获取这些索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？ - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- token_type_ids (
torch.LongTensor形状为(batch_size, text_seq_length), 可选) — 用于指示输入中第一和第二部分的片段标记索引。索引取自[0, 1]:- 0 对应 sentence A 标记，
- 1 对应于 sentence B 标记。 什么是标记类型 ID？
- position_ids (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
BaseModelOutputWithPooling 或 tuple(torch.Tensor)
一个 BaseModelOutputWithPooling 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（FlavaConfig）和输入。
FlavaTextModel 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
last_hidden_state（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor）— 模型最后一层输出的隐藏状态序列。pooler_output (
torch.Tensor，形状为(batch_size, hidden_size)) — 序列中第一个 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
class transformers.FlavaImageModel
< source >( config: FlavaImageConfigadd_pooling_layer: bool = True )
参数
- config (FlavaImageConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
- add_pooling_layer (
bool，可选，默认为True) — 是否添加池化层
未添加任何特定头部的裸 Flava 模型，直接输出原始隐藏状态。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( pixel_values: typing.Optional[torch.Tensor] = Nonebool_masked_pos: typing.Optional[torch.BoolTensor] = Noneinterpolate_pos_encoding: bool | None = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
参数
- pixel_values (
torch.Tensor，形状为(batch_size, num_channels, image_size, image_size)，可选) — 与输入图像对应的张量。可以使用 FlavaImageProcessor 获取像素值。有关详细信息，请参阅 FlavaImageProcessor.call()（FlavaProcessor 使用 FlavaImageProcessor 来处理图像）。 - bool_masked_pos（形状为
(batch_size, image_num_patches)的torch.BoolTensor）— 布尔掩码位置。指示哪些 patch 被掩码（1），哪些未被掩码（0）。 - interpolate_pos_encoding (
bool, 可选) — 是否对预训练的位置编码进行插值。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
BaseModelOutputWithPooling 或 tuple(torch.Tensor)
一个 BaseModelOutputWithPooling 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（FlavaConfig）和输入。
FlavaImageModel 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
last_hidden_state（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor）— 模型最后一层输出的隐藏状态序列。pooler_output (
torch.Tensor，形状为(batch_size, hidden_size)) — 序列中第一个 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
class transformers.FlavaMultimodalModel
< source >( config: FlavaMultimodalConfigadd_pooling_layer = True )
参数
- config (FlavaMultimodalConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
- add_pooling_layer (
bool，可选，默认为True) — 是否添加池化层
未添加任何特定头部的裸 Flava 模型，直接输出原始隐藏状态。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( hidden_states: Tensorattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
参数
- hidden_states (
torch.Tensor，形状为(batch_size, image_num_patches + text_seq_len, hidden_size)) — 单模态编码器的拼接隐藏状态。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
BaseModelOutputWithPooling 或 tuple(torch.Tensor)
一个 BaseModelOutputWithPooling 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（FlavaConfig）和输入。
FlavaMultimodalModel 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
last_hidden_state（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor）— 模型最后一层输出的隐藏状态序列。pooler_output (
torch.Tensor，形状为(batch_size, hidden_size)) — 序列中第一个 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 之后的权重，用于在自注意力头中计算加权平均值。