Transformers--4-37-中文文档-二十九-

Transformers 4.37 中文文档（二十九）

原文：huggingface.co/docs/transformers

RoCBert

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

概述

RoCBert 模型是由 HuiSu、WeiweiShi、XiaoyuShen、XiaoZhou、TuoJi、JiaruiFang、JieZhou 在 RoCBert: Robust Chinese Bert with Multimodal Contrastive Pretraining 中提出的。它是一个经过预训练的中文语言模型，在各种形式的对抗攻击下具有鲁棒性。

论文摘要如下：

大规模预训练语言模型在自然语言处理任务上取得了最先进的结果。然而，它们被证明对付形象文字语言（如中文）的对抗攻击特别脆弱。在这项工作中，我们提出了 ROCBERT：一个经过预训练的中文 Bert，对各种形式的对抗攻击（如单词扰动、同义词、错别字等）具有鲁棒性。它是通过对比学习目标进行预训练的，该目标在不同的合成对抗示例下最大化标签一致性。该模型接受包括语义、音素和视觉特征在内的多模态信息作为输入。我们展示了所有这些特征对模型的鲁棒性都很重要，因为攻击可以以这三种形式进行。在 5 个中文自然语言理解任务中，ROCBERT 在三种黑盒对抗算法下优于强基线，而不会牺牲对干净测试集的性能。在人为攻击下，它在有毒内容检测任务中表现最佳。

该模型由 weiweishi 贡献。

资源

• 文本分类任务指南

• 标记分类任务指南

• 问答任务指南

• 因果语言建模任务指南

• 掩码语言建模任务指南

• 多项选择任务指南

RoCBertConfig

class transformers.RoCBertConfig

<来源>

( 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 position_embedding_type = 'absolute' classifier_dropout = None enable_pronunciation = True enable_shape = True pronunciation_embed_dim = 768 pronunciation_vocab_size = 910 shape_embed_dim = 512 shape_vocab_size = 24858 concat_input = True **kwargs )

参数

• vocab_size (int, optional, defaults to 30522) — RoCBert 模型的词汇量大小。定义了在调用 RoCBertModel 时可以表示的不同标记的数量。

• hidden_size (int, optional, defaults to 768) — 编码器层和池化器层的维度。

• num_hidden_layers (int, optional, defaults to 12) — Transformer 编码器中的隐藏层数量。

• num_attention_heads (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数。

• intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（即前馈）层的维度。

• hidden_act (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu"、"relu"、"selu" 和 "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) — 在调用 RoCBertModel 时传递的 token_type_ids 的词汇量大小。

• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。

• is_decoder (bool, optional, defaults to False) — 模型是否用作解码器。如果为 False，则模型用作编码器。

• use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在 config.is_decoder=True 时相关。

• position_embedding_type (str, optional, defaults to "absolute") — 位置嵌入的类型。选择 "absolute"、"relative_key"、"relative_key_query" 中的一种。对于位置嵌入，请使用 "absolute"。有关 "relative_key" 的更多信息，请参考 Self-Attention with Relative Position Representations (Shaw et al.)。有关 "relative_key_query" 的更多信息，请参考 Improve Transformer Models with Better Relative Position Embeddings (Huang et al.) 中的 Method 4。

• classifier_dropout (float, optional) — 分类头的丢弃比率。

• enable_pronunciation (bool, optional, defaults to True) — 模型在训练时是否使用发音嵌入。

• enable_shape (bool, optional, defaults to True) — 模型在训练时是否使用形状嵌入。

• pronunciation_embed_dim (int, optional, defaults to 768) — 发音嵌入的维度。

• pronunciation_vocab_size (int, optional, defaults to 910) — RoCBert 模型的发音词汇表大小。定义了在调用 RoCBertModel 时传递的 input_pronunciation_ids 可表示的不同标记数量。

• shape_embed_dim (int, optional, defaults to 512) — 形状嵌入的维度。

• shape_vocab_size (int, optional, defaults to 24858) — RoCBert 模型的形状词汇表大小。定义了在调用 RoCBertModel 时传递的 input_shape_ids 可表示的不同标记数量。

• concat_input (bool, optional, defaults to True) — 定义了合并 shape_embed、pronunciation_embed 和 word_embed 的方式，如果值为 true，则 output_embed = torch.cat((word_embed, shape_embed, pronunciation_embed), -1)，否则 output_embed = (word_embed + shape_embed + pronunciation_embed) / 3 示例 —

这是用于存储 RoCBertModel 配置的配置类。根据指定的参数实例化 RoCBert 模型，定义模型架构。使用默认值实例化配置将产生类似于 RoCBert weiweishi/roc-bert-base-zh 架构的配置。

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

>>> from transformers import RoCBertModel, RoCBertConfig

>>> # Initializing a RoCBert weiweishi/roc-bert-base-zh style configuration
>>> configuration = RoCBertConfig()

>>> # Initializing a model from the weiweishi/roc-bert-base-zh style configuration
>>> model = RoCBertModel(configuration)

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

RoCBertTokenizer

class transformers.RoCBertTokenizer

< source >

( vocab_file word_shape_file word_pronunciation_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 )

参数

• Construct 一个 RoCBert 分词器。基于 WordPiece。此分词器继承自 PreTrainedTokenizer，其中 —

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

build_inputs_with_special_tokens

< source >

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

参数

• token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表。

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

返回

List[int]

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

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

• 单个序列：[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], 可选) — 序列对的可选第二个 ID 列表。

• already_has_special_tokens (bool, 可选, 默认为 False) — 标记列表是否已经格式化为模型的特殊标记。

返回

List[int]

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

从没有添加特殊标记的标记列表中检索序列 ID。在使用 tokenizer 的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]，可选）— 序列对的可选第二个 ID 列表。

返回

List[int]

根据给定序列的令牌类型 ID 列表。

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

对的掩码具有以下格式：

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 )

RoCBertModel

class transformers.RoCBertModel

<来源>

( config add_pooling_layer = True )

参数

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

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

该模型可以表现为编码器（仅具有自注意力）以及解码器，在这种情况下，在自注意力层之间添加了一层交叉注意力，遵循Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser 和 Illia Polosukhin描述的架构。

为了表现为解码器，模型需要使用配置中设置为True的is_decoder参数进行初始化。要在 Seq2Seq 模型中使用，模型需要使用is_decoder参数和add_cross_attention都设置为True进行初始化；然后期望一个encoder_hidden_states作为前向传递的输入。

forward

<来源>

( input_ids: Optional = None input_shape_ids: Optional = None input_pronunciation_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.BaseModelOutputWithPoolingAndCrossAttentions or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• input_shape_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 形状词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• input_pronunciation_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（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）—避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用此掩码。选择的掩码值在[0, 1]中：

  • 1 表示未被“掩盖”的标记，

  • 0 表示被“掩盖”的标记。

• past_key_values（长度为config.n_layers的tuple(tuple(torch.FloatTensor))，每个元组有 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，可选）—如果设置为True，则返回past_key_values键值状态，并可用于加速解码（请参见past_key_values）。

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或者tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或者一个torch.FloatTensor的元组（如果传递了return_dict=False或者当config.return_dict=False时），包括根据配置（RoCBertConfig）和输入而不同的各种元素。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）- 模型最后一层的隐藏状态序列输出。

• pooler_output（形状为(batch_size, hidden_size)的torch.FloatTensor）- 经过用于辅助预训练任务的层进一步处理后，序列第一个标记（分类标记）的最后一层隐藏状态。例如，对于 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 之后的注意力权重。

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

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递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输入）以加速顺序解码。

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

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

示例：

>>> from transformers import AutoTokenizer, RoCBertModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("weiweishi/roc-bert-base-zh")
>>> model = RoCBertModel.from_pretrained("weiweishi/roc-bert-base-zh")

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

>>> last_hidden_states = outputs.last_hidden_state

RoCBertForPreTraining

class transformers.RoCBertForPreTraining

<来源>

( config )

参数

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

RoCBert 模型在预训练期间使用对比损失和掩码语言模型损失。

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

forward

<来源>

( input_ids: Optional = None input_shape_ids: Optional = None input_pronunciation_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None attack_input_ids: Optional = None attack_input_shape_ids: Optional = None attack_input_pronunciation_ids: Optional = None attack_attention_mask: Optional = None attack_token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels_input_ids: Optional = None labels_input_shape_ids: Optional = None labels_input_pronunciation_ids: Optional = None labels_attention_mask: Optional = None labels_token_type_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs ) → 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？

• input_shape_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 形状词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。

  什么是输入 ID？

• input_pronunciation_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 表示头部为not 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 而不是普通元组。

  attack_input_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）：用于计算对比损失的攻击样本 id。索引应在[-100, 0, ..., config.vocab_size]内（请参阅input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算标签为[0, ..., config.vocab_size]的标记。attack_input_shape_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）：用于计算对比损失的攻击样本形状 id。索引应在[-100, 0, ..., config.vocab_size]内（请参阅input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算标签为[0, ..., config.vocab_size]的标记。attack_input_pronunciation_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）：用于计算对比损失的攻击样本发音 id。索引应在[-100, 0, ..., config.vocab_size]内（请参阅input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算标签为[0, ..., config.vocab_size]的标记。labels_input_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）：用于计算对比损失和 masked_lm_loss 的目标 id。索引应在[-100, 0, ..., config.vocab_size]内（请参阅input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算标签为[0, ..., config.vocab_size]的标记。labels_input_shape_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）：用于计算对比损失和 masked_lm_loss 的目标形状 id。索引应在[-100, 0, ..., config.vocab_size]内（请参阅input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算标签为[0, ..., config.vocab_size]的标记。labels_input_pronunciation_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）：用于计算对比损失和 masked_lm_loss 的目标发音 id。索引应在[-100, 0, ..., config.vocab_size]内（请参阅input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算标签为[0, ..., config.vocab_size]的标记。

  kwargs（Dict[str, any]，可选，默认为{}）：用于隐藏已弃用的旧参数。

返回

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

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

• loss (torch.FloatTensor，形状为(1,)，可选，当提供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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, RoCBertForPreTraining
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("weiweishi/roc-bert-base-zh")
>>> model = RoCBertForPreTraining.from_pretrained("weiweishi/roc-bert-base-zh")

>>> inputs = tokenizer("你好，很高兴认识你", return_tensors="pt")
>>> attack_inputs = {}
>>> for key in list(inputs.keys()):
...     attack_inputs[f"attack_{key}"] = inputs[key]
>>> label_inputs = {}
>>> for key in list(inputs.keys()):
...     label_inputs[f"labels_{key}"] = inputs[key]

>>> inputs.update(label_inputs)
>>> inputs.update(attack_inputs)
>>> outputs = model(**inputs)

>>> logits = outputs.logits
>>> logits.shape
torch.Size([1, 11, 21128])

RoCBertForCausalLM

class transformers.RoCBertForCausalLM

<来源>

( config )

参数

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

RoCBert 模型在顶部带有一个语言建模头用于 CLM 微调。该模型是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_ids: Optional = None input_shape_ids: Optional = None input_pronunciation_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None head_mask: Optional = None past_key_values: 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.modeling_outputs.CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor） — 输入序列标记在词汇表中的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• input_shape_ids（形状为(batch_size, sequence_length)的torch.LongTensor） — 输入序列标记的索引在形状词汇表中。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是 input IDs?

• input_pronunciation_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 发音词汇中输入序列 token 的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是 input IDs?

• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充 token 索引上执行注意力的掩码。掩码值在[0, 1]中选择：

  • 1 表示未被遮蔽的 token，

  • 0 表示被遮蔽的 token。

  什么是 attention masks?

• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 指示输入的第一部分和第二部分的段 token 索引。索引在[0, 1]中选择：

  • 0 对应于句子 A的 token，

  • 1 对应于句子 B的 token。

  什么是 token type IDs?

• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列 token 的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

  什么是 position IDs?

• 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 而不是普通元组。

• encoder_hidden_states (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。

• encoder_attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在编码器输入的填充 token 索引上执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用此掩码。掩码值在[0, 1]中选择：

  • 1 表示未被遮蔽的 token，

  • 0 表示被遮蔽的 token。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回 — 长度为config.n_layers的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，以及 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。当模型用作序列到序列模型中的解码器时，这两个额外的张量是必需的。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。

  如果使用了past_key_values，用户可以选择性地仅输入形状为(batch_size, 1)的最后decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的）而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。

• labels (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于计算从左到右的语言建模损失（下一个词预测）的标签。索引应在[-100, 0, ..., config.vocab_size]内（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩盖），损失仅计算具有标签 n [0, ..., config.vocab_size]的标记。

• use_cache (bool，可选) — 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。

返回

transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或torch.FloatTensor的元组

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

• loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回） — 语言建模损失（用于下一个标记预测）。

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

• cross_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

  注意力 softmax 后的交叉注意力权重，用于计算交叉注意力头中的加权平均值。

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的torch.FloatTensor元组的元组，每个元组包含自注意力和交叉注意力层的缓存键、值状态，如果模型用于编码器-解码器设置，则相关。仅在config.is_decoder = True时相关。

  包含预先计算的隐藏状态（注意力块中的键和值），可以使用（查看past_key_values输入）以加速顺序解码。

RoCBertForCausalLM 的前向传播方法，覆盖了__call__特殊方法。

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

示例：

>>> from transformers import AutoTokenizer, RoCBertForCausalLM, RoCBertConfig
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("weiweishi/roc-bert-base-zh")
>>> config = RoCBertConfig.from_pretrained("weiweishi/roc-bert-base-zh")
>>> config.is_decoder = True
>>> model = RoCBertForCausalLM.from_pretrained("weiweishi/roc-bert-base-zh", config=config)

>>> inputs = tokenizer("你好，很高兴认识你", return_tensors="pt")
>>> outputs = model(**inputs)

>>> prediction_logits = outputs.logits

RoCBertForMaskedLM

class transformers.RoCBertForMaskedLM

<来源>

( config )

参数

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

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

前向传播

<来源>

( input_ids: Optional = None input_shape_ids: Optional = None input_pronunciation_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 labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。

  什么是输入 ID？

• input_shape_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 形状词汇中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。

  什么是输入 ID？

• input_pronunciation_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 发音词汇中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选定在[0, 1]中：

  • 1 表示标记未被masked,

  • 0 表示标记被masked。

  什么是注意力掩码？

• 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 而不是一个普通的元组。

• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]中（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（masked），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。

  示例 —

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

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

RoCBertForSequenceClassification

transformers.RoCBertForSequenceClassification类

<来源>

( config )

参数

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

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

forward

< source >

( input_ids: Optional = None input_shape_ids: Optional = None input_pronunciation_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 of shape (batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• input_shape_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 输入序列标记在形状词汇中的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• input_pronunciation_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 输入序列标记在发音词汇中的索引。

  可以使用 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，可选）- 是否返回一个 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时）包含根据配置（RoCBertConfig）和输入的各种元素。

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

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

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

单标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, RoCBertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("ArthurZ/dummy-rocbert-seq")
>>> model = RoCBertForSequenceClassification.from_pretrained("ArthurZ/dummy-rocbert-seq")

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

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

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
'financial news'

>>> # 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 = RoCBertForSequenceClassification.from_pretrained("ArthurZ/dummy-rocbert-seq", num_labels=num_labels)

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

多标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, RoCBertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("ArthurZ/dummy-rocbert-seq")
>>> model = RoCBertForSequenceClassification.from_pretrained("ArthurZ/dummy-rocbert-seq", 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 = RoCBertForSequenceClassification.from_pretrained(
...     "ArthurZ/dummy-rocbert-seq", 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

RoCBertForMultipleChoice

class transformers.RoCBertForMultipleChoice

< source >

( config )

参数

• config（RoCBertConfig](/docs/transformers/v4.37.2/en/main_classes/model#transformers.PreTrainedModel.from_pretrained)方法以加载模型权重。

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

forward

<来源>

( input_ids: Optional = None input_shape_ids: Optional = None input_pronunciation_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 是什么？

• input_shape_ids（形状为(batch_size, num_choices, sequence_length)的torch.LongTensor）- 形状词汇中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  输入 ID 是什么？

• input_pronunciation_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（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 时）包含根据配置（RoCBertConfig）和输入的不同元素。

• loss（torch.FloatTensor，形状为 (1,)，可选，当提供 labels 时返回）— 分类损失。

• logits（torch.FloatTensor，形状为 (batch_size, num_choices)）— 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 后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, RoCBertForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("weiweishi/roc-bert-base-zh")
>>> model = RoCBertForMultipleChoice.from_pretrained("weiweishi/roc-bert-base-zh")

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

RoCBertForTokenClassification

transformers.RoCBertForTokenClassification 类

< source >

( config )

参数

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

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

forward

< source >

( input_ids: Optional = None input_shape_ids: Optional = None input_pronunciation_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 (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

  索引可以使用 AutoTokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• input_shape_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 形状词汇表中输入序列标记的索引。

  索引可以使用 AutoTokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• input_pronunciation_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 发音词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 遮罩，避免在填充标记索引上执行注意力。遮罩值选择在[0, 1]范围内：

  • 对于未被masked的标记为 1，

  • 对于被masked的标记为 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 表示头部未被masked，

  • 0 表示头部被masked。

• 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（形状为(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时）包含根据配置（RoCBertConfig的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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, RoCBertForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("ArthurZ/dummy-rocbert-ner")
>>> model = RoCBertForTokenClassification.from_pretrained("ArthurZ/dummy-rocbert-ner")

>>> 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]]
>>> predicted_tokens_classes
['S-EVENT', 'S-FAC', 'I-ORDINAL', 'I-ORDINAL', 'E-ORG', 'E-LANGUAGE', 'E-ORG', 'E-ORG', 'E-ORG', 'E-ORG', 'I-EVENT', 'S-TIME', 'S-TIME', 'E-LANGUAGE', 'S-TIME', 'E-DATE', 'I-ORDINAL', 'E-QUANTITY', 'E-LANGUAGE', 'S-TIME', 'B-ORDINAL', 'S-PRODUCT', 'E-LANGUAGE', 'E-LANGUAGE', 'E-ORG', 'E-LOC', 'S-TIME', 'I-ORDINAL', 'S-FAC', 'O', 'S-GPE', 'I-EVENT', 'S-GPE', 'E-LANGUAGE', 'E-ORG', 'S-EVENT', 'S-FAC', 'S-FAC', 'S-FAC', 'E-ORG', 'S-FAC', 'E-ORG', 'S-GPE']

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
3.62

RoCBertForQuestionAnswering

class transformers.RoCBertForQuestionAnswering

<来源>

( config )

参数

• config（RoCBertConfig](/docs/transformers/v4.37.2/en/main_classes/model#transformers.PreTrainedModel.from_pretrained)方法以加载模型权重。

RoCBert 模型在抽取式问答任务（如 SQuAD）上具有一个跨度分类头部（在隐藏状态输出的线性层上计算跨度起始对数和跨度结束对数）。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。

forward

<来源>

( input_ids: Optional = None input_shape_ids: Optional = None input_pronunciation_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？

• input_shape_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 输入序列标记在形状词汇中的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• input_pronunciation_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 输入序列标记在发音词汇中的索引。

  可以使用 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（形状为(batch_size,)的torch.LongTensor，可选）- 用于计算标记跨度起始位置的位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内以计算损失。

• end_positions（形状为(batch_size,)的torch.LongTensor，可选）- 用于计算标记跨度结束位置的位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内以计算损失。

返回

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

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

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）- 总跨度提取损失是起始和结束位置的交叉熵之和。

• start_logits（形状为(batch_size, sequence_length)的torch.FloatTensor）- 跨度起始分数（SoftMax 之前）。

• end_logits（形状为(batch_size, sequence_length)的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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, RoCBertForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("ArthurZ/dummy-rocbert-qa")
>>> model = RoCBertForQuestionAnswering.from_pretrained("ArthurZ/dummy-rocbert-qa")

>>> 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]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
''

>>> # 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
>>> round(loss.item(), 2)
3.75

RoFormer

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

概述

RoFormer 模型由苏建林、陆宇、潘胜峰、文波和刘云峰在 RoFormer: Enhanced Transformer with Rotary Position Embedding 中提出。

该论文的摘要如下：

在 transformer 架构中的位置编码为序列中不同位置的元素之间的依赖建模提供了监督。我们研究了在基于 transformer 的语言模型中编码位置信息的各种方法，并提出了一种名为旋转位置嵌入（RoPE）的新颖实现。所提出的 RoPE 使用旋转矩阵编码绝对位置信息，并自然地将显式相对位置依赖性结合到自注意力公式中。值得注意的是，RoPE 具有诸如能够扩展到任何序列长度、随着相对距离增加而减少标记间依赖性、以及能够为线性自注意力提供相对位置编码等有价值的特性。因此，具有旋转位置嵌入的增强型 transformer，即 RoFormer，在长文本任务中实现了卓越的性能。我们发布了关于中国数据的理论分析以及一些初步实验结果。正在进行的英文基准实验将很快更新。

该模型由 junnyu 贡献。原始代码可在 这里 找到。

使用提示

RoFormer 是一种类似 BERT 的自编码模型，具有旋转位置嵌入。旋转位置嵌入已经在长文本分类任务中表现出改进的性能。

资源

• 文本分类任务指南

• 标记分类任务指南

• 问答任务指南

• 因果语言建模任务指南

• 掩码语言建模任务指南

• 多项选择任务指南

RoFormerConfig

class transformers.RoFormerConfig

<来源>

( vocab_size = 50000 embedding_size = None 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 = 1536 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 rotary_value = False use_cache = True **kwargs )

参数

• vocab_size (int, 可选, 默认为 50000) — RoFormer 模型的词汇量。定义了在调用 RoFormerModel 或 TFRoFormerModel 时可以表示的不同标记数量。

• embedding_size (int, 可选, 默认为 None) — 编码器层和池化层的维度。如果未提供，则默认为 hidden_size。

• 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.1) — 用于嵌入层、编码器和池化器中所有全连接层的丢弃概率。

• attention_probs_dropout_prob (float, optional, 默认为 0.1) — 注意力概率的丢弃比率。

• max_position_embeddings (int, optional, 默认为 1536) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512、1024 或 1536）。

• type_vocab_size (int, optional, 默认为 2) — 在调用 RoFormerModel 或 TFRoFormerModel 时传递的 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 时相关。

• rotary_value (bool, optional, 默认为 False) — 是否在值层上应用旋转位置嵌入。

这是用于存储 RoFormerModel 配置的配置类。根据指定的参数实例化 RoFormer 模型，定义模型架构。使用默认值实例化配置将产生类似于 RoFormer junnyu/roformer_chinese_base 架构的配置。

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

示例：

>>> from transformers import RoFormerModel, RoFormerConfig

>>> # Initializing a RoFormer junnyu/roformer_chinese_base style configuration
>>> configuration = RoFormerConfig()

>>> # Initializing a model (with random weights) from the junnyu/roformer_chinese_base style configuration
>>> model = RoFormerModel(configuration)

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

RoFormerTokenizer

class transformers.RoFormerTokenizer

< 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, 默认为 True) — 在标记化时是否将输入转换为小写。

• do_basic_tokenize (bool, optional, 默认为 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, 默认为 "[CLS]") — 分类器标记，用于进行序列分类（对整个序列进行分类，而不是每个标记的分类）。它是使用特殊标记构建的序列的第一个标记。

• mask_token (str, optional, defaults to "[MASK]") — 用于屏蔽值的标记。这是在使用屏蔽语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

• tokenize_chinese_chars (bool, optional, defaults to True) — 是否对中文字符进行分词。

  这可能应该在日语中停用（请参阅此问题）。

• strip_accents (bool, optional) — 是否去除所有重音符号。如果未指定此选项，则将由 lowercase 的值确定（与原始 BERT 相同）。

构建一个 RoFormer 分词器。基于Rust Jieba。

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

示例：

>>> from transformers import RoFormerTokenizer

>>> tokenizer = RoFormerTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> tokenizer.tokenize("今天天气非常好。")
['今', '天', '天', '气', '非常', '好', '。']

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 列表。

通过连接和添加特殊标记，为序列分类任务构建模型输入。RoFormer 序列的格式如下：

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

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

序列对掩码的格式如下：

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 )

RoFormerTokenizerFast

class transformers.RoFormerTokenizerFast

<来源>

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

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

RoFormerTokenizerFast 几乎与 BertTokenizerFast 相同，并且可以进行端到端的分词：标点符号拆分和词片。在分词中文时它们之间存在一些差异。

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

示例：

>>> from transformers import RoFormerTokenizerFast

>>> tokenizer = RoFormerTokenizerFast.from_pretrained("junnyu/roformer_chinese_base")
>>> tokenizer.tokenize("今天天气非常好。")
['今', '天', '天', '气', '非常', '好', '。']

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]，可选）- 序列对的可选第二个 ID 列表。

返回

List[int]

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

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

• 单个序列：[CLS] X [SEP]

• 序列对：[CLS] A [SEP] B [SEP]

PytorchHide Pytorch 内容

RoFormerModel

class transformers.RoFormerModel

<来源>

( config )

参数

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

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

该模型可以作为编码器（仅使用自注意力）或解码器运行，在后一种情况下，在自注意力层之间添加了一层交叉注意力，遵循Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser 和 Illia Polosukhin描述的架构。

要作为解码器运行，模型需要使用配置中的is_decoder参数初始化为True。要在 Seq2Seq 模型中使用，模型需要使用is_decoder参数和add_cross_attention设置为True进行初始化；然后预期将encoder_hidden_states作为输入传递。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_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()。

  什么是输入 IDs？

• attention_mask（torch.FloatTensor，形状为(batch_size, sequence_length)，可选）- 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]之间：

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

  • 0 表示被掩码的标记。

  什么是注意力掩码？

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

  • 0 对应于句子 A的标记，

  • 1 对应于句子 B的标记。

  什么是 token type IDs？

• 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（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用此掩码。掩码值选在[0, 1]之间：

  • 1 表示未被掩盖的标记，

  • 0 表示被掩盖的标记。

• past_key_values（长度为config.n_layers的tuple(tuple(torch.FloatTensor))，每个元组包含形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的 4 个张量）— 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用past_key_values，用户可以选择仅输入形状为(batch_size, 1)的最后一个decoder_input_ids（这些输入没有给定其过去键值状态的模型）而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。

• use_cache（bool，可选）— 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。

返回

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

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

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）— 模型最后一层的隐藏状态序列。

  如果使用past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递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)，可选，当传递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 之后，用于计算交叉注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, RoFormerModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> model = RoFormerModel.from_pretrained("junnyu/roformer_chinese_base")

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

>>> last_hidden_states = outputs.last_hidden_state

RoFormerForCausalLM

class transformers.RoFormerForCausalLM

<来源>

( config )

参数

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

RoFormer 模型在顶部带有语言建模头用于 CLM 微调。这个模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

前进

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None head_mask: Optional = None cross_attn_head_mask: Optional = None past_key_values: 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.modeling_outputs.CausalLMOutputWithCrossAttentions 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 表示未被 masked 的标记，

  • 0 表示被 masked 的标记。

  什么是注意力掩码？

• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段标记索引，指示输入的第一部分和第二部分。索引选在 [0, 1] 之间：

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选在 [0, 1] 之间：

  • 1 表示头部未被 masked，

  • 0 表示头部被 masked。

• 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 而不是一个普通的元组。

• encoder_hidden_states (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。

• encoder_attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用此掩码。掩码值选在 [0, 1] 之间：

  • 1 表示未被 masked 的标记，

  • 0 表示被 masked 的标记。

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

• labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算从左到右的语言建模损失（下一个单词预测）的标签。索引应在 [-100, 0, ..., config.vocab_size] 中（参见 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（被 masked），损失仅计算具有标签 n [0, ..., config.vocab_size] 的标记。

• use_cache（bool，可选） — 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。

返回

transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或者tuple(torch.FloatTensor)

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

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回） — 语言建模损失（用于下一个标记预测）。

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

• cross_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或者config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

  在注意力 softmax 之后的交叉注意力权重，用于计算交叉注意力头中的加权平均值。

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或者config.use_cache=True时返回） — 长度为config.n_layers的torch.FloatTensor元组的元组，每个元组包含自注意力和交叉注意力层的缓存键、值状态，如果模型用于编码器-解码器设置，则相关。仅在config.is_decoder = True时相关。

  包含预先计算的隐藏状态（注意力块中的键和值），可以用于加速顺序解码（参见past_key_values输入）。

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

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

示例：

>>> from transformers import AutoTokenizer, RoFormerForCausalLM, RoFormerConfig
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> config = RoFormerConfig.from_pretrained("junnyu/roformer_chinese_base")
>>> config.is_decoder = True
>>> model = RoFormerForCausalLM.from_pretrained("junnyu/roformer_chinese_base", config=config)

>>> inputs = tokenizer("今天天气非常好。", return_tensors="pt")
>>> outputs = model(**inputs)

>>> prediction_logits = outputs.logits

RoFormerForMaskedLM

transformers.RoFormerForMaskedLM类

< source >

( config )

参数

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

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

forward

<来源>

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

参数

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

• 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）包含各种元素，取决于配置（RoFormerConfig）和输入。

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

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

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

示例：

>>> from transformers import AutoTokenizer, RoFormerForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> model = RoFormerForMaskedLM.from_pretrained("junnyu/roformer_chinese_base")

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

RoFormerForSequenceClassification

class transformers.RoFormerForSequenceClassification

<来源>

( config )

参数

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

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

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_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 用于未被 masked 的 token，

  • 0 用于被 masked 的 token。

  什么是注意力掩码？

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

  • 0 对应于 句子 A 的 token，

  • 1 对应于 句子 B 的 token。

  什么是 token type IDs？

• 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 (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。

返回

transformers.modeling_outputs.SequenceClassifierOutput 或 torch.FloatTensor 元组

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

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

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

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

单标签分类的示例：

>>> import torch
>>> from transformers import AutoTokenizer, RoFormerForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> model = RoFormerForSequenceClassification.from_pretrained("junnyu/roformer_chinese_base")

>>> 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 = RoFormerForSequenceClassification.from_pretrained("junnyu/roformer_chinese_base", num_labels=num_labels)

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

多标签分类的示例：

>>> import torch
>>> from transformers import AutoTokenizer, RoFormerForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> model = RoFormerForSequenceClassification.from_pretrained("junnyu/roformer_chinese_base", 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 = RoFormerForSequenceClassification.from_pretrained(
...     "junnyu/roformer_chinese_base", 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

RoFormerForMultipleChoice

class transformers.RoFormerForMultipleChoice

<来源>

( config )

参数

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

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

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_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 表示未被masked的标记，

  • 0 表示被masked的标记。

  什么是注意力掩码？

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

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• head_mask（torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选）— 用于使自注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]中选择：

  • 1 表示头部未被masked，

  • 0 表示头部是masked。

• 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）包含根据配置(RoFormerConfig)和输入的各种元素。

• loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类损失。

• logits (torch.FloatTensor，形状为(batch_size, num_choices)) — num_choices是输入张量的第二维的大小。（参见上面的input_ids）。

  分类得分（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元组（每层一个）。

  在自注意力头中用于计算加权平均值的注意力权重。

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

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

示例：

>>> from transformers import AutoTokenizer, RoFormerForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> model = RoFormerForMultipleChoice.from_pretrained("junnyu/roformer_chinese_base")

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

RoFormerForTokenClassification

class transformers.RoFormerForTokenClassification

<来源>

( config )

参数

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

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

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_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 (torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 IDs？

• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

  • 对于未被masked的标记为 1，

  • 对于被masked的标记为 0。

  什么是注意力掩码？

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

  • 0 对应于sentence A标记，

  • 1 对应于sentence B标记。

  什么是 token type IDs？

• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• 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时）包含各种元素，具体取决于配置（RoFormerConfig）和输入。

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

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

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

示例：

>>> from transformers import AutoTokenizer, RoFormerForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> model = RoFormerForTokenClassification.from_pretrained("junnyu/roformer_chinese_base")

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

RoFormerForQuestionAnswering

class transformers.RoFormerForQuestionAnswering

< source >

( config )

参数

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

RoFormer 模型在顶部具有一个用于提取式问答任务（如 SQuAD）的跨度分类头部（在隐藏状态输出顶部的线性层，用于计算 跨度起始对数 和 跨度结束对数）。

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

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None token_type_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 (torch.LongTensor of shape (batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。

  可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 了解详情。

  什么是输入 ID？

• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), 可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1]：

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

  • 0 表示被掩码的标记。

  什么是注意力掩码？

• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), 可选) — 段标记索引，指示输入的第一部分和第二部分。索引选择在 [0, 1]：

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), 可选) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在 [0, 1]：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), 可选) — 可选地，可以直接传递嵌入表示而不是传递 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时）包含各种元素，具体取决于配置（RoFormerConfig）和输入。

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

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

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

示例：

>>> from transformers import AutoTokenizer, RoFormerForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> model = RoFormerForQuestionAnswering.from_pretrained("junnyu/roformer_chinese_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

TensorFlow 隐藏 TensorFlow 内容

TFRoFormerModel

class transformers.TFRoFormerModel

< source >

( config: RoFormerConfig *inputs **kwargs )

参数

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

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

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

这个模型也是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。

transformers中的 TensorFlow 模型和层接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或

• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于有了这种支持，当使用model.fit()等方法时，应该可以“正常工作” - 只需以model.fit()支持的任何格式传递输入和标签！但是，如果您想在 Keras 方法之外使用第二种格式，比如在使用 KerasFunctional API 创建自己的层或模型时，有三种可能性可以用来收集第一个位置参数中的所有输入张量：

• 一个只包含input_ids的单个张量，没有其他内容：model(input_ids)

• 一个长度不定的列表，其中包含一个或多个按照文档字符串中给定的顺序的输入张量：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])

• 一个字典，其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您不需要担心这些问题，因为您可以像对待任何其他 Python 函数一样传递输入！

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling or tuple(tf.Tensor)

参数

• input_ids（np.ndarray、tf.Tensor、List[tf.Tensor]、Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, sequence_length)） - 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。

  输入 ID 是什么？

• attention_mask（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选） - 避免在填充标记索引上执行注意力的蒙版。选择的蒙版值为[0, 1]：

  • 对于“未蒙版”的标记为 1，

  • 对于“蒙版”的标记为 0。

  注意力蒙版是什么？

• token_type_ids（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选） - 指示输入的第一部分和第二部分的段标记索引。索引选择在[0, 1]中：

  • 0 对应于“句子 A”标记，

  • 1 对应于句子 B令牌。

  令牌类型 ID 是什么？

• head_mask (np.ndarray 或 tf.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块的选定头部失效的掩码。在[0, 1]中选择的掩码值：

  • 1 表示头部未被屏蔽，

  • 0 表示头部被屏蔽。

• inputs_embeds (np.ndarray 或 tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。此参数仅在急切模式下可用，在图模式下将使用配置中的值。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。此参数仅在急切模式下可用，在图模式下将使用配置中的值。

• return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。

• training (bool, 可选，默认为`False“) — 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。

返回

transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或 tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或一个tf.Tensor元组（如果传递return_dict=False或当config.return_dict=False时）包括根据配置(RoFormerConfig)和输入的不同元素。

• last_hidden_state (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。

• pooler_output (tf.Tensor，形状为(batch_size, hidden_size)) — 序列第一个令牌（分类令牌）的最后一层隐藏状态，进一步由线性层和 Tanh 激活函数处理。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。

  此输出通常不是输入的语义内容的良好摘要，您通常最好对整个输入序列的隐藏状态序列进行平均或池化。

• hidden_states (tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每一层的输出）。

  模型在每一层输出的隐藏状态以及初始嵌入输出。

• attentions (tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。

  在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, TFRoFormerModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> model = TFRoFormerModel.from_pretrained("junnyu/roformer_chinese_base")

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

>>> last_hidden_states = outputs.last_hidden_state

TFRoFormerForMaskedLM

class transformers.TFRoFormerForMaskedLM

<来源>

( config: RoFormerConfig *inputs **kwargs )

参数

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

RoFormer 模型，顶部带有一个语言建模头。

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

这个模型也是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。

transformers中的 TensorFlow 模型和层接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或者

• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是，当将输入传递给模型和层时，Keras 方法更喜欢这种格式。由于这种支持，当使用model.fit()等方法时，您应该可以“正常工作” - 只需以model.fit()支持的任何格式传递输入和标签！但是，如果您想在 Keras 方法之外使用第二种格式，比如在使用 KerasFunctional API 创建自己的层或模型时，有三种可能性可以用来收集所有输入张量放在第一个位置参数中：

• 只有一个包含input_ids的张量，没有其他内容：model(input_ids)

• 一个长度可变的列表，其中包含一个或多个输入张量，按照文档字符串中给定的顺序：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])

• 一个包含与文档字符串中给定的输入名称相关联的一个或多个输入张量的字典：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您无需担心这些问题，因为您可以像对待其他 Python 函数一样传递输入！

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFMaskedLMOutput or tuple(tf.Tensor)

参数

• input_ids（np.ndarray、tf.Tensor、List[tf.Tensor]、Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, sequence_length)）- 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()获取详细信息。

  什么是输入 ID？

• attention_mask (形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，*可选*) — 用于避免在填充标记索引上执行注意力的掩码。 选择的掩码值在[0, 1]`中：

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

  • 0 表示被掩码的标记。

  什么是注意力掩码？

• token_type_ids (形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，*可选*) — 段标记索引，指示输入的第一部分和第二部分。 索引在[0, 1]`中选择：

  • 0 对应于一个句子 A标记，

  • 1 对应于一个句子 B标记。

  什么是标记类型 ID？

• head_mask (形状为(num_heads,)或(num_layers, num_heads)的np.ndarray或tf.Tensor，*可选*) — 用于使自注意力模块的选定头部失效的掩码。 选择的掩码值在[0, 1]`中：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• inputs_embeds (形状为(batch_size, sequence_length, hidden_size)的np.ndarray或tf.Tensor，*可选*) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您想要更多控制如何将input_ids`索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

• output_attentions (布尔值，可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参见返回张量下的attentions。 这个参数只能在急切模式下使用，在图模式下将使用配置中的值。

• output_hidden_states (布尔值，可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的hidden_states。 这个参数只能在急切模式下使用，在图模式下将使用配置中的值。

• return_dict (布尔值，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。 这个参数可以在急切模式下使用，在图模式下该值将始终设置为 True。

• training (布尔值，可选，默认为`False“) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

• labels (形状为(batch_size, sequence_length)的tf.Tensor或np.ndarray，*可选*) — 用于计算掩码语言建模损失的标签。 索引应在[-100, 0, ..., config.vocab_size]中（请参阅input_ids文档字符串）索引设置为-100的标记将被忽略（掩码），仅对具有标签在[0, ..., config.vocab_size]`中的标记计算损失

返回

transformers.modeling_tf_outputs.TFMaskedLMOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFMaskedLMOutput 或一个tf.Tensor元组（如果传递了return_dict=False或config.return_dict=False时）包括根据配置（RoFormerConfig）和输入的不同元素。

• 损失 (形状为(n,)的tf.Tensor，*可选*，当提供labels`时返回，其中 n 是非掩码标签的数量) — 掩码语言建模（MLM）损失。

• logits (形状为(batch_size, sequence_length, config.vocab_size)的tf.Tensor`) — 语言建模头部的预测分数（SoftMax 之前每个词汇标记的分数）。

• hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。

  模型在每个层的输出处的隐藏状态加上初始嵌入输出。

• attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每个层一个）。

  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

例如：

>>> from transformers import AutoTokenizer, TFRoFormerForMaskedLM
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> model = TFRoFormerForMaskedLM.from_pretrained("junnyu/roformer_chinese_base")

>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="tf")
>>> logits = model(**inputs).logits

>>> # retrieve index of [MASK]
>>> mask_token_index = tf.where((inputs.input_ids == tokenizer.mask_token_id)[0])
>>> selected_logits = tf.gather_nd(logits[0], indices=mask_token_index)

>>> predicted_token_id = tf.math.argmax(selected_logits, axis=-1)

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

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

TFRoFormerForCausalLM

class transformers.TFRoFormerForCausalLM

<来源>

( config: RoFormerConfig *inputs **kwargs )

参数

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

RoFormer 模型在顶部具有用于 CLM 微调的语言建模头。

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

此模型还是tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。

transformers中的 TensorFlow 模型和层接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或者

• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是，当将输入传递给模型和层时，Keras 方法更喜欢这种格式。由于这种支持，当使用model.fit()等方法时，应该可以“正常工作” - 只需以model.fit()支持的任何格式传递输入和标签！但是，如果您想在 Keras 方法之外使用第二种格式，比如在使用 KerasFunctional API 创建自己的层或模型时，有三种可能性可以用来收集第一个位置参数中的所有输入张量：

• 仅具有input_ids的单个张量，没有其他内容：model(input_ids)

• 具有不同长度的列表，其中包含按照文档字符串中给定的顺序的一个或多个输入张量：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])

• 一个字典，其中包含与文档字符串中给定的输入名称相关联的一个或多个输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您无需担心这些问题，因为您可以像对待任何其他 Python 函数一样传递输入！

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFCausalLMOutput or tuple(tf.Tensor)

返回

transformers.modeling_tf_outputs.TFCausalLMOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFCausalLMOutput 或一个tf.Tensor元组（如果传递了return_dict=False或当config.return_dict=False时）包含根据配置（RoFormerConfig）和输入的不同元素。

• loss（形状为(n,)的tf.Tensor，可选，当提供labels时返回，其中 n 是非掩码标签的数量） — 语言建模损失（用于下一个标记预测）。

• logits（形状为(batch_size, sequence_length, config.vocab_size)的tf.Tensor） — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。

  模型在每一层输出处的隐藏状态加上初始嵌入输出。

• attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。

  在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

labels（形状为(batch_size, sequence_length)的tf.Tensor或np.ndarray，可选）：用于计算交叉熵分类损失的标签。索引应在[0, ..., config.vocab_size - 1]范围内。

示例：

>>> from transformers import AutoTokenizer, TFRoFormerForCausalLM
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> model = TFRoFormerForCausalLM.from_pretrained("junnyu/roformer_chinese_base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> logits = outputs.logits

TFRoFormerForSequenceClassification

class transformers.TFRoFormerForSequenceClassification

<来源>

( config: RoFormerConfig *inputs **kwargs )

参数

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

RoFormer 模型变压器，顶部带有一个序列分类/回归头，例如，用于 GLUE 任务。

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

这个模型也是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。

transformers中的 TensorFlow 模型和层接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或

• 将所有输入作为列表、元组或字典的第一个位置参数。

支持第二种格式的原因是，Keras 方法在向模型和层传递输入时更喜欢这种格式。由于这种支持，在使用诸如model.fit()之类的方法时，应该对您“只需传递model.fit()支持的任何格式的输入和标签” - 事情应该“只需传递model.fit()支持的任何格式的输入和标签”！然而，如果您想在 Keras 方法之外使用第二种格式，比如在使用 KerasFunctional API 创建自己的层或模型时，有三种可能性可以用来收集第一个位置参数中的所有输入张量：

• 只有一个包含input_ids的张量，没有其他内容：model(input_ids)

• 一个长度可变的列表，其中包含按照文档字符串中给定的顺序的一个或多个输入张量：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])

• 一个字典，其中包含与文档字符串中给定的输入名称相关联的一个或多个输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您不需要担心这些问题，因为您可以像将输入传递给任何其他 Python 函数一样传递输入！

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSequenceClassifierOutput or tuple(tf.Tensor)

参数

• input_ids（np.ndarray，tf.Tensor，List[tf.Tensor] ``Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, sequence_length)`） - 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 来获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选） - 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

  • 1 表示“未屏蔽”的标记，

  • 0 表示“屏蔽”的标记。

  什么是注意力掩码？

• token_type_ids（np.ndarray或形状为(batch_size, sequence_length)的tf.Tensor，可选） - 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于“句子 A”标记，

  • 1 对应于“句子 B”标记。

  什么是令牌类型 ID？

• head_mask（形状为(num_heads,)或(num_layers, num_heads)的np.ndarray或tf.Tensor，可选） - 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：

  • 1 表示头部未“屏蔽”，

  • 0 表示头部被“屏蔽”。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的np.ndarray或tf.Tensor，可选） - 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权，以便将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• output_attentions（bool，可选） - 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• output_hidden_states（bool，可选） - 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。此参数可以在急切模式下使用，在图模式下该值将始终设置为 True。

• training (bool, optional, defaults to `False“) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

• labels (tf.Tensor or np.ndarray of shape (batch_size,), optional) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回值

transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置(RoFormerConfig)和输入的各种元素。

• loss (tf.Tensor of shape (batch_size, ), optional, 当提供labels时返回) — 分类（如果 config.num_labels==1 则为回归）损失。

• logits (tf.Tensor of shape (batch_size, config.num_labels)) — 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。

• hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入输出，一个用于每一层的输出）。

  模型在每一层输出的隐藏状态加上初始嵌入输出。

• attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。

  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, TFRoFormerForSequenceClassification
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> model = TFRoFormerForSequenceClassification.from_pretrained("junnyu/roformer_chinese_base")

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

>>> logits = model(**inputs).logits

>>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])

>>> # 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 = TFRoFormerForSequenceClassification.from_pretrained("junnyu/roformer_chinese_base", num_labels=num_labels)

>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).loss

TFRoFormerForMultipleChoice

class transformers.TFRoFormerForMultipleChoice

< source >

( config: RoFormerConfig *inputs **kwargs )

参数

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

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

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

这个模型也是一个tf.keras.Model的子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。

transformers中的 TensorFlow 模型和层接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或

• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于有了这种支持，当使用model.fit()等方法时，应该可以“正常工作” - 只需以model.fit()支持的任何格式传递输入和标签！但是，如果您想在 Keras 方法之外使用第二种格式，比如在使用 KerasFunctional API 创建自己的层或模型时，有三种可能性可以用来收集所有输入张量放在第一个位置参数中：

• 一个只包含input_ids的单个张量，没有其他内容：model(input_ids)

• 一个长度不同的列表，其中包含一个或多个按照文档字符串中给定顺序的输入张量：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])

• 一个字典，其中包含一个或多个与文档字符串中给定输入名称相关联的输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您不需要担心这些问题，因为您可以像对待其他 Python 函数一样传递输入！

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput or tuple(tf.Tensor)

参数

• input_ids（np.ndarray、tf.Tensor、List[tf.Tensor]、Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, num_choices, sequence_length)）- 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。

  什么是 input IDs？

• attention_mask（np.ndarray或tf.Tensor，形状为(batch_size, num_choices, sequence_length)，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

  • 1 表示未被“masked”的标记，

  • 对于被masked的标记，将其设为 0。

  什么是 attention masks？

• token_type_ids（np.ndarray或tf.Tensor，形状为(batch_size, num_choices, sequence_length)，可选）- 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A的标记，

  • 1 对应于句子 B的标记。

  什么是 token type IDs？

• head_mask（np.ndarray或tf.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选）- 用于使自注意力模块中选择的头部失效的掩码。掩码值在[0, 1]中选择：

  • 1 表示头部未被“masked”，

  • 0 表示头部被masked。

• inputs_embeds (np.ndarray或形状为(batch_size, num_choices, sequence_length, hidden_size)的tf.Tensor，optional) — 可选地，可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。这个参数只能在急切模式下使用，在图模式下将使用配置中的值。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。这个参数只能在急切模式下使用，在图模式下将使用配置中的值。

• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。这个参数可以在急切模式下使用，在图模式下该值将始终设置为 True。

• training (bool, optional, defaults to `False“) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

• labels (tf.Tensor或形状为(batch_size,)的np.ndarray，optional) — 用于计算多项选择分类损失的标签。索引应在[0, ..., num_choices]范围内，其中num_choices是输入张量第二维的大小。（参见上面的input_ids）

返回

transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput 或一个tf.Tensor元组（如果传递return_dict=False或当config.return_dict=False时）包括根据配置（RoFormerConfig）和输入的各种元素。

• loss (tf.Tensor形状为(batch_size, ), optional, 当提供labels时返回) — 分类损失。

• logits (tf.Tensor形状为(batch_size, num_choices)) — num_choices是输入张量的第二维。（参见input_ids上面）。

  分类得分（SoftMax 之前）。

• hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每一层的输出）。

  模型在每一层输出的隐藏状态以及初始嵌入输出。

• attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。

  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, TFRoFormerForMultipleChoice
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> model = TFRoFormerForMultipleChoice.from_pretrained("junnyu/roformer_chinese_base")

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

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

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

TFRoFormerForTokenClassification

class transformers.TFRoFormerForTokenClassification

<来源>

( config: RoFormerConfig *inputs **kwargs )

参数

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

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

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

此模型还是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有信息。

transformers中的 TensorFlow 模型和层接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或

• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用model.fit()等方法时，您应该可以“轻松使用” - 只需传递您的输入和标签，以任何model.fit()支持的格式！但是，如果您想在 Keras 方法之外使用第二种格式，例如在使用 KerasFunctionalAPI 创建自己的层或模型时，有三种可能性可用于收集所有输入张量在第一个位置参数中：

• 一个仅包含input_ids的单个张量，没有其他内容：model(input_ids)

• 一个长度可变的列表，其中包含一个或多个按照文档字符串中给定的顺序的输入张量：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])

• 一个字典，其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，在使用子类化创建模型和层时，您无需担心任何这些，因为您可以像对待任何其他 Python 函数一样传递输入！

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFTokenClassifierOutput or tuple(tf.Tensor)

参数

• input_ids（np.ndarray、tf.Tensor、List[tf.Tensor]、Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, sequence_length)）- 输入序列标记在词汇表中的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。

  什么是输入 ID？

• attention_mask（np.ndarray或形状为(batch_size, sequence_length)的tf.Tensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

  • 对于未被masked的标记，值为 1。

  • 对于被masked的标记，值为 0。

  什么是注意力掩码？

• token_type_ids (np.ndarray 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 段标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• head_mask (np.ndarray 或 tf.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块中选择的头部失效的掩码。掩码值在 [0, 1] 中选择：

  • 1 表示头部未被遮蔽，

  • 0 表示头部被遮蔽。

• inputs_embeds (np.ndarray 或 tf.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选择直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制权来将 input_ids 索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。

• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。此参数仅在急切模式下使用，在图模式下，将使用配置中的值。

• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。此参数仅在急切模式下使用，在图模式下，将使用配置中的值。

• return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。此参数可以在急切模式下使用，在图模式下，该值将始终设置为 True。

• training (bool，可选，默认为 `False“) — 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。

• labels (tf.Tensor 或 np.ndarray，形状为 (batch_size, sequence_length)，可选) — 用于计算标记分类损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。

返回

transformers.modeling_tf_outputs.TFTokenClassifierOutput 或 tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFTokenClassifierOutput 或一个 tf.Tensor 元组（如果传递 return_dict=False 或当 config.return_dict=False 时）包含根据配置（RoFormerConfig）和输入而异的各种元素。

• loss (tf.Tensor，形状为 (n,)，可选，当提供 labels 时返回，其中 n 是未被遮蔽标签的数量) — 分类损失。

• logits (tf.Tensor，形状为 (batch_size, sequence_length, config.num_labels)) — 分类分数（SoftMax 之前）。

• hidden_states (tuple(tf.Tensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组（一个用于嵌入的输出 + 一个用于每一层的输出）。

  模型在每一层输出的隐藏状态以及初始嵌入输出。

• attentions (tuple(tf.Tensor)，可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。

  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, TFRoFormerForTokenClassification
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> model = TFRoFormerForTokenClassification.from_pretrained("junnyu/roformer_chinese_base")

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

>>> logits = model(**inputs).logits
>>> predicted_token_class_ids = tf.math.argmax(logits, axis=-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] for t in predicted_token_class_ids[0].numpy().tolist()]

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

TFRoFormerForQuestionAnswering

class transformers.TFRoFormerForQuestionAnswering

<来源>

( config: RoFormerConfig *inputs **kwargs )

参数

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

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

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

此模型还是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有信息。

transformers中的 TensorFlow 模型和层接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或者

• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是，Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用model.fit()等方法时，应该可以“正常工作” - 只需以model.fit()支持的任何格式传递输入和标签！但是，如果您想在 Keras 方法之外使用第二种格式，比如在使用 Keras Functional API 创建自己的层或模型时，有三种可能性可以用来收集所有输入张量放在第一个位置参数中：

• 一个仅包含input_ids的单个张量，没有其他内容：model(input_ids)

• 一个长度不定的列表，其中包含一个或多个输入张量，按照文档字符串中给定的顺序：model([input_ids, attention_mask]) 或 model([input_ids, attention_mask, token_type_ids])

• 一个字典，其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您无需担心这些内容，因为您可以像对待任何其他 Python 函数一样传递输入！

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None start_positions: np.ndarray | tf.Tensor | None = None end_positions: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput or tuple(tf.Tensor)

参数

• input_ids（np.ndarray、tf.Tensor、List[tf.Tensor]、Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, sequence_length)） — 输入序列标记在词汇表中的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选）— 用于避免在填充标记索引上执行注意力。掩码值选择在[0, 1]之间：

  • 1 表示未被掩盖的标记，

  • 0 表示被掩盖的标记。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]之间：

  • 0 对应于一个句子 A的标记，

  • 1 对应于一个句子 B的标记。

  什么是标记类型 ID？

• head_mask（形状为(num_heads,)或(num_layers, num_heads)的np.ndarray或tf.Tensor，可选）— 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]之间：

  • 1 表示头部未被掩盖，

  • 0 表示头部被掩盖。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的np.ndarray或tf.Tensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，这将非常有用。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。这个参数只能在急切模式下使用，在图模式下将使用配置中的值。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。这个参数只能在急切模式下使用，在图模式下将使用配置中的值。

• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通的元组。这个参数可以在急切模式下使用，在图模式下该值将始终设置为 True。

• training（bool，可选，默认为False）— 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

• start_positions（tf.Tensor或形状为(batch_size,)的np.ndarray，可选）— 用于计算标记范围开始位置（索引）的标签，以计算标记分类损失。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内以计算损失。

• end_positions（tf.Tensor或形状为(batch_size,)的np.ndarray，可选）— 用于计算标记范围结束位置（索引）的标签，以计算标记分类损失。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内以计算损失。

返回

transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False）包括根据配置（RoFormerConfig）和输入的不同元素。

• loss（形状为(batch_size, )的tf.Tensor，可选，当提供start_positions和end_positions时返回）- 总跨度提取损失是起始位置和结束位置的交叉熵之和。

• start_logits（形状为(batch_size, sequence_length)的tf.Tensor）- 跨度开始分数（SoftMax 之前）。

• end_logits（形状为(batch_size, sequence_length)的tf.Tensor）- 跨度结束分数（SoftMax 之前）。

• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每层的输出）。

  模型在每层输出的隐藏状态加上初始嵌入输出。

• attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。

  注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, TFRoFormerForQuestionAnswering
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> model = TFRoFormerForQuestionAnswering.from_pretrained("junnyu/roformer_chinese_base")

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

>>> inputs = tokenizer(question, text, return_tensors="tf")
>>> outputs = model(**inputs)

>>> answer_start_index = int(tf.math.argmax(outputs.start_logits, axis=-1)[0])
>>> answer_end_index = int(tf.math.argmax(outputs.end_logits, axis=-1)[0])

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

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

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

JAXHide JAX content

FlaxRoFormerModel

class transformers.FlaxRoFormerModel

<来源>

( config: RoFormerConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

• config（RoFormerConfig）- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 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()。

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

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

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

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

• 即时（JIT）编译

• 自动微分

• 矢量化

• 并行化

__call__

<来源>

( input_ids attention_mask = None token_type_ids = None head_mask = 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.FlaxBaseModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的numpy.ndarray）- 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的numpy.ndarray，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

  • 1 表示未被“掩盖”的标记，

  • 0 表示被“掩盖”的标记。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的numpy.ndarray，可选）- 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• position_ids（形状为(batch_size, sequence_length)的numpy.ndarray，可选）- 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

• head_mask（形状为(batch_size, sequence_length)的numpy.ndarray，可选）-- 用于使注意力模块的选定头部失效的掩码。掩码值在[0, 1]`中选择：

  • 1 表示头部未被“掩盖”，

  • 0 表示头部被“掩盖”。

• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutput 或tuple(torch.FloatTensor)

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

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray）- 模型最后一层的隐藏状态序列。

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

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

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

示例：

>>> from transformers import AutoTokenizer, FlaxRoFormerModel

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> model = FlaxRoFormerModel.from_pretrained("junnyu/roformer_chinese_base")

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

>>> last_hidden_states = outputs.last_hidden_state

FlaxRoFormerForMaskedLM

class transformers.FlaxRoFormerForMaskedLM

<来源>

( config: RoFormerConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

• config（RoFormerConfig）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 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()。

RoFormer 模型，顶部带有 语言建模 头。

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

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

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

• 即时编译（JIT）

• 自动微分

• 矢量化

• 并行化

__call__

<来源>

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

参数

• input_ids（形状为 (batch_size, sequence_length) 的 numpy.ndarray）— 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• attention_mask (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选定在 [0, 1]：

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

  • 0 表示被掩码的标记。

  什么是注意力掩码？

• token_type_ids (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) — 段标记索引，指示输入的第一部分和第二部分。索引选定在 [0, 1]：

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• position_ids (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。选定范围为 [0, config.max_position_embeddings - 1]。

• head_mask (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) -- 用于使注意力模块中选定头部失效的掩码。掩码值选定在 [0, 1]：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或者一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或者当 config.return_dict=False 时）包含根据配置 (RoFormerConfig) 和输入不同元素。

• logits (jnp.ndarray，形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, FlaxRoFormerForMaskedLM

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> model = FlaxRoFormerForMaskedLM.from_pretrained("junnyu/roformer_chinese_base")

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

>>> outputs = model(**inputs)
>>> logits = outputs.logits

FlaxRoFormerForSequenceClassification

class transformers.FlaxRoFormerForSequenceClassification

< source >

( config: RoFormerConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

• config (RoFormerConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 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()。

RoFormer 模型变换器，顶部带有序列分类/回归头（汇总输出的线性层），例如用于 GLUE 任务。

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

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

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

• 即时编译（JIT）

• 自动微分

• 向量化

• 并行化

__call__

< source >

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

参数

• input_ids (numpy.ndarray of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• attention_mask (numpy.ndarray of shape (batch_size, sequence_length), 可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1]：

  • 对于未被masked的标记，值为 1，

  • 对于被masked的标记，值为 0。

  什么是注意力掩码？

• token_type_ids (numpy.ndarray of shape (batch_size, sequence_length), 可选) — 指示输入的第一部分和第二部分的段标记索引。索引选择在 [0, 1]：

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• position_ids (numpy.ndarray of shape (batch_size, sequence_length), 可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

• head_mask (numpy.ndarray of shape (batch_size, sequence_length), 可选) -- 用于使注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1]：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput 或tuple(torch.FloatTensor)

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

• logits (jnp.ndarray of shape (batch_size, config.num_labels)) — 分类（如果 config.num_labels==1 则为回归）得分（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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, FlaxRoFormerForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> model = FlaxRoFormerForSequenceClassification.from_pretrained("junnyu/roformer_chinese_base")

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

>>> outputs = model(**inputs)
>>> logits = outputs.logits

FlaxRoFormerForMultipleChoice

class transformers.FlaxRoFormerForMultipleChoice

<来源>

( config: RoFormerConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

• config（RoFormerConfig） — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 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()。

RoFormer 模型在顶部带有一个多选分类头（在汇聚输出的顶部有一个线性层和一个 SoftMax），例如用于 RocStories/SWAG 任务。

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

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

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

• 即时 (JIT) 编译

• 自动微分

• 向量化

• 并行化

__call__

< source >

( input_ids attention_mask = None token_type_ids = None head_mask = 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.FlaxMultipleChoiceModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为 (batch_size, num_choices, sequence_length) 的 numpy.ndarray）— 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

  输入 ID 是什么？

• attention_mask（形状为 (batch_size, num_choices, sequence_length) 的 numpy.ndarray，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：

  • 1 表示 未掩码 的标记，

  • 0 表示 掩码 的标记。

  注意力掩码是什么？

• token_type_ids（形状为 (batch_size, num_choices, sequence_length) 的 numpy.ndarray，可选）— 分段标记索引，指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  令牌类型 ID 是什么？

• position_ids（形状为 (batch_size, num_choices, sequence_length) 的 numpy.ndarray，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

• head_mask（形状为 (batch_size, num_choices, sequence_length) 的 numpy.ndarray，可选）-- 用于使注意力模块中选择的头部失效的掩码。掩码值在 [0, 1] 中选择：

  • 1 表示头部是 未掩码，

  • 0 表示头部是 掩码。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置（RoFormerConfig）和输入而异的各种元素。

• logits（形状为 (batch_size, num_choices) 的 jnp.ndarray）— num_choices 是输入张量的第二维度。 (参见上面的 input_ids)。

  分类得分（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 之后的注意力权重。

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

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

示例：

>>> from transformers import AutoTokenizer, FlaxRoFormerForMultipleChoice

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> model = FlaxRoFormerForMultipleChoice.from_pretrained("junnyu/roformer_chinese_base")

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

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="jax", padding=True)
>>> outputs = model(**{k: v[None, :] for k, v in encoding.items()})

>>> logits = outputs.logits

FlaxRoFormerForTokenClassification

class transformers.FlaxRoFormerForTokenClassification

<来源>

( config: RoFormerConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

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

• dtype（jax.numpy.dtype，可选，默认为jax.numpy.float32）- 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。

  这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定，所有计算将使用给定的dtype执行。

  “请注意，这仅指定计算的 dtype，不影响模型参数的 dtype。”

  如果您希望更改模型参数的 dtype，请参阅 to_fp16()和 to_bf16()。

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

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

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

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

• 即时（JIT）编译

• 自动微分

• 矢量化

• 并行化

__call__

<来源>

( input_ids attention_mask = None token_type_ids = None head_mask = 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.FlaxTokenClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的numpy.ndarray）- 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• attention_mask (numpy.ndarray，形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：

  • 1 表示未被掩盖的标记，

  • 0 表示被掩盖的标记。

  什么是注意力掩码？

• token_type_ids (numpy.ndarray，形状为(batch_size, sequence_length)，可选) — 段标记索引，用于指示输入的第一部分和第二部分。索引选择在[0, 1]中：

  • 0 对应于一个句子 A标记，

  • 1 对应于一个句子 B标记。

  什么是标记类型 ID？

• position_ids (numpy.ndarray，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

• head_mask (numpy.ndarray，形状为(batch_size, sequence_length)，可选) -- 用于使注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]`中：

  • 1 表示头部未被掩盖，

  • 0 表示头部被掩盖。

• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxTokenClassifierOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxTokenClassifierOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或当config.return_dict=False时）包括根据配置（RoFormerConfig）和输入的不同元素。

• logits (jnp.ndarray，形状为(batch_size, sequence_length, config.num_labels)) — 分类得分（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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, FlaxRoFormerForTokenClassification

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> model = FlaxRoFormerForTokenClassification.from_pretrained("junnyu/roformer_chinese_base")

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

>>> outputs = model(**inputs)
>>> logits = outputs.logits

FlaxRoFormerForQuestionAnswering

class transformers.FlaxRoFormerForQuestionAnswering

<来源>

( config: RoFormerConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

• config（RoFormerConfig）- 模型的所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 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()。

RoFormer 模型在顶部具有用于提取式问答任务（如 SQuAD）的跨度分类头（在隐藏状态输出的顶部有线性层，用于计算跨度起始对数和跨度结束对数）。

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

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

最后，此模型支持 JAX 的内在特性，例如：

• 即时（JIT）编译

• 自动微分

• 矢量化

• 并行化

__call__

<来源>

( input_ids attention_mask = None token_type_ids = None head_mask = 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.FlaxQuestionAnsweringModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的numpy.ndarray）- 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。

  输入 ID 是什么？

• attention_mask（形状为(batch_size, sequence_length)的numpy.ndarray，可选）- 避免在填充标记索引上执行注意力的掩码。选择在[0, 1]中的掩码值：

  • 1 代表未被掩盖的标记，

  • 0 代表被掩盖的标记。

  注意力掩码是什么？

• token_type_ids（形状为(batch_size, sequence_length)的numpy.ndarray，可选）- 指示输入的第一部分和第二部分的段标记索引。索引在[0, 1]中选择：

  • 0 对应于句子 A 标记，

  • 1 对应于句子 B 标记。

  令牌类型 ID 是什么？

• position_ids (numpy.ndarray of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

• head_mask (numpy.ndarray of shape (batch_size, sequence_length), optional) -- 用于使注意力模块中选择的头部失效的掩码。掩码值选在 [0, 1]`之间：

  • 1 表示头部未被掩盖，

  • 0 表示头部被掩盖。

• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或者config.return_dict=False时）包含根据配置（RoFormerConfig）和输入不同元素。

• start_logits (jnp.ndarray of shape (batch_size, sequence_length)) — Span-start scores (before SoftMax).

• end_logits (jnp.ndarray of shape (batch_size, sequence_length)) — Span-end scores (before 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, FlaxRoFormerForQuestionAnswering

>>> tokenizer = AutoTokenizer.from_pretrained("junnyu/roformer_chinese_base")
>>> model = FlaxRoFormerForQuestionAnswering.from_pretrained("junnyu/roformer_chinese_base")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="jax")

>>> outputs = model(**inputs)
>>> start_scores = outputs.start_logits
>>> end_scores = outputs.end_logits

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 = \hbox{softmax}(QK^{T} / \sqrt{d}) V$$O=softmax(QKT/d​)V

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

用其值替换 softmax 得到：$$O_{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} = e^{K_{j}} + e^{w} \hat{D}_{j})。

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

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

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

和$M_{j+1} = q$Mj+1​=q。有了这些，我们可以计算$$N_{i} = e^{u + K_{i} - q} V_{i} + e^{M_{i}} \tilde{N}$${i} \hbox{ 其中 } q = \max(u + K, 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