Transformers 4.37 中文文档（四十）

原文：huggingface.co/docs/transformers

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]

Llama2

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

概述

Llama2 模型是由 Hugo Touvron、Louis Martin、Kevin Stone、Peter Albert、Amjad Almahairi、Yasmine Babaei、Nikolay Bashlykov、Soumya Batra、Prajjwal Bhargava、Shruti Bhosale、Dan Bikel、Lukas Blecher、Cristian Canton Ferrer、Moya Chen、Guillem Cucurull、David Esiobu、Jude Fernandes、Jeremy Fu、Wenyin Fu、Brian Fuller、Cynthia Gao、Vedanuj Goswami、Naman Goyal、Anthony Hartshorn、Saghar Hosseini、Rui Hou、Hakan Inan、Marcin Kardas、Viktor Kerkez Madian Khabsa、Isabel Kloumann、Artem Korenev、Punit Singh Koura、Marie-Anne Lachaux、Thibaut Lavril、Jenya Lee、Diana Liskovich、Yinghai Lu、Yuning Mao、Xavier Martinet、Todor Mihaylov、Pushka rMishra、Igor Molybog、Yixin Nie、Andrew Poulton、Jeremy Reizenstein、Rashi Rungta、Kalyan Saladi、Alan Schelten、Ruan Silva、Eric Michael Smith、Ranjan Subramanian、Xiaoqing EllenTan、Binh Tang、Ross Taylor、Adina Williams、Jian Xiang Kuan、Puxin Xu、Zheng Yan、Iliyan Zarov、Yuchen Zhang、Angela Fan、Melanie Kambadur、Sharan Narang、Aurelien Rodriguez、Robert Stojnic、Sergey Edunov、Thomas Scialom 提出的，它是一个包含从 7B 到 70B 参数的基础语言模型的集合，具有为聊天应用程序调优的检查点！

论文的摘要如下：

在这项工作中，我们开发并发布了 Llama 2，这是一组预训练和调优的大型语言模型（LLMs），规模从 70 亿到 700 亿参数不等。我们调优的 LLMs，称为 Llama 2-Chat，针对对话用例进行了优化。我们的模型在我们测试的大多数基准上优于开源聊天模型，并根据我们的人类评估，对于帮助和安全性，可能是封闭源模型的合适替代品。我们提供了关于我们对 Llama 2-Chat 进行调优和安全改进方法的详细描述，以便使社区能够在我们的工作基础上构建并促进 LLMs 的负责任发展。

查看所有 Llama2 模型检查点这里。该模型由Arthur Zucker贡献，Lysandre Debut也有贡献。Hugging Face 中的实现代码基于 GPT-NeoX 这里。作者的原始代码可以在这里找到。

使用提示

Llama2模型是使用bfloat16进行训练的，但原始推断使用float16。Hub 上上传的检查点使用torch_dtype='float16'，AutoModel API 将使用它将检查点从torch.float32转换为torch.float16。

在线权重的dtype大多不相关，除非您在使用model = AutoModelForCausalLM.from_pretrained("path", torch_dtype = "auto")初始化模型时使用torch_dtype="auto"。原因是模型将首先被下载（使用在线检查点的dtype），然后将被转换为torch的默认dtype（变为torch.float32），最后，如果配置中提供了torch_dtype，则将使用它。

不建议在float16中训练模型，已知会产生nan；因此，模型应该在bfloat16中进行训练。

提示：

• Llama2 模型的权重可以通过填写此表格获得
• 该架构与第一个 Llama 非常相似，增加了 Grouped Query Attention（GQA），参考这篇论文
• 将 config.pretraining_tp 设置为与 1 不同的值将激活线性层的更准确但更慢的计算，这应该更好地匹配原始对数。
• 原始模型使用 pad_id = -1，这意味着没有填充标记。我们不能使用相同的逻辑，确保使用 tokenizer.add_special_tokens({"pad_token":"<pad>"}) 添加一个填充标记，并相应调整令牌嵌入。您还应该设置 model.config.pad_token_id。模型的 embed_tokens 层使用 self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.config.padding_idx) 进行初始化，这确保了对填充标记进行编码将输出零，因此在初始化时传递它是推荐的。
• 填写表格并获得模型检查点访问权限后，您应该能够使用已转换的检查点。否则，如果您正在转换自己的模型，请随时使用 转换脚本。可以使用以下（示例）命令调用脚本：

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 中）。对于 75B 模型，因此需要 145GB 的 RAM。

• LLaMA 分词器是基于 sentencepiece 的 BPE 模型。sentencepiece 的一个特点是，在解码序列时，如果第一个令牌是单词的开头（例如“Banana”），分词器不会在字符串前面添加前缀空格。
• 通过 attn_implementation="flash_attention_2" 使用 Flash Attention 2 时，不要将 torch_dtype 传递给 from_pretrained 类方法，并使用自动混合精度训练。当使用 Trainer 时，只需将 fp16 或 bf16 指定为 True。否则，请确保您使用 torch.autocast。这是必需的，因为 Flash Attention 仅支持 fp16 和 bf16 数据类型。

资源

一个官方 Hugging Face 和社区（由 🌎 表示）资源列表，可帮助您开始使用 LLaMA2。如果您有兴趣提交资源以包含在此处，请随时打开一个 Pull Request，我们将对其进行审查！资源应该理想地展示一些新内容，而不是重复现有资源。

• Llama 2 已发布 - 在 Hugging Face 上获取，关于 Llama 2 及如何与 🤗 Transformers 和 🤗 PEFT 一起使用的博客文章。
• LLaMA 2 - 您需要的所有资源，一个相关资源的汇编，用于了解 LLaMA 2 并快速入门。

文本生成

• 一个关于如何在 Google Colab 中使用 QLoRA 和 4 位精度对 Llama 2 进行微调的 笔记本。🌎
• 一个关于如何使用 4 位 QLoRA 对“Llama-v2-7b-guanaco”模型进行微调并从 PDF 中生成问答数据集的 笔记本。🌎

文本分类

• 一个关于如何使用 QLoRa、TRL 和韩文文本分类数据集对 Llama 2 模型进行微调的 笔记本。🌎🇰🇷

⚗️ 优化

• 使用 DPO 对 Llama 2 进行微调，一个指南，介绍如何使用 TRL 库的 DPO 方法对特定数据集上的 Llama 2 进行微调。
• 扩展指南：指导调整 Llama 2，一个指南，用于训练 Llama 2 从输入生成指令，将模型从遵循指令转变为给出指令。
• 一个笔记本，介绍如何在个人计算机上使用 QLoRa 和 TRL 对 Llama 2 模型进行微调。

⚡️ 推理

• 一个笔记本，介绍如何使用 AutoGPTQ 库中的 GPTQ 对 Llama 2 模型进行量化。
• 一个笔记本，介绍如何在本地计算机或 Google Colab 上运行带有 4 位量化的 Llama 2 Chat Model。

🚀 部署

• 在亚马逊 SageMaker 上对 LLaMA 2 (7-70B) 进行微调，从设置到 QLoRA 微调和部署的完整指南。
• 在亚马逊 SageMaker 上部署 Llama 2 7B/13B/70B，使用 Hugging Face 的 LLM DLC 容器进行安全和可扩展部署的指南。

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, 可选, 默认为 32000) — LLaMA 模型的词汇量。定义了在调用 LlamaModel 时可以表示的不同令牌数量。
• hidden_size (int, 可选, 默认为 4096) — 隐藏表示的维度。
• intermediate_size (int, 可选, 默认为 11008) — MLP 表示的维度。
• num_hidden_layers (int, 可选, 默认为 32) — Transformer 解码器中的隐藏层数量。
• num_attention_heads (int, 可选, 默认为 32) — Transformer 解码器中每个注意力层的注意力头数量。
• num_key_value_heads (int, 可选) — 这是应该用于实现 Grouped Query Attention 的 key_value heads 的数量。如果 num_key_value_heads=num_attention_heads，模型将使用 Multi Head Attention (MHA)，如果 num_key_value_heads=1，模型将使用 Multi Query Attention (MQA)，否则使用 GQA。将多头检查点转换为 GQA 检查点时，每个组键和值头应通过对该组中所有原始头进行均值池化来构建。有关更多详细信息，请查看此论文。如果未指定，将默认为 num_attention_heads。
• hidden_act (str 或 function, 可选, 默认为 "silu") — 解码器中的非线性激活函数（函数或字符串）。
• max_position_embeddings (int, 可选, 默认为 2048) — 此模型可能使用的最大序列长度。Llama 1 支持最多 2048 个令牌，Llama 2 支持最多 4096 个令牌，CodeLlama 支持最多 16384 个令牌。
• initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• rms_norm_eps (float, 可选, 默认为 1e-06) — rms normalization 层使用的 epsilon。
• use_cache (bool, 可选, 默认为 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）— 注意力概率的 dropout 比率。

这是用于存储 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：unigram 抽样的平滑参数，以及 BPE-dropout 合并操作的 dropout 概率。
• add_bos_token（bool，可选，默认为True）— 是否在序列开头添加bos_token。
• add_eos_token（bool，可选，默认为False）— 是否在序列末尾添加eos_token。
• clean_up_tokenization_spaces（bool，可选，默认为False）— 是否在解码后清除空格，清除包括删除额外空格等潜在工件。
• use_default_system_prompt（bool，可选，默认为False）— 是否应使用 Llama 的默认系统提示。
• spaces_between_special_tokens（bool，可选，默认为False）— 是否在特殊标记之间添加空格。
• legacy（bool，可选）— 是否应使用分词器的legacy行为。在合并＃24622 和＃25224 之前的遗留版本中，包括修复正确处理出现在特殊标记之后的标记的问题。一个简单的例子：
  • legacy=True：

构建一个 Llama 分词器。基于字节级字节对编码。默认填充标记未设置，因为原始模型中没有填充标记。

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';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]

根据给定序列的标记类型 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，则仅返回掩码的第一部分（0s）。

save_vocabulary

<来源>

( save_directory filename_prefix: Optional = None ) → export const metadata = 'undefined';Tuple(str)

参数

• save_directory（str）— 保存词汇表的目录。

返回

Tuple(str)

保存的文件路径。

将词汇表和特殊标记文件保存到目录中。

LlamaTokenizerFast

class transformers.LlamaTokenizerFast

<来源>

( 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，可选）— SentencePiece文件（通常具有.model 扩展名），其中包含实例化分词器所需的词汇表。
• tokenizer_file（str，可选）— 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。在使用 tokenizer 的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()方法以加载模型权重。配置 — LlamaConfig

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

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

Transformer 解码器由config.num_hidden_layers层组成。每一层都是一个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 实例；
  • 长度为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 而不是普通元组。

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]中的掩码值：
  • 对于未被“掩盖”的标记，为 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（torch.LongTensor，形状为(batch_size, sequence_length)，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[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（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。
• use_cache（bool，可选）— 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。 参数 — 标签（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（torch.FloatTensor，形状为(1,)，可选，当提供labels时返回）— 语言建模损失（用于下一个标记预测）。
• logits（torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)）— 语言建模头的预测分数（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)的张量） 包含预先计算的隐藏状态（自注意力块中的键和值），可用于加速顺序解码。
• 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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 表示未被masked的标记，
  • 0 表示被masked的标记。

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

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

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

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

Longformer

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

概述

Longformer 模型在Iz Beltagy, Matthew E. Peters, Arman Cohan 的《Longformer: The Long-Document Transformer》中提出。

论文摘要如下：

基于 Transformer 的模型由于其自注意力操作而无法处理长序列，该操作随着序列长度呈二次方增长。为了解决这一限制，我们引入了 Longformer，其注意力机制与序列长度呈线性增长，使其能够轻松处理数千个标记或更长文档。Longformer 的注意力机制是标准自注意力的替代品，结合了局部窗口注意力和任务驱动的全局注意力。在长序列 Transformer 的先前工作基础上，我们在字符级语言建模上评估 Longformer，并在 text8 和 enwik8 上取得了最新的成果。与大多数先前的工作相比，我们还对 Longformer 进行了预训练，并在各种下游任务上进行了微调。我们的预训练 Longformer 在长文档任务上始终优于 RoBERTa，并在 WikiHop 和 TriviaQA 上取得了最新的成果。

此模型由beltagy贡献。作者的代码可以在此处找到。

使用提示

• 由于 Longformer 基于 RoBERTa，它没有token_type_ids。您不需要指示哪个标记属于哪个段。只需使用分隔标记tokenizer.sep_token（或</s>）分隔您的段。
• 将注意力矩阵替换为稀疏矩阵以加快速度的变压器模型。通常，局部上下文（例如，左右两个标记是什么？）足以为给定标记采取行动。仍然会给定一些预选输入标记全局关注，但是注意力矩阵的参数要少得多，从而加快速度。有关更多信息，请参阅局部注意力部分。

Longformer 自注意力

Longformer 自注意力同时在“局部”上下文和“全局”上下文上使用自注意力。大多数标记仅“局部”地相互关注，这意味着每个标记只关注其前12w\frac{1}{2} w21​w 个标记和后12w\frac{1}{2} w21​w 个标记，其中www 是在config.attention_window中定义的窗口长度。请注意，config.attention_window可以是List类型，以定义每个层的不同www。少数选定的标记对所有其他标记进行“全局”关注，就像在BertSelfAttention中为所有标记惯例上所做的那样。

请注意，“局部”和“全局”关注的标记由不同的查询、键和值矩阵进行投影。还请注意，每个“局部”关注的标记不仅关注其窗口内的标记www，还关注所有“全局”关注的标记，以使全局关注是对称的。

用户可以通过在运行时适当设置张量global_attention_mask来定义哪些令牌“局部”关注，哪些令牌“全局”关注。所有 Longformer 模型都采用以下逻辑来处理global_attention_mask：

• 0：令牌“局部”关注，
• 1：令牌“全局”关注。

更多信息，请参考 forward()方法。

使用 Longformer 自注意力机制，通常代表内存和时间瓶颈的查询-键 matmul 操作的内存和时间复杂度可以从 O(ns×ns)降低到 O(ns×w)，其中 ns 是序列长度，w 是平均窗口大小。假设“全局”关注的令牌数量与“局部”关注的令牌数量相比微不足道。

更多信息，请参考官方论文。

训练

LongformerForMaskedLM 的训练方式与 RobertaForMaskedLM 完全相同，应该如下使用：

input_ids = tokenizer.encode("This is a sentence from [MASK] training data", return_tensors="pt")
mlm_labels = tokenizer.encode("This is a sentence from the training data", return_tensors="pt")

loss = model(input_ids, labels=input_ids, masked_lm_labels=mlm_labels)[0]

资源

• 文本分类任务指南
• 令牌分类任务指南
• 问答任务指南
• 遮蔽语言建模任务指南
• 多项选择任务指南

LongformerConfig

class transformers.LongformerConfig

<来源>

( attention_window: Union = 512 sep_token_id: int = 2 pad_token_id: int = 1 bos_token_id: int = 0 eos_token_id: int = 2 vocab_size: int = 30522 hidden_size: int = 768 num_hidden_layers: int = 12 num_attention_heads: int = 12 intermediate_size: int = 3072 hidden_act: str = 'gelu' hidden_dropout_prob: float = 0.1 attention_probs_dropout_prob: float = 0.1 max_position_embeddings: int = 512 type_vocab_size: int = 2 initializer_range: float = 0.02 layer_norm_eps: float = 1e-12 onnx_export: bool = False **kwargs )

参数

• vocab_size（int，可选，默认为 30522）— Longformer 模型的词汇量。定义了在调用 LongformerModel 或 TFLongformerModel 时可以由inputs_ids表示的不同令牌数量。
• hidden_size（int，可选，默认为 768）— 编码器层和池化器层的维度。
• num_hidden_layers（int，可选，默认为 12）— Transformer 编码器中的隐藏层数量。
• num_attention_heads（int，可选，默认为 12）— Transformer 编码器中每个注意力层的注意力头数量。
• intermediate_size（int，可选，默认为 3072）— Transformer 编码器中“中间”（通常称为前馈）层的维度。
• hidden_act（str或Callable，可选，默认为"gelu"）— 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。
• hidden_dropout_prob（float，可选，默认为 0.1）— 嵌入层、编码器和池化器中所有全连接层的丢失概率。
• attention_probs_dropout_prob (float, optional, defaults to 0.1) — 注意力概率的 dropout 比率。
• max_position_embeddings (int, optional, defaults to 512) — 此模型可能使用的最大序列长度。通常设置为较大的值以防万一（例如，512 或 1024 或 2048）。
• type_vocab_size (int, optional, defaults to 2) — 在调用 LongformerModel 或 TFLongformerModel 时传递的token_type_ids的词汇大小。
• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。
• attention_window (int or List[int], optional, defaults to 512) — 每个标记周围的注意力窗口大小。如果是int，则对所有层使用相同大小。要为每个层指定不同的窗口大小，请使用List[int]，其中len(attention_window) == num_hidden_layers。

这是用于存储 LongformerModel 或 TFLongformerModel 配置的配置类。它用于根据指定的参数实例化 Longformer 模型，定义模型架构。

这是用于存储 LongformerModel 配置的配置类。它用于根据指定的参数实例化 Longformer 模型，定义模型架构。使用默认值实例化配置将产生与 LongFormer allenai/longformer-base-4096架构相似的配置，序列长度为 4,096。

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

示例：

>>> from transformers import LongformerConfig, LongformerModel

>>> # Initializing a Longformer configuration
>>> configuration = LongformerConfig()

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

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

LongformerTokenizer

class transformers.LongformerTokenizer

<来源>

( 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, 默认为 "<s>") — 在进行序列分类（整个序列而不是每个标记的分类）时使用的分类器标记。这是构建带有特殊标记的序列时的第一个标记。
• unk_token (str, optional, 默认为 "<unk>") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。
• pad_token (str, optional, 默认为 "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时。
• mask_token (str, optional, 默认为 "<mask>") — 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
• add_prefix_space (bool, optional, 默认为 False) — 是否在输入前添加一个初始空格。这允许将前导单词视为任何其他单词。（Longformer 分词器通过前面的空格检测单词的开头）。

构建一个 Longformer 分词器，从 GPT-2 分词器派生，使用字节级字节对编码。

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

根据句子开头是否有空格，将被编码为不同的方式：

>>> from transformers import LongformerTokenizer

>>> tokenizer = LongformerTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> 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

<来源>

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

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

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

• 单个序列：<s> X </s>
• 序列对：<s> A </s></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], optional) — 可选的第二个 ID 列表，用于序列对。

返回

List[int]

零列表。

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

get_special_tokens_mask

<来源>

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

参数

• token_ids_0 (List[int]) — ID 列表。
• token_ids_1 (List[int], optional) — 可选的第二个 ID 列表，用于序列对。
• already_has_special_tokens (bool, optional, 默认为 False) — 标记列表是否已经格式化为模型的特殊标记。

返回

List[int]

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

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

LongformerTokenizerFast

class transformers.LongformerTokenizerFast

< source >

( 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）— 是否在输入中添加初始空格。这允许将前导单词视为任何其他单词。（Longformer 分词器通过前面的空格检测单词的开头）。
• trim_offsets（bool，可选，默认为True）— 后处理步骤是否应该修剪偏移量以避免包含空格。

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

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

在句子开头（没有空格）或不是时，可能会以不同方式编码：

>>> from transformers import LongformerTokenizerFast

>>> tokenizer = LongformerTokenizerFast.from_pretrained("allenai/longformer-base-4096")
>>> 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], optional) — 序列对的可选第二个 ID 列表。

返回

List[int]

零列表。

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

Longformer 特定输出

class transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput

<来源>

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

参数

• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
• 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时返回) — 每一层的torch.FloatTensor元组，形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的令牌数量。 在注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个令牌到具有全局注意力的每个令牌（前x个值）和到注意力窗口中的每个令牌（剩余的attention_window）的注意力权重。
  • 1values)。请注意，前x个值是指文本中具有固定位置的令牌，但剩余的attention_window + 1个值是指具有相对位置的令牌：令牌到自身的注意力权重位于索引x + attention_window / 2，前（后）的attention_window / 2个值是到前（后）的令牌的注意力权重。如果注意力窗口包含具有全局注意力的令牌，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中访问。如果一个令牌具有全局注意力，则到attentions中的所有其他令牌的注意力权重设置为 0，该值应从global_attentions`中访问。
• global_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 每一层的torch.FloatTensor元组，形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的令牌数量。 在注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是来自具有全局注意力的每个令牌到序列中每个令牌的注意力权重。

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

class transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling

<来源>

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

参数

• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
• pooler_output（形状为(batch_size, hidden_size)的torch.FloatTensor）— 序列第一个令牌（分类令牌）的最后一层隐藏状态，进一步由线性层和 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, x + attention_window + 1)的torch.FloatTensor元组（每层一个），其中x是具有全局注意力掩码的令牌数量。 在注意力 softmax 之后的本地注意力权重，用于计算自注意力头中的加权平均值。这些是从序列中的每个令牌到具有全局注意力的每个令牌（前x个值）以及到注意力窗口中的每个令牌的注意力权重（剩余的attention_window）。
  • 1值）。注意，前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 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是具有全局注意力的每个令牌到序列中的每个令牌的注意力权重。

Longformer 输出的基类，还包含最后隐藏状态的池化。

class transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput

<来源>

( loss: Optional = None logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None global_attentions: Optional = None )

参数

• loss（形状为(1,)的torch.FloatTensor，可选，在提供labels时返回）— 掩码语言建模（MLM）损失。
• logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）— 语言建模头的预测分数（SoftMax 之前每个词汇令牌的分数）。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。 模型在每一层输出的隐藏状态加上初始嵌入输出。
• attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)的torch.FloatTensor元组（每层一个），其中x是具有全局注意力掩码的令牌数。 在自注意力头中用于计算加权平均值的注意力 softmax 后的本地注意力权重。这些是从序列中的每个令牌到具有全局注意力的每个令牌（前x个值）和到注意力窗口中的每个令牌（剩余attention_window个值）的注意力权重。
  • 注意：前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 后的全局注意力权重。这些是从具有全局注意力的每个令牌到序列中的每个令牌的注意力权重。

用于掩码语言模型输出的基类。

class transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput

<来源>

( loss: Optional = None start_logits: FloatTensor = None end_logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None global_attentions: Optional = None )

参数

• 损失 (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 总跨度抽取损失是开始和结束位置的交叉熵之和。
• start_logits (torch.FloatTensor，形状为(batch_size, sequence_length)) — 跨度开始得分（SoftMax 之前）。
• end_logits (torch.FloatTensor，形状为(batch_size, sequence_length)) — 跨度结束得分（SoftMax 之前）。
• hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（嵌入输出的一个和每层输出的一个）。 模型在每一层输出的隐藏状态加上初始嵌入输出。
• attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)的torch.FloatTensor元组（每层一个），其中x是具有全局注意力掩码的令牌数。 在自注意力头中用于计算加权平均值的注意力 softmax 后的本地注意力权重。这些是从序列中的每个令牌到具有全局注意力的每个令牌（前x个值）和到注意力窗口中的每个令牌（剩余attention_window个值）。
  • 1值）。注意，前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 后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个令牌与序列中每个令牌的全局注意力的注意力权重。

用于问答 Longformer 模型输出的基类。

class transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput

<来源>

( loss: Optional = None logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None global_attentions: Optional = None )

参数

• loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类（如果config.num_labels==1则为回归）损失。
• logits (torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（如果config.num_labels==1则为回归）得分（SoftMax 之前）。
• hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（嵌入输出和每一层输出各一个）。 模型在每一层输出的隐藏状态加上初始嵌入输出。
• attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)的torch.FloatTensor元组（每层一个），其中x是具有全局注意力掩码的令牌数量。 注意力 softmax 后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个令牌与具有全局注意力的每个令牌（前x个值）以及注意力窗口中的每个令牌的注意力权重（剩余的attention_window值）。
  • 1值）。注意，前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 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是来自每个令牌的全局注意力到序列中每个令牌的注意力权重。

句子分类模型输出的基类。

class transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput

<来源>

( loss: Optional = None logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None global_attentions: Optional = None )

参数

• loss（torch.FloatTensor，形状为*(1,)*，可选，当提供labels时返回）— 分类损失。
• logits（形状为(batch_size, num_choices)的torch.FloatTensor）— num_choices是输入张量的第二维度。（参见上面的input_ids）。 分类得分（SoftMax 之前）。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（嵌入输出和每层输出各一个）。 模型在每一层输出的隐藏状态加上初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)的torch.FloatTensor元组（每层一个），其中x是具有全局注意力掩码的令牌数。 在注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是来自序列中每个令牌的注意力权重，分别对全局注意力的每个令牌（前x个值）和注意力窗口中的每个令牌进行注意力。
  • 1值）。请注意，前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 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是来自每个令牌的全局注意力到序列中每个令牌的注意力权重。

多选 Longformer 模型输出的基类。

class transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput

<来源>

( loss: Optional = None logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None global_attentions: Optional = None )

参数

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 分类损失。
• logits (torch.FloatTensor of shape (batch_size, sequence_length, config.num_labels)) — 分类得分（SoftMax 之前）。
• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。 模型在每一层输出的隐藏状态加上初始嵌入输出。
• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)的torch.FloatTensor元组（每层一个），其中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(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x)的torch.FloatTensor元组（每层一个），其中x是具有全局注意力掩码的标记数。 在注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是具有全局注意力的每个标记到序列中的每个标记的注意力权重。

用于标记分类模型输出的基类。

class transformers.models.longformer.modeling_tf_longformer.TFLongformerBaseModelOutput

<来源>

( 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 of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列输出。
• hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。 模型在每一层输出的隐藏状态加上初始嵌入输出。
• attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)的tf.Tensor元组（每层一个），其中x是具有全局注意力掩码的标记数。 在注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是从序列中的每个标记到具有全局注意力的每个标记（前x个值）以及到注意力窗口中的每个标记的注意力权重（剩余的attention_window）。
  • 1值）。注意，前x个值是指文本中具有固定位置的令牌，但剩余的attention_window + 1个值是指具有相对位置的令牌：令牌对自身的注意力权重位于索引x + attention_window / 2，前（后）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.longformer.modeling_tf_longformer.TFLongformerBaseModelOutputWithPooling

<来源>

( last_hidden_state: tf.Tensor = None pooler_output: 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（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor）- 模型最后一层的隐藏状态序列。
• pooler_output（形状为(batch_size, hidden_size)的tf.Tensor）- 序列第一个标记（分类标记）的最后一层隐藏状态，经过线性层和 Tanh 激活函数进一步处理。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。
• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。 模型在每一层输出的隐藏状态加上初始嵌入输出。
• attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)的tf.Tensor元组（每层一个），其中x是具有全局注意力掩码的令牌数。 本地注意力在注意力 softmax 之后的权重，用于计算自注意力头中的加权平均值。这些是来自序列中每个令牌到具有全局注意力的每个令牌（前x个值）和注意力窗口中每个令牌的注意力权重（剩余attention_window个值）。
  • 1值）。注意，前x个值是指文本中具有固定位置的令牌，但剩余的attention_window + 1个值是指具有相对位置的令牌：令牌对自身的注意力权重位于索引x + attention_window / 2，前（后）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.longformer.modeling_tf_longformer.TFLongformerMaskedLMOutput

<来源>

( loss: tf.Tensor | None = None logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None global_attentions: Tuple[tf.Tensor] | None = None )

参数

• loss（形状为(1,)的tf.Tensor，可选，在提供labels时返回）- 掩蔽语言建模（MLM）损失。
• logits（形状为(batch_size, sequence_length, config.vocab_size)的tf.Tensor）- 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每层的输出）。 模型在每一层输出的隐藏状态加上初始嵌入输出。
• attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, 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 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是具有全局注意力的每个标记到序列中的每个标记的注意力权重。

用于掩蔽语言模型输出的基类。

class transformers.models.longformer.modeling_tf_longformer.TFLongformerQuestionAnsweringModelOutput

<来源>

( loss: tf.Tensor | None = None start_logits: tf.Tensor = None end_logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None global_attentions: Tuple[tf.Tensor] | None = None )

参数

• loss（形状为(1,)的tf.Tensor，可选，在提供labels时返回）- 总跨度提取损失是起始位置和结束位置的交叉熵之和。
• start_logits (tf.Tensor of shape (batch_size, sequence_length)) — 跨度开始得分（SoftMax 之前）。
• end_logits (tf.Tensor of shape (batch_size, sequence_length)) — 跨度结束得分（SoftMax 之前）。
• hidden_states (tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每一层的输出）。 模型在每一层输出的隐藏状态加上初始嵌入输出。
• attentions (tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)的tf.Tensor元组（每层一个），其中x是具有全局注意力掩码的令牌数。 在注意力 SoftMax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是来自序列中每个令牌到具有全局注意力的每个令牌（前x个值）和到注意力窗口中的每个令牌（剩余attention_window个值）的注意力权重。
  • 1值）。请注意，前x个值是指文本中具有固定位置的令牌，但剩余的attention_window + 1个值是指具有相对位置的令牌：令牌对自身的注意力权重位于索引x + attention_window / 2，前（后）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.longformer.modeling_tf_longformer.TFLongformerSequenceClassifierOutput

<来源>

( loss: tf.Tensor | None = None logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None global_attentions: Tuple[tf.Tensor] | None = None )

参数

• loss (tf.Tensor of shape (1,)，可选，当提供labels时返回） — 分类（如果 config.num_labels==1 则为回归）损失。
• logits (tf.Tensor of shape (batch_size, config.num_labels)) — 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。
• hidden_states (tuple(tf.Tensor)，可选，当传递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个值）和到注意力窗口中的每个令牌的注意力权重。
  • 1值）。请注意，前x个值是指文本中具有固定位置的令牌，但剩余的attention_window + 1值是指具有相对位置的令牌：令牌对自身的注意力权重位于索引x + attention_window / 2，前（后）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 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是来自每个令牌的全局注意力到序列中每个令牌的注意力权重。

句子分类模型输出的基类。

class transformers.models.longformer.modeling_tf_longformer.TFLongformerMultipleChoiceModelOutput

来源

( loss: tf.Tensor | None = None logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None global_attentions: Tuple[tf.Tensor] | None = None )

参数

• loss (tf.Tensor，形状为*(1,)*，可选的，当提供labels时返回) — 分类损失。
• logits (tf.Tensor，形状为(batch_size, num_choices)) — num_choices是输入张量的第二维度。（参见上面的input_ids）。 分类得分（SoftMax 之前）。
• hidden_states (tuple(tf.Tensor), 可选的, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每层的输出）。 模型在每一层输出的隐藏状态加上初始嵌入输出。
• attentions (tuple(tf.Tensor), 可选的, 当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)的tf.Tensor元组（每层一个），其中x是具有全局注意力掩码的令牌数量。 在注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是来自序列中每个令牌到具有全局注意力的每个令牌（前x个值）和到注意力窗口中的每个令牌的注意力权重。
  • 1值）。请注意，前x个值是指文本中具有固定位置的令牌，但剩余的attention_window + 1值是指具有相对位置的令牌：令牌对自身的注意力权重位于索引x + attention_window / 2，前（后）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 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是具有全局注意力的每个标记到序列中每个标记的注意力权重。

多选模型输出的基类。

class transformers.models.longformer.modeling_tf_longformer.TFLongformerTokenClassifierOutput

<来源>

( loss: tf.Tensor | None = None logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None global_attentions: Tuple[tf.Tensor] | None = None )

参数

• loss（形状为(1,)的tf.Tensor，可选，当提供labels时返回）— 分类损失。
• logits（形状为(batch_size, sequence_length, config.num_labels)的tf.Tensor）— 分类分数（SoftMax 之前）。
• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（嵌入输出的一个和每层输出的一个）。 每层输出的模型隐藏状态加上初始嵌入输出。
• attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)的tf.Tensor元组（每层一个），其中x是具有全局注意力掩码的标记数。 在注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个标记到具有全局注意力的每个标记（前x个值）和到注意力窗口中的每个标记（剩余attention_window个值）的注意力权重。
  • 1values)。请注意，前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 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是具有全局注意力的每个标记到序列中每个标记的注意力权重。

标记分类模型输出的基类。

Pytorch 隐藏 Pytorch 内容

LongformerModel

class transformers.LongformerModel

<来源>

( config add_pooling_layer = True )

参数

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

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

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

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

这个类从 RobertaModel 复制了代码，并用 Longformer 自注意力覆盖了标准的自注意力，以提供处理长序列的能力，遵循Longformer: 长文档 Transformer中描述的自注意力方法，作者是 Iz Beltagy、Matthew E. Peters 和 Arman Cohan。Longformer 自注意力结合了局部（滑动窗口）和全局注意力，以扩展到长文档，而不会导致内存和计算的 O(n²) 增加。

这里实现的自注意力模块LongformerSelfAttention支持局部和全局注意力的组合，但不支持自回归注意力和扩张注意力。自回归和扩张注意力对于自回归语言建模比微调下游任务更相关。未来的版本将添加对自回归注意力的支持，但对扩张注意力的支持需要自定义 CUDA 内核以提高内存和计算效率。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None global_attention_mask: Optional = None head_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling 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 代表被掩盖的标记。

  什么是注意力掩码？

• global_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选） — 决定每个标记上的注意力分配，局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于任务特定的微调很重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予该标记全局注意力。对于问答，所有问题标记也应该具有全局注意力。请参考Longformer 论文获取更多细节。掩码值选在[0, 1]之间：
  • 0 代表局部注意力（滑动窗口注意力），
  • 1 表示全局注意力（关注所有其他标记，所有其他标记也关注它们）。
• head_mask (torch.Tensor of shape (num_layers, num_heads), optional) — 在编码器中，用于使注意力模块的特定头部失效的掩码。掩码值在 [0, 1] 中选择：
  • 1 表示头部未被屏蔽，
  • 0 表示头部被屏蔽。
• decoder_head_mask (torch.Tensor of shape (num_layers, num_heads), 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？
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制权来将 input_ids 索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling 或 tuple(torch.FloatTensor)

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

• last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列的输出。
• pooler_output (torch.FloatTensor of shape (batch_size, hidden_size)) — 序列第一个标记（分类标记）的最后一层隐藏状态，进一步由线性层和 Tanh 激活函数处理。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。
• hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（一个用于嵌入的输出 + 一个用于每一层的输出）。 模型在每一层的输出的隐藏状态加上初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, 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 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是具有全局注意力的每个标记到序列中的每个标记的注意力权重。

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

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

示例：

>>> import torch
>>> from transformers import LongformerModel, AutoTokenizer

>>> model = LongformerModel.from_pretrained("allenai/longformer-base-4096")
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")

>>> SAMPLE_TEXT = " ".join(["Hello world! "] * 1000)  # long input document
>>> input_ids = torch.tensor(tokenizer.encode(SAMPLE_TEXT)).unsqueeze(0)  # batch of size 1

>>> attention_mask = torch.ones(
...     input_ids.shape, dtype=torch.long, device=input_ids.device
... )  # initialize to local attention
>>> global_attention_mask = torch.zeros(
...     input_ids.shape, dtype=torch.long, device=input_ids.device
... )  # initialize to global attention to be deactivated for all tokens
>>> global_attention_mask[
...     :,
...     [
...         1,
...         4,
...         21,
...     ],
... ] = 1  # Set global attention to random tokens for the sake of this example
>>> # Usually, set global attention based on the task. For example,
>>> # classification: the <s> token
>>> # QA: question tokens
>>> # LM: potentially on the beginning of sentences and paragraphs
>>> outputs = model(input_ids, attention_mask=attention_mask, global_attention_mask=global_attention_mask)
>>> sequence_output = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output

LongformerForMaskedLM

class transformers.LongformerForMaskedLM

<来源>

( config )

参数

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

在顶部带有语言建模头的 Longformer 模型。

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

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None global_attention_mask: Optional = None head_mask: Optional = None token_type_ids: Optional = None position_ids: 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.models.longformer.modeling_longformer.LongformerMaskedLMOutput or tuple(torch.FloatTensor)

参数

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

  什么是 attention masks？

• global_attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于决定每个标记的注意力分配，局部注意力或全局注意力。具有全局注意力的标记关注所有其他标记，所有其他标记也关注它们。这对于任务特定的微调很重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予~~标记全局注意力。对于问答，所有问题标记也应该具有全局注意力。请参考Longformer paper获取更多详细信息。掩码值选在[0, 1]之间：
  • 0 表示局部注意力（滑动窗口注意力），
  • 1 表示全局注意力（关注所有其他标记，所有其他标记也关注它们）。
• head_mask (torch.Tensor of shape (num_layers, num_heads), optional) — 用于使编码器中的注意力模块中的选定头部失效的掩码。掩码值选在[0, 1]之间：
  • 1 表示头部未被掩盖，
  • 0 表示头部被掩盖。
• decoder_head_mask (torch.Tensor of shape (num_layers, num_heads), optional) — 用于使解码器中的注意力模块中的选定头部失效的掩码。掩码值选在[0, 1]之间：
  • 1 表示头部未被掩盖，
  • 0 表示头部被掩盖。
• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段标记索引，指示输入的第一部分和第二部分。索引选在[0, 1]之间：
  • 0 对应于句子 A标记，
  • 1 对应于句子 B标记。

  什么是 token type IDs？

• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围在[0, config.max_position_embeddings - 1]内。 什么是 position IDs？
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多细节，请参阅返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多细节，请参阅返回张量下的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
• labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算掩盖语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]范围内（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩盖），损失仅计算具有标签在[0, ..., config.vocab_size]范围内的标记
• kwargs（Dict[str, any]，可选，默认为*{}*）— 用于隐藏已被弃用的旧参数。

返回

transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput 或tuple(torch.FloatTensor)

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

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 掩码语言建模（MLM）损失。
• logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）— 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入输出，一个用于每一层的输出）。 模型在每一层输出的隐藏状态加上初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)的torch.FloatTensor元组（每层一个），其中x是具有全局注意力掩码的标记数。 在注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是从序列中的每个标记到具有全局注意力的每个标记（前x个值）以及到注意力窗口中的每个标记（剩余的attention_window值）的注意力权重。
  • 注意：第一个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 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是从具有全局注意力的每个标记到序列中的每个标记的注意力权重。

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

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

填充掩码示例：

>>> from transformers import AutoTokenizer, LongformerForMaskedLM

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = LongformerForMaskedLM.from_pretrained("allenai/longformer-base-4096")

让我们尝试一个非常长的输入。

>>> TXT = (
...     "My friends are <mask> but they eat too many carbs."
...     + " That's why I decide not to eat with them." * 300
... )
>>> input_ids = tokenizer([TXT], return_tensors="pt")["input_ids"]
>>> logits = model(input_ids).logits

>>> masked_index = (input_ids[0] == tokenizer.mask_token_id).nonzero().item()
>>> probs = logits[0, masked_index].softmax(dim=0)
>>> values, predictions = probs.topk(5)

>>> tokenizer.decode(predictions).split()
['healthy', 'skinny', 'thin', 'good', 'vegetarian']

LongformerForSequenceClassification

class transformers.LongformerForSequenceClassification

<来源>

( config )

参数

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

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

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

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None global_attention_mask: Optional = None head_mask: Optional = None token_type_ids: Optional = None position_ids: 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.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput 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 表示被掩盖的标记。

  什么是注意力蒙版？

• global_attention_mask (torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于决定每个标记上的注意力的蒙版，局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，而所有其他标记会关注它们。这对于特定任务微调很重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予全局关注。对于问答，所有问题标记也应该有全局关注。请参阅Longformer 论文以获取更多详细信息。蒙版值选择在[0, 1]之间：
  • 0 表示局部注意力（滑动窗口注意力），
  • 1 表示全局注意力（关注所有其他标记的标记，所有其他标记也关注它们）。
• head_mask (torch.Tensor，形状为(num_layers, num_heads)，可选) — 用于在编码器中使注意力模块的选定头部失效的蒙版。蒙版值选择在[0, 1]之间：
  • 1 表示头部未被掩盖，
  • 0 表示头部被masked。
• decoder_head_mask (torch.Tensor，形状为(num_layers, num_heads)，可选) — 用于在解码器中使注意力模块的选定头部失效的蒙版。蒙版值选择在[0, 1]之间：
  • 1 表示头部未被掩盖，
  • 0 表示头部被masked。
• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段落标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
  • 0 对应于 句子 A 的标记，
  • 1 对应于 句子 B 的标记。

  什么是 token type IDs？

• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。 什么是 position IDs？
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制权来将 input_ids 索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的 attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的 hidden_states。
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。
• labels (torch.LongTensor of shape (batch_size,), optional) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。

返回

transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput 或 tuple(torch.FloatTensor)

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

• loss (torch.FloatTensor of shape (1,), optional, 当提供 labels 时返回) — 分类（如果 config.num_labels==1 则为回归）损失。
• logits (torch.FloatTensor of shape (batch_size, config.num_labels)) — 分类（如果 config.num_labels==1 则为回归）分数（SoftMax 之前）。
• hidden_states (tuple(torch.FloatTensor), 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, 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 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是来自具有全局注意力的每个令牌到序列中每个令牌的注意力权重。

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

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

单标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, LongformerForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("jpwahle/longformer-base-plagiarism-detection")
>>> model = LongformerForSequenceClassification.from_pretrained("jpwahle/longformer-base-plagiarism-detection")

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

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

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

>>> # 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 = LongformerForSequenceClassification.from_pretrained("jpwahle/longformer-base-plagiarism-detection", num_labels=num_labels)

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

多标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, LongformerForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("jpwahle/longformer-base-plagiarism-detection")
>>> model = LongformerForSequenceClassification.from_pretrained("jpwahle/longformer-base-plagiarism-detection", 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 = LongformerForSequenceClassification.from_pretrained(
...     "jpwahle/longformer-base-plagiarism-detection", 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

LongformerForMultipleChoice

class transformers.LongformerForMultipleChoice

< source >

( config )

参数

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

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

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

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

forward

< source >

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

参数

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

  什么是注意力掩码？

• global_attention_mask（形状为(batch_size, num_choices, sequence_length)的torch.FloatTensor，可选）— 用于决定每个标记上给予的注意力，局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于任务特定的微调非常重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予全局注意力。对于问答，所有问题标记也应该具有全局注意力。有关更多详细信息，请参考Longformer paper。在[0, 1]中选择的掩码值：
  • 0 表示局部注意力（滑动窗口注意力），
  • 1 表示全局注意力（关注所有其他标记的标记，所有其他标记也关注它们）。
• head_mask（形状为(num_layers, num_heads)的torch.Tensor，可选）— 用于在编码器中使注意力模块的选定头部失效的掩码。在[0, 1]中选择的掩码值：
  • 1 表示头部是未掩码。
  • 0 表示头部是掩码。
• decoder_head_mask（形状为(num_layers, num_heads)的torch.Tensor，可选）— 用于在解码器中使注意力模块的选定头部失效的掩码。在[0, 1]中选择的掩码值：
  • 1 表示头部是未掩码，
  • 0 表示头部是掩码。
• token_type_ids（形状为(batch_size, num_choices, sequence_length)的torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
  • 0 对应于句子 A标记，
  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• position_ids（形状为(batch_size, num_choices, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• inputs_embeds（形状为(batch_size, num_choices, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回的张量下的attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回的张量下的hidden_states。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。
• labels（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算多项选择分类损失的标签。索引应在[0, ..., num_choices-1]范围内，其中num_choices是输入张量第二维的大小。（参见上面的input_ids）

返回

transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput 或tuple(torch.FloatTensor)

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

• loss（形状为*(1,)*的torch.FloatTensor，可选，当提供labels时返回）- 分类损失。
• logits（形状为(batch_size, num_choices)的torch.FloatTensor）- num_choices是输入张量的第二维。（参见上面的input_ids）。 分类得分（SoftMax 之前）。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。 模型在每一层输出的隐藏状态加上初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, 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 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是来自具有全局注意力的每个令牌到序列中每个令牌的注意力权重。

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

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

示例：

>>> from transformers import AutoTokenizer, LongformerForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = LongformerForMultipleChoice.from_pretrained("allenai/longformer-base-4096")

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

LongformerForTokenClassification

class transformers.LongformerForTokenClassification

< source >

( config )

参数

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

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

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

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None global_attention_mask: Optional = None head_mask: Optional = None token_type_ids: Optional = None position_ids: 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.models.longformer.modeling_longformer.LongformerTokenClassifierOutput 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 用于被掩码的标记。

  什么是注意力掩码？

• global_attention_mask（形状为 (batch_size, sequence_length) 的 torch.FloatTensor，可选）— 用于决定每个标记上给予的注意力，局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，而所有其他标记会关注它们。这对于任务特定的微调很重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予全局注意力。对于问答，所有问题标记也应该有全局注意力。有关更多详细信息，请参阅Longformer 论文。掩码值选定在 [0, 1]：
  • 0 用于局部注意力（滑动窗口注意力），
  • 1 用于全局注意力（关注所有其他标记的标记，所有其他标记也关注它们）。
• head_mask（形状为 (num_layers, num_heads) 的 torch.Tensor，可选）— 用于在编码器中使注意力模块中的选定头部失效的掩码。掩码值选定在 [0, 1]：
  • 1 表示头部未被掩码。
  • 0 表示头部被掩码。
• decoder_head_mask（形状为 (num_layers, num_heads) 的 torch.Tensor，可选）— 用于在解码器中使注意力模块中的选定头部失效的掩码。掩码值选定在 [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？
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。
• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于计算令牌分类损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。

返回

transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput 或者tuple(torch.FloatTensor)

一个 transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput 或者一个torch.FloatTensor元组（如果传递了return_dict=False或者config.return_dict=False时）包括不同的元素，取决于配置（LongformerConfig）和输入。

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 分类损失。
• logits（形状为(batch_size, sequence_length, config.num_labels)的torch.FloatTensor）— 分类分数（SoftMax 之前）。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或者config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每一层的输出）。 模型在每一层输出的隐藏状态加上初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或者config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, 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 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的令牌对序列中的每个令牌的注意力权重。

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

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

示例：

>>> from transformers import AutoTokenizer, LongformerForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("brad1141/Longformer-finetuned-norm")
>>> model = LongformerForTokenClassification.from_pretrained("brad1141/Longformer-finetuned-norm")

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

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

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
['Evidence', 'Evidence', 'Evidence', 'Evidence', 'Evidence', 'Evidence', 'Evidence', 'Evidence', 'Evidence', 'Evidence', 'Evidence', 'Evidence']

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

LongformerForQuestionAnswering

class transformers.LongformerForQuestionAnswering

< source >

( config )

参数

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

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

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

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

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None global_attention_mask: Optional = None head_mask: Optional = None token_type_ids: Optional = None position_ids: 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.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput or tuple(torch.FloatTensor)

参数

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

  什么是注意力掩码？

• global_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于决定每个标记上给出的注意力，局部注意力或全局注意力。具有全局注意力的标记关注所有其他标记，所有其他标记也关注它们。这对于任务特定的微调非常重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予标记全局注意力。对于问答，所有问题标记也应该具有全局注意力。有关更多详细信息，请参阅Longformer paper。选择的掩码值为[0, 1]：
  • 0 用于局部注意力（滑动窗口注意力），
  • 1 用于全局注意力（关注所有其他标记，所有其他标记也关注它们）。
• head_mask（形状为(num_layers, num_heads)的torch.Tensor，可选）— 用于在编码器中使注意力模块中的选定头部失效的掩码。选择的掩码值为[0, 1]：
  • 1 表示头部未被masked，
  • 0 表示头部被masked。
• decoder_head_mask（形状为(num_layers, num_heads)的torch.Tensor，可选）— 用于在解码器中使注意力模块中的选定头部失效的掩码。选择的掩码值为[0, 1]：
  • 1 表示头部未被masked，
  • 0 表示头部被masked。
• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]中：
  • 0 对应一个句子 A标记，
  • 1 对应一个句子 B标记。

  什么是标记类型 ID？

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• 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.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput 或tuple(torch.FloatTensor)

transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包括根据配置（LongformerConfig）和输入而异的各种元素。

• 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时返回） — 形状为(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）的注意力权重。
  • 1值）。请注意，前x个值是指文本中固定位置的令牌，但剩余的attention_window + 1个值是指相对位置的令牌：令牌对自身的注意力权重位于索引x + 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 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是具有全局注意力的每个令牌到序列中的每个令牌的注意力权重。

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

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

示例：

>>> from transformers import AutoTokenizer, LongformerForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-large-4096-finetuned-triviaqa")
>>> model = LongformerForQuestionAnswering.from_pretrained("allenai/longformer-large-4096-finetuned-triviaqa")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> encoding = tokenizer(question, text, return_tensors="pt")
>>> input_ids = encoding["input_ids"]

>>> # default is local attention everywhere
>>> # the forward method will automatically set global attention on question tokens
>>> attention_mask = encoding["attention_mask"]

>>> outputs = model(input_ids, attention_mask=attention_mask)
>>> start_logits = outputs.start_logits
>>> end_logits = outputs.end_logits
>>> all_tokens = tokenizer.convert_ids_to_tokens(input_ids[0].tolist())

>>> answer_tokens = all_tokens[torch.argmax(start_logits) : torch.argmax(end_logits) + 1]
>>> answer = tokenizer.decode(
...     tokenizer.convert_tokens_to_ids(answer_tokens)
... )  # remove space prepending space token

TensorFlowHide TensorFlow 内容

TFLongformerModel

class transformers.TFLongformerModel

<来源>

( config *inputs **kwargs )

参数

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

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

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

这个模型也是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档，了解所有与一般使用和行为相关的事项。

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

• 所有输入作为关键字参数（类似于 PyTorch 模型），或者
• 所有输入作为列表、元组或字典在第一个位置参数中。

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

• 只有一个input_ids的张量，没有其他内容：model(input_ids)
• 一个长度可变的列表，包含一个或多个按照文档字符串中给定顺序的输入张量：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])
• 一个包含一个或多个与文档字符串中给定输入名称相关联的输入张量的字典：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

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

这个类从 TFRobertaModel 复制代码，并用 Longformer 自注意力覆盖标准的自注意力，以提供处理长序列的能力，遵循[Iz Beltagy, Matthew E. Peters, and Arman Cohan 撰写的《Longformer: the Long-Document Transformer》中描述的自注意力方法。Longformer 自注意力结合了局部（滑动窗口）和全局注意力，以扩展到长文档，而不会增加 O(n²)的内存和计算量。

这里实现的自注意力模块TFLongformerSelfAttention支持局部和全局注意力的组合，但不支持自回归注意力和扩张注意力。自回归和扩张注意力对于自回归语言建模比下游任务的微调更相关。未来的版本将添加对自回归注意力的支持，但对扩张注意力的支持需要一个自定义 CUDA 内核，以实现内存和计算的高效性。

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None global_attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False )

参数

• input_ids (np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。 什么是输入 ID？
• attention_mask (np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。在[0, 1]中选择的掩码值：
  • 1 表示未被masked的标记，
  • 对于被masked的标记为 0。

  什么是注意力掩码？

• head_mask (np.ndarray或tf.Tensor，形状为(encoder_layers, encoder_attention_heads)，可选) — 用于使注意力模块的选定头部失效的掩码。在[0, 1]中选择的掩码值：
  • 1 表示头部未被masked，
  • 0 表示头部被masked。
• global_attention_mask (np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用于决定每个标记上给予的注意力，局部注意力或全局注意力的掩码。具有全局注意力的标记会关注所有其他标记，而所有其他标记会关注它们。这对于任务特定的微调很重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予全局注意力。对于问答，所有问题标记也应该有全局注意力。有关更多详细信息，请参阅Longformer 论文。在[0, 1]中选择的掩码值：
  • 对于局部注意力（滑动窗口注意力），为 0。
  • 1 表示全局注意力（关注所有其他标记，所有其他标记也关注它们）。
• token_type_ids (np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
  • 0 对应于一个句子 A的标记，
  • 1 对应于一个句子 B的标记。

  令牌类型 ID 是什么？

• position_ids (np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• inputs_embeds (np.ndarray或tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。这个参数只能在急切模式下使用，在图模式下，将使用配置中的值。
• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。这个参数只能在急切模式下使用，在图模式下，将使用配置中的值。
• return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。这个参数可以在急切模式下使用，在图模式下，该值将始终设置为 True。
• training（bool，可选，默认为False） - 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。

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

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

TFLongformerForMaskedLM

class transformers.TFLongformerForMaskedLM

<来源>

( config *inputs **kwargs )

参数

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

在顶部带有语言建模头的 Longformer 模型。

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

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

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

• 将所有输入作为关键字参数（就像 PyTorch 模型一样），或者
• 将所有输入作为列表、元组或字典的第一个位置参数。

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

• 只有一个张量input_ids，没有其他内容：model(input_ids)
• 按照文档字符串中给定的顺序，具有一个或多个输入张量的长度可变的列表：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])
• 具有一个或多个与文档字符串中给定的输入名称相关联的输入张量的字典：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

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

call

<来源>

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

参数

• input_ids（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor） - 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 来获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。 什么是输入 ID？
• attention_mask（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选） — 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：
  • 1 表示未掩码的标记，
  • 0 表示已掩码的标记。

  什么是注意力掩码？

• head_mask（形状为(encoder_layers, encoder_attention_heads)的np.ndarray或tf.Tensor，可选） — 用于使注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]中：
  • 1 表示头部未掩码，
  • 0 表示头部是掩码。
• global_attention_mask（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选） — 用于决定每个标记上给定的注意力，局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，而所有其他标记会关注它们。这对于特定任务微调非常重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予全局关注。对于问答，所有问题标记也应该有全局关注。有关更多详细信息，请参阅Longformer paper。选择的掩码值在[0, 1]中：
  • 0 用于局部注意力（滑动窗口注意力），
  • 1 表示全局注意力（关注所有其他标记的标记，以及所有其他标记关注它们）。
• token_type_ids（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选） — 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]中：
  • 0 对应于句子 A的标记，
  • 1 对应于句子 B的标记。

  什么是标记类型 ID？

• position_ids（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选） — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的np.ndarray或tf.Tensor，可选） — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权，以便将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• output_attentions（bool，可选） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数仅可在急切模式下使用，在图模式下，将使用配置中的值。
• output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅可在急切模式下使用，在图模式下，将使用配置中的值。
• return_dict（bool，可选） — 是否返回 ModelOutput 而不是普通元组。此参数可以在急切模式下使用，在图模式下，该值将始终设置为 True。
• training（bool，可选，默认为False） — 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。
• labels（形状为(batch_size, sequence_length)的tf.Tensor，可选）— 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]内（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。

返回

transformers.models.longformer.modeling_tf_longformer.TFLongformerMaskedLMOutput 或tuple(tf.Tensor)

transformers.models.longformer.modeling_tf_longformer.TFLongformerMaskedLMOutput 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，取决于配置（LongformerConfig）和输入。

• loss（形状为(1,)的tf.Tensor，可选，当提供labels时返回）— 掩码语言建模（MLM）损失。
• logits（形状为(batch_size, sequence_length, config.vocab_size)的tf.Tensor）— 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出，一个用于每一层的输出）。 模型在每一层输出的隐藏状态加上初始嵌入输出。
• attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)的tf.Tensor元组（每层一个），其中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(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, x)的tf.Tensor元组（每层一个），其中x是具有全局注意力掩码的标记数。 在注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是具有全局注意力的每个标记到序列中每个标记的注意力权重。

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

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

示例：

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

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = TFLongformerForMaskedLM.from_pretrained("allenai/longformer-base-4096")

>>> inputs = tokenizer("The capital of France is <mask>.", return_tensors="tf")
>>> logits = model(**inputs).logits

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

>>> predicted_token_id = tf.math.argmax(selected_logits, axis=-1)
>>> tokenizer.decode(predicted_token_id)
' Paris'

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

>>> outputs = model(**inputs, labels=labels)
>>> round(float(outputs.loss), 2)
0.44

TFLongformerForQuestionAnswering

class transformers.TFLongformerForQuestionAnswering

< source >

( config *inputs **kwargs )

参数

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

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

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

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

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

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或
• 将所有输入作为列表、元组或字典放在第一个位置参数中。

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

• 仅具有 input_ids 的单个张量，没有其他内容：model(input_ids)
• 一个长度可变的列表，其中包含一个或多个输入张量，按照文档字符串中给定的顺序：model([input_ids, attention_mask]) 或 model([input_ids, attention_mask, token_type_ids])
• 一个字典，其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

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

call

< source >

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

参数

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

  什么是注意力掩码？

• head_mask (np.ndarray或tf.Tensor，形状为(encoder_layers, encoder_attention_heads)，可选) — 用于使注意力模块的特定头部失效的掩码。选择的掩码值为[0, 1]：
  • 1 表示头部未被masked，
  • 0 表示头部被masked。
• global_attention_mask (np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 决定每个标记上给予的注意力，局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，而所有其他标记会关注它们。这对于任务特定的微调非常重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予全局关注。对于问答，所有问题标记也应该有全局关注。有关更多详细信息，请参考Longformer paper。选择的掩码值为[0, 1]：
  • 0 表示局部注意力（滑动窗口注意力），
  • 1 表示全局注意力（关注所有其他标记的标记，所有其他标记也关注它们）。
• token_type_ids (np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]中：
  • 0 对应于句子 A标记，
  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• position_ids (np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 什么是位置 ID？
• inputs_embeds (np.ndarray或tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的attentions。此参数仅在急切模式下可用，在图模式下将使用配置中的值。
• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的hidden_states。此参数仅在急切模式下可用，在图模式下将使用配置中的值。
• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数仅在急切模式下可用，在图模式下该值将始终设置为 True。
• training (bool, 可选，默认为False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。
• start_positions (tf.Tensor，形状为(batch_size,)，可选) — 用于计算标记分类损失的标记跨度开始位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。超出序列范围的位置不会用于计算损失。
• end_positions（形状为(batch_size,)的tf.Tensor，可选）— 用于计算标记范围结束位置的位置（索引）标签，以计算标记分类损失。位置被夹紧到序列的长度（sequence_length）。超出序列范围的位置不会用于计算损失。

返回值

transformers.models.longformer.modeling_tf_longformer.TFLongformerQuestionAnsweringModelOutput 或 tuple(tf.Tensor)

一个 transformers.models.longformer.modeling_tf_longformer.TFLongformerQuestionAnsweringModelOutput 或一个tf.Tensor元组（如果传递了return_dict=False或config.return_dict=False）包含各种元素，这取决于配置（LongformerConfig）和输入。

• loss（形状为(1,)的tf.Tensor，可选，当提供labels时返回）— 总跨度提取损失是起始和结束位置的交叉熵之和。
• start_logits（形状为(batch_size, sequence_length)的tf.Tensor）— 跨度起始得分（在 SoftMax 之前）。
• end_logits（形状为(batch_size, sequence_length)的tf.Tensor）— 跨度结束得分（在 SoftMax 之前）。
• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。 模型在每个层输出的隐藏状态加上初始嵌入输出。
• attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)的tf.Tensor元组，其中x是具有全局注意力掩码的令牌数。 自注意力头中用于计算加权平均值的注意力 softmax 后的本地注意力权重。这些是从序列中的每个令牌到具有全局注意力的每个令牌（前x个值）和到注意力窗口中的每个令牌（剩余的attention_window值）的注意力权重。
  • 注意：第一个x个值是指文本中具有固定位置的令牌，但剩余的attention_window + 1个值是指具有相对位置的令牌：令牌与自身的注意力权重位于索引x + attention_window / 2，前（后）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 后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是从具有全局注意力的每个令牌到序列中的每个令牌的注意力权重。

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

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

示例：

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

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-large-4096-finetuned-triviaqa")
>>> model = TFLongformerForQuestionAnswering.from_pretrained("allenai/longformer-large-4096-finetuned-triviaqa")

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

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

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

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens)
' puppet'

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

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

TFLongformerForSequenceClassification

class transformers.TFLongformerForSequenceClassification

<来源>

( config *inputs **kwargs )

参数

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

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

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

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

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

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或
• 将所有输入作为列表、元组或字典放在第一个位置参数中。

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

• 只有一个input_ids的张量，没有其他内容：model(input_ids)
• 一个长度可变的列表，其中包含一个或多个按照文档字符串中给定的顺序的输入张量：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])
• 一个字典，其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

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

call

<来源>

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

参数

• input_ids（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor） — 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。 什么是输入 ID？
• attention_mask（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选定在[0, 1]范围内：
  • 1 表示未被屏蔽的标记，
  • 0 表示被屏蔽的标记。

  什么是注意力掩码？

• head_mask（形状为(encoder_layers, encoder_attention_heads)的np.ndarray或tf.Tensor，可选）— 用于使注意力模块中的选定头部失效的掩码。掩码值选定在[0, 1]范围内：
  • 1 表示头部未被屏蔽，
  • 0 表示头部被屏蔽。
• global_attention_mask（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选）— 用于决定每个标记上给予的注意力，局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于任务特定的微调很重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予全局注意力。对于问答，所有问题标记也应该有全局注意力。有关更多详细信息，请参阅Longformer 论文。掩码值选定在[0, 1]范围内：
  • 0 表示局部注意力（滑动窗口注意力），
  • 1 表示全局注意力（关注所有其他标记的标记，所有其他标记也关注它们）。
• token_type_ids（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引选定在[0, 1]范围内：
  • 0 对应于一个句子 A的标记，
  • 1 对应于一个句子 B的标记。

  什么是标记类型 ID？

• position_ids（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选）— 输入序列标记的位置嵌入中每个位置的索引。在范围[0, config.max_position_embeddings - 1]中选定。 什么是位置 ID？
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的np.ndarray或tf.Tensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。此参数可以在急切模式下使用，在图模式下该值将始终设置为 True。
• training（bool，可选，默认为False）— 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。

返回

transformers.models.longformer.modeling_tf_longformer.TFLongformerSequenceClassifierOutput 或tuple(tf.Tensor)

一个 transformers.models.longformer.modeling_tf_longformer.TFLongformerSequenceClassifierOutput 或一个tf.Tensor元组（如果传递了return_dict=False或config.return_dict=False）包括根据配置（LongformerConfig）和输入的不同元素。

• loss (tf.Tensor，形状为(1,)，optional，当提供labels时返回) — 分类（如果config.num_labels==1则为回归）损失。
• logits (tf.Tensor，形状为(batch_size, config.num_labels)） — 分类（如果config.num_labels==1则为回归）分数（SoftMax 之前）。
• hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。 模型在每个层的输出以及初始嵌入输出的隐藏状态。
• attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, 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), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x)的tf.Tensor元组（每个层一个），其中x是具有全局注意力掩码的标记数。 在自注意力头中用于计算加权平均值的全局注意力权重。这些是具有全局注意力的每个标记到序列中的每个标记的注意力权重。

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

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

示例：

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

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = TFLongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096")

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

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

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

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = TFLongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096", num_labels=num_labels)

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

TFLongformerForTokenClassification

class transformers.TFLongformerForTokenClassification

<来源>

( config *inputs **kwargs )

参数

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

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

此模型继承自 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 head_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None global_attention_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: Optional[Union[np.array, tf.Tensor]] = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.models.longformer.modeling_tf_longformer.TFLongformerTokenClassifierOutput or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor）- 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。 什么是输入 ID？
• attention_mask（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：
  • 1 表示未被掩盖的标记，
  • 0 表示被掩盖的标记。

  什么是注意力掩码？

• head_mask (np.ndarray或tf.Tensor，形状为(encoder_layers, encoder_attention_heads)，optional) — 用于使注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]中：
  • 1 表示头部未被遮蔽，
  • 0 表示头部被遮蔽。
• global_attention_mask (np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，optional) — 用于决定每个标记上给定的注意力，局部注意力或全局注意力。具有全局注意力的标记关注所有其他标记，所有其他标记也关注它们。这对于特定任务微调很重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予标记全局注意力。对于问答，所有问题标记也应该具有全局注意力。有关更多详细信息，请参考Longformer paper。选择的掩码值在[0, 1]中：
  • 0 表示局部注意力（滑动窗口注意力），
  • 1 表示全局注意力（关注所有其他标记，所有其他标记也关注它们）。
• token_type_ids (np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，optional) — 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
  • 0 对应于 句子 A 标记，
  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• position_ids (np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• inputs_embeds (np.ndarray或tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。此参数仅在急切模式下使用，在图模式中将使用配置中的值。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。此参数仅在急切模式下使用，在图模式中将使用配置中的值。
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。此参数可在急切模式下使用，在图模式中该值将始终设置为 True。
• training (bool, optional, defaults to False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。
• labels (tf.Tensor，形状为(batch_size, sequence_length)，optional) — 用于计算标记分类损失的标签。索引应在[0, ..., config.num_labels - 1]中。

返回

transformers.models.longformer.modeling_tf_longformer.TFLongformerTokenClassifierOutput 或 tuple(tf.Tensor)

一个 transformers.models.longformer.modeling_tf_longformer.TFLongformerTokenClassifierOutput 或一个tf.Tensor元组（如果传递return_dict=False或当config.return_dict=False时）包括根据配置（LongformerConfig）和输入的不同元素。

• loss (tf.Tensor，形状为(1,), 可选的, 当提供labels时返回) — 分类损失。
• logits (tf.Tensor，形状为(batch_size, sequence_length, config.num_labels)) — SoftMax 之前的分类分数。
• hidden_states (tuple(tf.Tensor), 可选的, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每一层的输出）。 模型在每一层输出的隐藏状态加上初始嵌入输出。
• attentions (tuple(tf.Tensor), 可选的, 当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)的tf.Tensor元组，其中x是具有全局注意力掩码的令牌数。 局部注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。这些是来自序列中每个令牌到具有全局注意力的每个令牌（前x个值）和到注意力窗口中的每个令牌的注意力权重（剩余的attention_window个值）。
  • 注意：第一个x个值指的是文本中具有固定位置的令牌，但剩余的attention_window + 1个值指的是具有相对位置的令牌：令牌对自身的注意力权重位于索引x + attention_window / 2，前（后）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 之后，用于计算自注意力头中的加权平均值。这些是来自每个令牌的全局注意力到序列中每个令牌的注意力权重。

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

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

示例：

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

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = TFLongformerForTokenClassification.from_pretrained("allenai/longformer-base-4096")

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

>>> logits = model(**inputs).logits
>>> predicted_token_class_ids = tf.math.argmax(logits, axis=-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t] for t in predicted_token_class_ids[0].numpy().tolist()]

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

TFLongformerForMultipleChoice

class transformers.TFLongformerForMultipleChoice

<来源>

( config *inputs **kwargs )

参数

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

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

此模型继承自 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: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None global_attention_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.models.longformer.modeling_tf_longformer.TFLongformerMultipleChoiceModelOutput or tuple(tf.Tensor)

参数

• input_ids (np.ndarray 或 tf.Tensor，形状为 (batch_size, num_choices, sequence_length)) — 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。 什么是输入 ID？
• attention_mask (np.ndarray 或 tf.Tensor，形状为 (batch_size, num_choices, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1] 之间：
  • 对于not masked的标记，值为 1，
  • 对于masked的标记，值为 0。

  什么是注意力掩码？

• head_mask (np.ndarray 或 tf.Tensor，形状为 (encoder_layers, encoder_attention_heads)，可选) — 用于使注意力模块的选定头部失效的掩码。掩码值选在 [0, 1] 之间：
  • 1 表示头部未被masked，
  • 0 表示头部被“掩盖”。
• global_attention_mask（形状为 (batch_size, num_choices, sequence_length) 的 np.ndarray 或 tf.Tensor，可选）— 用于决定每个标记的注意力分配，局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于任务特定的微调很重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予全局注意力。对于问答，所有问题标记也应该有全局注意力。更多细节请参考Longformer 论文。在 [0, 1] 中选择的掩码值：
  • 0 用于局部注意力（滑动窗口注意力），
  • 1 用于全局注意力（关注所有其他标记，所有其他标记也关注它们）。
• token_type_ids（形状为 (batch_size, num_choices, sequence_length) 的 np.ndarray 或 tf.Tensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在 [0, 1] 中选择。
  • 0 对应于 句子 A 标记，
  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• position_ids（形状为 (batch_size, num_choices, sequence_length) 的 np.ndarray 或 tf.Tensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。 什么是位置 ID？
• inputs_embeds（形状为 (batch_size, num_choices, sequence_length, hidden_size) 的 np.ndarray 或 tf.Tensor，可选）— 可选地，可以直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回张量下的 attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的 hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。此参数可以在急切模式下使用，在图模式下该值将始终设置为 True。
• training（bool，可选，默认为 False）— 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间有不同的行为）。
• labels（形状为 (batch_size,) 的 tf.Tensor，可选）— 用于计算多项选择分类损失的标签。索引应在 [0, ..., num_choices] 范围内，其中 num_choices 是输入张量第二维的大小。（参见上面的 input_ids）

返回

transformers.models.longformer.modeling_tf_longformer.TFLongformerMultipleChoiceModelOutput 或 tuple(tf.Tensor)

transformers.models.longformer.modeling_tf_longformer.TFLongformerMultipleChoiceModelOutput 或者一个 tf.Tensor 元组（如果传递了 return_dict=False 或者 config.return_dict=False）包含不同的元素，取决于配置（LongformerConfig）和输入。

• loss（形状为*(1,)*的tf.Tensor，可选，当提供labels时返回） — 分类损失。
• logits（形状为(batch_size, num_choices)的tf.Tensor） — num_choices是输入张量的第二维度。（参见上面的input_ids）。 分类得分（SoftMax 之前）。
• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。 模型在每个层的输出以及初始嵌入输出的隐藏状态。
• attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, 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 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个令牌对序列中每个令牌的全局注意力的注意力权重。

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

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

示例：

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

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = TFLongformerForMultipleChoice.from_pretrained("allenai/longformer-base-4096")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."

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

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

ay或tf.Tensor，*可选*）— 用于决定每个标记的注意力分配，局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于任务特定的微调很重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予全局注意力。对于问答，所有问题标记也应该有全局注意力。更多细节请参考[Longformer 论文](https://arxiv.org/abs/2004.05150)。在 [0, 1]` 中选择的掩码值：

+   0 用于局部注意力（滑动窗口注意力），

+   1 用于全局注意力（关注所有其他标记，所有其他标记也关注它们）。

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

  什么是标记类型 ID？

• position_ids（形状为 (batch_size, num_choices, sequence_length) 的 np.ndarray 或 tf.Tensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。 什么是位置 ID？
• inputs_embeds（形状为 (batch_size, num_choices, sequence_length, hidden_size) 的 np.ndarray 或 tf.Tensor，可选）— 可选地，可以直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回张量下的 attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的 hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。此参数可以在急切模式下使用，在图模式下该值将始终设置为 True。
• training（bool，可选，默认为 False）— 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间有不同的行为）。
• labels（形状为 (batch_size,) 的 tf.Tensor，可选）— 用于计算多项选择分类损失的标签。索引应在 [0, ..., num_choices] 范围内，其中 num_choices 是输入张量第二维的大小。（参见上面的 input_ids）

返回

transformers.models.longformer.modeling_tf_longformer.TFLongformerMultipleChoiceModelOutput 或 tuple(tf.Tensor)

transformers.models.longformer.modeling_tf_longformer.TFLongformerMultipleChoiceModelOutput 或者一个 tf.Tensor 元组（如果传递了 return_dict=False 或者 config.return_dict=False）包含不同的元素，取决于配置（LongformerConfig）和输入。

• loss（形状为*(1,)*的tf.Tensor，可选，当提供labels时返回） — 分类损失。
• logits（形状为(batch_size, num_choices)的tf.Tensor） — num_choices是输入张量的第二维度。（参见上面的input_ids）。 分类得分（SoftMax 之前）。
• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。 模型在每个层的输出以及初始嵌入输出的隐藏状态。
• attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, 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 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个令牌对序列中每个令牌的全局注意力的注意力权重。

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

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

示例：

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

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = TFLongformerForMultipleChoice.from_pretrained("allenai/longformer-base-4096")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."

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

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