Transformers 文档
BEiT
并获得增强的文档体验
开始使用
BEiT
概述
BEiT 模型由 Hangbo Bao、Li Dong 和 Furu Wei 在 BEiT: BERT Pre-Training of Image Transformers 中提出。受到 BERT 的启发，BEiT 是第一篇使 Vision Transformers (ViTs) 的自监督预训练优于监督预训练的论文。与预训练模型以预测图像的类别（如 原始 ViT 论文 中所做的那样）不同，BEiT 模型经过预训练，以从 OpenAI 的 DALL-E 模型 的代码本中预测给定掩码补丁的视觉 tokens。
论文的摘要如下：
我们介绍了一种自监督视觉表示模型 BEiT，它代表来自图像 Transformers 的双向编码器表示。 遵循自然语言处理领域开发的 BERT，我们提出了一种掩码图像建模任务来预训练视觉 Transformers。 具体来说，在我们的预训练中，每个图像都有两个视图，即图像补丁（例如 16x16 像素）和视觉 tokens（即离散 tokens）。 我们首先将原始图像“token 化”为视觉 tokens。 然后，我们随机掩盖一些图像补丁，并将它们馈送到骨干 Transformer 中。 预训练目标是根据损坏的图像补丁恢复原始视觉 tokens。 在预训练 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) 和 数据高效图像 Transformers (DeiT)。 您可以查看关于推理以及在自定义数据上进行微调的演示 notebook 这里（您可以只将 ViTFeatureExtractor 替换为 BeitImageProcessor，并将 ViTForImageClassification 替换为 BeitForImageClassification）。
- 还有一个演示 notebook 可用，展示了如何将 DALL-E 的图像 tokenizer 与 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 万张图像和 1,000 个类别的集合）上微调。
- BEiT 使用相对位置嵌入，灵感来自 T5 模型。 在预训练期间，作者在多个自注意力层之间共享了相对位置偏差。 在微调期间，每个层的相对位置偏差都使用预训练后获得的共享相对位置偏差进行初始化。 请注意，如果有人想从头开始预训练模型，则需要将 BeitConfig 的
use_relative_position_bias或use_relative_position_bias属性设置为True，以便添加位置嵌入。
BEiT 预训练。 取自原始论文。使用缩放点积注意力 (SDPA)
PyTorch 包含一个原生的缩放点积注意力 (SDPA) 运算符，作为 torch.nn.functional 的一部分。 此函数包含多种实现，可以根据输入和正在使用的硬件应用。 有关更多信息，请参阅官方文档或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", torch_dtype=torch.float16)
...为了获得最佳加速效果，我们建议以半精度（例如 torch.float16 或 torch.bfloat16）加载模型。
在本地基准测试（NVIDIA GeForce RTX 2060-8GB，PyTorch 2.5.1，OS Ubuntu 20.04）中使用 float16 和 microsoft/beit-base-patch16-224 模型，我们看到了以下训练和推理过程中的改进
训练
| num_training_steps | batch_size | image_size | is_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 CI, % | Eager 内存 (MB) | SDPA (秒/迭代) | SDPA CI, % | 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 由此示例脚本和notebook 支持。
- 另请参阅：图像分类任务指南
语义分割
如果您有兴趣提交资源以包含在此处，请随时打开 Pull Request，我们将对其进行审核！ 该资源理想情况下应展示一些新的内容，而不是重复现有资源。
BEiT 特定输出
class transformers.models.beit.modeling_beit.BeitModelOutputWithPooling
< source >( last_hidden_state: FloatTensor = None pooler_output: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = 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，则为补丁 tokens（不包括 [CLS] token）的最后一层隐藏状态的平均值。 如果设置为 False，则将返回 [CLS] token 的最终隐藏状态。 - 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), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
用于 BeitModel 输出的类。
class transformers.models.beit.modeling_flax_beit.FlaxBeitModelOutputWithPooling
< source >( last_hidden_state: Array = None pooler_output: Array = None hidden_states: typing.Optional[typing.Tuple[jax.Array]] = None attentions: typing.Optional[typing.Tuple[jax.Array]] = None )
参数
- last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的jnp.ndarray) — 模型最后一层的隐藏状态序列。 - pooler_output (形状为
(batch_size, hidden_size)的jnp.ndarray) — 如果 config.use_mean_pooling 设置为 True，则为 patch 令牌（排除 [CLS] 令牌）的最后一层隐藏状态的平均值。如果设置为 False，则将返回 [CLS] 令牌的最终隐藏状态。 - hidden_states (
tuple(jnp.ndarray), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（每个嵌入输出 + 每层输出各一个）。模型在每一层输出端的隐藏状态，加上初始嵌入输出。 - attentions (
tuple(jnp.ndarray), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
用于 FlaxBeitModel 输出的类。
BeitConfig
class transformers.BeitConfig
< source >( 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, optional, defaults to 8192) — BEiT 模型的词汇表大小。定义了预训练期间可以使用的不同图像令牌的数量。 - hidden_size (
int, optional, defaults to 768) — 编码器层和池化器层的维度。 - num_hidden_layers (
int, optional, defaults to 12) — Transformer 编码器中的隐藏层数。 - num_attention_heads (
int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数。 - intermediate_size (
int, optional, defaults to 3072) — Transformer 编码器中“中间”（即，前馈）层的维度。 - hidden_act (
str或function, optional, defaults to"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持"gelu"、"relu"、"selu"和"gelu_new"。 - hidden_dropout_prob (
float, optional, defaults to 0.0) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。 - attention_probs_dropout_prob (
float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。 - initializer_range (
float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - layer_norm_eps (
float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon 值。 - image_size (
int, optional, defaults to 224) — 每张图片的大小（分辨率）。 - patch_size (
int, optional, defaults to 16) — 每个 patch 的大小（分辨率）。 - num_channels (
int, optional, defaults to 3) — 输入通道数。 - use_mask_token (
bool, optional, defaults toFalse) — 是否为掩码图像建模使用掩码令牌。 - use_absolute_position_embeddings (
bool, optional, defaults toFalse) — 是否使用 BERT 风格的绝对位置嵌入。 - use_relative_position_bias (
bool, optional, defaults toFalse) — 是否在自注意力层中使用 T5 风格的相对位置嵌入。 - use_shared_relative_position_bias (
bool, optional, defaults toFalse) — 是否在 Transformer 的所有自注意力层中使用相同的相对位置嵌入。 - layer_scale_init_value (
float, optional, defaults to 0.1) — 在自注意力层中使用的缩放。base 模型为 0.1，large 模型为 1e-5。设置为 0 以禁用层缩放。 - drop_path_rate (
float, optional, defaults to 0.1) — 每个样本的随机深度率（当应用于残差层的主路径时）。 - use_mean_pooling (
bool, optional, defaults toTrue) — 是否对patches的最终隐藏状态进行均值池化，而不是在使用分类head之前使用CLS token的最终隐藏状态。 - pool_scales (
Tuple[int], optional, defaults to[1, 2, 3, 6]) — 在应用于最后一个特征图的池化金字塔模块中使用的池化尺度。 - use_auxiliary_head (
bool, optional, defaults toTrue) — 是否在训练期间使用辅助head。 - auxiliary_loss_weight (
float, optional, defaults to 0.4) — 辅助head的交叉熵损失的权重。 - auxiliary_channels (
int, optional, defaults to 256) — 辅助head中使用的通道数。 - auxiliary_num_convs (
int, optional, defaults to 1) — 辅助head中使用的卷积层数。 - auxiliary_concat_input (
bool, optional, defaults toFalse) — 是否将辅助head的输出与分类层之前的输入连接起来。 - semantic_loss_ignore_index (
int, optional, defaults to 255) — 语义分割模型的损失函数忽略的索引。 - out_features (
List[str], optional) — 如果用作骨干网络，则输出的特征列表。可以是"stem"、"stage1"、"stage2"等（取决于模型有多少个stage）。如果未设置且设置了out_indices，则默认为相应的stage。如果未设置且out_indices也未设置，则默认为最后一个stage。必须与stage_names属性中定义的顺序相同。 - out_indices (
List[int], optional) — 如果用作骨干网络，则输出的特征索引列表。可以是 0、1、2 等（取决于模型有多少个stage）。如果未设置且设置了out_features，则默认为相应的stage。如果未设置且out_features也未设置，则默认为最后一个stage。必须与stage_names属性中定义的顺序相同。 - add_fpn (
bool, optional, defaults toFalse) — 是否添加 FPN 作为骨干网络的一部分。仅与BeitBackbone相关。 - reshape_hidden_states (
bool, optional, defaults toTrue) — 当模型用作骨干网络时，是否将特征图重塑为形状为(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.configBeitFeatureExtractor
post_process_semantic_segmentation
< source >( outputs target_sizes: typing.List[typing.Tuple] = None ) → semantic_segmentation
参数
- outputs (BeitForSemanticSegmentation) — 模型的原始输出。
- target_sizes (
List[Tuple]of lengthbatch_size, optional) — 与每个预测请求的最终尺寸（高度，宽度）相对应的元组列表。如果未设置，则不会调整预测大小。
返回值
semantic_segmentation
List[torch.Tensor]，长度为 batch_size，其中每个项目是形状为 (height, width) 的语义分割图，对应于 target_sizes 条目（如果指定了 target_sizes）。每个 torch.Tensor 的每个条目对应于一个语义类别ID。
将 BeitForSemanticSegmentation 的输出转换为语义分割图。仅支持 PyTorch。
BeitImageProcessor
class transformers.BeitImageProcessor
< source >( do_resize: bool = True size: typing.Dict[str, int] = None resample: Resampling = <Resampling.BICUBIC: 3> do_center_crop: bool = True crop_size: typing.Dict[str, int] = None rescale_factor: typing.Union[int, float] = 0.00392156862745098 do_rescale: bool = True do_normalize: bool = True image_mean: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None do_reduce_labels: bool = False **kwargs )
参数
- do_resize (
bool, optional, defaults toTrue) — 是否将图像的（高度，宽度）尺寸调整为指定的size。可以被preprocess方法中的do_resize参数覆盖。 - size (
Dict[str, int]optional, defaults to{"height" -- 256, "width": 256}): 调整大小后输出图像的大小。可以被preprocess方法中的size参数覆盖。 - resample (
PILImageResampling, optional, defaults toResampling.BICUBIC) — 如果调整图像大小，则使用的重采样过滤器。可以被preprocess方法中的resample参数覆盖。 - do_center_crop (
bool, optional, defaults toTrue) — 是否对图像进行中心裁剪。如果输入尺寸沿任何边缘小于crop_size，则图像将用 0 填充，然后进行中心裁剪。可以被preprocess方法中的do_center_crop参数覆盖。 - crop_size (
Dict[str, int], optional, defaults to{"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) — 是否将分割图的所有标签值减 1。通常用于数据集，其中 0 用于背景，而背景本身不包含在数据集的所有类别中（例如 ADE20k）。背景标签将被替换为 255。可以被preprocess方法中的do_reduce_labels参数覆盖。
构建 BEiT 图像处理器。
preprocess
< source >( 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 do_resize: bool = None size: typing.Dict[str, int] = None resample: Resampling = None do_center_crop: bool = None crop_size: typing.Dict[str, int] = None do_rescale: bool = None rescale_factor: float = None do_normalize: bool = None image_mean: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None do_reduce_labels: typing.Optional[bool] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None )
参数
- images (
ImageInput) — 要预处理的图像。 期望是像素值范围为 0 到 255 的单张或批量图像。 如果传入像素值在 0 到 1 之间的图像，请设置do_rescale=False。 - segmentation_maps (
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) — 是否将分割图的所有标签值减 1。通常用于数据集，其中 0 用于背景，而背景本身不包含在数据集的所有类别中（例如 ADE20k）。背景标签将被替换为 255。 - return_tensors (
str或TensorType, 可选) — 返回的张量类型。 可以是以下之一：- Unset: 返回
np.ndarray列表。 TensorType.TENSORFLOW或'tf': 返回tf.Tensor类型的批次。TensorType.PYTORCH或'pt': 返回torch.Tensor类型的批次。TensorType.NUMPY或'np': 返回np.ndarray类型的批次。TensorType.JAX或'jax': 返回jax.numpy.ndarray类型的批次。
- Unset: 返回
- data_format (
ChannelDimension或str, 可选, 默认为ChannelDimension.FIRST) — 输出图像的通道维度格式。 可以是以下之一："channels_first"或ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。"channels_last"或ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。- Unset: 使用输入图像的通道维度格式。
- input_data_format (
ChannelDimension或str, 可选) — 输入图像的通道维度格式。 如果未设置，则通道维度格式将从输入图像推断。 可以是以下之一："channels_first"或ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。"channels_last"或ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。"none"或ChannelDimension.NONE: 图像格式为 (height, width)。
预处理单张或批量图像。
post_process_semantic_segmentation
< source >( outputs target_sizes: typing.List[typing.Tuple] = None ) → semantic_segmentation
参数
- outputs (BeitForSemanticSegmentation) — 模型的原始输出。
- target_sizes (
List[Tuple]，长度为batch_size，可选) — 对应于每个预测请求的最终尺寸（高度，宽度）的元组列表。如果未设置，则不会调整预测大小。
返回值
semantic_segmentation
List[torch.Tensor]，长度为 batch_size，其中每个项目是形状为 (height, width) 的语义分割图，对应于 target_sizes 条目（如果指定了 target_sizes）。每个 torch.Tensor 的每个条目对应于一个语义类别ID。
将 BeitForSemanticSegmentation 的输出转换为语义分割图。仅支持 PyTorch。
BeitModel
class transformers.BeitModel
< source >( config: BeitConfig add_pooling_layer: bool = True )
参数
- config (BeitConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
裸Beit模型 Transformer 输出原始隐藏状态，顶部没有任何特定的 head。此模型是 PyTorch torch.nn.Module 子类。 可将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( pixel_values: Tensor bool_masked_pos: typing.Optional[torch.BoolTensor] = None head_mask: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: bool = False return_dict: typing.Optional[bool] = None ) → transformers.models.beit.modeling_beit.BeitModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- pixel_values (形状为
(batch_size, num_channels, height, width)的torch.FloatTensor) — 像素值。像素值可以使用 AutoImageProcessor 获得。 有关详细信息，请参见 BeitImageProcessor.call()。 - head_mask (形状为
(num_heads,)或(num_layers, num_heads)的torch.FloatTensor, 可选) — 用于置空自注意力模块的选定 head 的 Mask。Mask 值在[0, 1]中选择：- 1 表示 head 未被 Mask，
- 0 表示 head 被 Mask。
- output_attentions (
bool, 可选) — 是否返回所有注意力层的 attentions 张量。 有关更多详细信息，请参见返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回张量下的hidden_states。 - interpolate_pos_encoding (
bool, 可选, 默认为False) — 是否插值预训练的位置编码。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 - bool_masked_pos (形状为
(batch_size, num_patches)的torch.BoolTensor, 可选) — 布尔 Mask 位置。指示哪些 patch 被 Mask (1) 以及哪些未被 Mask (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 (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor) — 模型最后一层输出端的隐藏状态序列。 -
pooler_output (形状为
(batch_size, hidden_size)的torch.FloatTensor) — 如果 config.use_mean_pooling 设置为 True，则 patch token（不包括 [CLS] token）的最后一层隐藏状态的平均值。如果设置为 False，则将返回 [CLS] token 的最终隐藏状态。 -
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 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
BeitModel forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoImageProcessor, BeitModel
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image", trust_remote_code=True)
>>> 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
< source >( config: BeitConfig )
参数
- config (BeitConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
带有“语言”建模 head 的 Beit 模型 Transformer。BEiT 通过预测向量量化变分自编码器 (VQ-VAE) 的视觉 token 来进行 Mask 图像建模，而其他视觉模型（如 ViT 和 DeiT）则预测 RGB 像素值。因此，此类与 AutoModelForMaskedImageModeling 不兼容，因此如果您希望使用 BEiT 进行 Mask 图像建模，则需要直接使用 BeitForMaskedImageModeling。此模型是 PyTorch torch.nn.Module 子类。 可将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( pixel_values: typing.Optional[torch.Tensor] = None bool_masked_pos: typing.Optional[torch.BoolTensor] = None head_mask: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: bool = False return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (形状为
(batch_size, num_channels, height, width)的torch.FloatTensor) — 像素值。像素值可以使用 AutoImageProcessor 获得。 有关详细信息，请参见 BeitImageProcessor.call()。 - head_mask (形状为
(num_heads,)或(num_layers, num_heads)的torch.FloatTensor, 可选) — 用于置空自注意力模块的选定 head 的 Mask。Mask 值在[0, 1]中选择：- 1 表示 head 未被 Mask，
- 0 表示 head 被 Mask。
- output_attentions (
bool, 可选) — 是否返回所有注意力层的 attentions 张量。 有关更多详细信息，请参见返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回张量下的hidden_states。 - interpolate_pos_encoding (
bool, 可选, 默认为False) — 是否插值预训练的位置编码。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 - bool_masked_pos (形状为
(batch_size, num_patches)的torch.BoolTensor) — 布尔 Mask 位置。指示哪些 patch 被 Mask (1) 以及哪些未被 Mask (0)。 - labels (形状为
(batch_size,)的torch.LongTensor, 可选) — 用于计算图像分类/回归损失的标签。索引应为[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 (形状为
(1,)的torch.FloatTensor, 可选, 当提供labels时返回) — Mask 语言建模 (MLM) 损失。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言建模 head 的预测分数（SoftMax 之前每个词汇 token 的分数）。 -
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时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
BeitForMaskedImageModeling 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 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]BeitForImageClassification
class transformers.BeitForImageClassification
< source >( config: BeitConfig )
参数
- config (BeitConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
Beit 模型转换器，顶部带有一个图像分类头 (位于 patch tokens 的最终隐藏状态平均值之上的线性层)，例如用于 ImageNet。
此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。
forward
< source >( pixel_values: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: bool = False return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.ImageClassifierOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (形状为
(batch_size, num_channels, height, width)的torch.FloatTensor) — 像素值。像素值可以使用 AutoImageProcessor 获得。 有关详细信息，请参阅 BeitImageProcessor.call()。 - head_mask (形状为
(num_heads,)或(num_layers, num_heads)的torch.FloatTensor, 可选) — 用于使自注意力模块的选定头无效的掩码。在[0, 1]中选择的掩码值：- 1 表示头未被掩蔽，
- 0 表示头被掩蔽。
- output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 - interpolate_pos_encoding (
bool, 可选, 默认为False) — 是否插值预训练的位置编码。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。 - labels (形状为
(batch_size,)的torch.LongTensor, 可选) — 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]中。如果config.num_labels == 1，则计算回归损失 (均方误差损失)。如果config.num_labels > 1，则计算分类损失 (交叉熵)。
返回值
transformers.modeling_outputs.ImageClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.ImageClassifierOutput 或一个 torch.FloatTensor 的元组 (如果传入 return_dict=False 或当 config.return_dict=False 时)，包括各种元素，具体取决于配置 (BeitConfig) 和输入。
-
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), 可选, 当传入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, patch_size, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
BeitForImageClassification 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoImageProcessor, BeitForImageClassification
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image", trust_remote_code=True)
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/beit-base-patch16-224")
>>> model = BeitForImageClassification.from_pretrained("microsoft/beit-base-patch16-224")
>>> 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])
tabby, tabby catBeitForSemanticSegmentation
class transformers.BeitForSemanticSegmentation
< source >( config: BeitConfig )
参数
- config (BeitConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
Beit 模型转换器，顶部带有一个语义分割头，例如用于 ADE20k、CityScapes。
此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。
forward
< source >( pixel_values: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: bool = False return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.SemanticSegmenterOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (形状为
(batch_size, num_channels, height, width)的torch.FloatTensor) — 像素值。像素值可以使用 AutoImageProcessor 获得。 有关详细信息，请参阅 BeitImageProcessor.call()。 - head_mask (形状为
(num_heads,)或(num_layers, num_heads)的torch.FloatTensor, 可选) — 用于使自注意力模块的选定头无效的掩码。在[0, 1]中选择的掩码值：- 1 表示头未被掩蔽，
- 0 表示头被掩蔽。
- output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 - interpolate_pos_encoding (
bool, 可选, 默认为False) — 是否插值预训练的位置编码。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。 - labels (
torch.LongTensor，形状为(batch_size, height, width)，可选) — 用于计算损失的真实语义分割图。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels > 1，则计算分类损失（交叉熵）。
返回值
transformers.modeling_outputs.SemanticSegmenterOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.SemanticSegmenterOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (BeitConfig) 和输入。
-
loss (形状为
(1,)的torch.FloatTensor, 可选, 当提供labels时返回) — 分类 (或回归，如果 config.num_labels==1) 损失。 -
logits (
torch.FloatTensor，形状为(batch_size, config.num_labels, logits_height, logits_width)) — 每个像素的分类得分。返回的 logits 不一定与作为输入传递的
pixel_values具有相同的大小。这是为了避免进行两次插值，并在用户需要将 logits 调整为原始图像大小作为后处理时损失一些质量。您应始终检查您的 logits 形状并根据需要调整大小。 -
hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型具有嵌入层，则为嵌入的输出提供一个，加上每一层的输出提供一个），形状为(batch_size, patch_size, hidden_size)。模型在每一层输出的隐藏状态，加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组 (每层一个)，形状为(batch_size, num_heads, patch_size, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
BeitForSemanticSegmentation 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> 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.logitsFlaxBeitModel
class transformers.FlaxBeitModel
< 源代码 >( config: BeitConfig input_shape = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (BeitConfig) — 模型配置类，其中包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
- dtype (
jax.numpy.dtype，可选，默认为jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定，所有计算将使用给定的
dtype执行。请注意，这仅指定计算的 dtype，并不影响模型参数的 dtype。
纯 Beit 模型 transformer，输出原始隐藏状态，顶部没有任何特定的 head。
此模型继承自 FlaxPreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如，从 PyTorch 模型下载、保存和转换权重）。
此模型也是 flax.linen.Module 的子类。将其用作常规 Flax linen Module，并参考 Flax 文档以了解与一般用法和行为相关的所有事项。
最后，此模型支持固有的 JAX 功能，例如
__call__
< 源代码 >( pixel_values bool_masked_pos = None params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.beit.modeling_flax_beit.FlaxBeitModelOutputWithPooling 或 tuple(torch.FloatTensor)
返回值
transformers.models.beit.modeling_flax_beit.FlaxBeitModelOutputWithPooling 或 tuple(torch.FloatTensor)
一个 transformers.models.beit.modeling_flax_beit.FlaxBeitModelOutputWithPooling 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (<class 'transformers.models.beit.configuration_beit.BeitConfig'>) 和输入。
- last_hidden_state (
jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 - pooler_output (
jnp.ndarray，形状为(batch_size, hidden_size)) — 如果 config.use_mean_pooling 设置为 True，则为图像块 tokens（排除 [CLS] token）的最后一层隐藏状态的平均值。如果设置为 False，则将返回 [CLS] token 的最终隐藏状态。 - hidden_states (
tuple(jnp.ndarray)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的元组（嵌入的输出提供一个，加上每一层的输出提供一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态加上初始嵌入输出。 - attentions (
tuple(jnp.ndarray)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
FlaxBeitPreTrainedModel 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoImageProcessor, FlaxBeitModel
>>> 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-ft22k")
>>> model = FlaxBeitModel.from_pretrained("microsoft/beit-base-patch16-224-pt22k-ft22k")
>>> inputs = image_processor(images=image, return_tensors="np")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_stateFlaxBeitForMaskedImageModeling
class transformers.FlaxBeitForMaskedImageModeling
< 源代码 >( config: BeitConfig input_shape = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (BeitConfig) — 模型配置类，其中包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
- dtype (
jax.numpy.dtype，可选，默认为jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定，所有计算将使用给定的
dtype执行。请注意，这仅指定计算的 dtype，并不影响模型参数的 dtype。
带有“语言”建模 head 的 Beit 模型 transformer（用于预测视觉 tokens）。
此模型继承自 FlaxPreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如，从 PyTorch 模型下载、保存和转换权重）。
此模型也是 flax.linen.Module 的子类。将其用作常规 Flax linen Module，并参考 Flax 文档以了解与一般用法和行为相关的所有事项。
最后，此模型支持固有的 JAX 功能，例如
__call__
< 源代码 >( pixel_values bool_masked_pos = None params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或 tuple(torch.FloatTensor)
返回值
transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (<class 'transformers.models.beit.configuration_beit.BeitConfig'>) 和输入。
-
logits (
jnp.ndarray，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模 head 的预测得分（SoftMax 之前的每个词汇表 token 的得分）。 -
hidden_states (
tuple(jnp.ndarray)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的元组（嵌入的输出提供一个，加上每一层的输出提供一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出端的隐藏状态，加上初始嵌入输出。
-
attentions (
tuple(jnp.ndarray)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
FlaxBeitPreTrainedModel 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
bool_masked_pos (numpy.ndarray，形状为 (batch_size, num_patches)): 布尔掩码位置。指示哪些图像块被掩码 (1)，哪些没有 (0)。
示例
>>> from transformers import AutoImageProcessor, BeitForMaskedImageModeling
>>> 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")
>>> inputs = image_processor(images=image, return_tensors="np")
>>> outputs = model(**inputs)
>>> logits = outputs.logitsFlaxBeitForImageClassification
class transformers.FlaxBeitForImageClassification
< 源代码 >( config: BeitConfig input_shape = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (BeitConfig) — 模型配置类，其中包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
- dtype (
jax.numpy.dtype，可选，默认为jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定，所有计算将使用给定的
dtype执行。请注意，这仅指定计算的 dtype，并不影响模型参数的 dtype。
Beit 模型转换器，顶部带有一个图像分类头 (位于 patch tokens 的最终隐藏状态平均值之上的线性层)，例如用于 ImageNet。
此模型继承自 FlaxPreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如，从 PyTorch 模型下载、保存和转换权重）。
此模型也是 flax.linen.Module 的子类。将其用作常规 Flax linen Module，并参考 Flax 文档以了解与一般用法和行为相关的所有事项。
最后，此模型支持固有的 JAX 功能，例如
__call__
< 源代码 >( pixel_values bool_masked_pos = None params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput 或 tuple(torch.FloatTensor)
返回值
transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (<class 'transformers.models.beit.configuration_beit.BeitConfig'>) 和输入。
-
logits (
jnp.ndarray，形状为(batch_size, config.num_labels)) — 分类（如果 config.num_labels==1，则为回归）得分（SoftMax 之前）。 -
hidden_states (
tuple(jnp.ndarray)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的元组（嵌入的输出提供一个，加上每一层的输出提供一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出端的隐藏状态，加上初始嵌入输出。
-
attentions (
tuple(jnp.ndarray)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
FlaxBeitPreTrainedModel 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoImageProcessor, FlaxBeitForImageClassification
>>> 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")
>>> model = FlaxBeitForImageClassification.from_pretrained("microsoft/beit-base-patch16-224")
>>> inputs = image_processor(images=image, return_tensors="np")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])