Transformers 4.37 中文文档（六十四）（3）-阿里云开发者社区

Transformers 4.37 中文文档（六十四）（2）https://developer.aliyun.com/article/1564124

愿景模型

BEiT

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/beit

概述

BEiT 模型是由鲍航波、董立和魏甫茹在《BEiT: BERT Pre-Training of Image Transformers》中提出的。受 BERT 启发，BEiT 是第一篇使自监督预训练的 Vision Transformers（ViTs）优于监督预训练的论文。BEiT 模型的预训练不是预测图像的类别（如原始 ViT 论文中所做的那样），而是预训练模型以预测来自 OpenAI 的 DALL-E 模型的代码本的视觉标记，给定遮罩补丁。

该论文的摘要如下：

我们介绍了一种自监督视觉表示模型 BEiT，代表从图像变换器中的双向编码器表示。在自然语言处理领域开发的 BERT 之后，我们提出了一个遮罩图像建模任务来预训练视觉变换器。具体来说，我们的预训练中，每个图像有两个视图，即图像补丁（例如 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贡献的。这个模型的 JAX/FLAX 版本是由kamalkraj贡献的。原始代码可以在这里找到。

使用提示

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

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

资源

一系列官方 Hugging Face 和社区（由🌎表示）资源的列表，可帮助您开始使用 BEiT。

图像分类

BeitForImageClassification 由这个示例脚本和笔记本支持。
另请参阅：图像分类任务指南

语义分割

语义分割任务指南

如果您有兴趣提交资源以包含在此处，请随时打开一个 Pull Request，我们将进行审查！资源应该展示一些新东西，而不是重复现有资源。

BEiT 特定输出

`class transformers.models.beit.modeling_beit.BeitModelOutputWithPooling`

<来源>

( last_hidden_state: FloatTensor = None pooler_output: FloatTensor = None hidden_states: Optional = None attentions: Optional = 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时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。
模型在每个层的输出的隐藏状态加上初始嵌入输出。
attentions (tuple(torch.FloatTensor), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）。
在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

用于 BeitModel 输出的类。

`class transformers.models.beit.modeling_flax_beit.FlaxBeitModelOutputWithPooling`

<来源>

( last_hidden_state: Array = None pooler_output: Array = None hidden_states: Optional = None attentions: Optional = None )

参数

last_hidden_state (jnp.ndarray，形状为 (batch_size, sequence_length, hidden_size)） — 模型最后一层的隐藏状态序列。
pooler_output (jnp.ndarray，形状为 (batch_size, hidden_size)） — 如果 config.use_mean_pooling 设置为 True，则为补丁标记的最后一层隐藏状态的平均值（不包括 [CLS] 标记）。如果设置为 False，则将返回 [CLS] 标记的最终隐藏状态。
hidden_states (tuple(jnp.ndarray)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回） — 形状为 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray 元组（一个用于嵌入的输出 + 一个用于每层的输出）。模型在每层输出的隐藏状态加上初始嵌入输出。
attentions (tuple(jnp.ndarray)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回） — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 jnp.ndarray 元组（每层一个）。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

用于 FlaxBeitModel 输出的类。

BeitConfig

`class transformers.BeitConfig`

<来源>

( vocab_size = 8192 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 layer_norm_eps = 1e-12 image_size = 224 patch_size = 16 num_channels = 3 use_mask_token = False use_absolute_position_embeddings = False use_relative_position_bias = False use_shared_relative_position_bias = False layer_scale_init_value = 0.1 drop_path_rate = 0.1 use_mean_pooling = True pool_scales = [1, 2, 3, 6] use_auxiliary_head = True auxiliary_loss_weight = 0.4 auxiliary_channels = 256 auxiliary_num_convs = 1 auxiliary_concat_input = False semantic_loss_ignore_index = 255 out_features = None out_indices = None add_fpn = False reshape_hidden_states = True **kwargs )

参数

vocab_size (int，可选，默认为 8192) — BEiT 模型的词汇表大小。定义了在预训练期间可以使用的不同图像标记数量。
hidden_size (int，可选，默认为 768) — 编码器层和池化器层的维度。
num_hidden_layers (int，可选，默认为 12) — Transformer 编码器中的隐藏层数量。
num_attention_heads (int，可选，默认为 12) — Transformer 编码器中每个注意力层的注意力头数量。
intermediate_size (int，可选，默认为 3072) — Transformer 编码器中“中间”（即前馈）层的维度。
hidden_act (str 或 function，可选，默认为 "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu"、"relu"、"selu" 和 "gelu_new"。
hidden_dropout_prob (float，可选，默认为 0.0) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。
attention_probs_dropout_prob (float，可选，默认为 0.0) — 注意力概率的丢弃比率。
initializer_range (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
layer_norm_eps (float，可选，默认为 1e-12) — 层归一化层使用的 epsilon。
image_size (int，可选，默认为 224) — 每个图像的大小（分辨率）。
patch_size (int，可选，默认为 16) — 每个补丁的大小（分辨率）。
num_channels (int，可选，默认为 3) — 输入通道数。
use_mask_token (bool，可选，默认为 False) — 是否为遮罩图像建模使用遮罩标记。
use_absolute_position_embeddings (bool，可选，默认为 False) — 是否使用类似 BERT 的绝对位置嵌入。
use_relative_position_bias (bool，可选，默认为 False) — 是否在自注意力层中使用 T5 风格的相对位置嵌入。
use_shared_relative_position_bias (bool, 可选, 默认为 False) — 是否在 Transformer 的所有自注意力层中使用相同的相对位置嵌入。
layer_scale_init_value (float, 可选, 默认为 0.1) — 在自注意力层中使用的比例。基础为 0.1，大型为 1e-5。设置为 0 以禁用层比例。
drop_path_rate (float, 可选, 默认为 0.1) — 每个样本的随机深度率（应用于残差层的主路径）。
use_mean_pooling (bool, 可选, 默认为 True) — 是否对补丁的最终隐藏状态进行均值池化，而不是使用 CLS 标记的最终隐藏状态后应用分类头。
pool_scales (Tuple[int], 可选, 默认为 [1, 2, 3, 6]) — 在最后一个特征图上应用的池化金字塔模块中使用的池化比例。
use_auxiliary_head (bool, 可选, 默认为 True) — 是否在训练过程中使用辅助头。
auxiliary_loss_weight (float, 可选, 默认为 0.4) — 辅助头的交叉熵损失的权重。
auxiliary_channels (int, 可选, 默认为 256) — 辅助头中要使用的通道数。
auxiliary_num_convs (int, 可选, 默认为 1) — 辅助头中要使用的卷积层数。
auxiliary_concat_input (bool, 可选, 默认为 False) — 是否在分类层之前将辅助头的输出与输入进行连接。
semantic_loss_ignore_index (int, 可选, 默认为 255) — 语义分割模型的损失函数中被忽略的索引。
out_features (List[str], 可选) — 如果用作骨干，要输出的特征列表。可以是 "stem"、"stage1"、"stage2" 等（取决于模型有多少阶段）。如果未设置且设置了 out_indices，将默认为相应的阶段。如果未设置且未设置 out_indices，将默认为最后一个阶段。必须按照 stage_names 属性中定义的顺序。
out_indices (List[int], 可选) — 如果用作骨干，要输出的特征的索引列表。可以是 0、1、2 等（取决于模型有多少阶段）。如果未设置且设置了 out_features，将默认为相应的阶段。如果未设置且未设置 out_features，将默认为最后一个阶段。必须按照 stage_names 属性中定义的顺序。
add_fpn (bool, 可选, 默认为 False) — 是否将 FPN 添加为骨干的一部分。仅适用于 BeitBackbone。
reshape_hidden_states (bool, 可选, 默认为 True) — 是否在将模型用作骨干时将特征图重塑为形状为 (batch_size, hidden_size, height, width) 的 4D 张量。如果为 False，特征图将是形状为 (batch_size, seq_len, hidden_size) 的 3D 张量。仅适用于 BeitBackbone。

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

示例：

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

BeitFeatureExtractor

`class transformers.BeitFeatureExtractor`

<来源>

( *args **kwargs )

`call`

<来源>

( images segmentation_maps = None **kwargs )

`post_process_semantic_segmentation`

<来源>

( outputs target_sizes: List = None ) → export const metadata = 'undefined';semantic_segmentation

参数

outputs（BeitForSemanticSegmentation） — 模型的原始输出。
target_sizes（长度为 batch_size 的 List[Tuple]，可选） — 每个预测的请求最终尺寸（高度，宽度）对应的元组列表。如果未设置，预测将不会被调整大小。

语义分割

长度为 batch_size 的 List[torch.Tensor]，每个项目是形状为 (height, width) 的语义分割地图，对应于 target_sizes 条目（如果指定）。每个 torch.Tensor 的每个条目对应于语义类别 id。

将 BeitForSemanticSegmentation 的输出转换为语义分割地图。仅支持 PyTorch。

BeitImageProcessor

`class transformers.BeitImageProcessor`

<来源>

( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BICUBIC: 3> do_center_crop: bool = True crop_size: Dict = None rescale_factor: Union = 0.00392156862745098 do_rescale: bool = True do_normalize: bool = True image_mean: Union = None image_std: Union = None do_reduce_labels: bool = False **kwargs )

参数

do_resize (bool，可选，默认为 True) — 是否将图像的（高度，宽度）尺寸调整为指定的 size。可以通过 preprocess 方法中的 do_resize 参数进行覆盖。
size (Dict[str, int] 可选，默认为 {"height" -- 256, "width": 256})：调整大小后的输出图像尺寸。可以通过 preprocess 方法中的 size 参数进行覆盖。
resample (PILImageResampling，可选，默认为 Resampling.BICUBIC) — 如果调整图像大小，则要使用的重采样滤波器。可以通过 preprocess 方法中的 resample 参数进行覆盖。
do_center_crop (bool，可选，默认为 True) — 是否对图像进行中心裁剪。如果输入尺寸沿任何边缘小于 crop_size，则图像将填充为 0，然后进行中心裁剪。可以通过 preprocess 方法中的 do_center_crop 参数进行覆盖。
crop_size (Dict[str, int]，可选，默认为 {"height" -- 224, "width": 224})：应用中心裁剪时的期望输出尺寸。仅在 do_center_crop 设置为 True 时有效。可以通过 preprocess 方法中的 crop_size 参数进行覆盖。
rescale_factor (int 或 float，可选，默认为 1/255) — 如果重新缩放图像，则使用的缩放因子。可以通过 preprocess 方法中的 rescale_factor 参数进行覆盖。
do_rescale (bool，可选，默认为 True) — 是否按指定比例 rescale_factor 重新缩放图像。可以通过 preprocess 方法中的 do_rescale 参数进行覆盖。
do_normalize (bool，可选，默认为 True) — 是否对图像进行归一化。可以通过 preprocess 方法中的 do_normalize 参数进行覆盖。
image_mean (float 或 List[float]，可选，默认为 IMAGENET_STANDARD_MEAN) — 如果对图像进行归一化，则使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以通过 preprocess 方法中的 image_mean 参数进行覆盖。
image_std (float 或 List[float]，可选，默认为 IMAGENET_STANDARD_STD) — 如果对图像进行归一化，则使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以通过 preprocess 方法中的 image_std 参数进行覆盖。
do_reduce_labels (bool，可选，默认为 False) — 是否减少所有分割地图的标签值。通常用于数据集中将 0 用于背景，且背景本身不包含在数据集的所有类中（例如 ADE20k）。背景标签将被替换为 255。可以通过 preprocess 方法中的 do_reduce_labels 参数进行覆盖。

构建 BEiT 图像处理器。

`preprocess`

<来源>

( images: Union segmentation_maps: Union = None do_resize: bool = None size: Dict = None resample: Resampling = None do_center_crop: bool = None crop_size: Dict = None do_rescale: bool = None rescale_factor: float = None do_normalize: bool = None image_mean: Union = None image_std: Union = None do_reduce_labels: Optional = None return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

images (ImageInput) — 预处理的图像。期望单个或批量图像，像素值范围为 0 到 255。如果传入像素值在 0 到 1 之间的图像，请设置do_rescale=False。
do_resize (bool, 可选, 默认为self.do_resize) — 是否调整图像大小。
size (Dict[str, int], 可选, 默认为self.size) — 调整大小后的图像大小。
resample (int, 可选, 默认为self.resample) — 调整图像大小时要使用的重采样滤波器。这可以是枚举PILImageResampling之一，仅在设置do_resize=True时有效。
do_center_crop (bool, 可选, 默认为self.do_center_crop) — 是否对图像进行中心裁剪。
crop_size (Dict[str, int], 可选, 默认为self.crop_size) — 中心裁剪后的图像大小。如果图像的一条边小于crop_size，则将用零填充，然后裁剪。
do_rescale (bool, 可选, 默认为self.do_rescale) — 是否将图像值重新缩放为[0 - 1]。
rescale_factor (float, 可选, 默认为self.rescale_factor) — 如果设置do_rescale=True，则用于重新缩放图像的重新缩放因子。
do_normalize (bool, 可选, 默认为self.do_normalize) — 是否对图像进行归一化。
image_mean (float 或 List[float], 可选, 默认为self.image_mean) — 图像均值。
image_std (float 或 List[float], 可选, 默认为self.image_std) — 图像标准差。
do_reduce_labels (bool, 可选, 默认为self.do_reduce_labels) — 是否减少所有分割地图的标签值。通常用于数据集中使用 0 表示背景，并且背景本身不包含在数据集的所有类中（例如 ADE20k）。背景标签将被替换为 255。
return_tensors (str 或 TensorType, 可选) — 要返回的张量类型。可以是以下之一：

未设置：返回一个np.ndarray列表。
TensorType.TENSORFLOW 或 'tf'：返回一个类型为tf.Tensor的批量。
TensorType.PYTORCH 或 'pt'：返回一个类型为torch.Tensor的批量。
TensorType.NUMPY 或 'np'：返回一个类型为np.ndarray的批量。
TensorType.JAX 或 'jax'：返回一个类型为jax.numpy.ndarray的批量。

data_format (ChannelDimension 或 str, 可选, 默认为ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：

"channels_first" 或 ChannelDimension.FIRST：图像以（通道数，高度，宽度）格式。
"channels_last" 或 ChannelDimension.LAST：图像以（高度，宽度，通道数）格式。
未设置：使用输入图像的通道维度格式。

input_data_format (ChannelDimension 或 str, 可选) — 输入图像的通道维度格式。如果未设置，将从输入图像中推断通道维度格式。可以是以下之一：

"channels_first" 或 ChannelDimension.FIRST：图像以（通道数，高度，宽度）格式。
"channels_last" 或 ChannelDimension.LAST：图像以（高度，宽度，通道数）格式。
"none" 或 ChannelDimension.NONE：图像以（高度，宽度）格式。

预处理图像或一批图像。

`post_process_semantic_segmentation`

<来源>

( outputs target_sizes: List = None ) → export const metadata = 'undefined';semantic_segmentation

参数

outputs（BeitForSemanticSegmentation） — 模型的原始输出。
target_sizes (List[Tuple]，长度为batch_size，可选) — 与每个预测的请求最终大小（高度，宽度）对应的元组列表。如果未设置，预测将不会被调整大小。

语义分割

List[torch.Tensor] 长度为 batch_size，其中每个项目是形状为 (height, width) 的语义分割地图，对应于目标大小条目（如果指定了 target_sizes）。每个 torch.Tensor 的每个条目对应于一个语义类别 id。

将 BeitForSemanticSegmentation 的输出转换为语义分割地图。仅支持 PyTorch。

PytorchHide Pytorch content

BeitModel

`class transformers.BeitModel`

<来源>

( config: BeitConfig add_pooling_layer: bool = True )

参数

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

裸的 Beit 模型变压器输出原始隐藏状态，没有特定的头部。这个模型是一个 PyTorch torch.nn.Module 子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

`forward`

<来源>

( pixel_values: Optional = None bool_masked_pos: Optional = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.beit.modeling_beit.BeitModelOutputWithPooling or tuple(torch.FloatTensor)

参数

pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 BeitImageProcessor.call()。
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值在 [0, 1] 中选择：

1 表示头部未被掩盖，
0 表示头部被掩盖。

output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的 hidden_states。
return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。
bool_masked_pos (torch.BoolTensor of shape (batch_size, num_patches), optional) — 布尔掩码位置。指示哪些补丁被掩盖（1）哪些没有（0）。

transformers.models.beit.modeling_beit.BeitModelOutputWithPooling 或 tuple(torch.FloatTensor)

一个 transformers.models.beit.modeling_beit.BeitModelOutputWithPooling 或 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置（BeitConfig）和输入的各种元素。

last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
pooler_output（形状为(batch_size, hidden_size)的torch.FloatTensor）- 如果config.use_mean_pooling设置为 True，则是补丁标记的最后一层隐藏状态的平均值（不包括*[CLS]标记）。如果设置为 False，则将返回[CLS]*标记的最终隐藏状态。
hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。
模型在每一层的输出的隐藏状态加上初始嵌入输出。
attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoImageProcessor, BeitModel
>>> 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 = BeitModel.from_pretrained("microsoft/beit-base-patch16-224-pt22k")
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 197, 768]

BeitForMaskedImageModeling

`class transformers.BeitForMaskedImageModeling`

<来源>

( config: BeitConfig )

参数

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

Beit 模型变压器顶部带有“语言”建模头。BEiT 通过预测矢量量化变分自动编码器（VQ-VAE）的视觉标记来进行遮蔽图像建模，而其他视觉模型如 ViT 和 DeiT 则预测 RGB 像素值。因此，此类与 AutoModelForMaskedImageModeling 不兼容，因此如果要使用 BEiT 进行遮蔽图像建模，则需要直接使用 BeitForMaskedImageModeling。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

`forward`

<来源>

( pixel_values: Optional = None bool_masked_pos: Optional = None head_mask: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MaskedLMOutput or tuple(torch.FloatTensor)

参数

pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）- 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 BeitImageProcessor.call()。
head_mask（torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选）- 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]之间：

1 表示头部未被遮蔽，
0 表示头部被遮蔽。

output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。查看返回张量中的 hidden_states 以获取更多细节。
return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。
bool_masked_pos (torch.BoolTensor，形状为 (batch_size, num_patches)) — 布尔掩码位置。指示哪些补丁被掩盖（1）哪些没有（0）。
labels (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算图像分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。

返回值

transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)

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

loss (torch.FloatTensor，形状为 (1,)，可选，当提供 labels 时返回) — 掩码语言建模（MLM）损失。
logits (torch.FloatTensor，形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（如果模型有嵌入层的输出，则为嵌入层的输出 + 每一层的输出）。
模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组。
自注意力头中的注意力权重，用于计算自注意力头中的加权平均值。

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

虽然前向传递的方法需要在此函数内定义，但应该在此之后调用 Module 实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> 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]

Transformers 4.37 中文文档（六十四）（4）https://developer.aliyun.com/article/1564126

Transformers 4.37 中文文档（六十四）（3）

愿景模型

BEiT

概述

使用提示

资源

BEiT 特定输出

`class transformers.models.beit.modeling_beit.BeitModelOutputWithPooling`

`class transformers.models.beit.modeling_flax_beit.FlaxBeitModelOutputWithPooling`

BeitConfig

`class transformers.BeitConfig`

BeitFeatureExtractor

`class transformers.BeitFeatureExtractor`

`call`

`post_process_semantic_segmentation`

BeitImageProcessor

`class transformers.BeitImageProcessor`

`preprocess`

`post_process_semantic_segmentation`

BeitModel

`class transformers.BeitModel`

`forward`

BeitForMaskedImageModeling

`class transformers.BeitForMaskedImageModeling`

`forward`

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Transformers 4.37 中文文档（六十四）（3）

愿景模型

BEiT

概述

使用提示

资源

BEiT 特定输出

class transformers.models.beit.modeling_beit.BeitModelOutputWithPooling

class transformers.models.beit.modeling_flax_beit.FlaxBeitModelOutputWithPooling

BeitConfig

class transformers.BeitConfig

BeitFeatureExtractor

class transformers.BeitFeatureExtractor

__call__

post_process_semantic_segmentation

BeitImageProcessor

class transformers.BeitImageProcessor

preprocess

post_process_semantic_segmentation

BeitModel

class transformers.BeitModel

forward

BeitForMaskedImageModeling

class transformers.BeitForMaskedImageModeling

forward

热门文章

最新文章

相关电子书

`class transformers.models.beit.modeling_beit.BeitModelOutputWithPooling`

`class transformers.models.beit.modeling_flax_beit.FlaxBeitModelOutputWithPooling`

`class transformers.BeitConfig`

`class transformers.BeitFeatureExtractor`

`call`

`post_process_semantic_segmentation`

`class transformers.BeitImageProcessor`

`preprocess`

`post_process_semantic_segmentation`

`class transformers.BeitModel`

`forward`

`class transformers.BeitForMaskedImageModeling`

`forward`