Transformers 4.37 中文文档（四十八）

原文：huggingface.co/docs/transformers

MVP

原文：huggingface.co/docs/transformers/v4.37.2/en/model_doc/mvp

概述

MVP 模型由唐天一、李俊毅、赵新文和文继荣在《MVP: 多任务监督预训练用于自然语言生成》中提出。

根据摘要，

• MVP 遵循标准的 Transformer 编码器-解码器架构。
• MVP 是使用标记数据集进行监督预训练的。
• MVP 还具有任务特定的软提示，以激发模型在执行特定任务时的能力。
• MVP 专为自然语言生成而设计，可适应各种生成任务，包括但不限于摘要、数据到文本生成、开放式对话系统、故事生成、问答、问题生成、任务导向对话系统、常识生成、释义生成、文本风格转换和文本简化。我们的模型也可以适应自然语言理解任务，如序列分类和（抽取式）问答。

此模型由Tianyi Tang贡献。详细信息和说明可在此处找到。

使用提示

• 我们发布了一系列模型这里，包括 MVP、具有任务特定提示的 MVP 和多任务预训练变体。
• 如果要使用没有提示的模型（标准 Transformer），可以通过MvpForConditionalGeneration.from_pretrained('RUCAIBox/mvp')加载。
• 如果要使用具有任务特定提示的模型，例如摘要，可以通过MvpForConditionalGeneration.from_pretrained('RUCAIBox/mvp-summarization')加载。
• 我们的模型支持轻量级提示调整，遵循Prefix-tuning，使用方法set_lightweight_tuning()。

使用示例

对于摘要，可以使用 MVP 和具有摘要特定提示的 MVP 作为示例。

代码语言：javascript复制

>>> from transformers import MvpTokenizer, MvpForConditionalGeneration

>>> tokenizer = MvpTokenizer.from_pretrained("RUCAIBox/mvp")
>>> model = MvpForConditionalGeneration.from_pretrained("RUCAIBox/mvp")
>>> model_with_prompt = MvpForConditionalGeneration.from_pretrained("RUCAIBox/mvp-summarization")

>>> inputs = tokenizer(
...     "Summarize: You may want to stick it to your boss and leave your job, but don't do it if these are your reasons.",
...     return_tensors="pt",
... )
>>> generated_ids = model.generate(**inputs)
>>> tokenizer.batch_decode(generated_ids, skip_special_tokens=True)
["Why You Shouldn't Quit Your Job"]

>>> generated_ids = model_with_prompt.generate(**inputs)
>>> tokenizer.batch_decode(generated_ids, skip_special_tokens=True)
["Don't do it if these are your reasons"]

对于数据到文本生成，可以使用 MVP 和多任务预训练变体作为示例。

代码语言：javascript复制

>>> from transformers import MvpTokenizerFast, MvpForConditionalGeneration

>>> tokenizer = MvpTokenizerFast.from_pretrained("RUCAIBox/mvp")
>>> model = MvpForConditionalGeneration.from_pretrained("RUCAIBox/mvp")
>>> model_with_mtl = MvpForConditionalGeneration.from_pretrained("RUCAIBox/mtl-data-to-text")

>>> inputs = tokenizer(
...     "Describe the following data: Iron Man | instance of | Superhero [SEP] Stan Lee | creator | Iron Man",
...     return_tensors="pt",
... )
>>> generated_ids = model.generate(**inputs)
>>> tokenizer.batch_decode(generated_ids, skip_special_tokens=True)
['Stan Lee created the character of Iron Man, a fictional superhero appearing in American comic']

>>> generated_ids = model_with_mtl.generate(**inputs)
>>> tokenizer.batch_decode(generated_ids, skip_special_tokens=True)
['Iron Man is a fictional superhero appearing in American comic books published by Marvel Comics.']

对于轻量级调整，即固定模型并仅调整提示，您可以加载具有随机初始化提示或具有任务特定提示的 MVP。我们的代码还支持使用 BART 进行前缀调整，遵循原始论文。

代码语言：javascript复制

>>> from transformers import MvpForConditionalGeneration

>>> model = MvpForConditionalGeneration.from_pretrained("RUCAIBox/mvp", use_prompt=True)
>>> # the number of trainable parameters (full tuning)
>>> sum(p.numel() for p in model.parameters() if p.requires_grad)
468116832

>>> # lightweight tuning with randomly initialized prompts
>>> model.set_lightweight_tuning()
>>> # the number of trainable parameters (lightweight tuning)
>>> sum(p.numel() for p in model.parameters() if p.requires_grad)
61823328

>>> # lightweight tuning with task-specific prompts
>>> model = MvpForConditionalGeneration.from_pretrained("RUCAIBox/mtl-data-to-text")
>>> model.set_lightweight_tuning()
>>> # original lightweight Prefix-tuning
>>> model = MvpForConditionalGeneration.from_pretrained("facebook/bart-large", use_prompt=True)
>>> model.set_lightweight_tuning()

资源

• 文本分类任务指南
• 问答任务指南
• 因果语言建模任务指南
• 掩码语言建模任务指南
• 翻译任务指南
• 摘要任务指南

MvpConfig

class transformers.MvpConfig

<来源>

代码语言：javascript复制

( vocab_size = 50267 max_position_embeddings = 1024 encoder_layers = 12 encoder_ffn_dim = 4096 encoder_attention_heads = 16 decoder_layers = 12 decoder_ffn_dim = 4096 decoder_attention_heads = 16 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 activation_function = 'gelu' d_model = 1024 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 classifier_dropout = 0.0 scale_embedding = False use_cache = True pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 is_encoder_decoder = True decoder_start_token_id = 2 forced_eos_token_id = 2 use_prompt = False prompt_length = 100 prompt_mid_dim = 800 **kwargs )

参数

• vocab_size（int，可选，默认为 50267）- MVP 模型的词汇量。定义了在调用 MvpModel 时可以表示的不同标记数量。
• d_model（int，可选，默认为 1024）- 层和池化层的维度。
• encoder_layers（int，可选，默认为 12）- 编码器层数。
• decoder_layers（int，可选，默认为 12）- 解码器层数。
• encoder_attention_heads（int，可选，默认为 16）- Transformer 编码器中每个注意力层的注意力头数。
• decoder_attention_heads（int，可选，默认为 16）- Transformer 解码器中每个注意力层的注意力头数。
• decoder_ffn_dim（int，可选，默认为 4096）- 解码器中“中间”（通常称为前馈）层的维度。
• encoder_ffn_dim (int, optional, defaults to 4096) — 解码器中“中间”（通常称为前馈）层的维度。
• activation_function (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。
• dropout (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
• attention_dropout (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。
• activation_dropout (float, optional, defaults to 0.0) — 全连接层内激活的 dropout 比率。
• classifier_dropout (float, optional, defaults to 0.0) — 分类器的 dropout 比率。
• max_position_embeddings (int, optional, defaults to 1024) — 此模型可能使用的最大序列长度。通常设置为较大的值以防万一（例如，512 或 1024 或 2048）。
• init_std (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• encoder_layerdrop (float, optional, defaults to 0.0) — 编码器的 LayerDrop 概率。更多细节请参阅 LayerDrop paper)。
• decoder_layerdrop (float, optional, defaults to 0.0) — 解码器的 LayerDrop 概率。更多细节请参阅 LayerDrop paper)。
• scale_embedding (bool, optional, defaults to False) — 通过 sqrt(d_model)缩放嵌入。
• use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。
• forced_eos_token_id (int, optional, defaults to 2) — 当达到max_length时，强制作为最后生成的 token 的 id。通常设置为eos_token_id。
• use_prompt (bool, optional, defaults to False) — 是否使用 prompt。
• prompt_length (int, optional, defaults to 100) — prompt 的长度。
• prompt_mid_dim (int, optional, defaults to 800) — prompt 中“中间”层的维度。

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

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

示例：

代码语言：javascript复制

>>> from transformers import MvpConfig, MvpModel

>>> # Initializing a MVP RUCAIBox/mvp style configuration
>>> configuration = MvpConfig()

>>> # Initializing a model (with random weights) from the RUCAIBox/mvp style configuration
>>> model = MvpModel(configuration)

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

MvpTokenizer

class transformers.MvpTokenizer

< source >

代码语言：javascript复制

( vocab_file merges_file errors = 'replace' bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' add_prefix_space = False **kwargs )

参数

• vocab_file (str) — 词汇文件的路径。
• merges_file (str) — 合并文件的路径。
• errors (str, optional, defaults to "replace") — 解码字节为 UTF-8 时要遵循的范例。更多信息请参阅bytes.decode。
• bos_token (str, optional, defaults to "<s>") — 在预训练期间使用的序列开始 token。可以用作序列分类器 token。 构建序列时使用特殊 token 时，这不是用于序列开头的 token。用于开头的 token 是cls_token。
• eos_token (str, optional, defaults to "</s>") — 序列结束标记。 在使用特殊标记构建序列时，这不是用于序列结尾的标记。使用的标记是sep_token。
• sep_token (str, optional, defaults to "</s>") — 分隔符标记，在从多个序列构建序列时使用，例如用于序列分类的两个序列或用于文本和问题的问题回答。它也用作使用特殊标记构建的序列的最后一个标记。
• cls_token (str, optional, defaults to "<s>") — 用于序列分类（整个序列而不是每个标记的分类）时使用的分类器标记。当使用特殊标记构建序列时，它是序列的第一个标记。
• unk_token (str, optional, defaults to "<unk>") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。
• pad_token (str, optional, defaults to "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时使用。
• mask_token (str, optional, defaults to "<mask>") — 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
• add_prefix_space (bool, optional, defaults to False) — 是否在输入前添加一个初始空格。这允许将前导单词视为任何其他单词。（MVP 标记器通过前面的空格检测单词的开头）。

构建一个 MVP 标记器，类似于 RoBERTa 标记器，使用字节级字节对编码。

此标记器已经训练成将空格视为标记的一部分（有点像 sentencepiece），因此一个单词将

在句子开头（无空格）或不在句子开头时，将以不同方式编码：

代码语言：javascript复制

>>> from transformers import MvpTokenizer

>>> tokenizer = MvpTokenizer.from_pretrained("RUCAIBox/mvp")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]

>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]

您可以通过在实例化此标记器时或在对某些文本调用它时传递add_prefix_space=True来避免这种行为，但由于模型不是以这种方式进行预训练的，因此可能会导致性能下降。

当与is_split_into_words=True一起使用时，此标记器将在每个单词之前添加一个空格（甚至是第一个单词）。

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

build_inputs_with_special_tokens

<来源>

代码语言：javascript复制

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

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

• 单个序列：<s> X </s>
• 序列对：<s> A </s></s> B </s>

convert_tokens_to_string

<来源>

代码语言：javascript复制

( tokens )

将标记序列（字符串）转换为单个字符串。

create_token_type_ids_from_sequences

<来源>

代码语言：javascript复制

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

零列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。MVP 不使用标记类型 ID，因此返回一个零列表。

get_special_tokens_mask

< source >

代码语言：javascript复制

( 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方法添加特殊标记时调用此方法。

MvpTokenizerFast

class transformers.MvpTokenizerFast

< source >

代码语言：javascript复制

( vocab_file = None merges_file = None tokenizer_file = None errors = 'replace' bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' add_prefix_space = False trim_offsets = True **kwargs )

参数

• vocab_file (str) — 词汇表文件的路径。
• merges_file (str) — 合并文件的路径。
• errors (str, 可选, 默认为 "replace") — 解码字节为 UTF-8 时要遵循的范例。有关更多信息，请参阅bytes.decode。
• bos_token (str, 可选, 默认为 "<s>") — 在预训练期间使用的序列开头标记。可用作序列分类器标记。 构建序列时使用特殊标记时，这不是用于序列开头的标记。使用的标记是cls_token。
• eos_token (str, 可选, 默认为 "</s>") — 序列结束标记。 在使用特殊标记构建序列时，这不是用于序列结尾的标记。使用的标记是sep_token。
• sep_token (str, 可选, 默认为 "</s>") — 分隔符标记，在从多个序列构建序列时使用，例如用于序列分类的两个序列或用于问题回答的文本和问题。它还用作使用特殊标记构建的序列的最后一个标记。
• cls_token (str, 可选, 默认为 "<s>") — 分类器标记，用于进行序列分类（对整个序列进行分类而不是对每个标记进行分类）。在使用特殊标记构建时，它是序列的第一个标记。
• unk_token (str, 可选, 默认为 "<unk>") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。
• pad_token (str, 可选, 默认为 "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时。
• mask_token (str, 可选, 默认为 "<mask>") — 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
• add_prefix_space (bool, 可选, 默认为 False) — 是否在输入前添加一个初始空格。这允许将前导单词视为任何其他单词。（MVP tokenizer 通过前面的空格检测单词的开头）。
• trim_offsets (bool, 可选, 默认为 True) — 后处理步骤是否应修剪偏移量以避免包含空格。

构建一个“快速”MVP tokenizer（由 HuggingFace 的tokenizers库支持），源自 GPT-2 tokenizer，使用字节级别的字节对编码。

此 tokenizer 已经训练成将空格视为标记的一部分（有点像 sentencepiece），因此一个单词将

在句子开头（无空格）或不在句子开头时，将以不同方式编码：

代码语言：javascript复制

>>> from transformers import MvpTokenizerFast

>>> tokenizer = MvpTokenizerFast.from_pretrained("RUCAIBox/mvp")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]

>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]

您可以通过在实例化此 tokenizer 时或在对某些文本调用它时传递add_prefix_space=True来避免该行为，但由于模型不是以这种方式进行预训练的，因此可能会降低性能。

当与is_split_into_words=True一起使用时，需要使用add_prefix_space=True来实例化此 tokenizer。

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

create_token_type_ids_from_sequences

<来源>

代码语言：javascript复制

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

零的列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。MVP 不使用标记类型 id，因此返回一个零的列表。

MvpModel

class transformers.MvpModel

<来源>

代码语言：javascript复制

( config: MvpConfig )

参数

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

裸 MVP 模型输出原始隐藏状态，没有特定的头部。此模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

代码语言：javascript复制

( input_ids: LongTensor = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: 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.Seq2SeqModelOutput 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.Tensor，可选）— 避免在填充标记索引上执行注意力的掩码。在[0, 1]中选择的掩码值：
  • 对于未屏蔽的标记为 1，
  • 对于被屏蔽的标记为 0。

  注意力掩码是什么？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 解码器输入序列标记在词汇表中的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 解码器输入 ID 是什么？ Mvp 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则可以选择仅输入最后的decoder_input_ids（请参阅past_key_values）。 对于翻译和摘要训练，应提供decoder_input_ids。如果未提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，以用于去噪预训练。
• decoder_attention_mask（torch.LongTensor，形状为(batch_size, target_sequence_length)，可选）— 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。 如果您想要更改填充行为，您应该阅读modeling_mvp._prepare_decoder_attention_mask并根据您的需求进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。
• head_mask（torch.Tensor，形状为(encoder_layers, encoder_attention_heads)，可选）— 用于在编码器的注意力模块中使特定头部失效的掩码。掩码值选在[0, 1]之间：
  • 1 表示头部未被屏蔽，
  • 0 表示头部被屏蔽。
• decoder_head_mask（torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选）— 用于在解码器的注意力模块中使特定头部失效的掩码。掩码值选在[0, 1]之间：
  • 1 表示头部未被屏蔽，
  • 0 表示头部被屏蔽。
• cross_attn_head_mask（torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选）— 用于在解码器中使交叉注意力模块中的特定头部失效的掩码。掩码值选在[0, 1]之间：
  • 1 表示头部未被屏蔽，
  • 0 表示头部被屏蔽。
• encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）— 元组由(last_hidden_state，可选：hidden_states，可选：attentions) 组成，last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递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输入）。 如果使用了past_key_values，用户可以选择仅输入最后的decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
• inputs_embeds（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
• decoder_inputs_embeds（torch.FloatTensor，形状为(batch_size, target_sequence_length, hidden_size)，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。如果使用了past_key_values，则可以选择仅输入最后的decoder_inputs_embeds（请参阅past_key_values）。如果您希望更多地控制如何将decoder_input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。 如果decoder_input_ids和decoder_inputs_embeds都未设置，则decoder_inputs_embeds将取inputs_embeds的值。
• use_cache（bool，可选）— 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.Seq2SeqModelOutput 或torch.FloatTensor元组

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

• 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)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。 包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。
• decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的一个 每层输出的一个）。 解码器每层输出的隐藏状态加上可选的初始嵌入输出。
• decoder_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.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
• encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层的隐藏状态序列。
• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的一个 每层输出的一个）。 编码器在每一层的隐藏状态加上可选的初始嵌入输出。
• encoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, MvpModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("RUCAIBox/mvp")
>>> model = MvpModel.from_pretrained("RUCAIBox/mvp")

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

>>> last_hidden_states = outputs.last_hidden_state

MvpForConditionalGeneration

class transformers.MvpForConditionalGeneration

<来源>

代码语言：javascript复制

( config: MvpConfig )

参数

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

具有语言建模头的 MVP 模型。 可用于各种文本生成任务。 该模型继承自 PreTrainedModel。 检查超类文档以获取库为所有模型实现的通用方法（例如下载或保存，调整输入嵌入，修剪头等）。

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

forward

<来源>

代码语言：javascript复制

( input_ids: LongTensor = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: 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.Seq2SeqLMOutput 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.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。 选择在[0, 1]中的掩码值：
  • 1 表示未被掩码的标记，
  • 0 表示被掩码的标记。

  注意力掩码是什么？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 词汇表中解码器输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 解码器输入 ID 是什么？ Mvp 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则可以选择仅输入最后的decoder_input_ids（请参阅past_key_values）。 对于翻译和摘要训练，应提供decoder_input_ids。如果未提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，以用于去噪预训练，遵循论文中的默认策略。
• decoder_attention_mask (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。 如果要更改填充行为，您应该阅读modeling_mvp._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。
• head_mask (torch.Tensor of shape (encoder_layers, encoder_attention_heads), optional) — 用于使编码器中注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]中：
  • 1 表示头部未被masked。
  • 0 表示头部被masked。
• decoder_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于使解码器中注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]中：
  • 1 表示头部未被masked。
  • 0 表示头部被masked。
• cross_attn_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于使解码器中交叉注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]中：
  • 1 表示头部未被masked。
  • 0 表示头部被masked。
• encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — 元组包括(last_hidden_state, optional: hidden_states, optional: attentions) last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，optional) 是编码器最后一层输出的隐藏状态序列。在解码器的交叉注意力中使用。
• 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输入）。 如果使用past_key_values，用户可以选择仅输入形状为(batch_size, 1)的最后的decoder_input_ids（这些没有将它们的过去键值状态提供给此模型）而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权，以便将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• decoder_inputs_embeds (torch.FloatTensor of shape (batch_size, target_sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。如果使用past_key_values，则可以选择仅输入最后的decoder_inputs_embeds（请参阅past_key_values）。如果您想要更多控制权，以便将decoder_input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。 如果decoder_input_ids和decoder_inputs_embeds都未设置，则decoder_inputs_embeds取inputs_embeds的值。
• use_cache（bool，可选）— 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（请参见past_key_values）。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。
• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]范围内，或者为-100（请参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]范围内的标记。

返回

transformers.modeling_outputs.Seq2SeqLMOutput 或torch.FloatTensor元组。

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

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 语言建模损失。
• logits（形状为(batch_size, sequence_length, config.vocab_size)的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)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。 包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（请参见past_key_values输入）。
• decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组，包括每个层的嵌入输出（如果模型有嵌入层） 每个层的输出。 解码器在每个层的输出以及初始嵌入输出的隐藏状态。
• decoder_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 之后，用于计算交叉注意力头中的加权平均值。
• encoder_last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选） — 模型编码器最后一层的隐藏状态序列。
• encoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，如果模型有一个嵌入层， 一个用于每一层的输出）。 每层编码器的隐藏状态以及初始嵌入输出。
• encoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

摘要示例：

微调模型

代码语言：javascript复制

>>> import torch
>>> from transformers import AutoTokenizer, MvpForConditionalGeneration

>>> tokenizer = AutoTokenizer.from_pretrained("RUCAIBox/mvp")
>>> model = MvpForConditionalGeneration.from_pretrained("RUCAIBox/mvp")

>>> inputs = tokenizer(
...     "Summarize: You may want to stick it to your boss and leave your job, but don't do it if these are your reasons.",
...     return_tensors="pt",
... )
>>> labels = tokenizer("Bad Reasons To Quit Your Job", return_tensors="pt")["input_ids"]

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

模型微调后的推断

代码语言：javascript复制

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

>>> generated_text = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)

MvpForSequenceClassification

class transformers.MvpForSequenceClassification

<来源>

代码语言：javascript复制

( config: MvpConfig **kwargs )

参数

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

在顶部具有序列分类/头的 Mvp 模型（在汇总输出的顶部有一个线性层），例如用于 GLUE 任务。

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

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

forward

<来源>

代码语言：javascript复制

( input_ids: LongTensor = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: 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？
• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选） — 避免对填充标记索引执行注意力的蒙版。蒙版值选在[0, 1]之间：
  • 对于未被“masked”的标记，为 1，
  • 对于被masked的标记，为 0。

  什么是注意力蒙版？

• decoder_input_ids（形状为 (batch_size, target_sequence_length) 的 torch.LongTensor，可选）— 词汇表中解码器输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是解码器输入 ID？ Mvp 使用 eos_token_id 作为 decoder_input_ids 生成的起始标记。如果使用了 past_key_values，可以选择仅输入最后的 decoder_input_ids（请参见 past_key_values）。 对于翻译和摘要训练，应提供 decoder_input_ids。如果未提供 decoder_input_ids，模型将通过将 input_ids 向右移动来创建此张量，以用于去噪预训练，遵循论文中的方法。
• decoder_attention_mask（形状为 (batch_size, target_sequence_length) 的 torch.LongTensor，可选）— 默认行为：生成一个张量，忽略解码器输入中的填充标记。因果掩码也将默认使用。 如果您想要更改填充行为，您应该阅读 modeling_mvp._prepare_decoder_attention_mask 并根据您的需求进行修改。有关默认策略的更多信息，请参见论文中的图表 1。
• head_mask（形状为 (encoder_layers, encoder_attention_heads) 的 torch.Tensor，可选）— 用于使编码器中的注意力模块中的选定头部失效的掩码。掩码值选定在 [0, 1] 中：
  • 1 表示头部未被“掩盖”，
  • 0 表示头部被“掩盖”。
• decoder_head_mask（形状为 (decoder_layers, decoder_attention_heads) 的 torch.Tensor，可选）— 用于使解码器中的注意力模块中的选定头部失效的掩码。掩码值选定在 [0, 1] 中：
  • 1 表示头部未被“掩盖”，
  • 0 表示头部被“掩盖”。
• cross_attn_head_mask（形状为 (decoder_layers, decoder_attention_heads) 的 torch.Tensor，可选）— 用于使解码器中的交叉注意力模块中的选定头部失效的掩码。掩码值选定在 [0, 1] 中：
  • 1 表示头部未被“掩盖”，
  • 0 表示头部被“掩盖”。
• encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）— 元组包括 (last_hidden_state，可选：hidden_states，可选：attentions) last_hidden_state 的形状为 (batch_size, sequence_length, 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) 的张量和 2 个额外的形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的张量。 包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（请参见 past_key_values 输入）。 如果使用了 past_key_values，用户可以选择仅输入最后的 decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）的形状为 (batch_size, 1) 的张量，而不是形状为 (batch_size, sequence_length) 的所有 decoder_input_ids。
• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
• decoder_inputs_embeds (torch.FloatTensor，形状为(batch_size, target_sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。如果使用past_key_values，则可能只需输入最后的decoder_inputs_embeds（请参阅past_key_values）。如果您想要更多控制如何将decoder_input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。 如果decoder_input_ids和decoder_inputs_embeds都未设置，则decoder_inputs_embeds取inputs_embeds的值。
• use_cache (bool, 可选) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。
• 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，则计算分类损失（交叉熵）。

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

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

单标签分类示例：

在num_labels类上微调模型

代码语言：javascript复制

>>> import torch
>>> from transformers import AutoTokenizer, MvpForSequenceClassification

>>> num_labels = 2  # for example, this is a binary classification task
>>> tokenizer = AutoTokenizer.from_pretrained("RUCAIBox/mvp")
>>> model = MvpForSequenceClassification.from_pretrained("RUCAIBox/mvp", num_labels=num_labels)

>>> inputs = tokenizer("Classify: Hello, my dog is cute", return_tensors="pt")
>>> labels = torch.tensor(1)  # the real label for inputs

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

在模型微调后进行推理

代码语言：javascript复制

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

>>> predicted_class_id = logits.argmax()

MvpForQuestionAnswering

class transformers.MvpForQuestionAnswering

<来源>

代码语言：javascript复制

( config )

参数

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

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

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

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

forward

<来源>

代码语言：javascript复制

( input_ids: Tensor = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None start_positions: Optional = None end_positions: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None use_cache: 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？
• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）— 用于避免在填充令牌索引上执行注意力的遮罩。遮罩值在[0, 1]中选择：
  • 1 表示令牌未被遮罩，
  • 0 表示被遮罩的令牌。

  什么是注意力遮罩？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 解码器输入序列标记在词汇表中的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是解码器输入 ID？ Mvp 使用eos_token_id作为decoder_input_ids生成的起始令牌。如果使用past_key_values，则只需选择最后的decoder_input_ids作为输入（参见past_key_values）。 对于翻译和摘要训练，应提供decoder_input_ids。如果未提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，以进行去噪预训练，遵循论文。
• decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 默认行为：生成一个忽略decoder_input_ids中填充令牌的张量。因果遮罩也将默认使用。 如果要更改填充行为，应阅读modeling_mvp._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。
• head_mask（形状为(encoder_layers, encoder_attention_heads)的torch.Tensor，可选）— 用于在编码器中使注意力模块的选定头部失效的遮罩。遮罩值在[0, 1]中选择：
  • 1 表示头部未被遮罩，
  • 0 表示头部被遮罩。
• decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于在解码器中使注意力模块的选定头部失效的遮罩。遮罩值在[0, 1]中选择：
  • 1 表示头部未被遮罩，
  • 0 表示头部被遮罩。
• cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于在解码器中使交叉注意力模块的选定头部失效的遮罩。遮罩值在[0, 1]中选择：
  • 1 表示头部未被遮罩，
  • 0 表示头部被遮罩。
• encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）— 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, 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)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。 包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。 如果使用了past_key_values，用户可以选择仅输入最后一个形状为(batch_size, 1)的decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的输入）而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。
• decoder_inputs_embeds (torch.FloatTensor，形状为(batch_size, target_sequence_length, hidden_size)，optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。如果使用了past_key_values，则可以选择仅输入最后一个decoder_inputs_embeds（参见past_key_values）。如果您想要更多控制如何将decoder_input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。 如果decoder_input_ids和decoder_inputs_embeds都未设置，则decoder_inputs_embeds取inputs_embeds的值。
• use_cache (bool, optional) — 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的attentions。
• output_hidden_states (bool，optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的hidden_states。
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。
• start_positions (torch.LongTensor，形状为(batch_size,)，optional) — 用于计算标记跨度开始位置的位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。超出序列范围的位置不会被考虑在内计算损失。
• end_positions (torch.LongTensor，形状为(batch_size,)，optional) — 用于计算标记跨度结束位置的位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。超出序列范围的位置不会被考虑在内计算损失。

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

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

示例：

对于抽取式问答模型进行微调，我们的模型还支持使用BartForConditionalGeneration进行生成式问答。

代码语言：javascript复制

>>> import torch
>>> from transformers import AutoTokenizer, MvpForQuestionAnswering

>>> tokenizer = AutoTokenizer.from_pretrained("RUCAIBox/mvp")
>>> model = MvpForQuestionAnswering.from_pretrained("RUCAIBox/mvp")

>>> inputs = tokenizer(
...     "Answer the following question: Who was Jim Henson? [SEP] Jim Henson was a nice puppet",
...     return_tensors="pt",
... )
>>> target_start_index = torch.tensor([18])
>>> target_end_index = torch.tensor([19])

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

在模型微调后进行推理

代码语言：javascript复制

>>> 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]
>>> predict_answer = tokenizer.decode(predict_answer_tokens)

MvpForCausalLM

class transformers.MvpForCausalLM

<来源>

代码语言：javascript复制

( config )

前向

<来源>

代码语言：javascript复制

( input_ids: LongTensor = None attention_mask: 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 inputs_embeds: 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（形状为(batch_size, sequence_length)的torch.Tensor，可选）- 用于避免在填充标记索引上执行注意力。在[0, 1]中选择的掩码值：
  • 1 表示未被掩盖的标记，
  • 0 表示被掩盖的标记。

  什么是注意力掩码？

• encoder_hidden_states（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。
• encoder_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 用于避免在编码器输入的填充标记索引上执行注意力。如果模型配置为解码器，则在交叉注意力中使用此掩码。在[0, 1]中选择的掩码值：
• head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）- 用于使注意力模块的选定头部失效的掩码。在[0, 1]中选择的掩码值：
  • 1 表示头部未被掩盖，
  • 0 表示头部被掩盖。
• cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）- 用于使交叉注意力模块的选定头部失效的掩码。在[0, 1]中选择的掩码值：
  • 1 表示头部未被掩盖，
  • 0 表示头部被掩盖。
• 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)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。当模型用作序列到序列模型中的解码器时，只有在需要时才需要这两个额外的张量。 包含预先计算的隐藏状态（自注意块和交叉注意块中的键和值），可用于加速顺序解码（请参见past_key_values输入）。 如果使用past_key_values，用户可以选择性地仅输入最后一个形状为(batch_size, 1)的decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的）而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]或-100（参见input_ids文档字符串）。将索引设置为-100的标记将被忽略（掩盖），损失仅计算具有[0, ..., config.vocab_size]标签的标记。
• use_cache（bool，可选）- 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
  • 1 表示未被掩盖的标记，
  • 0 表示被掩盖的标记。
• output_attentions (bool，optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict (bool，optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或torch.FloatTensor元组

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

• loss (torch.FloatTensor，形状为(1,)，optional，当提供labels时返回） — 语言建模损失（用于下一个标记预测）。
• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)） — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• hidden_states (tuple(torch.FloatTensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的一个 每层输出的一个）。 模型在每一层输出时的隐藏状态以及可选的初始嵌入输出。
• attentions (tuple(torch.FloatTensor)，optional，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
• cross_attentions (tuple(torch.FloatTensor)，optional，当传递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))，optional，当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的torch.FloatTensor元组的元组，每个元组包含自注意力和交叉注意力层的缓存键、值状态，如果模型用于编码器-解码器设置，则相关。仅在config.is_decoder = True时相关。 包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码。

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, MvpForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("RUCAIBox/mvp")
>>> model = MvpForCausalLM.from_pretrained("RUCAIBox/mvp", add_cross_attention=False)

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

>>> logits = outputs.logits
>>> list(logits.shape)
[1, 8, 50267]

Nezha

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

概述

Nezha 模型是由魏俊秋等人在NEZHA: Neural Contextualized Representation for Chinese Language Understanding中提出的。

论文摘要如下：

预训练语言模型在各种自然语言理解（NLU）任务中取得了巨大成功，因为它能够通过在大规模语料库上进行预训练来捕捉文本中的深层上下文信息。在这份技术报告中，我们介绍了我们在中文语料库上预训练语言模型 NEZHA（NEural contextualiZed representation for CHinese lAnguage understanding）的实践，并为中文 NLU 任务进行微调。当前版本的 NEZHA 基于 BERT，并包含一系列经过验证的改进，包括功能相对位置编码作为有效的位置编码方案、整词遮盖策略、混合精度训练和 LAMB 优化器用于训练模型。实验结果表明，NEZHA 在微调几个代表性的中文任务（包括命名实体识别（人民日报 NER）、句子匹配（LCQMC）、中文情感分类（ChnSenti）和自然语言推理（XNLI））时取得了最先进的性能。

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

资源

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

NezhaConfig

class transformers.NezhaConfig

<来源>

代码语言：javascript复制

( vocab_size = 21128 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 max_relative_position = 64 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 classifier_dropout = 0.1 pad_token_id = 0 bos_token_id = 2 eos_token_id = 3 use_cache = True **kwargs )

参数

• vocab_size (int, optional, defaults to 21128) — NEZHA 模型的词汇表大小。定义了可以由传递给 NezhaModel 的inputs_ids表示的不同标记。
• 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”) — 编码器和池化器中的非线性激活函数（函数或字符串）。
• hidden_dropout_prob (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
• attention_probs_dropout_prob (float, optional, defaults to 0.1) — 注意力概率的 dropout 比率。
• max_position_embeddings (int, optional, defaults to 512) — 该模型可能会使用的最大序列长度。通常将其设置为较大的值（例如 512、1024 或 2048）。
• type_vocab_size (int, optional, defaults to 2) — 传递给 NezhaModel 的token_type_ids的词汇表大小。
• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps（float，可选，默认为 1e-12）—层归一化层使用的 epsilon。
• classifier_dropout（float，可选，默认为 0.1）—附加分类器的丢失比率。
• is_decoder（bool，可选，默认为False）—模型是否用作解码器。如果为False，则模型用作编码器。

这是用于存储 NezhaModel 配置的配置类。根据指定的参数实例化 Nezha 模型，定义模型架构。使用默认值实例化配置将产生类似于 Nezha sijunhe/nezha-cn-base架构的配置。

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

示例：

代码语言：javascript复制

>>> from transformers import NezhaConfig, NezhaModel

>>> # Initializing an Nezha configuration
>>> configuration = NezhaConfig()

>>> # Initializing a model (with random weights) from the Nezha-base style configuration model
>>> model = NezhaModel(configuration)

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

NezhaModel

class transformers.NezhaModel

<来源>

代码语言：javascript复制

( config add_pooling_layer = True )

参数

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

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

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

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

该模型可以作为编码器（仅具有自注意力）或解码器，此时在自注意力层之间添加了一层交叉注意力，遵循Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser 和 Illia Polosukhin 在《Attention is all you need》中描述的架构。

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

forward

<来源>

代码语言：javascript复制

( 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.BaseModelOutputWithPoolingAndCrossAttentions 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] 之间：
  • 对于未被masked的标记为 1，
  • 对于被masked的标记为 0。

  什么是注意力掩码？

• 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，
  • 对于被masked的头部为 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) — 用于避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用。掩码值在 [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.BaseModelOutputWithPoolingAndCrossAttentions 或 tuple(torch.FloatTensor)

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

• 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输入）。

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

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

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, NezhaModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("sijunhe/nezha-cn-base")
>>> model = NezhaModel.from_pretrained("sijunhe/nezha-cn-base")

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

>>> last_hidden_states = outputs.last_hidden_state

NezhaForPreTraining

class transformers.NezhaForPreTraining

<来源>

代码语言：javascript复制

( config )

参数

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

Nezha 模型在预训练期间顶部有两个头部：一个掩码语言建模头部和一个下一个句子预测（分类）头部。

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

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

forward

<来源>

代码语言：javascript复制

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None next_sentence_label: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.nezha.modeling_nezha.NezhaForPreTrainingOutput 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的标记，
  • 0 表示被 masked的标记。

  什么是注意力掩码？

• 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 表示头部未被 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 而不是普通元组。 标签（形状为(batch_size, sequence_length)的torch.LongTensor，可选）：用于计算被 masked 语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]内（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（masked），损失仅计算具有标签在[0, ..., config.vocab_size]内的标记。next_sentence_label（形状为(batch_size,)的torch.LongTensor，可选）：用于计算下一个序列预测（分类）损失的标签。输入应为一个序列对（参见input_ids文档字符串）。索引应在[0, 1]内：
  • 0 表示序列 B 是序列 A 的延续，
  • 1 表示序列 B 是一个随机序列。kwargs（Dict[str, any]，可选，默认为*{}*）：用于隐藏已被弃用的旧参数。

返回

transformers.models.nezha.modeling_nezha.NezhaForPreTrainingOutput或tuple(torch.FloatTensor)

一个transformers.models.nezha.modeling_nezha.NezhaForPreTrainingOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含根据配置（NezhaConfig）和输入不同元素。

• loss (optional, 当提供labels时返回，形状为(1,)的torch.FloatTensor) — 总损失，作为掩码语言建模损失和下一个序列预测（分类）损失的总和。
• prediction_logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• seq_relationship_logits (torch.FloatTensor，形状为(batch_size, 2)) — 下一个序列预测（分类）头的预测分数（SoftMax 之前的 True/False 连续性分数）。
• 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, NezhaForPreTraining
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("sijunhe/nezha-cn-base")
>>> model = NezhaForPreTraining.from_pretrained("sijunhe/nezha-cn-base")

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

>>> prediction_logits = outputs.prediction_logits
>>> seq_relationship_logits = outputs.seq_relationship_logits

NezhaForMaskedLM

class transformers.NezhaForMaskedLM

<来源>

代码语言：javascript复制

( config )

参数

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

在顶部具有语言建模头的 Nezha 模型。

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

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

forward

<来源>

代码语言：javascript复制

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

  什么是注意力掩码？

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

  什么是标记类型 ID？

• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：
  • 1 表示头部未被掩码，
  • 0 表示头部被掩码。
• inputs_embeds (torch.FloatTensor，形状为(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，形状为(batch_size, sequence_length)，optional) — 用于计算掩码语言建模损失的标签。索引应在[-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时）包含根据配置（NezhaConfig）和输入的各种元素。

• loss (torch.FloatTensor，形状为(1,)，optional，当提供labels时返回) — 掩码语言建模（MLM）损失。
• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出 每一层的输出）。 模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 在自注意力头中使用注意力 softmax 后的注意力权重，用于计算加权平均值。

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

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

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, NezhaForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("sijunhe/nezha-cn-base")
>>> model = NezhaForMaskedLM.from_pretrained("sijunhe/nezha-cn-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)

NezhaForNextSentencePrediction

class transformers.NezhaForNextSentencePrediction

< source >

代码语言：javascript复制

( config )

参数

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

Nezha 模型在顶部有一个下一句预测（分类）头。

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

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

forward

< source >

代码语言：javascript复制

( 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 **kwargs ) → export const metadata = 'undefined';transformers.modeling_outputs.NextSentencePredictorOutput 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), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：
  • 1 用于未屏蔽的标记，
  • 0 用于屏蔽的标记。

  什么是注意力掩码？

• 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 表示头部是未屏蔽，
  • 0 表示头部是屏蔽。
• inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，可以直接传递嵌入表示而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
• return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
• labels (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算下一个序列预测（分类）损失的标签。输入应该是一个序列对（参见 input_ids 文档字符串）。索引应该在 [0, 1] 范围内：
  • 0 表示序列 B 是序列 A 的继续，
  • 1 表示序列 B 是一个随机序列。

返回

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

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

• loss (torch.FloatTensor，形状为 (1,)，可选，当提供 next_sentence_label 时返回) — 下一个序列预测（分类）损失。
• logits (torch.FloatTensor，形状为 (batch_size, 2)) — 下一个序列预测（分类）头的预测分数（在 SoftMax 之前的 True/False 继续分数）。
• 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, NezhaForNextSentencePrediction
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("sijunhe/nezha-cn-base")
>>> model = NezhaForNextSentencePrediction.from_pretrained("sijunhe/nezha-cn-base")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> next_sentence = "The sky is blue due to the shorter wavelength of blue light."
>>> encoding = tokenizer(prompt, next_sentence, return_tensors="pt")

>>> outputs = model(**encoding, labels=torch.LongTensor([1]))
>>> logits = outputs.logits
>>> assert logits[0, 0] < logits[0, 1]  # next sentence was random

NezhaForSequenceClassification

class transformers.NezhaForSequenceClassification

< source >

代码语言：javascript复制

( config )

参数

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

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

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

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

forward

<来源>

代码语言：javascript复制

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

返回

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

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

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

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

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

单标签分类示例：

代码语言：javascript复制

>>> import torch
>>> from transformers import AutoTokenizer, NezhaForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("sijunhe/nezha-cn-base")
>>> model = NezhaForSequenceClassification.from_pretrained("sijunhe/nezha-cn-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 = NezhaForSequenceClassification.from_pretrained("sijunhe/nezha-cn-base", num_labels=num_labels)

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

多标签分类示例：

代码语言：javascript复制

>>> import torch
>>> from transformers import AutoTokenizer, NezhaForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("sijunhe/nezha-cn-base")
>>> model = NezhaForSequenceClassification.from_pretrained("sijunhe/nezha-cn-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 = NezhaForSequenceClassification.from_pretrained(
...     "sijunhe/nezha-cn-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

NezhaForMultipleChoice

class transformers.NezhaForMultipleChoice

<来源>

代码语言：javascript复制

( config )

参数

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

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

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

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

forward

<来源>

代码语言：javascript复制

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

  什么是注意力掩码？

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

  什么是 token type IDs？

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

返回

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

一个 transformers.modeling_outputs.MultipleChoiceModelOutput 或者一个torch.FloatTensor的元组（如果传递了return_dict=False或者config.return_dict=False时）包含不同的元素，取决于配置（NezhaConfig）和输入。

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

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

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

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, NezhaForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("sijunhe/nezha-cn-base")
>>> model = NezhaForMultipleChoice.from_pretrained("sijunhe/nezha-cn-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

NezhaForTokenClassification

class transformers.NezhaForTokenClassification

<来源>

代码语言：javascript复制

( config )

参数

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

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

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

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

forward

<来源>

代码语言：javascript复制

( 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()。 什么是输入 ID？
• attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 避免在填充令牌索引上执行注意力的掩码。掩码值选择在 [0, 1] 中：
  • 1 代表未被masked的令牌，
  • 0 代表被masked的令牌。

  什么是注意力掩码？

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

  什么是令牌类型 ID？

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

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

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

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

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, NezhaForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("sijunhe/nezha-cn-base")
>>> model = NezhaForTokenClassification.from_pretrained("sijunhe/nezha-cn-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

NezhaForQuestionAnswering

class transformers.NezhaForQuestionAnswering

<来源>

代码语言：javascript复制

( config )

参数

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

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

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

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

forward

< source >

代码语言：javascript复制

( 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), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：
  • 1 用于未被遮蔽的标记，
  • 0 用于被遮蔽的标记。

  什么是注意力掩码？

• 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 表示头部未被遮蔽，
  • 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,), 可选) — 用于计算标记跨度开始位置的位置（索引）标签。位置被夹紧到序列的长度 (sequence_length)。序列外的位置不会被考虑在内计算损失。
• end_positions (torch.LongTensor of shape (batch_size,), 可选) — 用于计算标记跨度结束位置的位置（索引）标签。位置被夹紧到序列的长度 (sequence_length)。序列外的位置不会被考虑在内计算损失。

返回

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

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

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

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

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

例如：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, NezhaForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("sijunhe/nezha-cn-base")
>>> model = NezhaForQuestionAnswering.from_pretrained("sijunhe/nezha-cn-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

torch 模型 配置 索引 size

0 人点赞