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

Transformers 4.37 中文文档（二十）

原文：huggingface.co/docs/transformers

GPTBigCode

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

概述

GPTBigCode 模型是由 BigCode 在SantaCoder: don’t reach for the stars!中提出的。列出的作者包括：Loubna Ben Allal、Raymond Li、Denis Kocetkov、Chenghao Mou、Christopher Akiki、Carlos Munoz Ferrandis、Niklas Muennighoff、Mayank Mishra、Alex Gu、Manan Dey、Logesh Kumar Umapathi、Carolyn Jane Anderson、Yangtian Zi、Joel Lamy Poirier、Hailey Schoelkopf、Sergey Troshin、Dmitry Abulkhanov、Manuel Romero、Michael Lappert、Francesco De Toni、Bernardo García del Río、Qian Liu、Shamik Bose、Urvashi Bhattacharyya、Terry Yue Zhuo、Ian Yu、Paulo Villegas、Marco Zocca、Sourab Mangrulkar、David Lansky、Huu Nguyen、Danish Contractor、Luis Villa、Jia Li、Dzmitry Bahdanau、Yacine Jernite、Sean Hughes、Daniel Fried、Arjun Guha、Harm de Vries、Leandro von Werra。

论文摘要如下：

BigCode 项目是一个开放的科学合作项目，致力于负责任地开发用于代码的大型语言模型。这份技术报告描述了合作项目直到 2022 年 12 月的进展，概述了个人可识别信息（PII）遮蔽管道的当前状态，用于降低模型架构风险的实验，以及用于训练数据的更好预处理方法的实验。我们在 The Stack 的 Java、JavaScript 和 Python 子集上训练了 1.1B 参数模型，并在 MultiPL-E 文本到代码基准上对其进行评估。我们发现更激进地过滤近似重复内容可以进一步提升性能，并且令人惊讶的是，从拥有 5 个以上 GitHub 星标的存储库中选择文件会显著降低性能。我们的最佳模型在 MultiPL-E 的 Java、JavaScript 和 Python 部分的左到右生成和填充方面优于先前的开源多语言代码生成模型（InCoder-6.7B 和 CodeGen-Multi-2.7B），尽管它是一个规模较小的模型。所有模型都在此链接下以 OpenRAIL 许可证发布。

该模型是一个优化的GPT2 模型，支持多查询注意力。

实现细节

与 GPT2 相比的主要区别。

• 增加了对多查询注意力的支持。

• 使用gelu_pytorch_tanh代替经典的gelu。

• 避免不必要的同步（这已经添加到 GPT2 中＃20061，但在参考代码库中没有）。

• 使用线性层代替 Conv1D（速度提升很好，但会使检查点不兼容）。

• 合并_attn和_upcast_and_reordered_attn。始终将矩阵乘法与缩放合并。将reorder_and_upcast_attn重命名为attention_softmax_in_fp32

• 缓存注意力掩码值，以避免每次重新创建它。

• 使用 jit 来融合注意力 fp32 转换、掩码、softmax 和缩放。

• 将注意力和因果掩码合并为一个，为整个模型预先计算，而不是每个层都计算。

• 将键和值缓存合并为一个（这会改变 layer_past/present 的格式，是否会有问题？）

• 使用内存布局（self.num_heads, 3, self.head_dim）而不是(3, self.num_heads, self.head_dim)用于具有 MHA 的 QKV 张量。 （防止与合并的键和值产生开销，但使检查点与原始 gpt2 模型不兼容）。

您可以在原始拉取请求中阅读更多关于优化的信息。

将 Starcoder 和 Flash Attention 2 结合使用

首先，请确保安装最新版本的 Flash Attention 2，以包括滑动窗口注意力功能。

pip install -U flash-attn --no-build-isolation

还要确保您有与 Flash-Attention 2 兼容的硬件。在 flash-attn 存储库的官方文档中了解更多信息。还要确保以半精度加载模型（例如`torch.float16“）

要加载和运行使用 Flash Attention 2 的模型，请参考下面的代码片段：

>>> import torch
>>> from transformers import AutoModelForCausalLM, AutoTokenizer
>>> device = "cuda" # the device to load the model onto

>>> model = AutoModelForCausalLM.from_pretrained("bigcode/gpt_bigcode-santacoder", torch_dtype=torch.float16, attn_implementation="flash_attention_2")
>>> tokenizer = AutoTokenizer.from_pretrained("bigcode/gpt_bigcode-santacoder")

>>> prompt = "def hello_world():"

>>> model_inputs = tokenizer([prompt], return_tensors="pt").to(device)
>>> model.to(device)

>>> generated_ids = model.generate(**model_inputs, max_new_tokens=30, do_sample=False)
>>> tokenizer.batch_decode(generated_ids)[0]
'def hello_world():\n    print("hello world")\n\nif __name__ == "__main__":\n    print("hello world")\n<|endoftext|>'

预期加速

下面是一个预期加速图表，比较了在 transformers 中使用bigcode/starcoder检查点的原生实现和使用模型的 Flash Attention 2 版本在两种不同序列长度下的纯推理时间。

GPTBigCodeConfig

class transformers.GPTBigCodeConfig

< source >

( vocab_size = 50257 n_positions = 1024 n_embd = 768 n_layer = 12 n_head = 12 n_inner = None activation_function = 'gelu_pytorch_tanh' resid_pdrop = 0.1 embd_pdrop = 0.1 attn_pdrop = 0.1 layer_norm_epsilon = 1e-05 initializer_range = 0.02 scale_attn_weights = True use_cache = True bos_token_id = 50256 eos_token_id = 50256 attention_softmax_in_fp32 = True scale_attention_softmax_in_fp32 = True multi_query = True **kwargs )

参数

• vocab_size (int, optional, 默认为 50257) — GPT-2 模型的词汇大小。定义了在调用 GPTBigCodeModel 时可以表示的不同标记数量。

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

• n_embd (int, optional, 默认为 768) — 嵌入和隐藏状态的维度。

• n_layer (int, optional, 默认为 12) — Transformer 编码器中的隐藏层数量。

• n_head (int, optional, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。

• n_inner (int, optional, 默认为 None) — 内部前馈层的维度。None将将其设置为 4 倍的 n_embd。

• activation_function (str, optional, 默认为"gelu_pytorch_tanh") — 激活函数，可在列表["relu", "silu", "gelu", "tanh", "gelu_new", "gelu_pytorch_tanh"]中选择。

• resid_pdrop (float, optional, 默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。

• embd_pdrop (float, optional, 默认为 0.1) — 嵌入的 dropout 比率。

• attn_pdrop (float, optional, 默认为 0.1) — 注意力的 dropout 比率。

• layer_norm_epsilon (float, optional, 默认为 1e-5) — 在层归一化层中使用的 epsilon。

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

• scale_attn_weights (bool, optional, 默认为True) — 通过将其除以 sqrt(hidden_size)来缩放注意力权重。

• use_cache (bool, optional, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。

• attention_softmax_in_fp32 (bool, optional, 默认为True) — 是否在 float32 中调用融合 softmax。

• scale_attention_softmax_in_fp32 (bool, optional, 默认为True) — 是否在 float32 中缩放注意力 softmax。

• attention_type (bool, optional, 默认为True) — 是否使用多查询注意力(True)或多头注意力(False)。

这是一个配置类，用于存储 GPTBigCodeModel 的配置。根据指定的参数实例化一个 GPTBigCode 模型，定义模型架构。使用默认值实例化配置将产生类似于 GPTBigCode gpt_bigcode架构的配置。

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

示例：

>>> from transformers import GPTBigCodeConfig, GPTBigCodeModel

>>> # Initializing a GPTBigCode configuration
>>> configuration = GPTBigCodeConfig()

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

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

GPTBigCodeModel

class transformers.GPTBigCodeModel

< source >

( config )

参数

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

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

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

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

forward

< source >

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions or tuple(torch.FloatTensor)

参数

• input_ids（形状为 (batch_size, input_ids_length) 的 torch.Tensor）- 如果 past_key_values 为 None，则 input_ids_length = sequence_length，否则为 past_key_values[0][0].shape[-2]（输入过去键值状态的序列长度）。词汇表中输入序列标记的索引。

  如果使用了 past_key_values，则只应传递那些没有计算过去的 input_ids 作为 input_ids。

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

  什么是输入 ID？

• past_key_values（长度为 config.n_layers 的 Tuple[torch.Tensor]）- 包含由模型计算的预计算隐藏状态（注意力块中的键和值），如模型计算的 past_key_values 输出所示。可用于加速顺序解码。已给定其过去的 input_ids 不应作为 input_ids 传递，因为它们已经计算过。

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

  • 1 用于“未被掩码”的标记，

  • 0 用于被“掩码”掉的标记。

  如果使用了 past_key_values，则 attention_mask 需要包含用于 past_key_values 的掩码策略。换句话说，attention_mask 总是必须具有长度：len(past_key_values) + len(input_ids)

  什么是注意力掩码？

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

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

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

  • 1 表示头部未被掩盖，

  • 0 表示头部被掩盖。

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

  如果使用past_key_values，可选地只需输入最后的inputs_embeds（参见past_key_values输入）。

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

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

• 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的情况下）可以用于加速顺序解码。

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

GPTBigCodeModel 的前进方法，覆盖了__call__特殊方法。

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

例子：

>>> from transformers import AutoTokenizer, GPTBigCodeModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("bigcode/gpt_bigcode-santacoder")
>>> model = GPTBigCodeModel.from_pretrained("bigcode/gpt_bigcode-santacoder")

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

>>> last_hidden_states = outputs.last_hidden_state

GPTBigCodeForCausalLM

class transformers.GPTBigCodeForCausalLM

<来源>

( config )

参数

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

GPT_BIGCODE 模型变压器，顶部带有语言建模头（线性层，其权重与输入嵌入相关联）。

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

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

前进

<来源>

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None labels: Optional = None 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, input_ids_length)的torch.Tensor）- 如果past_key_values为None，则input_ids_length=sequence_length，否则past_key_values[0][0].shape[-2]（输入过去键值状态的序列长度）。词汇表中输入序列标记的索引。

  如果使用past_key_values，则只能将未计算其过去的input_ids作为input_ids传递。

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

  什么是输入 ID？

• past_key_values (Tuple[torch.Tensor]，长度为 config.n_layers) — 包含由模型计算的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码。将其过去传递给该模型的 input_ids 不应作为 input_ids 传递，因为它们已经被计算。

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

  • 对于未被 masked 的令牌为 1，

  • 对于被 masked 的令牌为 0。

  如果使用了 past_key_values，则 attention_mask 需要包含用于 past_key_values 的掩码策略。换句话说，attention_mask 总是需要具有长度：len(past_key_values) + len(input_ids)

  注意力掩码是什么？

• token_type_ids (torch.Tensor，形状为 (batch_size, input_ids_length)，可选) — 段令牌索引，用于指示输入的第一部分和第二部分。索引选在 [0, 1]：

  • 0 对应于 句子 A 令牌，

  • 1 对应于 句子 B 令牌。

  令牌类型 ID 是什么？

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

  位置 ID 是什么？

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

  • 1 表示头部未被 masked，

  • 0 表示头部被 masked。

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

  如果使用了 past_key_values，则可能只需要输入最后的 inputs_embeds（参见 past_key_values）。

• 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.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于语言建模的标签。请注意，模型内部的标签是偏移的，即您可以设置 labels = input_ids。索引选在 [-100, 0, ..., config.vocab_size] 所有设置为 -100 的标签都被忽略（被 masked），损失仅计算在 [0, ..., config.vocab_size] 的标签上。

返回

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

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

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

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

• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层的输出，则为嵌入层的输出+每层的输出）。

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

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

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

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

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

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

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

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

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

示例：

>>> import torch
>>> from transformers import AutoTokenizer, GPTBigCodeForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("bigcode/gpt_bigcode-santacoder")
>>> model = GPTBigCodeForCausalLM.from_pretrained("bigcode/gpt_bigcode-santacoder")

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

GPTBigCodeForSequenceClassification

class transformers.GPTBigCodeForSequenceClassification

< source >

( config )

参数

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

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

GPTBigCodeForSequenceClassification 使用最后一个令牌来进行分类，就像其他因果模型（例如 GPT-1）一样。

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

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

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

forward

<来源>

( input_ids: Optional = None past_key_values: 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 use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

• input_ids（形状为(batch_size, input_ids_length)的torch.Tensor）- 如果past_key_values为None，则input_ids_length = sequence_length，否则为past_key_values[0][0].shape[-2]（输入过去键值状态的序列长度）。词汇表中输入序列令牌的索引。

  如果使用past_key_values，则只应将未计算其过去的input_ids作为input_ids传递。

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

  什么是输入 ID？

• past_key_values（长度为config.n_layers的Tuple[torch.Tensor]）- 包含由模型计算的预计算隐藏状态（注意力块中的键和值）（请参见下面的past_key_values输出）。可用于加速顺序解码。将其过去传递给此模型的input_ids不应作为input_ids传递，因为它们已经计算过。

• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）- 用于避免在填充令牌索引上执行注意力的蒙版。蒙版值在[0, 1]中选择：

  • 对于未被掩码的令牌为 1，

  • 对于被掩码的令牌为 0。

  如果使用past_key_values，则attention_mask需要包含用于past_key_values的掩码策略。换句话说，attention_mask始终必须具有长度：len(past_key_values) + len(input_ids)

  什么是注意力蒙版？

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

  • 0 对应于句子 A令牌，

  • 1 对应于句子 B令牌。

  什么是令牌类型 ID？

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

  什么是位置 ID？

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

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

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

  如果使用past_key_values，则可能只需输入最后的inputs_embeds（参见past_key_values）。

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

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

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

GPTBigCodeForTokenClassification

class transformers.GPTBigCodeForTokenClassification

<来源>

( config )

参数

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

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

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

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

forward

<来源>

( input_ids: Optional = None past_key_values: 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 use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

• input_ids（形状为(batch_size, input_ids_length)的torch.Tensor）- 如果past_key_values为None，则input_ids_length = sequence_length，否则为past_key_values[0][0].shape[-2]（输入过去键值状态的序列长度）。词汇表中输入序列标记的索引。

  如果使用了past_key_values，则只有那些未计算过去的input_ids应作为input_ids传递。

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

  什么是输入 ID？

• past_key_values（长度为config.n_layers的Tuple[torch.Tensor]）- 包含由模型计算的预计算隐藏状态（注意力块中的键和值），如下面的past_key_values输出所示。可用于加速顺序解码。将其过去给定给该模型的input_ids不应作为input_ids传递，因为它们已经计算过。

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

  • 1 表示未被masked的标记，

  • 0 表示被masked的标记。

  如果使用了past_key_values，则attention_mask需要包含用于past_key_values的掩码策略。换句话说，attention_mask的长度始终必须为：len(past_key_values) + len(input_ids)

  什么是注意力掩码？

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

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

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

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

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

  如果使用了past_key_values，则只需输入最后的inputs_embeds（参见past_key_values）。

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

GPTBigCodeForTokenClassification 的前向方法重写了 __call__ 特殊方法。

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

GPTSAN-japanese

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

概述

GPTSAN-japanese 模型由坂本俊之（tanreinama）在仓库中发布。

GPTSAN 是一个使用 Switch Transformer 的日语语言模型。它具有与 T5 论文中介绍的 Prefix LM 模型相同的结构，并支持文本生成和掩码语言建模任务。这些基本任务同样可以用于翻译或摘要的微调。

用法示例

generate() 方法可用于使用 GPTSAN-Japanese 模型生成文本。

>>> from transformers import AutoModel, AutoTokenizer
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("Tanrei/GPTSAN-japanese")
>>> model = AutoModel.from_pretrained("Tanrei/GPTSAN-japanese").cuda()
>>> x_tok = tokenizer("は、", prefix_text="織田信長", return_tensors="pt")
>>> torch.manual_seed(0)
>>> gen_tok = model.generate(x_tok.input_ids.cuda(), token_type_ids=x_tok.token_type_ids.cuda(), max_new_tokens=20)
>>> tokenizer.decode(gen_tok[0])
'織田信長は、2004 年に『戦国 BASARA』のために、豊臣秀吉'

GPTSAN 特点

GPTSAN 具有一些独特的特点。它具有 Prefix-LM 的模型结构。它作为前缀输入 token 的移位掩码语言模型。未加前缀的输入行为类似于正常的生成模型。Spout 向量是 GPTSAN 特定的输入。Spout 在预训练时使用随机输入，但在微调期间可以指定文本类别或任意向量。这允许您指示生成文本的倾向。GPTSAN 具有基于 Switch-Transformer 的稀疏前馈。您还可以添加其他层并部分训练它们。有关详细信息，请参阅原始 GPTSAN 仓库。

Prefix-LM 模型

GPTSAN 具有 T5 论文中称为 Prefix-LM 的模型结构。（原始 GPTSAN 仓库将其称为 hybrid）在 GPTSAN 中，Prefix-LM 的 Prefix 部分，即可以由两个 token 引用的输入位置，可以指定为任意长度。对于每个批次，也可以为不同的长度指定不同的长度。这个长度适用于 tokenizer 中输入的 prefix_text 文本。tokenizer 返回 Prefix-LM 的 Prefix 部分的掩码作为 token_type_ids。模型将其中 token_type_ids 为 1 的部分视为 Prefix 部分，即输入可以引用前后两个 token。

使用提示

通过传递给自注意力的掩码来指定前缀部分。当 token_type_ids=None 或全部为零时，等同于常规因果掩码。

例如：

x_token = tokenizer(“ｱｲｳｴ”) input_ids: | SOT | SEG | ｱ | ｲ | ｳ | ｴ | token_type_ids: | 1 | 0 | 0 | 0 | 0 | 0 | prefix_lm_mask: SOT | 1 0 0 0 0 0 | SEG | 1 1 0 0 0 0 | ｱ | 1 1 1 0 0 0 | ｲ | 1 1 1 1 0 0 | ｳ | 1 1 1 1 1 0 | ｴ | 1 1 1 1 1 1 |

x_token = tokenizer("", prefix_text=“ｱｲｳｴ”) input_ids: | SOT | ｱ | ｲ | ｳ | ｴ | SEG | token_type_ids: | 1 | 1 | 1 | 1 | 1 | 0 | prefix_lm_mask: SOT | 1 1 1 1 1 0 | ｱ | 1 1 1 1 1 0 | ｲ | 1 1 1 1 1 0 | ｳ | 1 1 1 1 1 0 | ｴ | 1 1 1 1 1 0 | SEG | 1 1 1 1 1 1 |

x_token = tokenizer(“ｳｴ”, prefix_text=“ｱｲ”) input_ids: | SOT | ｱ | ｲ | SEG | ｳ | ｴ | token_type_ids: | 1 | 1 | 1 | 0 | 0 | 0 | prefix_lm_mask: SOT | 1 1 1 0 0 0 | ｱ | 1 1 1 0 0 0 | ｲ | 1 1 1 0 0 0 | SEG | 1 1 1 1 0 0 | ｳ | 1 1 1 1 1 0 | ｴ | 1 1 1 1 1 1 |

Spout Vector

Spout Vector 是用于控制文本生成的特殊向量。这个向量被视为自注意力中的第一个嵌入，以将额外的注意力引入生成的 token。在从 Tanrei/GPTSAN-japanese 发布的预训练模型中，Spout Vector 是一个通过模型中的 8 个全连接层传递的 128 维向量，并投影到充当外部注意力的空间。由全连接层投影的 Spout Vector 被分割以传递到所有自注意力。

GPTSanJapaneseConfig

class transformers.GPTSanJapaneseConfig

< source >

( vocab_size = 36000 max_position_embeddings = 1280 d_model = 1024 d_ff = 8192 d_ext = 4096 d_spout = 128 num_switch_layers = 10 num_ext_layers = 0 num_heads = 16 num_experts = 16 expert_capacity = 128 dropout_rate = 0.0 layer_norm_epsilon = 1e-05 router_bias = False router_jitter_noise = 0.0 router_dtype = 'float32' router_ignore_padding_tokens = False output_hidden_states = False output_attentions = False initializer_factor = 0.002 output_router_logits = False use_cache = True separator_token_id = 35998 pad_token_id = 35995 eos_token_id = 35999 **kwargs )

参数

• vocab_size (int, optional, defaults to 36000) — GPTSANJapanese 模型的词汇量。定义了在调用 GPTSanJapaneseModel 时可以表示的不同 token 数量。

• max_position_embeddings (int, optional, defaults to 1280) — 该模型可能使用的最大序列长度。默认设置为 1280。

• d_model (int, optional, defaults to 1024) — 编码器层和池化层的大小。

• d_ff (int, optional, defaults to 8192) — 每个SwitchTransformersBlock中间级前馈层的大小。

• d_ext (int, optional, defaults to 4096) — 额外层中间前馈层的大小。

• d_spout (int, optional, defaults to 128) — spout向量的大小。

• num_switch_layers (int, optional, defaults to 10) — Switch Transformer 层中的层数。

• num_ext_layers (int, optional, defaults to 0) — 额外层中的层数。

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

• num_experts (int, optional, defaults to 16) — 每个 SwitchTransformer 层的专家数量。

• expert_capacity (int, optional, defaults to 128) — 每个专家可以存储的令牌数量。如果设置为 1，则模型将表现得像一个常规 Transformer。

• dropout_rate (float, optional, defaults to 0.0) — 所有 dropout 层的比率。

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

• router_bias (bool, optional, defaults to False) — 是否向路由器添加偏置。

• router_jitter_noise (float, optional, defaults to 0.0) — 添加到路由器的噪声量。在预测期间将其设置为 0.0，或者在训练期间设置一个小值（通常为 1e-2）。

• router_dtype (str, optional, default to "float32") — 用于路由器的dtype。最好将dtype保持为在论文中指定的"float32"类型。

• router_ignore_padding_tokens (bool, optional, defaults to False) — 在路由时是否忽略填充标记。

• output_hidden_states (bool, optional, default to False) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• output_attentions (bool, optional, defaults to False) — 是否返回所有注意力层的注意力张量。

• initializer_factor (float, optional, defaults to 0.002) — 用于初始化所有权重矩阵的因子。

• output_router_logits (bool, optional, default to False) — 是否返回所有专家的路由器 logits。

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

这是一个配置类，用于存储 GPTSanJapaneseModel 的配置。根据指定的参数实例化一个 GPTSANJapanese 模型，定义模型架构。使用默认值实例化配置将产生类似于 GPTSANJapaneseTanrei/GPTSAN-japanese架构的配置。

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

GPTSanJapaneseTokenizer

class transformers.GPTSanJapaneseTokenizer

< source >

( vocab_file emoji_file unk_token = '<|nottoken|>' pad_token = '<|separator|>' bos_token = '<|startoftext|>' eos_token = '<|endoftext|>' sep_token = '<|segmenter|>' do_clean_text = False **kwargs )

参数

• vocab_file (str) — 包含词汇表的文件。

• emoji_file (str) — 包含表情符号的文件。

• unk_token（str，optional，默认为"<|nottoken|>"）--用于未知字符的令牌

• pad_token（str，optional，默认为“<[UNK]分隔符[UNK]>”）--用于填充的令牌

• bos_token（str，optional，默认为"<|startoftext|>"）--序列标记的开头。

• eos_token（str，optional，默认为"<|endoftext|>"）--序列结束标记。

• sep_token（str，optional，默认为"<|segmenter|>"）--一个特殊的令牌，用于分隔前缀部分和一般输入部分的令牌。

• do_clean_text（bool，可选，默认为False） - 是否清理 URL、EMAIL、TEL、日语日期和日语价格的文本。

此标记器基于 GPTNeoXJapaneseTokenizer，并具有以下修改

• 正确解码字节 0~字节 255 的标记

• 添加了 bagofword 标记处理

• 为 Prefix-LM 模型返回 token_type_ids。 bagofword 标记表示前一个标记的重复，并在解码时转换为 3 个连续的标记。此外，原始的日语特殊 Sub-Word-Encoding 已在此存储库中发布（github.com/tanreinama/Japanese-BPEEncoder_V2）。 token_type_ids 是一个掩码，指示 Prefix-LM 模型的前缀输入位置。要指定前缀位置，请为 prefix_text 指定前缀输入，或将前缀部分和其后部分作为批量输入的文本对指定为前缀部分。

示例：

>>> from transformers import GPTSanJapaneseTokenizer

>>> tokenizer = GPTSanJapaneseTokenizer.from_pretrained("Tanrei/GPTSAN-japanese")
>>> # You can confirm both 慶応 and 慶應 are encoded to 17750
>>> tokenizer("吾輩は猫である🐯。実は慶応(慶應)大学出身")["input_ids"]
[35993, 35998, 34347, 31459, 30647, 31448, 25, 30659, 35729, 35676, 32417, 30647, 17750, 35589, 17750, 35590, 321, 1281]

>>> # Both 慶応 and 慶應 are decoded to 慶応
>>> tokenizer.decode(tokenizer("吾輩は猫である🐯。実は慶応(慶應)大学出身")["input_ids"])
'吾輩は猫である🐯。実は慶応(慶応)大学出身'

前缀-LM 示例：

>>> from transformers import GPTSanJapaneseTokenizer

>>> tokenizer = GPTSanJapaneseTokenizer.from_pretrained("Tanrei/GPTSAN-japanese")
>>> tokenizer("実は慶応(慶應)大学出身", prefix_text="吾輩は猫である🐯。")["input_ids"]
[35993, 34347, 31459, 30647, 31448, 25, 30659, 35729, 35676, 35998, 32417, 30647, 17750, 35589, 17750, 35590, 321, 1281]

>>> # Mask for Prefix-LM inputs
>>> tokenizer("実は慶応(慶應)大学出身", prefix_text="吾輩は猫である🐯。")["token_type_ids"]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]

批量编码示例：

>>> from transformers import GPTSanJapaneseTokenizer

>>> tokenizer = GPTSanJapaneseTokenizer.from_pretrained("Tanrei/GPTSAN-japanese")
>>> tokenizer([["武田信玄", "は、"], ["織田信長", "の配下の、"]], padding=True)["input_ids"]
[[35993, 8640, 25948, 35998, 30647, 35675, 35999, 35999], [35993, 10382, 9868, 35998, 30646, 9459, 30646, 35675]]

>>> # Mask for Prefix-LM inputs
>>> tokenizer([["武田信玄", "は、"], ["織田信長", "の配下の、"]], padding=True)["token_type_ids"]
[[1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 0, 0, 0, 0, 0]]

>>> # Mask for padding
>>> tokenizer([["武田信玄", "は、"], ["織田信長", "の配下の、"]], padding=True)["attention_mask"]
[[1, 1, 1, 1, 1, 1, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1]]

convert_tokens_to_string

<来源>

( tokens )

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

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None )

标记器返回 token_type_ids 作为前缀部分和其余部分之间的分隔符。 token_type_ids 对于前缀部分为 1，对于其余标记为 0。

示例：

>>> from transformers import GPTSanJapaneseTokenizer

>>> tokenizer = GPTSanJapaneseTokenizer.from_pretrained("Tanrei/GPTSAN-japanese")
>>> x_token = tokenizer("ｱｲｳｴ")
>>> # input_ids:      | SOT | SEG | ｱ | ｲ | ｳ | ｴ |
>>> # token_type_ids: | 1   | 0   | 0 | 0 | 0 | 0 |

>>> x_token = tokenizer("", prefix_text="ｱｲｳｴ")
>>> # input_ids:      | SOT | ｱ | ｲ | ｳ | ｴ | SEG |
>>> # token_type_ids: | 1   | 1 | 1 | 1 | 1 | 0  |

>>> x_token = tokenizer("ｳｴ", prefix_text="ｱｲ")
>>> # input_ids:      | SOT | ｱ | ｲ | SEG | ｳ | ｴ |
>>> # token_type_ids: | 1   | 1 | 1 | 0   | 0 | 0 |

GPTSanJapaneseModel

class transformers.GPTSanJapaneseModel

<来源>

( config: GPTSanJapaneseConfig )

参数

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

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

GPTSAN-japanese模型是基于通用 Swich 变压器的日语语言模型

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None spout: Optional = None past_key_values: Optional = None head_mask: Optional = None use_cache: Optional = False inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None output_router_logits: Optional = None num_precontext: Optional = None )

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor） - 词汇表中输入序列标记的索引。GPTSAN-japanese 是一个生成句子延续或预测掩码位置标记的模型。用于模型输入的特殊标记会自动附加。

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

  • 对于未掩码的标记为 1，

  • 对于masked的标记为 0。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的torch.FloatTensor，可选） - 用于掩盖 Prefix-LM 输入中的前缀部分的输入。选择的掩码值为[0, 1]：

  • 对于prefix输入的标记，

  • 对于not-prefix输入的标记为 0。

• spout（形状为(batch_size, config.d_spout)的torch.Tensor） - 通过 8 层 FFN 转换的向量，可以用于替代past_key_values。

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

• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于将自注意力模块的选定头部置零的掩码。掩码值选定在[0, 1]之间：

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

• 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索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• output_attentions (bool，optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states (bool，optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

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

• router_logits (tuple(torch.FloatTensor)，optional，当传递output_router_logits=True或config.add_router_probs=True时返回） — 形状为(batch_size, sequence_length, num_experts)的torch.FloatTensor元组（每层一个）。解码器模型的路由器对数，有助于计算混合专家模型的辅助损失。

• num_precontext (torch.LongTensor，形状为(batch_size,1)) — 输入中hybrid标记的长度。直到此长度的标记同时指向前后，类似于 BERT，之后的标记只指向前，类似于 GPT。另请参阅：github.com/tanreinama/GPTSAN/blob/main/report/model.md

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

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

GPTSanJapaneseForConditionalGeneration

class transformers.GPTSanJapaneseForConditionalGeneration

<来源>

( config: GPTSanJapaneseConfig )

参数

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

具有语言建模头的裸 GPTSAN-japanese 模型。

GPTSAN-japanese模型是基于通用开关变压器的日语语言模型

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None spout: Optional = None past_key_values: Optional = None head_mask: Optional = None use_cache: Optional = False inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None output_router_logits: Optional = None labels: Optional = None )

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。GPTSAN-japanese 是一个生成句子延续或预测掩码位置的标记的模型。输入模型所需的特殊标记会自动附加。

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

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

  • 0 表示被掩码的标记。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 用于掩盖前缀-LM 输入中的前缀部分的输入。掩码值选在[0, 1]之间：

  • 1 表示前缀输入的标记，

  • 0 表示非前缀输入的标记。

• spout（形状为(batch_size, config.d_spout)的torch.Tensor）- 通过 8 层 FFN 转换的向量，可以用来替代past_key_values。

• past_key_values（长度为config.n_layers的tuple(tuple(torch.FloatTensor))，每个元组有 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的张量）- 包含注意力块的预计算键和值隐藏状态。可用于加速解码。

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

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

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

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

• decoder_inputs_embeds（形状为(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。如果使用past_key_values，可以选择只输入最后一个decoder_inputs_embeds（参见past_key_values）。如果您想要更多控制权来将decoder_input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。

• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。

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

• router_logits (tuple(torch.FloatTensor)，可选，当传递 output_router_logits=True 或 config.add_router_probs=True 时返回) — 形状为 (batch_size, sequence_length, num_experts) 的 torch.FloatTensor 元组（每层一个）。解码器模型的路由器对数，用于计算混合专家模型的辅助损失。

• labels (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算序列分类损失的标签。索引应在 [-100, 0, ..., config.vocab_size - 1] 中。所有设置为 -100 的标签都被忽略（掩码），损失仅计算 [0, ..., config.vocab_size] 中的标签

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

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

示例：

带有常规 LM 模型的文本生成

>>> from transformers import AutoModel, AutoTokenizer, trainer_utils

>>> device = "cuda"
>>> model = AutoModel.from_pretrained("Tanrei/GPTSAN-japanese").to(device)
>>> tokenizer = AutoTokenizer.from_pretrained("Tanrei/GPTSAN-japanese")
>>> x_token = tokenizer("織田信長は、", return_tensors="pt")
>>> trainer_utils.set_seed(30)
>>> input_ids = x_token.input_ids.to(device)
>>> gen_token = model.generate(input_ids, max_new_tokens=50)
>>> tokenizer.decode(gen_token[0])
"織田信長は、政治・軍事の中枢まで掌握した政治家であり、日本史上類を見ない驚異的な軍事侵攻を続け..."

带有前缀-LM 模型的文本生成

>>> from transformers import AutoModel, AutoTokenizer, trainer_utils

>>> device = "cuda"
>>> model = AutoModel.from_pretrained("Tanrei/GPTSAN-japanese").to(device)
>>> tokenizer = AutoTokenizer.from_pretrained("Tanrei/GPTSAN-japanese")
>>> x_token = tokenizer("", prefix_text="織田信長は、", return_tensors="pt")
>>> trainer_utils.set_seed(30)
>>> input_ids = x_token.input_ids.to(device)
>>> token_type_ids = x_token.token_type_ids.to(device)
>>> gen_token = model.generate(input_ids, token_type_ids=token_type_ids, max_new_tokens=50)
>>> tokenizer.decode(gen_token[0])
"織田信長は、政治・外交で数々の戦果を上げるが、1568 年からは、いわゆる本能寺の変で細川晴元に暗殺される..."

同时进行文本生成和掩码语言模型

>>> from transformers import AutoModel, AutoTokenizer, trainer_utils

>>> device = "cuda"
>>> model = AutoModel.from_pretrained("Tanrei/GPTSAN-japanese").to(device)
>>> tokenizer = AutoTokenizer.from_pretrained("Tanrei/GPTSAN-japanese")
>>> masked_sentence = "武田信玄は、<|inputmask|>時代ファンならぜひ押さえ<|inputmask|>きたい名将の一人。"
>>> x_token = tokenizer("", prefix_text=masked_sentence, return_tensors="pt")
>>> trainer_utils.set_seed(30)
>>> input_ids = x_token.input_ids.to(device)
>>> token_type_ids = x_token.token_type_ids.to(device)
>>> out_lm_token = model.generate(input_ids, token_type_ids=token_type_ids, max_new_tokens=50)
>>> out_mlm_token = model(input_ids, token_type_ids=token_type_ids).logits.argmax(axis=-1)
>>> tokenizer.decode(out_mlm_token[0])
"武田信玄は、戦国時代ファンならぜひ押さえておきたい名将の一人。"

>>> tokenizer.decode(out_lm_token[0][input_ids.shape[1] :])
"武田氏の三代に渡った武田家のひとり\n 甲斐市に住む、日本史上最大の戦国大名。..."

GPT-Sw3

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

概述

GPT-Sw3 模型首次提出于 Lessons Learned from GPT-SW3: Building the First Large-Scale Generative Language Model for Swedish 由 Ariel Ekgren, Amaru Cuba Gyllensten, Evangelia Gogoulou, Alice Heiman, Severine Verlinden, Joey Öhman, Fredrik Carlsson, Magnus Sahlgren 撰写。

自第一篇论文以来，作者已经扩展了他们的工作，并在他们的新 1.2TB 语料库上训练了新模型，名为 The Nordic Pile。

GPT-Sw3 是由 AI Sweden 与 RISE 和 WASP WARA for Media and Language 合作开发的一组大型仅解码器预训练的变压器语言模型。GPT-Sw3 在包含 320B 个瑞典语、挪威语、丹麦语、冰岛语、英语和编程代码的数据集上进行了训练。该模型使用了因果语言建模（CLM）目标进行预训练，利用了 NeMo Megatron GPT 实现。

此模型由 AI Sweden Models 贡献。

使用示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("AI-Sweden-Models/gpt-sw3-356m")
>>> model = AutoModelForCausalLM.from_pretrained("AI-Sweden-Models/gpt-sw3-356m")

>>> input_ids = tokenizer("Träd är fina för att", return_tensors="pt")["input_ids"]

>>> generated_token_ids = model.generate(inputs=input_ids, max_new_tokens=10, do_sample=True)[0]

>>> print(tokenizer.decode(generated_token_ids))
Träd är fina för att de är färgstarka. Men ibland är det fint

资源

• 文本分类任务指南

• 标记分类任务指南

• 因果语言建模任务指南

该实现使用 GPT2Model 与我们的 GPTSw3Tokenizer 结合。请参考 GPT2Model 文档 获取 API 参考和示例。

请注意，使用我们的标记器需要 sentencepiece，并可通过 pip install transformers[sentencepiece] 或 pip install sentencepiece 进行安装。

GPTSw3Tokenizer

class transformers.GPTSw3Tokenizer

< source >

( vocab_file do_lower_case = False remove_space = False keep_accents = False pad_token = None unk_token = None eos_token = None bos_token = None sp_model_kwargs: Optional = None **kwargs )

参数

• vocab_file (str) — 包含实例化标记器所需词汇表的 SentencePiece 文件（通常具有 .spm 扩展名）。

• do_lower_case (bool, optional, 默认为 False) — 在标记化时是否将输入转换为小写。

• remove_space (bool, optional, 默认为 False) — 在标记化时是否去除文本（删除字符串前后的多余空格）。

• keep_accents (bool, optional, 默认为 False) — 在标记化时是否保留重音。

• pad_token (str, optional) — 用于填充的标记，例如在批处理不同长度的序列时使用。如果未提供，默认为 ’’ 或 ’’，取决于模型大小。

• unk_token (str, optional) — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。如果未提供，默认为 ’‘。

• eos_token（str，可选）--在预训练过程中看到的序列结束标记。如果未提供，则默认为<|endoftext|>

• bos_token（str，optional）--可用于下游任务的序列标记的开头，在预训练过程中没有看到。如果未提供，将默认为~~或<|endoftext|>，具体取决于模型大小

• sp_model_kwargs (dict, optional) — 将传递给 SentencePieceProcessor.__init__() 方法的参数。SentencePiece 的 Python 封装 可以用来设置：

  • enable_sampling: 启用子词规范化。

  • nbest_size: unigram 的抽样参数。对于 BPE-Dropout 无效。

    • nbest_size = {0,1}: 不执行抽样。

    • nbest_size > 1: 从 nbest_size 结果中进行抽样。

    • nbest_size < 0: 假设 nbest_size 为无限，并使用前向过滤和后向抽样算法从所有假设（格）中进行抽样。

  • alpha: unigram 抽样的平滑参数，以及 BPE-Dropout 合并操作的丢弃概率。

• sp_model (SentencePieceProcessor) — 用于每次转换（字符串、标记和 ID）的 SentencePiece 处理器。

• whitespaces (set) — 在预处理中进行空格规范化时替换的空格。

• non_printing_characters_re (Pattern) — 编译后的正则表达式，用于在预处理中删除非打印字符。

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

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

示例用法：

>>> from transformers import GPTSw3Tokenizer

>>> tokenizer = GPTSw3Tokenizer.from_pretrained("AI-Sweden-Models/gpt-sw3-126m")
>>> tokenizer("Svenska är kul!")["input_ids"]
[1814, 377, 3617, 63504]

save_vocabulary

< source >

( save_directory: str filename_prefix: Optional = None )

HerBERT

原始文本: huggingface.co/docs/transformers/v4.37.2/en/model_doc/herbert

概述

HerBERT 模型是由 Piotr Rybak、Robert Mroczkowski、Janusz Tracz 和 Ireneusz Gawlik 在波兰语理解全面基准 KLEJ中提出的。它是一个基于 BERT 的语言模型，仅使用 MLM 目标在波兰语语料库上训练，动态屏蔽整个单词。

论文摘要如下:

近年来，一系列基于 Transformer 的模型在一般自然语言理解（NLU）任务中取得了重大进展。这样快速的研究进展不可能没有一般 NLU 基准，这些基准允许对所提出的方法进行公平比较。然而，这样的基准仅适用于少数几种语言。为了缓解这个问题，我们引入了一个全面的波兰语理解多任务基准，并附带在线排行榜。它包括一系列多样的任务，从现有的命名实体识别、问答、文本蕴涵等数据集中采用。我们还为电子商务领域引入了一个新的情感分析任务，名为 Allegro Reviews（AR）。为了确保一个共同的评估方案，并促进能够泛化到不同 NLU 任务的模型，该基准包括来自不同领域和应用的数据集。此外，我们发布了 HerBERT，这是一个专门为波兰语训练的基于 Transformer 的模型，它在平均性能方面表现最佳，并在九项任务中的三项中取得最佳结果。最后，我们提供了广泛的评估，包括几个标准基线和最近提出的多语言 Transformer 模型。

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

用法示例

>>> from transformers import HerbertTokenizer, RobertaModel

>>> tokenizer = HerbertTokenizer.from_pretrained("allegro/herbert-klej-cased-tokenizer-v1")
>>> model = RobertaModel.from_pretrained("allegro/herbert-klej-cased-v1")

>>> encoded_input = tokenizer.encode("Kto ma lepszą sztukę, ma lepszy rząd – to jasne.", return_tensors="pt")
>>> outputs = model(encoded_input)

>>> # HerBERT can also be loaded using AutoTokenizer and AutoModel:
>>> import torch
>>> from transformers import AutoModel, AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("allegro/herbert-klej-cased-tokenizer-v1")
>>> model = AutoModel.from_pretrained("allegro/herbert-klej-cased-v1")

Herbert 的实现与BERT相同，除了分词方法。有关 API 参考和示例，请参考 BERT 文档。

HerbertTokenizer

class transformers.HerbertTokenizer

<来源>

( vocab_file merges_file tokenizer_file = None cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' sep_token = '</s>' bos_token = '<s>' do_lowercase_and_remove_accent = False additional_special_tokens = ['<special0>', '<special1>', '<special2>', '<special3>', '<special4>', '<special5>', '<special6>', '<special7>', '<special8>', '<special9>'] lang2id = None id2lang = None **kwargs )

构建 HerBERT 的 BPE 分词器。

特点:

• 使用 BERT 的预分词器：BaseTokenizer 在空格上分割标记，也在标点上分割。每个标点字符的出现将被单独处理。

• 这种预分词输入是 BPE 子标记化的

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

build_inputs_with_special_tokens

<来源>

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

参数

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

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

返回

List[int]

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

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

• 单个序列: <s> X </s>

• 序列对: <s> A </s> B </s>

convert_tokens_to_string

<来源>

( tokens )

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

create_token_type_ids_from_sequences

<来源>

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

参数

• token_ids_0 (List[int]) — ID 列表。

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

返回

List[int]

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

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

序列对掩码具有以下格式：

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

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

get_special_tokens_mask

<来源>

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

参数

• token_ids_0 (List[int]) — ID 列表。

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

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

返回

List[int]

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

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

HerbertTokenizerFast

class transformers.HerbertTokenizerFast

<来源>

( vocab_file = None merges_file = None tokenizer_file = None cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' sep_token = '</s>' **kwargs )

参数

• vocab_file (str) — 词汇文件的路径。

• merges_file (str) — 合并文件的路径。

为 HerBERT 构建一个“快速”BPE 标记器（由 HuggingFace 的tokenizers库支持）。

特殊之处：

• 使用 BERT 的预标记器：BertPreTokenizer 在空格上分割标记，也在标点上分割。每个标点字符的出现将被单独处理。

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

build_inputs_with_special_tokens

<来源>

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

参数

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

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

返回

List[int]

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

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

• 单个序列：<s> X </s>

• 序列对：<s> A </s> B </s>

create_token_type_ids_from_sequences

<来源>

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

参数

• token_ids_0 (List[int]) — ID 列表。

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

返回

List[int]

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

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

BERT 序列对掩码具有以下格式：

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

get_special_tokens_mask

<来源>

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

参数

• token_ids_0 (List[int]) — ID 列表。

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

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

返回

List[int]

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

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

I-BERT

原始文本: huggingface.co/docs/transformers/v4.37.2/en/model_doc/ibert

概述

I-BERT 模型是由 Sehoon Kim、Amir Gholami、Zhewei Yao、Michael W. Mahoney 和 Kurt Keutzer 在 I-BERT: Integer-only BERT Quantization 中提出的。它是 RoBERTa 的量化版本，推理速度提高了最多四倍。

论文的摘要如下:

基于 Transformer 的模型，如 BERT 和 RoBERTa，在许多自然语言处理任务中取得了最先进的结果。然而，它们的内存占用、推理延迟和功耗对于在边缘进行高效推理，甚至在数据中心进行推理是禁锢的。虽然量化可以是解决这个问题的可行方案，但以前关于量化基于 Transformer 的模型的工作在推理过程中使用浮点运算，这不能有效利用整数逻辑单元，如最近的图灵张量核心，或传统的仅整数 ARM 处理器。在这项工作中，我们提出了 I-BERT，一种用于基于 Transformer 的模型的新型量化方案，它使用纯整数算术对整个推理进行量化。基于轻量级整数逼近方法进行非线性操作，例如 GELU、Softmax 和 Layer Normalization，I-BERT 执行端到端的整数 BERT 推理，没有任何浮点计算。我们使用 RoBERTa-Base/Large 在 GLUE 下游任务上评估我们的方法。我们展示，对于这两种情况，与全精度基线相比，I-BERT 实现了类似（甚至稍高）的准确性。此外，我们对 T4 GPU 系统上的 INT8 推理的 I-BERT 的初步实现显示，与 FP32 推理相比，速度提高了 2.4 - 4.0 倍。该框架已在 PyTorch 中开发并已开源。

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

资源

• 文本分类任务指南

• 标记分类任务指南

• 问答任务指南

• 遮盖语言建模任务指南

• 多项选择任务指南

IBertConfig

class transformers.IBertConfig

<来源>

( vocab_size = 30522 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 position_embedding_type = 'absolute' quant_mode = False force_dequant = 'none' **kwargs )

参数

• vocab_size (int, optional, 默认为 30522) — I-BERT 模型的词汇量。定义了在调用 IBertModel 时可以表示的不同标记的数量。

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

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

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

• intermediate_size (int, optional, 默认为 3072) — Transformer 编码器中“中间”（通常称为前馈）层的维度。

• hidden_act (str 或 Callable, optional, 默认为"gelu") — 编码器和池化层中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu" 和"gelu_new"。

• hidden_dropout_prob (float, optional, 默认为 0.1) — 嵌入层、编码器和池化层中所有全连接层的丢弃概率。

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

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

• type_vocab_size（int，可选，默认为 2）— 在调用 IBertModel 时传递的token_type_ids的词汇表大小。

• initializer_range（float，可选，默认为 0.02）— 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps（float，可选，默认为 1e-12）— 层归一化层使用的ε。

• position_embedding_type（str，可选，默认为"absolute"）— 位置嵌入的类型。选择"absolute"、"relative_key"、"relative_key_query"之一。对于位置嵌入，请使用"absolute"。有关"relative_key"的更多信息，请参阅Self-Attention with Relative Position Representations (Shaw et al.)。有关"relative_key_query"的更多信息，请参阅Improve Transformer Models with Better Relative Position Embeddings (Huang et al.)中的Method 4。

• quant_mode（bool，可选，默认为False）— 是否对模型进行量化。

• force_dequant（str，可选，默认为"none"）— 强制去量化特定的非线性层。然后，去量化的层将以完整精度执行。支持"none"、"gelu"、"softmax"、"layernorm"和"nonlinear"。默认情况下，它设置为"none"，不去量化任何层。请指定"gelu"、"softmax"或"layernorm"以去量化 GELU、Softmax 或 LayerNorm。"nonlinear"将去量化所有非线性层，即 GELU、Softmax 和 LayerNorm。

这是一个配置类，用于存储 IBertModel 的配置。根据指定的参数实例化一个 I-BERT 模型，定义模型架构。使用默认值实例化配置将产生类似于 IBERT kssteven/ibert-roberta-base架构的配置。

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

IBertModel

class transformers.IBertModel

<来源>

( config add_pooling_layer = True )

参数

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

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

这个模型继承自 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中描述的架构。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 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 而不是一个普通元组。

返回

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

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

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

• pooler_output (torch.FloatTensor，形状为(batch_size, hidden_size)) — 经过辅助预训练任务中使用的层进一步处理后，序列中第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 系列模型，这返回经过线性层和 tanh 激活函数处理后的分类标记。线性层权重是从预训练期间的下一个句子预测（分类）目标中训练的。

• hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每层的输出）。

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

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

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

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

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

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

例子：

>>> from transformers import AutoTokenizer, IBertModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("kssteven/ibert-roberta-base")
>>> model = IBertModel.from_pretrained("kssteven/ibert-roberta-base")

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

>>> last_hidden_states = outputs.last_hidden_state

IBertForMaskedLM

class transformers.IBertForMaskedLM

<来源>

( config )

参数

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

I-BERT 模型顶部带有语言建模头。

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

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

forward

<来源>

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

参数

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

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

  什么是输入 ID？

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

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

  • 0 表示被掩码的标记。

  什么是注意力掩码？

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

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

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

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

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

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

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

返回

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

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

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

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

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

示例：

>>> from transformers import AutoTokenizer, IBertForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("kssteven/ibert-roberta-base")
>>> model = IBertForMaskedLM.from_pretrained("kssteven/ibert-roberta-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)

IBertForSequenceClassification

class transformers.IBertForSequenceClassification

<来源>

( config )

参数

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

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

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

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

forward

<来源>

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

参数

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

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

  什么是输入 ID？

• attention_mask (torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的蒙版。蒙版值选择在 [0, 1] 范围内：

  • 1 对应于未被 蒙版 的标记，

  • 0 代表被 蒙版 的标记。

  什么是注意力蒙版？

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

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

• head_mask (torch.FloatTensor，形状为(num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块的特定头部失效的蒙版。蒙版值选择在 [0, 1] 范围内：

  • 1 表示头部未被 蒙版，

  • 0 表示头部被 蒙版。

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

• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回张量中的 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 时）包含根据配置（IBertConfig）和输入的不同元素。

• loss (torch.FloatTensor，形状为(1,)，可选，在提供 labels 时返回) — 分类（如果 config.num_labels==1 则为回归）损失。

• logits (torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。

• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — torch.FloatTensor元组（用于嵌入的输出，如果模型有嵌入层，则为一个 + 每个层的输出）的形状为(batch_size, sequence_length, hidden_size)。

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

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

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

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

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

单标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, IBertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("kssteven/ibert-roberta-base")
>>> model = IBertForSequenceClassification.from_pretrained("kssteven/ibert-roberta-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 = IBertForSequenceClassification.from_pretrained("kssteven/ibert-roberta-base", num_labels=num_labels)

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

多标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, IBertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("kssteven/ibert-roberta-base")
>>> model = IBertForSequenceClassification.from_pretrained("kssteven/ibert-roberta-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 = IBertForSequenceClassification.from_pretrained(
...     "kssteven/ibert-roberta-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

IBertForMultipleChoice

class transformers.IBertForMultipleChoice

<来源>

( config )

参数

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

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

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

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

forward

<来源>

( input_ids: Optional = None token_type_ids: Optional = None attention_mask: Optional = None labels: 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.MultipleChoiceModelOutput or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

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

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

  • 对于被masked的标记为 0。

  什么是注意力掩码？

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

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

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

  什么是标记类型 ID？

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

  什么是位置 ID？

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

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• inputs_embeds (torch.FloatTensor，形状为(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，形状为(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时）包含各种元素，具体取决于配置（IBertConfig）和输入。

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

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

  分类得分（SoftMax 之前）。

• hidden_states (tuple(torch.FloatTensor)，optional，当传递output_hidden_states=True或当config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层的输出，则为嵌入的输出+每层的输出）。

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

• attentions (tuple(torch.FloatTensor)，optional，当传递output_attentions=True或当config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。

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

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

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

示例：

>>> from transformers import AutoTokenizer, IBertForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("kssteven/ibert-roberta-base")
>>> model = IBertForMultipleChoice.from_pretrained("kssteven/ibert-roberta-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

IBertForTokenClassification

class transformers.IBertForTokenClassification

< source >

( config )

参数

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

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

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

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

forward

< source >

( 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 表示头部未被掩盖，

  • 0 表示头部被掩盖。

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

• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。

• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。

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

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

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

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

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

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

示例：

>>> from transformers import AutoTokenizer, IBertForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("kssteven/ibert-roberta-base")
>>> model = IBertForTokenClassification.from_pretrained("kssteven/ibert-roberta-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

IBertForQuestionAnswering

class transformers.IBertForQuestionAnswering

<来源>

( config )

参数

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

I-BERT 模型，顶部带有用于提取问答任务（如 SQuAD）的跨度分类头（在隐藏状态输出的线性层上计算跨度起始 logits和跨度结束 logits）。

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

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → 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（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算标记范围开始位置的位置（索引）的标签，以计算标记分类损失。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内以计算损失。

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

返回

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

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

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

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

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

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

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

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

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

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

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

示例：

>>> from transformers import AutoTokenizer, IBertForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("kssteven/ibert-roberta-base")
>>> model = IBertForQuestionAnswering.from_pretrained("kssteven/ibert-roberta-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

Jukebox

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

概述

Jukebox 模型在 Jukebox: A generative model for music 中由 Prafulla Dhariwal, Heewoo Jun, Christine Payne, Jong Wook Kim, Alec Radford, Ilya Sutskever 提出。它引入了一个生成音乐模型，可以生成可以根据艺术家、流派和歌词进行条件化的一分钟长样本。

论文摘要如下：

我们推出了 Jukebox，这是一个在原始音频领域生成带有歌唱的音乐的模型。我们使用多尺度 VQ-VAE 来压缩原始音频的长上下文为离散代码，并使用自回归 Transformers 对其进行建模。我们展示了规模上的组合模型可以生成高保真度和多样化的歌曲，连贯性可达多分钟。我们可以根据艺术家和流派来引导音乐和声音风格，并根据不对齐的歌词来使歌唱更可控。我们发布了数千个非精选样本，以及模型权重和代码。

如下图所示，Jukebox 由 3 个仅解码器模型的 priors 组成。它们遵循 使用稀疏 Transformers 生成长序列 中描述的架构，经过修改以支持更长的上下文长度。首先，使用自编码器对文本歌词进行编码。接下来，第一个（也称为 top_prior）prior 关注从歌词编码器提取的最后隐藏状态。先前的 priors 通过 AudioConditionner 模块分别连接到前一个 priors。AudioConditioner 将先前 prior 的输出上采样到特定音频帧每秒的原始标记。元数据，如 艺术家、流派和时间，以起始标记和时间数据的位置嵌入的形式传递给每个 prior。隐藏状态被映射到 VQVAE 中最接近的码书向量，以将它们转换为原始音频。

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

使用提示

• 该模型仅支持推理。这主要是因为训练需要大量内存。欢迎提交 PR 并添加缺失的内容，以实现与 Hugging Face Trainer 的完全集成！

• 该模型非常慢，使用 V100 GPU 上的 5b 顶部 prior 生成一分钟长的音频需要 8 小时。为了自动处理模型应在其上执行的设备，请使用 accelerate。

• 与论文相反，prior 的顺序从 0 到 1，因为这样更直观：我们从 0 开始采样。

• 基于预先采样（在原始音频上进行采样）需要比祖先采样更多的内存，并且应该将 fp16 设置为 True。

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

JukeboxConfig

transformers.JukeboxConfig 类

< source >

( vqvae_config = None prior_config_list = None nb_priors = 3 sampling_rate = 44100 timing_dims = 64 min_duration = 0 max_duration = 600.0 max_nb_genres = 5 metadata_conditioning = True **kwargs )

参数

• vqvae_config (JukeboxVQVAEConfig, 可选) — JukeboxVQVAE 模型的配置。

• prior_config_list (List[JukeboxPriorConfig], 可选) — 模型中每个 JukeboxPrior 的配置列表。原始架构使用了 3 个 priors。

• nb_priors (int, 可选, 默认为 3) — 将依次采样标记的先前模型数量。每个 prior 都是条件自回归（解码器）模型，除了顶部 prior 可以包括歌词编码器。可用的模型是使用顶部 prior 和 2 个上采样 prior 进行训练的。

• sampling_rate (int, optional, defaults to 44100) — 原始音频的采样率。

• timing_dims (int, optional, defaults to 64) — JukeboxRangeEmbedding 层的维度，相当于传统的位置嵌入层。定时嵌入层将当前采样音频中的绝对位置和相对位置转换为长度为timing_dims的张量，该张量将添加到音乐标记中。

• min_duration (int, optional, defaults to 0) — 生成音频的最小持续时间

• max_duration (float, optional, defaults to 600.0) — 生成音频的最大持续时间

• max_nb_genres (int, optional, defaults to 5) — 可用于调节单个样本的最大流派数量。

• metadata_conditioning (bool, optional, defaults to True) — 是否使用元数据调节，对应于艺术家、流派和最小/最大持续时间。

这是一个配置类，用于存储 JukeboxModel 的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。使用默认值实例化配置将产生类似于openai/jukebox-1b-lyrics架构的配置。

下采样和步幅用于确定输入序列的下采样。例如，下采样 = (5,3)，步幅 = (2, 2) 将使音频下采样为 2⁵ = 32，以获得第一级代码，以及 2**8 = 256，以获得第二级代码。这在训练顶层先验和上采样器时通常是正确的。

示例：

>>> from transformers import JukeboxModel, JukeboxConfig

>>> # Initializing a Jukebox configuration
>>> configuration = JukeboxConfig()

>>> # Initializing a model from the configuration
>>> model = JukeboxModel(configuration)

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

from_configs

< source >

( prior_configs: List vqvae_config: JukeboxVQVAEConfig **kwargs ) → export const metadata = 'undefined';JukeboxConfig

返回

JukeboxConfig

配置对象的一个实例

从剪辑文本模型配置和剪辑视觉模型配置实例化一个 JukeboxConfig（或派生类）的实例。

JukeboxPriorConfig

class transformers.JukeboxPriorConfig

< source >

( act_fn = 'quick_gelu' level = 0 alignment_head = 2 alignment_layer = 68 attention_multiplier = 0.25 attention_pattern = 'enc_dec_with_lyrics' attn_dropout = 0 attn_res_scale = False blocks = 64 conv_res_scale = None num_layers = 72 emb_dropout = 0 encoder_config = None encoder_loss_fraction = 0.4 hidden_size = 2048 init_scale = 0.2 is_encoder_decoder = True lyric_vocab_size = 80 mask = False max_duration = 600 max_nb_genres = 1 merged_decoder = True metadata_conditioning = True metadata_dims = [604, 7898] min_duration = 0 mlp_multiplier = 1.0 music_vocab_size = 2048 n_ctx = 6144 n_heads = 2 nb_relevant_lyric_tokens = 384 res_conv_depth = 3 res_conv_width = 128 res_convolution_multiplier = 1 res_dilation_cycle = None res_dilation_growth_rate = 1 res_downs_t = [3, 2, 2] res_strides_t = [2, 2, 2] resid_dropout = 0 sampling_rate = 44100 spread = None timing_dims = 64 zero_out = False **kwargs )

参数

• act_fn (str, optional, defaults to "quick_gelu") — 激活函数。

• alignment_head (int, optional, defaults to 2) — 负责歌词和音乐之间对齐的头部。仅用于计算歌词到音频的对齐

• alignment_layer (int, optional, defaults to 68) — 负责歌词和音乐之间对齐的层的索引。仅用于计算歌词到音频的对齐

• attention_multiplier (float, optional, defaults to 0.25) — 用于定义注意力层隐藏维度的乘数系数。0.25 表示将使用模型宽度的 0.25。

• attention_pattern (str, optional, defaults to "enc_dec_with_lyrics") — 解码器使用的注意力模式

• attn_dropout (int, optional, defaults to 0) — 解码器中注意力层后的丢弃概率。

• attn_res_scale (bool, optional, defaults to False) — 是否在注意力调节器块中缩放残差。

• blocks (int, optional, defaults to 64) — block_attn 中使用的块数。长度为 seq_len 的序列在JukeboxAttention层中被分解为[blocks, seq_len // blocks]。

• conv_res_scale (int, optional) — 是否要在条件块中缩放残差。由于顶层先验没有条件块，因此默认值为None，不应修改。

• num_layers (int, optional, 默认为 72) — 变压器架构的层数。

• emb_dropout (int, optional, 默认为 0) — 歌词解码器中使用的嵌入丢失。

• encoder_config (JukeboxPriorConfig, optional) — 对歌词先验进行建模的编码器配置。

• encoder_loss_fraction (float, optional, 默认为 0.4) — 用于歌词编码器损失前面的乘法因子。

• hidden_size (int, optional, 默认为 2048) — 注意力层的隐藏维度。

• init_scale (float, optional, 默认为 0.2) — 先验模块的初始化比例。

• is_encoder_decoder (bool, optional, 默认为True) — 先验是否为编码器-解码器模型。如果不是，并且nb_relevant_lyric_tokens大于 0，则应为歌词编码指定encoder参数。

• mask (bool, optional, 默认为False) — 是否要屏蔽注意力中的先前位置。

• max_duration (int, optional, 默认为 600) — 生成歌曲的最大支持持续时间（以秒为单位）。

• max_nb_genres (int, optional, 默认为 1) — 可用于条件模型的最大流派数量。

• merged_decoder (bool, optional, 默认为True) — 解码器和编码器输入是否合并。这用于分离的编码器-解码器架构

• metadata_conditioning (bool, optional, 默认为True) — 是否要在艺术家和流派元数据上进行条件。

• metadata_dims (List[int], optional, 默认为[604, 7898]) — 用于训练先验模型的嵌入层的流派数量和艺术家数量。

• min_duration (int, optional, 默认为 0) — 模型训练的生成音频的最小持续时间。

• mlp_multiplier (float, optional, 默认为 1.0) — 用于定义 MLP 层隐藏维度的乘数系数。0.25 表示将使用模型宽度的 0.25。

• music_vocab_size (int, optional, 默认为 2048) — 不同音乐标记的数量。应与JukeboxVQVAEConfig.nb_discrete_codes类似。

• n_ctx (int, optional, 默认为 6144) — 每个先验的上下文标记数量。上下文标记是在生成音乐标记时所关注的音乐标记。

• n_heads (int, optional, 默认为 2) — 注意力头的数量。

• nb_relevant_lyric_tokens (int, optional, 默认为 384) — 在采样长度为n_ctx的单个窗口时使用的歌词标记数量

• res_conv_depth (int, optional, 默认为 3) — 用于在JukeboxMusicTokenConditioner中上采样先前采样音频的JukeboxDecoderConvBock的深度。

• res_conv_width (int, optional, 默认为 128) — 用于在JukeboxMusicTokenConditioner中上采样先前采样音频的JukeboxDecoderConvBock的宽度。

• res_convolution_multiplier (int, optional, 默认为 1) — 用于缩放JukeboxResConv1DBlock的hidden_dim的乘数。

• res_dilation_cycle (int, optional) — 用于定义JukeboxMusicTokenConditioner的扩张周期。通常类似于 VQVAE 相应级别中使用的周期。第一个先验不使用它，因为它不是基于上一级标记的。

• res_dilation_growth_rate (int, optional, 默认为 1) — 用于JukeboxMusicTokenConditioner的每个卷积块之间的扩张增长率

• res_downs_t (List[int], optional, 默认为[3, 2, 2]) — 音频调节网络中使用的下采样率

• res_strides_t (List[int], optional, 默认为[2, 2, 2]) — 音频调节网络中使用的步幅

• resid_dropout (int, optional, defaults to 0) — 注意力模式中使用的残差丢失。

• sampling_rate (int, optional, defaults to 44100) — 用于训练的采样率。

• spread (int, optional) — summary_spread_attention模式中使用的扩展

• timing_dims (int, optional, defaults to 64) — 时间嵌入的维度。

• zero_out (bool, optional, defaults to False) — 初始化时是否将卷积权重归零。

这是配置类，用于存储 JukeboxPrior 的配置。根据指定的参数实例化JukeboxPrior，定义模型架构。使用默认值实例化配置将产生类似于 openai/jukebox-1b-lyrics -1b-lyrics)架构顶级先验的配置。

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

JukeboxVQVAEConfig

class transformers.JukeboxVQVAEConfig

<来源>

( act_fn = 'relu' nb_discrete_codes = 2048 commit = 0.02 conv_input_shape = 1 conv_res_scale = False embed_dim = 64 hop_fraction = [0.125, 0.5, 0.5] levels = 3 lmu = 0.99 multipliers = [2, 1, 1] res_conv_depth = 4 res_conv_width = 32 res_convolution_multiplier = 1 res_dilation_cycle = None res_dilation_growth_rate = 3 res_downs_t = [3, 2, 2] res_strides_t = [2, 2, 2] sample_length = 1058304 init_scale = 0.2 zero_out = False **kwargs )

参数

• act_fn (str, optional, defaults to "relu") — 模型的激活函数。

• nb_discrete_codes (int, optional, defaults to 2048) — VQVAE 的代码数量。

• commit (float, optional, defaults to 0.02) — 提交损失乘数。

• conv_input_shape (int, optional, defaults to 1) — 音频通道数。

• conv_res_scale (bool, optional, defaults to False) — 是否对JukeboxResConv1DBlock的残差进行缩放。

• embed_dim (int, optional, defaults to 64) — 码书向量的嵌入维度。

• hop_fraction (List[int], optional, defaults to [0.125, 0.5, 0.5]) — 在继续采样过程时使用的非交叉窗口的比例。

• levels (int, optional, defaults to 3) — VQVAE 中使用的分层级别数。

• lmu (float, optional, defaults to 0.99) — 用于码书更新的指数移动平均系数。有关详细信息，请参阅原始VQVAE 论文的附录 A.1

• multipliers (List[int], optional, defaults to [2, 1, 1]) — 每个级别使用的深度和宽度乘数。用于res_conv_width和res_conv_depth

• res_conv_depth (int, optional, defaults to 4) — 编码器和解码器块的深度。如果没有使用multipliers，则每个级别的深度相同。

• res_conv_width (int, optional, defaults to 32) — 编码器和解码器块的宽度。如果没有使用multipliers，则每个级别的宽度相同。

• res_convolution_multiplier (int, optional, defaults to 1) — JukeboxResConv1DBlock中使用的隐藏维度的缩放因子。

• res_dilation_cycle (int, optional) — JukeboxResnet中使用的膨胀周期值。如果使用 int，每个新的 Conv1 块的深度将减少res_dilation_cycle的幂。

• res_dilation_growth_rate (int, optional, defaults to 3) — VQVAE 中使用的 Resnet 膨胀增长率（膨胀增长率 ** 深度）

• res_downs_t (List[int], optional, defaults to [3, 2, 2]) — 分层 VQ-VAE 每个级别的下采样率。

• res_strides_t (List[int], optional, defaults to [2, 2, 2]) — 分层 VQ-VAE 每个级别使用的步幅。

• sample_length (int, optional, defaults to 1058304) — 提供 VQVAE 的最大输入形状。用于计算每个级别的输入形状。

• init_scale (float, optional, defaults to 0.2) — 初始化比例。

• zero_out (bool, optional, defaults to False) — 是否在初始化时将卷积权重归零。

这是用于存储 JukeboxVQVAE 配置的配置类。它用于根据指定的参数实例化JukeboxVQVAE，定义模型架构。使用默认值实例化配置将产生与openai/jukebox-1b-lyrics架构的 VQVAE 类似的配置。

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

JukeboxTokenizer

class transformers.JukeboxTokenizer

<来源>

( artists_file genres_file lyrics_file version = ['v3', 'v2', 'v2'] max_n_lyric_tokens = 512 n_genres = 5 unk_token = '<|endoftext|>' **kwargs )

参数

• artists_file (str) — 包含艺术家和 id 之间映射的词汇文件的路径。默认文件支持“v2”和“v3”。

• genres_file (str) — 包含流派和 id 之间映射的词汇文件的路径。

• lyrics_file (str) — 包含歌词分词所需字符的词汇文件的路径。

• version (List[str], optional, default to ["v3", "v2", "v2"]) — 分词器版本的列表。5b-lyrics的顶级先验模型是使用v3而不是v2进行训练的。

• n_genres (int, optional, defaults to 1) — 用于作曲的最大流派数量。

• max_n_lyric_tokens (int, optional, defaults to 512) — 保留的最大歌词标记数量。

• unk_token（str，optional，默认为"<|endoftext|>"）--未知令牌。词汇表中没有的令牌无法转换为 ID，而是设置为该令牌。

构建一个 Jukebox 分词器。Jukebox 可以根据 3 种不同的输入进行条件化：

• 艺术家，唯一的 id 与提供的字典中的每位艺术家相关联。

• 流派，唯一的 id 与提供的字典中的每个流派相关联。

• 歌词，基于字符的分词。必须使用词汇表中包含的字符列表进行初始化。

这个分词器不需要训练。它应该能够处理不同数量的输入：因为模型的条件化可以在三个不同的查询上进行。如果未提供 None，则将使用默认值。

取决于模型应该被条件化的流派数量（n_genres）。

>>> from transformers import JukeboxTokenizer

>>> tokenizer = JukeboxTokenizer.from_pretrained("openai/jukebox-1b-lyrics")
>>> tokenizer("Alan Jackson", "Country Rock", "old town road")["input_ids"]
[tensor([[   0,    0,    0, 6785,  546,   41,   38,   30,   76,   46,   41,   49,
           40,   76,   44,   41,   27,   30]]), tensor([[  0,   0,   0, 145,   0]]), tensor([[  0,   0,   0, 145,   0]])]

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

如果未提供任何内容，则流派和艺术家将随机选择或设置为 None

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

但是代码不允许这样做，只支持从各种流派进行作曲。

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

参数

• save_directory (str) — 保存的目录路径。如果不存在，将创建该目录。

• filename_prefix (Optional[str], optional) — 添加到分词器保存的文件名称前缀。

将分词器的词汇字典保存到提供的保存目录中。

JukeboxModel

class transformers.JukeboxModel

<来源>

( config )

参数

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

用于音乐生成的基本 JUKEBOX 模型。支持 4 种采样技术：primed_sample、upsample、continue_sample和ancestral_sample。它没有forward方法，因为训练不是端到端的。如果要微调模型，建议使用JukeboxPrior类并分别训练每个先验。

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

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

ancestral_sample

<来源>

( labels n_samples = 1 **sampling_kwargs )

参数

• labels（List[torch.LongTensor]）- 长度为n_sample的列表，形状为(self.levels, 4 + self.config.max_nb_genre + lyric_sequence_length)，元数据，例如artist_id、genre_id和用于条件生成的完整歌词标记列表。

• n_samples（int，可选，默认为 1）- 要并行生成的样本数量。

根据提供的labels生成音乐标记。将从所需的先验级别开始，并自动上采样序列。如果要创建音频，应调用model.decode(tokens)，这将使用 VQ-VAE 解码器将音乐标记转换为原始音频。

示例：

>>> from transformers import AutoTokenizer, JukeboxModel, set_seed

>>> model = JukeboxModel.from_pretrained("openai/jukebox-1b-lyrics", min_duration=0).eval()
>>> tokenizer = AutoTokenizer.from_pretrained("openai/jukebox-1b-lyrics")

>>> lyrics = "Hey, are you awake? Can you talk to me?"
>>> artist = "Zac Brown Band"
>>> genre = "Country"
>>> metas = tokenizer(artist=artist, genres=genre, lyrics=lyrics)
>>> set_seed(0)
>>> music_tokens = model.ancestral_sample(metas.input_ids, sample_length=400)

>>> with torch.no_grad():
...     model.decode(music_tokens)[:, :10].squeeze(-1)
tensor([[-0.0219, -0.0679, -0.1050, -0.1203, -0.1271, -0.0936, -0.0396, -0.0405,
    -0.0818, -0.0697]])

primed_sample

<来源>

( raw_audio labels **sampling_kwargs )

参数

• raw_audio（长度为n_samples的List[torch.Tensor]）- 用作每个将生成的样本的条件信息的原始音频列表。

• labels（长度为n_sample的List[torch.LongTensor]，形状为(self.levels, self.config.max_nb_genre + lyric_sequence_length)）- 元数据列表，例如artist_id、genre_id和用于条件生成的完整歌词标记列表。

• sampling_kwargs（Dict[Any]）- _sample函数使用的各种额外采样参数。可以在_sample函数文档中看到参数的详细列表。

根据提供的raw_audio生成原始音频，该音频将用作每个生成级别的条件。音频被编码为音乐标记，使用 VQ-VAE 的 3 个级别。这些标记被用作每个级别的条件，这意味着不需要祖先抽样。

continue_sample

<来源>

( music_tokens labels **sampling_kwargs )

参数

• music_tokens（长度为self.levels的List[torch.LongTensor]）- 一系列音乐标记，将用作继续采样过程的上下文。应该有self.levels个张量，每个对应于特定级别的生成。

• labels（长度为n_sample的List[torch.LongTensor]，形状为(self.levels, self.config.max_nb_genre + lyric_sequence_length)）- 元数据列表，例如artist_id、genre_id和用于条件生成的完整歌词标记列表。

• sampling_kwargs (Dict[Any]) — 由_sample函数使用的各种额外采样参数。参数的详细列表可以在_sample函数文档中看到。

生成先前生成标记的延续。

upsample

<来源>

( music_tokens labels **sampling_kwargs )

参数

• music_tokens (List[torch.LongTensor]，长度为self.levels) — 一系列音乐标记，将用作继续采样过程的上下文。应该有self.levels个张量，每个对应于某个级别的生成。

• labels (List[torch.LongTensor]，长度为n_sample，形状为(self.levels, self.config.max_nb_genre + lyric_sequence_length) — 包括元数据，如artist_id、genre_id以及用于条件生成的完整歌词标记列表。

• sampling_kwargs (Dict[Any]) — 由_sample函数使用的各种额外采样参数。参数的详细列表可以在_sample函数文档中看到。

使用级别level的先验对音乐标记序列进行上采样。

_sample

<来源>

( music_tokens labels sample_levels metas = None chunk_size = 32 sampling_temperature = 0.98 lower_batch_size = 16 max_batch_size = 16 sample_length_in_seconds = 24 compute_alignments = False sample_tokens = None offset = 0 save_results = True sample_length = None )

参数

• music_tokens (List[torch.LongTensor]) — 音乐标记序列，长度为self.levels，将用作继续采样过程的上下文。应该有self.levels个张量，每个对应于某个级别的生成。

• labels (List[torch.LongTensor]) — 长度为n_sample的列表，形状为(self.levels, 4 + self.config.max_nb_genre + lyric_sequence_length)，包括artist_id、genre_id等元数据以及用于条件生成的完整歌词标记列表。

• sample_levels (List[int]) — 要进行采样的期望级别列表。级别等同于先验列表中的先验索引

• metas (List[Any], 可选) — 用于生成labels的元数据

• chunk_size (int, 可选, 默认为 32) — 音频块的大小，用于以块的形式填充内存，以防止 OOM 错误。更大的块意味着更快的内存填充但更多的消耗。

• sampling_temperature (float, 可选, 默认为 0.98) — 用于调整采样随机性的温度。

• lower_batch_size (int, 可选, 默认为 16) — 低级别先验的最大批处理大小

• max_batch_size (int, 可选, 默认为 16) — 顶层先验的最大批处理大小

• sample_length_in_seconds (int, 可选, 默认为 24) — 生成的长度（秒数）

• compute_alignments (bool, 可选, 默认为False) — 是否计算歌词和音频之间的对齐，使用顶级先验

• sample_tokens (int, 可选) — 每个级别应采样的精确标记数。这对于运行虚拟实验非常有用

• offset (int, 可选, 默认为 0) — 用作条件的音频偏移，对应于音乐中的起始样本。如果偏移大于 0，则歌词将被移位以考虑这一点

• save_results (bool, 可选, 默认为True) — 是否保存中间结果。如果为True，将生成一个以开始时间命名的文件夹。

• sample_length (int, 可选) — 生成的长度（样本数）。

用于生成音乐标记的核心采样函数。在每一步保存生成的原始音频，遍历提供的级别列表。

返回：torch.Tensor

示例：

>>> from transformers import AutoTokenizer, JukeboxModel, set_seed
>>> import torch

>>> metas = dict(artist="Zac Brown Band", genres="Country", lyrics="I met a traveller from an antique land")
>>> tokenizer = AutoTokenizer.from_pretrained("openai/jukebox-1b-lyrics")
>>> model = JukeboxModel.from_pretrained("openai/jukebox-1b-lyrics", min_duration=0).eval()

>>> labels = tokenizer(**metas)["input_ids"]
>>> set_seed(0)
>>> zs = [torch.zeros(1, 0, dtype=torch.long) for _ in range(3)]
>>> zs = model._sample(zs, labels, [0], sample_length=40 * model.priors[0].raw_to_tokens, save_results=False)
>>> zs[0]
tensor([[1853, 1369, 1150, 1869, 1379, 1789,  519,  710, 1306, 1100, 1229,  519,
      353, 1306, 1379, 1053,  519,  653, 1631, 1467, 1229, 1229,   10, 1647,
     1254, 1229, 1306, 1528, 1789,  216, 1631, 1434,  653,  475, 1150, 1528,
     1804,  541, 1804, 1434]])

JukeboxPrior

class transformers.JukeboxPrior

<来源>

( config: JukeboxPriorConfig level = None nb_priors = 3 vqvae_encoder = None vqvae_decoder = None )

参数

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

• level（int，可选）— 先验的当前级别。应在范围[0,nb_priors]内。

• nb_priors（int，可选，默认为 3）— 先验总数。

• vqvae_encoder（Callable，可选）— VQVAE 编码器在模型前向传递中使用的编码方法。传递函数而不是 vqvae 模块以避免获取参数。

• vqvae_decoder（Callable，可选）— 在模型的前向传递中使用的 VQVAE 解码器的解码方法。传递函数而不是 vqvae 模块以避免获取参数。

JukeboxPrior 类是各种条件和变压器的包装器。JukeboxPrior 可以被视为在音乐上训练的语言模型。它们对下一个音乐标记预测任务进行建模。如果定义了（歌词）编码器，它还对歌词上的下一个字符预测进行建模。可以基于定时、艺术家、流派、歌词和来自较低级先验的代码进行条件化。

sample

<来源>

( n_samples music_tokens = None music_tokens_conds = None metadata = None temp = 1.0 top_k = 0 top_p = 0.0 chunk_size = None sample_tokens = None )

参数

• n_samples（int）— 要生成的样本数。

• music_tokens（List[torch.LongTensor]，可选）— 当前级别上先前生成的标记。用作生成的上下文。

• music_tokens_conds（List[torch.FloatTensor]，可选）— 由先前先验模型生成的上层音乐标记。如果生成不是基于上层标记的，则为None。

• metadata（List[torch.LongTensor]，可选）— 包含包含艺术家、流派和歌词标记的元数据张量的列表。

• temp（float，可选，默认为 1.0）— 采样温度。

• top_k（int，可选，默认为 0）— 用于过滤的前 k 个概率。

• top_p（float，可选，默认为 0.0）— 用于过滤的前 p 个概率。

• chunk_size（int，可选）— 用于准备变压器缓存的块的大小。

• sample_tokens（int，可选）— 要采样的标记数。

使用提供的条件和元数据对标记窗口进行祖先/主要采样。

forward

<来源>

( hidden_states: Tensor metadata: Optional decode: Optional = False get_preds: Optional = False )

参数

• hidden_states（torch.Tensor）— 应为原始音频的隐藏状态

• metadata（List[torch.LongTensor]，可选）— 包含歌词和元数据标记的元数据条件张量的列表。

• decode（bool，可选，默认为False）— 是否解码编码为标记。

• get_preds（bool，可选，默认为False）— 是否返回模型的实际预测。

使用vqvae编码器对隐藏状态进行编码，然后在forward_tokens函数中预测下一个标记。损失是encoder损失和decoder损失的总和。

JukeboxVQVAE

class transformers.JukeboxVQVAE

<来源>

( config: JukeboxVQVAEConfig )

参数

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

Jukebox 中使用的分层 VQ-VAE 模型。该模型遵循Will Williams, Sam Ringer, Tom Ash, John Hughes, David MacLeod, Jamie Dougherty的 Hierarchical VQVAE 论文。

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

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

forward

<来源>

( raw_audio: FloatTensor )

参数

• raw_audio (torch.FloatTensor) — 音频输入，将被编码和解码。

VQ-VAE 的前向传递，将raw_audio编码为潜在状态，然后为每个级别解码。计算提交损失，确保编码器计算的嵌入接近码书向量。

示例：

>>> from transformers import JukeboxVQVAE, set_seed
>>> import torch

>>> model = JukeboxVQVAE.from_pretrained("openai/jukebox-1b-lyrics").eval()
>>> set_seed(0)
>>> zs = [torch.randint(100, (4, 1))]
>>> model.decode(zs).shape
torch.Size([4, 8, 1])

encode

<来源>

( input_audio start_level = 0 end_level = None bs_chunks = 1 )

参数

• input_audio（torch.Tensor）— 将被编码为其离散表示的原始音频，使用码书。将为每个样本序列计算最接近码书的code。

• start_level（int，可选，默认为 0）— 编码过程将开始的级别。默认为 0。

• end_level（int，可选）— 编码过程将开始的级别。默认为 None。

• bs_chunks（int，可选，默认为 1）— 要同时处理的原始音频块数。

将input_audio转换为由music_tokens组成的离散表示。

decode

<来源>

( music_tokens start_level = 0 end_level = None bs_chunks = 1 )

参数

• music_tokens（torch.LongTensor）— 将通过使用码书解码为原始音频的音乐标记张量。每个音乐标记应该是码书中对应code向量的索引。

• start_level（int，可选）— 解码过程将开始的级别。默认为 0。

• end_level（int，可选）— 解码过程将开始的级别。默认为 None。

• bs_chunks（int，可选）— 要同时处理的块数。

将输入的music_tokens转换为它们的raw_audio表示。

LED

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

概述

LED 模型是由 Iz Beltagy、Matthew E. Peters、Arman Cohan 在Longformer: The Long-Document Transformer中提出的。

论文的摘要如下：

基于 Transformer 的模型由于其自注意力操作，无法处理长序列，其操作随着序列长度呈二次方增长。为了解决这一限制，我们引入了 Longformer，其注意力机制与序列长度呈线性增长，使得处理数千个标记或更长文档变得容易。Longformer 的注意力机制是标准自注意力的替代品，结合了局部窗口注意力和任务驱动的全局注意力。在长序列 Transformer 的先前工作基础上，我们在字符级语言建模上评估 Longformer，并在 text8 和 enwik8 上取得了最先进的结果。与大多数先前的工作相比，我们还对 Longformer 进行预训练，并在各种下游任务上进行微调。我们的预训练 Longformer 在长文档任务上始终优于 RoBERTa，并在 WikiHop 和 TriviaQA 上取得了最新的最先进结果。最后，我们介绍了 Longformer-Encoder-Decoder（LED），这是 Longformer 的一种变体，用于支持长文档生成的序列到序列任务，并展示了其在 arXiv 摘要数据集上的有效性。

使用提示

• LEDForConditionalGeneration 是 BartForConditionalGeneration 的扩展，用Longformer的分块自注意力层替换传统的自注意力层。LEDTokenizer 是 BartTokenizer 的别名。

• LED 在长距离序列到序列任务中表现非常出色，其中input_ids大部分超过 1024 个标记的长度。

• 如果需要，LED 会将input_ids填充为config.attention_window的倍数。因此，当 LEDTokenizer 与pad_to_multiple_of参数一起使用时，可以获得一定的加速。

• LED 通过global_attention_mask（参见 LongformerModel）利用全局注意力。对于摘要，建议仅在第一个<s>标记上放置全局注意力。对于问答，建议在问题的所有标记上放置全局注意力。

• 要在所有 16384 上微调 LED，如果训练导致内存不足（OOM）错误，可以启用梯度检查点。这可以通过执行model.gradient_checkpointing_enable()来实现。此外，可以使用use_cache=False标志来禁用缓存机制以节省内存。

• LED 是一个具有绝对位置嵌入的模型，因此通常建议在右侧而不是左侧填充输入。

此模型由patrickvonplaten贡献。

资源

• 展示如何评估 LED 的笔记本。

• 展示如何微调 LED 的笔记本。

• 文本分类任务指南

• 问答任务指南

• 翻译任务指南

• 总结任务指南

LEDConfig

class transformers.LEDConfig

< source >

( vocab_size = 50265 max_encoder_position_embeddings = 16384 max_decoder_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 use_cache = True is_encoder_decoder = True activation_function = 'gelu' d_model = 1024 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 decoder_start_token_id = 2 classifier_dropout = 0.0 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 attention_window: Union = 512 **kwargs )

参数

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

• 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_encoder_position_embeddings (int, optional, defaults to 16384) — 编码器可能使用的最大序列长度。

• max_decoder_position_embeddings (int, optional, defaults to 16384) — 解码器可能使用的最大序列长度。

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

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

这是用于存储 LEDModel 配置的配置类。根据指定的参数实例化一个 LED 模型，定义模型架构。使用默认值实例化配置将产生类似于allenai/led-base-16384架构的配置。

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

示例：

>>> from transformers import LEDModel, LEDConfig

>>> # Initializing a LED allenai/led-base-16384 style configuration
>>> configuration = LEDConfig()

>>> # Initializing a model from the allenai/led-base-16384 style configuration
>>> model = LEDModel(configuration)

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

LEDTokenizer

class transformers.LEDTokenizer

< source >

( 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>") — 在预训练期间使用的序列开头标记。可用作序列分类器标记。

  在使用特殊标记构建序列时，不是用于序列开头的标记。使用的标记是 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) — 是否在输入前添加一个初始空格。这允许将前导单词视为任何其他单词。（BART 分词器通过前面的空格检测单词的开头）。

构建一个 LED 分词器，类似于 ROBERTa 分词器，使用字节级字节对编码。

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

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

>>> from transformers import LEDTokenizer

>>> tokenizer = LEDTokenizer.from_pretrained("allenai/led-base-16384")
>>> 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

< source >

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

参数

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

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

返回

List[int]

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

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

• 单个序列：<s> X </s>

• 序列对：<s> A </s></s> B </s>

get_special_tokens_mask

<来源>

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

参数

• token_ids_0（List[int]）— ID 列表。

• token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。

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

返回

List[int]

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

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

create_token_type_ids_from_sequences

<来源>

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

参数

• token_ids_0（List[int]）— ID 列表。

• token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。

返回

List[int]

零列表。

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

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

LEDTokenizerFast

class transformers.LEDTokenizerFast

<来源>

( 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）— 是否在输入前添加一个初始空格。这允许将前导单词视为任何其他单词。（LED 标记器通过前导空格检测单词的开头）。

• trim_offsets（bool，可选，默认为True）— 后处理步骤是否应修剪偏移以避免包含空格。

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

这个分词器已经训练过，将空格视为标记的一部分（有点像 sentencepiece），所以一个单词会被编码成不同的方式

无论是在句子开头（没有空格）还是不是，都会被编码成不同的方式：

>>> from transformers import LEDTokenizerFast

>>> tokenizer = LEDTokenizerFast.from_pretrained("allenai/led-base-16384")
>>> 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一起使用时，这个分词器需要用add_prefix_space=True实例化。

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

create_token_type_ids_from_sequences

<来源>

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

参数

• token_ids_0（List[int]）— ID 列表。

• token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。

返回

List[int]

零的列表。

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

LED 特定的输出

class transformers.models.led.modeling_led.LEDEncoderBaseModelOutput

<来源>

( last_hidden_state: FloatTensor hidden_states: Optional = None attentions: Optional = None global_attentions: Optional = None )

参数

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

• 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, x + attention_window + 1)的torch.FloatTensor元组（每层一个），其中x是具有全局注意力掩码的标记数。

  在注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是从序列中的每个标记到具有全局注意力的每个标记（前x个值）和到注意力窗口中的每个标记（剩余attention_window个值）的注意力权重

  • 1values)。注意，前x个值是指文本中固定位置的标记，但剩余的attention_window + 1个值是指相对位置的标记：一个标记到自身的注意力权重位于索引x + attention_window / 2，前（后）attention_window / 2个值是指到前（后）attention_window / 2个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，相应索引处的注意力权重设置为 0；值应该从前x个注意力权重中访问。如果一个标记具有全局注意力，那么attentions中所有其他标记的注意力权重都设置为 0，值应该从global_attentions`中访问。

• global_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, x)的torch.FloatTensor元组（每层一个），其中x是具有全局注意力掩码的令牌数。

  注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个令牌与序列中每个令牌的全局注意力的注意力权重。

LEDEncoder 输出的基类，具有潜在的隐藏状态、局部和全局注意力。

class transformers.models.led.modeling_led.LEDSeq2SeqModelOutput

<来源>

( last_hidden_state: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None encoder_global_attentions: Optional = None )

参数

• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的隐藏状态序列输出。

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

• past_key_values (List[torch.FloatTensor]，可选，当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的torch.FloatTensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。

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

• 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 (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_global_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, x)的torch.FloatTensor元组，其中x是具有全局注意力掩码的令牌数。

  在注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个令牌对序列中每个令牌的全局注意力的注意力权重。

模型编码器输出的基类，还包含：可加速顺序解码的预计算隐藏状态。

class transformers.models.led.modeling_led.LEDSeq2SeqLMOutput

<来源>

( loss: Optional = None logits: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None encoder_global_attentions: Optional = None )

参数

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）- 语言建模损失。

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

• past_key_values（List[torch.FloatTensor]，可选，当传递use_cache=True或当config.use_cache=True时返回）- 长度为config.n_layers的torch.FloatTensor列表，每个张量形状为(2, batch_size, num_heads, 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 之后，用于计算自注意力头中的加权平均值。

• encoder_global_attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x)的torch.FloatTensor元组（每层一个），其中x是具有全局注意力掩码的令牌数。

  在注意力 SoftMax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是来自每个具有全局注意力的令牌对序列中每个令牌的注意力权重。

用于序列到序列语言模型输出的基类。

class transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput

<来源>

( loss: Optional = None logits: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None encoder_global_attentions: Optional = None )

参数

• loss (torch.FloatTensor，形状为(1,), 可选, 当提供label时返回) — 分类（如果config.num_labels==1则为回归）损失。

• logits (torch.FloatTensor，形状为(batch_size, config.num_labels)) — SoftMax 之前的分类（如果config.num_labels==1则为回归）分数。

• past_key_values (List[torch.FloatTensor], 可选, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的torch.FloatTensor列表，每个张量的形状为(2, batch_size, num_heads, 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 (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_global_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x)的torch.FloatTensor元组，其中x是具有全局注意力掩码的令牌数量。

  全局注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。这些是来自具有全局注意力的每个令牌到序列中每个令牌的注意力权重。

用于序列到序列句子分类模型输出的基类。

class transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput

<来源>

( loss: Optional = None start_logits: FloatTensor = None end_logits: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None encoder_global_attentions: Optional = None )

参数

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

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

• end_logits (torch.FloatTensor，形状为(batch_size, sequence_length)) — 跨度结束分数（SoftMax 之前）。

• past_key_values (List[torch.FloatTensor], optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的torch.FloatTensor列表，每个张量的形状为(2, batch_size, num_heads, 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，形状为(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), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。

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

• encoder_global_attentions (tuple(torch.FloatTensor), 可选的, 当传递 output_attentions=True 或者当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, x) 的 torch.FloatTensor 元组（每层一个），其中 x 是具有全局注意力掩码的令牌数量。

  在注意力 softmax 后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是从具有全局注意力的每个令牌到序列中的每个令牌的注意力权重。

用于序列到序列问答模型输出的基类。

class transformers.models.led.modeling_tf_led.TFLEDEncoderBaseModelOutput

<来源>

( last_hidden_state: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None global_attentions: Tuple[tf.Tensor] | None = None )

参数

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

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

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

• attentions (tuple(tf.Tensor)，可选的，当传递 output_attentions=True 或者当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, x + attention_window + 1) 的 tf.Tensor 元组（每层一个），其中 x 是具有全局注意力掩码的令牌数量。

  在注意力 softmax 后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是从序列中的每个令牌到具有全局注意力的每个令牌（前 x 个值）以及到注意力窗口中的每个令牌（剩余的 attention_window）的注意力权重。

  • 注意：前 x 个值指的是文本中具有固定位置的令牌，但剩余的 attention_window + 1 个值指的是具有相对位置的令牌：一个令牌到自身的注意力权重位于索引 x + attention_window / 2，前（后）的 attention_window / 2 个值是到前（后）的令牌的注意力权重。如果注意力窗口包含具有全局注意力的令牌，则相应索引处的注意力权重设置为 0；该值应从前 x 个注意力权重中获取。如果一个令牌具有全局注意力，则到attentions中的所有其他令牌的注意力权重设置为 0，应从global_attentions中获取值。

• global_attentions (tuple(tf.Tensor)，可选的，当传递 output_attentions=True 或者当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, x) 的 tf.Tensor 元组（每层一个），其中 x 是具有全局注意力掩码的令牌数量。

  在注意力 softmax 后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是从具有全局注意力的每个令牌到序列中的每个令牌的注意力权重。

Longformer 输出的基类，具有潜在的隐藏状态、局部和全局注意力。

class transformers.models.led.modeling_tf_led.TFLEDSeq2SeqModelOutput

<来源>

( last_hidden_state: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None decoder_hidden_states: Tuple[tf.Tensor] | None = None decoder_attentions: Tuple[tf.Tensor] | None = None cross_attentions: Tuple[tf.Tensor] | None = None encoder_last_hidden_state: tf.Tensor | None = None encoder_hidden_states: Tuple[tf.Tensor] | None = None encoder_attentions: Tuple[tf.Tensor] | None = None encoder_global_attentions: Tuple[tf.Tensor] | None = None )

参数

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

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

• past_key_values（List[tf.Tensor]，可选，当传递use_cache=True或config.use_cache=True时返回）- 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。

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

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

  每层解码器的隐藏状态加上初始嵌入输出。

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

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

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

  解码器的交叉注意力层的注意力权重，在注意力 SoftMax 之后，用于计算交叉注意力头中的加权平均值。

• encoder_last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）- 模型编码器最后一层的隐藏状态序列。

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

  每层编码器的隐藏状态加上初始嵌入输出。

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

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

• encoder_global_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, x)的tf.Tensor元组（每层一个），其中x是具有全局注意力掩码的令牌数。

  在注意力 SoftMax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的令牌对序列中每个令牌的注意力权重。

模型编码器输出的基类，还包含：可加速顺序解码的预计算隐藏状态。

class transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput

<来源>

( loss: tf.Tensor | None = None logits: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None decoder_hidden_states: Tuple[tf.Tensor] | None = None decoder_attentions: Tuple[tf.Tensor] | None = None cross_attentions: Tuple[tf.Tensor] | None = None encoder_last_hidden_state: tf.Tensor | None = None encoder_hidden_states: Tuple[tf.Tensor] | None = None encoder_attentions: Tuple[tf.Tensor] | None = None encoder_global_attentions: Tuple[tf.Tensor] | None = None )

参数

• loss（形状为(1,)的tf.Tensor，可选，当提供labels时返回）- 语言建模损失。

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

• past_key_values (List[tf.Tensor], optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。

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

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

  解码器在每个层输出的隐藏状态加上初始嵌入输出。

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

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

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

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

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

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

  编码器在每个层输出的隐藏状态加上初始嵌入输出。

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

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

• encoder_global_attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x)的tf.Tensor元组（每个层一个），其中x是具有全局注意力掩码的令牌数。

  全局注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。这些是来自每个令牌对整个序列中每个令牌的全局注意力权重。

用于序列到序列语言模型输出的基类。

PytorchHide Pytorch content

LEDModel

class transformers.LEDModel

< source >

( config: LEDConfig )

参数

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

裸 LED 模型输出原始隐藏状态，没有特定的头部。该模型继承自 PreTrainedModel。请参阅超类文档，了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头部等）。

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

forward

<来源>

( 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 global_attention_mask: 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，可选）— 词汇表中解码器输入序列标记的索引。

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

  什么是输入 ID？

  LED 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则可以选择仅输入最后的decoder_input_ids（请参阅past_key_values）。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果掩码也将默认使用。

  如果要更改填充行为，应阅读modeling_led._prepare_decoder_inputs并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。

• global_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于决定每个标记的注意力，编码器的局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于任务特定的微调非常重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予全局注意力。对于问答，所有问题标记也应该具有全局注意力。有关更多详细信息，请参阅Longformer 论文。掩码值选在[0, 1]之间：

  • 0 表示局部注意力（滑动窗口注意力），

  • 1 表示全局注意力（关注所有其他标记的标记，所有其他标记也关注它们）。

• head_mask（形状为(encoder_layers, encoder_attention_heads)的torch.Tensor，可选）— 用于使编码器中注意力模块的选定头部失效的掩码。掩码值选在[0, 1]之间：

  • 1 表示头部未被屏蔽，

  • 0 表示头部被masked。

• decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于使解码器中注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]中：

  • 1 表示头部未被masked。

  • 0 表示头部被masked。

• cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于使解码器中交叉注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]中：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• 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（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

• decoder_inputs_embeds（形状为(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示而不是传递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 而不是一个普通元组。

返回

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

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

• 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), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 解码器隐藏状态的元组，形状为(batch_size, sequence_length, hidden_size)，其中包括嵌入层的输出和每个层的输出。

  解码器在每一层的输出的隐藏状态，以及可选的初始嵌入输出。

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

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

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

  解码器的交叉注意力层的注意力权重，在注意力 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时返回) — 元组torch.FloatTensor（如果模型有嵌入层，则为一个，每个层的输出为一个），形状为(batch_size, sequence_length, hidden_size)。

  编码器在每一层的输出的隐藏状态，以及可选的初始嵌入输出。

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

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

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

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

示例：

>>> from transformers import AutoTokenizer, LEDModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = LEDModel.from_pretrained("allenai/led-base-16384")

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

>>> last_hidden_states = outputs.last_hidden_state

LEDForConditionalGeneration

class transformers.LEDForConditionalGeneration

<来源>

( config: LEDConfig )

参数

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

具有语言建模头的 LED 模型。可用于摘要。此模型继承自 PreTrainedModel。请参阅超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

( 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 global_attention_mask: 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，可选）— 词汇表中解码器输入序列标记的索引。

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

  什么是输入 ID？

  LED 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则只需选择最后的decoder_input_ids作为输入（请参阅past_key_values）。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。默认情况下还将使用因果掩码。

  如果要更改填充行为，应阅读modeling_led._prepare_decoder_inputs并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。

• global_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于决定每个标记的注意力分配，编码器的局部注意力或全局注意力。具有全局注意力的标记关注所有其他标记，所有其他标记也关注它们。这对于任务特定的微调很重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予全局注意力。对于问答，所有问题标记也应该具有全局注意力。有关更多详细信息，请参考Longformer paper。掩码值选在[0, 1]之间：

  • 0 表示局部注意力（滑动窗口注意力），

  • 全局注意力为 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，用户可以选择只输入最后的decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。

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

• decoder_inputs_embeds（形状为(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选择直接传递嵌入表示，而不是传递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 或tuple(torch.FloatTensor)

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

• 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)的张量。

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

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

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

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

条件生成示例：

>>> from transformers import AutoTokenizer, LEDForConditionalGeneration

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> TXT = "My friends are <mask> but they eat too many carbs."

>>> model = LEDForConditionalGeneration.from_pretrained("allenai/led-base-16384")
>>> input_ids = tokenizer([TXT], return_tensors="pt")["input_ids"]

>>> prediction = model.generate(input_ids)[0]
>>> print(tokenizer.decode(prediction, skip_special_tokens=True))

摘要示例：

>>> import torch
>>> from transformers import AutoTokenizer, LEDForConditionalGeneration

>>> model = LEDForConditionalGeneration.from_pretrained("allenai/led-large-16384-arxiv")
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-large-16384-arxiv")

>>> ARTICLE_TO_SUMMARIZE = '''Transformers (Vaswani et al., 2017) have achieved state-of-the-art
...     results in a wide range of natural language tasks including generative language modeling
...     (Dai et al., 2019; Radford et al., 2019) and discriminative ... language understanding (Devlin et al., 2019).
...     This success is partly due to the self-attention component which enables the network to capture contextual
...     information from the entire sequence. While powerful, the memory and computational requirements of
...     self-attention grow quadratically with sequence length, making it infeasible (or very expensive) to
...     process long sequences. To address this limitation, we present Longformer, a modified Transformer
...     architecture with a self-attention operation that scales linearly with the sequence length, making it
...     versatile for processing long documents (Fig 1). This is an advantage for natural language tasks such as
...     long document classification, question answering (QA), and coreference resolution, where existing approaches
...     partition or shorten the long context into smaller sequences that fall within the typical 512 token limit
...     of BERT-style pretrained models. Such partitioning could potentially result in loss of important
...     cross-partition information, and to mitigate this problem, existing methods often rely on complex
...     architectures to address such interactions. On the other hand, our proposed Longformer is able to build
...     contextual representations of the entire context using multiple layers of attention, reducing the need for
...     task-specific architectures.'''
>>> inputs = tokenizer.encode(ARTICLE_TO_SUMMARIZE, return_tensors="pt")

>>> # Global attention on the first token (cf. Beltagy et al. 2020)
>>> global_attention_mask = torch.zeros_like(inputs)
>>> global_attention_mask[:, 0] = 1

>>> # Generate Summary
>>> summary_ids = model.generate(inputs, global_attention_mask=global_attention_mask, num_beams=3, max_length=32)
>>> print(tokenizer.decode(summary_ids[0], skip_special_tokens=True, clean_up_tokenization_spaces=True))

LEDForSequenceClassification

class transformers.LEDForSequenceClassification

<来源>

( config: LEDConfig **kwargs )

参数

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

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

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

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

forward

<来源>

( 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 global_attention_mask: 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.Seq2SeqSequenceClassifierOutput 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，可选）- 词汇表中解码器输入序列标记的索引。

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

  什么是输入 ID？

  LED 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则只需输入最后的decoder_input_ids（参见past_key_values）。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）- 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。

  如果要更改填充行为，应阅读modeling_led._prepare_decoder_inputs并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。

• global_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 用于决定每个标记上给定的注意力，编码器的局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，而所有其他标记会关注它们。这对于任务特定的微调很重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予全局注意力。对于问答，所有问题标记也应该具有全局注意力。有关更多详细信息，请参阅Longformer paper。在[0, 1]中选择的掩码值：

  • 0 表示局部注意力（滑动窗口注意力），

  • 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的元组，每个元组有 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（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

• decoder_inputs_embeds（形状为(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选择直接传递嵌入表示，而不是传递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,)的torch.LongTensor，可选）— 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

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

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

• loss（形状为(1,)的torch.FloatTensor，可选，当提供label时返回）— 分类（如果config.num_labels==1则为回归）损失。

• logits（形状为(batch_size, config.num_labels)的torch.FloatTensor）— 分类（如果config.num_labels==1则为回归）得分（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)的张量。

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

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

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

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

单标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, LEDForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = LEDForSequenceClassification.from_pretrained("allenai/led-base-16384")

>>> 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 = LEDForSequenceClassification.from_pretrained("allenai/led-base-16384", num_labels=num_labels)

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

多标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, LEDForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = LEDForSequenceClassification.from_pretrained("allenai/led-base-16384", 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 = LEDForSequenceClassification.from_pretrained(
...     "allenai/led-base-16384", 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

LEDForQuestionAnswering

class transformers.LEDForQuestionAnswering

<来源>

( config )

参数

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

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

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

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

forward

< source >

( 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 global_attention_mask: 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 ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 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，可选）— 词汇表中解码器输入序列标记的索引。

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

  什么是输入 ID？

  LED 使用 eos_token_id 作为 decoder_input_ids 生成的起始标记。如果使用 past_key_values，则可选择仅输入最后的 decoder_input_ids（参见 past_key_values）。

• decoder_attention_mask（形状为 (batch_size, target_sequence_length) 的 torch.LongTensor，可选）— 默认行为：生成一个张量，忽略 decoder_input_ids 中的填充标记。默认情况下也会使用因果掩码。

  如果要更改填充行为，应阅读 modeling_led._prepare_decoder_inputs 并根据需要进行修改。有关默认策略的更多信息，请参阅 论文 中的图表 1。

• global_attention_mask（形状为 (batch_size, sequence_length) 的 torch.FloatTensor，可选）— 决定给予每个标记的注意力，编码器的局部注意力或全局注意力。具有全局注意力的标记关注所有其他标记，所有其他标记也关注它们。这对于任务特定的微调很重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予全局注意力。对于问答，所有问题标记也应该具有全局注意力。有关更多详细信息，请参阅 Longformer 论文。掩码值选在 [0, 1]：

  • 0 表示局部注意力（滑动窗口注意力），

  • 1 表示全局注意力（关注所有其他标记，所有其他标记也关注它们）。

• head_mask（形状为 (encoder_layers, encoder_attention_heads) 的 torch.Tensor，可选）— 在编码器中使注意力模块的选定头部失效的掩码。掩码值选在 [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的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)，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递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 而不是一个普通元组。

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

• end_positions (torch.LongTensor of shape (batch_size,), optional) — 用于计算标记跨度结束位置的位置（索引）标签。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内计算损失。

返回

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

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

• 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 之前）。

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

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

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

示例：

>>> from transformers import AutoTokenizer, LEDForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = LEDForQuestionAnswering.from_pretrained("allenai/led-base-16384")

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

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

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

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

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

TensorFlow 隐藏 TensorFlow 内容

TFLEDModel

class transformers.TFLEDModel

< source >

( config *inputs **kwargs )

参数

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

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

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

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

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

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

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

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

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

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

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

call

< source >

( input_ids: TFModelInputType | None = None attention_mask: tf.Tensor | None = None decoder_input_ids: tf.Tensor | None = None decoder_attention_mask: tf.Tensor | None = None head_mask: tf.Tensor | None = None decoder_head_mask: tf.Tensor | None = None encoder_outputs: tf.Tensor | None = None global_attention_mask: tf.Tensor | None = None past_key_values: Tuple[Tuple[tf.Tensor]] | None = None inputs_embeds: tf.Tensor | None = None decoder_inputs_embeds: tf.Tensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None training: bool = False **kwargs ) → export const metadata = 'undefined';transformers.models.led.modeling_tf_led.TFLEDSeq2SeqModelOutput or tuple(tf.Tensor)

参数

• input_ids (tf.Tensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

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

  • 1 表示未被遮罩的标记，

  • 0 表示被遮罩的标记。

  什么是注意力遮罩？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的tf.Tensor，可选）— 词汇表中解码器输入序列标记的索引。

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

  什么是输入 ID？

  LED 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则只需输入最后的decoder_input_ids（参见past_key_values）。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的tf.Tensor，可选）— 默认情况下将忽略填充标记并生成。不建议为大多数用例设置此选项。

• head_mask（形状为(encoder_layers, encoder_attention_heads)的tf.Tensor，可选）— 用于在编码器中使注意力模块中的选定头部失效的遮罩。在[0, 1]中选择的遮罩值：

  • 1 表示头部未被遮罩，

  • 0 表示头部被遮罩。

• decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的tf.Tensor，可选）— 用于在解码器中使注意力模块中的选定头部失效的遮罩。在[0, 1]中选择的遮罩值：

  • 1 表示头部未被遮罩，

  • 0 表示头部被遮罩，

• encoder_outputs（tf.Tensor，可选）— 编码器最后一层的隐藏状态的输出。在解码器的交叉注意力中使用。形状为(batch_size, sequence_length, hidden_size)的序列是

• past_key_values（长度为config.n_layers的Tuple[Tuple[tf.Tensor]]）— 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用past_key_values，用户可以选择仅输入最后的decoder_input_ids（即未将其过去的键值状态提供给此模型的那些）的形状为(batch_size, 1)的张量，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。

• use_cache（bool，可选，默认为True）— 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。在训练期间设置为False，在生成期间设置为True。

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

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

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

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

返回

transformers.models.led.modeling_tf_led.TFLEDSeq2SeqModelOutput 或 tuple(tf.Tensor)

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

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

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

• past_key_values (List[tf.Tensor], optional, returned when use_cache=True is passed or when config.use_cache=True) — 长度为 config.n_layers 的 tf.Tensor 列表，每个张量的形状为 (2, batch_size, num_heads, sequence_length, embed_size_per_head)。

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

• decoder_hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组（一个用于嵌入输出，一个用于每一层的输出）。

  解码器在每一层的隐藏状态加上初始嵌入输出。

• decoder_attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。

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

• cross_attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。

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

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

• encoder_hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组（一个用于嵌入输出，一个用于每一层的输出）。

  编码器在每一层的隐藏状态加上初始嵌入输出。

• encoder_attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。

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

• encoder_global_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, x)的tf.Tensor元组，其中x是具有全局注意掩码的令牌数。

  在注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是来自具有全局注意力的每个令牌到序列中每个令牌的注意力权重。

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

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

示例：

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

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = TFLEDModel.from_pretrained("allenai/led-base-16384")

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

>>> last_hidden_states = outputs.last_hidden_state

TFLEDForConditionalGeneration

class transformers.TFLEDForConditionalGeneration

<来源>

( config *inputs **kwargs )

参数

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

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

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

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

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

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

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

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

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

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

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

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None decoder_head_mask: np.ndarray | tf.Tensor | None = None encoder_outputs: TFLEDEncoderBaseModelOutput | None = None global_attention_mask: np.ndarray | tf.Tensor | None = None past_key_values: Tuple[Tuple[Union[np.ndarray, tf.Tensor]]] | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None decoder_inputs_embeds: np.ndarray | tf.Tensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None labels: tf.Tensor | None = None training: bool = False ) → export const metadata = 'undefined';transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput or tuple(tf.Tensor)

参数

• input_ids（形状为({0})的tf.Tensor）- 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

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

  • 1 用于未被“掩码”的标记，

  • 0 用于被“掩码”的标记。

  什么是注意力掩码？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的tf.Tensor，可选）- 词汇表中解码器输入序列标记的索引。

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

  什么是输入 ID？

  LED 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用了past_key_values，则可选择仅输入最后的decoder_input_ids（参见past_key_values）。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的tf.Tensor，可选）- 将默认生成并忽略填充标记。不建议为大多数用例设置此项。

• head_mask（形状为(encoder_layers, encoder_attention_heads)的tf.Tensor，可选）- 用于使编码器中的注意力模块中的选定头部无效的掩码。选择的掩码值为[0, 1]：

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

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

• decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的tf.Tensor，可选）- 用于使解码器中的注意力模块中的选定头部无效的掩码。选择的掩码值为[0, 1]：

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

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

• encoder_outputs（tf.Tensor，可选）- 编码器最后一层的隐藏状态输出。用于解码器的交叉注意力。形状为(batch_size, sequence_length, hidden_size)的序列是

• past_key_values（长度为config.n_layers的Tuple[Tuple[tf.Tensor]]）- 包含预先计算的注意力块的键和值隐藏状态。可用于加速解码。如果使用了past_key_values，用户可以选择仅输入最后的decoder_input_ids（即未将其过去的键值状态提供给此模型的那些）的形状为(batch_size, 1)的张量，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。

• use_cache（bool，可选，默认为True）- 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。在训练期间设置为False，在生成期间设置为True。

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

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

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

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

返回

transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput 或 tuple(tf.Tensor)

transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput 或 tf.Tensor元组（如果传递return_dict=False或config.return_dict=False）包括不同元素，取决于配置（LEDConfig）和输入。

• loss (形状为(1,)的tf.Tensor, *可选*, 当提供labels`时返回) — 语言建模损失。

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

• past_key_values (List[tf.Tensor], 可选, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。

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

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

  解码器在每一层输出的隐藏状态加上初始嵌入输出。

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

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

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

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

• encoder_last_hidden_state (形状为(batch_size, sequence_length, hidden_size)的tf.Tensor`, 可选) — 模型编码器最后一层的隐藏状态序列。

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

  编码器在每一层输出的隐藏状态加上初始嵌入输出。

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

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

• encoder_global_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, x)的tf.Tensor元组（每层一个），其中x是具有全局注意力掩码的令牌数。

  在注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是来自每个令牌的注意力权重，对序列中的每个令牌进行全局注意力。

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

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

示例：

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

>>> mname = "allenai/led-base-16384"
>>> tokenizer = AutoTokenizer.from_pretrained(mname)
>>> TXT = "My friends are <mask> but they eat too many carbs."
>>> model = TFLEDForConditionalGeneration.from_pretrained(mname)
>>> batch = tokenizer([TXT], return_tensors="tf")
>>> logits = model(inputs=batch.input_ids).logits
>>> probs = tf.nn.softmax(logits[0])
>>> # probs[5] is associated with the mask token

LLaMA

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

概述

Hugo Touvron、Thibaut Lavril、Gautier Izacard、Xavier Martinet、Marie-Anne Lachaux、Timothée Lacroix、Baptiste Rozière、Naman Goyal、Eric Hambro、Faisal Azhar、Aurelien Rodriguez、Armand Joulin、Edouard Grave、Guillaume Lample 在LLaMA: Open and Efficient Foundation Language Models中提出了 LLaMA 模型。它是一个包含从 7B 到 65B 参数的基础语言模型的集合。

该论文的摘要如下：

我们介绍 LLaMA，这是一个包含从 7B 到 65B 参数的基础语言模型的集合。我们在数万亿标记上训练我们的模型，并展示了可以仅使用公开可用的数据集训练最先进的模型，而无需使用专有和不可访问的数据集。特别是，LLaMA-13B 在大多数基准测试中优于 GPT-3（175B），而 LLaMA-65B 与最佳模型 Chinchilla-70B 和 PaLM-540B 竞争。我们向研究社区发布了所有我们的模型。

此模型由zphang贡献，BlackSamorez也有贡献。 Hugging Face 中的实现代码基于 GPT-NeoX 这里。作者的原始代码可以在这里找到。

使用提示

• LLaMA 模型的权重可以通过填写此表格获得。

• 下载权重后，需要使用转换脚本将其转换为 Hugging Face Transformers 格式。可以使用以下（示例）命令调用脚本：

python src/transformers/models/llama/convert_llama_weights_to_hf.py \
    --input_dir /path/to/downloaded/llama/weights --model_size 7B --output_dir /output/path

• 转换后，可以通过以下方式加载模型和分词器：

from transformers import LlamaForCausalLM, LlamaTokenizer

tokenizer = LlamaTokenizer.from_pretrained("/output/path")
model = LlamaForCausalLM.from_pretrained("/output/path")

请注意，执行脚本需要足够的 CPU RAM 来托管整个模型的 float16 精度（即使最大版本分为几个检查点，它们每个都包含模型的每个权重的一部分，因此我们需要将它们全部加载到 RAM 中）。对于 65B 模型，因此需要 130GB 的 RAM。

• LLaMA 分词器是基于sentencepiece的 BPE 模型。sentencepiece 的一个特点是，在解码序列时，如果第一个标记是单词的开头（例如“Banana”），分词器不会在字符串前添加前缀空格。

此模型由zphang贡献，BlackSamorez也有贡献。 Hugging Face 中的实现代码基于 GPT-NeoX 这里。作者的原始代码可以在这里找到。实现的 Flax 版本由afmck贡献，实现中的代码基于 Hugging Face 的 Flax GPT-Neo。

基于原始 LLaMA 模型，Meta AI 发布了一些后续作品：

• Llama2：Llama2 是 Llama 的改进版本，具有一些架构调整（Grouped Query Attention），并且在 2 万亿标记上进行了预训练。请参考可以在这里找到的 Llama2 的文档。

资源

一系列官方 Hugging Face 和社区（由🌎表示）资源列表，可帮助您开始使用 LLaMA。如果您有兴趣提交资源以包含在此处，请随时打开一个 Pull Request，我们将对其进行审查！资源应该理想地展示一些新内容，而不是重复现有资源。

文本分类

• 一个关于如何使用提示调整来适应 LLaMA 模型进行文本分类任务的笔记本。

问答

• StackLLaMA: 用 RLHF 训练 LLaMA 的实用指南，一篇关于如何使用 RLHF 训练 LLaMA 以回答Stack Exchange上问题的博文。

⚗️ 优化

• 一个关于如何使用 xturing 库在 GPU 上微调 LLaMA 模型的笔记本，该 GPU 具有有限的内存。🌎

⚡️ 推理

• 一个关于如何使用🤗 PEFT 库中的 PeftModel 运行 LLaMA 模型的笔记本。🌎

• 一个关于如何使用 LangChain 加载 PEFT 适配器 LLaMA 模型的笔记本。🌎

🚀 部署

• 一个关于如何使用 LoRA 方法通过🤗 PEFT 库进行 LLaMA 模型微调的笔记本。🌎

• 一个关于如何在 Amazon SageMaker 上部署 Open-LLaMA 模型进行文本生成的笔记本。🌎

LlamaConfig

class transformers.LlamaConfig

<来源>

( vocab_size = 32000 hidden_size = 4096 intermediate_size = 11008 num_hidden_layers = 32 num_attention_heads = 32 num_key_value_heads = None hidden_act = 'silu' max_position_embeddings = 2048 initializer_range = 0.02 rms_norm_eps = 1e-06 use_cache = True pad_token_id = None bos_token_id = 1 eos_token_id = 2 pretraining_tp = 1 tie_word_embeddings = False rope_theta = 10000.0 rope_scaling = None attention_bias = False attention_dropout = 0.0 **kwargs )

参数

• vocab_size (int, optional, 默认为 32000) — LLaMA 模型的词汇量。定义在调用 LlamaModel 时可以表示的不同标记的数量。

• 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 解码器中每个注意力层的注意力头数。

• num_key_value_heads (int, optional) — 这是应该用来实现分组查询注意力的 key_value 头的数量。如果num_key_value_heads=num_attention_heads，模型将使用多头注意力（MHA），如果num_key_value_heads=1，模型将使用多查询注意力（MQA），否则将使用 GQA。将多头检查点转换为 GQA 检查点时，应通过对该组中所有原始头进行均值池化来构建每个组键和值头。有关更多详细信息，请查看此论文。如果未指定，将默认为num_attention_heads。

• hidden_act (str 或 function, optional, 默认为"silu") — 解码器中的非线性激活函数（函数或字符串）。

• max_position_embeddings (int, optional, 默认为 2048) — 该模型可能使用的最大序列长度。Llama 1 支持最多 2048 个标记，Llama 2 支持最多 4096 个标记，CodeLlama 支持最多 16384 个标记。

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

• rms_norm_eps (float, optional, 默认为 1e-06) — rms 归一化层使用的 epsilon。

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

• pad_token_id (int, 可选) — 填充标记 id。

• bos_token_id (int, 可选, 默认为 1) — 流的开始标记 id。

• eos_token_id (int, 可选, 默认为 2) — 流的结束标记 id。

• pretraining_tp (int, 可选, 默认为 1) — 实验性功能。在预训练期间使用的张量并行性等级。请参考此文档以了解更多信息。此值对于确保预训练结果的精确可重现性是必要的。请参考此问题。

• tie_word_embeddings (bool, 可选, 默认为 False) — 是否绑定权重嵌入

• rope_theta (float, 可选, 默认为 10000.0) — RoPE 嵌入的基本周期。

• rope_scaling (Dict, 可选) — 包含 RoPE 嵌入的缩放配置的字典。当前支持两种缩放策略：线性和动态。它们的缩放因子必须是大于 1 的浮点数。预期格式为{"type": 策略名称, "factor": 缩放因子}。使用此标志时，不要将max_position_embeddings更新为预期的新最大值。有关这些缩放策略行为的更多信息，请参阅以下主题：www.reddit.com/r/LocalLLaMA/comments/14mrgpr/dynamically_scaled_rope_further_increases/。这是一个实验性功能，可能在未来版本中发生破坏性 API 更改。

• attention_bias (bool, 默认为 False, 可选, 默认为 False) — 在自注意力机制的查询、键、值和输出投影层中是否使用偏置。

• attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的丢失比率。

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

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

>>> from transformers import LlamaModel, LlamaConfig

>>> # Initializing a LLaMA llama-7b style configuration
>>> configuration = LlamaConfig()

>>> # Initializing a model from the llama-7b style configuration
>>> model = LlamaModel(configuration)

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

LlamaTokenizer

class transformers.LlamaTokenizer

<来源>

( vocab_file unk_token = '<unk>' bos_token = '<s>' eos_token = '</s>' pad_token = None sp_model_kwargs: Optional = None add_bos_token = True add_eos_token = False clean_up_tokenization_spaces = False use_default_system_prompt = False spaces_between_special_tokens = False legacy = None **kwargs )

参数

• vocab_file (str) — 词汇文件的路径。

• unk_token (str 或 tokenizers.AddedToken, 可选, 默认为 "<unk>") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。

• bos_token (str 或 tokenizers.AddedToken, 可选, 默认为 "<s>") — 在预训练期间使用的序列开始标记。可用作序列分类器标记。

• eos_token (str 或 tokenizers.AddedToken, 可选, 默认为 "</s>") — 序列的结束标记。

• pad_token (str 或 tokenizers.AddedToken, 可选) — 用于使标记数组在批处理目的上具有相同大小的特殊标记。然后将被注意机制或损失计算忽略。

• sp_model_kwargs (Dict[str, Any], Optional, 可选) — 将传递给SentencePieceProcessor.__init__()方法。SentencePiece 的 Python 包装器可用于设置：

  • enable_sampling: 启用子词正则化。

  • nbest_size: 用于 unigram 的采样参数。对于 BPE-Dropout 无效。

    • nbest_size = {0,1}: 不执行采样。

    • nbest_size > 1：从前 nbest_size 个结果中采样。

    • nbest_size < 0：假设 nbest_size 为无限大，并使用前向过滤和后向采样算法从所有假设（格子）中采样。

  • alpha：用于单字采样的平滑参数，以及 BPE-dropout 合并操作的丢弃概率。

• add_bos_token (bool, optional, 默认为 True) — 是否在序列开头添加 bos_token。

• add_eos_token (bool, optional, 默认为 False) — 是否在序列末尾添加 eos_token。

• clean_up_tokenization_spaces (bool, optional, 默认为 False) — 是否在解码后清除空格，清除包括删除额外空格等潜在的瑕疵。

• use_default_system_prompt (bool, optional, 默认为 False) — 是否使用 Llama 的默认系统提示。

• spaces_between_special_tokens (bool, optional, 默认为 False) — 是否在特殊标记之间添加空格。

• legacy (bool, optional) — 是否使用分词器的 legacy 行为。在合并 #24622 和 #25224 之前的遗留版本中，修复了在特殊标记后出现的标记的问题。一个简单的例子：

  • legacy=True:

构建一个 Llama 分词器。基于字节级字节对编码。默认的填充标记未设置，因为原始模型中没有填充标记。

build_inputs_with_special_tokens

< source >

( token_ids_0 token_ids_1 = None )

get_special_tokens_mask

< source >

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

参数

• token_ids_0 (List[int]) — ID 列表。

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

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

返回

List[int]

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

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

create_token_type_ids_from_sequences

< source >

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

参数

• token_ids_0 (List[int]) — ID 列表。

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

返回

List[int]

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

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

序列对掩码的格式如下：

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

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

save_vocabulary

< source >

( save_directory filename_prefix: Optional = None ) → export const metadata = 'undefined';Tuple(str)

参数

• save_directory (str) — 保存词汇表的目录。

返回

Tuple(str)

保存的文件路径。

将词汇表和特殊标记文件保存到目录中。

LlamaTokenizerFast

class transformers.LlamaTokenizerFast

< source >

( vocab_file = None tokenizer_file = None clean_up_tokenization_spaces = False unk_token = '<unk>' bos_token = '<s>' eos_token = '</s>' add_bos_token = True add_eos_token = False use_default_system_prompt = False **kwargs )

参数

• vocab_file (str, optional) — 包含实例化分词器所需词汇表的 SentencePiece 文件（通常具有 .model 扩展名）。

• tokenizer_file (str, optional) — 包含加载分词器所需的所有内容的 tokenizers 文件（通常具有 .json 扩展名）。

• clean_up_tokenization_spaces (bool, 可选, 默认为 False) — 是否在解码后清理空格，清理包括删除额外的空格等潜在残留物。

• unk_token (str 或 tokenizers.AddedToken, 可选, 默认为 "<unk>") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。

• bos_token (str 或 tokenizers.AddedToken, 可选, 默认为 "<s>") — 在预训练期间使用的序列开始标记。可用作序列分类器标记。

• eos_token (str 或 tokenizers.AddedToken, 可选, 默认为 "</s>") — 序列结束标记。

• add_bos_token (bool, 可选, 默认为 True) — 是否在序列开头添加 bos_token。

• add_eos_token (bool, 可选, 默认为 False) — 是否在序列末尾添加 eos_token。

• use_default_system_prompt (bool, 可选, 默认为 False) — 是否使用 Llama 的默认系统提示。

构建一个 Llama 分词器。基于字节级字节对编码。

这里特别使用了 ByteFallback 和无标准化。

>>> from transformers import LlamaTokenizerFast

>>> tokenizer = LlamaTokenizerFast.from_pretrained("hf-internal-testing/llama-tokenizer")
>>> tokenizer.encode("Hello this is a test")
[1, 15043, 445, 338, 263, 1243]

如果要更改 bos_token 或 eos_token，请确保在初始化模型时指定它们，或者调用 tokenizer.update_post_processor() 确保后处理正确完成（否则编码序列的第一个标记和最后一个标记的值将不正确）。有关更多详细信息，请查看[后处理器] (huggingface.co/docs/tokenizers/api/post-processors) 文档。

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

build_inputs_with_special_tokens

<来源>

( token_ids_0 token_ids_1 = None )

get_special_tokens_mask

<来源>

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';A list of integers in the range [0, 1]

参数

• token_ids_0 (List[int]) — 第一个序列的 ID 列表。

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

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

返回

一个整数列表，范围为 [0, 1]

1 代表特殊标记，0 代表序列标记。

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

create_token_type_ids_from_sequences

<来源>

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

参数

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

• token_ids_1 (List[int], 可选) — 第二个标记化序列。

返回

List[int]

标记类型 ID。

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

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

update_post_processor

<来源>

( )

使用当前的 bos_token 和 eos_token 更新底层后处理器。

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

LlamaModel

class transformers.LlamaModel

<来源>

( config: LlamaConfig )

参数

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

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

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

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

forward

<来源>

( 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，可选地只需输入最后的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（Cache或tuple(tuple(torch.FloatTensor))，可选）- 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。

  允许两种格式：

  • 一个 Cache 实例;

  • 元组tuple(torch.FloatTensor)的长度为config.n_layers，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。这也被称为传统缓存格式。

  模型将输出与输入相同的缓存格式。如果未传递past_key_values，则将返回传统缓存格式。

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

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递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 而不是普通元组。

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

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

LlamaForCausalLM

class transformers.LlamaForCausalLM

<来源>

( config )

forward

<来源>

( 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（形状为(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。

  什么是注意力掩码？

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

  如果使用past_key_values，则可选择仅输入最后的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（Cache或tuple(tuple(torch.FloatTensor))，可选） - 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。

  允许两种格式：

  • 一个 Cache 实例；

  • 长度为config.n_layers的tuple(torch.FloatTensor)的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。这也被称为传统缓存格式。

  模型将输出与输入相同的缓存格式。如果没有传递past_key_values，则将返回传统缓存格式。

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

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选） - 可选地，您可以选择直接传递嵌入表示，而不是传递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 而不是普通元组。

  参数 - 标签（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时），包括根据配置（LlamaConfig）和输入的不同元素。

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

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

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

示例：

>>> from transformers import AutoTokenizer, LlamaForCausalLM

>>> model = LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")

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

LlamaForSequenceClassification

class transformers.LlamaForSequenceClassification

<来源>

( config )

参数

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

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

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

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

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

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

forward

<来源>

( 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，可以选择仅输入最后的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（Cache或tuple(tuple(torch.FloatTensor))，可选）- 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。

  允许两种格式：

  • 一个 Cache 实例；

  • 元组，长度为config.n_layers的tuple(torch.FloatTensor)，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。这也被称为传统的缓存格式。

  模型将输出与输入相同的缓存格式。如果没有传递past_key_values，则将返回传统的缓存格式。

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

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

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

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

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

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

FlaxLlamaModel

class transformers.FlaxLlamaModel

<来源>

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

参数

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

• dtype (jax.numpy.dtype, optional, 默认为 jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16或jax.numpy.bfloat16之一。

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

  请注意，这仅指定计算的数据类型，不会影响模型参数的数据类型。

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

裸 Llama 模型变压器，输出原始隐藏状态而不带任何特定头部。

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

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

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

• 即时（JIT）编译

• 自动微分

• 矢量化

• 并行化

__call__

<来源>

( input_ids attention_mask = None position_ids = None params: dict = None past_key_values: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxBaseModelOutput or tuple(torch.FloatTensor)

参数

• input_ids (numpy.ndarray of shape (batch_size, input_ids_length)) — 词汇表中输入序列标记的索引。默认情况下，如果提供填充，则将忽略填充。

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

  什么是输入 ID？

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

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

  • 对于被masked的标记为 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 (numpy.ndarray of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。

  什么是位置 ID？

• past_key_values (Dict[str, np.ndarray], optional, 由init_cache返回或在传递先前的past_key_values时返回) — 预先计算的隐藏状态（注意力块中的键和值）的字典，可用于快速自回归解码。预先计算的键和值隐藏状态的形状为[batch_size, max_length]。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

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

返回

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

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

• last_hidden_state (jnp.ndarray of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。

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

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

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

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

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

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

此示例使用一个随机模型，因为真实的模型都非常大。为了获得正确的结果，您应该使用 openlm-research/open_llama_3b_v2 而不是 afmck/testing-llama-tiny。如果在加载该检查点时出现内存不足的情况，您可以尝试在 from_pretrained 调用中添加 device_map="auto"。

示例：

>>> from transformers import AutoTokenizer, FlaxLlamaModel

>>> tokenizer = AutoTokenizer.from_pretrained("afmck/testing-llama-tiny")
>>> model = FlaxLlamaModel.from_pretrained("afmck/testing-llama-tiny")

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

>>> last_hidden_states = outputs.last_hidden_state

FlaxLlamaForCausalLM

class transformers.FlaxLlamaForCausalLM

< source >

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

参数

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

• dtype (jax.numpy.dtype, 可选，默认为 jax.numpy.float32) — 计算的数据类型。可以是 jax.numpy.float32、jax.numpy.float16 或 jax.numpy.bfloat16 中的一个。

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

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

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

带有语言建模头（线性层）的 Llama 模型变压器。

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

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

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

• 即时编译 (JIT)

• 自动微分

• 矢量化

• 并行化

__call__

<来源>

( input_ids attention_mask = None position_ids = None params: dict = None past_key_values: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxMaskedLMOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, input_ids_length)的numpy.ndarray）- 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的numpy.ndarray，可选）- 避免在填充标记索引上执行注意力的掩码。掩码值选在[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)的numpy.ndarray，可选）- 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。

  什么是位置 ID？

• past_key_values（Dict[str, np.ndarray]，可选，由init_cache返回或传递先前的past_key_values时返回）- 预先计算的隐藏状态字典（注意力块中的键和值），可用于快速自回归解码。预先计算的键和值隐藏状态的形状为[batch_size, max_length]。

• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

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

返回

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

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

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

• hidden_states (tuple(jnp.ndarray), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of jnp.ndarray (one for the output of the embeddings + one for the output of each layer) of shape (batch_size, sequence_length, hidden_size)。

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

• attentions (tuple(jnp.ndarray), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of jnp.ndarray (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length)。

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

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

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

这个例子使用一个随机模型，因为真实的模型都非常庞大。为了获得正确的结果，您应该使用 openlm-research/open_llama_3b_v2，而不是 afmck/testing-llama-tiny。如果在加载该检查点时出现内存不足的情况，您可以尝试在 from_pretrained 调用中添加 device_map="auto"。

例如：

>>> from transformers import AutoTokenizer, FlaxLlamaForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("afmck/testing-llama-tiny")
>>> model = FlaxLlamaForCausalLM.from_pretrained("afmck/testing-llama-tiny")

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

>>> # retrieve logts for next token
>>> next_token_logits = outputs.logits[:, -1]