Transformers--4-37-中文文档-二十一-
Transformers 4.37 中文文档(二十一)
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 上取得了最新的成果。
使用提示
-
由于 Longformer 基于 RoBERTa,它没有
token_type_ids
。您不需要指示哪个标记属于哪个段。只需使用分隔标记tokenizer.sep_token
(或</s>
)分隔您的段。 -
将注意力矩阵替换为稀疏矩阵以加快速度的变压器模型。通常,局部上下文(例如,左右两个标记是什么?)足以为给定标记采取行动。仍然会给定一些预选输入标记全局关注,但是注意力矩阵的参数要少得多,从而加快速度。有关更多信息,请参阅局部注意力部分。
Longformer 自注意力
Longformer 自注意力同时在“局部”上下文和“全局”上下文上使用自注意力。大多数标记仅“局部”地相互关注,这意味着每个标记只关注其前21w 个标记和后21w 个标记,其中w 是在config.attention_window
中定义的窗口长度。请注意,config.attention_window
可以是List
类型,以定义每个层的不同w。少数选定的标记对所有其他标记进行“全局”关注,就像在BertSelfAttention
中为所有标记惯例上所做的那样。
请注意,“局部”和“全局”关注的标记由不同的查询、键和值矩阵进行投影。还请注意,每个“局部”关注的标记不仅关注其窗口内的标记w,还关注所有“全局”关注的标记,以使全局关注是对称的。
用户可以通过在运行时适当设置张量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
orList[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
( 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
)的注意力权重。- 1
values)。请注意,前
x个值是指文本中具有固定位置的令牌,但剩余的
attention_window + 1个值是指具有相对位置的令牌:令牌到自身的注意力权重位于索引
x + attention_window / 2,前(后)的
attention_window / 2个值是到前(后)的令牌的注意力权重。如果注意力窗口包含具有全局注意力的令牌,则相应索引处的注意力权重设置为 0;该值应从前
x个注意力权重中访问。如果一个令牌具有全局注意力,则到
attentions中的所有其他令牌的注意力权重设置为 0,该值应从
global_attentions`中访问。
- 1
-
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`中访问这些值。
- 1
-
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`中获取值。
- 1
-
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`中获取值。
- 1
-
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`中访问。
- 1
-
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`中访问这些值。
- 1
-
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`中访问这些值。
- 1
-
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`中访问这些值。
- 1
-
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`中访问。
- 1
-
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`中访问。
- 1
-
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
个值)的注意力权重。- 1
values)。请注意,前
x个值是指文本中固定位置的标记,但剩余的
attention_window + 1个值是指相对位置的标记:标记自身的注意力权重位于索引
x + attention_window / 2,前(后)的
attention_window / 2个值是指前(后)的标记的注意力权重。如果注意力窗口包含具有全局注意力的标记,则相应索引处的注意力权重设置为 0;该值应从前
x个注意力权重中访问。如果一个标记具有全局注意力,则
attentions中对所有其他标记的注意力权重设置为 0,应从
global_attentions`中访问这些值。
- 1
-
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
)的注意力权重。- 1
values)。注意,前
x个值是指文本中具有固定位置的标记,但剩余的
attention_window + 1个值是指具有相对位置的标记:标记到自身的注意力权重位于索引
x + attention_window / 2处,前(后)的
attention_window / 2个值是指到前(后)的
attention_window / 2个标记的注意力权重。如果注意力窗口包含具有全局注意力的标记,则相应索引处的注意力权重设置为 0;该值应从前
x个注意力权重中访问。如果一个标记具有全局注意力,则到
attentions中的所有其他标记的注意力权重设置为 0,应从
global_attentions`中访问这些值。
- 1
-
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
)的注意力权重。- 1
values)。请注意,前
x个值是指文本中具有固定位置的令牌,但剩余的
attention_window + 1个值是指具有相对位置的令牌:令牌到自身的注意力权重位于索引
x + attention_window / 2,前(后)
attention_window / 2个值是到前(后)
attention_window / 2个令牌的注意力权重。如果注意力窗口包含具有全局注意力的令牌,则相应索引处的注意力权重设置为 0;应从前
x个注意力权重中访问该值。如果一个令牌具有全局注意力,则
attentions中对所有其他令牌的注意力权重设置为 0,应从
global_attentions`中访问这些值。
- 1
-
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
( config )
参数
config
(LongformerConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
Longformer 模型在顶部具有多选分类头(池化输出顶部的线性层和 softmax),例如用于 RocStories/SWAG 任务。
此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。
此模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( 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
值)的注意力权重。- 1
values)。请注意,前
x个值是指文本中具有固定位置的令牌,但剩余的
attention_window + 1个值是指具有相对位置的令牌:令牌对自身的注意力权重位于索引
x + attention_window / 2,前
attention_window / 2(后续)值是指到前
attention_window / 2(后续)个令牌的注意力权重。如果注意力窗口包含具有全局注意力的令牌,则相应索引处的注意力权重设置为 0;该值应从前
x个注意力权重中访问。如果一个令牌具有全局注意力,则到
attentions中的所有其他令牌的注意力权重设置为 0,值应从
global_attentions`中访问。
- 1
-
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
( 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
)的注意力权重。- 1
values)。请注意,前
x个值是指文本中具有固定位置的令牌,但剩余的
attention_window + 1个值是指具有相对位置的令牌:令牌对自身的注意力权重位于索引
x + attention_window / 2处,前(后)
attention_window / 2个值是对前(后)
attention_window / 2个令牌的注意力权重。如果注意力窗口包含具有全局注意力的令牌,则相应索引处的注意力权重设置为 0;该值应从前
x个注意力权重中访问。如果一个令牌具有全局注意力,则
attentions中对所有其他令牌的注意力权重设置为 0,应从
global_attentions`中访问这些值。
- 1
-
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
( config )
参数
config
(LongformerConfig)—模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
Longformer 模型在顶部具有一个跨度分类头,用于提取式问答任务,如 SQuAD / TriviaQA(在隐藏状态输出的顶部添加线性层以计算span start logits
和span end logits
)。
此模型继承自 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 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`中访问。
- 1
-
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
)的注意力权重。- 1
values). 注意,前
x个值是指文本中固定位置的标记,但剩余的
attention_window + 1个值是指相对位置的标记:一个标记对自身的注意力权重位于索引
x + attention_window / 2,前(后)
attention_window / 2个值是指对前(后)
attention_window / 2个标记的注意力权重。如果注意力窗口包含具有全局注意力的标记,则相应索引处的注意力权重设置为 0;该值应从前
x个注意力权重中访问。如果一个标记具有全局注意力,则对
attentions中的所有其他标记的注意力权重设置为 0,这些值应从
global_attentions`中访问。
- 1
-
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
( 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
( 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 toFalse
) — 是否在训练模式下使用模型(一些模块如 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
( 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
LongT5
原始文本:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/longt5
概述
LongT5 模型是由 Mandy Guo、Joshua Ainslie、David Uthus、Santiago Ontanon、Jianmo Ni、Yun-Hsuan Sung 和 Yinfei Yang 在LongT5: Efficient Text-To-Text Transformer for Long Sequences中提出的。它是在文本到文本去噪生成设置中预训练的编码器-解码器变压器。LongT5 模型是 T5 模型的扩展,它可以使用两种不同的高效注意力机制之一——(1)局部注意力,或(2)瞬时全局注意力。
论文摘要如下:
最近的工作表明,要么增加输入长度,要么增加模型大小可以提高基于 Transformer 的神经模型的性能。在本文中,我们提出了一个名为 LongT5 的新模型,通过该模型我们同时探索了扩展输入长度和模型大小的效果。具体来说,我们将长输入变压器(ETC)的注意力思想与摘要预训练(PEGASUS)的预训练策略整合到可扩展的 T5 架构中。结果是一个我们称之为“瞬时全局”(TGlobal)的新注意力机制,模仿了 ETC 的局部/全局注意力机制,但不需要额外的辅助输入。我们能够在几个摘要任务上取得最先进的结果,并在问答任务上胜过原始的 T5 模型。
使用提示
-
LongT5ForConditionalGeneration 是 T5ForConditionalGeneration 的扩展,用高效的“局部”注意力或“瞬时全局”(tglobal)注意力交换传统的编码器“自注意力”层。
-
与 T5 模型不同,LongT5 不使用任务前缀。此外,它使用了受 PegasusForConditionalGeneration 预训练启发的不同预训练目标。
-
LongT5 模型旨在在输入序列超过常用的 512 个标记的长距离序列任务上高效地运行并表现良好。它能够处理长度长达 16,384 个标记的输入序列。
-
对于“局部注意力”,稀疏滑动窗口局部注意力操作允许给定标记仅关注其左右
r
个标记(默认为r=127
)。“局部注意力”不向模型引入任何新参数。该机制的复杂度与输入序列长度l
呈线性关系:O(l*r)
。 -
“瞬时全局注意力”是“局部注意力”的扩展。此外,它允许每个输入标记与该层中的所有其他标记进行交互。这是通过将输入序列分割为固定长度
k
的块(默认为k=16
)来实现的。然后,通过对该块中每个标记的嵌入进行求和和归一化,获得该块的全局标记。由于这一点,注意力机制允许每个标记既关注像局部注意力中的附近标记,也关注像标准全局注意力中的每个全局标记(“瞬时”表示全局标记在每个注意力操作中动态构建)。因此,“TGlobal”注意力引入了一些新参数——全局相对位置偏差和全局标记嵌入的层归一化。该机制的复杂度为O(l(r + l/k))
。 -
下面是一个示例,展示了如何在pubmed 数据集上评估一个经过精调的 LongT5 模型。
>>> import evaluate
>>> from datasets import load_dataset
>>> from transformers import AutoTokenizer, LongT5ForConditionalGeneration
>>> dataset = load_dataset("scientific_papers", "pubmed", split="validation")
>>> model = (
... LongT5ForConditionalGeneration.from_pretrained("Stancld/longt5-tglobal-large-16384-pubmed-3k_steps")
... .to("cuda")
... .half()
... )
>>> tokenizer = AutoTokenizer.from_pretrained("Stancld/longt5-tglobal-large-16384-pubmed-3k_steps")
>>> def generate_answers(batch):
... inputs_dict = tokenizer(
... batch["article"], max_length=16384, padding="max_length", truncation=True, return_tensors="pt"
... )
... input_ids = inputs_dict.input_ids.to("cuda")
... attention_mask = inputs_dict.attention_mask.to("cuda")
... output_ids = model.generate(input_ids, attention_mask=attention_mask, max_length=512, num_beams=2)
... batch["predicted_abstract"] = tokenizer.batch_decode(output_ids, skip_special_tokens=True)
... return batch
>>> result = dataset.map(generate_answer, batched=True, batch_size=2)
>>> rouge = evaluate.load("rouge")
>>> rouge.compute(predictions=result["predicted_abstract"], references=result["abstract"])
资源
-
翻译任务指南
-
摘要任务指南
LongT5Config
class transformers.LongT5Config
( vocab_size = 32128 d_model = 512 d_kv = 64 d_ff = 2048 num_layers = 6 num_decoder_layers = None num_heads = 8 local_radius = 127 global_block_size = 16 relative_attention_num_buckets = 32 relative_attention_max_distance = 128 dropout_rate = 0.1 layer_norm_epsilon = 1e-06 initializer_factor = 1.0 feed_forward_proj = 'relu' is_encoder_decoder = True encoder_attention_type = 'local' use_cache = True pad_token_id = 0 eos_token_id = 1 **kwargs )
参数
-
vocab_size
(int
, optional, defaults to 32128) — LongT5 模型的词汇量。定义了在调用 LongT5Model 时可以表示的不同标记数量。 -
d_model
(int
, optional, defaults to 512) — 编码器层和池化层的大小。 -
d_kv
(int
, optional, defaults to 64) — 每个注意力头的键、查询、值投影的大小。d_kv
必须等于d_model // num_heads
。 -
d_ff
(int
, optional, defaults to 2048) — 每个LongT5Block
中间级前向层的大小。 -
num_layers
(int
, optional, defaults to 6) — Transformer 编码器中的隐藏层数量。 -
num_decoder_layers
(int
, optional) — Transformer 解码器中的隐藏层数量。如果未设置,将使用与num_layers
相同的值。 -
num_heads
(int
, optional, defaults to 8) — Transformer 编码器中每个注意力层的注意力头数。 -
local_radius
(int
, optional, defaults to 127) — 每个标记左/右的标记数,用于在本地注意机制中进行本地自我关注。 -
global_block_size
(int
, optional, defaults to 16) — 输入序列分成用于全局标记表示的块的长度。仅用于encoder_attention_type = "transient-global"
。 -
relative_attention_num_buckets
(int
, optional, defaults to 32) — 每个注意力层使用的桶数量。 -
relative_attention_max_distance
(int
, optional, defaults to 128) — 用于桶分离的更长序列的最大距离。 -
dropout_rate
(float
, optional, defaults to 0.1) — 所有 dropout 层的比率。 -
layer_norm_eps
(float
, optional, defaults to 1e-6) — 层归一化层使用的 epsilon。 -
initializer_factor
(float
, optional, defaults to 1) — 用于初始化所有权重矩阵的因子(应保持为 1,用于内部初始化测试)。 -
feed_forward_proj
(string
, optional, defaults to"relu"
) — 要使用的前向层类型。应该是"relu"
或"gated-gelu"
之一。LongT5v1.1 使用"gated-gelu"
前向投影。原始 LongT5 实现使用"gated-gelu"
。 -
encoder_attention_type
(string
, optional, defaults to"local"
) — 要使用的编码器注意类型。应该是 LongT5 实现支持的"local"
或"transient-global"
之一。 -
use_cache
(bool
, optional, defaults toTrue
) — 模型是否应返回最后的键/值注意力(并非所有模型都使用)。
这是配置类,用于存储 LongT5Model 或 FlaxLongT5Model 的配置。根据指定的参数实例化一个 LongT5 模型,定义模型架构。使用默认值实例化配置将产生类似于 LongT5 google/long-t5-local-base架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
PytorchHide Pytorch 内容
LongT5Model
class transformers.LongT5Model
( config: LongT5Config )
参数
config
(LongT5Config)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
LONGT5 模型是一个裸的 transformer 模型,输出原始的隐藏状态,没有特定的头部。
LongT5 模型是由 Mandy Guo、Joshua Ainslie、David Uthus、Santiago Ontanon、Jianmo Ni、Yun-Hsuan Sung 和 Yinfei Yang 在LongT5: Efficient Text-To-Text Transformer for Long Sequences中提出的。它是一个在文本到文本去噪生成设置中预训练的编码器-解码器 transformer。LongT5 模型是 T5 模型的扩展,它可以使用两种不同的高效注意力机制之一 - (1) 本地注意力,或者(2) 瞬时-全局注意力。
这个模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
这个模型也是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
forward
( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqModelOutput or tuple(torch.FloatTensor)
参数
-
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)— 输入序列标记在词汇表中的索引。LongT5 是一个带有相对位置嵌入的模型,因此您应该能够在右侧和左侧都填充输入。可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()获取详细信息。什么是输入 ID?
要了解有关如何为预训练准备
input_ids
的更多信息,请查看长 T5 训练。 -
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)— 避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]
之间:-
对于
未屏蔽
的标记, -
对于
屏蔽
的标记为 0。
什么是注意力掩码?
-
-
decoder_input_ids
(形状为(batch_size, target_sequence_length)
的torch.LongTensor
,可选)— 解码器输入序列标记在词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.
call
()。什么是解码器输入 ID?
LONGT5 使用
pad_token_id
作为decoder_input_ids
生成的起始标记。如果使用past_key_values
,则可以选择仅输入最后的decoder_input_ids
(参见past_key_values
)。要了解有关如何为预训练准备
decoder_input_ids
的更多信息,请查看 LONGT5 Training。 -
decoder_attention_mask
(形状为(batch_size, target_sequence_length)
的torch.BoolTensor
,可选)- 默认行为:生成一个忽略decoder_input_ids
中填充标记的张量。因果掩码也将默认使用。 -
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)- 用于在编码器中使自注意力模块中选择的头部失效的掩码。掩码值在[0, 1]
中选择:-
1 表示头部未被
masked
, -
0 表示头部被
masked
。
-
-
decoder_head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)- 用于在解码器中使自注意力模块中选择的头部失效的掩码。掩码值在[0, 1]
中选择:-
1 表示头部未被
masked
, -
0 表示头部被
masked
。
-
-
cross_attn_head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.Tensor
,可选)- 用于在解码器中使交叉注意力模块中选择的头部失效的掩码。掩码值在[0, 1]
中选择:-
1 表示头部未被
masked
, -
0 表示头部被
masked
。
-
-
encoder_outputs
(tuple(tuple(torch.FloatTensor)
,可选)- 元组包含 (last_hidden_state
,可选:hidden_states,可选:attentions)last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 -
past_key_values
(长度为config.n_layers
的tuple(tuple(torch.FloatTensor))
,每个元组有 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)
的张量)- 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用
past_key_values
,用户可以选择仅输入最后的decoder_input_ids
(这些没有将它们的过去键值状态提供给此模型)的形状为(batch_size, 1)
的张量,而不是所有形状为(batch_size, sequence_length)
的decoder_input_ids
。 -
inputs_embeds
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)- 可选地,您可以选择直接传递嵌入表示而不是传递input_ids
。如果您想要更多控制如何将input_ids
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。 -
decoder_inputs_embeds
(形状为(batch_size, target_sequence_length, hidden_size)
的torch.FloatTensor
,可选)- 可选地,您可以选择直接传递嵌入表示而不是传递decoder_input_ids
。如果使用past_key_values
,则可以选择仅输入最后的decoder_inputs_embeds
(参见past_key_values
)。如果您想要更多控制如何将decoder_input_ids
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。如果未设置
decoder_input_ids
和decoder_inputs_embeds
,则decoder_inputs_embeds
将取inputs_embeds
的值。 -
use_cache
(bool
,可选)- 如果设置为True
,将返回past_key_values
键值状态,可用于加速解码(参见past_key_values
)。 -
output_attentions
(bool
,可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
。 -
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 -
return_dict
(bool
,可选)— 是否返回一个 ModelOutput 而不是一个普通元组。
返回
transformers.modeling_outputs.Seq2SeqModelOutput 或tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqModelOutput 或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
时)包含根据配置(LongT5Config)和输入的不同元素。
-
last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
)— 模型解码器最后一层的隐藏状态序列输出。如果仅使用
past_key_values
,则输出形状为(batch_size, 1, hidden_size)
的序列的最后隐藏状态。 -
past_key_values
(tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或config.use_cache=True
时返回)— 长度为config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(参见
past_key_values
输入)。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则包括嵌入层输出和每层输出)。解码器在每一层的隐藏状态以及可选的初始嵌入输出。
-
decoder_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)— 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则包括嵌入层输出和每层输出)。每层编码器的隐藏状态以及可选的初始嵌入输出。
-
encoder_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
LongT5Model 的前向方法覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在这个函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoTokenizer, LongT5Model
>>> tokenizer = AutoTokenizer.from_pretrained("google/long-t5-local-base")
>>> model = LongT5Model.from_pretrained("google/long-t5-local-base")
>>> # Let's try a very long encoder input.
>>> input_ids = tokenizer(
... 100 * "Studies have been shown that owning a dog is good for you", return_tensors="pt"
... ).input_ids # Batch size 1
>>> decoder_input_ids = tokenizer("Studies show that", return_tensors="pt").input_ids # Batch size 1
>>> # forward pass
>>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids)
>>> last_hidden_states = outputs.last_hidden_state
LongT5ForConditionalGeneration
class transformers.LongT5ForConditionalGeneration
( config: LongT5Config )
参数
config
(LongT5Config)- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
在顶部带有语言建模
头的 LONGT5 模型。
LongT5 模型是由 Mandy Guo、Joshua Ainslie、David Uthus、Santiago Ontanon、Jianmo Ni、Yun-Hsuan Sung 和 Yinfei Yang 在LongT5: Efficient Text-To-Text Transformer for Long Sequences中提出的。它是一个在文本到文本去噪生成设置中预训练的编码器-解码器 transformer。LongT5 模型是 T5 模型的扩展,它可以使用两种不同的高效注意力机制之一 - (1) 本地注意力,或者(2) 瞬时全局注意力。
这个模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
这个模型也是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)
参数
-
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)- 词汇表中输入序列标记的索引。LongT5 是一个具有相对位置嵌入的模型,因此您应该能够在右侧和左侧都填充输入。可以使用 AutoTokenizer 获取索引。详细信息请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()。什么是输入 ID?
要了解有关如何为预训练准备
input_ids
的更多信息,请查看长 T5 训练。 -
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)- 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]
之间:-
对于未被
masked
的标记为 1, -
对于被
masked
的标记为 0。
什么是注意力掩码?
-
-
decoder_input_ids
(形状为(batch_size, target_sequence_length)
的torch.LongTensor
,可选)— 解码器输入序列标记在词汇表中的索引。索引可以使用 AutoTokenizer 获得。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()。解码器输入 ID 是什么?
LONGT5 使用
pad_token_id
作为decoder_input_ids
生成的起始标记。如果使用了past_key_values
,可以选择只输入最后一个decoder_input_ids
(参见past_key_values
)。要了解有关如何为预训练准备
decoder_input_ids
的更多信息,请查看 LONGT5 训练。 -
decoder_attention_mask
(形状为(batch_size, target_sequence_length)
的torch.BoolTensor
,可选)— 默认行为:生成一个忽略decoder_input_ids
中填充标记的张量。因果掩码也将默认使用。 -
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)— 用于使编码器中自注意力模块中的选定头部失效的掩码。掩码值选定在[0, 1]
中:-
1 表示头部未被遮蔽,
-
0 表示头部被遮蔽。
-
-
decoder_head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)— 用于使解码器中自注意力模块中的选定头部失效的掩码。掩码值选定在[0, 1]
中:-
1 表示头部未被遮蔽,
-
0 表示头部被遮蔽。
-
-
cross_attn_head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.Tensor
,可选)— 用于使解码器中交叉注意力模块中的选定头部失效的掩码。掩码值选定在[0, 1]
中:-
1 表示头部未被遮蔽,
-
0 表示头部被遮蔽。
-
-
encoder_outputs
(tuple(tuple(torch.FloatTensor)
,可选)— 元组包括(last_hidden_state
,可选:hidden_states,可选:attentions)last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 -
past_key_values
(长度为config.n_layers
的tuple(tuple(torch.FloatTensor))
,每个元组包含形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)
的 4 个张量)— 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用了
past_key_values
,用户可以选择只输入最后一个形状为(batch_size, 1)
的decoder_input_ids
(那些没有将它们的过去键值状态提供给该模型的)而不是形状为(batch_size, sequence_length)
的所有decoder_input_ids
。 -
inputs_embeds
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)— 可选地,可以直接传递嵌入表示而不是传递input_ids
。如果您想要更多控制如何将input_ids
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。 -
decoder_inputs_embeds
(形状为(batch_size, target_sequence_length, hidden_size)
的torch.FloatTensor
,可选)— 可选地,可以直接传递嵌入表示而不是传递decoder_input_ids
。如果使用了past_key_values
,可以选择只输入最后一个decoder_inputs_embeds
(参见past_key_values
)。如果您想要更多控制如何将decoder_input_ids
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。如果
decoder_input_ids
和decoder_inputs_embeds
都未设置,decoder_inputs_embeds
将取inputs_embeds
的值。 -
use_cache
(bool
,可选)— 如果设置为True
,将返回past_key_values
键值状态,并可用于加速解码(请参见past_key_values
)。 -
output_attentions
(bool
,可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
。 -
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 -
return_dict
(bool
,可选)— 是否返回 ModelOutput 而不是普通元组。 -
labels
(形状为(batch_size,)
的torch.LongTensor
,可选)— 用于计算序列分类/回归损失的标签。索引应在[-100, 0, ..., config.vocab_size - 1]
中。所有标签设置为-100
都将被忽略(掩码),损失仅计算在[0, ..., config.vocab_size]
中的标签。
返回
transformers.modeling_outputs.Seq2SeqLMOutput 或torch.FloatTensor
的元组
一个 transformers.modeling_outputs.Seq2SeqLMOutput 或一个torch.FloatTensor
的元组(如果传递return_dict=False
或config.return_dict=False
)包含根据配置(LongT5Config)和输入的不同元素。
-
loss
(形状为(1,)
的torch.FloatTensor
,可选,当提供labels
时返回)— 语言建模损失。 -
logits
(形状为(batch_size, sequence_length, config.vocab_size)
的torch.FloatTensor
)— 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
past_key_values
(tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或config.use_cache=True
时返回)— 长度为config.n_layers
的tuple(torch.FloatTensor)
的元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(请参见
past_key_values
输入)。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
的元组(如果模型有嵌入层,则为嵌入的输出的一个+每层输出的一个)。解码器在每一层输出的隐藏状态加上初始嵌入输出。
-
decoder_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
的元组(每层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
的元组(每层一个)。解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,可选) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入的输出+每层的输出)。编码器在每一层的隐藏状态以及初始嵌入输出。
-
encoder_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
LongT5ForConditionalGeneration 的前向方法重写了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoTokenizer, LongT5ForConditionalGeneration
>>> tokenizer = AutoTokenizer.from_pretrained("Stancld/longt5-tglobal-large-16384-pubmed-3k_steps")
>>> model = LongT5ForConditionalGeneration.from_pretrained(
... "Stancld/longt5-tglobal-large-16384-pubmed-3k_steps"
... )
>>> # Let's try a very long input.
>>> inputs = tokenizer(100 * "studies have shown that owning a dog is good for you ", return_tensors="pt")
>>> input_ids = inputs.input_ids
>>> outputs = model.generate(input_ids)
>>> print(tokenizer.decode(outputs[0], skip_special_tokens=True))
abstractthe aim of this article is to provide an overview of the literature on the role of dog
LongT5EncoderModel
class transformers.LongT5EncoderModel
( config: LongT5Config )
参数
config
(LongT5Config) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
裸 LONGT5 模型 transformer 输出编码器的原始隐藏状态,没有特定的头部。
LongT5 模型是由 Mandy Guo、Joshua Ainslie、David Uthus、Santiago Ontanon、Jianmo Ni、Yun-Hsuan Sung 和 Yinfei Yang 在LongT5: Efficient Text-To-Text Transformer for Long Sequences中提出的。它是一个在文本到文本去噪生成设置中预训练的编码器-解码器 transformer。LongT5 模型是 T5 模型的扩展,它可以使用两种不同的高效注意机制之一 - (1) 本地注意力,或者(2) 瞬时-全局注意力。
此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
这个模型也是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( input_ids: Optional = None attention_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutput or tuple(torch.FloatTensor)
参数
-
input_ids
(torch.LongTensor
,形状为(batch_size, sequence_length)
) — 输入序列标记在词汇表中的索引。LongT5 是一个带有相对位置嵌入的模型,因此您应该能够在右侧和左侧都填充输入。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.
call
()。要了解有关如何为预训练准备
input_ids
的更多信息,请查看 LONGT5 Training。 -
attention_mask
(torch.FloatTensor
of shape(batch_size, sequence_length)
, optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选定在[0, 1]
:-
1 表示未被掩码的标记,
-
0 表示被掩码的标记。
什么是注意力掩码?
-
-
head_mask
(torch.FloatTensor
of shape(num_heads,)
or(num_layers, num_heads)
, optional) — 用于使自注意力模块中的选定头部失效的掩码。掩码值选定在[0, 1]
:-
1 表示头部未被掩码,
-
0 表示头部被掩码。
-
-
inputs_embeds
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 可选地,可以直接传递嵌入表示而不是传递input_ids
。如果您想要更多控制如何将input_ids
索引转换为相关向量,则这很有用,而不是使用模型的内部嵌入查找矩阵。 -
output_attentions
(bool
, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 -
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 -
return_dict
(bool
, optional) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutput 或一个 torch.FloatTensor
元组(如果传递 return_dict=False
或 config.return_dict=False
)包含各种元素,具体取决于配置(LongT5Config)和输入。
-
last_hidden_state
(torch.FloatTensor
of shape(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
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。在自注意力头中用于计算加权平均值的注意力 softmax 后的注意力权重。
LongT5EncoderModel 的前向方法,覆盖了 __call__
特殊方法。
虽然前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoTokenizer, LongT5ForConditionalGeneration
>>> tokenizer = AutoTokenizer.from_pretrained("google/long-t5-local-base")
>>> model = LongT5EncoderModel.from_pretrained("google/long-t5-local-base")
>>> input_ids = tokenizer(
... 100 * "Studies have been shown that owning a dog is good for you ", return_tensors="pt"
... ).input_ids # Batch size 1
>>> outputs = model(input_ids=input_ids)
>>> last_hidden_states = outputs.last_hidden_state
JAXHide JAX content
FlaxLongT5Model
class transformers.FlaxLongT5Model
( config: LongT5Config input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
__call__
( input_ids: Array attention_mask: Optional = None decoder_input_ids: Array = None decoder_attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput or tuple(torch.FloatTensor)
参数
-
input_ids
(形状为(batch_size, sequence_length)
的jnp.ndarray
)- 词汇表中输入序列令牌的索引。LongT5 是一个具有相对位置嵌入的模型,因此您应该能够在右侧和左侧填充输入。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()。什么是输入 ID?
要了解有关如何为预训练准备
input_ids
的更多信息,请查看长 T5 训练。 -
attention_mask
(形状为(batch_size, sequence_length)
的jnp.ndarray
,可选)- 用于避免在填充令牌索引上执行注意力的掩码。掩码值选在[0, 1]
之间:-
对于未被
masked
的令牌为 1。 -
对于被
masked
的令牌为 0。
什么是注意力掩码?
-
-
decoder_input_ids
(形状为(batch_size, target_sequence_length)
的jnp.ndarray
,可选)- 词汇表中解码器输入序列令牌的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()。什么是解码器输入 ID?
LONGT5 使用
pad_token_id
作为decoder_input_ids
生成的起始令牌。如果使用了past_key_values
,可以选择仅输入最后一个decoder_input_ids
(参见past_key_values
)。要了解有关如何为预训练准备
decoder_input_ids
的更多信息,请查看长 T5 训练。 -
decoder_attention_mask
(形状为(batch_size, target_sequence_length)
的jnp.ndarray
,可选)- 默认行为:生成一个张量,忽略decoder_input_ids
中的填充令牌。因果掩码也将默认使用。 -
encoder_outputs
(tuple(tuple(jnp.ndarray)
,可选)- 元组包含(last_hidden_state
,可选:hidden_states,可选:attentions)last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 -
past_key_values
(长度为config.n_layers
的tuple(tuple(jnp.ndarray))
,每个元组包含 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)
的张量)- 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用了
past_key_values
,用户可以选择仅输入最后一个decoder_input_ids
(那些没有将它们的过去键值状态提供给此模型的)的形状为(batch_size, 1)
,而不是形状为(batch_size, sequence_length)
的所有decoder_input_ids
。
返回
transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或tuple(torch.FloatTensor)
transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含根据配置(LongT5Config)和输入的不同元素。
-
logits
(形状为(batch_size, sequence_length, config.vocab_size)
的jnp.ndarray
) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
past_key_values
(tuple(tuple(jnp.ndarray))
,可选,当传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的tuple(jnp.ndarray)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可以用于加速顺序解码(参见
past_key_values
输入)。 -
decoder_hidden_states
(tuple(jnp.ndarray)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入的输出,一个用于每一层的输出)。解码器在每一层的隐藏状态加上初始嵌入输出。
-
decoder_attentions
(tuple(jnp.ndarray)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(jnp.ndarray)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
,可选) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(jnp.ndarray)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入的输出,一个用于每一层的输出)。编码器在每一层的隐藏状态加上初始嵌入输出。
-
encoder_attentions
(tuple(jnp.ndarray)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
FlaxLongT5PreTrainedModel
的前向方法,覆盖了__call__
特殊方法。
尽管前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoTokenizer, FlaxLongT5Model
>>> tokenizer = AutoTokenizer.from_pretrained("t5-base")
>>> model = FlaxLongT5Model.from_pretrained("google/long-t5-local-base")
>>> input_ids = tokenizer(
... "Studies have been shown that owning a dog is good for you", return_tensors="np"
... ).input_ids
>>> decoder_input_ids = tokenizer("Studies show that", return_tensors="np").input_ids
>>> # forward pass
>>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids)
>>> last_hidden_states = outputs.last_hidden_state
encode
( input_ids: Array attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxBaseModelOutput or tuple(torch.FloatTensor)
参数
-
input_ids
(jnp.ndarray
,形状为(batch_size, sequence_length)
) — 词汇表中输入序列标记的索引。LongT5 是一个具有相对位置嵌入的模型,因此您应该能够在右侧和左侧都填充输入。可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()获取详细信息。要了解如何为预训练准备
input_ids
,请查看长 T5 训练。 -
attention_mask
(jnp.ndarray
,形状为(batch_size, sequence_length)
,可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]
之间:-
对于未被
masked
的标记为 1, -
对于被
masked
的标记为 0。
什么是注意力掩码?
-
-
output_attentions
(bool
,可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请查看返回张量下的attentions
。 -
output_hidden_states
(bool
,可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请查看返回张量下的hidden_states
。 -
return_dict
(bool
, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
返回
transformers.modeling_flax_outputs.FlaxBaseModelOutput 或tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
)包含根据配置(<class 'transformers.models.longt5.configuration_longt5.LongT5Config'>
)和输入而异的各种元素。
-
last_hidden_state
(jnp.ndarray
,形状为(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 后的注意力权重,用于计算自注意力头中的加权平均值。
示例:
>>> from transformers import AutoTokenizer, FlaxLongT5ForConditionalGeneration
>>> tokenizer = AutoTokenizer.from_pretrained("t5-base")
>>> model = FlaxLongT5ForConditionalGeneration.from_pretrained("google/long-t5-local-base")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)
decode
( decoder_input_ids encoder_outputs encoder_attention_mask: Optional = None decoder_attention_mask: Optional = None past_key_values: dict = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions or tuple(torch.FloatTensor)
参数
-
decoder_input_ids
(jnp.ndarray
,形状为(batch_size, target_sequence_length)
) — 词汇表中解码器输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()。什么是解码器输入 ID?
在训练中,应提供
decoder_input_ids
。 -
encoder_outputs
(tuple(tuple(jnp.ndarray)
) — 元组包括(last_hidden_state
,optional:hidden_states
,optional:attentions
)last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,optional)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 -
encoder_attention_mask
(jnp.ndarray
,形状为(batch_size, sequence_length)
,optional) — 避免在填充标记索引上执行注意力的掩码。选择的掩码值为[0, 1]
:-
对于未被掩码的标记,为 1,
-
对于被掩码的标记为 0。
什么是注意力掩码?
-
-
decoder_attention_mask
(jnp.ndarray
,形状为(batch_size, target_sequence_length)
,optional) — 默认行为:生成一个忽略decoder_input_ids
中填充标记的张量。默认情况下还将使用因果掩码。如果要更改填充行为,应根据需要进行修改。有关默认策略的更多信息,请参见论文中的图表 1。
-
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.FlaxBaseModelOutputWithPastAndCrossAttentions 或tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含根据配置(<class 'transformers.models.longt5.configuration_longt5.LongT5Config'>
)和输入的不同元素。
-
last_hidden_state
(jnp.ndarray
,形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层的隐藏状态序列。如果仅使用
past_key_values
,则输出形状为(batch_size, 1, hidden_size)
的序列的最后隐藏状态。 -
past_key_values
(tuple(tuple(jnp.ndarray))
, optional, 当传递use_cache=True
或config.use_cache=True
时返回 — 长度为config.n_layers
的元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量,如果config.is_encoder_decoder=True
,还有 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块中的键和值,以及在交叉注意力块中,如果
config.is_encoder_decoder=True
,可以使用(查看past_key_values
输入)来加速顺序解码。 -
hidden_states
(tuple(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 之后的注意力权重,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(jnp.ndarray)
,可选,当传递output_attentions=True
和config.add_cross_attention=True
或传递config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
示例:
>>> from transformers import AutoTokenizer, FlaxLongT5ForConditionalGeneration
>>> import jax.numpy as jnp
>>> tokenizer = AutoTokenizer.from_pretrained("t5-base")
>>> model = FlaxLongT5ForConditionalGeneration.from_pretrained("google/long-t5-local-base")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)
>>> decoder_start_token_id = model.config.decoder_start_token_id
>>> decoder_input_ids = jnp.ones((inputs.input_ids.shape[0], 1), dtype="i4") * decoder_start_token_id
>>> outputs = model.decode(decoder_input_ids, encoder_outputs)
>>> logits = outputs.logits
FlaxLongT5ForConditionalGeneration
class transformers.FlaxLongT5ForConditionalGeneration
( config: LongT5Config input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
__call__
( input_ids: Array attention_mask: Optional = None decoder_input_ids: Array = None decoder_attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput or tuple(torch.FloatTensor)
参数
-
input_ids
(形状为(batch_size, sequence_length)
的jnp.ndarray
)- 词汇表中输入序列标记的索引。LongT5 是一个具有相对位置嵌入的模型,因此您应该能够在右侧和左侧都填充输入。可以使用 AutoTokenizer 获取索引。详细信息请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()。什么是输入 ID?
了解如何为预训练准备
input_ids
,请查看 LONGT5 Training。 -
attention_mask
(形状为(batch_size, sequence_length)
的jnp.ndarray
,可选)- 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]
之间:-
对于未被
masked
的标记,值为 1。 -
对于被
masked
的标记,值为 0。
什么是注意力掩码?
-
-
decoder_input_ids
(形状为(batch_size, target_sequence_length)
的jnp.ndarray
,可选)- 词汇表中解码器输入序列标记的索引。可以使用 AutoTokenizer 获取索引。详细信息请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()。什么是解码器输入 ID?
LONGT5 使用
pad_token_id
作为decoder_input_ids
生成的起始标记。如果使用了past_key_values
,可选择只需输入最后的decoder_input_ids
(查看past_key_values
)。了解如何为预训练准备
decoder_input_ids
,请查看 LONGT5 Training。 -
decoder_attention_mask
(形状为(batch_size, target_sequence_length)
的jnp.ndarray
,可选)- 默认行为:生成一个忽略decoder_input_ids
中填充标记的张量。因果膜也将默认使用。 -
encoder_outputs
(tuple(tuple(jnp.ndarray)
,可选)- 元组包括(last_hidden_state
,可选:hidden_states,可选:attentions)last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 -
past_key_values
(长度为config.n_layers
的tuple(tuple(jnp.ndarray))
,每个元组有 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)
的张量)- 包含注意力块的预先计算的键和值隐藏状态。可用于加速解码。如果使用了
past_key_values
,用户可以选择性地只输入最后一个形状为(batch_size, 1)
的decoder_input_ids
(那些没有将它们的过去键值状态提供给该模型的输入),而不是形状为(batch_size, sequence_length)
的所有decoder_input_ids
。
返回
transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或tuple(torch.FloatTensor)
transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
时)包括根据配置(LongT5Config)和输入的不同元素。
-
logits
(形状为(batch_size, sequence_length, config.vocab_size)
的jnp.ndarray
)- 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
past_key_values
(tuple(tuple(jnp.ndarray))
,可选,当传递use_cache=True
或config.use_cache=True
时返回)- 长度为config.n_layers
的元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值)可以用(参见
past_key_values
输入)加速顺序解码。 -
decoder_hidden_states
(tuple(jnp.ndarray)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 元组包括(嵌入输出的输出+每层输出的输出)的jnp.ndarray
(每层一个)的形状为(batch_size, sequence_length, hidden_size)
。解码器在每一层输出的隐藏状态以及初始嵌入输出。
-
decoder_attentions
(tuple(jnp.ndarray)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(jnp.ndarray)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
,可选)- 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(jnp.ndarray)
,可选,当传递output_hidden_states=True
或者当config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入输出,一个用于每一层的输出)。编码器在每一层输出的隐藏状态加上初始嵌入输出。
-
encoder_attentions
(tuple(jnp.ndarray)
,可选,当传递output_attentions=True
或者当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
FlaxLongT5PreTrainedModel
的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoTokenizer, FlaxLongT5ForConditionalGeneration
>>> tokenizer = AutoTokenizer.from_pretrained("t5-base")
>>> model = FlaxLongT5ForConditionalGeneration.from_pretrained("google/long-t5-local-base")
>>> ARTICLE_TO_SUMMARIZE = "summarize: My friends are cool but they eat too many carbs."
>>> inputs = tokenizer([ARTICLE_TO_SUMMARIZE], return_tensors="np")
>>> # Generate Summary
>>> summary_ids = model.generate(inputs["input_ids"]).sequences
>>> print(tokenizer.decode(summary_ids[0], skip_special_tokens=True, clean_up_tokenization_spaces=False))
encode
( input_ids: Array attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxBaseModelOutput or tuple(torch.FloatTensor)
参数
-
input_ids
(形状为(batch_size, sequence_length)
的jnp.ndarray
) — 词汇表中输入序列标记的索引。LongT5 是一个带有相对位置嵌入的模型,因此您应该能够在右侧和左侧都填充输入。可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()获取详细信息。要了解有关如何为预训练准备
input_ids
的更多信息,请查看长 T5 训练。 -
attention_mask
(形状为(batch_size, sequence_length)
的jnp.ndarray
,可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]
范围内:-
对于
未被掩码
的标记为 1, -
对于
被掩码
的标记为 0。
什么是注意力掩码?
-
-
output_attentions
(bool
,可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请查看返回张量下的attentions
。 -
output_hidden_states
(bool
,可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请查看返回张量下的hidden_states
。 -
return_dict
(bool
,可选) — 是否返回一个 ModelOutput 而不是一个普通元组。
返回
transformers.modeling_flax_outputs.FlaxBaseModelOutput 或者tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或者一个torch.FloatTensor
元组(如果传递了return_dict=False
或者当config.return_dict=False
时)包括各种元素,取决于配置(<class 'transformers.models.longt5.configuration_longt5.LongT5Config'>
)和输入。
-
last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
) — 模型最后一层的隐藏状态序列。 -
hidden_states
(tuple(jnp.ndarray)
,可选,当传递output_hidden_states=True
或者当config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入输出,一个用于每一层的输出)。模型每一层的隐藏状态加上初始嵌入输出。
-
attentions
(tuple(jnp.ndarray)
, optional, 当传递output_attentions=True
或者config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
示例:
>>> from transformers import AutoTokenizer, FlaxLongT5ForConditionalGeneration
>>> tokenizer = AutoTokenizer.from_pretrained("t5-base")
>>> model = FlaxLongT5ForConditionalGeneration.from_pretrained("google/long-t5-local-base")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)
decode
( decoder_input_ids encoder_outputs encoder_attention_mask: Optional = None decoder_attention_mask: Optional = None past_key_values: dict = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)
参数
-
decoder_input_ids
(jnp.ndarray
形状为(batch_size, target_sequence_length)
) — 词汇表中解码器输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.
call
()。什么是解码器输入 ID?
对于训练,应提供
decoder_input_ids
。 -
encoder_outputs
(tuple(tuple(jnp.ndarray)
) — 元组包括 (last_hidden_state
, optional:hidden_states
, optional:attentions
)last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,optional) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 -
encoder_attention_mask
(jnp.ndarray
形状为(batch_size, sequence_length)
,optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]
:-
1 代表
未被掩码
的标记, -
0 代表
被掩码
的标记。
什么是注意力掩码?
-
-
decoder_attention_mask
(jnp.ndarray
形状为(batch_size, target_sequence_length)
,optional) — 默认行为:生成一个忽略decoder_input_ids
中填充标记的张量。因果掩码也将默认使用。如果要更改填充行为,应根据需要进行修改。有关默认策略的更多信息,请参见 论文 中的图表 1。
-
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.FlaxCausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或一个 torch.FloatTensor
元组(如果传递 return_dict=False
或者 config.return_dict=False
)包含根据配置 (<class 'transformers.models.longt5.configuration_longt5.LongT5Config'>
) 和输入的各种元素。
-
logits
(形状为(batch_size, sequence_length, config.vocab_size)
的jnp.ndarray
)- 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
hidden_states
(tuple(jnp.ndarray)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入的输出,一个用于每个层的输出)。模型在每一层输出的隐藏状态以及初始嵌入输出。
-
attentions
(tuple(jnp.ndarray)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。在自注意力头中用于计算加权平均的注意力权重 softmax 后的值。
-
cross_attentions
(tuple(jnp.ndarray)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。在交叉注意力头中用于计算加权平均的注意力权重 softmax 后的值。
-
past_key_values
(tuple(tuple(jnp.ndarray))
,可选,当传递use_cache=True
或config.use_cache=True
时返回)- 长度为config.n_layers
的jnp.ndarray
元组的元组,每个元组包含自注意力和交叉注意力层的缓存键、值状态,如果模型在编码器-解码器设置中使用,则相关。仅在config.is_decoder = True
时相关。包含预先计算的隐藏状态(注意力块中的键和值),可用于加速顺序解码。
示例:
>>> from transformers import AutoTokenizer, FlaxLongT5ForConditionalGeneration
>>> import jax.numpy as jnp
>>> tokenizer = AutoTokenizer.from_pretrained("t5-base")
>>> model = FlaxLongT5ForConditionalGeneration.from_pretrained("google/long-t5-local-base")
>>> text = "summarize: My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)
>>> decoder_start_token_id = model.config.decoder_start_token_id
>>> decoder_input_ids = jnp.ones((inputs.input_ids.shape[0], 1), dtype="i4") * decoder_start_token_id
>>> outputs = model.decode(decoder_input_ids, encoder_outputs)
>>> logits = outputs.logits
卢克
原文链接:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/luke
概述
LUKE 模型是由 Ikuya Yamada、Akari Asai、Hiroyuki Shindo、Hideaki Takeda 和 Yuji Matsumoto 在LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention中提出的。它基于 RoBERTa,并添加了实体嵌入以及实体感知自注意机制,有助于提高在涉及推理实体的各种下游任务上的性能,如命名实体识别、提取式和填空式问答、实体类型划分和关系分类。
以下是论文摘要:
*实体表示在涉及实体的自然语言任务中非常有用。在本文中,我们提出了基于双向变换器的新的预训练上下文化单词和实体表示。所提出的模型将给定文本中的单词和实体视为独立标记,并输出它们的上下文化表示。我们的模型使用基于 BERT 的遮蔽语言模型的新预训练任务进行训练。该任务涉及在从维基百科检索的大型实体注释语料库中预测随机屏蔽的单词和实体。我们还提出了一种实体感知自注意机制,它是变换器自注意机制的扩展,并在计算注意力分数时考虑标记类型(单词或实体)。所提出的模型在广泛的与实体相关任务上取得了令人印象深刻的实证性表现。特别是,在五个知名数据集上取得了最新成果:Open Entity(实体类型划分)、TACRED(关系分类)、CoNLL-2003(命名实体识别)、ReCoRD(填空式问答)和 SQuAD 1.1(提取式问答)。
此模型由ikuyamada和nielsr贡献。原始代码可在此处找到。
使用提示
-
此实现与 RobertaModel 相同,只是添加了实体嵌入以及实体感知自注意机制,从而提高了在涉及推理实体的任务中的性能。
-
LUKE 将实体视为输入标记;因此,它接受
entity_ids
、entity_attention_mask
、entity_token_type_ids
和entity_position_ids
作为额外输入。您可以使用 LukeTokenizer 来获取这些信息。 -
LukeTokenizer 接受
entities
和entity_spans
(实体在输入文本中基于字符的起始和结束位置)作为额外输入。entities
通常包括[MASK]实体或维基百科实体。输入这些实体时的简要描述如下:-
输入[MASK]实体以计算实体表示:[MASK]实体用于在预训练期间屏蔽待预测的实体。当 LUKE 接收到[MASK]实体时,它会尝试通过从输入文本中收集有关实体的信息来预测原始实体。因此,[MASK]实体可用于处理需要文本中实体信息的下游任务,如实体类型划分、关系分类和命名实体识别。
-
输入维基百科实体以计算知识增强的令牌表示:LUKE 在预训练期间学习关于维基百科实体的丰富信息(或知识),并将信息存储在其实体嵌入中。通过使用维基百科实体作为输入令牌,LUKE 输出由这些实体嵌入中存储的信息丰富的令牌表示。这对于需要现实世界知识的任务(如问答)特别有效。
-
-
前一用例有三个头模型:
-
用于实体分类的 LukeForEntityClassification,用于对输入文本中的单个实体进行分类,例如实体类型标注,例如Open Entity 数据集。该模型在输出实体表示上放置了一个线性头。
-
用于实体对分类的 LukeForEntityPairClassification,用于对两个实体之间的关系进行分类,例如关系分类,例如TACRED 数据集。该模型在给定实体对的连接输出表示上放置了一个线性头。
-
用于实体跨度分类的 LukeForEntitySpanClassification,用于对实体跨度序列进行分类,例如命名实体识别(NER)。该模型在输出实体表示上放置了一个线性头。您可以通过将文本中的所有可能实体跨度输入到模型中来使用此模型来处理 NER。
LukeTokenizer 有一个
task
参数,通过指定task="entity_classification"
、task="entity_pair_classification"
或task="entity_span_classification"
,可以轻松地创建这些头模型的输入。请参考每个头模型的示例代码。 -
用法示例:
>>> from transformers import LukeTokenizer, LukeModel, LukeForEntityPairClassification
>>> model = LukeModel.from_pretrained("studio-ousia/luke-base")
>>> tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-base")
# Example 1: Computing the contextualized entity representation corresponding to the entity mention "Beyoncé"
>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [(0, 7)] # character-based entity span corresponding to "Beyoncé"
>>> inputs = tokenizer(text, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt")
>>> outputs = model(**inputs)
>>> word_last_hidden_state = outputs.last_hidden_state
>>> entity_last_hidden_state = outputs.entity_last_hidden_state
# Example 2: Inputting Wikipedia entities to obtain enriched contextualized representations
>>> entities = [
... "Beyoncé",
... "Los Angeles",
... ] # Wikipedia entity titles corresponding to the entity mentions "Beyoncé" and "Los Angeles"
>>> entity_spans = [(0, 7), (17, 28)] # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
>>> inputs = tokenizer(text, entities=entities, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt")
>>> outputs = model(**inputs)
>>> word_last_hidden_state = outputs.last_hidden_state
>>> entity_last_hidden_state = outputs.entity_last_hidden_state
# Example 3: Classifying the relationship between two entities using LukeForEntityPairClassification head model
>>> model = LukeForEntityPairClassification.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
>>> tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
>>> entity_spans = [(0, 7), (17, 28)] # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_idx = int(logits[0].argmax())
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
资源
-
文本分类任务指南
-
令牌分类任务指南
-
问答任务指南
-
掩码语言建模任务指南
-
多项选择任务指南
LukeConfig
class transformers.LukeConfig
( vocab_size = 50267 entity_vocab_size = 500000 hidden_size = 768 entity_emb_size = 256 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 use_entity_aware_attention = True classifier_dropout = None pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 **kwargs )
参数
-
vocab_size
(int
, 可选, 默认为 50267) — LUKE 模型的词汇表大小。定义了在调用 LukeModel 时可以表示的不同令牌数量。 -
entity_vocab_size
(int
, 可选, 默认为 500000) — LUKE 模型的实体词汇表大小。定义了在调用 LukeModel 时可以表示的不同实体数量。 -
hidden_size
(int
, 可选, 默认为 768) — 编码器层和池化层的维度。 -
entity_emb_size
(int
, 可选, 默认为 256) — 实体嵌入的维度数。 -
num_hidden_layers
(int
, 可选, 默认为 12) — Transformer 编码器中的隐藏层数量。 -
num_attention_heads
(int
, optional, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。 -
intermediate_size
(int
, optional, 默认为 3072) — Transformer 编码器中“中间”(通常称为前馈)层的维度。 -
hidden_act
(str
或Callable
, optional, 默认为"gelu"
) — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"silu"
和"gelu_new"
。 -
hidden_dropout_prob
(float
, optional, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。 -
attention_probs_dropout_prob
(float
, optional, 默认为 0.1) — 注意力概率的 dropout 比率。 -
max_position_embeddings
(int
, optional, 默认为 512) — 该模型可能使用的最大序列长度。通常将其设置为较大的值以防万一(例如,512、1024 或 2048)。 -
type_vocab_size
(int
, optional, 默认为 2) — 在调用 LukeModel 时传递的token_type_ids
的词汇大小。 -
initializer_range
(float
, optional, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 -
layer_norm_eps
(float
, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。 -
use_entity_aware_attention
(bool
, optional, 默认为True
) — 模型是否应该使用LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention (Yamada et al.)中提出的实体感知自注意机制。 -
classifier_dropout
(float
, optional) — 分类头的 dropout 比率。 -
pad_token_id
(int
, optional, 默认为 1) — 填充标记 id。 -
bos_token_id
(int
, optional, 默认为 0) — 流的起始标记 id。 -
eos_token_id
(int
, optional, 默认为 2) — 流的结束标记 id。
这是用于存储 LukeModel 配置的配置类。根据指定的参数实例化 LUKE 模型,定义模型架构。使用默认值实例化配置将产生类似于 LUKE studio-ousia/luke-base架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import LukeConfig, LukeModel
>>> # Initializing a LUKE configuration
>>> configuration = LukeConfig()
>>> # Initializing a model from the configuration
>>> model = LukeModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
LukeTokenizer
class transformers.LukeTokenizer
( vocab_file merges_file entity_vocab_file task = None max_entity_length = 32 max_mention_length = 30 entity_token_1 = '<ent>' entity_token_2 = '<ent2>' entity_unk_token = '[UNK]' entity_pad_token = '[PAD]' entity_mask_token = '[MASK]' entity_mask2_token = '[MASK2]' 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
) — 合并文件的路径。 -
entity_vocab_file
(str
) — 实体词汇文件的路径。 -
task
(str
, optional) — 您想要准备序列的任务。其中之一是"entity_classification"
、"entity_pair_classification"
或"entity_span_classification"
。如果指定此参数,实体序列将根据给定的实体跨度自动创建。 -
max_entity_length
(int
, optional, 默认为 32) —entity_ids
的最大长度。 -
max_mention_length
(int
, optional, 默认为 30) — 实体跨度内的最大标记数。 -
entity_token_1
(str
, optional, 默认为<ent>
) — 用于表示单词标记序列中实体跨度的特殊标记。仅当task
设置为"entity_classification"
或"entity_pair_classification"
时才使用此标记。 -
entity_token_2
(str
,可选,默认为<ent2>
)— 用于表示单词标记序列中实体跨度的特殊标记。仅当task
设置为"entity_pair_classification"
时才使用此标记。 -
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
)— 是否在输入前添加一个初始空格。这允许将前导单词视为任何其他单词。(LUKE 分词器通过前面的空格检测单词的开头)。
构建一个 LUKE 分词器,从 GPT-2 分词器派生,使用字节级字节对编码。
这个分词器已经训练成将空格视为标记的一部分(有点像 sentencepiece),因此一个单词将
在句子开头(无空格)或不是时,将以不同方式编码:
>>> from transformers import LukeTokenizer
>>> tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-base")
>>> 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,其中包含大多数主要方法。用户应参考这个超类以获取有关这些方法的更多信息。它还创建实体序列,即entity_ids
、entity_attention_mask
、entity_token_type_ids
和entity_position_ids
,供 LUKE 模型使用。
__call__
( text: Union text_pair: Union = None entity_spans: Union = None entity_spans_pair: Union = None entities: Union = None entities_pair: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = None max_length: Optional = None max_entity_length: Optional = None stride: int = 0 is_split_into_words: Optional = False pad_to_multiple_of: Optional = None return_tensors: Union = None return_token_type_ids: Optional = None return_attention_mask: Optional = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True **kwargs ) → export const metadata = 'undefined';BatchEncoding
参数
-
text
(str
,List[str]
,List[List[str]]
)— 要编码的序列或序列批次。每个序列必须是一个字符串。请注意,此分词器不支持基于预分词字符串的分词。 -
text_pair
(str
,List[str]
,List[List[str]]
)— 要编码的序列或批次。每个序列必须是一个字符串。请注意,此分词器不支持基于预分词字符串的分词。 -
entity_spans
(List[Tuple[int, int]]
,List[List[Tuple[int, int]]]
,可选)— 要编码的实体跨度序列或批次。每个序列由元组组成,每个元组包含两个整数,表示实体的基于字符的起始和结束位置。如果在构造函数中将task
参数指定为"entity_classification"
或"entity_pair_classification"
,则每个序列的长度必须分别为 1 或 2。如果指定了entities
,则每个序列的长度必须等于entities
的每个序列的长度。 -
entity_spans_pair
(List[Tuple[int, int]]
,List[List[Tuple[int, int]]]
,可选)— 要编码的实体跨度序列或批次。每个序列由元组组成,每个元组包含两个整数,表示实体的基于字符的起始和结束位置。如果在构造函数中指定了task
参数,则将忽略此参数。如果指定了entities_pair
,则每个序列的长度必须等于entities_pair
的每个序列的长度。 -
entities
(List[str]
,List[List[str]]
,可选)— 要编码的实体序列或批次。每个序列由表示实体的字符串组成,即特殊实体(例如 [MASK])或维基百科的实体标题(例如洛杉矶)。如果在构造函数中指定了task
参数,则将忽略此参数。每个序列的长度必须等于entity_spans
的每个序列的长度。如果指定了entity_spans
而没有指定此参数,则实体序列或实体序列批次将通过填充 [MASK] 实体来自动构建。 -
entities_pair
(List[str]
,List[List[str]]
,可选)— 要编码的实体序列或批次。每个序列由表示实体的字符串组成,即特殊实体(例如 [MASK])或维基百科的实体标题(例如洛杉矶)。如果在构造函数中指定了task
参数,则将忽略此参数。每个序列的长度必须等于entity_spans_pair
的每个序列的长度。如果指定了entity_spans_pair
而没有指定此参数,则实体序列或实体序列批次将通过填充 [MASK] 实体来自动构建。 -
max_entity_length
(int
,可选)—entity_ids
的最大长度。 -
add_special_tokens
(bool
,可选,默认为True
)— 在编码序列时是否添加特殊标记。这将使用底层的PretrainedTokenizerBase.build_inputs_with_special_tokens
函数,该函数定义了自动添加到输入 id 的标记。如果要自动添加bos
或eos
标记,这很有用。 -
padding
(bool
,str
或 PaddingStrategy,可选,默认为False
)— 激活和控制填充。接受以下值:-
True
或'longest'
:填充到批次中最长的序列(如果只提供了单个序列,则不进行填充)。 -
'max_length'
:填充到指定的最大长度(使用max_length
参数)或者填充到模型的最大可接受输入长度(如果未提供该参数)。 -
False
或'do_not_pad'
(默认):不进行填充(即可以输出具有不同长度序列的批次)。
-
-
truncation
(bool
,str
或 TruncationStrategy,可选,默认为False
)— 激活和控制截断。接受以下值:-
True
或'longest_first'
: 截断到指定的最大长度,使用参数max_length
,或者使用模型的最大可接受输入长度(如果未提供该参数)。如果提供一对序列(或一批序列),则逐标记截断,从一对序列中最长的序列中删除一个标记。 -
'only_first'
: 截断到指定的最大长度,使用参数max_length
,或者使用模型的最大可接受输入长度(如果未提供该参数)。如果提供一对序列(或一批序列),则仅截断第一个序列。 -
'only_second'
: 截断到指定的最大长度,使用参数max_length
,或者使用模型的最大可接受输入长度(如果未提供该参数)。如果提供一对序列(或一批序列),则仅截断第二个序列。 -
False
或'do_not_truncate'
(默认): 不截断(即,可以输出长度大于模型最大可接受输入大小的批次)。
-
-
max_length
(int
, 可选) — 控制截断/填充参数使用的最大长度。如果未设置或设置为
None
,则将使用预定义的模型最大长度,如果截断/填充参数需要最大长度。如果模型没有特定的最大输入长度(如 XLNet),则将禁用截断/填充到最大长度。 -
stride
(int
, 可选, 默认为 0) — 如果与max_length
一起设置为一个数字,当return_overflowing_tokens=True
时返回的溢出标记将包含截断序列末尾的一些标记,以提供截断和溢出序列之间的一些重叠。该参数的值定义重叠标记的数量。 -
is_split_into_words
(bool
, 可选, 默认为False
) — 输入是否已经预分词(例如,已经分成单词)。如果设置为True
,分词器会假定输入已经分成单词(例如,通过空格分割),然后进行分词。这对于命名实体识别或标记分类很有用。 -
pad_to_multiple_of
(int
, 可选) — 如果设置,将序列填充到提供的值的倍数。需要激活padding
。这对于在具有计算能力>= 7.5
(Volta)的 NVIDIA 硬件上启用 Tensor Cores 特别有用。 -
return_tensors
(str
或 TensorType, 可选) — 如果设置,将返回张量而不是 Python 整数列表。可接受的值为:-
'tf'
: 返回 TensorFlowtf.constant
对象。 -
'pt'
: 返回 PyTorchtorch.Tensor
对象。 -
'np'
: 返回 Numpynp.ndarray
对象。
-
-
return_token_type_ids
(bool
, 可选) — 是否返回 token 类型 ID。如果保持默认设置,将根据特定分词器的默认设置返回 token 类型 ID,由return_outputs
属性定义。什么是 token 类型 ID?
-
return_attention_mask
(bool
, 可选) — 是否返回注意力掩码。如果保持默认设置,将根据特定分词器的默认设置返回注意力掩码,由return_outputs
属性定义。什么是注意力掩码?
-
return_overflowing_tokens
(bool
, 可选, 默认为False
) — 是否返回溢出的标记序列。如果提供一对输入 ID 序列(或一批序列),并且truncation_strategy = longest_first
或True
,则会引发错误,而不是返回溢出的标记。 -
return_special_tokens_mask
(bool
, 可选, 默认为False
) — 是否返回特殊标记掩码信息。 -
return_offsets_mapping
(bool
, 可选, 默认为False
) — 是否返回每个标记的(char_start, char_end)
。这仅适用于继承自 PreTrainedTokenizerFast 的快速分词器,如果使用 Python 的分词器,此方法将引发
NotImplementedError
。 -
return_length
(bool
,可选,默认为False
) — 是否返回编码输入的长度。 -
verbose
(bool
,可选,默认为True
) — 是否打印更多信息和警告。**kwargs — 传递给self.tokenize()
方法
返回
BatchEncoding
具有以下字段的 BatchEncoding:
-
input_ids
— 要馈送到模型的标记 ID 列表。什么是输入 ID?
-
token_type_ids
— 要馈送到模型的标记类型 ID 列表(当return_token_type_ids=True
或者token_type_ids
在self.model_input_names
中时)。什么是标记类型 ID?
-
attention_mask
— 指定模型应该关注哪些标记的索引列表(当return_attention_mask=True
或者attention_mask
在self.model_input_names
中时)。什么是注意力掩码?
-
entity_ids
— 要馈送到模型的实体 ID 列表。什么是输入 ID?
-
entity_position_ids
— 输入序列中实体位置的列表,将被馈送到模型中。 -
entity_token_type_ids
— 要馈送到模型的实体标记类型 ID 列表(当return_token_type_ids=True
或者entity_token_type_ids
在self.model_input_names
中时)。什么是标记类型 ID?
-
entity_attention_mask
— 指定模型应该关注哪些实体的索引列表(当return_attention_mask=True
或者entity_attention_mask
在self.model_input_names
中时)。什么是注意力掩码?
-
entity_start_positions
— 单词标记序列中实体的开始位置列表(当task="entity_span_classification"
时)。 -
entity_end_positions
— 单词标记序列中实体的结束位置列表(当task="entity_span_classification"
时)。 -
overflowing_tokens
— 溢出标记序列的列表(当指定max_length
并且return_overflowing_tokens=True
时)。 -
num_truncated_tokens
— 被截断的标记数量(当指定max_length
并且return_overflowing_tokens=True
时)。 -
special_tokens_mask
— 由 0 和 1 组成的列表,其中 1 指定添加的特殊标记,0 指定常规序列标记(当add_special_tokens=True
和return_special_tokens_mask=True
时)。 -
length
— 输入的长度(当return_length=True
时)
为模型准备一个或多个序列或一个或多个序列对的主要方法,具体取决于您要为其准备的任务。
save_vocabulary
( save_directory: str filename_prefix: Optional = None )
LukeModel
class transformers.LukeModel
( config: LukeConfig add_pooling_layer: bool = True )
参数
config
(LukeConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
裸 LUKE 模型变压器输出原始隐藏状态,既适用于单词标记,也适用于实体,没有特定的头部。
该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。
该模型也是 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None entity_ids: Optional = None entity_attention_mask: Optional = None entity_token_type_ids: Optional = None entity_position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.luke.modeling_luke.BaseLukeModelOutputWithPooling or tuple(torch.FloatTensor)
参数
-
input_ids
(torch.LongTensor
of shape(batch_size, sequence_length)
) — 序列输入标记在词汇表中的索引。索引可以使用 AutoTokenizer 获得。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.
call
()。什么是输入 ID?
-
attention_mask
(torch.FloatTensor
of shape(batch_size, sequence_length)
, optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]
之间:-
1 表示
未被掩码
的标记, -
0 表示
被掩码
的标记。
什么是注意力掩码?
-
-
token_type_ids
(torch.LongTensor
of shape(batch_size, sequence_length)
, optional) — 段标记索引,用于指示输入的第一部分和第二部分。索引选择在[0, 1]
之间:-
0 对应于 句子 A 标记,
-
1 对应于 句子 B 标记。
什么是标记类型 ID?
-
-
position_ids
(torch.LongTensor
of shape(batch_size, sequence_length)
, optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]
。什么是位置 ID?
-
entity_ids
(torch.LongTensor
of shape(batch_size, entity_length)
) — 实体词汇中实体标记的索引。索引可以使用 AutoTokenizer 获得。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.
call
()。 -
entity_attention_mask
(torch.FloatTensor
of shape(batch_size, entity_length)
, optional) — 用于避免在填充实体标记索引上执行注意力的掩码。掩码值选择在[0, 1]
之间:-
1 表示
未被掩码
的实体标记, -
0 表示
被掩码
的实体标记。
-
-
entity_token_type_ids
(torch.LongTensor
of shape(batch_size, entity_length)
, optional) — 段标记索引,用于指示实体标记输入的第一部分和第二部分。索引选择在[0, 1]
之间:-
0 对应于 部分 A 实体标记,
-
1 对应于 部分 B 实体标记。
-
-
entity_position_ids
(torch.LongTensor
of shape(batch_size, entity_length, max_mention_length)
, optional) — 每个输入实体在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]
。 -
inputs_embeds
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 可选地,您可以直接传递嵌入表示,而不是传递input_ids
。如果您想要更多控制如何将input_ids
索引转换为相关向量,这将非常有用,而不是使用模型的内部嵌入查找矩阵。 -
head_mask
(torch.FloatTensor
,形状为(num_heads,)
或(num_layers, num_heads)
,可选) — 用于使自注意力模块中选择的头部失效的掩码。掩码值在[0, 1]
中选择:-
1 表示头部未被
masked
, -
0 表示头部被
masked
。
-
-
output_attentions
(bool
,可选) — 是否返回所有注意力层的注意力张量。更多细节请参见返回张量中的attentions
。 -
output_hidden_states
(bool
,可选) — 是否返回所有层的隐藏状态。更多细节请参见返回张量中的hidden_states
。 -
return_dict
(bool
,可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.models.luke.modeling_luke.BaseLukeModelOutputWithPooling
或tuple(torch.FloatTensor)
一个transformers.models.luke.modeling_luke.BaseLukeModelOutputWithPooling
或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
时)包含根据配置(LukeConfig)和输入而异的各种元素。
-
last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层的隐藏状态序列。 -
entity_last_hidden_state
(torch.FloatTensor
,形状为(batch_size, entity_length, hidden_size)
) — 模型最后一层的实体隐藏状态序列。 -
pooler_output
(torch.FloatTensor
,形状为(batch_size, hidden_size)
) — 序列第一个标记(分类标记)的最后一层隐藏状态,经过线性层和 Tanh 激活函数进一步处理。 -
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(嵌入输出的一个+每层输出的一个)。模型在每一层的隐藏状态加上初始嵌入输出。 -
entity_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, entity_length, hidden_size)
的torch.FloatTensor
元组(嵌入输出的一个+每层输出的一个)。模型在每一层的实体隐藏状态加上初始实体嵌入输出。 -
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length + entity_length, sequence_length + entity_length)
的torch.FloatTensor
元组(每层一个)。自注意力头部中的注意力权重 softmax 后的值,用于计算自注意力头部中的加权平均值。
LukeyModel 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的方法需要在此函数内定义,但应该在之后调用Module
实例而不是这个,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoTokenizer, LukeModel
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeModel.from_pretrained("studio-ousia/luke-base")
# Compute the contextualized entity representation corresponding to the entity mention "Beyoncé"
>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [(0, 7)] # character-based entity span corresponding to "Beyoncé"
>>> encoding = tokenizer(text, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt")
>>> outputs = model(**encoding)
>>> word_last_hidden_state = outputs.last_hidden_state
>>> entity_last_hidden_state = outputs.entity_last_hidden_state
# Input Wikipedia entities to obtain enriched contextualized representations of word tokens
>>> text = "Beyoncé lives in Los Angeles."
>>> entities = [
... "Beyoncé",
... "Los Angeles",
... ] # Wikipedia entity titles corresponding to the entity mentions "Beyoncé" and "Los Angeles"
>>> entity_spans = [
... (0, 7),
... (17, 28),
... ] # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
>>> encoding = tokenizer(
... text, entities=entities, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt"
... )
>>> outputs = model(**encoding)
>>> word_last_hidden_state = outputs.last_hidden_state
>>> entity_last_hidden_state = outputs.entity_last_hidden_state
LukeForMaskedLM
class transformers.LukeForMaskedLM
( config )
参数
config
(LukeConfig)— 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
LUKE 模型具有语言建模头和顶部的实体预测头,用于掩码语言建模和掩码实体预测。
这个模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。
这个模型也是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None entity_ids: Optional = None entity_attention_mask: Optional = None entity_token_type_ids: Optional = None entity_position_ids: Optional = None labels: Optional = None entity_labels: Optional = None head_mask: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.luke.modeling_luke.LukeMaskedLMOutput or tuple(torch.FloatTensor)
参数
-
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)— 输入序列标记在词汇表中的索引。可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()获取详细信息。什么是输入 ID?
-
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)— 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]
之间:-
1 代表
未被掩码
的标记, -
0 代表
被掩码
的标记。
什么是注意力掩码?
-
-
token_type_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 段标记索引,指示输入的第一部分和第二部分。索引选择在[0, 1]
之间:-
0 对应于一个句子 A标记,
-
1 对应于一个句子 B标记。
什么是标记类型 ID?
-
-
position_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]
。什么是位置 ID?
-
entity_ids
(形状为(batch_size, entity_length)
的torch.LongTensor
)— 实体词汇表中实体标记的索引。可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()获取详细信息。 -
entity_attention_mask
(形状为(batch_size, entity_length)
的torch.FloatTensor
,可选)— 避免在填充实体标记索引上执行注意力的掩码。掩码值选择在[0, 1]
之间:-
1 代表
未被掩码
的实体标记, -
0 代表
被掩码
的实体标记。
-
-
entity_token_type_ids
(形状为(batch_size, entity_length)
的torch.LongTensor
,可选)— 段标记索引,指示实体标记输入的第一部分和第二部分。索引选择在[0, 1]
之间:-
0 对应于一个部分 A实体标记,
-
1 对应于一个部分 B实体标记。
-
-
entity_position_ids
(torch.LongTensor
of shape(batch_size, entity_length, max_mention_length)
, optional) — 每个输入实体在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。 -
inputs_embeds
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您想要更多控制权来将input_ids
索引转换为相关向量,这将非常有用,而不是使用模型的内部嵌入查找矩阵。 -
head_mask
(torch.FloatTensor
of shape(num_heads,)
or(num_layers, num_heads)
, optional) — 用于使自注意力模块中选择的头部失效的掩码。选择的掩码值在[0, 1]
中。-
1 表示头部是
not masked
, -
0 表示头部是
masked
。
-
-
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]
中的标记。 -
entity_labels
(torch.LongTensor
of shape(batch_size, entity_length)
, optional) — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]
范围内(请参阅input_ids
文档字符串)。索引设置为-100
的标记将被忽略(掩码),损失仅计算具有标签在[0, ..., config.vocab_size]
中的标记。
返回
transformers.models.luke.modeling_luke.LukeMaskedLMOutput
或tuple(torch.FloatTensor)
一个transformers.models.luke.modeling_luke.LukeMaskedLMOutput
或一个torch.FloatTensor
元组(如果传递了return_dict=False
或当config.return_dict=False
时),包含根据配置(LukeConfig)和输入的各种元素。
-
loss
(torch.FloatTensor
of shape(1,)
, optional, returned whenlabels
is provided) — 掩码语言建模(MLM)损失和实体预测损失的总和。 -
mlm_loss
(torch.FloatTensor
of shape(1,)
, optional, returned whenlabels
is provided) — 掩码语言建模(MLM)损失。 -
mep_loss
(torch.FloatTensor
of shape(1,)
, optional, returned whenlabels
is provided) — 掩码实体预测(MEP)损失。 -
logits
(torch.FloatTensor
of shape(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
entity_logits
(torch.FloatTensor
of shape(batch_size, sequence_length, config.vocab_size)
) — 实体预测头的预测分数(SoftMax 之前每个实体词汇标记的分数)。 -
hidden_states
(tuple(torch.FloatTensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) —torch.FloatTensor
元组(一个用于嵌入输出,一个用于每个层的输出)的形状为(batch_size, sequence_length, hidden_size)
。每层模型输出的隐藏状态加上初始嵌入输出。
-
entity_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, entity_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 后的注意力权重,用于计算自注意力头中的加权平均值。
LuKeForMaskedLM 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
LukeForEntityClassification
class transformers.LukeForEntityClassification
( config )
参数
config
(LukeConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
LUKE 模型在顶部有一个分类头(在第一个实体标记的隐藏状态上有一个线性层)用于实体分类任务,如 Open Entity。
该模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
该模型也是 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
forward
( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None entity_ids: Optional = None entity_attention_mask: Optional = None entity_token_type_ids: Optional = None entity_position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.luke.modeling_luke.EntityClassificationOutput or tuple(torch.FloatTensor)
参数
-
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)— 输入序列标记在词汇表中的索引。可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()获取详细信息。什么是输入 ID?
-
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]
中选择:-
1 代表未被“掩盖”的标记,
-
0 代表被“掩盖”的标记。
什么是注意力掩码?
-
-
token_type_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 段标记索引,指示输入的第一部分和第二部分。索引在[0, 1]
中选择:-
0 对应于句子 A标记。
-
1 对应于句子 B标记。
什么是标记类型 ID?
-
-
position_ids
(torch.LongTensor
of shape(batch_size, sequence_length)
, optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]
。什么是位置 ID?
-
entity_ids
(torch.LongTensor
of shape(batch_size, entity_length)
) — 实体词汇表中实体标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()。 -
entity_attention_mask
(torch.FloatTensor
of shape(batch_size, entity_length)
, optional) — 避免在填充实体标记索引上执行注意力的掩码。选择的掩码值在[0, 1]
中:-
1 表示未被
masked
的实体标记, -
0 表示被
masked
的实体标记。
-
-
entity_token_type_ids
(torch.LongTensor
of shape(batch_size, entity_length)
, optional) — 段标记索引,指示实体标记输入的第一部分和第二部分。索引在[0, 1]
中选择:-
0 对应于部分 A实体标记,
-
1 对应于部分 B实体标记。
-
-
entity_position_ids
(torch.LongTensor
of shape(batch_size, entity_length, max_mention_length)
, optional) — 每个输入实体在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]
。 -
inputs_embeds
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 可选地,您可以直接传递嵌入表示,而不是传递input_ids
。如果您想要更多控制权来将input_ids
索引转换为相关向量,这将非常有用,而不是使用模型的内部嵌入查找矩阵。 -
head_mask
(torch.FloatTensor
of shape(num_heads,)
or(num_layers, num_heads)
, optional) — 用于使自注意力模块中的选定头部失效的掩码。选择的掩码值在[0, 1]
中:-
1 表示头部未被
masked
, -
0 表示头部被
masked
。
-
-
output_attentions
(bool
, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
。 -
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 -
return_dict
(bool
, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。 -
labels
(torch.LongTensor
of shape(batch_size,)
or(batch_size, num_labels)
, optional) — 用于计算分类损失的标签。如果形状为(batch_size,)
,则单标签分类使用交叉熵损失。在这种情况下,标签应包含应在[0, ..., config.num_labels - 1]
中的索引。如果形状为(batch_size, num_labels)
,则多标签分类使用二元交叉熵损失。在这种情况下,标签应只包含[0, 1]
,其中 0 和 1 分别表示 false 和 true。
返回
transformers.models.luke.modeling_luke.EntityClassificationOutput
或tuple(torch.FloatTensor)
一个transformers.models.luke.modeling_luke.EntityClassificationOutput
或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
时)包含根据配置(LukeConfig)和输入而异的各种元素。
-
loss
(torch.FloatTensor
of shape(1,)
, optional, returned whenlabels
is provided) — 分类损失。 -
logits
(torch.FloatTensor
,形状为(batch_size, config.num_labels)
) — 分类分数(SoftMax 之前)。 -
hidden_states
(tuple(torch.FloatTensor)
, 可选的, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。模型在每个层的输出的隐藏状态加上初始嵌入输出。 -
entity_hidden_states
(tuple(torch.FloatTensor)
, 可选的, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, entity_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 后的注意力权重,用于计算自注意力头中的加权平均值。
LukeForEntityClassification 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会负责运行前处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoTokenizer, LukeForEntityClassification
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-open-entity")
>>> model = LukeForEntityClassification.from_pretrained("studio-ousia/luke-large-finetuned-open-entity")
>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [(0, 7)] # character-based entity span corresponding to "Beyoncé"
>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: person
LukeForEntityPairClassification
class transformers.LukeForEntityPairClassification
( config )
参数
config
(LukeConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
LUKE 模型在顶部具有分类头(两个实体标记的隐藏状态上的线性层)用于实体对分类任务,如 TACRED。
该模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
该模型也是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。
forward
( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None entity_ids: Optional = None entity_attention_mask: Optional = None entity_token_type_ids: Optional = None entity_position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.luke.modeling_luke.EntityPairClassificationOutput or tuple(torch.FloatTensor)
参数
-
input_ids
(torch.LongTensor
,形状为(batch_size, sequence_length)
) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()。什么是输入 ID?
-
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)- 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]
中选择:-
1 表示未被屏蔽的标记,
-
0 表示被屏蔽的标记。
什么是注意力掩码?
-
-
token_type_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)- 指示输入的第一部分和第二部分的段标记索引。索引在[0, 1]
中选择:-
0 对应于句子 A标记,
-
1 对应于句子 B标记。
什么是标记类型 ID?
-
-
position_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)- 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。什么是位置 ID?
-
entity_ids
(形状为(batch_size, entity_length)
的torch.LongTensor
)- 实体词汇中实体标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()。 -
entity_attention_mask
(形状为(batch_size, entity_length)
的torch.FloatTensor
,可选)- 用于避免在填充实体标记索引上执行注意力的掩码。掩码值在[0, 1]
中选择:-
1 表示未被屏蔽的实体标记,
-
0 表示被屏蔽的实体标记。
-
-
entity_token_type_ids
(形状为(batch_size, entity_length)
的torch.LongTensor
,可选)- 指示实体标记输入的第一部分和第二部分的段标记索引。索引在[0, 1]
中选择:-
0 对应于部分 A实体标记,
-
1 对应于部分 B实体标记。
-
-
entity_position_ids
(形状为(batch_size, entity_length, max_mention_length)
的torch.LongTensor
,可选)- 每个输入实体在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。 -
inputs_embeds
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)- 可选地,您可以直接传递嵌入表示,而不是传递input_ids
。如果您想要更多控制如何将input_ids
索引转换为相关向量,这将非常有用,而不是使用模型的内部嵌入查找矩阵。 -
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)- 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]
中选择:-
1 表示头部未被屏蔽,
-
0 表示头部被屏蔽。
-
-
output_attentions
(bool
,可选)- 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 -
output_hidden_states
(bool
,可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 -
return_dict
(bool
,可选)- 是否返回一个 ModelOutput 而不是一个普通元组。 -
labels
(torch.LongTensor
,形状为(batch_size,)
或(batch_size, num_labels)
,optional) — 用于计算分类损失的标签。如果形状为(batch_size,)
,则用于单标签分类的交叉熵损失。在这种情况下,标签应包含应在[0, ..., config.num_labels - 1]
中的索引。如果形状为(batch_size, num_labels)
,则用于多标签分类的二元交叉熵损失。在这种情况下,标签应只包含[0, 1]
,其中 0 和 1 分别表示 false 和 true。
返回
transformers.models.luke.modeling_luke.EntityPairClassificationOutput
或tuple(torch.FloatTensor)
一个transformers.models.luke.modeling_luke.EntityPairClassificationOutput
或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含根据配置(LukeConfig)和输入的不同元素。
-
loss
(torch.FloatTensor
,形状为(1,)
,optional,当提供labels
时返回) — 分类损失。 -
logits
(torch.FloatTensor
,形状为(batch_size, 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
元组。每层输出的模型隐藏状态加上初始嵌入输出。 -
entity_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, entity_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 后的注意力权重,用于计算自注意力头中的加权平均值。
LukeyForEntityPairClassification 的前向方法,覆盖__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默忽略它们。
示例:
>>> from transformers import AutoTokenizer, LukeForEntityPairClassification
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
>>> model = LukeForEntityPairClassification.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [
... (0, 7),
... (17, 28),
... ] # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: per:cities_of_residence
LukeForEntitySpanClassification
class transformers.LukeForEntitySpanClassification
( config )
参数
config
(LukeConfig) — 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
LUKE 模型,顶部带有一个跨度分类头(隐藏状态输出的线性层),用于命名实体识别等任务。
该模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。
该模型还是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None entity_ids: Optional = None entity_attention_mask: Optional = None entity_token_type_ids: Optional = None entity_position_ids: Optional = None entity_start_positions: Optional = None entity_end_positions: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.luke.modeling_luke.EntitySpanClassificationOutput or tuple(torch.FloatTensor)
参数
-
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)— 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()。什么是输入 ID?
-
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]
之间:-
1 表示未被掩码的标记,
-
0 表示被掩码的标记。
什么是注意力掩码?
-
-
token_type_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 指示输入的第一部分和第二部分的段标记索引。索引选在[0, 1]
之间:-
0 对应一个句子 A标记。
-
1 对应一个句子 B标记。
什么是标记类型 ID?
-
-
position_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 每个输入序列标记在位置嵌入中的位置索引。选在范围[0, config.max_position_embeddings - 1]
内。什么是位置 ID?
-
entity_ids
(形状为(batch_size, entity_length)
的torch.LongTensor
)— 实体词汇表中实体标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()。 -
entity_attention_mask
(形状为(batch_size, entity_length)
的torch.FloatTensor
,可选)— 用于避免在填充实体标记索引上执行注意力的掩码。掩码值选在[0, 1]
之间:-
1 表示未被掩码的实体标记,
-
0 表示被掩码的实体标记。
-
-
entity_token_type_ids
(形状为(batch_size, entity_length)
的torch.LongTensor
,可选)— 指示实体标记输入的第一部分和第二部分的段标记索引。索引选在[0, 1]
之间:-
0 对应一个部分 A实体标记,
-
1 对应一个部分 B实体标记。
-
-
entity_position_ids
(形状为(batch_size, entity_length, max_mention_length)
的torch.LongTensor
,可选)— 每个输入实体在位置嵌入中的位置索引。选在范围[0, config.max_position_embeddings - 1]
内。 -
inputs_embeds
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)— 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您想要更多控制如何将input_ids
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。 -
head_mask
(torch.FloatTensor
,形状为(num_heads,)
或(num_layers, num_heads)
,可选) — 用于使自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]
:-
1 表示头部未被掩盖,
-
0 表示头部被掩盖。
-
-
output_attentions
(bool
,可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 -
output_hidden_states
(bool
,可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 -
return_dict
(bool
,可选) — 是否返回 ModelOutput 而不是普通元组。 -
entity_start_positions
(torch.LongTensor
) — 实体在单词标记序列中的起始位置。 -
entity_end_positions
(torch.LongTensor
) — 实体在单词标记序列中的结束位置。 -
labels
(torch.LongTensor
,形状为(batch_size, entity_length)
或(batch_size, entity_length, num_labels)
,可选) — 用于计算分类损失的标签。如果形状为(batch_size, entity_length)
,则使用交叉熵损失进行单标签分类。在这种情况下,标签应包含应在[0, ..., config.num_labels - 1]
中的索引。如果形状为(batch_size, entity_length, num_labels)
,则使用二元交叉熵损失进行多标签分类。在这种情况下,标签应只包含[0, 1]
,其中 0 和 1 分别表示 false 和 true。
返回
transformers.models.luke.modeling_luke.EntitySpanClassificationOutput
或 tuple(torch.FloatTensor)
一个 transformers.models.luke.modeling_luke.EntitySpanClassificationOutput
或一个 torch.FloatTensor
元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),包括根据配置(LukeConfig)和输入的各种元素。
-
loss
(torch.FloatTensor
,形状为(1,)
,可选,当提供了labels
时返回) — 分类损失。 -
logits
(torch.FloatTensor
,形状为(batch_size, entity_length, config.num_labels)
) — 分类分数(SoftMax 之前)。 -
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递了output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。模型在每个层的输出的隐藏状态加上初始嵌入输出。 -
entity_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递了output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 形状为(batch_size, entity_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 后的注意力权重,用于计算自注意力头中的加权平均值。
LukeyForEntitySpanClassification 的前向方法,覆盖了 __call__
特殊方法。
虽然前向传递的配方需要在此函数内定义,但应该在此之后调用 Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例:
>>> from transformers import AutoTokenizer, LukeForEntitySpanClassification
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-conll-2003")
>>> model = LukeForEntitySpanClassification.from_pretrained("studio-ousia/luke-large-finetuned-conll-2003")
>>> text = "Beyoncé lives in Los Angeles"
# List all possible entity spans in the text
>>> word_start_positions = [0, 8, 14, 17, 21] # character-based start positions of word tokens
>>> word_end_positions = [7, 13, 16, 20, 28] # character-based end positions of word tokens
>>> entity_spans = []
>>> for i, start_pos in enumerate(word_start_positions):
... for end_pos in word_end_positions[i:]:
... entity_spans.append((start_pos, end_pos))
>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_indices = logits.argmax(-1).squeeze().tolist()
>>> for span, predicted_class_idx in zip(entity_spans, predicted_class_indices):
... if predicted_class_idx != 0:
... print(text[span[0] : span[1]], model.config.id2label[predicted_class_idx])
Beyoncé PER
Los Angeles LOC
LukeForSequenceClassification
class transformers.LukeForSequenceClassification
( config )
参数
config
(LukeConfig)— 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
LUKE 模型变压器,顶部带有一个序列分类/回归头(在池化输出的顶部有一个线性层),例如用于 GLUE 任务。
这个模型继承自 PreTrainedModel。查看超类文档,了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
这个模型也是 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
forward
( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None entity_ids: Optional = None entity_attention_mask: Optional = None entity_token_type_ids: Optional = None entity_position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.luke.modeling_luke.LukeSequenceClassifierOutput or tuple(torch.FloatTensor)
参数
-
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)— 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()获取详细信息。什么是输入 ID?
-
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)— 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]
之间:-
对于未被“masked”掩盖的标记,将其设为 1,
-
对于被
masked
掩盖的标记,将其设为 0。
什么是注意力掩码?
-
-
token_type_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 段标记索引,指示输入的第一部分和第二部分。索引选择在[0, 1]
之间:-
0 对应于句子 A标记,
-
1 对应于句子 B标记。
什么是标记类型 ID?
-
-
position_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]
。什么是位置 ID?
-
entity_ids
(形状为(batch_size, entity_length)
的torch.LongTensor
)— 实体词汇中实体标记的索引。可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()获取详细信息。 -
entity_attention_mask
(形状为(batch_size, entity_length)
的torch.FloatTensor
,可选)— 避免在填充实体标记索引上执行注意力的掩码。掩码值选择在[0, 1]
之间:-
对于未被“masked”掩盖的实体标记,将其设为 1,
-
对于被
masked
掩盖的实体标记,将其设为 0。
-
-
entity_token_type_ids
(torch.LongTensor
of shape(batch_size, entity_length)
, optional) — 段标记索引,用于指示实体标记输入的第一部分和第二部分。索引选在[0, 1]
范围内:-
0 对应于部分 A实体标记,
-
1 对应于部分 B实体标记。
-
-
entity_position_ids
(torch.LongTensor
of shape(batch_size, entity_length, max_mention_length)
, optional) — 每个输入实体在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]
。 -
inputs_embeds
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 可选地,您可以直接传递嵌入表示,而不是传递input_ids
。如果您想要更多控制如何将input_ids
索引转换为相关向量,这将很有用,而不是使用模型的内部嵌入查找矩阵。 -
head_mask
(torch.FloatTensor
of shape(num_heads,)
or(num_layers, num_heads)
, optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选在[0, 1]
范围内。-
1 表示头部未被
masked
, -
0 表示头部是
masked
。
-
-
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.luke.modeling_luke.LukeSequenceClassifierOutput
或 tuple(torch.FloatTensor)
一个transformers.models.luke.modeling_luke.LukeSequenceClassifierOutput
或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含根据配置(LukeConfig)和输入的各种元素。
-
loss
(torch.FloatTensor
of shape(1,)
, optional, returned whenlabels
is provided) — 分类(或回归,如果 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, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入的输出加上每层的输出)。模型每层输出的隐藏状态加上可选的初始嵌入输出。
-
entity_hidden_states
(tuple(torch.FloatTensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) — 形状为(batch_size, entity_length, hidden_size)
的torch.FloatTensor
元组(嵌入输出的输出加上每层的输出)。模型每层输出的实体隐藏状态加上初始实体嵌入输出。 -
attentions
(tuple(torch.FloatTensor)
, optional, returned whenoutput_attentions=True
is passed or whenconfig.output_attentions=True
) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
LukeForSequenceClassification 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的方法需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
单标签分类的示例:
>>> import torch
>>> from transformers import AutoTokenizer, LukeForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-base")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-base", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
多标签分类的示例:
>>> import torch
>>> from transformers import AutoTokenizer, LukeForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-base", problem_type="multi_label_classification")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = LukeForSequenceClassification.from_pretrained(
... "studio-ousia/luke-base", num_labels=num_labels, problem_type="multi_label_classification"
... )
>>> labels = torch.sum(
... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss
LukeForMultipleChoice
class transformers.LukeForMultipleChoice
( config )
参数
config
(LukeConfig)- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
LUKE 模型在顶部具有多选分类头(在池化输出的顶部和 softmax 上的线性层),例如用于 RocStories/SWAG 任务。
这个模型继承自 PreTrainedModel。查看超类文档,了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
这个模型也是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。
forward
( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None entity_ids: Optional = None entity_attention_mask: Optional = None entity_token_type_ids: Optional = None entity_position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.luke.modeling_luke.LukeMultipleChoiceModelOutput or tuple(torch.FloatTensor)
参数
-
input_ids
(形状为(batch_size, num_choices, sequence_length)
的torch.LongTensor
)- 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()获取详细信息。什么是输入 ID?
-
attention_mask
(形状为(batch_size, num_choices, sequence_length)
的torch.FloatTensor
,可选)- 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]
之间:-
1 用于未被“掩码”的标记,
-
0 用于被“掩码”的标记。
什么是注意力掩码?
-
-
token_type_ids
(形状为(batch_size, num_choices, sequence_length)
的torch.LongTensor
,可选)- 段标记索引,用于指示输入的第一部分和第二部分。索引选择在[0, 1]
之间:-
0 对应于“句子 A”标记,
-
1 对应于“句子 B”标记。
什么是标记类型 ID?
-
-
position_ids
(形状为(batch_size, num_choices, sequence_length)
的torch.LongTensor
,可选)- 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]
。什么是位置 ID?
-
entity_ids
(形状为(batch_size, entity_length)
的torch.LongTensor
)- 实体词汇表中实体标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()。 -
entity_attention_mask
(形状为(batch_size, entity_length)
的torch.FloatTensor
,可选) - 避免在填充实体标记索引上执行注意力的掩码。选择的掩码值在[0, 1]
中:-
1 表示未被
masked
的实体标记, -
对于被
masked
的实体标记为 0。
-
-
entity_token_type_ids
(形状为(batch_size, entity_length)
的torch.LongTensor
,可选) - 指示实体标记输入的第一部分和第二部分的段标记索引。索引在[0, 1]
中选择:-
0 对应于部分 A实体标记,
-
1 对应于部分 B实体标记。
-
-
entity_position_ids
(形状为(batch_size, entity_length, max_mention_length)
的torch.LongTensor
,可选) - 每个输入实体在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。 -
inputs_embeds
(形状为(batch_size, num_choices, sequence_length, hidden_size)
的torch.FloatTensor
,可选) - 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您想要更多控制如何将input_ids
索引转换为相关向量,而不是模型的内部嵌入查找矩阵,则这很有用。 -
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选) - 用于使自注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]
中:-
1 表示头部未被
masked
, -
0 表示头部被
masked
。
-
-
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.luke.modeling_luke.LukeMultipleChoiceModelOutput
或tuple(torch.FloatTensor)
一个transformers.models.luke.modeling_luke.LukeMultipleChoiceModelOutput
或一个torch.FloatTensor
元组(如果传递了return_dict=False
或当config.return_dict=False
时)包括各种元素,取决于配置(LukeConfig)和输入。
-
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
元组(一个用于嵌入的输出,如果模型有一个嵌入层,+ 一个用于每个层的输出)。每层模型的隐藏状态加上可选的初始嵌入输出。
-
entity_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回)— 形状为(batch_size, entity_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 之后的注意力权重,用于计算自注意力头中的加权平均值。
LukeyForMultipleChoice 的前向方法,覆盖了 __call__
特殊方法。
虽然前向传递的配方需要在此函数内定义,但应该在此之后调用 Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoTokenizer, LukeForMultipleChoice
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForMultipleChoice.from_pretrained("studio-ousia/luke-base")
>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0) # choice0 is correct (according to Wikipedia ;)), batch size 1
>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels) # batch size is 1
>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits
LukeForTokenClassification
transformers.LukeForTokenClassification
类
( config )
参数
config
(LukeConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained() 方法以加载模型权重。
LUKE 模型在顶部具有一个标记分类头(隐藏状态输出的线性层)。为了使用 LUKE 解决命名实体识别(NER)任务,比起这个类,更适合使用 LukeForEntitySpanClassification
。
此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None entity_ids: Optional = None entity_attention_mask: Optional = None entity_token_type_ids: Optional = None entity_position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.luke.modeling_luke.LukeTokenClassifierOutput or tuple(torch.FloatTensor)
参数
-
input_ids
(torch.LongTensor
,形状为(batch_size, sequence_length)
) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.
call
()。什么是输入 ID?
-
attention_mask
(torch.FloatTensor
,形状为(batch_size, sequence_length)
,可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]
中:-
1 表示未被
masked
的标记, -
0 表示被
masked
的标记。
什么是注意力掩码?
-
-
token_type_ids
(torch.LongTensor
,形状为(batch_size, sequence_length)
,可选) — 段标记索引,用于指示输入的第一部分和第二部分。索引选择在[0, 1]
中:-
0 对应于 句子 A 标记,
-
1 对应于 句子 B 标记。
令牌类型 ID 是什么?
-
-
position_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)- 每个输入序列令牌在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。位置 ID 是什么?
-
entity_ids
(形状为(batch_size, entity_length)
的torch.LongTensor
)- 实体词汇中实体令牌的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()。 -
entity_attention_mask
(形状为(batch_size, entity_length)
的torch.FloatTensor
,可选)- 用于避免在填充实体令牌索引上执行注意力的掩码。掩码值在[0, 1]
中选择:-
对于未被“掩盖”的实体令牌,ID 为 1,
-
对于被“掩盖”的实体令牌,ID 为 0。
-
-
entity_token_type_ids
(形状为(batch_size, entity_length)
的torch.LongTensor
,可选)- 段令牌索引,用于指示实体令牌输入的第一部分和第二部分。索引在[0, 1]
中选择:-
0 对应于部分 A实体令牌,
-
1 对应于部分 B实体令牌。
-
-
entity_position_ids
(形状为(batch_size, entity_length, max_mention_length)
的torch.LongTensor
,可选)- 每个输入实体在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。 -
inputs_embeds
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)- 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您希望更多地控制如何将input_ids
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。 -
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)- 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]
中选择:-
1 表示头部未被“掩盖”,
-
0 表示头部被“掩盖”。
-
-
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.luke.modeling_luke.LukeTokenClassifierOutput
或元组(torch.FloatTensor)
一个transformers.models.luke.modeling_luke.LukeTokenClassifierOutput
或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
时)包含根据配置(LukeConfig)和输入的不同元素。
-
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
元组(如果模型有嵌入层,则一个用于嵌入的输出 + 一个用于每层的输出)。模型在每层输出的隐藏状态加上可选的初始嵌入输出。
-
entity_hidden_states
(tuple(torch.FloatTensor)
, 可选的, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, entity_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 之后。
LukeForTokenClassification 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会处理运行前后的处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoTokenizer, LukeForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForTokenClassification.from_pretrained("studio-ousia/luke-base")
>>> inputs = tokenizer(
... "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_token_class_ids = logits.argmax(-1)
>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
LukeForQuestionAnswering
class transformers.LukeForQuestionAnswering
( config )
参数
config
(LukeConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
LUKE 模型在顶部具有一个跨度分类头,用于提取式问答任务,如 SQuAD(在隐藏状态输出的线性层上计算span start logits
和span end logits
)。
此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
此模型也是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有信息。
forward
( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None entity_ids: Optional = None entity_attention_mask: Optional = None entity_token_type_ids: Optional = None entity_position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.luke.modeling_luke.LukeQuestionAnsweringModelOutput or tuple(torch.FloatTensor)
参数
-
input_ids
(torch.LongTensor
,形状为(batch_size, sequence_length)
) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()获取详细信息。什么是输入 ID?
-
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]
中:-
1 用于未被“掩盖”的标记,
-
0 用于被“掩盖”的标记。
什么是注意力掩码?
-
-
token_type_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 段标记索引,指示输入的第一部分和第二部分。索引选择在[0, 1]
中:-
0 对应于句子 A标记,
-
1 对应于句子 B标记。
什么是标记类型 ID?
-
-
position_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]
。什么是位置 ID?
-
entity_ids
(形状为(batch_size, entity_length)
的torch.LongTensor
)— 实体词汇中实体标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()。 -
entity_attention_mask
(形状为(batch_size, entity_length)
的torch.FloatTensor
,可选)— 用于避免在填充实体标记索引上执行注意力的掩码。掩码值选择在[0, 1]
中:-
1 用于未被“掩盖”的实体标记,
-
0 用于被“掩盖”的实体标记。
-
-
entity_token_type_ids
(形状为(batch_size, entity_length)
的torch.LongTensor
,可选)— 段标记索引,指示实体标记输入的第一部分和第二部分。索引选择在[0, 1]
中:-
0 对应于部分 A实体标记,
-
1 对应于部分 B实体标记。
-
-
entity_position_ids
(形状为(batch_size, entity_length, max_mention_length)
的torch.LongTensor
,可选)— 每个输入实体在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]
。 -
inputs_embeds
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)— 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您想要更多控制权来将input_ids
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。 -
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)— 用于使自注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]
中:-
1 表示头部未被“掩盖”,
-
0 表示头部被“掩盖”。
-
-
output_attentions
(bool
,可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回的张量下的attentions
。 -
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回的张量下的hidden_states
。 -
return_dict
(bool
,可选)— 是否返回 ModelOutput 而不是普通元组。 -
start_positions
(形状为(batch_size,)
的torch.LongTensor
,可选)— 用于计算标记范围开始位置的位置(索引)的标签,以计算标记分类损失。位置被夹紧到序列的长度(sequence_length
)。超出序列范围的位置不会用于计算损失。 -
end_positions
(torch.LongTensor
形状为(batch_size,)
, optional) — 用于计算标记跨度结束位置的位置(索引)的标签。位置被夹紧到序列的长度(sequence_length
)。序列外的位置不会被考虑在内计算损失。
返回
transformers.models.luke.modeling_luke.LukeQuestionAnsweringModelOutput
或tuple(torch.FloatTensor)
一个transformers.models.luke.modeling_luke.LukeQuestionAnsweringModelOutput
或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含各种元素,取决于配置(LukeConfig)和输入。
-
loss
(torch.FloatTensor
形状为(1,)
, optional, 当提供labels
时返回) — 总跨度提取损失是起始位置和结束位置的交叉熵之和。 -
start_logits
(torch.FloatTensor
形状为(batch_size, sequence_length)
) — 跨度起始得分(SoftMax 之前)。 -
end_logits
(torch.FloatTensor
形状为(batch_size, sequence_length)
) — 跨度结束得分(SoftMax 之前)。 -
hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) —torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入的输出+每一层的输出)的形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
-
entity_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) —torch.FloatTensor
元组(嵌入输出+每一层的输出)的形状为(batch_size, entity_length, hidden_size)
。模型在每一层输出的实体隐藏状态加上初始实体嵌入输出。 -
attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) —torch.FloatTensor
元组(每层一个)的形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
LukeForQuestionAnswering 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoTokenizer, LukeForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForQuestionAnswering.from_pretrained("studio-ousia/luke-base")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()
>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])
>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· DeepSeek “源神”启动!「GitHub 热点速览」
· 我与微信审核的“相爱相杀”看个人小程序副业
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· 如何使用 Uni-app 实现视频聊天(源码,支持安卓、iOS)
· C# 集成 DeepSeek 模型实现 AI 私有化(本地部署与 API 调用教程)