Transformers

( last_hidden_state: None类型 pooler_output: None类型 hidden_states: None类型 attentions: 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，则为 patch tokens 的最后一层隐藏状态的平均值（不包括 [CLS] tokens）。如果设置为 False，则返回 [CLS] tokens 的最终隐藏状态。
hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — Tuple 形状的 torch.FloatTensor (每个层一个，包括嵌入层的输出和一个层输出) (batch_size, sequence_length, hidden_size)。
模型在每个层输出的隐藏状态以及初始嵌入输出。
attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — Tuple 形状的 torch.FloatTensor (每个层一个) (batch_size, num_heads, sequence_length, sequence_length)。
在每个层的注意力 softmax 之后的注意力权重，用于计算每个自注意力头中的加权平均。

对应于 BeitModel 的输出的类。

类 transformers.models.beit.modeling_flax_beit.FlaxBeitModelOutputWithPooling

参数

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 模型的词汇大小。定义了预训练期间可以使用的信息 tokens 的数量。
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) — 嵌入层、编码器和池器中所有全连接层的dropout概率。
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) — 是否使用 mask token 进行掩码图像建模。
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]） — 在 Pooling Pyramid 模块应用于最后一个特征图时所使用的池化尺度。
use_auxiliary_head (bool，可选，默认为 True） — 场景中是否在使用辅助头进行训练。
auxiliary_loss_weight （float，可选，默认为 0.4） — 辅助头交叉熵损失的权重。
辅助通道 (int, 可选, 默认为256) — 在辅助头中使用的通道数量。
辅助卷积层数 (int, 可选, 默认为1) — 在辅助头中使用的卷积层数量。
辅助连接输入 (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（《布尔值》，《可选》，默认为《False》）— 是否将FPN作为骨干的一部分添加。仅适用于《BeitBackbone》。
reshape_hidden_states（《布尔值》，《可选》，默认为《True》）— 当模型作为骨干时，是否将特征图重塑为形状为《batch_size, hidden_size, height, width》的4D张量。如果为《False》，特征图为形状为《batch_size, seq_len, hidden_size`》的3D张量。仅适用于《BeitBackbone`。

这是一个存储BeitModel配置的配置类。它用于根据指定的参数实例化一个BEiT模型，定义模型架构。使用默认参数实例化配置将得到类似于BEiTmicrosoft/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

类 transformers.BeitFeatureExtractor

( *args **kwargs )

call

( images segmentation_maps = None **kwargs )

后处理语义分割

( outputs target_sizes: List = None ) → semantic_segmentation

参数

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

语义分割

List[torch.Tensor]的长度为batch_size，其中每个项对应于目标_sizes条目（如果指定target_sizes）。每个torch.Tensor的每个条目均对应于语义类别ID。

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

BeitImageProcessor

类 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, optional, 默认为 False) — 是否将分割图的全部标签值减1。通常用于将0用作背景的集合并不包括在所有类别的数据集中（例如，ADE20k）。背景标签将被替换为255。可以通过在 preprocess 方法中覆盖 do_reduce_labels 参数。

构建BEiT图像处理器。

preprocess

（( images: 联合类型 segmentation_maps: 联合类型 = None do_resize: bool = None size: Dict = None resample: 重采样 = None do_center_crop: bool = None crop_size: Dict = None do_rescale: bool = None rescale_factor: float = None do_normalize: bool = None image_mean: 联合类型 = None image_std: 联合类型 = None do_reduce_labels: 可选 = None return_tensors: 联合类型 = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: 联合类型 = 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，可选) — 返回张量的类型。可以是以下之一：
- 未设置：返回一个 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：图像格式为 (num_channels, height, width)。
- "channels_last" 或 ChannelDimension.LAST：图像格式为 (height, width, num_channels)。
- 未设置：使用输入图像的通道维度格式。
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)。

预处理图像或图像批。

后处理语义分割

( outputs target_sizes: List = None ) → semantic_segmentation

参数

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

语义分割

List[torch.Tensor]的长度为batch_size，其中每个项对应于目标_sizes条目（如果指定target_sizes）。每个torch.Tensor的每个条目均对应于语义类别ID。

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

Pytorch

隐藏 Pytorch 内容

BeitModel

类 transformers.BeitModel

( config: BeitConfig add_pooling_layer: bool = True )

参数

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

裸Beit模型转换器，输出原始隐藏状态而不顶部有任何特定头。此模型是PyTorch torch.nn.Module 子类。将其用作常规PyTorch模块，并参阅PyTorch文档以了解所有有关通用使用和行为的问题。

forward

( pixel_values: Tensor bool_masked_pos: Optional = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None interpolate_pos_encoding: bool = False return_dict: Optional = None ) → transformers.models.beit.modeling_beit.BeitModelOutputWithPooling 或 tuple(torch.FloatTensor)

参数

pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)）— 像素值。像素值可以使用AutoImageProcessor获取。更多信息请参阅BeitImageProcessor.call()。
head_mask (torch.FloatTensor，形状为(num_heads,) 或 (num_layers, num_heads)，可选）— 用于取消自注意力模块中选定头的mask。选择[0, 1]中的mask值：
output_attentions (bool，可选）— 是否返回所有注意力层的注意力张量。关于返回张量中的attentions的更多详细信息，请参见。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多详细信息请参阅返回张量下的 hidden_states。
interpolate_pos_encoding (bool, 可选, 默认为 False) — 是否插值预训练的位置编码。
return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是普通的元组。
bool_masked_pos (torch.BoolTensor 形状为 (batch_size, num_patches)，可选) — 表示哪些patches被遮挡（1）以及哪些没有被遮挡（0）的布尔型遮挡位置。

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

A transformers.models.beit.modeling_beit.BeitModelOutputWithPooling 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置（BeitConfig）和输入。

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 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)，可选，在传递 output_attentions=True 或当 config.output_attentions=True 时返回） — 一个 torch.FloatTensor 的元组（每个层一个）的形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力的权重，在注意力 softmax 后使用，用于在自注意力头中进行加权平均。

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

尽管前向传递的配方需要在函数内部定义，但应该调用 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

类 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 interpolate_pos_encoding: bool = False return_dict: Optional = None ) → transformers.modeling_outputs.MaskedLMOutput or tuple(torch.FloatTensor)

参数

pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 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 以获取更多详细信息。
interpolate_pos_encoding (bool, 可选, 默认为 False) — 是否插值预训练的位置编码。
return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是原始元组。
bool_masked_pos (torch.BoolTensor 的形状为 (batch_size, num_patches)) — 布尔掩码位置。表示哪些补丁被掩码（1）以及没有被掩码（0）。
labels (torch.LongTensor of shape (batch_size,), optional) — 用于计算图像分类/回归损失的标签。索引应在 [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 of shape (1,), optional, returned when labels is provided) — 掩码语言模型（MLM）损失。
logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言模型头部（SoftMax前的每个词汇表标记的得分）的预测得分。
hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when 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 后使用，用于在自注意力头中进行加权平均。

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

示例

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

参数

配置 (BeitConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不加载模型的权重，只加载配置。检查from_pretrained()方法以加载模型权重。

Beit 模型转换器，带图像分类头（在补丁标记的最终隐藏状态的均值之上线性层），例如用于 ImageNet。

此模型是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用，并参阅 PyTorch 文档了解所有与通用使用和行为相关的问题。

forward

( pixel_values: 可选 = None head_mask: 可选 = None labels: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None interpolate_pos_encoding: bool = False return_dict: 可选 = None ) → transformers.modeling_outputs.ImageClassifierOutput 或 tuple(torch.FloatTensor)

参数

pixel_values (torch.FloatTensor 形状 (batch_size, num_channels, height, width)) — 像素值。使用 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 以获取更多细节。
interpolate_pos_encoding (bool, 可选, 默认为 False) — 是否插值预训练的位置编码。
return_dict (bool, 可选) —— 是否返回ModelOutput对象而不是普通元组。
labels (torch.LongTensor，形状为(batch_size,)，可选) —— 计算图像分类/回归损失的标签。索引应在[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 （torch.FloatTensor，形状为(1,)，可选，当提供labels时返回） —— 分类损失（如果config.num_labels==1则为回归损失）。
logits （torch.FloatTensor，形状为(batch_size, config.num_labels)） —— 分类得分（在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 后使用，用于在自注意力头中进行加权平均。

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

示例

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

BeitForSemanticSegmentation

类 transformers.BeitForSemanticSegmentation

( config: BeitConfig )

参数

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

在Beit模型顶部添加语义分割头部，例如用于ADE20k、CityScapes等。

此模型是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用，并参阅 PyTorch 文档了解所有与通用使用和行为相关的问题。

forward

( pixel_values: 可选 = None head_mask: 可选 = None labels: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None interpolate_pos_encoding: 布尔型 = False return_dict: 可选 = None ) → transformers.modeling_outputs.SemanticSegmenterOutput 或 tuple(torch.FloatTensor)

参数

pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。像素值可通过 AutoImageProcessor 获取。详细信息请参考 BeitImageProcessor.call()。
head_mask (torch.FloatTensor 的 shape 为 (num_heads,) 或 (num_layers, num_heads)，可选) —— 空白化自注意力模块选中头的掩码。掩码值选在 [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 shape 为 (batch_size, height, width)，可选) — 用于计算损失的地面实况语义分割图。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels > 1，则计算分类损失（交叉熵）。

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

A transformers.modeling_outputs.SemanticSegmenterOutput 或一个包含各种元素的torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False）取决于配置(BeitConfig)和输入。

loss （torch.FloatTensor，形状为(1,)，可选，当提供labels时返回） —— 分类损失（如果config.num_labels==1则为回归损失）。
logits (torch.FloatTensor shape 为 (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 后使用，用于在自注意力头中进行加权平均。

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

示例

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

JAX

隐藏JAX内容

FlaxBeitModel

类 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 进行。

注意，这仅指定计算的数据类型，不影响模型参数的数据类型。

如果您想更改模型参数的数据类型，请参阅 to_fp16() 和 to_bf16()。

Beit 模型变压器，输出原始隐藏状态，顶部没有特定头。

此模型继承自 FlaxPreTrainedModel。请查看超级类文档，了解库为其所有模型实现的通用方法（例如下载、保存和从PyTorch模型转换权重）

此模型也是 flax.linen.Module 子类。将其用作常规 Flax linen 模块，并参考 Flax 文档以获取所有与通用使用和行为相关的事项。

最后，此模型支持以下继承自 JAX 的功能

call

( pixel_values bool_masked_pos = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.models.beit.modeling_flax_beit.FlaxBeitModelOutputWithPooling or tuple(torch.FloatTensor)

transformers.models.beit.modeling_flax_beit.FlaxBeitModelOutputWithPooling or 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，则为 patch tokens（排除 [CLS] token）的最后一层隐藏状态的平均值。如果设置为 False，则返回 [CLS] token 的最终隐藏状态。
hidden_states （tuple(jnp.ndarray)，可选，在传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回）— 包含一个形状为 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray 的元组（一个是嵌入输出的输出 + 每层的输出），这是每个层的隐藏状态以及初始嵌入输出。
注意事项 (jnp.ndarray元组，可选，当传递output_attentions=True时返回，或者当config.output_attentions=True时返回) — 一个形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每个层一个）。这是在注意力softmax后的注意力权重，用于在自注意力头中计算加权平均。

《FlaxBeitPreTrainedModel》的前向方法覆盖了特殊的__call__方法。

示例

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

FlaxBeitForMaskedImageModeling

类 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上）。
This can be used to enable mixed-precision training or half-precision inference on GPUs or TPUs. If specified all the computation will be performed with the given dtype.

请注意，这仅指定了计算的数据类型，并不会影响模型参数的数据类型。

如果您想更改模型参数的数据类型，请参阅to_fp16()和to_bf16()。

Beit模型变压器，顶部带有一个“语言”建模头（用于预测视觉标记）。

此模型继承自 FlaxPreTrainedModel。请查看超级类文档，了解库为其所有模型实现的通用方法（例如下载、保存和从PyTorch模型转换权重）

此模型也是 flax.linen.Module 子类。将其用作常规 Flax linen 模块，并参考 Flax 文档以获取所有与通用使用和行为相关的事项。

最后，此模型支持以下继承自 JAX 的功能

call

( pixel_values bool_masked_pos = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = 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），包含根据配置（例如 transformers.models.beit.configuration_beit.BeitConfig）和输入的不同元素。

logits（形状为 (batch_size, sequence_length, config.vocab_size) 的 jnp.ndarray）— 语言模型头的预测得分（SoftMax 之前的每个词汇的得分）。
hidden_states（在 output_hidden_states=True 传入时返回，或者当 config.output_hidden_states=True）— 包含 jnp.ndarray 的元组（一个是嵌入层的输出，一个是每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型每个层输出的隐藏状态以及初始嵌入输出。
attentions（在 output_attentions=True 传入时返回，或者当 config.output_attentions=True）— 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 jnp.ndarray 的元组（每个层的Attention矩阵）。

注意力的权重，在注意力 softmax 后使用，用于在自注意力头中进行加权平均。

《FlaxBeitPreTrainedModel》的前向方法覆盖了特殊的__call__方法。

bool_masked_pos（形状为 (batch_size, num_patches) 的 numpy.ndarray）：布尔掩码位置。表示哪些补丁被掩码（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.logits

FlaxBeitForImageClassification

类 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 上）。

Beit 模型转换器，带图像分类头（在补丁标记的最终隐藏状态的均值之上线性层），例如用于 ImageNet。

此模型继承自 FlaxPreTrainedModel。请查看超级类文档，了解库为其所有模型实现的通用方法（例如下载、保存和从PyTorch模型转换权重）

此模型也是 flax.linen.Module 子类。将其用作常规 Flax linen 模块，并参考 Flax 文档以获取所有与通用使用和行为相关的事项。

最后，此模型支持以下继承自 JAX 的功能

call