Transformers 4.37 中文文档（五十四）（4）

Transformers 4.37 中文文档（五十四）（3）https://developer.aliyun.com/article/1565375

ReformerForSequenceClassification

class transformers.ReformerForSequenceClassification

<来源>

( config )

参数

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

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

Reformer 是由 Nikita Kitaev、Łukasz Kaiser、Anselm Levskaya 在 Reformer: The Efficient Transformer 中提出的。

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

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

forward

< source >

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

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。在训练期间，input_ids 序列长度必须是相关模型的块长度（lsh’s、local’s 或两者）的倍数。在评估期间，索引会自动填充为块长度的倍数。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1]：

• 1 代表未被遮蔽的标记，
  
• 0 代表被遮蔽的标记。
  

• 什么是注意力掩码？
  
• 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 索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
  
• num_hashes (int, optional) — 在分桶期间应执行的哈希轮数。设置此参数会覆盖 config.num_hashes 中定义的默认值。
  有关更多信息，请参见 ReformerConfig 中的 num_hashes。
  
• past_buckets_states (List[Tuple(torch.LongTensor, torch.FloatTensor)], optional) — 长度为 config.n_layers 的 Tuple(torch.LongTensor, torch.FloatTensor 列表，第一个元素是形状为 (batch_size, num_heads, num_hashes, sequence_length) 的先前 buckets，第二个元素是形状为 (batch_size, sequence_length, hidden_size) 的先前 hidden_states)。
  包含预先计算的隐藏状态和桶（仅与 LSH 自注意力相关）。可用于加速顺序解码。
  
• use_cache (bool, optional) — 如果设置为 True，则返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
  
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的 attentions。
  
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的 hidden_states。
  
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。
  
• labels (torch.LongTensor of shape (batch_size,), 可选) — 用于计算序列分类/回归损失的标签。索引应在[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时），包括根据配置（ReformerConfig）和输入不同元素。

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

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

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

单标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, ReformerForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("google/reformer-crime-and-punishment")
>>> model = ReformerForSequenceClassification.from_pretrained("google/reformer-crime-and-punishment")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> label = model.config.id2label[predicted_class_id]

>>> # 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 = ReformerForSequenceClassification.from_pretrained(
...     "google/reformer-crime-and-punishment", num_labels=num_labels
... )
>>> labels = torch.tensor(1)
>>> loss = model(**inputs, labels=labels).loss

ReformerForQuestionAnswering

class transformers.ReformerForQuestionAnswering

<来源>

( config )

参数

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

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

Reformer 是由 Nikita Kitaev、Łukasz Kaiser、Anselm Levskaya 在Reformer: The Efficient Transformer中提出的。

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

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

forward

<来源>

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

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。在训练期间，input_ids 序列长度必须是相关模型块长度（lsh’s、local’s 或两者的倍数）。在评估期间，这些索引会自动填充为块长度的倍数。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

• 1 表示未被掩码的标记，
  
• 0 表示被掩码的标记。
  

• 什么是注意力掩码？
  
• 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索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。
  
• num_hashes (int, optional) — 在分桶期间应执行的哈希轮数。设置此参数会覆盖config.num_hashes中定义的默认值。
  有关更多信息，请参阅 ReformerConfig 中的num_hashes。
  
• past_buckets_states (List[Tuple(torch.LongTensor, torch.FloatTensor)], optional) — 长度为config.n_layers的Tuple(torch.LongTensor, torch.FloatTensor列表，第一个元素是先前的桶的形状(batch_size, num_heads, num_hashes, sequence_length)，第二个元素是先前的隐藏状态的形状(batch_size, sequence_length, hidden_size)。
  包含预先计算的隐藏状态和桶（仅与 LSH 自注意力相关）。可用于加速顺序解码。
  
• use_cache (bool, optional) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
  
• 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时）包含各种元素，取决于配置（ReformerConfig）和输入。

• 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时返回) — 形状为(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 之后的注意力权重，用于计算自注意力头中的加权平均值。
  

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

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

示例：

>>> from transformers import AutoTokenizer, ReformerForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("google/reformer-crime-and-punishment")
>>> model = ReformerForQuestionAnswering.from_pretrained("google/reformer-crime-and-punishment")
>>> 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

RemBERT

原文链接: huggingface.co/docs/transformers/v4.37.2/en/model_doc/rembert

概述

RemBERT 模型是由 Hyung Won Chung、Thibault Févry、Henry Tsai、Melvin Johnson、Sebastian Ruder 在 重新思考预训练语言模型中的嵌入耦合 中提出的。

论文摘要如下:

我们重新评估了在最先进的预训练语言模型中共享输入和输出嵌入权重的标准做法。我们表明，解耦的嵌入提供了增加的建模灵活性，使我们能够显著改善多语言模型输入嵌入的参数分配效率。通过在  Transformer  层中重新分配输入嵌入参数，我们在微调期间使用相同数量的参数实现了标准自然语言理解任务的显著性能提升。我们还表明，为输出嵌入分配额外容量对模型有益，即使在预训练后丢弃输出嵌入后，这些好处仍然持续存在于微调阶段。我们的分析表明，更大的输出嵌入可以防止模型的最后几层过度专门化于预训练任务，并鼓励  Transformer 表示更加通用和更易于迁移到其他任务和语言。利用这些发现，我们能够训练出在 XTREME  基准测试上表现出色的模型，而不增加微调阶段的参数数量。

使用提示

对于微调，RemBERT 可以被视为 mBERT 的一个更大版本，具有类似 ALBERT 的嵌入层因式分解。与 BERT  不同，这些嵌入在预训练中没有绑定，这使得输入嵌入更小（在微调期间保留）和输出嵌入更大（在微调时丢弃）。分词器也类似于 Albert 而不是  BERT。

资源

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

RemBertConfig

class transformers.RemBertConfig

< 源代码 >

( vocab_size = 250300 hidden_size = 1152 num_hidden_layers = 32 num_attention_heads = 18 input_embedding_size = 256 output_embedding_size = 1664 intermediate_size = 4608 hidden_act = 'gelu' hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 classifier_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 bos_token_id = 312 eos_token_id = 313 **kwargs )

参数

• vocab_size (int, 可选, 默认为 250300) — RemBERT 模型的词汇量。定义了在调用 RemBertModel 或 TFRemBertModel 时可以由 inputs_ids 表示的不同标记数量。模型的词汇量。定义了可以由传递给 RemBertModel 的 inputs_ids 表示的不同标记。
  
• hidden_size (int, 可选, 默认为 1152) — 编码器层和池化层的维度。
  
• num_hidden_layers (int, 可选, 默认为 32) — Transformer 编码器中的隐藏层数。
  
• num_attention_heads (int, 可选, 默认为 18) — Transformer 编码器中每个注意力层的注意力头数。
  
• input_embedding_size (int, 可选, 默认为 256) — 输入嵌入的维度。
  
• output_embedding_size (int, 可选, 默认为 1664) — 输出嵌入的维度。
  
• intermediate_size (int, 可选, 默认为 4608) — Transformer 编码器中“中间”（即前馈）层的维度。
  
• hidden_act (str 或 function, optional, 默认为 "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu"、"relu"、"selu" 和 "gelu_new"。
  
• hidden_dropout_prob (float, optional, 默认为 0) — 嵌入层、编码器和池化器中所有全连接层的丢失概率。
  
• attention_probs_dropout_prob (float, optional, 默认为 0) — 注意力概率的丢失比率。
  
• classifier_dropout_prob (float, optional, 默认为 0.1) — 在微调时分类器层的丢失比率。
  
• max_position_embeddings (int, optional, 默认为 512) — 该模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512、1024 或 2048）。
  
• type_vocab_size (int, optional, 默认为 2) — 在调用 RemBertModel 或 TFRemBertModel 时传递的 token_type_ids 的词汇表大小。
  
• initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  
• layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。
  
• is_decoder (bool, optional, 默认为 False) — 模型是否用作解码器。如果为 False，则模型用作编码器。
  
• use_cache (bool, optional, 默认为 True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在 config.is_decoder=True 时相关。
  

这是用于存储 RemBertModel 配置的配置类。它用于根据指定的参数实例化 RemBERT 模型，定义模型架构。使用默认值实例化配置将产生类似于 RemBERT google/rembert 架构的配置。

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

示例：

>>> from transformers import RemBertModel, RemBertConfig
>>> # Initializing a RemBERT rembert style configuration
>>> configuration = RemBertConfig()
>>> # Initializing a model from the rembert style configuration
>>> model = RemBertModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

RemBertTokenizer

class transformers.RemBertTokenizer

< source >

( vocab_file do_lower_case = False remove_space = True keep_accents = True bos_token = '[CLS]' eos_token = '[SEP]' unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' **kwargs )

参数

• vocab_file (str) — SentencePiece 文件（通常具有 .spm 扩展名），其中包含实例化分词器所需的词汇表。
  
• bos_token (str, optional, 默认为 "[CLS]") — 在预训练期间使用的序列开头标记。可用作序列分类器标记。
  在使用特殊标记构建序列时，这不是用于序列开头的标记。使用的标记是 cls_token。
  
• eos_token (str, optional, 默认为 "[SEP]") — 序列结束标记。
  在使用特殊标记构建序列时，这不是用于序列结尾的标记。使用的标记是 sep_token。
  
• unk_token (str, optional, 默认为 "") — 未知标记。词汇表中不存在的标记无法转换为 ID，并将设置为此标记。
  
• sep_token (str, optional, 默认为 "[SEP]") — 分隔符标记，在从多个序列构建序列时使用，例如，用于序列分类的两个序列或用于问题回答的文本和问题。它还用作使用特殊标记构建的序列的最后一个标记。
  
• pad_token (str, optional, 默认为"") — 用于填充的标记，例如在批处理不同长度的序列时。
  
• cls_token (str, optional, 默认为"[CLS]") — 在进行序列分类（整个序列的分类而不是每个标记的分类）时使用的分类器标记。构建带有特殊标记的序列时，它是序列的第一个标记。
  
• mask_token (str, optional, 默认为"[MASK]") — 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
  
• sp_model (SentencePieceProcessor) — 用于每次转换（字符串、标记和 ID）的SentencePiece处理器。
  

构建一个 RemBERT 分词器。基于SentencePiece。

此分词器继承自 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 列表。

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

• 单个序列：[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, 默认为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 列表。

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

序列对掩码的格式如下：

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

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

RemBertTokenizerFast

class transformers.RemBertTokenizerFast

<来源>

( vocab_file = None tokenizer_file = None do_lower_case = True remove_space = True keep_accents = False bos_token = '[CLS]' eos_token = '[SEP]' unk_token = '<unk>' sep_token = '[SEP]' pad_token = '<pad>' cls_token = '[CLS]' mask_token = '[MASK]' **kwargs )

参数

• vocab_file (str) — SentencePiece 文件（通常具有*.spm*扩展名），其中包含实例化分词器所需的词汇表。
  
• do_lower_case (bool, optional, 默认为True) — 在标记化时是否将输入转换为小写。
  
• remove_space (bool, 可选, 默认为 True) — 在分词时是否去除文本（删除字符串前后的多余空格）。
  
• keep_accents (bool, 可选, 默认为 False) — 在分词时是否保留重音。
  
• bos_token (str, 可选, 默认为 "[CLS]") — 在预训练期间使用的序列开头标记。可以用作序列分类器标记。
  在构建使用特殊标记的序列时，这不是用于序列开头的标记。使用的标记是 cls_token。
  
• eos_token (str, 可选, 默认为 "[SEP]") — 序列结束标记。… 注意：在使用特殊标记构建序列时，这不是用于序列结尾的标记。使用的标记是 sep_token。
  
• unk_token (str, 可选, 默认为 "") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。
  
• sep_token (str, 可选, 默认为 "[SEP]") — 分隔符标记，在从多个序列构建序列时使用，例如，用于序列分类的两个序列或用于问题回答的文本和问题。它也被用作使用特殊标记构建的序列的最后一个标记。
  
• pad_token (str, 可选, 默认为 "") — 用于填充的标记，例如在批处理不同长度的序列时使用。
  
• cls_token (str, 可选, 默认为 "[CLS]") — 在进行序列分类（整个序列的分类而不是每个标记的分类）时使用的分类器标记。在使用特殊标记构建时，它是序列的第一个标记。
  
• mask_token (str, 可选, 默认为 "[MASK]") — 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
  

构建一个“快速”的 RemBert 分词器（由 HuggingFace 的 tokenizers 库支持）。基于 Unigram。这个分词器继承自 PreTrainedTokenizerFast，其中包含大部分主要方法。用户应该参考这个超类以获取有关这些方法的更多信息

build_inputs_with_special_tokens

< source >

( 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], 可选, 默认为 None) — 第二个序列对的 ID 列表。
  

返回

List[int]

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

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

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

get_special_tokens_mask

< source >

( 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], 可选, 默认为 None) — 第二个序列对的 ID 列表。
  
• already_has_special_tokens (bool, 可选, 默认为 False) — 如果 token 列表已经使用特殊标记格式化，则设置为 True
  

返回

List[int]

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

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

create_token_type_ids_from_sequences

< source >

( 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, 默认为 None) — 序列对的可选第二个 ID 列表。
  

返回

List[int]

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

从传递的两个序列创建一个掩码，用于在序列对分类任务中使用。一个 RemBERT

序列对掩码的格式如下：

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

< source >

( save_directory: str filename_prefix: Optional = None )

PytorchHide Pytorch 内容

Transformers 4.37 中文文档（五十四）（5）https://developer.aliyun.com/article/1565377