该模型于 2021 年 6 月 15 日在 HF papers 上发布，并于 2021 年 8 月 4 日贡献给 Hugging Face Transformers。

BEiT

概述

BEiT 模型由 Hangbo Bao, Li Dong 和 Furu Wei 在 BEiT: BERT Pre-Training of Image Transformers 一文中提出。受 BERT 的启发，BEiT 是第一篇证明视觉 Transformer (ViTs) 的自监督预训练可以优于监督预训练的论文。与原始 ViT 论文中通过预训练模型来预测图像类别不同，BEiT 模型是通过预训练来预测给定掩码补丁（masked patches）时来自 OpenAI DALL-E 模型码本（codebook）中的视觉标记（visual tokens）。

论文摘要如下：

我们引入了一种自监督视觉表示模型 BEiT，它是 Bidirectional Encoder representation from Image Transformers（来自图像 Transformer 的双向编码器表示）的缩写。参考自然语言处理领域开发的 BERT，我们提出了掩码图像建模任务来预训练视觉 Transformer。具体来说，在我们的预训练中，每张图像有两种视图，即图像补丁（例如 16x16 像素）和视觉标记（即离散标记）。我们首先将原始图像“标记化”为视觉标记。然后，我们随机掩盖一些图像补丁并将它们输入到主干 Transformer 中。预训练的目标是根据损坏的图像补丁恢复原始的视觉标记。在预训练 BEiT 之后，我们通过在预训练编码器之上附加任务层，直接在下游任务上微调模型参数。在图像分类和语义分割方面的实验结果表明，我们的模型在预训练方法上取得了竞争性的结果。例如，基础版 BEiT 在 ImageNet-1K 上达到了 83.2% 的 top-1 准确率，在相同设置下显著优于从头开始训练的 DeiT (81.8%)。此外，大型版 BEiT 仅使用 ImageNet-1K 就获得了 86.3% 的准确率，甚至超过了在 ImageNet-22K 上进行监督预训练的 ViT-L (85.2%)。

该模型由 nielsr 贡献。原始代码可以在这里找到。

使用技巧

BEiT 模型是常规的视觉 Transformer，但以自监督而非监督的方式进行预训练。当在 ImageNet-1K 和 CIFAR-100 上进行微调时，它们的表现优于原始模型 (ViT) 和数据高效图像 Transformer (DeiT)。您可以在这里查看关于推理以及在自定义数据上微调的演示笔记本（您只需将 ViTImageProcessor 替换为 BeitImageProcessor，将 ViTForImageClassification 替换为 BeitForImageClassification）。
此外还有一个演示笔记本，展示了如何结合 DALL-E 的图像标记器与 BEiT 来执行掩码图像建模。您可以在这里找到它。
由于 BEiT 模型要求每张图像具有相同的大小（分辨率），因此可以使用 BeitImageProcessor 对图像进行调整大小（或重新缩放）和归一化，以供模型使用。
预训练或微调期间使用的补丁分辨率和图像分辨率都反映在每个检查点的名称中。例如，microsoft/beit-base-patch16-224 指的是具有 16x16 补丁分辨率和 224x224 微调分辨率的基础架构。所有检查点都可以在 hub 上找到。
可用的检查点分为：(1) 仅在 ImageNet-22k（包含 1400 万张图像和 2.2 万个类别）上预训练的，(2) 也在 ImageNet-22k 上进行过微调的，或 (3) 也在 ImageNet-1k（也称为 ILSVRC 2012，包含 130 万张图像和 1,000 个类别）上进行过微调的。
BEiT 使用了受 T5 模型启发的相对位置嵌入。在预训练期间，作者在多个自注意力层之间共享了相对位置偏差。在微调期间，每一层的相对位置偏差都使用预训练后获得的共享相对位置偏差进行初始化。注意，如果想从头开始预训练模型，需要将 BeitConfig 的 use_relative_position_bias 或 use_relative_position_bias 属性设置为 True，以添加位置嵌入。

BEiT 预训练。取自原始论文。

使用缩放点积注意力 (SDPA)

PyTorch 在 torch.nn.functional 中包含一个原生的缩放点积注意力 (SDPA) 算子。此函数包含几个实现，具体取决于输入和使用的硬件。有关更多信息，请参阅官方文档或GPU 推理页面。

当实现可用时，SDPA 默认用于 `torch>=2.1.1`，但你也可以在 `from_pretrained()` 中设置 `attn_implementation="sdpa"` 来明确请求使用 SDPA。

from transformers import BeitForImageClassification


model = BeitForImageClassification.from_pretrained("microsoft/beit-base-patch16-224", attn_implementation="sdpa", device_map="auto")
...

为了获得最佳加速效果，我们建议以半精度（例如 `torch.float16` 或 `torch.bfloat16`）加载模型。

在本地基准测试（NVIDIA GeForce RTX 2060-8GB，PyTorch 2.5.1，OS Ubuntu 20.04）中，使用 float16 和 microsoft/beit-base-patch16-224 模型，我们在训练和推理过程中观察到了以下改进：

训练

训练步数	批处理大小	图像大小	是否使用 CUDA	每批次时间（Eager - 秒）	每批次时间（SDPA - 秒）	加速（%）	Eager 峰值内存（MB）	SDPA 峰值内存（MB）	内存节省（%）
50	2	(1048, 640)	True	0.984	0.746	31.975	6738.915	4319.886	55.998

推理

图像批处理大小	Eager (秒/迭代)	Eager 置信区间, %	Eager 内存 (MB)	SDPA (秒/迭代)	SDPA 置信区间, %	SDPA 内存 (MB)	SDPA 加速比	SDPA 节省内存 (%)
1	0.012	±0.3%	3.76657e+08	0.011	±0.5%	3.75739e+08	1.05	0.244
4	0.013	±0.1%	4.03147e+08	0.011	±0.2%	3.90554e+08	1.178	3.225
16	0.045	±0.1%	4.96697e+08	0.035	±0.1%	4.51232e+08	1.304	10.076
32	0.088	±0.1%	6.24417e+08	0.066	±0.1%	5.33488e+08	1.325	17.044

资源

官方 Hugging Face 和社区（用 🌎 表示）资源列表，帮助您上手 BEiT。

图像分类

BeitForImageClassification 受到此示例脚本和笔记本的支持。
另请参阅：图像分类任务指南

语义分割

语义分割任务指南

如果您有兴趣在此处提交资源，请随时开启 Pull Request，我们将对其进行审查！该资源最好能展示一些新内容，而不是重复现有资源。

BEiT 特有输出

class transformers.models.beit.modeling_beit.BeitModelOutputWithPooling

< source >

( last_hidden_state: torch.FloatTensor | None = None pooler_output: torch.FloatTensor | None = None hidden_states: tuple[torch.FloatTensor, ...] | None = None attentions: tuple[torch.FloatTensor, ...] | None = None )

参数

last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
pooler_output (torch.FloatTensor，形状为 (batch_size, hidden_size)) — 如果 config.use_mean_pooling 设置为 True，则为补丁标记（不包括 [CLS] 标记）的最后一层隐藏状态的平均值。如果设置为 False，则将返回 [CLS] 标记的最终隐藏状态。
hidden_states (tuple(torch.FloatTensor)，可选，当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（如果模型有嵌入层，则第一个为嵌入输出，后续为每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型每一层的隐藏状态加上可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor)，可选，当传入 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

BeitModel 的输出类。

BeitConfig

class transformers.BeitConfig

< source >

( 包含所有配置参数的类定义... )

参数

vocab_size (int，可选，默认为 8192) — 模型词汇表大小。定义了 input_ids 可以表示的不同标记的数量。
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 probability）。
attention_probs_dropout_prob (Union[float, int]，可选，默认为 0.0) — 注意力概率的丢弃率。
initializer_range (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
layer_norm_eps (float，可选，默认为 1e-12) — 层归一化层使用的 epsilon 值。
image_size (Union[int, list[int], tuple[int, int]], optional, defaults to 224) — 每个图像的尺寸（分辨率）。
patch_size (Union[int, list[int], tuple[int, int]], optional, defaults to 16) — 每个补丁（patch）的尺寸（分辨率）。
num_channels (int, optional, defaults to 3) — 输入通道的数量。
use_mask_token (bool, optional, defaults to False) — 是否在掩码图像建模（masked image modeling）中使用掩码标记（mask token）。
use_absolute_position_embeddings (bool, optional, defaults to False) — 是否使用绝对位置嵌入。
use_relative_position_bias (bool, optional, defaults to False) — 是否在自注意力层中使用 T5 风格的相对位置偏差。
use_shared_relative_position_bias (bool, optional, defaults to False) — 是否在 Transformer 的所有自注意力层中共享相同的相对位置偏差。
layer_scale_init_value (float, optional, defaults to 0.1) — 自注意力层中使用的缩放比例。Base 模型为 0.1，Large 模型为 1e-6。设置为 0 可禁用层缩放。
drop_path_rate (Union[float, int], optional, defaults to 0.1) — 补丁融合的 Drop path 比率。
use_mean_pooling (bool, optional, defaults to True) — 在应用分类头之前，是否对补丁的最终隐藏状态进行平均池化，而不是使用 CLS 标记的最终隐藏状态。
pool_scales (tuple[int], optional, defaults to [1, 2, 3, 6]) — 应用于最后一个特征图的池化金字塔模块中使用的池化比例。
use_auxiliary_head (bool, optional, defaults to True) — 训练期间是否使用辅助头（auxiliary head）。
auxiliary_loss_weight (float, optional, defaults to 0.4) — 辅助头的交叉熵损失的权重。
auxiliary_channels (int, optional, defaults to 256) — 辅助头中使用的通道数量。
auxiliary_num_convs (int, optional, defaults to 1) — 辅助头中使用的卷积层数量。
auxiliary_concat_input (bool, optional, defaults to False) — 是否在分类层之前将辅助头的输出与输入进行拼接。
semantic_loss_ignore_index (int, optional, defaults to 255) — 语义分割模型的损失函数所忽略的索引。
add_fpn (bool, optional, defaults to False) — 是否添加 FPN 作为骨干网络的一部分。仅对 BeitBackbone 有效。
reshape_hidden_states (bool, optional, defaults to True) — 当模型用作骨干网络时，是否将特征图重塑为形状为 (batch_size, hidden_size, height, width) 的 4D 张量。如果为 False，特征图将是形状为 (batch_size, seq_len, hidden_size) 的 3D 张量。仅对 BeitBackbone 有效。

这是用于存储 BeitModel 配置的配置类。它根据指定的参数实例化 Beit 模型，从而定义模型架构。使用默认值实例化配置将产生与 microsoft/beit-base-patch16-224-pt22k 相似的配置。

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

示例

>>> from transformers import BeitConfig, BeitModel

>>> # Initializing a BEiT beit-base-patch16-224-pt22k style configuration
>>> configuration = BeitConfig()

>>> # Initializing a model (with random weights) from the beit-base-patch16-224-pt22k style configuration
>>> model = BeitModel(configuration)

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

BeitImageProcessor

class transformers.BeitImageProcessor

< 源代码 >

( **kwargs: typing_extensions.Unpack[transformers.models.beit.image_processing_beit.BeitImageProcessorKwargs] )

参数

do_reduce_labels (bool, kwargs, optional, defaults to self.do_reduce_labels) — 是否将分割图的所有标签值减 1。通常用于背景标记为 0 且背景本身未包含在数据集所有类别中的数据集（例如 ADE20k）。背景标签将被替换为 255。
**kwargs (ImagesKwargs, optional) — 其他图像预处理选项。模型特定的 kwargs 列于上方；有关支持参数的完整列表，请参阅 TypedDict 类。

构建 BeitImageProcessor 图像处理器。

preprocess

< 源代码 >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None **kwargs: typing_extensions.Unpack[transformers.models.beit.image_processing_beit.BeitImageProcessorKwargs] ) → ~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。
segmentation_maps (ImageInput, optional) — 要预处理的分割图。
do_reduce_labels (bool, kwargs, optional, defaults to self.do_reduce_labels) — 是否将分割图的所有标签值减 1。通常用于背景标记为 0 且背景本身未包含在数据集所有类别中的数据集（例如 ADE20k）。背景标签将被替换为 255。
return_tensors (str or TensorType, optional) — 如果设置为 'pt'，则返回堆叠的张量，否则返回张量列表。
**kwargs (ImagesKwargs, optional) — 其他图像预处理选项。模型特定的 kwargs 列于上方；有关支持参数的完整列表，请参阅 TypedDict 类。

~image_processing_base.BatchFeature

data (dict) — 由 call 方法返回的列表/数组/张量字典（“pixel_values”等）。
tensor_type (Union[None, str, TensorType], optional) — 您可以在此处提供 tensor_type 以在初始化时将整数列表转换为 PyTorch/Numpy 张量。

post_process_semantic_segmentation

< 源代码 >

( outputs target_sizes: list[tuple] | None = None ) → semantic_segmentation

参数

outputs (BeitForSemanticSegmentation) — 模型的原始输出。
target_sizes (长度为 batch_size 的 list[Tuple]，可选) — 对应于每个预测所需的最终尺寸（高，宽）的元组列表。如果未设置，则不会调整预测结果的大小。

语义分割

list[torch.Tensor] of length batch_size, where each item is a semantic segmentation map of shape (height, width) corresponding to the target_sizes entry (if target_sizes is specified). Each entry of each torch.Tensor correspond to a semantic class id.

将 BeitForSemanticSegmentation 的输出转换为语义分割图。

BeitImageProcessorPil

class transformers.BeitImageProcessorPil

< 源代码 >

( **kwargs: typing_extensions.Unpack[transformers.models.beit.image_processing_pil_beit.BeitImageProcessorKwargs] )

参数

do_reduce_labels (bool, kwargs, 可选, 默认为 self.do_reduce_labels) — 是否将分割图中的所有标签值减 1。通常用于数据集（例如 ADE20k）中 0 用作背景，且背景本身未包含在数据集的所有类别中的情况。背景标签将被替换为 255。
**kwargs (ImagesKwargs, 可选) — 其他图像预处理选项。模型特定的 kwargs 列在上面；请参阅 TypedDict 类以获取支持参数的完整列表。

构建 BeitImageProcessor 图像处理器。

preprocess

< 源代码 >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None **kwargs: typing_extensions.Unpack[transformers.models.beit.image_processing_pil_beit.BeitImageProcessorKwargs] ) → ~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。
segmentation_maps (ImageInput, 可选) — 要预处理的分割图。
do_reduce_labels (bool, kwargs, 可选, 默认为 self.do_reduce_labels) — 是否将分割图中的所有标签值减 1。通常用于数据集（例如 ADE20k）中 0 用作背景，且背景本身未包含在数据集的所有类别中的情况。背景标签将被替换为 255。
return_tensors (str 或 TensorType, 可选) — 如果设置为 'pt'，则返回堆叠的张量，否则返回张量列表。
**kwargs (ImagesKwargs, 可选) — 其他图像预处理选项。模型特定的 kwargs 列在上面；请参阅 TypedDict 类以获取支持参数的完整列表。

~image_processing_base.BatchFeature

data (dict) — 由 call 方法返回的列表/数组/张量字典（“pixel_values”等）。
tensor_type (Union[None, str, TensorType], optional) — 您可以在此处提供 tensor_type 以在初始化时将整数列表转换为 PyTorch/Numpy 张量。

post_process_semantic_segmentation

< 源代码 >

( outputs target_sizes: list[tuple] | None = None ) → semantic_segmentation

参数

outputs (BeitForSemanticSegmentation) — 模型的原始输出。
target_sizes (长度为 batch_size 的 list[Tuple]，可选) — 对应于每个预测所需的最终尺寸（高，宽）的元组列表。如果未设置，则不会调整预测结果的大小。

语义分割

将 BeitForSemanticSegmentation 的输出转换为语义分割图。

BeitModel

class transformers.BeitModel

< 源代码 >

( config: BeitConfig add_pooling_layer: bool = True )

参数

config (BeitConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载模型相关的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。
add_pooling_layer (bool, 可选, 默认为 True) — 是否添加池化层。

Beit 模型的基本输出，输出原始隐藏状态，顶部没有任何特定的头部。

该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< 源代码 >

( pixel_values: Tensor bool_masked_pos: torch.BoolTensor | None = None interpolate_pos_encoding: bool = False attention_mask: torch.Tensor | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → BeitModelOutputWithPooling 或 tuple(torch.FloatTensor)

参数

pixel_values (形状为 (batch_size, num_channels, image_size, image_size) 的 torch.Tensor) — 对应于输入图像的张量。可以使用 BeitImageProcessor 获取像素值。有关详细信息，请参见 BeitImageProcessor.__call__()（processor_class 使用 BeitImageProcessor 来处理图像）。
bool_masked_pos (形状为 (batch_size, num_patches) 的 torch.BoolTensor，可选) — 布尔遮罩位置。指示哪些 patch 被遮罩（1），哪些没有被遮罩（0）。
interpolate_pos_encoding (bool，可选，默认为 False) — 是否对预训练的位置编码进行插值。
attention_mask (形状为 (batch_size, sequence_length) 的 torch.Tensor，可选) — 用于避免对填充 token 索引执行注意力操作的遮罩。遮罩值在 [0, 1] 中选择：
- 1 表示未被遮罩的 token，
- 0 表示被遮罩的 token。
什么是注意力遮罩？

BeitModelOutputWithPooling 或 tuple(torch.FloatTensor)

一个 BeitModelOutputWithPooling 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或者当 config.return_dict=False 时），根据配置（BeitConfig）和输入，包含不同的元素。

BeitModel 的前向传播方法，覆盖了 __call__ 特殊方法。

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 Module 实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。

last_hidden_state (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。
pooler_output (torch.FloatTensor，形状为 (batch_size, hidden_size)) — 如果 config.use_mean_pooling 设置为 True，则为 patch token（不包括 [CLS] token）的最后一层隐藏状态的平均值。如果设置为 False，则返回 [CLS] token 的最终隐藏状态。
hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

示例

BeitForMaskedImageModeling

class transformers.BeitForMaskedImageModeling

< 源代码 >

( config: BeitConfig )

参数

config (BeitConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载模型相关的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。

带有“语言”建模头部的 Beit 模型 transformer。BEiT 通过预测向量量化变分自编码器（VQ-VAE）的视觉 token 来进行掩码图像建模，而其他视觉模型（如 ViT 和 DeiT）则预测 RGB 像素值。因此，该类与 AutoModelForMaskedImageModeling 不兼容，如果您希望使用 BEiT 进行掩码图像建模，则需要直接使用 BeitForMaskedImageModeling。

该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< 源代码 >

( pixel_values: torch.Tensor | None = None bool_masked_pos: torch.BoolTensor | None = None labels: torch.Tensor | None = None interpolate_pos_encoding: bool = False attention_mask: torch.Tensor | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → MaskedLMOutput 或 tuple(torch.FloatTensor)

参数

pixel_values (torch.Tensor，形状为 (batch_size, num_channels, image_size, image_size)，可选) — 对应于输入图像的张量。像素值可以使用 BeitImageProcessor 获取。详情请参阅 BeitImageProcessor.__call__()（processor_class 使用 BeitImageProcessor 处理图像）。
bool_masked_pos (torch.BoolTensor，形状为 (batch_size, num_patches)) — 布尔型掩码位置。用于指示哪些补丁（patch）被掩码（1），哪些未被掩码（0）。
labels (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算图像分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方误差损失）；如果 config.num_labels > 1，则计算分类损失（交叉熵损失）。
interpolate_pos_encoding (bool，可选，默认为 False) — 是否对预训练的位置编码进行插值。
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力机制的掩码。掩码值选自 [0, 1]：
- 1 表示未被掩码的标记，
- 0 表示被掩码的标记。
什么是注意力掩码？

MaskedLMOutput 或 tuple(torch.FloatTensor)

一个 MaskedLMOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置（BeitConfig）和输入，包含不同的元素。

BeitForMaskedImageModeling 的前向传播方法，覆盖了 __call__ 特殊方法。

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 Module 实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。

loss (形状为 (1,) 的 torch.FloatTensor，可选，当提供 labels 时返回) — 掩码语言建模 (MLM) 损失。
logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 语言建模头部的预测分数（SoftMax 之前的每个词汇标记的分数）。
hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

示例

>>> from transformers import AutoImageProcessor, BeitForMaskedImageModeling
>>> import torch
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/beit-base-patch16-224-pt22k")
>>> model = BeitForMaskedImageModeling.from_pretrained("microsoft/beit-base-patch16-224-pt22k")

>>> num_patches = (model.config.image_size // model.config.patch_size) ** 2
>>> pixel_values = image_processor(images=image, return_tensors="pt").pixel_values
>>> # create random boolean mask of shape (batch_size, num_patches)
>>> bool_masked_pos = torch.randint(low=0, high=2, size=(1, num_patches)).bool()

>>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos)
>>> loss, logits = outputs.loss, outputs.logits
>>> list(logits.shape)
[1, 196, 8192]

BeitForImageClassification

class transformers.BeitForImageClassification

< 源码 >

( config: BeitConfig )

参数

config (BeitConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。请查阅 from_pretrained() 方法以加载模型权重。

带有顶部图像分类头的 Beit 模型（在 patch token 的最终隐藏状态平均值之上有一个线性层），例如用于 ImageNet。

该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< 源码 >

( pixel_values: torch.Tensor | None = None labels: torch.Tensor | None = None interpolate_pos_encoding: bool = False **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → ImageClassifierOutput 或 tuple(torch.FloatTensor)

参数

pixel_values (torch.Tensor，形状为 (batch_size, num_channels, image_size, image_size)，可选) — 对应于输入图像的张量。像素值可以使用 BeitImageProcessor 获取。详情请参阅 BeitImageProcessor.__call__()（processor_class 使用 BeitImageProcessor 处理图像）。
labels (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算图像分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方误差损失）；如果 config.num_labels > 1，则计算分类损失（交叉熵损失）。
interpolate_pos_encoding (bool，可选，默认为 False) — 是否对预训练的位置编码进行插值。

ImageClassifierOutput 或 tuple(torch.FloatTensor)

一个 ImageClassifierOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置（BeitConfig）和输入，包含不同的元素。

BeitForImageClassification 的前向传播方法，覆盖了 __call__ 特殊方法。

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 Module 实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。

loss (形状为 (1,) 的 torch.FloatTensor，可选，当提供 labels 时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。
logits (形状为 (batch_size, config.num_labels) 的 torch.FloatTensor) — 分类（如果 config.num_labels==1，则为回归）分数（SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), optional, 当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个阶段的输出）。模型在每个阶段输出的隐藏状态（也称为特征图）。
attentions (tuple(torch.FloatTensor), optional, 当传入 output_attentions=True 或当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, patch_size, sequence_length) 的 torch.FloatTensor 元组（每个层一个）。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

示例

>>> from transformers import AutoImageProcessor, BeitForImageClassification
>>> import torch
>>> from datasets import load_dataset

>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/beit-base-patch16-224-pt22k")
>>> model = BeitForImageClassification.from_pretrained("microsoft/beit-base-patch16-224-pt22k")

>>> inputs = image_processor(image, return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
...

BeitForSemanticSegmentation

class transformers.BeitForSemanticSegmentation

< 源码 >

( config: BeitConfig )

参数

config (BeitConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。请查阅 from_pretrained() 方法以加载模型权重。

带有顶部语义分割头的 Beit 模型，例如用于 ADE20K、CityScapes。

该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< 源码 >

( pixel_values: torch.Tensor | None = None labels: torch.Tensor | None = None interpolate_pos_encoding: bool = False **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → SemanticSegmenterOutput 或 tuple(torch.FloatTensor)

参数

pixel_values (torch.Tensor，形状为 (batch_size, num_channels, image_size, image_size)，可选) — 对应于输入图像的张量。像素值可以使用 BeitImageProcessor 获取。详情请参阅 BeitImageProcessor.__call__()（processor_class 使用 BeitImageProcessor 处理图像）。
labels (torch.LongTensor，形状为 (batch_size, height, width)，可选) — 用于计算损失的地面真值（ground truth）语义分割图。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels > 1，则计算分类损失（交叉熵损失）。
interpolate_pos_encoding (bool，可选，默认为 False) — 是否对预训练的位置编码进行插值。

SemanticSegmenterOutput 或 tuple(torch.FloatTensor)

一个 SemanticSegmenterOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置（BeitConfig）和输入，包含不同的元素。

BeitForSemanticSegmentation 的前向传播方法，覆盖了 __call__ 特殊方法。

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 Module 实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。

loss (形状为 (1,) 的 torch.FloatTensor，可选，当提供 labels 时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。
logits (形状为 (batch_size, config.num_labels, logits_height, logits_width) 的 torch.FloatTensor) — 每个像素的分类分数。

返回的 logits 大小不一定与传入的 pixel_values 相同。这是为了避免在用户需要将 logits 大小调整回原始图像大小时进行两次插值并损失质量。您应该始终检查 logits 形状并根据需要进行调整。
hidden_states (tuple(torch.FloatTensor), optional, 当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（如果模型有嵌入层，则包含一个嵌入层输出，加上每层的一个输出），形状为 (batch_size, patch_size, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传入 output_attentions=True 或当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, patch_size, sequence_length) 的 torch.FloatTensor 元组（每个层一个）。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

示例

>>> from transformers import AutoImageProcessor, BeitForSemanticSegmentation
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/beit-base-finetuned-ade-640-640")
>>> model = BeitForSemanticSegmentation.from_pretrained("microsoft/beit-base-finetuned-ade-640-640")

>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> # logits are of shape (batch_size, num_labels, height, width)
>>> logits = outputs.logits

在 GitHub 上更新