Transformers 4.37 中文文档（四十九）

2024-06-26 16:31:53 浏览数 (1)

原文：huggingface.co/docs/transformers

NLLB

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

更新的分词器行为

免责声明： 分词器的默认行为已在 2023 年 4 月修复并更改。之前的版本在目标和源分词序列的末尾都添加了 [self.eos_token_id, self.cur_lang_code]。这是错误的，因为 NLLB 论文提到了 (第 48 页，6.1.1. 模型架构)：

请注意，我们将源序列前缀与源语言一起使用，而不是像以前的一些作品那样使用目标语言 (Arivazhagan 等人，2019；Johnson 等人，2017)。这主要是因为我们优先考虑在任何一对 200 种语言上优化我们模型的零翻译性能，对监督性能的损失很小。

先前的行为：

代码语言：javascript复制
>>> from transformers import NllbTokenizer

>>> tokenizer = NllbTokenizer.from_pretrained("facebook/nllb-200-distilled-600M")
>>> tokenizer("How was your day?").input_ids
[13374, 1398, 4260, 4039, 248130, 2, 256047]

>>> # 2: '</s>'
>>> # 256047 : 'eng_Latn'

新行为

代码语言：javascript复制
>>> from transformers import NllbTokenizer

>>> tokenizer = NllbTokenizer.from_pretrained("facebook/nllb-200-distilled-600M")
>>> tokenizer("How was your day?").input_ids
[256047, 13374, 1398, 4260, 4039, 248130, 2]

可以通过以下方式启用旧行为：

代码语言：javascript复制
>>> from transformers import NllbTokenizer

>>> tokenizer = NllbTokenizer.from_pretrained("facebook/nllb-200-distilled-600M", legacy_behaviour=True)

更多细节，请查看链接的 PR 和 Issue。

概述

NLLB 模型由 Marta R. Costa-jussà、James Cross、Onur Çelebi、Maha Elbayad、Kenneth Heafield、Kevin Heffernan、Elahe Kalbassi、Janice Lam、Daniel Licht、Jean Maillard、Anna Sun、Skyler Wang、Guillaume Wenzek、Al Youngblood、Bapi Akula、Loic Barrault、Gabriel Mejia Gonzalez、Prangthip Hansanti、John Hoffman、Semarley Jarrett、Kaushik Ram Sadagopan、Dirk Rowe、Shannon Spruit、Chau Tran、Pierre Andrews、Necip Fazil Ayan、Shruti Bhosale、Sergey Edunov、Angela Fan、Cynthia Gao、Vedanuj Goswami、Francisco Guzmán、Philipp Koehn、Alexandre Mourachko、Christophe Ropers、Safiyyah Saleem、Holger Schwenk 和 Jeff Wang 在 No Language Left Behind: Scaling Human-Centered Machine Translation 中提出。

该论文的摘要如下：

受到在全球范围内消除语言障碍的目标驱动，机器翻译已经巩固自己作为当今人工智能研究的重点。然而，这些努力已经围绕一小部分语言展开，抛弃了绝大多数主要是低资源语言。要突破 200 种语言障碍并确保安全、高质量的结果，同时考虑伦理因素，需要什么？在《No Language Left Behind》中，我们首先通过与母语者的探索性访谈来定位对低资源语言翻译支持的需求。然后，我们创建了旨在缩小低资源语言和高资源语言之间性能差距的数据集和模型。更具体地说，我们开发了一个基于 Sparsely Gated Mixture of Experts 的条件计算模型，该模型是通过针对低资源语言量身定制的新颖和有效的数据挖掘技术获得的数据进行训练的。我们提出了多种架构和训练改进来对抗在数千个任务上训练时的过拟合。至关重要的是，我们使用人工翻译的基准 Flores-200 评估了超过 40,000 种不同的翻译方向的性能，并结合了一个涵盖 Flores-200 中所有语言的新颖毒性基准来评估翻译的安全性。我们的模型相对于先前的最新技术实现提高了 44% 的 BLEU，为实现通用翻译系统奠定了重要基础。

此实现包含发布的稠密模型。

稀疏模型 NLLB-MoE (Mixture of Expert) 现已推出！更多细节请查看 这里

此模型由 Lysandre 贡献。作者的代码可以在 这里 找到。

使用 NLLB 生成

在生成目标文本时，将forced_bos_token_id设置为目标语言 ID。以下示例展示了如何使用facebook/nllb-200-distilled-600M模型将英语翻译成法语。

请注意，我们使用法语fra_Latn的 BCP-47 代码。在Flores 200 数据集中查看所有 BCP-47 的列表。

代码语言：javascript复制
>>> from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/nllb-200-distilled-600M")
>>> model = AutoModelForSeq2SeqLM.from_pretrained("facebook/nllb-200-distilled-600M")

>>> article = "UN Chief says there is no military solution in Syria"
>>> inputs = tokenizer(article, return_tensors="pt")

>>> translated_tokens = model.generate(
...     **inputs, forced_bos_token_id=tokenizer.lang_code_to_id["fra_Latn"], max_length=30
... )
>>> tokenizer.batch_decode(translated_tokens, skip_special_tokens=True)[0]
Le chef de l'ONU dit qu'il n'y a pas de solution militaire en Syrie
从除英语以外的任何其他语言生成

英语（eng_Latn）被设置为默认的翻译源语言。为了指定您想要从其他语言翻译，您应该在分词器初始化的src_lang关键字参数中指定 BCP-47 代码。

查看以下示例，将罗马尼亚语翻译成德语：

代码语言：javascript复制
>>> from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained(
...     "facebook/nllb-200-distilled-600M", token=True, src_lang="ron_Latn"
... )
>>> model = AutoModelForSeq2SeqLM.from_pretrained("facebook/nllb-200-distilled-600M", token=True)

>>> article = "Şeful ONU spune că nu există o soluţie militară în Siria"
>>> inputs = tokenizer(article, return_tensors="pt")

>>> translated_tokens = model.generate(
...     **inputs, forced_bos_token_id=tokenizer.lang_code_to_id["deu_Latn"], max_length=30
... )
>>> tokenizer.batch_decode(translated_tokens, skip_special_tokens=True)[0]
UN-Chef sagt, es gibt keine militärische Lösung in Syrien

资源

  • 翻译任务指南
  • 摘要任务指南

NllbTokenizer

class transformers.NllbTokenizer

<来源>

代码语言：javascript复制
( vocab_file bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' tokenizer_file = None src_lang = None tgt_lang = None sp_model_kwargs: Optional = None additional_special_tokens = None legacy_behaviour = False **kwargs )

参数

  • vocab_file (str) — 词汇文件的路径。
  • 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>") — 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
  • tokenizer_file (str，可选) — 要使用的分词器文件的路径，而不是词汇文件。
  • src_lang (str，可选) — 用作翻译源语言的语言。
  • tgt_lang (str，可选) — 用作翻译目标语言的语言。
  • sp_model_kwargs (Dict[str, str]) — 传递给模型初始化的额外关键字参数。

构建一个 NLLB 分词器。

改编自 RobertaTokenizer 和 XLNetTokenizer。基于SentencePiece。

源语言文档的分词方法是<tokens> <eos> <语言代码>，目标语言文档的分词方法是<语言代码>

` 用于目标语言文档。

示例：

代码语言：javascript复制
>>> from transformers import NllbTokenizer

>>> tokenizer = NllbTokenizer.from_pretrained(
...     "facebook/nllb-200-distilled-600M", src_lang="eng_Latn", tgt_lang="fra_Latn"
... )
>>> example_english_phrase = " UN Chief Says There Is No Military Solution in Syria"
>>> expected_translation_french = "Le chef de l'ONU affirme qu'il n'y a pas de solution militaire en Syrie."
>>> inputs = tokenizer(example_english_phrase, text_target=expected_translation_french, return_tensors="pt")
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], 可选) — 第二个序列对的 ID 列表。

返回

List[int]

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

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

  • input_ids (用于编码器) X [eos, src_lang_code]
  • decoder_input_ids: (用于解码器) X [eos, tgt_lang_code]

BOS 从不使用。序列对不是预期的用例，但它们将被处理而无需分隔符。

NllbTokenizerFast

class transformers.NllbTokenizerFast

< source >

代码语言：javascript复制
( vocab_file = None tokenizer_file = None bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' src_lang = None tgt_lang = None additional_special_tokens = None legacy_behaviour = False **kwargs )

参数

  • vocab_file (str) — 词汇表文件的路径。
  • 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>") — 用于掩码值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
  • tokenizer_file (str, 可选) — 要使用的分词器文件的路径，而不是词汇表文件。
  • src_lang (str, 可选) — 用作翻译源语言的语言。
  • tgt_lang (str, 可选) — 用作翻译目标语言的语言。

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

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

源语言文档的分词方法是<tokens> <eos> <language code>，目标语言文档的分词方法是<tokens> <eos>。

<tokens> <eos> 用于目标语言文档。

示例:

代码语言：javascript复制
>>> from transformers import NllbTokenizerFast

>>> tokenizer = NllbTokenizerFast.from_pretrained(
...     "facebook/nllb-200-distilled-600M", src_lang="eng_Latn", tgt_lang="fra_Latn"
... )
>>> example_english_phrase = " UN Chief Says There Is No Military Solution in Syria"
>>> expected_translation_french = "Le chef de l'ONU affirme qu'il n'y a pas de solution militaire en Syrie."
>>> inputs = tokenizer(example_english_phrase, text_target=expected_translation_french, return_tensors="pt")
build_inputs_with_special_tokens

< source >

代码语言：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]

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

通过连接和添加特殊标记从序列或序列对构建用于序列分类任务的模型输入。特殊标记取决于调用 set_lang。

NLLB 序列具有以下格式，其中X表示序列：

  • input_ids（用于编码器）X [eos, src_lang_code]
  • decoder_input_ids：（用于解码器）X [eos, tgt_lang_code]

BOS 从不使用。序列对不是预期的用例，但它们将在没有分隔符的情况下处理。

create_token_type_ids_from_sequences

< source >

代码语言：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]

零的列表。

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

set_src_lang_special_tokens

< source >

代码语言：javascript复制
( src_lang )

将特殊标记重置为源语言设置。

  • 在传统模式下：无前缀，后缀=[eos, src_lang_code]。
  • 在默认模式下：前缀=[src_lang_code]，后缀=[eos]
set_tgt_lang_special_tokens

< source >

代码语言：javascript复制
( lang: str )

将特殊标记重置为目标语言设置。

  • 在传统模式下：无前缀，后缀=[eos, tgt_lang_code]。
  • 在默认模式下：前缀=[tgt_lang_code]，后缀=[eos]

NLLB-MOE

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/nllb-moe

概述

NLLB 模型是由 Marta R. Costa-jussà、James Cross、Onur Çelebi、Maha Elbayad、Kenneth Heafield、Kevin Heffernan、Elahe Kalbassi、Janice Lam、Daniel Licht、Jean Maillard、Anna Sun、Skyler Wang、Guillaume Wenzek、Al Youngblood、Bapi Akula、Loic Barrault、Gabriel Mejia Gonzalez、Prangthip Hansanti、John Hoffman、Semarley Jarrett、Kaushik Ram Sadagopan、Dirk Rowe、Shannon Spruit、Chau Tran、Pierre Andrews、Necip Fazil Ayan、Shruti Bhosale、Sergey Edunov、Angela Fan、Cynthia Gao、Vedanuj Goswami、Francisco Guzmán、Philipp Koehn、Alexandre Mourachko、Christophe Ropers、Safiyyah Saleem、Holger Schwenk 和 Jeff Wang 在No Language Left Behind: Scaling Human-Centered Machine Translation中提出的。

该论文的摘要如下：

受到在全球范围内消除语言障碍的目标驱动，机器翻译已经巩固自己作为当今人工智能研究的重点。然而，这些努力已经围绕着一小部分语言展开，抛弃了大多数主要是低资源语言的语言。要突破 200 种语言障碍，同时确保安全、高质量的结果，同时考虑伦理因素，需要什么？在《No Language Left Behind》中，我们通过首先通过与母语者的探索性访谈来将对低资源语言翻译支持的需求进行情境化，然后创建了旨在缩小低资源语言与高资源语言之间性能差距的数据集和模型。更具体地说，我们开发了一个基于 Sparsely Gated Mixture of Experts 的条件计算模型，该模型是通过针对低资源语言量身定制的新颖和有效的数据挖掘技术获得的数据进行训练的。我们提出了多种架构和训练改进措施，以抵消在数千个任务上训练时的过拟合。至关重要的是，我们使用人工翻译的基准 Flores-200 评估了超过 40,000 个不同的翻译方向的性能，并结合了一个涵盖 Flores-200 中所有语言的新型毒性基准来评估翻译的安全性。我们的模型相对于先前的最先进技术实现了 44%的 BLEU 改进，为实现通用翻译系统奠定了重要基础。

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

使用提示

  • M2M100ForConditionalGeneration 是 NLLB 和 NLLB MoE 的基础模型
  • NLLB-MoE 与 NLLB 模型非常相似，但其前馈层基于 SwitchTransformers 的实现。
  • 分词器与 NLLB 模型相同。

与 SwitchTransformers 的实现差异

最大的区别在于令牌路由的方式。NLLB-MoE 使用top-2-gate，这意味着对于每个输入，只选择两个最高预测概率的专家，其余专家将被忽略。在SwitchTransformers中，只计算了前两个最高概率，这意味着令牌被转发的概率较低。此外，如果一个令牌没有路由到任何专家，SwitchTransformers仍然会添加其未修改的隐藏状态（类似于残差连接），而在NLLB的 top-2 路由机制中，它们被屏蔽。

使用 NLLB-MoE 生成

可用的检查点需要约 350GB 的存储空间。如果您的计算机内存不足，请确保使用accelerate。

在生成目标文本集时，将forced_bos_token_id设置为目标语言 id。以下示例显示如何使用facebook/nllb-200-distilled-600M模型将英语翻译成法语。

请注意，我们使用法语的 BCP-47 代码fra_Latn。请参阅Flores 200 数据集中所有 BCP-47 的列表。

代码语言：javascript复制
>>> from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/nllb-moe-54b")
>>> model = AutoModelForSeq2SeqLM.from_pretrained("facebook/nllb-moe-54b")

>>> article = "Previously, Ring's CEO, Jamie Siminoff, remarked the company started when his doorbell wasn't audible from his shop in his garage."
>>> inputs = tokenizer(article, return_tensors="pt")

>>> translated_tokens = model.generate(
...     **inputs, forced_bos_token_id=tokenizer.lang_code_to_id["fra_Latn"], max_length=50
... )
>>> tokenizer.batch_decode(translated_tokens, skip_special_tokens=True)[0]
"Auparavant, le PDG de Ring, Jamie Siminoff, a fait remarquer que la société avait commencé lorsque sa sonnette n'était pas audible depuis son magasin dans son garage."
从除英语以外的任何其他语言生成

英语（eng_Latn）被设置为默认语言进行翻译。为了指定您希望从其他语言翻译，您应该在分词器初始化的src_lang关键字参数中指定 BCP-47 代码。

请参见下面的示例，将罗马尼亚语翻译成德语：

代码语言：javascript复制
>>> from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/nllb-moe-54b", src_lang="ron_Latn")
>>> model = AutoModelForSeq2SeqLM.from_pretrained("facebook/nllb-moe-54b")

>>> article = "Şeful ONU spune că nu există o soluţie militară în Siria"
>>> inputs = tokenizer(article, return_tensors="pt")

>>> translated_tokens = model.generate(
...     **inputs, forced_bos_token_id=tokenizer.lang_code_to_id["deu_Latn"], max_length=30
... )
>>> tokenizer.batch_decode(translated_tokens, skip_special_tokens=True)[0]

资源

  • 翻译任务指南
  • 摘要任务指南

NllbMoeConfig

class transformers.NllbMoeConfig

<来源>

代码语言：javascript复制
( vocab_size = 128112 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.05 decoder_layerdrop = 0.05 use_cache = True is_encoder_decoder = True activation_function = 'relu' d_model = 1024 dropout = 0.1 attention_dropout = 0.1 activation_dropout = 0.0 init_std = 0.02 decoder_start_token_id = 2 scale_embedding = True router_bias = False router_dtype = 'float32' router_ignore_padding_tokens = False num_experts = 128 expert_capacity = 64 encoder_sparse_step = 4 decoder_sparse_step = 4 router_z_loss_coef = 0.001 router_aux_loss_coef = 0.001 second_expert_policy = 'all' normalize_router_prob_before_dropping = False batch_prioritized_routing = False moe_eval_capacity_token_fraction = 1.0 moe_token_dropout = 0.2 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 output_router_logits = False **kwargs )

参数

  • vocab_size (int, optional, defaults to 50265) — NllbMoe 模型的词汇量。定义了在调用 NllbMoeModel 时可以表示的不同标记数量。
  • d_model (int, optional, defaults to 1024) — 层和池化器层的维度。
  • encoder_layers (int, optional, defaults to 12) — 编码器层数。
  • decoder_layers (int, optional, defaults to 12) — 解码器层数。
  • encoder_attention_heads (int, optional, defaults to 16) — Transformer 编码器中每个注意力层的注意力头数。
  • decoder_attention_heads (int, optional, defaults to 16) — Transformer 解码器中每个注意力层的注意力头数。
  • decoder_ffn_dim (int, optional, defaults to 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 论文。
  • decoder_layerdrop (float, optional, defaults to 0.0) — 解码器的 LayerDrop 概率。有关更多详细信息，请参阅LayerDrop 论文。
  • second_expert_policy (str, optional, default to "all") — 用于对每个标记采样到第二专家的概率进行采样的策略。
  • normalize_router_prob_before_dropping (bool, optional, defaults to True) — 是否在应用基于专家容量的掩码之前对路由器概率进行归一化（容量降低）。
  • batch_prioritized_routing (bool, optional, 默认为True) — 是否按照路由器概率对令牌进行排序以进行容量丢弃。这意味着具有最高概率的令牌将在其他可能在序列中更远的令牌之前路由。
  • moe_eval_capacity_token_fraction (float, optional, 默认为 1.0) — 验证期间作为容量的令牌分数，如果设置为负数，则使用与训练相同的值。应在范围内：(0.0, 1.0]。
  • num_experts (int, optional, 默认为 128) — 每个 NllbMoeSparseMlp 层的专家数量。
  • expert_capacity (int, optional, 默认为 64) — 每个专家可以存储的令牌数量。
  • encoder_sparse_step (int, optional, defaults to 4) — 编码器中稀疏层的频率。4 表示每 4 层中会有一层是稀疏的。
  • decoder_sparse_step (int, optional, defaults to 4) — 解码器中稀疏层的频率。4 表示每 4 层中会有一层是稀疏的。
  • router_dtype (str, optional, 默认为"float32") — 用于路由器的dtype。最好保持dtype为"float32"，如论文中的selective precision讨论中所指定的。
  • router_ignore_padding_tokens (bool, optional, 默认为False) — 在路由时是否忽略填充令牌。如果为False，则填充令牌不会路由到任何专家。
  • router_bias (bool, optional, 默认为False) — 路由器的分类器是否应具有偏差。
  • moe_token_dropout (float, optional, 默认为 0.2) — MoE 专家输出掩码（EOM）的掩码率，通过对专家输出进行 Dropout2d 实现。
  • output_router_logits (bool, optional, 默认为False) — 是否返回路由器 logits。仅在训练时设置为True以获得辅助损失。
  • use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。

这是一个配置类，用于存储 NllbMoeModel 的配置。它用于根据指定的参数实例化一个 NLLB-MoE 模型，定义模型架构。使用默认值实例化配置将产生类似于 NLLB-MoE facebook/nllb-moe-54b 架构的配置。

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

示例：

代码语言：javascript复制
>>> from transformers import NllbMoeModel, NllbMoeConfig

>>> # Initializing a NllbMoe facebook/nllb-moe-54b style configuration
>>> configuration = NllbMoeConfig()

>>> # Initializing a model from the facebook/nllb-moe-54b style configuration
>>> model = NllbMoeModel(configuration)

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

NllbMoeTop2Router

class transformers.NllbMoeTop2Router

<来源>

代码语言：javascript复制
( config: NllbMoeConfig )

路由器使用令牌选择前两个专家的分配。

此路由器使用与 fairseq 存储库中的 NLLB-MoE 相同的机制。项目按照 router_probs 排序，然后路由到其选择的专家，直到达到专家的 expert_capacity。不能保证每个令牌都由专家处理，也不能保证每个专家至少收到一个令牌。

还返回路由器组合权重，以确保未更新的状态将被掩码。

route_tokens

<来源>

代码语言：javascript复制
( router_logits: Tensor input_dtype: dtype = torch.float32 padding_mask: Optional = None )

计算每个专家的dispatch_mask和dispatch_weights。这些掩码会根据专家的容量进行调整。

forward

<来源>

代码语言：javascript复制
( hidden_states: Tensor padding_mask: Optional = None ) → export const metadata = 'undefined';top_1_mask (torch.Tensor of shape (batch_size, sequence_length))

参数

  • hidden_states (torch.Tensor) — (batch_size, sequence_length, hidden_dim) 用于计算路由器概率。

返回

top_1_mask (torch.Tensor，形状为(batch_size, sequence_length))

形状为[batch_size, sequence_length]的索引张量，对应于使用路由器的 top1 概率为每个标记选择的专家。router_probabilities (torch.Tensor，形状为(batch_size, sequence_length, nump_experts))：形状为(batch_size, sequence_length, num_experts)的张量，对应于每个标记和专家的概率。用于将标记路由到专家。router_logits (torch.Tensor，形状为(batch_size, sequence_length))：形状为(batch_size, sequence_length, num_experts)的原始路由器 logits 张量。稍后用于计算路由器 z-loss。

隐藏状态被重新整形以简化路由器概率的计算（为每个专家组合权重）。

NllbMoeSparseMLP

class transformers.NllbMoeSparseMLP

< source >

代码语言：javascript复制
( config: NllbMoeConfig ffn_dim: int expert_class: Module = <class 'transformers.models.nllb_moe.modeling_nllb_moe.NllbMoeDenseActDense'> )

NLLB-MoE 稀疏 MLP 模块的实现。

forward

< source >

代码语言：javascript复制
( hidden_states: Tensor padding_mask: Optional = False ) → export const metadata = 'undefined';hidden_states (torch.Tensor of shape (batch_size, sequence_length, hidden_dim))

参数

  • hidden_states (torch.Tensor，形状为(batch_size, sequence_length, hidden_dim)) — 隐藏状态
  • padding_mask (torch.Tensor，可选，默认为False) — 注意力掩码。可以是因果形式或非因果形式。

返回

hidden_states (torch.Tensor，形状为(batch_size, sequence_length, hidden_dim))

更新后的隐藏状态路由器 logits (torch.Tensor，形状为(batch_size, sequence_length, num_experts))：用于计算损失

前向传递的目标是具有与等效的NllbMoeDenseActDense（mlp）层相同数量的操作。这意味着所有隐藏状态最多应该被处理两次（因为我们使用了一个 top_2 门控机制）。这意味着我们将复杂度保持在 O(batch_size x sequence_length x hidden_dim)而不是 O(num_experts x batch_size x sequence_length x hidden_dim)。

1- 从router获取router_probs。router_mask的形状为(batch_size X sequence_length, num_expert)，对应于router_probs的布尔版本。使用router_mask对输入进行掩码处理。

2- 将隐藏状态分派给其关联的专家。路由器概率用于在更新掩码隐藏状态时加权每个专家的贡献。

NllbMoeModel

class transformers.NllbMoeModel

< source >

代码语言：javascript复制
( config: NllbMoeConfig )

参数

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

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

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

forward

<来源>

代码语言：javascript复制
( input_ids: Optional = 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 output_router_logits: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqMoEModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

返回

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

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

  • last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的隐藏状态序列。 如果仅使用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)的张量和 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 之后，用于计算自注意力头中的加权平均值。
  • decoder_router_logits (tuple(torch.FloatTensor)，可选，当传递output_router_logits=True或者config.add_router_probs=True时返回) — 形状为(batch_size, sequence_length, num_experts)的torch.FloatTensor元组（每层一个）。 解码器模型的路由器 logits，用于计算混合专家模型的辅助损失。
  • 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 (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的隐藏状态序列。
  • 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 之后，用于计算自注意力头中的加权平均值。
  • encoder_router_logits（tuple(torch.FloatTensor)，可选，当传递output_router_logits=True或config.add_router_probs=True时返回）— 形状为(batch_size, sequence_length, num_experts)的torch.FloatTensor元组（每层一个）。 编码器模型的路由器 logits，用于计算辅助损失和稀疏模块的 z_loss。

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

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

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

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

示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, NllbMoeModel

>>> tokenizer = AutoTokenizer.from_pretrained("hf-internal-testing/random-nllb-moe-2-experts")
>>> model = SwitchTransformersModel.from_pretrained("hf-internal-testing/random-nllb-moe-2-experts")

>>> input_ids = tokenizer(
...     "Studies have been shown that owning a dog is good for you", return_tensors="pt"
... ).input_ids  # Batch size 1
>>> decoder_input_ids = tokenizer("Studies show that", return_tensors="pt").input_ids  # Batch size 1

>>> # preprocess: Prepend decoder_input_ids with start token which is pad token for NllbMoeModel
>>> decoder_input_ids = model._shift_right(decoder_input_ids)

>>> # forward pass
>>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids)
>>> last_hidden_states = outputs.last_hidden_state

NllbMoeForConditionalGeneration

class transformers.NllbMoeForConditionalGeneration

<来源>

代码语言：javascript复制
( config: NllbMoeConfig )

参数

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

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

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

forward

<来源>

代码语言：javascript复制
( input_ids: Optional = 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 output_router_logits: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqMoEOutput or tuple(torch.FloatTensor)

参数

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

    什么是注意力掩码？

  • decoder_input_ids (torch.LongTensor 的形状为 (batch_size, target_sequence_length)，optional) — 词汇表中解码器输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是解码器输入标记？ NllbMoe 使用 eos_token_id 作为 decoder_input_ids 生成的起始标记。如果使用 past_key_values，可选择仅输入最后的 decoder_input_ids（参见 past_key_values）。
  • decoder_attention_mask (torch.LongTensor 的形状为 (batch_size, target_sequence_length)，optional) — 默认行为：生成一个忽略 decoder_input_ids 中填充标记的张量。因果掩码也将默认使用。
  • head_mask (torch.Tensor 的形状为 (encoder_layers, encoder_attention_heads)，optional) — 编码器中注意力模块中选择性头部置零的掩码。掩码值在 [0, 1] 之间：
    • 1 表示头部未被掩码，
    • 0 表示头部被掩码。
  • decoder_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 解码器中注意力模块中选择性头部置零的掩码。掩码值在 [0, 1] 之间：
    • 1 表示头部未被掩码，
    • 0 表示头部被掩码。
  • cross_attn_head_mask (torch.Tensor 的形状为 (decoder_layers, decoder_attention_heads)，optional) — 解码器中交叉注意力模块中选择性头部置零的掩码。掩码值在 [0, 1] 之间：
    • 1 表示头部未被掩码，
    • 0 表示头部被掩码。
  • 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 的 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)，optional) — 可选地，可以直接传递嵌入表示，而不是传递 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。
  • output_router_logits (bool, 可选的) — 是否返回所有路由器的对数。它们对于计算路由器损失很有用，在推断期间不应返回。
  • return_dict (bool, 可选的) — 是否返回一个 ModelOutput 而不是一个普通元组。
  • labels (torch.LongTensor，形状为(batch_size, sequence_length)，可选的) — 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]范围内，或者为-100（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]范围内的标记。

返回值

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

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

  • loss (torch.FloatTensor，形状为(1,), 可选的, 当提供labels时返回) — 语言建模损失。
  • logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（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元组（每个层一个）。 NllbMoeForConditionalGeneration 的前向方法，覆盖了__call__特殊方法。
  • cross_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length)。 encoder_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length)。
  • encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 编码器模型最后一层的隐藏状态序列。 编码器每一层输出的隐藏状态，以及初始嵌入输出。
  • 编码器模型的路由器 logits，用于计算混合专家模型的辅助损失和 z_loss。
  • 解码器模型的路由器 logits，用于计算混合专家模型的辅助损失。 解码器的注意力权重，在注意力 softmax 之后使用，用于计算自注意力头中的加权平均值。
  • 编码器的注意力权重，在注意力 softmax 之后使用，用于计算自注意力头中的加权平均值。 虽然前向传递的步骤需要在这个函数内定义，但应该在之后调用Module实例，而不是这个函数，因为前者会负责运行前后处理步骤，而后者会默默地忽略它们。
  • encoder_router_logits (tuple(torch.FloatTensor), optional, returned when output_router_logits=True is passed or when config.add_router_probs=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, sequence_length, num_experts). 解码器的交叉注意力层的注意力权重，在注意力 softmax 之后使用，用于计算交叉注意力头中的加权平均值。

encoder_hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings, if the model has an embedding layer, one for the output of each layer) of shape (batch_size, sequence_length, hidden_size)。

在传递output_router_logits=True或config.add_router_probs=True时返回，encoder_router_logits是一个元组，包含每一层的torch.FloatTensor，形状为(batch_size, sequence_length, num_experts)。

decoder_router_logits (tuple(torch.FloatTensor), optional, returned when output_router_logits=True is passed or when config.add_router_probs=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, sequence_length, num_experts)。

代码语言：javascript复制
>>> from transformers import AutoTokenizer, NllbMoeForConditionalGeneration

>>> model = NllbMoeForConditionalGeneration.from_pretrained("facebook/nllb-moe-54b")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/nllb-moe-54b")

>>> text_to_translate = "Life is like a box of chocolates"
>>> model_inputs = tokenizer(text_to_translate, return_tensors="pt")

>>> # translate to French
>>> gen_tokens = model.generate(**model_inputs, forced_bos_token_id=tokenizer.get_lang_id("eng_Latn"))
>>> print(tokenizer.batch_decode(gen_tokens, skip_special_tokens=True))

Nyströmformer

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

概述

Nyströmformer 模型由 Yunyang Xiong、Zhanpeng Zeng、Rudrasis Chakraborty、Mingxing Tan、Glenn Fung、Yin Li 和 Vikas Singh 在Nyströmformer: A Nyström-Based Algorithm for Approximating Self-Attention中提出。

论文摘要如下：

Transformer 已经成为自然语言处理任务的强大工具。驱动 Transformer 出色性能的关键组件是自注意力机制，它编码了其他标记对每个特定标记的影响或依赖。尽管有益，但自注意力对输入序列长度的二次复杂度限制了其在更长序列上的应用——这是社区正在积极研究的一个主题。为了解决这一限制，我们提出了 Nyströmformer——一个模型，随着序列长度的增加，展现出有利的可扩展性。我们的想法是基于将 Nyström 方法调整为用 O(n)复杂度近似标准自注意力。Nyströmformer 的可扩展性使其能够应用于包含数千个标记的更长序列。我们在 GLUE 基准和 IMDB 评论的多个下游任务上进行评估，使用标准序列长度，发现我们的 Nyströmformer 表现相当，甚至在少数情况下，甚至略优于标准自注意力。在 Long Range Arena（LRA）基准上的更长序列任务中，Nyströmformer 相对于其他高效自注意力方法表现良好。我们的代码可以在此 https URL 找到。

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

资源

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

NystromformerConfig

class transformers.NystromformerConfig

<来源>

代码语言：javascript复制
( vocab_size = 30000 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu_new' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 510 type_vocab_size = 2 segment_means_seq_len = 64 num_landmarks = 64 conv_kernel_size = 65 inv_coeff_init_option = False initializer_range = 0.02 layer_norm_eps = 1e-05 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 **kwargs )

参数

  • vocab_size (int, 可选，默认为 30000) — Nystromformer 模型的词汇表大小。定义了在调用 NystromformerModel 时可以表示的不同标记数量。
  • 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, 可选，默认为 0.1) — 注意力概率的丢弃比率。
  • max_position_embeddings (int, 可选，默认为 512) — 该模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如 512、1024 或 2048）。
  • type_vocab_size (int, optional, defaults to 2) — 在调用 NystromformerModel 时传递的token_type_ids的词汇表大小。
  • segment_means_seq_len (int, optional, defaults to 64) — 在段均值中使用的序列长度。
  • num_landmarks (int, optional, defaults to 64) — 在 Nystrom 近似中使用的地标（或 Nystrom）点的数量。
  • conv_kernel_size (int, optional, defaults to 65) — Nystrom 近似中使用的深度卷积的核大小。
  • inv_coeff_init_option (bool, optional, defaults to False) — 是否使用精确系数计算来计算矩阵的 Moore-Penrose 逆的初始值的迭代方法。
  • initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  • layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。

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

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

示例：

代码语言：javascript复制
>>> from transformers import NystromformerModel, NystromformerConfig

>>> # Initializing a Nystromformer uw-madison/nystromformer-512 style configuration
>>> configuration = NystromformerConfig()

>>> # Initializing a model from the uw-madison/nystromformer-512 style configuration
>>> model = NystromformerModel(configuration)

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

NystromformerModel

class transformers.NystromformerModel

< source >

代码语言：javascript复制
( config )

参数

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

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

forward

< source >

代码语言：javascript复制
( 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.BaseModelOutputWithPastAndCrossAttentions 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]之间：
    • 对于未被masked的令牌为 1，
    • 对于被masked的令牌为 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，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
  • return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。

返回

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

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

  • last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。 如果使用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 之后，用于计算交叉注意力头中的加权平均值。

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

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

示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, NystromformerModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/nystromformer-512")
>>> model = NystromformerModel.from_pretrained("uw-madison/nystromformer-512")

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

>>> last_hidden_states = outputs.last_hidden_state

NystromformerForMaskedLM

class transformers.NystromformerForMaskedLM

<来源>

代码语言：javascript复制
( config )

参数

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

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

forward

<来源>

代码语言：javascript复制
( 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]中选择：
    • 对于“未屏蔽”的标记，
    • 对于“屏蔽”的标记为 0。

    什么是注意力掩码？

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

    什么是标记类型 ID？

  • position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
  • head_mask (torch.FloatTensor，形状为(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）包含根据配置（NystromformerConfig）和输入的不同元素。

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

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

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

示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, NystromformerForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/nystromformer-512")
>>> model = NystromformerForMaskedLM.from_pretrained("uw-madison/nystromformer-512")

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

NystromformerForSequenceClassification

class transformers.NystromformerForSequenceClassification

<来源>

代码语言：javascript复制
( config )

参数

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

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

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

forward

<来源>

代码语言：javascript复制
( 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]中选择：
    • 对于未被masked的标记为 1，
    • 对于被masked的标记为 0。

    什么是注意力掩码？

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

    什么是标记类型 ID？

  • position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
  • head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）- 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：
    • 1 表示头部是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 而不是普通元组。
  • 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）包含根据配置（NystromformerConfig）和输入的各种元素。

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

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

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

单标签分类示例：

代码语言：javascript复制
>>> import torch
>>> from transformers import AutoTokenizer, NystromformerForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/nystromformer-512")
>>> model = NystromformerForSequenceClassification.from_pretrained("uw-madison/nystromformer-512")

>>> 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 = NystromformerForSequenceClassification.from_pretrained("uw-madison/nystromformer-512", num_labels=num_labels)

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

多标签分类示例：

代码语言：javascript复制
>>> import torch
>>> from transformers import AutoTokenizer, NystromformerForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/nystromformer-512")
>>> model = NystromformerForSequenceClassification.from_pretrained("uw-madison/nystromformer-512", 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 = NystromformerForSequenceClassification.from_pretrained(
...     "uw-madison/nystromformer-512", 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

NystromformerForMultipleChoice

class transformers.NystromformerForMultipleChoice

<来源>

代码语言：javascript复制
( config )

参数

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

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

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

forward

<来源>

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

    什么是 attention masks？

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

    什么是 token type IDs？

  • position_ids (torch.LongTensor of shape (batch_size, num_choices, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [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 表示头部未被 masked。
    • 0 表示头部是 masked。
  • inputs_embeds (torch.FloatTensor of shape (batch_size, num_choices, 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,), optional) — 用于计算多项选择分类损失的标签。索引应在 [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 时），包含根据配置（NystromformerConfig）和输入的不同元素。

  • loss (torch.FloatTensor of shape (1,), optional, 当提供 labels 时返回) — 分类损失。
  • logits (torch.FloatTensor of shape (batch_size, num_choices)) — num_choices 是输入张量的第二维度。（参见上面的 input_ids）。 分类分数（SoftMax 之前）。
  • hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings, if the model has an embedding layer, one for the output of each layer) of shape (batch_size, sequence_length, hidden_size). 模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
  • attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length). 在传递output_attentions=True或config.output_attentions=True时返回，用于计算自注意力头中加权平均值的注意力权重。

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

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

示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, NystromformerForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/nystromformer-512")
>>> model = NystromformerForMultipleChoice.from_pretrained("uw-madison/nystromformer-512")

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

NystromformerForTokenClassification

class transformers.NystromformerForTokenClassification

< source >

代码语言：javascript复制
( config )

参数

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

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

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

forward

< source >

代码语言：javascript复制
( 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 (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 表示头部是not 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时）包含根据配置（NystromformerConfig）和输入的各种元素。

  • 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), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, NystromformerForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/nystromformer-512")
>>> model = NystromformerForTokenClassification.from_pretrained("uw-madison/nystromformer-512")

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

NystromformerForQuestionAnswering

class transformers.NystromformerForQuestionAnswering

<来源>

代码语言：javascript复制
( config )

参数

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

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

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

forward

<来源>

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

参数

  • input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
  • attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：
    • 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 而不是普通元组。
  • 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 时）包含各种元素，具体取决于配置（NystromformerConfig）和输入。

  • loss (torch.FloatTensor of shape (1,), optional, 当提供 labels 时返回) — 总跨度提取损失是开始和结束位置的交叉熵之和。
  • start_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 跨度开始分数（SoftMax 之前）。
  • end_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 跨度结束分数（SoftMax 之前）。
  • hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组。 模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
  • attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组。 在注意力 SoftMax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, NystromformerForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/nystromformer-512")
>>> model = NystromformerForQuestionAnswering.from_pretrained("uw-madison/nystromformer-512")

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

Open-Llama

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/open-llama

此模型仅处于维护模式，我们不接受任何更改其代码的新 PR。

如果您在运行此模型时遇到任何问题，请重新安装支持此模型的最后一个版本：v4.31.0。您可以通过运行以下命令来执行：pip install -U transformers==4.31.0。

该模型与 Hugging Face Hub 上的OpenLLaMA 模型不同，后者主要使用 LLaMA 架构。

概述

Open-Llama 模型是由社区开发者 s-JoL 在开源 Open-Llama 项目中提出的。

该模型主要基于 LLaMA，具有一些修改，包括来自 Xformers 的内存高效注意力，来自 Bloom 的稳定嵌入和来自 PaLM 的共享输入输出嵌入。该模型经过中英文的预训练，这使其在中文语言任务上表现更好。

该模型由s-JoL贡献。原始代码由s-JoL发布在 GitHub 上，但现已删除。

OpenLlamaConfig

class transformers.OpenLlamaConfig

<来源>

代码语言：javascript复制
( vocab_size = 100000 hidden_size = 4096 intermediate_size = 11008 num_hidden_layers = 32 num_attention_heads = 32 hidden_act = 'silu' max_position_embeddings = 2048 initializer_range = 0.02 rms_norm_eps = 1e-06 use_cache = True pad_token_id = 0 bos_token_id = 1 eos_token_id = 2 tie_word_embeddings = False use_memory_efficient_attention = True hidden_dropout_prob = 0.1 attention_dropout_prob = 0.1 use_stable_embedding = True shared_input_output_embedding = True rope_scaling = None **kwargs )

参数

  • vocab_size (int, optional, 默认为 32000) — Open-Llama 模型的词汇量。定义了在调用 OpenLlamaModel 时可以表示的不同标记数量。
  • hidden_size (int, optional, 默认为 4096) — 隐藏表示的维度。
  • intermediate_size (int, optional, 默认为 11008) — MLP 表示的维度。
  • num_hidden_layers (int, optional, 默认为 32) — Transformer 编码器中的隐藏层数量。
  • num_attention_heads (int, optional, 默认为 32) — Transformer 编码器中每个注意力层的注意力头数。
  • hidden_act (str 或 function, optional, 默认为"silu") — 解码器中的非线性激活函数（函数或字符串）。
  • max_position_embeddings (int, optional, 默认为 2048) — 此模型可能会使用的最大序列长度。通常将其设置为较大的值以防万一（例如 512 或 1024 或 2048）。
  • initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  • rms_norm_eps (float, optional, 默认为 1e-12) — rms 归一化层使用的 epsilon。
  • use_cache (bool, optional, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在config.is_decoder=True时相关。
  • tie_word_embeddings(bool, optional, 默认为False) — 是否绑定权重嵌入
  • rope_scaling (Dict, optional) — 包含 RoPE 嵌入的缩放配置的字典。目前支持两种缩放策略：线性和动态。它们的缩放因子必须是大于 1 的浮点数。预期格式为{"type": 策略名称, "factor": 缩放因子}。在使用此标志时，不要更新max_position_embeddings为预期的新最大值。查看以下主题以获取有关这些缩放策略行为的更多信息：www.reddit.com/r/LocalLLaMA/comments/14mrgpr/dynamically_scaled_rope_further_increases/。这是一个实验性功能，可能在未来版本中发生破坏性 API 更改。 示例 —

这是用于存储 OpenLlamaModel 配置的配置类。根据指定的参数实例化 Open-Llama 模型，定义模型架构。使用默认值实例化配置将产生类似于s-JoL/Open-Llama-V1的配置。

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

代码语言：javascript复制
>>> from transformers import OpenLlamaModel, OpenLlamaConfig

>>> # Initializing a Open-Llama open_llama-7b style configuration
>>> configuration = OpenLlamaConfig()

>>> # Initializing a model from the open_llama-7b style configuration
>>> model = OpenLlamaModel(configuration)

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

OpenLlamaModel

class transformers.OpenLlamaModel

<来源>

代码语言：javascript复制
( config: OpenLlamaConfig )

参数

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

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

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

由config.num_hidden_layers层组成的 Transformer 解码器。每一层都是一个OpenLlamaDecoderLayer

forward

<来源>

代码语言：javascript复制
( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None 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 表示“屏蔽”的标记。

    注意力蒙版是什么？ 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 如果使用past_key_values，则可选择仅输入最后的decoder_input_ids（请参阅past_key_values）。 如果要更改填充行为，应该阅读modeling_opt._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。

    • 1 表示头部未被masked，
    • 0 表示头部被masked。
  • position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。 什么是位置 ID？
  • 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_input_ids（这些没有将其过去的键值状态提供给此模型）的形状为(batch_size, 1)的张量，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
  • inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，您可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为关联向量，这将很有用，而不是使用模型的内部嵌入查找矩阵。
  • 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 而不是普通元组。

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

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

OpenLlamaForCausalLM

class transformers.OpenLlamaForCausalLM

<来源>

代码语言：javascript复制
( config )
forward

<来源>

代码语言：javascript复制
( input_ids: LongTensor = None attention_mask: Optional = None position_ids: 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.CausalLMOutputWithPast or tuple(torch.FloatTensor)

参数

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

    什么是注意力掩码？ 索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 如果使用了 past_key_values，可以选择仅输入最后的 decoder_input_ids（参见 past_key_values）。 如果要更改填充行为，您应该阅读 modeling_opt._prepare_decoder_attention_mask 并根据需要进行修改。有关默认策略的更多信息，请参阅 论文 中的图表 1。

    • 1 表示头部是 未被掩码，
    • 0 表示头部是 被掩码。
  • position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选的) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.n_positions - 1] 中选择。 什么是位置 ID？
  • 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 索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。
  • 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, sequence_length)，可选的): 用于计算掩码语言建模损失的标签。索引应该在 [0, ..., config.vocab_size] 或 -100（参见 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（掩码），损失仅计算具有标签在 [0, ..., config.vocab_size] 中的标记。

返回

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

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

  • 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)的张量。 包含预先计算的隐藏状态（自注意力块中的键和值），可用于加速顺序解码（查看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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, OpenLlamaForCausalLM

>>> model = OpenLlamaForCausalLM.from_pretrained("openlm-research/open_llama_7b")
>>> tokenizer = AutoTokenizer.from_pretrained("openlm-research/open_llama_7b")

>>> prompt = "Hey, are you conscious? Can you talk to me?"
>>> inputs = tokenizer(prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Hey, are you conscious? Can you talk to me?nI'm not conscious, but I can talk to you."

OpenLlamaForSequenceClassification

class transformers.OpenLlamaForSequenceClassification

<来源>

代码语言：javascript复制
( config )

参数

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

LLaMa 模型变压器，顶部带有序列分类头（线性层）。

OpenLlamaForSequenceClassification 使用最后一个标记进行分类，就像其他因果模型（例如 GPT-2）一样。

由于它对最后一个标记进行分类，因此需要知道最后一个标记的位置。如果在配置中定义了pad_token_id，则找到每行中不是填充标记的最后一个标记。如果未定义pad_token_id，则简单地取批次的每行中的最后一个值。由于在传递inputs_embeds而不是input_ids时无法猜测填充标记，因此执行相同操作（取批次的每行中的最后一个值）。

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

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

forward

<来源>

代码语言：javascript复制
( input_ids: LongTensor = None attention_mask: Optional = None position_ids: 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 )

参数

  • 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 表示“屏蔽”的标记。

    什么是注意力蒙版？ 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 如果使用了past_key_values，则只需选择最后的decoder_input_ids进行输入（参见past_key_values）。 如果要更改填充行为，应阅读modeling_opt._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。

    • 1 表示头部“未屏蔽”，
    • 0 表示头部“屏蔽”。
  • position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]。 什么是位置 ID？
  • 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。
  • inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵。
  • use_cache (bool, optional) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
  • return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。
  • labels (torch.LongTensor，形状为(batch_size,)，optional) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

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

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

索引 size torch 模型 配置

0 人点赞