Transformers 4.37 中文文档（五十八）

原文：huggingface.co/docs/transformers

RWKV

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

概述

RWKV 模型是在此存储库中提出的。

它建议对传统 Transformer 注意力进行微调，使其线性化。这样，模型可以用作循环网络：同时传递时间戳 0 和时间戳 1 的输入与在时间戳 0 传递输入，然后在时间戳 1 传递输入以及时间戳 0 的状态是相同的（见下面的示例）。

这比常规 Transformer 更有效，并且可以处理任意长度的句子（即使模型在训练时使用固定的上下文长度）。

这个模型是由sgugger贡献的。原始代码可以在这里找到。

用法示例

import torch
from transformers import AutoTokenizer, RwkvConfig, RwkvModel

model = RwkvModel.from_pretrained("sgugger/rwkv-430M-pile")
tokenizer = AutoTokenizer.from_pretrained("sgugger/rwkv-430M-pile")

inputs = tokenizer("This is an example.", return_tensors="pt")
# Feed everything to the model
outputs = model(inputs["input_ids"])
output_whole = outputs.last_hidden_state

outputs = model(inputs["input_ids"][:, :2])
output_one = outputs.last_hidden_state

# Using the state computed on the first inputs, we will get the same output
outputs = model(inputs["input_ids"][:, 2:], state=outputs.state)
output_two = outputs.last_hidden_state

torch.allclose(torch.cat([output_one, output_two], dim=1), output_whole, atol=1e-5)

如果要确保模型在检测到'\n\n'时停止生成，我们建议使用以下停止标准：

from transformers import StoppingCriteria

class RwkvStoppingCriteria(StoppingCriteria):
    def __init__(self, eos_sequence = [187,187], eos_token_id = 537):
        self.eos_sequence = eos_sequence
        self.eos_token_id = eos_token_id

    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
        last_2_ids = input_ids[:,-2:].tolist()
        return self.eos_sequence in last_2_ids

output = model.generate(inputs["input_ids"], max_new_tokens=64, stopping_criteria = [RwkvStoppingCriteria()])

RwkvConfig

class transformers.RwkvConfig

<来源>

( vocab_size = 50277 context_length = 1024 hidden_size = 4096 num_hidden_layers = 32 attention_hidden_size = None intermediate_size = None layer_norm_epsilon = 1e-05 bos_token_id = 0 eos_token_id = 0 rescale_every = 6 tie_word_embeddings = False use_cache = True **kwargs )

参数

• vocab_size (int，可选，默认为 50277) — RWKV 模型的词汇量。定义了在调用 RwkvModel 时可以表示的不同标记数量。
• context_length (int，可选，默认为 1024) — 此模型可以在单个前向传播中使用的最大序列长度（在 RNN 模式中使用任何序列长度）。
• hidden_size (int，可选，默认为 4096) — 嵌入和隐藏状态的维度。
• num_hidden_layers (int，可选，默认为 32) — 模型中的隐藏层数量。
• attention_hidden_size (int，可选) — 注意力隐藏状态的维度。如果未设置，将默认为hidden_size。
• intermediate_size (int，可选) — 内部前馈层的维度。如果未设置，将默认为hidden_size的 4 倍。
• layer_norm_epsilon (float，可选，默认为 1e-05) — 在层归一化层中使用的 epsilon。
• bos_token_id (int，可选，默认为 0) — 词汇表中句子开头标记的 id。默认为 0，因为 RWKV 使用与 GPTNeoX 相同的分词器。
• eos_token_id (int，可选，默认为 0) — 词汇表中句子结尾标记的 id。默认为 0，因为 RWKV 使用与 GPTNeoX 相同的分词器。
• rescale_every (int，可选，默认为 6) — 推理时，隐藏状态（以及相应输出层的权重）每rescale_every层除以 2。如果设置为 0 或负数，则不进行重新缩放。
• tie_word_embeddings (bool，可选，默认为False) — 是否将单词嵌入与输入标记嵌入相结合。
• use_cache (bool，可选，默认为True) — 模型是否应返回最后一个状态。

这是存储 RwkvModel 配置的配置类。它用于根据指定的参数实例化一个 RWKV 模型，定义模型架构。使用默认值实例化配置将产生类似于 RWVK-4 RWKV/rwkv-4-169m-pile架构的配置。

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

示例：

>>> from transformers import RwkvConfig, RwkvModel

>>> # Initializing a Rwkv configuration
>>> configuration = RwkvConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = RwkvModel(configuration)

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

RwkvModel

class transformers.RwkvModel

<来源>

( config )

参数

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

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

这个模型继承自 PreTrainedModel。查看超类文档以获取库实现的所有模型的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

前进

<来源>

( input_ids: Optional = None attention_mask: Optional = None inputs_embeds: Optional = None state: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.rwkv.modeling_rwkv.RwkvOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, input_ids_length)的torch.LongTensor）— 如果past_key_values为None，则input_ids_length = sequence_length，否则为past_key_values[0][0].shape[-2]（输入过去关键值状态的序列长度）。词汇表中输入序列标记的索引。 如果使用past_key_values，则只有那些没有计算过去的input_ids应该作为input_ids传递。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask（形状为(batch_size, input_ids_length)的torch.LongTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：
  • 对于未被“掩码”的标记为 1，
  • 对于被“掩码”的标记为 0。

  目前RwkvModel不使用这个，但将在未来支持。 什么是注意力掩码？

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将很有用，而不是使用模型的内部嵌入查找矩阵。
• state（五个形状为(batch_size, hidden_size, num_hidden_layers)的torch.FloatTensor元组，可选）— 如果传递，模型将在所有块中使用先前的状态（这将为提供的input_ids提供输出，就好像模型将state_input_ids + input_ids作为上下文）。
• use_cache（bool，可选）— 如果设置为True，则返回上一个状态，并可用于快速生成下一个对数。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.rwkv.modeling_rwkv.RwkvOutput或tuple(torch.FloatTensor)

一个transformers.models.rwkv.modeling_rwkv.RwkvOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，具体取决于配置（RwkvConfig）和输入。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）- 模型最后一层的隐藏状态序列。
• state（形状为(batch_size, hidden_size, num_hidden_layers)的五个torch.FloatTensor列表）- 模型在最后一个时间步的状态。可以在前向方法中与下一个input_ids一起使用，以避免提供旧的input_ids。
• 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, RwkvModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("RWKV/rwkv-4-169m-pile")
>>> model = RwkvModel.from_pretrained("RWKV/rwkv-4-169m-pile")

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

>>> last_hidden_states = outputs.last_hidden_state

RwkvLMHeadModel

class transformers.RwkvForCausalLM

<来源>

( config )

参数

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

带有语言建模头部的 RWKV 模型变压器（线性层，其权重与输入嵌入绑定）。

该模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（例如下载或保存，调整输入嵌入大小，修剪头等）。

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None inputs_embeds: Optional = None state: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.rwkv.modeling_rwkv.RwkvCausalLMOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, input_ids_length)的torch.LongTensor）- 如果past_key_values为None，则input_ids_length=sequence_length，否则input_ids_length=past_key_values[0][0].shape[-2]（输入过去关键值状态的序列长度）。词汇表中输入序列标记的索引。 如果使用past_key_values，则只应将未计算其过去的input_ids作为input_ids传递。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask (torch.LongTensor，形状为(batch_size, input_ids_length)，可选) — 避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：
  • 1 表示未被掩盖的标记，
  • 0 表示被掩盖的标记。

  这目前RwkvModel没有使用，但将来会支持。 什么是注意力掩码？

• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。
• state（五个形状为(batch_size, hidden_size, num_hidden_layers)的torch.FloatTensor元组，可选） — 如果传递，模型将在所有块中使用先前的状态（这将为提供的input_ids产生输出，就好像模型将state_input_ids + input_ids作为上下文）。
• use_cache (bool，可选) — 如果设置为True，则返回上一个状态，并可用于快速生成下一个 logits。
• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。
• labels (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 语言建模的标签。请注意，标签在模型内部被移位，即您可以设置labels = input_ids。索引在[-100, 0, ..., config.vocab_size]中选择。所有设置为-100的标签都被忽略（掩盖），损失仅计算在[0, ..., config.vocab_size]中的标签。

返回

transformers.models.rwkv.modeling_rwkv.RwkvCausalLMOutput或tuple(torch.FloatTensor)

一个transformers.models.rwkv.modeling_rwkv.RwkvCausalLMOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含根据配置（RwkvConfig）和输入的不同元素。

• loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 语言建模损失（用于下一个标记预测）。
• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• state（五个形状为(batch_size, hidden_size, num_hidden_layers)的torch.FloatTensor列表） — 模型在最后一个时间步的状态。可以在前向方法中与下一个input_ids一起使用，以避免提供旧的input_ids。
• 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), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 注意权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

例如：

>>> import torch
>>> from transformers import AutoTokenizer, RwkvForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("RWKV/rwkv-4-169m-pile")
>>> model = RwkvForCausalLM.from_pretrained("RWKV/rwkv-4-169m-pile")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits

Rwkv 注意力和循环公式

在传统的自回归 Transformer 中，注意力写为O=softmax(QKT/d)VO = \hbox{softmax}(QK^{T} / \sqrt{d}) VO=softmax(QKT/d​)V

其中QQQ，KKK 和VVV 是形状为seq_len x hidden_size的矩阵，分别命名为查询、键和值（实际上它们是带有批处理维度和注意力头维度的更大矩阵，但我们只关心最后两个，这是矩阵乘积发生的地方，所以为了简单起见，我们只考虑这两个）。乘积QKTQK^{T}QKT 然后具有形状seq_len x seq_len，我们可以将其与VVV 进行矩阵乘积，得到与其他相同形状的输出OOO。

用其值替换 softmax 得到：Oi=∑j=1ieQiKjT/dVj∑j=1ieQiKjT/dO_{i} = \frac{\sum_{j=1}^{i} e^{Q_{i} K_{j}^{T} / \sqrt{d}} V_{j}}{\sum_{j=1}^{i} e^{Q_{i} K_{j}^{T} / \sqrt{d}}}Oi​=∑j=1i​eQi​KjT​/d​∑j=1i​eQi​KjT​/d​Vj​​

请注意，QKT 中与 j>i 对应的条目被屏蔽（总和在 j 处停止），因为注意力不允许查看未来的令牌（只能查看过去的令牌）。

相比之下，RWKV 注意力由 Oi = σ(Ri)（∑j=1i eWi−j + Kj Vj）/（∑j=1i eWi−j + Kj）给出。

作者称之为接受度的新矩阵 R，K 和 V 仍然是关键和值（这里σ是 Sigmoid 函数）。W 是代表令牌位置的新向量，由 W0 = u 和 Wk = (k-1)w（对于 k≥1）给出。

u 和 w 是可学习的参数，分别在代码中称为time_first和time_decay。分子和分母都可以递归表示。将它们命名为 Ni 和 Di，我们有：Ni = e^(u + Ki)Vi + N^i 其中 N^i = e^(Ki-1)Vi-1 + e^(w + Ki-2)Vi-2 + … + e^((i-2)w + K1)Vi-1

所以 N^i（在代码中称为numerator_state）满足 N⁰ = 0 和 N^j+1 = e^Kj Vj + e^w N^j

和 Di = e^(u + Ki) + D^i 其中 D^i = e^(Ki-1) + e^(w + Ki-2) + … + e^((i-2)w + K1)

因此，(\hat{D}^{i})（在代码中称为denominator_state）满足(\hat{D}{0} = 0)和(\hat{D}{j+1} = e^{K_{j}} + e^{w} \hat{D}_{j})。

实际使用的递归公式稍微复杂一些，因为为了数值稳定性，我们不希望计算大数的指数。通常，softmax 不是按原样计算的，而是将最大项的指数除以分子和分母：(\frac{e{x_{i}}}{\sum_{j=1}{n} e^{x_{j}}} = \frac{e^{x_{i} - M}}{\sum_{j=1}^{n} e^{x_{j} - M}})。

M 是所有 xj 的最大值。因此，在保存分子状态（(\hat{N})）和分母状态（(\hat{D})）的同时，我们还跟踪遇到的所有指数项的最大值。因此，我们实际上使用(\tilde{N}{i} = e^{-M{i}} \hat{N}{i})和(\tilde{D}{i} = e^{-M_{i}} \hat{D}_{i})。

根据以下递归公式定义：N~0=0 和 N~j+1=eKj−qVj+ew+Mj−qN~j 其中 q=max⁡(Kj,w+Mj)\tilde{N}{0} = 0 \hbox{ 和 } \tilde{N}{j+1} = e^{K_{j} - q} V_{j} + e^{w + M_{j} - q} \tilde{N}{j} \hbox{ 其中 } q = \max(K{j}, w + M_{j})N~0​=0 和 Nj+1​=eKj​−qVj​+ew+Mj​−qNj​ 其中 q=max(Kj​,w+Mj​)

根据以下递归公式定义：D~0=0 和 D~j+1=eKj−q+ew+Mj−qD~j 其中 q=max⁡(Kj,w+Mj)\tilde{D}{0} = 0 \hbox{ 和 } \tilde{D}{j+1} = e^{K_{j} - q} + e^{w + M_{j} - q} \tilde{D}{j} \hbox{ 其中 } q = \max(K{j}, w + M_{j})D~0​=0 和 Dj+1​=eKj​−q+ew+Mj​−qDj​ 其中 q=max(Kj​,w+Mj​)

和Mj+1=qM_{j+1} = qMj+1​=q。有了这些，我们可以计算Ni=eu+Ki−qVi+eMiN~i 其中 q=max⁡(u+Ki,Mi)N_{i} = e^{u + K_{i} - q} V_{i} + e^{M_{i}} \tilde{N}{i} \hbox{ 其中 } q = \max(u + K{i}, M_{i})Ni​=eu+Ki​−qVi​+eMi​N~i​ 其中 q=max(u+Ki​,Mi​)

和 Di = e^(u + Ki - q) + e^Mi D~i，其中 q = max(u + Ki, Mi)

最终给出了 Oi = σ(Ri) Ni / Di

Splinter

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

概述

Splinter 模型是由 Ori Ram、Yuval Kirstain、Jonathan Berant、Amir Globerson、Omer Levy 在 Few-Shot Question Answering by Pretraining Span Selection 中提出的。Splinter 是一个仅编码器的 transformer 模型（类似于 BERT），使用包含维基百科和多伦多图书语料库的大型语料库上的循环跨度选择任务进行预训练。

该论文的摘要如下：

在几个问答基准测试中，预训练模型通过在约 100,000 个注释问题和答案上进行微调达到了人类水平。我们探索了更现实的少样本设置，在这种情况下只有几百个训练示例可用，并观察到标准模型表现不佳，突显了当前预训练目标和问答之间的差异。我们提出了一种针对问答定制的新的预训练方案：循环跨度选择。给定一个包含多组循环跨度的段落，我们在每组中屏蔽所有循环跨度，然后要求模型为每个屏蔽的跨度在段落中选择正确的跨度。屏蔽的跨度将被一个特殊 token 替换，被视为问题表示，稍后在微调过程中用于选择答案跨度。结果模型在多个基准测试中获得了令人惊讶的好结果（例如，在只有 128 个训练示例的情况下，在 SQuAD 上达到了 72.7 的 F1 分数），同时在高资源设置中保持了竞争性能。

这个模型由 yuvalkirstain 和 oriram 贡献。原始代码可以在 这里 找到。

使用提示

• Splinter 被训练来预测在特定 [QUESTION] token 条件下的答案跨度。这些 token 用于上下文化问题表示，用于预测答案。这一层被称为 QASS，并且是 SplinterForQuestionAnswering 类中的默认行为。因此：
• 使用 SplinterTokenizer（而不是 BertTokenizer），因为它已经包含了这个特殊 token。此外，当给定两个序列时（例如在 run_qa.py 脚本中），其默认行为是使用这个 token。
• 如果您计划在 run_qa.py 之外使用 Splinter，请记住问题 token - 这对于您的模型的成功可能很重要，特别是在少样本设置中。
• 请注意，每个 Splinter 大小都有两个不同的检查点。它们基本上是相同的，只是一个还具有 QASS 层的预训练权重（tau/splinter-base-qass 和 tau/splinter-large-qass），另一个没有（tau/splinter-base 和 tau/splinter-large）。这样做是为了支持在微调时随机初始化这一层，因为在某些情况下已经证明这样做可以获得更好的结果。

资源

• 问答任务指南

SplinterConfig

class transformers.SplinterConfig

< source >

( vocab_size = 30522 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 = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 use_cache = True pad_token_id = 0 question_token_id = 104 **kwargs )

参数

• vocab_size (int, optional, 默认为 30522) — Splinter 模型的词汇大小。定义了在调用 SplinterModel 时可以表示的不同 token 数量。
• hidden_size (int, optional, 默认为 768) — 编码器层和池化层的维度。
• num_hidden_layers (int，optional，默认为 12) — Transformer 编码器中的隐藏层数量。
• num_attention_heads (int, optional, defaults to 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) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。
• attention_probs_dropout_prob (float，optional，默认为 0.1) — 注意力概率的丢弃比率。
• max_position_embeddings (int，optional，默认为 512) — 该模型可能被使用的最大序列长度。通常将其设置为较大的值以防万一（例如 512、1024 或 2048）。
• type_vocab_size (int，optional，默认为 2) — 调用 SplinterModel 时传递的token_type_ids的词汇表大小。
• initializer_range (float，optional，默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps (float，optional，默认为 1e-12) — 层归一化层使用的 epsilon。
• use_cache (bool，optional，默认为True) — 模型是否应返回最后的键/值注意力（不是所有模型都使用）。仅在config.is_decoder=True时相关。
• question_token_id (int，optional，默认为 104) — [QUESTION]标记的 ID。

这是用于存储 SplinterModel 配置的配置类。它用于根据指定的参数实例化 Splinter 模型，定义模型架构。使用默认值实例化配置将产生类似于 Splinter tau/splinter-base架构的配置。

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

示例：

>>> from transformers import SplinterModel, SplinterConfig

>>> # Initializing a Splinter tau/splinter-base style configuration
>>> configuration = SplinterConfig()

>>> # Initializing a model from the tau/splinter-base style configuration
>>> model = SplinterModel(configuration)

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

SplinterTokenizer

class transformers.SplinterTokenizer

<来源>

( vocab_file do_lower_case = True do_basic_tokenize = True never_split = None unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' question_token = '[QUESTION]' tokenize_chinese_chars = True strip_accents = None **kwargs )

参数

• vocab_file (str) — 包含词汇表的文件。
• do_lower_case (bool，optional，默认为True) — 在分词时是否将输入转换为小写。
• do_basic_tokenize (bool, optional, defaults to True) — 是否在 WordPiece 之前进行基本的分词。
• never_split (Iterable，optional) — 在分词时永远不会被拆分的标记集合。仅在do_basic_tokenize=True时有效。
• unk_token (str，optional，默认为"[UNK]") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。
• sep_token (str，optional，默认为"[SEP]") — 分隔符标记，在构建多个序列时使用，例如用于序列分类的两个序列或用于文本和问题的问题回答。它还用作使用特殊标记构建的序列的最后一个标记。
• pad_token (str，optional，默认为"[PAD]") — 用于填充的标记，例如在批处理不同长度的序列时使用。
• cls_token (str, optional, defaults to "[CLS]") — 在进行序列分类（对整个序列而不是每个标记进行分类）时使用的分类器标记。当使用特殊标记构建序列时，它是序列的第一个标记。
• mask_token (str, optional, defaults to "[MASK]") — 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
• question_token (str, optional, defaults to "[QUESTION]") — 用于构建问题表示的标记。
• tokenize_chinese_chars (bool, optional, defaults to True) — 是否对中文字符进行分词。 对于日语，这可能应该被停用（参见此问题）。
• strip_accents (bool, optional) — 是否去除所有重音符号。如果未指定此选项，则将由lowercase的值确定（与原始 BERT 相同）。

构建一个 Splinter 分词器。基于 WordPiece。

此分词器继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

build_inputs_with_special_tokens

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — 如果 pad_on_right，则为问题标记 ID，否则为上下文标记 ID
• token_ids_1 (List[int], optional) — 如果 pad_on_right，则为上下文标记 ID，否则为问题标记 ID

返回

List[int]

具有适当特殊标记的 input IDs 列表。

通过连接和添加特殊标记来从一对序列构建用于问答任务的模型输入。Splinter 序列具有以下格式：

• 单个序列：[CLS] X [SEP]
• 用于问答的序列对：[CLS] 问题标记 [QUESTION] . [SEP] 上下文标记 [SEP]

get_special_tokens_mask

<来源>

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — ID 列表。
• token_ids_1 (List[int], optional) — 序列对的可选第二个 ID 列表。
• already_has_special_tokens (bool, optional, defaults to False) — 是否已经为模型格式化了特殊标记的标记列表。

返回

List[int]

一个整数列表，范围为[0, 1]：特殊标记为 1，序列标记为 0。

从没有添加特殊标记的标记列表中检索序列 ID。当使用分词器的prepare_for_model方法添加特殊标记时，将调用此方法。

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — 第一个标记化序列。
• token_ids_1 (List[int], optional) — 第二个标记化序列。

返回

List[int]

标记类型 ID。

创建与传递的序列对应的标记类型 ID。什么是标记类型 ID？

如果模型有特殊的构建方式，则应在子类中重写。

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

SplinterTokenizerFast

class transformers.SplinterTokenizerFast

<来源>

( vocab_file = None tokenizer_file = None do_lower_case = True unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' question_token = '[QUESTION]' tokenize_chinese_chars = True strip_accents = None **kwargs )

参数

• vocab_file (str) — 包含词汇表的文件。
• do_lower_case (bool, optional, defaults to True) — 在分词时是否将输入转换为小写。
• unk_token (str, optional, defaults to "[UNK]") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。
• sep_token (str, optional, defaults to "[SEP]") — 分隔符标记，在从多个序列构建序列时使用，例如，用于序列分类的两个序列或用于问题回答的文本和问题。它也被用作使用特殊标记构建的序列的最后一个标记。
• pad_token (str, optional, defaults to "[PAD]") — 用于填充的标记，例如在批处理不同长度的序列时使用。
• cls_token (str, optional, defaults to "[CLS]") — 分类器标记，在进行序列分类（对整个序列而不是每个标记进行分类）时使用。当使用特殊标记构建序列时，它是序列的第一个标记。
• mask_token (str, optional, defaults to "[MASK]") — 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
• question_token (str, optional, defaults to "[QUESTION]") — 用于构建问题表示的标记。
• clean_text (bool, optional, defaults to True) — 是否在分词之前清理文本，通过删除任何控制字符并将所有空格替换为经典空格。
• tokenize_chinese_chars (bool, optional, defaults to True) — 是否对中文字符进行分词。这可能应该在日语中停用（参见此问题）。
• strip_accents (bool, optional) — 是否去除所有重音符号。如果未指定此选项，则将由lowercase的值确定（与原始 BERT 相同）。
• wordpieces_prefix (str, optional, defaults to "##") — 子词的前缀。

构建一个“快速”Splinter 分词器（由 HuggingFace 的tokenizers库支持）。基于 WordPiece。

这个分词器继承自 PreTrainedTokenizerFast，其中包含大部分主要方法。用户应该参考这个超类以获取有关这些方法的更多信息。

build_inputs_with_special_tokens

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — 如果 pad_on_right，则为问题标记 ID，否则为上下文标记 ID
• token_ids_1 (List[int], optional) — 如果 pad_on_right，则为上下文标记 ID，否则为问题标记 ID

返回

List[int]

具有适当特殊标记的 input IDs 列表。

通过连接和添加特殊标记，从一对序列构建问题回答任务的模型输入。Splinter 序列的格式如下：

• 单个序列：[CLS] X [SEP]
• 问题回答的序列对：[CLS] question_tokens [QUESTION] . [SEP] context_tokens [SEP]

SplinterModel

class transformers.SplinterModel

<来源>

( config )

参数

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

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

该模型是一个编码器（仅具有自注意力），遵循Ashish Vaswani、Noam Shazeer、Niki Parmar、Jakob Uszkoreit、Llion Jones、Aidan N. Gomez、Lukasz Kaiser 和 Illia Polosukhin描述的架构。

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 encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 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（形状为(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 而不是普通元组。
• encoder_hidden_states（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。
• encoder_attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用此掩码。掩码值选在 [0, 1] 之间：
  • 对于未被 masked 的标记为 1。
  • 对于被 masked 的标记为 0。
• past_key_values (tuple(tuple(torch.FloatTensor))，长度为 config.n_layers，每个元组包含 4 个形状为 (batch_size, num_heads, sequence_length - 1, embed_size_per_head) 的张量） — 包含注意力块的预计算的键和值隐藏状态。可用于加速解码。如果使用了 past_key_values，用户可以选择只输入最后的 decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的）的形状为 (batch_size, 1)，而不是形状为 (batch_size, sequence_length) 的所有 decoder_input_ids。
• use_cache (bool，optional) — 如果设置为 True，则返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。

返回

transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 或 torch.FloatTensor 元组

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

• last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列的输出。 如果使用了 past_key_values，则输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。
• past_key_values (tuple(tuple(torch.FloatTensor))，optional，当传递 use_cache=True 或 config.use_cache=True 时返回） — 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量，如果 config.is_encoder_decoder=True 还有 2 个额外的形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的张量。 包含预计算的隐藏状态（自注意力块中的键和值以及在交叉注意力块中可选地如果 config.is_encoder_decoder=True）可以使用（参见 past_key_values 输入）加速顺序解码。
• hidden_states (tuple(torch.FloatTensor)，optional，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回） — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（如果模型有嵌入层的输出，则为一个 + 每层的输出一个）。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
• attentions (tuple(torch.FloatTensor)，optional，当传递 output_attentions=True 或 config.output_attentions=True 时返回） — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
• cross_attentions (tuple(torch.FloatTensor)，optional，当传递 output_attentions=True 和 config.add_cross_attention=True 或 config.output_attentions=True 时返回） — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每层一个）。 解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, SplinterModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("tau/splinter-base")
>>> model = SplinterModel.from_pretrained("tau/splinter-base")

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

>>> last_hidden_states = outputs.last_hidden_state

SplinterForQuestionAnswering

class transformers.SplinterForQuestionAnswering

<来源>

( config )

参数

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

Splinter 模型在顶部具有一个跨度分类头，用于提取式问答任务，如 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 question_positions: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.QuestionAnsweringModelOutput 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 表示未被遮罩的标记，
  • 0 表示被遮罩的标记。

  注意力掩码是什么？

• 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 表示头部未被遮罩，
  • 0 表示头部被遮罩。
• inputs_embeds（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）— 可选地，可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为关联向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。
• start_positions (torch.LongTensor of shape (batch_size,), optional) — 用于计算标记范围的开始位置（索引）的标签，以计算标记分类损失。位置被夹紧到序列的长度(sequence_length)。超出序列范围的位置不会被考虑在内计算损失。
• end_positions (torch.LongTensor of shape (batch_size,), optional) — 用于计算标记分类损失的标签位置（索引）的标签。位置被夹紧到序列的长度(sequence_length)。超出序列范围的位置不会被考虑在内计算损失。
• question_positions (torch.LongTensor of shape (batch_size, num_questions), optional) — 所有问题标记的位置。如果给定，start_logits和end_logits的形状将为(batch_size, num_questions, sequence_length)。如果为 None，则批处理中每个序列中的第一个问题标记将是唯一一个计算start_logits和end_logits的标记，它们的形状将为(batch_size, sequence_length)。

返回

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

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

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 总跨度提取损失是开始和结束位置的交叉熵之和。
• start_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 跨度开始分数（SoftMax 之前）。
• end_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 跨度结束分数（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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, SplinterForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("tau/splinter-base")
>>> model = SplinterForQuestionAnswering.from_pretrained("tau/splinter-base")

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

SplinterForPreTraining

class transformers.SplinterForPreTraining

<来源>

( config )

参数

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

Splinter 模型用于在预训练期间执行重复跨度选择任务。与 QA 任务的不同之处在于我们没有问题，而是有多个问题标记，这些标记替换了重复跨度的出现。

这个模型是 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 question_positions: Optional = None )

参数

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

  什么是注意力掩码？

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

  什么是标记类型 ID？

• position_ids（形状为batch_size, num_questions, 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_questions, 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（形状为(batch_size, num_questions)的torch.LongTensor，可选）— 用于计算标记跨度的起始位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内以计算损失。
• end_positions（形状为(batch_size, num_questions)的torch.LongTensor，可选）— 用于计算标记跨度的结束位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内以计算损失。
• question_positions（形状为(batch_size, num_questions)的torch.LongTensor，可选）— 所有问题标记的位置。如果给定，start_logits 和 end_logits 将具有形状(batch_size, num_questions, sequence_length)。如果为 None，则批处理中每个序列中的第一个问题标记将是唯一一个计算 start_logits 和 end_logits 的标记，并且它们将具有形状(batch_size, sequence_length)。

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

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

SqueezeBERT

huggingface.co/docs/transformers/v4.37.2/en/model_doc/squeezebert

概述

SqueezeBERT 模型是由 Forrest N. Iandola、Albert E. Shaw、Ravi Krishna、Kurt W. Keutzer 在SqueezeBERT: What can computer vision teach NLP about efficient neural networks?中提出的。它是一个类似于 BERT 模型的双向 transformer。BERT 架构和 SqueezeBERT 架构之间的关键区别在于 SqueezeBERT 使用分组卷积而不是全连接层用于 Q、K、V 和 FFN 层。

该论文的摘要如下：

人类每天阅读和撰写数百亿条消息。此外，由于大型数据集、大型计算系统和更好的神经网络模型的可用性，自然语言处理（NLP）技术在理解、校对和组织这些消息方面取得了重大进展。因此，在许多应用中部署 NLP 技术以帮助网络用户、社交网络和企业存在重大机会。特别是，我们认为智能手机和其他移动设备是大规模部署 NLP 模型的关键平台。然而，如今的高度准确的 NLP 神经网络模型，如 BERT 和 RoBERTa，计算成本极高，BERT-base 在 Pixel 3 智能手机上对文本片段进行分类需要 1.7 秒。在这项工作中，我们观察到诸如分组卷积等方法已经显著加快了计算机视觉网络的速度，但是许多这些技术尚未被 NLP 神经网络设计者采用。我们演示了如何用分组卷积替换自注意力层中的几个操作，并将这种技术应用于一种名为 SqueezeBERT 的新型网络架构，该架构在 Pixel 3 上比 BERT-base 运行速度快 4.3 倍，同时在 GLUE 测试集上实现了竞争性的准确性。SqueezeBERT 代码将发布。

此模型由forresti贡献。

使用提示

• SqueezeBERT 是一个具有绝对位置嵌入的模型，因此通常建议在右侧而不是左侧填充输入。
• SqueezeBERT 类似于 BERT，因此依赖于掩码语言建模（MLM）目标。因此，它在预测掩码标记和自然语言理解方面效率高，但不适用于文本生成。使用因果语言建模（CLM）目标训练的模型在这方面更好。
• 在进行序列分类任务的微调时，建议从squeezebert/squeezebert-mnli-headless检查点开始以获得最佳结果。

资源

• 文本分类任务指南
• 标记分类任务指南
• 问答任务指南
• 掩码语言建模任务指南
• 多项选择任务指南

SqueezeBertConfig

class transformers.SqueezeBertConfig

<来源>

( vocab_size = 30522 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 = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 embedding_size = 768 q_groups = 4 k_groups = 4 v_groups = 4 post_attention_groups = 1 intermediate_groups = 4 output_groups = 4 **kwargs )

参数

• vocab_size（int，可选，默认为 30522）— SqueezeBERT 模型的词汇量。定义了在调用 SqueezeBertModel 时可以表示的不同标记数量。
• hidden_size（int，可选，默认为 768）— 编码器层和池化器层的维度。
• num_hidden_layers（int，可选，默认为 12）— Transformer 编码器中的隐藏层数量。
• num_attention_heads（int，可选，默认为 12）— Transformer 编码器中每个注意力层的注意力头数量。
• intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（通常称为前馈）层的维度。
• hidden_act (str or Callable, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。
• hidden_dropout_prob (float, optional, defaults to 0.1) — 嵌入、编码器和池化器中所有全连接层的丢弃概率。
• attention_probs_dropout_prob (float, optional, defaults to 0.1) — 注意力概率的丢弃比例。
• max_position_embeddings (int, optional, defaults to 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512 或 1024 或 2048）。
• type_vocab_size (int, optional, defaults to 2) — 在调用 BertModel 或 TFBertModel 时传递的token_type_ids的词汇表大小。
• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps (float, optional, defaults to 1e-12) —
• pad_token_id (int, optional, defaults to 0) — 用作填充的词嵌入中的标记 ID。
• embedding_size (int, optional, defaults to 768) — 词嵌入向量的维度。
• q_groups (int, optional, defaults to 4) — Q 层中的组数。
• k_groups (int, optional, defaults to 4) — K 层中的组数。
• v_groups (int, optional, defaults to 4) — V 层中的组数。
• post_attention_groups (int, optional, defaults to 1) — 第一个前馈网络层中的组数。
• intermediate_groups (int, optional, defaults to 4) — 第二个前馈网络层中的组数。
• output_groups (int, optional, defaults to 4) — 第三个前馈网络层中的组数。

这是用于存储 SqueezeBertModel 配置的配置类。它用于根据指定的参数实例化一个 SqueezeBERT 模型，定义模型架构。使用默认值实例化配置将产生类似于 SqueezeBERT squeezebert/squeezebert-uncased 架构的配置。

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

示例：

>>> from transformers import SqueezeBertConfig, SqueezeBertModel

>>> # Initializing a SqueezeBERT configuration
>>> configuration = SqueezeBertConfig()

>>> # Initializing a model (with random weights) from the configuration above
>>> model = SqueezeBertModel(configuration)

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

属性：pretrained_config_archive_map（Dict[str, str]）：包含所有可用预训练检查点的字典。

SqueezeBertTokenizer

class transformers.SqueezeBertTokenizer

< source >

( vocab_file do_lower_case = True do_basic_tokenize = True never_split = None unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' tokenize_chinese_chars = True strip_accents = None **kwargs )

参数

• vocab_file (str) — 包含词汇表的文件。
• do_lower_case (bool, optional, defaults to True) — 是否在标记化时将输入转换为小写。
• do_basic_tokenize (bool, optional, defaults to True) — 是否在 WordPiece 之前进行基本的分词处理。
• never_split (Iterable, optional) — 在标记化过程中永远不会拆分的标记集合。仅在do_basic_tokenize=True时有效。
• unk_token (str, optional, defaults to "[UNK]") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。
• sep_token (str, optional, defaults to "[SEP]") — 分隔符标记，在从多个序列构建序列时使用，例如，用于序列分类的两个序列或用于问答的文本和问题。它还用作使用特殊标记构建的序列的最后一个标记。
• pad_token (str, optional, defaults to "[PAD]") — 用于填充的标记，例如在批处理不同长度的序列时使用。
• cls_token (str, optional, defaults to "[CLS]") — 分类器标记，用于进行序列分类（对整个序列进行分类，而不是每个标记进行分类）。在使用特殊标记构建时，它是序列的第一个标记。
• mask_token (str, optional, defaults to "[MASK]") — 用于屏蔽值的标记。在使用遮罩语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
• tokenize_chinese_chars (bool, optional, defaults to True) — 是否对中文字符进行标记化。 这可能应该在日语中停用（请参阅此问题）。
• strip_accents (bool, optional) — 是否去除所有重音符号。如果未指定此选项，则将由lowercase的值确定（与原始 SqueezeBERT 相同）。

构建一个 SqueezeBERT 分词器。基于 WordPiece。

此分词器继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

build_inputs_with_special_tokens

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表。
• token_ids_1 (List[int], optional) — 序列对的可选第二个 ID 列表。

返回

List[int]

带有适当特殊标记的输入 ID 列表。

通过连接和添加特殊标记构建用于序列分类任务的序列或序列对的模型输入。SqueezeBERT 序列的格式如下：

• 单个序列：[CLS] X [SEP]
• 序列对：[CLS] A [SEP] B [SEP]

get_special_tokens_mask

<来源>

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — ID 列表。
• token_ids_1 (List[int], optional) — 序列对的可选第二个 ID 列表。
• already_has_special_tokens (bool, optional, defaults to False) — 标记列表是否已经使用特殊标记格式化为模型。

返回

List[int]

一个整数列表，范围为[0, 1]：1 表示特殊标记，0 表示序列标记。

从没有添加特殊标记的标记列表中检索序列 ID。在使用分词器prepare_for_model方法添加特殊标记时调用此方法。

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — ID 列表。
• token_ids_1 (List[int], optional) — 序列对的可选第二个 ID 列表。

返回

List[int]

根据给定序列的标记类型 ID 列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。一个 SqueezeBERT 序列

对掩码的格式如下：

0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果 token_ids_1 是 None，则此方法仅返回掩码的第一部分（0s）。

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

SqueezeBertTokenizerFast

class transformers.SqueezeBertTokenizerFast

<来源>

( vocab_file = None tokenizer_file = None do_lower_case = True unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' tokenize_chinese_chars = True strip_accents = None **kwargs )

参数

• vocab_file (str) — 包含词汇表的文件。
• do_lower_case (bool, optional, 默认为 True) — 在分词时是否将输入转换为小写。
• unk_token (str, optional, 默认为 "[UNK]") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。
• sep_token (str, optional, 默认为 "[SEP]") — 分隔符标记，在构建来自多个序列的序列时使用，例如用于序列分类的两个序列或用于文本和问题的问题回答。它还用作使用特殊标记构建的序列的最后一个标记。
• pad_token (str, optional, 默认为 "[PAD]") — 用于填充的标记，例如在批处理不同长度的序列时使用。
• cls_token (str, optional, 默认为 "[CLS]") — 分类器标记，用于进行序列分类（对整个序列进行分类而不是对每个标记进行分类）。当使用特殊标记构建序列时，它是序列的第一个标记。
• mask_token (str, optional, 默认为 "[MASK]") — 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
• clean_text (bool, optional, 默认为 True) — 在分词之前是否清理文本，通过删除任何控制字符并将所有空格替换为经典空格。
• tokenize_chinese_chars (bool, optional, 默认为 True) — 是否对中文字符进行分词。这可能应该在日语中停用（参见此问题）。
• strip_accents (bool, optional) — 是否去除所有重音符号。如果未指定此选项，则将由 lowercase 的值确定（与原始 SqueezeBERT 相同）。
• wordpieces_prefix (str, optional, 默认为 "##") — 子词的前缀。

构建一个“快速”SqueezeBERT 分词器（由 HuggingFace 的 tokenizers 库支持）。基于 WordPiece。

此分词器继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

build_inputs_with_special_tokens

<来源>

( token_ids_0 token_ids_1 = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表。
• token_ids_1 (List[int], optional) — 可选的第二个 ID 列表，用于序列对。

返回

List[int]

具有适当特殊标记的输入 ID 列表。

通过连接和添加特殊标记从序列或序列对构建用于序列分类任务的模型输入。SqueezeBERT 序列具有以下格式：

• 单个序列：[CLS] X [SEP]
• 序列对：[CLS] A [SEP] B [SEP]

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — ID 列表。
• token_ids_1 (List[int], optional) — 可选的第二个 ID 列表，用于序列对。

返回

List[int]

根据给定序列的标记类型 ID 列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。一个 SqueezeBERT 序列

对对掩码具有以下格式：

0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果token_ids_1为None，则此方法仅返回掩码的第一部分（0）。

SqueezeBertModel

class transformers.SqueezeBertModel

<来源>

( config )

参数

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

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

SqueezeBERT 模型是由 Forrest N. Iandola，Albert E. Shaw，Ravi Krishna 和 Kurt W. Keutzer 在SqueezeBERT: 计算机视觉能教自然语言处理什么关于高效神经网络？中提出的

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

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

为了在文本分类任务上进行 SqueezeBERT 微调获得最佳结果，建议使用squeezebert/squeezebert-mnli-headless检查点作为起点。

层次结构：

Internal class hierarchy:
SqueezeBertModel
    SqueezeBertEncoder
        SqueezeBertModule
        SqueezeBertSelfAttention
            ConvActivation
            ConvDropoutLayerNorm

数据布局：

Input data is in [batch, sequence_length, hidden_size] format.

Data inside the encoder is in [batch, hidden_size, sequence_length] format. But, if `output_hidden_states == True`, the data from inside the encoder is returned in [batch, sequence_length, hidden_size] format.

The final output of the encoder is in [batch, sequence_length, hidden_size] format.

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 output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPooling 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 表示未被屏蔽的标记，
  • 0 表示被屏蔽的标记。

  什么是注意力掩码？

• 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 表示头部未被屏蔽，
  • 0 表示头部是masked。
• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将很有用。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

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

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

• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列输出。
• pooler_output (torch.FloatTensor，形状为(batch_size, hidden_size)) — 经过用于辅助预训练任务的层进一步处理后的序列的第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 系列模型，这将返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。
• 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, SqueezeBertModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("squeezebert/squeezebert-uncased")
>>> model = SqueezeBertModel.from_pretrained("squeezebert/squeezebert-uncased")

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

>>> last_hidden_states = outputs.last_hidden_state

SqueezeBertForMaskedLM

class transformers.SqueezeBertForMaskedLM

< source >

( config )

参数

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

在顶部带有语言建模头的 SqueezeBERT 模型。

SqueezeBERT 模型是由 Forrest N. Iandola、Albert E. Shaw、Ravi Krishna 和 Kurt W. Keutzer 在SqueezeBERT: What can computer vision teach NLP about efficient neural networks?中提出的。

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

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

为了在文本分类任务上对 SqueezeBERT 进行最佳微调，建议使用squeezebert/squeezebert-mnli-headless检查点作为起点。

层次结构：

Internal class hierarchy:
SqueezeBertModel
    SqueezeBertEncoder
        SqueezeBertModule
        SqueezeBertSelfAttention
            ConvActivation
            ConvDropoutLayerNorm

数据布局：

Input data is in [batch, sequence_length, hidden_size] format.

Data inside the encoder is in [batch, hidden_size, sequence_length] format. But, if `output_hidden_states == True`, the data from inside the encoder is returned in [batch, sequence_length, hidden_size] format.

The final output of the encoder is in [batch, sequence_length, hidden_size] format.

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()。 什么是输入 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（形状为(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 而不是普通元组。
• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 用于计算掩码语言建模损失的标签。索引应在[-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时）包含根据配置（SqueezeBertConfig）和输入的不同元素。

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）- 掩码语言建模（MLM）损失。
• logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）- 语言建模头的预测分数（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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例:

>>> from transformers import AutoTokenizer, SqueezeBertForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("squeezebert/squeezebert-uncased")
>>> model = SqueezeBertForMaskedLM.from_pretrained("squeezebert/squeezebert-uncased")

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

SqueezeBertForSequenceClassification

class transformers.SqueezeBertForSequenceClassification

<来源>

( config )

参数

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

在顶部具有序列分类/回归头的 SqueezeBERT 模型变压器（池化输出顶部的线性层），例如用于 GLUE 任务。

SqueezeBERT 模型由 Forrest N. Iandola、Albert E. Shaw、Ravi Krishna 和 Kurt W. Keutzer 在SqueezeBERT: What can computer vision teach NLP about efficient neural networks?中提出

此模型继承自 PreTrainedModel。检查超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

为了在文本分类任务上对 SqueezeBERT 进行最佳微调，建议使用squeezebert/squeezebert-mnli-headless检查点作为起点。

层次结构：

Internal class hierarchy:
SqueezeBertModel
    SqueezeBertEncoder
        SqueezeBertModule
        SqueezeBertSelfAttention
            ConvActivation
            ConvDropoutLayerNorm

数据布局：

Input data is in [batch, sequence_length, hidden_size] format.

Data inside the encoder is in [batch, hidden_size, sequence_length] format. But, if `output_hidden_states == True`, the data from inside the encoder is returned in [batch, sequence_length, hidden_size] format.

The final output of the encoder is in [batch, sequence_length, hidden_size] format.

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（形状为(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（形状为(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 而不是一个普通的元组。
• 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时）包含各种元素，取决于配置（SqueezeBertConfig）和输入。

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

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

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

单标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, SqueezeBertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("squeezebert/squeezebert-uncased")
>>> model = SqueezeBertForSequenceClassification.from_pretrained("squeezebert/squeezebert-uncased")

>>> 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 = SqueezeBertForSequenceClassification.from_pretrained("squeezebert/squeezebert-uncased", num_labels=num_labels)

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

多标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, SqueezeBertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("squeezebert/squeezebert-uncased")
>>> model = SqueezeBertForSequenceClassification.from_pretrained("squeezebert/squeezebert-uncased", 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 = SqueezeBertForSequenceClassification.from_pretrained(
...     "squeezebert/squeezebert-uncased", 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

SqueezeBertForMultipleChoice

class transformers.SqueezeBertForMultipleChoice

<来源>

( config )

参数

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

SqueezeBERT 模型，顶部带有多选分类头（池化输出顶部的线性层和 Softmax），例如用于 RocStories/SWAG 任务。

SqueezeBERT 模型是由 Forrest N. Iandola，Albert E. Shaw，Ravi Krishna 和 Kurt W. Keutzer 在SqueezeBERT: What can computer vision teach NLP about efficient neural networks?中提出的。

这个模型继承自 PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

为了在文本分类任务上进行 SqueezeBERT 微调获得最佳结果，建议使用squeezebert/squeezebert-mnli-headless检查点作为起点。

层次结构：

Internal class hierarchy:
SqueezeBertModel
    SqueezeBertEncoder
        SqueezeBertModule
        SqueezeBertSelfAttention
            ConvActivation
            ConvDropoutLayerNorm

数据布局：

Input data is in [batch, sequence_length, hidden_size] format.

Data inside the encoder is in [batch, hidden_size, sequence_length] format. But, if `output_hidden_states == True`, the data from inside the encoder is returned in [batch, sequence_length, hidden_size] format.

The final output of the encoder is in [batch, sequence_length, hidden_size] format.

前向

<来源>

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

  什么是注意力掩码？

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

  什么是标记类型 ID？

• position_ids (torch.LongTensor，形状为(batch_size, num_choices, 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, num_choices, 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,)，可选) — 用于计算多项选择分类损失的标签。索引应在[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）包含各种元素，具体取决于配置（SqueezeBertConfig）和输入。

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

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

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

示例：

>>> from transformers import AutoTokenizer, SqueezeBertForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("squeezebert/squeezebert-uncased")
>>> model = SqueezeBertForMultipleChoice.from_pretrained("squeezebert/squeezebert-uncased")

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

SqueezeBertForTokenClassification

class transformers.SqueezeBertForTokenClassification

<来源>

( config )

参数

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

在顶部带有标记分类头（隐藏状态输出顶部的线性层）的 SqueezeBERT 模型，例如用于命名实体识别（NER）任务。

SqueezeBERT 模型是由 Forrest N. Iandola、Albert E. Shaw、Ravi Krishna 和 Kurt W. Keutzer 在SqueezeBERT: What can computer vision teach NLP about efficient neural networks?中提出的。

这个模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（例如下载或保存，调整输入嵌入大小，修剪头等）。

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

为了在文本分类任务上进行最佳微调 SqueezeBERT，建议使用squeezebert/squeezebert-mnli-headless检查点作为起点。

层次结构：

Internal class hierarchy:
SqueezeBertModel
    SqueezeBertEncoder
        SqueezeBertModule
        SqueezeBertSelfAttention
            ConvActivation
            ConvDropoutLayerNorm

数据布局：

Input data is in [batch, sequence_length, hidden_size] format.

Data inside the encoder is in [batch, hidden_size, sequence_length] format. But, if `output_hidden_states == True`, the data from inside the encoder is returned in [batch, sequence_length, hidden_size] format.

The final output of the encoder is in [batch, sequence_length, hidden_size] format.

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（形状为(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 而不是普通元组。
• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于计算标记分类损失的标签。索引应在[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时）包含根据配置（SqueezeBertConfig）和输入的各种元素。

• loss（形状为(1,)的torch.FloatTensor，可选，在提供labels时返回）— 分类损失。
• logits（形状为(batch_size, sequence_length, config.num_labels)的torch.FloatTensor）— 分类得分（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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, SqueezeBertForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("squeezebert/squeezebert-uncased")
>>> model = SqueezeBertForTokenClassification.from_pretrained("squeezebert/squeezebert-uncased")

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

SqueezeBertForQuestionAnswering

class transformers.SqueezeBertForQuestionAnswering

<来源>

( config )

参数

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

SqueezeBERT 模型在顶部带有一个跨度分类头，用于提取式问答任务，如 SQuAD（在隐藏状态输出的顶部有线性层，用于计算span start logits和span end logits）。

SqueezeBERT 模型是由 Forrest N. Iandola、Albert E. Shaw、Ravi Krishna 和 Kurt W. Keutzer 在SqueezeBERT: What can computer vision teach NLP about efficient neural networks?中提出的。

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

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

为了在文本分类任务上对 SqueezeBERT 进行最佳微调，建议使用squeezebert/squeezebert-mnli-headless检查点作为起点。

层次结构：

Internal class hierarchy:
SqueezeBertModel
    SqueezeBertEncoder
        SqueezeBertModule
        SqueezeBertSelfAttention
            ConvActivation
            ConvDropoutLayerNorm

数据布局：

Input data is in [batch, sequence_length, hidden_size] format.

Data inside the encoder is in [batch, hidden_size, sequence_length] format. But, if `output_hidden_states == True`, the data from inside the encoder is returned in [batch, sequence_length, hidden_size] format.

The final output of the encoder is in [batch, sequence_length, hidden_size] format.

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 (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：
  • 1 表示未被掩盖的标记，
  • 0 表示被掩盖的标记。

  什么是注意力掩码？

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

  什么是标记类型 ID？

• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[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 而不是普通元组。
• start_positions (torch.LongTensor of shape (batch_size,), optional) — 用于计算标记分类损失的标记跨度开始位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。超出序列范围的位置不会被考虑在内以计算损失。
• end_positions (torch.LongTensor of shape (batch_size,), optional) — 用于计算标记分类损失的标记跨度结束位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。超出序列范围的位置不会被考虑在内以计算损失。

返回

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

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

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 总跨度提取损失是起始和结束位置的交叉熵之和。
• start_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 跨度开始分数（SoftMax 之前）。
• end_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 跨度结束分数（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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, SqueezeBertForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("squeezebert/squeezebert-uncased")
>>> model = SqueezeBertForQuestionAnswering.from_pretrained("squeezebert/squeezebert-uncased")

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