Transformers documentation
LUKE
该模型于 2020-10-02 在 HF papers 上发布，并于 2021-05-03 贡献至 Hugging Face Transformers。
LUKE
概述
LUKE 模型由 Ikuya Yamada、Akari Asai、Hiroyuki Shindo、Hideaki Takeda 和 Yuji Matsumoto 在 LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention 中提出。 它基于 RoBERTa，并添加了实体嵌入以及实体感知的自注意力机制，有助于提升涉及实体推理的各种下游任务的性能，例如命名实体识别、抽取式和完形填空式问答、实体类型分类以及关系分类。
该论文的摘要如下：
实体表示在涉及实体的自然语言任务中非常有用。在本文中，我们提出了一种基于双向 Transformer 的新的预训练上下文词和实体表示。所提出的模型将给定文本中的词和实体视为独立的 token，并输出它们的上下文表示。我们的模型使用一种基于 BERT 掩码语言模型的新预训练任务进行训练。该任务涉及在从维基百科检索的大型实体标注语料库中预测随机掩码的词和实体。我们还提出了一种实体感知的自注意力机制，它是 Transformer 自注意力机制的扩展，在计算注意力分数时会考虑 token 的类型（词或实体）。所提出的模型在广泛的实体相关任务上取得了令人印象深刻的实证性能。特别是，它在五个知名数据集上获得了最先进的结果：Open Entity（实体类型分类）、TACRED（关系分类）、CoNLL-2003（命名实体识别）、ReCoRD（完形填空式问答）和 SQuAD 1.1（抽取式问答）。
该模型由 ikuyamada 和 nielsr 贡献。原始代码可在此处找到。
使用技巧
此实现与 RobertaModel 相同，但额外增加了实体嵌入以及实体感知的自注意力机制，从而提升了涉及实体推理任务的性能。
LUKE 将实体视为输入 token；因此，它额外接受
entity_ids、entity_attention_mask、entity_token_type_ids和entity_position_ids作为输入。您可以使用 LukeTokenizer 来获取这些值。LukeTokenizer 额外接收
entities和entity_spans（实体在输入文本中基于字符的起始和结束位置）作为输入。entities通常由 [MASK] 实体或 Wikipedia 实体组成。输入这些实体时的简要说明如下：- 输入 [MASK] 实体以计算实体表示：[MASK] 实体用于在预训练期间遮蔽待预测的实体。当 LUKE 接收到 [MASK] 实体时，它会尝试通过从输入文本中收集有关该实体的信息来预测原始实体。因此，[MASK] 实体可用于处理需要文本中实体信息的下游任务，例如实体类型识别、关系分类和命名实体识别。
- 输入维基百科实体以计算知识增强的词元表示：LUKE 在预训练过程中学习关于维基百科实体的丰富信息（或知识），并将这些信息存储在其实体嵌入中。通过使用维基百科实体作为输入词元，LUKE 会输出由这些实体嵌入中存储的信息所增强的词元表示。这对于需要现实世界知识的任务（例如问答）尤为有效。
针对上述使用场景，共有三种头部模型：
- LukeForEntityClassification，用于对输入文本中的单个实体进行分类的任务，例如实体类型标注，如 Open Entity 数据集。该模型在输出实体表示之上添加了一个线性层。
- LukeForEntityPairClassification，用于对两个实体之间的关系进行分类的任务，例如关系分类，如 TACRED dataset。该模型在给定实体对的拼接输出表示之上添加了一个线性头。
- LukeForEntitySpanClassification，用于对实体跨度序列进行分类的任务，例如命名实体识别（NER）。该模型在输出的实体表示之上添加了一个线性头。您可以通过将文本中所有可能的实体跨度作为输入提供给该模型，来使用它处理 NER 任务。
LukeTokenizer 提供了一个
task参数，通过指定task="entity_classification"、task="entity_pair_classification"或task="entity_span_classification"，您可以轻松为这些头模型创建输入。请参阅各头模型的示例代码。
使用示例：
from transformers import LukeForEntityPairClassification, LukeModel, LukeTokenizer
model = LukeModel.from_pretrained("studio-ousia/luke-base", device_map="auto")
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").to(model.device)
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").to(model.device)
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", device_map="auto")
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").to(model.device)
outputs = model(**inputs)
logits = outputs.logits
predicted_class_idx = int(logits[0].argmax())
print("Predicted class:", model.config.id2label[predicted_class_idx])资源
- 一个演示笔记本，介绍如何微调 [LukeForEntityPairClassification](/docs/transformers/v5.23.0/en/model_doc/luke#transformers.LukeForEntityPairClassification) 以进行关系分类
- 展示如何使用 HuggingFace 的 LUKE 实现复现论文中所报告结果的 Notebook
- 文本分类任务指南
- Token 分类任务指南
- 问答任务指南
- 掩码语言建模任务指南
- 多项选择任务指南
LukeConfig
class transformers.LukeConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 50267entity_vocab_size: int = 500000hidden_size: int = 768entity_emb_size: int = 256num_hidden_layers: int = 12num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.1attention_probs_dropout_prob: float | int = 0.1max_position_embeddings: int = 512type_vocab_size: int = 2initializer_range: float = 0.02layer_norm_eps: float = 1e-12use_entity_aware_attention: bool = Trueclassifier_dropout: float | int | None = Nonepad_token_id: int | None = 1bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 2tie_word_embeddings: bool = True )
参数
- vocab_size (
int，可选，默认为50267) — 模型的词汇表大小。定义了input_ids可以表示的不同 token 数量。 - entity_vocab_size (
int, 可选，默认为 500000) — LUKE 模型的实体词表大小。定义了调用 LukeModel 时传入的entity_ids所能表示的不同实体的数量。 - hidden_size (
int，可选，默认为768) — 隐藏表示的维度。 - entity_emb_size (
int，可选，默认为 256) — 实体嵌入的维度数。 - num_hidden_layers (
int, 可选, 默认为12) — Transformer 解码器中的隐藏层数量。 - num_attention_heads (
int，可选，默认为12) — Transformer 解码器中每个注意力层的注意力头数量。 - intermediate_size (
int，可选，默认为3072) — MLP 表示的维度。 - hidden_act (
str，可选，默认为gelu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、"relu"、"silu"等。 - hidden_dropout_prob (
Union[float, int]，可选，默认为0.1) — 嵌入层、编码器和池化层中所有全连接层的 dropout 概率。 - attention_probs_dropout_prob (
Union[float, int]，可选，默认为0.1) — 注意力概率的 dropout 比率。 - max_position_embeddings (
int，可选，默认为512) — 该模型可能使用的最大序列长度。 - type_vocab_size (
int，可选，默认为2) —token_type_ids的词汇表大小。 - initializer_range (
float，可选，默认为0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - layer_norm_eps (
float，可选，默认为1e-12) — 层归一化层所使用的 epsilon 值。 - use_entity_aware_attention (
bool，可选，默认为True) — 模型是否应使用 LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention (Yamada et al.) 中提出的实体感知自注意力机制。 - classifier_dropout (
Union[float, int], 可选) — 分类器的 dropout 比率。 - pad_token_id (
int，可选，默认为1) — 词表中用于填充的 token id。 - bos_token_id (
int，可选，默认为0) — 词汇表中用于表示流起始的 Token id。 - eos_token_id (
Union[int, list[int]]，可选，默认为2) — 词汇表中用于表示流结束（end-of-stream）的 token id。 - tie_word_embeddings (
bool，可选，默认为True) — 是否根据模型的tied_weights_keys映射来绑定权重嵌入。
这是用于存储 LukeModel 配置的类。它根据指定的参数实例化 Luke 模型，并定义模型架构。使用默认值实例化配置将生成与 studio-ousia/luke-base 类似的配置。
配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。
LukeTokenizer
class transformers.LukeTokenizer
< source >( vocab: str | dict[str, int] | None = Nonemerges: str | list[str] | None = Noneentity_vocab: str | dict | list | None = Noneerrors = '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 = Falsetask = Nonemax_entity_length = 32max_mention_length = 30entity_1_token = '<ent>'entity_2_token = '<ent2>'entity_unk_token = '[UNK]'entity_pad_token = '[PAD]'entity_mask_token = '[MASK]'entity_mask2_token = '[MASK2]'**kwargs )
参数
- vocab_file (
str) — 词汇表文件的路径。 - merges_file (
str) — 合并文件的路径。 - vocab (
str或dict[str, int]，可选) — 自定义词汇表。如果未提供，则从vocab_file加载词汇表。 - merges（
str或list[str]，可选）— 自定义合并列表。如果未提供，则从merges_file加载合并列表。 - entity_vocab_file (
str) — 实体词汇表文件的路径。 - task (
str，可选) — 用于准备序列的任务。取值为"entity_classification"、"entity_pair_classification"或"entity_span_classification"之一。如果指定了此参数，则会根据给定的实体跨度自动创建实体序列。 - max_entity_length (
int，可选，默认为 32) —entity_ids的最大长度。 - max_mention_length (
int，可选，默认为 30) — 实体跨度内的最大 token 数量。 - entity_1_token (
str，可选，默认为<ent>) — 用于在词元序列中表示实体跨度的特殊标记。仅当task设置为"entity_classification"或"entity_pair_classification"时才会使用此标记。 - entity_2_token (
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。 - sep_token (
str，可选，默认为"</s>") — 分隔符 token，用于从多个序列构建序列时，例如用于序列分类的两个序列，或用于问答的文本和问题。它也用作使用特殊 token 构建的序列的最后一个 token。 - cls_token (
str，可选，默认为"<s>") — 用于序列分类（对整个序列进行分类，而非逐 token 分类）的分类器 token。当使用特殊 token 构建序列时，它是序列的第一个 token。 - unk_token (
str，可选，默认为"<unk>") — 未知标记。不在词汇表中的标记无法转换为 ID，因此会被设置为该标记。 - pad_token (
str，可选，默认为"<pad>") — 用于填充的标记，例如在对长度不同的序列进行批处理时。 - mask_token (
str, 可选，默认为"<mask>") — 用于掩码值的标记。这是在以掩码语言建模方式训练该模型时所使用的标记，也是模型将尝试预测的标记。 - add_prefix_space (
bool，可选，默认为False) — 是否要在输入前添加一个初始空格。这可以将开头的单词视为与其他单词相同。（LUKE 分词器通过前导空格来检测单词的起始位置）。
构建一个 LUKE 分词器，该分词器派生自 GPT-2 分词器，并使用字节级 Byte-Pair-Encoding。
该分词器经过训练，将空格视为标记的一部分（类似于 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__
< source >( text: str | list[str]text_pair: str | list[str] | None = Noneentity_spans: list[tuple[int, int]] | list[list[tuple[int, int]]] | None = Noneentity_spans_pair: list[tuple[int, int]] | list[list[tuple[int, int]]] | None = Noneentities: list[str] | list[list[str]] | None = Noneentities_pair: list[str] | list[list[str]] | None = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = Nonemax_length: int | None = Nonemax_entity_length: int | None = Nonestride: int = 0is_split_into_words: bool | None = Falsepad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_offsets_mapping: bool = Falsereturn_length: bool = Falseverbose: bool = True**kwargs ) → BatchEncoding
返回值
一个包含以下字段的 BatchEncoding：
-
input_ids — 要输入模型的 token id 列表。
-
token_type_ids — 要输入模型的 token 类型 ID 列表（当
return_token_type_ids=True或self.model_input_names中包含 “token_type_ids” 时）。 -
attention_mask — 索引列表，指定模型应关注哪些 token（当
return_attention_mask=True或 “attention_mask” 位于self.model_input_names中时）。 -
entity_ids — 要输入模型的实体 ID 列表。
-
entity_position_ids — 输入序列中实体位置的列表，用于提供给模型。
-
entity_token_type_ids — 要输入模型的实体 token 类型 ID 列表（当
return_token_type_ids=True或 “entity_token_type_ids” 位于self.model_input_names中时）。 -
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 — 溢出 token 序列的列表（当指定了
max_length且return_overflowing_tokens=True时）。 -
num_truncated_tokens — 被截断的 token 数量（当指定了
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时）
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指定的最大长度，或者如果未提供该参数，则截断至模型可接受的最大输入长度。这将逐个 token 进行截断，如果提供了一对序列（或一批序列对），则会从该对中最长的序列中移除一个 token。'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 时返回的溢出 token 将包含来自截断序列末尾的一些 token，以在截断序列和溢出序列之间提供一些重叠。此参数的值定义了重叠 token 的数量。
is_split_into_words (bool, 可选，默认为 False)：
输入是否已经预先分词（例如，已拆分为单词）。如果设置为 True，分词器将假设输入已拆分为单词（例如，通过按空白字符拆分），然后对其进行分词。这对于 NER 或 token 分类非常有用。
pad_to_multiple_of (int, 可选)：
如果设置，则将序列填充为所提供值的倍数。需要启用 padding。
这对于在具有计算能力 >= 7.5（Volta）的 NVIDIA 硬件上启用 Tensor Cores 的使用特别有用。
padding_side (str, 可选)：
应在模型的哪一侧应用填充。应在 [‘right’, ‘left’] 之间进行选择。
默认值取自同名的类属性。
return_tensors (str 或 TensorType, 可选)：
如果设置，将返回张量而不是 Python 整数列表。可接受的值是：
'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 Numpynp.ndarray对象。
return_token_type_ids (bool，可选)：
是否返回 token type ID。如果保持默认值，则根据特定 tokenizer 的默认设置返回 token type ID，该设置由 return_outputs 属性定义。
什么是 token type IDs？ return_attention_mask (bool, 可选)：
是否返回 attention mask。如果保持默认值，则根据特定 tokenizer 的默认设置返回 attention mask，该设置由 return_outputs 属性定义。
什么是注意力掩码？ return_overflowing_tokens (bool，可选，默认为 False)：
是否返回溢出的 token 序列。如果提供了输入 id 的序列对（或序列对批次），且 truncation_strategy = longest_first 或 True，则会抛出错误，而不是返回溢出的 token。
return_special_tokens_mask (bool，可选，默认为 False)：
是否返回特殊 token 掩码信息。
return_offsets_mapping (bool，可选，默认为 False)：
是否为每个 token 返回 (char_start, char_end)。
此功能仅适用于继承自 PreTrainedTokenizerFast 的快速分词器；如果使用 Python 分词器，此方法将引发 NotImplementedError。
return_length (bool，可选，默认为 False)：
是否返回编码后输入的长度。
verbose (bool，可选，默认为 True)：
是否打印更多信息和警告。
**kwargs：传递给 self.tokenize() 方法
LukeModel
class transformers.LukeModel
< source >( config: LukeConfigadd_pooling_layer: bool = True )
参数
- config (LukeConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
- add_pooling_layer (
bool，可选，默认为True) — 是否添加池化层
原始的 LUKE 模型 transformer 输出词元（word tokens）和实体的原始隐藏状态（hidden-states），且
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.Tensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BaseLukeModelOutputWithPooling or tuple(torch.Tensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- token_type_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段 token 索引。索引取值范围为[0, 1]:- 0 对应 sentence A 标记，
- 1 对应于 sentence B 标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - entity_ids (
torch.LongTensor形状为(batch_size, entity_length)) — 实体词元在实体词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- entity_attention_mask (
torch.Tensor形状为(batch_size, entity_length), 可选) — 用于避免对填充实体标记索引执行注意力的掩码。掩码值在[0, 1]:- 1 对于未被掩码的实体标记，
- 实体 token 的值为 0，表示其已被掩码。
- entity_token_type_ids (
torch.LongTensor形状为(batch_size, entity_length), 可选) — 用于指示实体 token 输入中第一和第二部分的片段 token 索引。索引从[0, 1]:- 0 对应 portion A 实体标记，
- 1 对应于 portion 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.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对input_ids索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
BaseLukeModelOutputWithPooling 或 tuple(torch.Tensor)
BaseLukeModelOutputWithPooling 或 torch.Tensor 元组（如果传入 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（LukeConfig）和输入。
LukeModel 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
last_hidden_state（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor）— 模型最后一层输出的隐藏状态序列。pooler_output（形状为
(batch_size, hidden_size)的torch.Tensor）— 序列中第一个 token（分类 token）的最后一层隐藏状态，经过一个 Linear 层和 Tanh 激活函数进一步处理后的结果。hidden_states (
tuple(torch.Tensor)，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple(torch.Tensor)，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
entity_last_hidden_state（形状为
(batch_size, entity_length, hidden_size)的torch.Tensor）— 模型最后一层输出的实体隐藏状态序列。entity_hidden_states (
tuple(torch.Tensor)，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（包含嵌入层的输出以及每一层的输出），形状为(batch_size, entity_length, hidden_size)。模型在每一层输出处的实体隐藏状态，以及初始实体嵌入输出。
示例：
>>> 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_stateLukeForMaskedLM
class transformers.LukeForMaskedLM
< source >( config: LukeConfig )
参数
- config (LukeConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
LUKE 模型，其顶部包含一个语言建模头和一个实体预测头，用于执行掩码语言建模和掩码实体预测。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.LongTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneentity_labels: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LukeMaskedLMOutput or tuple(torch.Tensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- token_type_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段 token 索引。索引取值范围为[0, 1]:- 0 对应 sentence A 标记，
- 1 对应于 sentence B 标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - entity_ids (
torch.LongTensor形状为(batch_size, entity_length)) — 实体词元在实体词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- entity_attention_mask (
torch.Tensor形状为(batch_size, entity_length), 可选) — 用于避免对填充实体标记索引执行注意力的掩码。掩码值在[0, 1]:- 1 对于未被掩码的实体标记，
- 实体 token 的值为 0，表示其已被掩码。
- entity_token_type_ids (
torch.LongTensor形状为(batch_size, entity_length), 可选) — 用于指示实体 token 输入中第一和第二部分的片段 token 索引。索引从[0, 1]:- 0 对应 portion A 实体标记，
- 1 对应于 portion B 实体标记。
- entity_position_ids（形状为
(batch_size, entity_length, max_mention_length)的torch.LongTensor，可选） — 每个输入实体在位置嵌入中的位置索引。取值范围为[0, config.max_position_embeddings - 1]。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]范围内（参见input_ids的文档字符串）。索引设置为-100的 token 将被忽略（即被掩码），损失仅针对标签在[0, ..., config.vocab_size]范围内的 token 进行计算。 - entity_labels（形状为
(batch_size, entity_length)的torch.LongTensor，可选） — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]范围内（参见input_ids的文档字符串）。索引设置为-100的 token 将被忽略（即被掩码），损失仅针对标签位于[0, ..., config.vocab_size]范围内的 token 进行计算。 - inputs_embeds（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对input_ids索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
LukeMaskedLMOutput 或 tuple(torch.Tensor)
LukeMaskedLMOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），包含根据配置（LukeConfig）和输入而定的各种元素。
LukeForMaskedLM 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss (
torch.Tensor，形状为(1,)，可选，当提供labels时返回) — 掩码语言建模（MLM）损失与实体预测损失的总和。mlm_loss (
torch.Tensor，形状为(1,)，可选，在提供labels时返回) — 掩码语言建模（MLM）损失。mep_loss（形状为
(1,)的torch.Tensor，可选，在提供labels时返回）— 掩码实体预测（MEP）损失。logits（形状为
(batch_size, sequence_length, config.vocab_size)的torch.Tensor）— 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。entity_logits（形状为
(batch_size, sequence_length, config.vocab_size)的torch.Tensor）— 实体预测头的预测分数（SoftMax 之前每个实体词汇标记的分数）。hidden_states (
tuple[torch.Tensor]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
entity_hidden_states (
tuple(torch.Tensor)，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（包含嵌入层的输出以及每一层的输出），形状为(batch_size, entity_length, hidden_size)。模型在每一层输出处的实体隐藏状态，以及初始实体嵌入输出。attentions (
tuple[torch.Tensor, ...]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
示例：
>>> from transformers import AutoTokenizer, LukeForMaskedLM
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForMaskedLM.from_pretrained("studio-ousia/luke-base")
>>> inputs = tokenizer("The capital of France is <mask>.", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> # retrieve index of <mask>
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]
>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> tokenizer.decode(predicted_token_id)
...
>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-<mask> tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)
>>> outputs = model(**inputs, labels=labels)
>>> round(outputs.loss.item(), 2)
...LukeForEntityClassification
class transformers.LukeForEntityClassification
< source >( config: LukeConfig )
参数
- config (LukeConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
在实体分类任务（例如 Open Entity）中，LUKE 模型顶部带有分类头（即在第一个实体 token 的隐藏状态之上添加一个线性层）。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.Tensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → EntityClassificationOutput or tuple(torch.Tensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- token_type_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段 token 索引。索引取值范围为[0, 1]:- 0 对应 sentence A 标记，
- 1 对应于 sentence B 标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - entity_ids (
torch.LongTensor形状为(batch_size, entity_length)) — 实体词元在实体词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- entity_attention_mask (
torch.Tensor形状为(batch_size, entity_length), 可选) — 用于避免对填充实体标记索引执行注意力的掩码。掩码值在[0, 1]:- 1 对于未被掩码的实体标记，
- 实体 token 的值为 0，表示其已被掩码。
- entity_token_type_ids (
torch.LongTensor形状为(batch_size, entity_length), 可选) — 用于指示实体 token 输入中第一和第二部分的片段 token 索引。索引从[0, 1]:- 0 对应 portion A 实体标记，
- 1 对应于 portion 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.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对input_ids索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - labels (
torch.LongTensor，形状为(batch_size,)或(batch_size, num_labels)，可选) — 用于计算分类损失的标签。如果形状为(batch_size,)，则使用交叉熵损失进行单标签分类。在这种情况下，labels 应包含[0, ..., config.num_labels - 1]范围内的索引。如果形状为(batch_size, num_labels)，则使用二元交叉熵损失进行多标签分类。在这种情况下，labels 应仅包含[0, 1]，其中 0 和 1 分别表示假和真。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
EntityClassificationOutput 或 tuple(torch.Tensor)
EntityClassificationOutput 或 torch.Tensor 元组（如果传入 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（LukeConfig）和输入。
LukeForEntityClassification 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss（形状为
(1,)的torch.Tensor，可选，在提供labels时返回） — 分类损失。logits（形状为
(batch_size, config.num_labels)的torch.Tensor）— 分类分数（SoftMax 之前）。hidden_states (
tuple[torch.Tensor, ...]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
entity_hidden_states (
tuple(torch.Tensor)，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（包含嵌入层的输出以及每一层的输出），形状为(batch_size, entity_length, hidden_size)。模型在每一层输出处的实体隐藏状态，以及初始实体嵌入输出。attentions (
tuple[torch.Tensor, ...]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
示例：
>>> 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: personLukeForEntityPairClassification
class transformers.LukeForEntityPairClassification
< source >( config: LukeConfig )
参数
- config (LukeConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
在实体对分类任务（例如 TACRED）中，LUKE 模型顶部带有一个分类头（即在两个实体 token 的隐藏状态之上添加一个线性层）。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.Tensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → EntityPairClassificationOutput or tuple(torch.Tensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- token_type_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段 token 索引。索引取值范围为[0, 1]:- 0 对应 sentence A 标记，
- 1 对应于 sentence B 标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - entity_ids (
torch.LongTensor形状为(batch_size, entity_length)) — 实体词元在实体词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- entity_attention_mask (
torch.Tensor形状为(batch_size, entity_length), 可选) — 用于避免对填充实体标记索引执行注意力的掩码。掩码值在[0, 1]:- 1 对于未被掩码的实体标记，
- 实体 token 的值为 0，表示其已被掩码。
- entity_token_type_ids (
torch.LongTensor形状为(batch_size, entity_length), 可选) — 用于指示实体 token 输入中第一和第二部分的片段 token 索引。索引从[0, 1]:- 0 对应 portion A 实体标记，
- 1 对应于 portion 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.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对input_ids索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - labels (
torch.LongTensor，形状为(batch_size,)或(batch_size, num_labels)，可选) — 用于计算分类损失的标签。如果形状为(batch_size,)，则使用交叉熵损失进行单标签分类。在这种情况下，labels 应包含[0, ..., config.num_labels - 1]范围内的索引。如果形状为(batch_size, num_labels)，则使用二元交叉熵损失进行多标签分类。在这种情况下，labels 应仅包含[0, 1]，其中 0 和 1 分别表示假和真。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
EntityPairClassificationOutput 或 tuple(torch.Tensor)
EntityPairClassificationOutput 或 torch.Tensor 元组（如果传入 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（LukeConfig）和输入。
LukeForEntityPairClassification 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss（形状为
(1,)的torch.Tensor，可选，在提供labels时返回） — 分类损失。logits（形状为
(batch_size, config.num_labels)的torch.Tensor）— 分类分数（SoftMax 之前）。hidden_states (
tuple[torch.Tensor, ...]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
entity_hidden_states (
tuple(torch.Tensor)，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（包含嵌入层的输出以及每一层的输出），形状为(batch_size, entity_length, hidden_size)。模型在每一层输出处的实体隐藏状态，以及初始实体嵌入输出。attentions (
tuple[torch.Tensor, ...]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
示例：
>>> 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_residenceLukeForEntitySpanClassification
class transformers.LukeForEntitySpanClassification
< source >( config: LukeConfig )
参数
- config (LukeConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
在隐藏状态输出之上添加一个线性层作为跨度分类头，用于命名实体识别等任务的 LUKE 模型。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.LongTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneentity_start_positions: typing.Optional[torch.LongTensor] = Noneentity_end_positions: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → EntitySpanClassificationOutput or tuple(torch.Tensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- token_type_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段 token 索引。索引取值范围为[0, 1]:- 0 对应 sentence A 标记，
- 1 对应于 sentence B 标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - entity_ids (
torch.LongTensor形状为(batch_size, entity_length)) — 实体词元在实体词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- entity_attention_mask (
torch.Tensor形状为(batch_size, entity_length), 可选) — 用于避免对填充实体标记索引执行注意力的掩码。掩码值在[0, 1]:- 1 对于未被掩码的实体标记，
- 实体 token 的值为 0，表示其已被掩码。
- entity_token_type_ids (
torch.LongTensor形状为(batch_size, entity_length), 可选) — 用于指示实体 token 输入中第一和第二部分的片段 token 索引。索引从[0, 1]:- 0 对应 portion A 实体标记，
- 1 对应于 portion B 实体标记。
- entity_position_ids（形状为
(batch_size, entity_length, max_mention_length)的torch.LongTensor，可选） — 每个输入实体在位置嵌入中的位置索引。取值范围为[0, config.max_position_embeddings - 1]。 - entity_start_positions (
torch.LongTensor, 可选) — 实体在词元序列中的起始位置。 - entity_end_positions (
torch.LongTensor, 可选) — 实体在词元序列中的结束位置。 - inputs_embeds（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对input_ids索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - labels (
torch.LongTensor，形状为(batch_size, entity_length)或(batch_size, entity_length, num_labels)，可选) — 用于计算分类损失的标签。如果形状为(batch_size, entity_length)，则使用交叉熵损失进行单标签分类。在这种情况下，labels 应包含[0, ..., config.num_labels - 1]范围内的索引。如果形状为(batch_size, entity_length, num_labels)，则使用二元交叉熵损失进行多标签分类。在这种情况下，labels 应仅包含[0, 1]，其中 0 和 1 分别表示假和真。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
EntitySpanClassificationOutput 或 tuple(torch.Tensor)
EntitySpanClassificationOutput 或 torch.Tensor 元组（如果传入 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（LukeConfig）和输入。
LukeForEntitySpanClassification 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss（形状为
(1,)的torch.Tensor，可选，在提供labels时返回） — 分类损失。logits（形状为
(batch_size, entity_length, config.num_labels)的torch.Tensor）— 分类分数（SoftMax 之前）。hidden_states (
tuple[torch.Tensor, ...]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
entity_hidden_states (
tuple(torch.Tensor)，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（包含嵌入层的输出以及每一层的输出），形状为(batch_size, entity_length, hidden_size)。模型在每一层输出处的实体隐藏状态，以及初始实体嵌入输出。attentions (
tuple[torch.Tensor, ...]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
示例：
>>> 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 LOCLukeForSequenceClassification
class transformers.LukeForSequenceClassification
< source >( config: LukeConfig )
参数
- config (LukeConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
带有序列分类/回归头（在池化输出之上添加一个线性层）的 LUKE 模型 Transformer，例如用于 GLUE 任务。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.Tensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LukeSequenceClassifierOutput or tuple(torch.Tensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- token_type_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段 token 索引。索引取值范围为[0, 1]:- 0 对应 sentence A 标记，
- 1 对应于 sentence B 标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - entity_ids (
torch.LongTensor形状为(batch_size, entity_length)) — 实体词元在实体词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- entity_attention_mask (
torch.Tensor形状为(batch_size, entity_length), 可选) — 用于避免对填充实体标记索引执行注意力的掩码。掩码值在[0, 1]:- 1 对于未被掩码的实体标记，
- 实体 token 的值为 0，表示其已被掩码。
- entity_token_type_ids (
torch.LongTensor形状为(batch_size, entity_length), 可选) — 用于指示实体 token 输入中第一和第二部分的片段 token 索引。索引从[0, 1]:- 0 对应 portion A 实体标记，
- 1 对应于 portion 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.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对input_ids索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - labels (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失）；如果config.num_labels > 1，则计算分类损失（交叉熵）。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
LukeSequenceClassifierOutput 或 tuple(torch.Tensor)
LukeSequenceClassifierOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（LukeConfig）和输入。
LukeForSequenceClassification 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss (
torch.Tensor，形状为(1,)，可选，当提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。logits（形状为
(batch_size, config.num_labels)的torch.Tensor）— 分类（或当 config.num_labels==1 时为回归）得分（SoftMax 之前）。hidden_states (
tuple[torch.Tensor, ...]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
entity_hidden_states (
tuple(torch.Tensor)，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（包含嵌入层的输出以及每一层的输出），形状为(batch_size, entity_length, hidden_size)。模型在每一层输出处的实体隐藏状态，以及初始实体嵌入输出。attentions (
tuple[torch.Tensor, ...]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
单标签分类示例：
>>> 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()
>>> model.config.id2label[predicted_class_id]
...
>>> # 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
>>> round(loss.item(), 2)
...多标签分类示例：
>>> 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).lossLukeForMultipleChoice
class transformers.LukeForMultipleChoice
< source >( config: LukeConfig )
参数
- config (LukeConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
在 Luke 模型顶部添加一个多项选择分类头（即在池化输出之上添加一个线性层和一个 softmax），例如用于 RocStories/SWAG 任务。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.Tensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LukeMultipleChoiceModelOutput or tuple(torch.Tensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, num_choices, sequence_length)) — 输入序列 token 在词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- token_type_ids (
torch.LongTensor形状为(batch_size, num_choices, sequence_length), 可选) — 用于指示输入中第一和第二部分的片段标记索引。索引取值范围为[0, 1]:- 0 对应 sentence A 标记，
- 1 对应于 sentence B 标记。
- position_ids (
torch.LongTensor形状为(batch_size, num_choices, sequence_length), ，可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.max_position_embeddings - 1]. - entity_ids (
torch.LongTensor形状为(batch_size, entity_length)) — 实体词元在实体词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- entity_attention_mask (
torch.Tensor形状为(batch_size, entity_length), 可选) — 用于避免对填充实体标记索引执行注意力的掩码。掩码值在[0, 1]:- 1 对于未被掩码的实体标记，
- 实体 token 的值为 0，表示其已被掩码。
- entity_token_type_ids (
torch.LongTensor形状为(batch_size, entity_length), 可选) — 用于指示实体 token 输入中第一和第二部分的片段 token 索引。索引从[0, 1]:- 0 对应 portion A 实体标记，
- 1 对应于 portion B 实体标记。
- entity_position_ids（形状为
(batch_size, entity_length, max_mention_length)的torch.LongTensor，可选） — 每个输入实体在位置嵌入中的位置索引。取值范围为[0, config.max_position_embeddings - 1]。 - inputs_embeds (
torch.Tensor，形状为(batch_size, num_choices, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对input_ids索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - labels（形状为
(batch_size,)的torch.LongTensor，可选） — 用于计算多项选择分类损失的标签。索引应在[0, ..., num_choices-1]范围内，其中num_choices是输入张量第二维的大小。（参见上文中的input_ids） - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
LukeMultipleChoiceModelOutput 或 tuple(torch.Tensor)
LukeMultipleChoiceModelOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（LukeConfig）和输入。
LukeForMultipleChoice 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss（形状为 (1,) 的
torch.Tensor，可选，在提供labels时返回） — 分类损失。logits（形状为
(batch_size, num_choices)的torch.Tensor）— num_choices 是输入张量的第二维（参见上文中的 input_ids）。分类分数（SoftMax 之前）。
hidden_states (
tuple[torch.Tensor, ...]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
entity_hidden_states (
tuple(torch.Tensor)，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（包含嵌入层的输出以及每一层的输出），形状为(batch_size, entity_length, hidden_size)。模型在每一层输出处的实体隐藏状态，以及初始实体嵌入输出。attentions (
tuple[torch.Tensor, ...]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
示例：
>>> 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.logitsLukeForTokenClassification
class transformers.LukeForTokenClassification
< source >( config: LukeConfig )
参数
- config (LukeConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
带有 token 分类头（位于 hidden-states 输出之上的线性层）的 LUKE 模型。若要使用 LUKE 解决命名实体识别（NER）任务，LukeForEntitySpanClassification 比此类更为合适。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.Tensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LukeTokenClassifierOutput or tuple(torch.Tensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- token_type_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段 token 索引。索引取值范围为[0, 1]:- 0 对应 sentence A 标记，
- 1 对应于 sentence B 标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - entity_ids (
torch.LongTensor形状为(batch_size, entity_length)) — 实体词元在实体词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- entity_attention_mask (
torch.Tensor形状为(batch_size, entity_length), 可选) — 用于避免对填充实体标记索引执行注意力的掩码。掩码值在[0, 1]:- 1 对于未被掩码的实体标记，
- 实体 token 的值为 0，表示其已被掩码。
- entity_token_type_ids (
torch.LongTensor形状为(batch_size, entity_length), 可选) — 用于指示实体 token 输入中第一和第二部分的片段 token 索引。索引从[0, 1]:- 0 对应 portion A 实体标记，
- 1 对应于 portion 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.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对input_ids索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - labels（形状为
(batch_size,)的torch.LongTensor，可选） — 用于计算多项选择分类损失的标签。索引应在[0, ..., num_choices-1]范围内，其中num_choices是输入张量第二维的大小。（参见上文中的input_ids） - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
LukeTokenClassifierOutput 或 tuple(torch.Tensor)
LukeTokenClassifierOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（LukeConfig）和输入。
LukeForTokenClassification 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss（形状为
(1,)的torch.Tensor，可选，在提供labels时返回） — 分类损失。logits（形状为
(batch_size, sequence_length, config.num_labels)的torch.Tensor）— 分类分数（SoftMax 之前）。hidden_states (
tuple[torch.Tensor, ...]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
entity_hidden_states (
tuple(torch.Tensor)，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（包含嵌入层的输出以及每一层的输出），形状为(batch_size, entity_length, hidden_size)。模型在每一层输出处的实体隐藏状态，以及初始实体嵌入输出。attentions (
tuple[torch.Tensor, ...]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
示例：
>>> 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]]
>>> predicted_tokens_classes
...
>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...LukeForQuestionAnswering
class transformers.LukeForQuestionAnswering
< source >( config: LukeConfig )
参数
- config (LukeConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
用于抽取式问答任务（如 SQuAD）的 Luke 变换器，其顶部带有一个跨度分类头（在隐藏状态输出之上添加一个线性层，用于计算 span start logits 和 span end logits）。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.Tensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonestart_positions: typing.Optional[torch.LongTensor] = Noneend_positions: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LukeQuestionAnsweringModelOutput or tuple(torch.Tensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- token_type_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段 token 索引。索引取值范围为[0, 1]:- 0 对应 sentence A 标记，
- 1 对应于 sentence B 标记。
- position_ids (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - entity_ids (
torch.LongTensor形状为(batch_size, entity_length)) — 实体词元在实体词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- entity_attention_mask (
torch.Tensor形状为(batch_size, entity_length), 可选) — 用于避免对填充实体标记索引执行注意力的掩码。掩码值在[0, 1]:- 1 对于未被掩码的实体标记，
- 实体 token 的值为 0，表示其已被掩码。
- entity_token_type_ids (
torch.LongTensor形状为(batch_size, entity_length), 可选) — 用于指示实体 token 输入中第一和第二部分的片段 token 索引。索引从[0, 1]:- 0 对应 portion A 实体标记，
- 1 对应于 portion 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.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对input_ids索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - start_positions (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算 token 分类损失的标注片段起始位置（索引）的标签。 位置会被截断到序列长度（sequence_length）。序列之外的位置在计算损失时不予考虑。 - end_positions (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算 token 分类损失的标注片段结束位置（索引）的标签。 位置会被截断到序列长度（sequence_length）。序列之外的位置在计算损失时不予考虑。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
LukeQuestionAnsweringModelOutput 或 tuple(torch.Tensor)
LukeQuestionAnsweringModelOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（LukeConfig）和输入。
LukeForQuestionAnswering 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss (
torch.Tensor，形状为(1,)，可选，当提供labels时返回) — 总跨度提取损失是起始位置和结束位置的交叉熵之和。start_logits（形状为
(batch_size, sequence_length)的torch.Tensor，可选）— 跨度起始分数（SoftMax 之前）。end_logits（形状为
(batch_size, sequence_length)的torch.Tensor，可选）— 跨度结束分数（SoftMax 之前）。hidden_states (
tuple[torch.Tensor, ...]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
entity_hidden_states (
tuple(torch.Tensor)，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（包含嵌入层的输出以及每一层的输出），形状为(batch_size, entity_length, hidden_size)。模型在每一层输出处的实体隐藏状态，以及初始实体嵌入输出。attentions (
tuple[torch.Tensor, ...]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
示例：
>>> 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]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...
>>> # 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
>>> round(loss.item(), 2)
...