Transformers 4.37 中文文档（六十四）

原文：huggingface.co/docs/transformers

YOSO

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/yoso

概述

YOSO 模型提出于You Only Sample (Almost) Once: Linear Cost Self-Attention Via Bernoulli Sampling

作者：Zhanpeng Zeng，Yunyang Xiong，Sathya N. Ravi，Shailesh Acharya，Glenn Fung，Vikas Singh。YOSO 通过基于局部敏感哈希（LSH）的伯努利采样方案近似标准 softmax 自注意力。原则上，所有伯努利随机变量可以通过单个哈希进行采样。

论文摘要如下：

基于 Transformer 的模型在自然语言处理（NLP）中被广泛使用。Transformer 模型的核心是自注意机制，它捕捉输入序列中令牌对的交互，并且在序列长度上呈二次方依赖。在较长序列上训练这样的模型是昂贵的。在本文中，我们展示了基于局部敏感哈希（LSH）的伯努利采样注意机制，将这些模型的二次复杂度降低到线性。我们通过将自注意力视为与伯努利随机变量相关联的各个令牌的总和来绕过二次成本，这些随机变量原则上可以通过单个哈希一次性采样（尽管在实践中，这个数字可能是一个小常数）。这导致了一种有效的采样方案来估计自注意力，该方案依赖于 LSH 的特定修改（以便在 GPU 架构上部署）。我们在 GLUE 基准测试中评估了我们的算法，标准 512 序列长度下，我们看到相对于标准预训练 Transformer 有良好的性能。在长距离竞技场（LRA）基准测试中，用于评估长序列性能，我们的方法实现了与 softmax 自注意力一致的结果，但具有可观的加速和内存节省，并且通常优于其他高效的自注意力方法。我们的代码可以在此 https URL 找到

此模型由novice03贡献。原始代码可以在此处找到。

使用提示

• YOSO 注意力算法通过自定义 CUDA 内核实现，这些内核是用 CUDA C++编写的函数，可以在 GPU 上并行执行多次。
• 这些内核提供了一个fast_hash函数，它使用快速哈达玛变换近似查询和键的随机投影。使用这些哈希码，lsh_cumulation函数通过基于 LSH 的伯努利采样近似自注意力。
• 要使用自定义内核，用户应设置config.use_expectation = False。为了确保内核成功编译，用户必须安装正确版本的 PyTorch 和 cudatoolkit。默认情况下，config.use_expectation = True，使用 YOSO-E，不需要编译 CUDA 内核。

YOSO 注意力算法。摘自原始论文。

资源

• 文本分类任务指南
• 令牌分类任务指南
• 问答任务指南
• 遮蔽语言建模任务指南
• 多项选择任务指南

YosoConfig

class transformers.YosoConfig

<来源>

( vocab_size = 50265 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 4096 type_vocab_size = 1 initializer_range = 0.02 layer_norm_eps = 1e-12 position_embedding_type = 'absolute' use_expectation = True hash_code_len = 9 num_hash = 64 conv_window = None use_fast_hash = True lsh_backward = True pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 **kwargs )

参数

• vocab_size（int，可选，默认为 50265）—YOSO 模型的词汇量。定义了在调用 YosoModel 时可以由inputs_ids传递的不同令牌数量。
• hidden_size（int，可选，默认为 768）—编码器层和池化层的维度。
• num_hidden_layers (int, optional, 默认为 12) — Transformer 编码器中的隐藏层数量。
• num_attention_heads (int, optional, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。
• intermediate_size (int, optional, 默认为 3072) — Transformer 编码器中“中间”（即前馈）层的维度。
• hidden_act (str 或 function, optional, 默认为 "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu", "relu", "selu" 和 "gelu_new"。
• hidden_dropout_prob (float, optional, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
• attention_probs_dropout_prob (float, optional, 默认为 0.1) — 注意力概率的 dropout 比率。
• max_position_embeddings (int, optional, 默认为 512) — 该模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512、1024 或 2048）。
• type_vocab_size (int, optional, 默认为 2) — 在调用 YosoModel 时传递的 token_type_ids 的词汇表大小。
• initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。
• position_embedding_type (str, optional, 默认为 "absolute") — 位置嵌入的类型。选择 "absolute", "relative_key", "relative_key_query" 中的一个。
• use_expectation (bool, optional, 默认为 True) — 是否使用 YOSO 期望。覆盖任何 num_hash 的效果。
• hash_code_len (int, optional, 默认为 9) — 哈希函数生成的哈希长度。
• num_hash (int, optional, 默认为 64) — 在 YosoSelfAttention 中使用的哈希函数数量。
• conv_window (int, optional) — 深度卷积的内核大小。
• use_fast_hash (bool, optional, 默认为 False) — 是否使用自定义的 cuda 内核，通过哈达玛变换执行快速随机投影。
• lsh_backward (bool, optional, 默认为 True) — 是否使用局部敏感哈希进行反向传播。

这是用于存储 YosoModel 配置的配置类。根据指定的参数实例化一个 YOSO 模型，定义模型架构。使用默认值实例化配置将产生类似于 YOSO uw-madison/yoso-4096 架构的配置。

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

示例：

>>> from transformers import YosoConfig, YosoModel

>>> # Initializing a YOSO uw-madison/yoso-4096 style configuration
>>> configuration = YosoConfig()

>>> # Initializing a model (with random weights) from the uw-madison/yoso-4096 style configuration
>>> model = YosoModel(configuration)

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

YosoModel

class transformers.YosoModel

< source >

( config )

参数

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

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

前向

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 避免在填充标记索引上执行注意力的掩码。选择的掩码值为[0, 1]：
  • 对于未屏蔽的标记，
  • 0 表示已屏蔽的标记。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 段标记索引，指示输入的第一部分和第二部分。索引选择范围为[0, 1]：
  • 0 对应于句子 A标记，
  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 什么是位置 ID？
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）- 用于使自注意力模块的选定头部失效的掩码。选择的掩码值为[0, 1]：
  • 1 表示头部未屏蔽，
  • 0 表示头部已屏蔽。
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

返回

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

transformers.modeling_outputs.BaseModelOutputWithCrossAttentions 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含各种元素，具体取决于配置（YosoConfig）和输入。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）- 模型最后一层输出的隐藏状态序列。
• 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 之后的注意力权重，用于计算自注意力头中的加权平均值。
• cross_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True和config.add_cross_attention=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, YosoModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/yoso-4096")
>>> model = YosoModel.from_pretrained("uw-madison/yoso-4096")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

YosoForMaskedLM

class transformers.YosoForMaskedLM

<来源>

( config )

参数

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

YOSO 模型在顶部带有language modeling头。该模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有信息。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: 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)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 输入序列标记在词汇表中的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是 input IDs？
• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：
  • 1 表示未被masked的标记，
  • 0 表示被masked的标记。

  什么是 attention masks？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
  • 0 对应于句子 A的标记，
  • 1 对应于句子 B的标记。

  什么是 token type IDs？

• position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。 什么是位置 ID？
• head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块的选定头部失效的掩码。掩码值选择在 [0, 1] 中：
  • 1 表示头部未被遮蔽，
  • 0 表示头部被遮蔽。
• inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以直接传递一个嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为关联向量，而不是使用模型的内部嵌入查找矩阵，这将很有用。
• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多细节，请参阅返回张量中的 attentions。
• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多细节，请参阅返回张量中的 hidden_states。
• return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通元组。
• labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算遮蔽语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 内（参见 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（遮蔽），损失仅计算具有标签在 [0, ..., config.vocab_size] 内的标记。

返回

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

一个 transformers.modeling_outputs.MaskedLMOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含各种元素，取决于配置（YosoConfig）和输入。

• 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 元组（每层一个）。 自注意力头中的注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, YosoForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/yoso-4096")
>>> model = YosoForMaskedLM.from_pretrained("uw-madison/yoso-4096")

>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="pt")

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

>>> # retrieve index of [MASK]
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)

>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-[MASK] tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

>>> outputs = model(**inputs, labels=labels)

YosoForSequenceClassification

class transformers.YosoForSequenceClassification

<来源>

( config )

参数

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

YOSO 模型变压器，顶部带有序列分类/回归头（池化输出之上的线性层），例如用于 GLUE 任务。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: 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.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids（torch.LongTensor，形状为(batch_size, sequence_length)）— 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask（torch.FloatTensor，形状为(batch_size, sequence_length)，可选）— 避免对填充标记索引执行注意力的掩码。掩码值选择在[0, 1]之间：
  • 1 表示未被masked的标记，
  • 0 表示被masked的标记。

  什么是注意力掩码？

• token_type_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）— 段令牌索引，指示输入的第一部分和第二部分。索引选择在[0, 1]之间：
  • 0 对应于句子 A标记，
  • 1 对应于句子 B标记。

  什么是令牌类型 ID？

• position_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 什么是位置 ID？
• head_mask（torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选）— 用于使自注意力模块中的选定头部失效的掩码。掩码值选择在[0, 1]之间：
  • 1 表示头部未被masked，
  • 0 表示头部被masked。
• inputs_embeds（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• 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.SequenceClassifierOutput 或tuple(torch.FloatTensor)

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

• 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, sequence_length, sequence_length)。 注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

单标签分类的示例：

>>> import torch
>>> from transformers import AutoTokenizer, YosoForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/yoso-4096")
>>> model = YosoForSequenceClassification.from_pretrained("uw-madison/yoso-4096")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

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

>>> predicted_class_id = logits.argmax().item()

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = YosoForSequenceClassification.from_pretrained("uw-madison/yoso-4096", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss

多标签分类的示例：

>>> import torch
>>> from transformers import AutoTokenizer, YosoForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/yoso-4096")
>>> model = YosoForSequenceClassification.from_pretrained("uw-madison/yoso-4096", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

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

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = YosoForSequenceClassification.from_pretrained(
...     "uw-madison/yoso-4096", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss

YosoForMultipleChoice

class transformers.YosoForMultipleChoice

< source >

( config )

参数

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

YOSO 模型在顶部具有多选分类头（池化输出上的线性层和 softmax），例如用于 RocStories/SWAG 任务。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: 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.MultipleChoiceModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, num_choices, sequence_length)的torch.LongTensor） — 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 输入 ID 是什么？
• attention_mask（形状为(batch_size, num_choices, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：
  • 1 对于未被遮蔽的标记，
  • 0 对于被遮蔽的标记。

  注意力掩码是什么？

• token_type_ids（形状为(batch_size, num_choices, sequence_length)的torch.LongTensor，可选）— 指示输入的第一部分和第二部分的段标记索引。索引选在[0, 1]中：
  • 0 对应于句子 A的标记，
  • 1 对应于句子 B的标记。

  令牌类型 ID 是什么？

• position_ids（形状为(batch_size, num_choices, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 位置 ID 是什么？
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块中选择的头部失效的掩码。掩码值选在[0, 1]之间：
  • 1 表示头部未被遮蔽，
  • 0 表示头部被遮蔽。
• inputs_embeds（形状为(batch_size, num_choices, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通的元组。
• labels（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算多项选择分类损失的标签。索引应在[0, ..., num_choices-1]中，其中num_choices是输入张量的第二维的大小。（参见上面的input_ids）

返回

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

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

• loss（形状为*(1,)*的torch.FloatTensor，可选，当提供labels时返回）— 分类损失。
• logits（形状为(batch_size, num_choices)的torch.FloatTensor）— num_choices是输入张量的第二维。（参见上面的input_ids）。 分类得分（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元组（每层一个）。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, YosoForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/yoso-4096")
>>> model = YosoForMultipleChoice.from_pretrained("uw-madison/yoso-4096")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits

YosoForTokenClassification

class transformers.YosoForTokenClassification

<来源>

( config )

参数

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

YOSO 模型，顶部带有一个标记分类头（隐藏状态输出顶部的线性层），例如用于命名实体识别（NER）任务。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: 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.TokenClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor） — 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选） — 避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：
  • 1 表示未被掩码的标记，
  • 0 表示被掩码的标记。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选） — 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
  • 0 对应于句子 A的标记，
  • 1 对应于句子 B的标记。

  什么是标记类型 ID？

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选） — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中的选定头部失效的掩码。掩码值选定在[0, 1]之间：
  • 1 表示头部未被掩码，
  • 0 表示头部被掩码。
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多细节，请参阅返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多细节，请参阅返回张量下的hidden_states。
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。
• labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算标记分类损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。

返回值

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

一个 transformers.modeling_outputs.TokenClassifierOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False，则包括根据配置（YosoConfig）和输入不同元素。

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 分类损失。
• logits (torch.FloatTensor of shape (batch_size, sequence_length, config.num_labels)) — 分类分数（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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, YosoForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/yoso-4096")
>>> model = YosoForTokenClassification.from_pretrained("uw-madison/yoso-4096")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

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

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss

YosoForQuestionAnswering

class transformers.YosoForQuestionAnswering

<来源>

( config )

参数

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

YOSO 模型在顶部具有用于提取问答任务（如 SQuAD）的跨度分类头（在隐藏状态输出顶部的线性层上计算span start logits和span end logits）。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.QuestionAnsweringModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）-输入序列标记在词汇表中的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）-用于避免在填充令牌索引上执行注意力的掩码。掩码值在[0, 1]中选择：
  • 对于被masked的令牌，为 1，
  • 对于被masked的令牌，为 0。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）-段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
  • 0 对应于句子 A令牌，
  • 1 对应于句子 B令牌。

  令牌类型 ID 是什么？

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）-输入序列标记的位置在位置嵌入中的索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）-用于使自注意力模块的选定头部无效的掩码。掩码值在[0, 1]中选择：
  • 1 表示头部未被masked，
  • 0 表示头部被masked。
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）-可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
• output_attentions（bool，可选）-是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）-是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）-是否返回 ModelOutput 而不是普通元组。
• start_positions (torch.LongTensor，形状为(batch_size,)，可选) — 用于计算标记跨度起始位置的位置（索引）标签，以计算标记分类损失。位置被夹紧到序列的长度(sequence_length)。超出序列范围的位置不会被考虑在内计算损失。
• end_positions (torch.LongTensor，形状为(batch_size,)，可选) — 用于计算标记跨度结束位置的位置（索引）标签。位置被夹紧到序列的长度(sequence_length)。超出序列范围的位置不会被考虑在内计算损失。

返回值

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

一个 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置(YosoConfig)和输入的不同元素。

• loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 总跨度抽取损失是起始和结束位置的交叉熵之和。
• start_logits (torch.FloatTensor，形状为(batch_size, sequence_length)) — 跨度起始得分（SoftMax 之前）。
• end_logits (torch.FloatTensor，形状为(batch_size, sequence_length)) — 跨度结束得分（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元组（每层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, YosoForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/yoso-4096")
>>> model = YosoForQuestionAnswering.from_pretrained("uw-madison/yoso-4096")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss

愿景模型

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]

BeitForImageClassification

class transformers.BeitForImageClassification

< source >

( config: BeitConfig )

参数

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

Beit 模型变压器，顶部带有图像分类头（线性层位于补丁标记的最终隐藏状态的平均值之上），例如用于 ImageNet。

此模型是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( pixel_values: 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.ImageClassifierOutput or 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。
• 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)) — 分类（如果config.num_labels==1则为回归）得分（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, patch_size, sequence_length)的torch.FloatTensor元组（每层一个）。 注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

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

class transformers.BeitForSemanticSegmentation

<来源>

( config: BeitConfig )

参数

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

Beit 模型变换器，顶部带有语义分割头，例如用于 ADE20k、CityScapes。

此模型是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

( pixel_values: 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.SemanticSegmenterOutput or 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。
• return_dict（bool，可选）- 是否返回一个 ModelOutput 而不是一个普通的元组。
• labels（形状为(batch_size, height, width)的torch.LongTensor，可选）- 用于计算损失的地面真实语义分割地图。索引应在[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（形状为(batch_size, config.num_labels, logits_height, logits_width)的torch.FloatTensor）- 每个像素的分类分数。 返回的 logits 不一定与作为输入传递的pixel_values具有相同的大小。这是为了避免进行两次插值并在用户需要将 logits 调整为原始图像大小时丢失一些质量。您应该始终检查您的 logits 形状并根据需要调整大小。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, patch_size, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出）。 模型在每个层的输出处的隐藏状态以及可选的初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, patch_size, sequence_length)的torch.FloatTensor元组（每个层一个）。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

BeitForSemanticSegmentation 前向方法，覆盖__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用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.logits

JAXHide JAX 内容

FlaxBeitModel

class transformers.FlaxBeitModel

< source >

( 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，请参阅 to_fp16()和 to_bf16()。

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

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

这个模型也是一个flax.linen.Module子类。将其用作常规的 Flax linen 模块，并参考 Flax 文档以获取与一般用法和行为相关的所有内容。

最后，这个模型支持 JAX 的固有特性，例如：

• 即时（JIT）编译
• 自动微分
• 矢量化
• 并行化

__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 ) → export const metadata = 'undefined';transformers.models.beit.modeling_flax_beit.FlaxBeitModelOutputWithPooling or 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，则是补丁标记的最后一层隐藏状态的平均值（不包括*[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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用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_state

FlaxBeitForMaskedImageModeling

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执行。 请注意，这仅指定计算的数据类型，不影响模型参数的数据类型。 如果希望更改模型参数的数据类型，请参阅 to_fp16()和 to_bf16()。

在顶部添加一个“语言”建模头的 Beit 模型变换器（用于预测视觉标记）。

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

此模型还是一个flax.linen.Module子类。将其用作常规的 Flax linen 模块，并参考 Flax 文档以了解与一般用法和行为相关的所有事项。

最后，此模型支持 JAX 的固有特性，例如：

• 即时编译（JIT）
• 自动微分
• 矢量化
• 并行化

__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 ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxMaskedLMOutput or 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（形状为(batch_size, sequence_length, config.vocab_size)的jnp.ndarray） — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• 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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

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

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, optional, 默认为 jax.numpy.float32) — 计算的数据类型。可以是 jax.numpy.float32, jax.numpy.float16 (在 GPU 上) 和 jax.numpy.bfloat16 (在 TPU 上) 中的一个。 这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定了，所有的计算将使用给定的 dtype 进行。 请注意，这只指定了计算的数据类型，不影响模型参数的数据类型。 如果您希望更改模型参数的数据类型，请参阅 to_fp16() 和 to_bf16()。

Beit 模型变换器，顶部带有一个图像分类头（一个线性层位于补丁标记的最终隐藏状态的平均值之上），例如用于 ImageNet。

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

这个模型也是一个 flax.linen.Module 的子类。将其用作常规的 Flax linen 模块，并参考 Flax 文档以获取有关一般用法和行为的所有相关信息。

最后，这个模型支持 JAX 的内在特性，比如：

• 即时编译 (JIT)
• 自动微分
• 向量化
• 并行化

__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 ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput or 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), optional, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray 元组（一个用于嵌入的输出 + 一个用于每一层的输出）。 模型在每一层输出的隐藏状态以及初始嵌入输出。
• attentions (tuple(jnp.ndarray), optional, 当传递 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 jnp.ndarray 元组（每一层一个）。 自注意力头中的注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

虽然前向传递的步骤需要在这个函数内定义，但应该在之后调用 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])

Big Transfer (BiT)

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

概述

BiT 模型是由 Alexander Kolesnikov, Lucas Beyer, Xiaohua Zhai, Joan Puigcerver, Jessica Yung, Sylvain Gelly, Neil Houlsby 在 Big Transfer (BiT): General Visual Representation Learning 中提出的。BiT 是一个简单的方法，用于扩大类似于 ResNet（具体来说是 ResNetv2）的架构的预训练。该方法在迁移学习方面取得了显著的改进。

该论文的摘要如下：

预训练表示的迁移提高了样本效率，并简化了训练视觉深度神经网络时的超参数调整。我们重新审视了在大型监督数据集上进行预训练并在目标任务上微调模型的范例。我们扩大了预训练规模，并提出了一个我们称之为 Big Transfer (BiT) 的简单方法。通过组合几个精心选择的组件，并使用简单的启发式方法进行迁移，我们在超过 20 个数据集上取得了强大的性能。BiT 在各种数据范例中表现良好 — 从每类 1 个示例到总共 1M 个示例。BiT 在 ILSVRC-2012 上达到了 87.5% 的 top-1 准确率，在 CIFAR-10 上达到了 99.4%，在 19 个任务的 Visual Task Adaptation Benchmark (VTAB) 上达到了 76.3%。在小数据集上，BiT 在每类 10 个示例的情况下，ILSVRC-2012 达到了 76.8%，在 CIFAR-10 上达到了 97.0%。我们对导致高迁移性能的主要组件进行了详细分析。

此模型由 nielsr 贡献。原始代码可在 此处 找到。

使用提示

• BiT 模型在架构上等同于 ResNetv2，除了：1）所有批量归一化层都被 group normalization 取代，2）卷积层使用 weight standardization。作者表明，这两者的结合对于使用大批量大小进行训练是有用的，并且对迁移学习有显著影响。

资源

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

图像分类

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

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

BitConfig

class transformers.BitConfig

< source >

( num_channels = 3 embedding_size = 64 hidden_sizes = [256, 512, 1024, 2048] depths = [3, 4, 6, 3] layer_type = 'preactivation' hidden_act = 'relu' global_padding = None num_groups = 32 drop_path_rate = 0.0 embedding_dynamic_padding = False output_stride = 32 width_factor = 1 out_features = None out_indices = None **kwargs )

参数

• num_channels (int, optional, defaults to 3) — 输入通道数。
• embedding_size (int, optional, defaults to 64) — 嵌入层的维度（隐藏大小）。
• hidden_sizes (List[int], optional, defaults to [256, 512, 1024, 2048]) — 每个阶段的维度（隐藏大小）。
• depths (List[int], optional, defaults to [3, 4, 6, 3]) — 每个阶段的深度（层数）。
• layer_type (str, optional, defaults to "preactivation") — 要使用的层，可以是 "preactivation" 或 "bottleneck"。
• hidden_act (str, optional, defaults to "relu") — 每个块中的非线性激活函数。如果是字符串，支持 "gelu", "relu", "selu" 和 "gelu_new"。
• global_padding (str, 可选) — 用于卷积层的填充策略。可以是 "valid"、"same" 或 None。
• num_groups (int, 可选, 默认为 32) — 用于 BitGroupNormActivation 层的组数。
• drop_path_rate (float, 可选, 默认为 0.0) — 随机深度的丢弃路径率。
• embedding_dynamic_padding (bool, 可选, 默认为 False) — 是否使用动态填充来进行嵌入层。
• output_stride (int, 可选, 默认为 32) — 模型的输出步幅。
• width_factor (int, 可选, 默认为 1) — 模型的宽度因子。
• 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 属性中定义的顺序。

这是一个配置类，用于存储 BitModel 的配置。根据指定的参数实例化一个 BiT 模型，定义模型架构。使用默认值实例化配置将产生类似于 BiT google/bit-50 架构的配置。

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

示例：

>>> from transformers import BitConfig, BitModel

>>> # Initializing a BiT bit-50 style configuration
>>> configuration = BitConfig()

>>> # Initializing a model (with random weights) from the bit-50 style configuration
>>> model = BitModel(configuration)

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

BitImageProcessor

class transformers.BitImageProcessor

< source >

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

参数

• do_resize (bool, 可选, 默认为 True) — 是否将图像的（高度，宽度）维度调整为指定的 size。可以被 preprocess 方法中的 do_resize 覆盖。
• size (Dict[str, int] 可选, 默认为 {"shortest_edge" -- 224}): 调整大小后的图像大小。图像的最短边被调整为 size[“shortest_edge”]，最长边被调整以保持输入的纵横比。可以被 preprocess 方法中的 size 覆盖。
• resample (PILImageResampling, 可选, 默认为 PILImageResampling.BICUBIC) — 如果调整图像大小，则使用的重采样滤波器。可以被 preprocess 方法中的 resample 覆盖。
• do_center_crop (bool, 可选, 默认为 True) — 是否将图像居中裁剪到指定的 crop_size。可以被 preprocess 方法中的 do_center_crop 覆盖。
• crop_size (Dict[str, int] 可选, 默认为 224) — 应用 center_crop 后的输出图像大小。可以被 preprocess 方法中的 crop_size 覆盖。
• do_rescale (bool, 可选, 默认为 True) — 是否按照指定的比例 rescale_factor 重新缩放图像。可以被 preprocess 方法中的 do_rescale 覆盖。
• rescale_factor (int 或 float, 可选, 默认为 1/255) — 如果重新调整图像，则使用的比例因子。可以被 preprocess 方法中的 rescale_factor 覆盖。do_normalize — 是否对图像进行归一化。可以被 preprocess 方法中的 do_normalize 覆盖。
• image_mean (float 或 List[float], optional, defaults to OPENAI_CLIP_MEAN) — 如果归一化图像，则使用的均值。这是一个浮点数或与图像中通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_mean 参数覆盖。
• image_std (float 或 List[float], optional, defaults to OPENAI_CLIP_MEAN) — 如果归一化图像，则使用的标准差。这是一个浮点数或与图像中通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_std 参数覆盖。可以被 preprocess 方法中的 image_std 参数覆盖。
• do_convert_rgb (bool, optional, defaults to True) — 是否将图像转换为 RGB。

构造一个 BiT 图像处理器。

preprocess

< source >

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

参数

• images (ImageInput) — 要预处理的图像。期望单个或批量图像，像素值范围为 0 到 255。如果传入像素值在 0 到 1 之间的图像，请设置 do_rescale=False。
• do_resize (bool, optional, defaults to self.do_resize) — 是否调整图像大小。
• size (Dict[str, int], optional, defaults to self.size) — 调整大小后的图像尺寸。图像的最短边被调整为 size[“shortest_edge”]，最长边被调整以保持输入的长宽比。
• resample (int, optional, defaults to self.resample) — 如果调整图像大小，则使用的重采样滤波器。这可以是枚举 PILImageResampling 之一。仅在 do_resize 设置为 True 时有效。
• do_center_crop (bool, optional, defaults to self.do_center_crop) — 是否对图像进行中心裁剪。
• crop_size (Dict[str, int], optional, defaults to self.crop_size) — 中心裁剪的尺寸。仅在 do_center_crop 设置为 True 时有效。
• do_rescale (bool, optional, defaults to self.do_rescale) — 是否重新缩放图像。
• rescale_factor (float, optional, defaults to self.rescale_factor) — 如果 do_rescale 设置为 True，则重新缩放图像的重新缩放因子。
• do_normalize (bool, optional, defaults to self.do_normalize) — 是否对图像进行归一化。
• image_mean (float 或 List[float], optional, defaults to self.image_mean) — 用于归一化的图像均值。仅在 do_normalize 设置为 True 时有效。
• image_std (float 或 List[float], optional, defaults to self.image_std) — 用于归一化的图像标准差。仅在 do_normalize 设置为 True 时有效。
• do_convert_rgb (bool, optional, defaults to self.do_convert_rgb) — 是否将图像转换为 RGB。
• return_tensors (str 或 TensorType, optional) — 要返回的张量类型。可以是以下之一：
  • 未设置：返回一个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, optional, defaults to ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：
  • "channels_first" 或 ChannelDimension.FIRST：图像以 (num_channels, height, width) 格式。
  • "channels_last" 或 ChannelDimension.LAST：图像以 (height, width, num_channels) 格式。
  • 未设置：使用输入图像的通道维度格式。
• input_data_format (ChannelDimension 或 str, optional) — 输入图像的通道维度格式。如果未设置，则从输入图像推断通道维度格式。可以是以下之一：
  • "channels_first" 或 ChannelDimension.FIRST：图像以 (num_channels, height, width) 格式。
  • "channels_last" 或 ChannelDimension.LAST：图像以 (height, width, num_channels) 格式。
  • "none"或ChannelDimension.NONE：图像以（高度，宽度）格式。

预处理图像或图像批次。

BitModel

class transformers.BitModel

<来源>

( config )

参数

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

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

forward

<来源>

( pixel_values: Tensor output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 BitImageProcessor.call()。
• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的hidden_states。
• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

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

一个transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含各种元素，具体取决于配置(BitConfig)和输入。

• last_hidden_state (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 模型最后一层的隐藏状态序列。
• pooler_output (torch.FloatTensor，形状为(batch_size, hidden_size)) — 在空间维度上进行池化操作后的最后一层隐藏状态。
• hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("google/bit-50")
>>> model = BitModel.from_pretrained("google/bit-50")

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

BitForImageClassification

class transformers.BitForImageClassification

<来源>

( config )

参数

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

BiT 模型，顶部带有图像分类头部（在池化特征之上的线性层），例如用于 ImageNet。

此模型是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

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

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)） — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 BitImageProcessor.call()。
• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的hidden_states。
• return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。
• labels (torch.LongTensor，形状为(batch_size,)，可选） — 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

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

一个 transformers.modeling_outputs.ImageClassifierOutputWithNoAttention 或一个torch.FloatTensor元组（如果传递return_dict=False或者config.return_dict=False时）包含各种元素，取决于配置（BitConfig）和输入。

• 损失 (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类（或者如果config.num_labels==1则为回归）损失。
• logits (torch.FloatTensor，形状为(batch_size, config.num_labels)） — 分类（或者如果config.num_labels==1则为回归）得分（SoftMax 之前）。
• hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或者config.output_hidden_states=True时返回） — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组。模型在每个阶段输出的隐藏状态（也称为特征图）。

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

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

示例：

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("google/bit-50")
>>> model = BitForImageClassification.from_pretrained("google/bit-50")

>>> 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])
tiger cat

ifierOutputWithNoAttention or tuple(torch.FloatTensor)

参数

+   `pixel_values` (`torch.FloatTensor`，形状为`(batch_size, num_channels, height, width)`） — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 BitImageProcessor.`call`()。

+   `output_hidden_states` (`bool`，*可选*) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的`hidden_states`。

+   `return_dict` (`bool`，*可选*) — 是否返回一个 ModelOutput 而不是一个普通元组。

+   `labels` (`torch.LongTensor`，形状为`(batch_size,)`，*可选*） — 用于计算图像分类/回归损失的标签。索引应在`[0, ..., config.num_labels - 1]`范围内。如果`config.num_labels > 1`，则计算分类损失（交叉熵）。

返回

transformers.modeling_outputs.ImageClassifierOutputWithNoAttention 或`tuple(torch.FloatTensor)`

一个 transformers.modeling_outputs.ImageClassifierOutputWithNoAttention 或一个`torch.FloatTensor`元组（如果传递`return_dict=False`或者`config.return_dict=False`时）包含各种元素，取决于配置（BitConfig）和输入。

+   `损失` (`torch.FloatTensor`，形状为`(1,)`，*可选*，当提供`labels`时返回) — 分类（或者如果`config.num_labels==1`则为回归）损失。

+   `logits` (`torch.FloatTensor`，形状为`(batch_size, config.num_labels)`） — 分类（或者如果`config.num_labels==1`则为回归）得分（SoftMax 之前）。

+   `hidden_states` (`tuple(torch.FloatTensor)`，*可选*，当传递`output_hidden_states=True`或者`config.output_hidden_states=True`时返回） — 形状为`(batch_size, num_channels, height, width)`的`torch.FloatTensor`元组。模型在每个阶段输出的隐藏状态（也称为特征图）。

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

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

示例：

```py
>>> from transformers import AutoImageProcessor, BitForImageClassification
>>> import torch
>>> from datasets import load_dataset

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

>>> image_processor = AutoImageProcessor.from_pretrained("google/bit-50")
>>> model = BitForImageClassification.from_pretrained("google/bit-50")

>>> 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])
tiger cat