Transformers 文档

LUKE

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

LUKE

PyTorch

概述

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 (抽取式问答)。

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

使用技巧

  • 此实现与 RobertaModel 相同,但增加了实体嵌入以及实体感知自注意力机制,从而提高了在涉及实体推理任务上的性能。

  • LUKE 将实体作为输入 token;因此,它需要额外的输入 entity_idsentity_attention_maskentity_token_type_idsentity_position_ids。你可以使用 LukeTokenizer 获取这些输入。

  • LukeTokenizer 需要额外的输入 entitiesentity_spans(实体在输入文本中基于字符的起始和结束位置)。entities 通常由 [MASK] 实体或维基百科实体组成。输入这些实体时的简要说明如下:

    • 输入 [MASK] 实体以计算实体表示:[MASK] 实体用于在预训练期间掩码要预测的实体。当 LUKE 接收到 [MASK] 实体时,它会尝试通过从输入文本中收集实体信息来预测原始实体。因此,[MASK] 实体可用于处理需要文本中实体信息的下游任务,如实体类型化、关系分类和命名实体识别。
    • 输入维基百科实体以计算知识增强的 token 表示:LUKE 在预训练期间学习了关于维基百科实体的丰富信息(或知识),并将这些信息存储在其实体嵌入中。通过使用维基百科实体作为输入 token,LUKE 输出的 token 表示会因这些实体嵌入中存储的信息而得到增强。这对于需要现实世界知识的任务(如问答)特别有效。
  • 针对前一种用例,有三种头模型:

    • 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 时传递的 `inputs_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) — Transformer 编码器中“中间”(通常称为前馈)层的维度。
  • hidden_act (strCallable, 可选, 默认为 "gelu") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,则支持 "gelu""relu""silu""gelu_new"
  • hidden_dropout_prob (float, 可选, 默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的丢弃概率。
  • attention_probs_dropout_prob (float, 可选, 默认为 0.1) — 注意力概率的丢弃率。
  • max_position_embeddings (int, 可选, 默认为 512) — 该模型可能使用的最大序列长度。通常将其设置为较大的值以备不时之需(例如,512、1024 或 2048)。
  • type_vocab_size (int, 可选, 默认为 2) — 调用 LukeModel 时传递的 `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 (float, 可选) — 分类头的丢弃率。
  • pad_token_id (int, 可选, 默认为 1) — 填充 token 的 ID。
  • bos_token_id (int, 可选, 默认为 0) — 序列开始 token 的 ID。
  • eos_token_id (int, 可选, 默认为 2) — 序列结束 token 的 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) — merges 文件的路径。
  • 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) — 实体范围内词元(token)的最大数量。
  • entity_token_1 (str, optional, 默认为 <ent>) — 用于在词元序列中表示实体范围的特殊词元。仅当 task 设置为 "entity_classification""entity_pair_classification" 时使用此词元。
  • entity_token_2 (str, optional, 默认为 <ent2>) — 用于在词元序列中表示实体范围的特殊词元。仅当 task 设置为 "entity_pair_classification" 时使用此词元。
  • errors (str, optional, 默认为 "replace") — 将字节解码为 UTF-8 时遵循的范式。更多信息请参见 bytes.decode
  • bos_token (str, optional, 默认为 "<s>") — 预训练期间使用的序列开始词元。可用作序列分类器词元。

    使用特殊词元构建序列时,这不是用于序列开头的词元。使用的词元是 cls_token

  • eos_token (str, optional, 默认为 "</s>") — 序列结束词元。

    使用特殊词元构建序列时,这不是用于序列结尾的词元。使用的词元是 sep_token

  • sep_token (str, optional, 默认为 "</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) — 是否在输入前添加一个初始空格。这允许将开头的词像其他词一样处理。(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_idsentity_attention_maskentity_token_type_idsentity_position_ids,供 LUKE 模型使用。

__call__

< >

( text: typing.Union[str, list[str]] text_pair: typing.Union[str, list[str], NoneType] = None entity_spans: typing.Union[list[tuple[int, int]], list[list[tuple[int, int]]], NoneType] = None entity_spans_pair: typing.Union[list[tuple[int, int]], list[list[tuple[int, int]]], NoneType] = None entities: typing.Union[list[str], list[list[str]], NoneType] = None entities_pair: typing.Union[list[str], list[list[str]], NoneType] = None add_special_tokens: bool = True padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False truncation: typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy] = None max_length: typing.Optional[int] = None max_entity_length: typing.Optional[int] = None stride: int = 0 is_split_into_words: typing.Optional[bool] = False pad_to_multiple_of: typing.Optional[int] = None padding_side: typing.Optional[str] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None return_token_type_ids: typing.Optional[bool] = None return_attention_mask: typing.Optional[bool] = 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 ) 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]]], optional) — 待编码的实体范围序列或序列批次。每个序列由元组组成,每个元组包含两个整数,表示实体的基于字符的起始和结束位置。如果在构造函数中将 task 参数指定为 "entity_classification""entity_pair_classification",则每个序列的长度必须分别为 1 或 2。如果指定了 entities,则每个序列的长度必须等于 entities 中每个序列的长度。
  • entity_spans_pair (list[tuple[int, int]], list[list[tuple[int, int]]], optional) — 待编码的实体范围序列或序列批次。每个序列由元组组成,每个元组包含两个整数,表示实体的基于字符的起始和结束位置。如果在构造函数中指定了 task 参数,则忽略此参数。如果指定了 entities_pair,则每个序列的长度必须等于 entities_pair 中每个序列的长度。
  • entities (list[str], list[list[str]], optional) — 待编码的实体序列或序列批次。每个序列由表示实体的字符串组成,即特殊实体(例如 [MASK])或维基百科的实体标题(例如 Los Angeles)。如果在构造函数中指定了 task 参数,则忽略此参数。每个序列的长度必须等于 entity_spans 中每个序列的长度。如果指定了 entity_spans 但未指定此参数,则会自动构建实体序列或实体序列批次,并用 [MASK] 实体填充。
  • entities_pair (list[str], list[list[str]], optional) — 待编码的实体序列或序列批次。每个序列由表示实体的字符串组成,即特殊实体(例如 [MASK])或维基百科的实体标题(例如 Los Angeles)。如果在构造函数中指定了 task 参数,则忽略此参数。每个序列的长度必须等于 entity_spans_pair 中每个序列的长度。如果指定了 entity_spans_pair 但未指定此参数,则会自动构建实体序列或实体序列批次,并用 [MASK] 实体填充。
  • max_entity_length (int, optional) — entity_ids 的最大长度。
  • add_special_tokens (bool, optional, 默认为 True) — 在编码序列时是否添加特殊词元。这将使用底层的 PretrainedTokenizerBase.build_inputs_with_special_tokens 函数,该函数定义了哪些词元会自动添加到输入 ID 中。如果你想自动添加 boseos 词元,这会很有用。
  • padding (bool, str or PaddingStrategy, optional, 默认为 False) — 激活和控制填充。接受以下值:

    • True'longest':填充到批次中最长的序列(如果只提供单个序列则不填充)。
    • 'max_length':填充到由 max_length 参数指定的最大长度,如果未提供该参数,则填充到模型可接受的最大输入长度。
    • False'do_not_pad'(默认):不填充(即可以输出具有不同长度序列的批次)。
  • truncation (bool, str or TruncationStrategy, optional, 默认为 False) — 激活和控制截断。接受以下值:

    • True'longest_first':截断到由 max_length 参数指定的最大长度,如果未提供该参数,则截断到模型可接受的最大输入长度。这将逐个词元进行截断,如果提供了一对序列(或一批序列对),则从最长的序列中移除一个词元。
    • 'only_first':截断到由 max_length 参数指定的最大长度,如果未提供该参数,则截断到模型可接受的最大输入长度。如果提供了一对序列(或一批序列对),则仅截断第一个序列。
    • 'only_second':截断到由 max_length 参数指定的最大长度,如果未提供该参数,则截断到模型可接受的最大输入长度。如果提供了一对序列(或一批序列对),则仅截断第二个序列。
    • False'do_not_truncate'(默认):不截断(即可以输出序列长度大于模型最大可接受输入大小的批次)。
  • max_length (int, optional) — 控制截断/填充参数使用的最大长度。

    如果未设置或设置为 None,则如果截断/填充参数需要最大长度,将使用预定义的模型最大长度。如果模型没有特定的最大输入长度(如 XLNet),则将停用截断/填充到最大长度的功能。

  • stride (int, optional, 默认为 0) — 如果与 max_length 一起设置为一个数字,当 return_overflowing_tokens=True 时返回的溢出词元将包含一些来自返回的截断序列末尾的词元,以便在截断和溢出序列之间提供一些重叠。此参数的值定义了重叠词元的数量。
  • is_split_into_words (bool, optional, 默认为 False) — 输入是否已经预分词(例如,拆分成单词)。如果设置为 True,分词器会假定输入已经拆分成单词(例如,通过空格拆分),然后对其进行分词。这对于 NER 或词元分类很有用。
  • pad_to_multiple_of (int, optional) — 如果设置,将把序列填充到所提供值的倍数。需要激活 padding。这对于在计算能力 >= 7.5 (Volta) 的 NVIDIA 硬件上启用 Tensor Cores 特别有用。
  • padding_side (str, optional) — 模型应应用填充的一侧。应在 [‘right’, ‘left’] 中选择。默认值从同名的类属性中选取。
  • return_tensors (str or TensorType, optional) — 如果设置,将返回张量而不是 Python 整数列表。可接受的值有:

    • 'tf':返回 TensorFlow tf.constant 对象。
    • 'pt':返回 PyTorch torch.Tensor 对象。
    • 'np':返回 Numpy np.ndarray 对象。
  • return_token_type_ids (bool, optional) — 是否返回词元类型 ID。如果保留默认值,将根据特定分词器的默认设置返回词元类型 ID,该设置由 return_outputs 属性定义。

    什么是词元类型 ID?

  • return_attention_mask (bool, optional) — 是否返回注意力掩码。如果保留默认值,将根据特定分词器的默认设置返回注意力掩码,该设置由 return_outputs 属性定义。

    什么是注意力掩码?

  • return_overflowing_tokens (bool, optional, 默认为 False) — 是否返回溢出的词元序列。如果提供了一对输入 ID 序列(或一批序列对),且 truncation_strategy = longest_firstTrue,则会引发错误,而不是返回溢出的词元。
  • return_special_tokens_mask (bool, optional, 默认为 False) — 是否返回特殊词元掩码信息。
  • return_offsets_mapping (bool, optional, 默认为 False) — 是否为每个词元返回 (char_start, char_end)

    这仅在继承自 PreTrainedTokenizerFast 的快速分词器上可用,如果使用 Python 的分词器,此方法将引发 NotImplementedError

  • return_length (bool, optional, 默认为 False) — 是否返回编码输入的长度。
  • verbose (bool, optional, 默认为 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_lengthreturn_overflowing_tokens=True 时)。

  • num_truncated_tokens — 截断标记的数量(当指定 max_lengthreturn_overflowing_tokens=True 时)。

  • special_tokens_mask — 0 和 1 的列表,其中 1 表示添加的特殊标记,0 表示常规序列标记(当 add_special_tokens=Truereturn_special_tokens_mask=True 时)。

  • length — 输入的长度(当 return_length=True 时)

用于分词并为模型准备一个或多个序列,或一个或多个序列对的主要方法,具体取决于你想要为之准备的任务。

save_vocabulary

< >

( save_directory: str filename_prefix: typing.Optional[str] = None )

LukeModel

class transformers.LukeModel

< >

( config: LukeConfig add_pooling_layer: bool = True )

参数

  • config (LukeConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。请查看 from_pretrained() 方法来加载模型权重。
  • add_pooling_layer (bool, optional, 默认为 True) — 是否添加池化层

基础的 LUKE 模型 Transformer,输出词元和实体的原始隐藏状态,不带任何特定任务的头部。

此模型继承自 PreTrainedModel。请查阅超类文档,了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。

此模型也是 PyTorch 的 torch.nn.Module 子类。可以像常规 PyTorch Module 一样使用它,并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None entity_ids: typing.Optional[torch.LongTensor] = None entity_attention_mask: typing.Optional[torch.FloatTensor] = None entity_token_type_ids: typing.Optional[torch.LongTensor] = None entity_position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.models.luke.modeling_luke.BaseLukeModelOutputWithPoolingtuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

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

    • 1 表示标记未被掩码
    • 0 表示标记已被掩码

    什么是注意力掩码?

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

    • 0 对应于 *句子 A* 的标记,
    • 1 对应于 *句子 B* 的标记。

    什么是标记类型 ID?

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

    什么是位置 ID?

  • entity_ids (torch.LongTensor,形状为 (batch_size, entity_length)) — 实体词汇表中实体标记的索引。

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

  • entity_attention_mask (torch.FloatTensor,形状为 (batch_size, entity_length)可选) — 用于避免在填充实体标记索引上执行注意力的掩码。掩码值选自 [0, 1]

    • 1 表示实体标记未被掩码
    • 0 表示实体标记已被掩码
  • entity_token_type_ids (torch.LongTensor,形状为 (batch_size, entity_length)可选) — 片段标记索引,用于指示实体标记输入的第一和第二部分。索引选自 [0, 1]

    • 0 对应于 *A 部分* 的实体标记,
    • 1 对应于 *B 部分* 的实体标记。
  • entity_position_ids (torch.LongTensor,形状为 (batch_size, entity_length, max_mention_length)可选) — 位置嵌入中每个输入实体的位置索引。选自范围 [0, config.max_position_embeddings - 1]
  • head_mask (torch.FloatTensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 用于置零自注意力模块中选定头的掩码。掩码值选自 [0, 1]

    • 1 表示头未被掩码
    • 0 表示头已被掩码
  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,你可以选择直接传递嵌入表示,而不是传递 input_ids。如果你想比模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为相关向量,这会很有用。
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.luke.modeling_luke.BaseLukeModelOutputWithPoolingtuple(torch.FloatTensor)

一个 transformers.models.luke.modeling_luke.BaseLukeModelOutputWithPooling 或一个 torch.FloatTensor 的元组 (如果传递了 return_dict=Falseconfig.return_dict=False),根据配置 (LukeConfig) 和输入包含各种元素。

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

  • pooler_output (torch.FloatTensor,形状为 (batch_size, hidden_size)) — 如果 *config.use_mean_pooling* 设置为 True,则为块标记(不包括 *[CLS]* 标记)的最后一层隐藏状态的平均值。如果设置为 False,则返回 *[CLS]* 标记的最终隐藏状态。

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

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

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

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

  • entity_last_hidden_state (torch.FloatTensor,形状为 (batch_size, entity_length, hidden_size)) — 模型最后一层输出的实体隐藏状态序列。

  • entity_hidden_states (tuple(torch.FloatTensor)可选,当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(一个用于嵌入层的输出 + 一个用于每层的输出),形状为 (batch_size, entity_length, hidden_size)。模型每层输出的实体隐藏状态加上初始实体嵌入输出。

LukeModel 的 forward 方法会覆盖 __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 (LukeForMaskedLM) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。请查看 from_pretrained() 方法来加载模型权重。

带有语言建模头和实体预测头的 LUKE 模型,用于掩码语言建模和掩码实体预测。

此模型继承自 PreTrainedModel。请查阅超类文档,了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。

此模型也是 PyTorch 的 torch.nn.Module 子类。可以像常规 PyTorch Module 一样使用它,并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None entity_ids: typing.Optional[torch.LongTensor] = None entity_attention_mask: typing.Optional[torch.LongTensor] = None entity_token_type_ids: typing.Optional[torch.LongTensor] = None entity_position_ids: typing.Optional[torch.LongTensor] = None labels: typing.Optional[torch.LongTensor] = None entity_labels: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.models.luke.modeling_luke.LukeMaskedLMOutputtuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

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

    • 1 表示标记未被掩码
    • 0 表示标记已被掩码

    什么是注意力掩码?

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

    • 0 对应于 *句子 A* 的标记,
    • 1 对应于 *句子 B* 的标记。

    什么是标记类型 ID?

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

    什么是位置 ID?

  • entity_ids (torch.LongTensor,形状为 (batch_size, entity_length)) — 实体词汇表中实体标记的索引。

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

  • entity_attention_mask (torch.FloatTensor,形状为 (batch_size, entity_length)可选) — 用于避免在填充实体标记索引上执行注意力的掩码。掩码值选自 [0, 1]

    • 1 表示实体标记未被掩码
    • 0 表示实体标记已被掩码
  • entity_token_type_ids (torch.LongTensor,形状为 (batch_size, entity_length)可选) — 片段标记索引,用于指示实体标记输入的第一和第二部分。索引选自 [0, 1]

    • 0 对应于 *A 部分* 的实体标记,
    • 1 对应于 *B 部分* 的实体标记。
  • entity_position_ids (torch.LongTensor,形状为 (batch_size, entity_length, max_mention_length)可选) — 位置嵌入中每个输入实体的位置索引。选自范围 [0, config.max_position_embeddings - 1]
  • labels (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 用于计算掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 中(参见 input_ids 文档字符串)。索引设置为 -100 的标记将被忽略(掩码),损失仅对标签在 [0, ..., config.vocab_size] 中的标记计算。
  • entity_labels (torch.LongTensor,形状为 (batch_size, entity_length)可选) — 用于计算掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 中(参见 input_ids 文档字符串)。索引设置为 -100 的标记将被忽略(掩码),损失仅对标签在 [0, ..., config.vocab_size] 中的标记计算。
  • head_mask (torch.FloatTensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 用于置零自注意力模块中选定头的掩码。掩码值选自 [0, 1]

    • 1 表示头未被掩码
    • 0 表示头已被掩码
  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,你可以选择直接传递嵌入表示,而不是传递 input_ids。如果你想比模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为相关向量,这会很有用。
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.luke.modeling_luke.LukeMaskedLMOutputtuple(torch.FloatTensor)

一个 transformers.models.luke.modeling_luke.LukeMaskedLMOutput 或一个 torch.FloatTensor 的元组 (如果传递了 return_dict=Falseconfig.return_dict=False),根据配置 (LukeConfig) 和输入包含各种元素。

  • loss (torch.FloatTensor,形状为 (1,)可选,当提供 labels 时返回) — 掩码语言建模 (MLM) 损失和实体预测损失的总和。

  • mlm_loss (torch.FloatTensor,形状为 (1,)可选,当提供 labels 时返回) — 掩码语言建模 (MLM) 损失。

  • mep_loss (torch.FloatTensor,形状为 (1,)可选,当提供 labels 时返回) — 掩码实体预测 (MEP) 损失。

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

  • entity_logits (torch.FloatTensor,形状为 (batch_size, sequence_length, config.vocab_size)) — 实体预测头的预测分数(SoftMax 前每个实体词汇标记的分数)。

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

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

  • entity_hidden_states (tuple(torch.FloatTensor)可选,当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(一个用于嵌入层的输出 + 一个用于每层的输出),形状为 (batch_size, entity_length, hidden_size)。模型每层输出的实体隐藏状态加上初始实体嵌入输出。

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

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

LukeForMaskedLM 的 forward 方法会覆盖 __call__ 特殊方法。

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

示例

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

< >

( config )

参数

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

带有分类头的 LUKE 模型(在第一个实体标记的隐藏状态之上加一个线性层),用于实体分类任务,例如 Open Entity。

此模型继承自 PreTrainedModel。请查阅超类文档,了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。

此模型也是 PyTorch 的 torch.nn.Module 子类。可以像常规 PyTorch Module 一样使用它,并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None entity_ids: typing.Optional[torch.LongTensor] = None entity_attention_mask: typing.Optional[torch.FloatTensor] = None entity_token_type_ids: typing.Optional[torch.LongTensor] = None entity_position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.models.luke.modeling_luke.EntityClassificationOutputtuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

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

    • 1 表示标记未被掩码
    • 0 表示标记已被掩码

    什么是注意力掩码?

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

    • 0 对应于 *句子 A* 的标记,
    • 1 对应于 *句子 B* 的标记。

    什么是标记类型 ID?

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

    什么是位置 ID?

  • entity_ids (torch.LongTensor,形状为 (batch_size, entity_length)) — 实体词汇表中实体标记的索引。

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

  • entity_attention_mask (torch.FloatTensor,形状为 (batch_size, entity_length), 可选) — 用于避免对填充的实体词元索引执行注意力操作的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示实体词元未被掩码
    • 0 表示实体词元被掩码
  • entity_token_type_ids (torch.LongTensor,形状为 (batch_size, entity_length), 可选) — 段词元索引,用于指示实体词元输入的第一部分和第二部分。索引在 [0, 1] 中选择:

    • 0 对应于 A 部分 的实体词元,
    • 1 对应于 B 部分 的实体词元。
  • entity_position_ids (torch.LongTensor,形状为 (batch_size, entity_length, max_mention_length), 可选) — 每个输入实体在位置嵌入中的位置索引。在 [0, config.max_position_embeddings - 1] 范围内选择。
  • head_mask (torch.FloatTensor,形状为 (num_heads,)(num_layers, num_heads), 可选) — 用于置零自注意力模块中选定头的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示头未被掩码
    • 0 表示头被掩码
  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地,你可以不传递 input_ids,而是直接传递嵌入表示。如果你想比模型内部的嵌入查找矩阵有更多控制权来将 input_ids 索引转换为相关向量,这将非常有用。
  • labels (torch.LongTensor,形状为 (batch_size,)(batch_size, num_labels), 可选) — 用于计算分类损失的标签。如果形状是 (batch_size,),则使用交叉熵损失进行单标签分类。在这种情况下,标签应包含在 [0, ..., config.num_labels - 1] 范围内的索引。如果形状是 (batch_size, num_labels),则使用二元交叉熵损失进行多标签分类。在这种情况下,标签应只包含 [0, 1],其中 0 和 1 分别表示假和真。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.models.luke.modeling_luke.EntityClassificationOutputtuple(torch.FloatTensor)

一个 transformers.models.luke.modeling_luke.EntityClassificationOutput 或一个 torch.FloatTensor 的元组(如果传递了 return_dict=Falseconfig.return_dict=False),根据配置 (LukeConfig) 和输入,包含不同的元素。

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

  • logits (torch.FloatTensor,形状为 (batch_size, config.num_labels)) — 分类分数(在 SoftMax 之前)。

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

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

  • entity_hidden_states (tuple(torch.FloatTensor)可选,当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(一个用于嵌入层的输出 + 一个用于每层的输出),形状为 (batch_size, entity_length, hidden_size)。模型每层输出的实体隐藏状态加上初始实体嵌入输出。

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

    注意力 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 (LukeForEntityPairClassification) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重,只会加载配置。请查看 from_pretrained() 方法来加载模型权重。

带有分类头的 LUKE 模型(在两个实体词元的隐藏状态之上有一个线性层),用于实体对分类任务,例如 TACRED。

此模型继承自 PreTrainedModel。请查阅超类文档,了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。

此模型也是 PyTorch 的 torch.nn.Module 子类。可以像常规 PyTorch Module 一样使用它,并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None entity_ids: typing.Optional[torch.LongTensor] = None entity_attention_mask: typing.Optional[torch.FloatTensor] = None entity_token_type_ids: typing.Optional[torch.LongTensor] = None entity_position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.models.luke.modeling_luke.EntityPairClassificationOutputtuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

  • attention_mask (torch.FloatTensor,形状为 (batch_size, sequence_length), 可选) — 用于避免对填充的词元索引执行注意力操作的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示词元未被掩码
    • 0 表示词元被掩码

    什么是注意力掩码?

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

    • 0 对应于 句子 A 的词元,
    • 1 对应于 句子 B 的词元。

    什么是词元类型 ID?

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

    什么是位置 ID?

  • entity_ids (torch.LongTensor,形状为 (batch_size, entity_length)) — 实体词汇表中实体词元的索引。

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

  • entity_attention_mask (torch.FloatTensor,形状为 (batch_size, entity_length), 可选) — 用于避免对填充的实体词元索引执行注意力操作的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示实体词元未被掩码
    • 0 表示实体词元被掩码
  • entity_token_type_ids (torch.LongTensor,形状为 (batch_size, entity_length), 可选) — 段词元索引,用于指示实体词元输入的第一部分和第二部分。索引在 [0, 1] 中选择:

    • 0 对应于 A 部分 的实体词元,
    • 1 对应于 B 部分 的实体词元。
  • entity_position_ids (torch.LongTensor,形状为 (batch_size, entity_length, max_mention_length), 可选) — 每个输入实体在位置嵌入中的位置索引。在 [0, config.max_position_embeddings - 1] 范围内选择。
  • head_mask (torch.FloatTensor,形状为 (num_heads,)(num_layers, num_heads), 可选) — 用于置零自注意力模块中选定头的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示头未被掩码
    • 0 表示头被掩码
  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地,你可以不传递 input_ids,而是直接传递嵌入表示。如果你想比模型内部的嵌入查找矩阵有更多控制权来将 input_ids 索引转换为相关向量,这将非常有用。
  • labels (torch.LongTensor,形状为 (batch_size,)(batch_size, num_labels), 可选) — 用于计算分类损失的标签。如果形状是 (batch_size,),则使用交叉熵损失进行单标签分类。在这种情况下,标签应包含在 [0, ..., config.num_labels - 1] 范围内的索引。如果形状是 (batch_size, num_labels),则使用二元交叉熵损失进行多标签分类。在这种情况下,标签应只包含 [0, 1],其中 0 和 1 分别表示假和真。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.models.luke.modeling_luke.EntityPairClassificationOutputtuple(torch.FloatTensor)

一个 transformers.models.luke.modeling_luke.EntityPairClassificationOutput 或一个 torch.FloatTensor 的元组(如果传递了 return_dict=Falseconfig.return_dict=False),根据配置 (LukeConfig) 和输入,包含不同的元素。

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

  • logits (torch.FloatTensor,形状为 (batch_size, config.num_labels)) — 分类分数(在 SoftMax 之前)。

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

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

  • entity_hidden_states (tuple(torch.FloatTensor)可选,当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(一个用于嵌入层的输出 + 一个用于每层的输出),形状为 (batch_size, entity_length, hidden_size)。模型每层输出的实体隐藏状态加上初始实体嵌入输出。

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

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

LukeForEntityPairClassification 的前向方法重写了 __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 (LukeForEntitySpanClassification) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重,只会加载配置。请查看 from_pretrained() 方法来加载模型权重。

带有跨度分类头的 LUKE 模型(在隐藏状态输出之上有一个线性层),用于命名实体识别等任务。

此模型继承自 PreTrainedModel。请查阅超类文档,了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。

此模型也是 PyTorch 的 torch.nn.Module 子类。可以像常规 PyTorch Module 一样使用它,并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None entity_ids: typing.Optional[torch.LongTensor] = None entity_attention_mask: typing.Optional[torch.LongTensor] = None entity_token_type_ids: typing.Optional[torch.LongTensor] = None entity_position_ids: typing.Optional[torch.LongTensor] = None entity_start_positions: typing.Optional[torch.LongTensor] = None entity_end_positions: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.models.luke.modeling_luke.EntitySpanClassificationOutputtuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

  • attention_mask (torch.FloatTensor,形状为 (batch_size, sequence_length), 可选) — 用于避免对填充的词元索引执行注意力操作的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示词元未被掩码
    • 0 表示词元被掩码

    什么是注意力掩码?

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

    • 0 对应于 句子 A 的词元,
    • 1 对应于 句子 B 的词元。

    什么是词元类型 ID?

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

    什么是位置 ID?

  • entity_ids (torch.LongTensor,形状为 (batch_size, entity_length)) — 实体词汇表中实体词元的索引。

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

  • entity_attention_mask (torch.FloatTensor,形状为 (batch_size, entity_length), 可选) — 用于避免对填充的实体词元索引执行注意力操作的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示实体词元未被掩码
    • 0 表示实体词元被掩码
  • entity_token_type_ids (torch.LongTensor,形状为 (batch_size, entity_length), 可选) — 段词元索引,用于指示实体词元输入的第一部分和第二部分。索引在 [0, 1] 中选择:

    • 0 对应于 A 部分 的实体词元,
    • 1 对应于 B 部分 的实体词元。
  • entity_position_ids (torch.LongTensor,形状为 (batch_size, entity_length, max_mention_length), 可选) — 每个输入实体在位置嵌入中的位置索引。在 [0, config.max_position_embeddings - 1] 范围内选择。
  • entity_start_positions (torch.LongTensor, 可选) — 词元序列中实体的起始位置。
  • entity_end_positions (torch.LongTensor, 可选) — 词元序列中实体的结束位置。
  • head_mask (torch.FloatTensor,形状为 (num_heads,)(num_layers, num_heads), 可选) — 用于置零自注意力模块中选定头的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示头未被掩码
    • 0 表示头被掩码
  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地,你可以不传递 input_ids,而是直接传递嵌入表示。如果你想比模型内部的嵌入查找矩阵有更多控制权来将 input_ids 索引转换为相关向量,这将非常有用。
  • 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 分别表示假和真。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.models.luke.modeling_luke.EntitySpanClassificationOutputtuple(torch.FloatTensor)

一个 transformers.models.luke.modeling_luke.EntitySpanClassificationOutput 或一个 torch.FloatTensor 的元组(如果传递了 return_dict=Falseconfig.return_dict=False),根据配置 (LukeConfig) 和输入,包含不同的元素。

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

  • logits (torch.FloatTensor,形状为 (batch_size, entity_length, config.num_labels)) — 分类分数(在 SoftMax 之前)。

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

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

  • entity_hidden_states (tuple(torch.FloatTensor)可选,当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(一个用于嵌入层的输出 + 一个用于每层的输出),形状为 (batch_size, entity_length, hidden_size)。模型每层输出的实体隐藏状态加上初始实体嵌入输出。

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

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

LukeForEntitySpanClassification 的前向方法重写了 __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 (LukeForSequenceClassification) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重,只会加载配置。请查看 from_pretrained() 方法来加载模型权重。

带有序列分类/回归头的 LUKE 模型转换器(在池化输出之上有一个线性层),例如用于 GLUE 任务。

此模型继承自 PreTrainedModel。请查阅超类文档,了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。

此模型也是 PyTorch 的 torch.nn.Module 子类。可以像常规 PyTorch Module 一样使用它,并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None entity_ids: typing.Optional[torch.LongTensor] = None entity_attention_mask: typing.Optional[torch.FloatTensor] = None entity_token_type_ids: typing.Optional[torch.LongTensor] = None entity_position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.models.luke.modeling_luke.LukeSequenceClassifierOutputtuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

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

    • 1 表示标记未被遮盖
    • 0 表示标记被遮盖

    什么是注意力掩码?

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

    • 0 对应于 句子 A 的标记,
    • 1 对应于 句子 B 的标记。

    什么是标记类型 ID?

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

    什么是位置 ID?

  • entity_ids (torch.LongTensor,形状为 (batch_size, entity_length)) — 实体词汇表中实体标记的索引。

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

  • entity_attention_mask (torch.FloatTensor,形状为 (batch_size, entity_length), 可选) — 用于避免对填充实体标记索引执行注意力的掩码。掩码值选自 [0, 1]

    • 1 表示实体标记未被遮盖
    • 0 表示实体标记被遮盖
  • entity_token_type_ids (torch.LongTensor,形状为 (batch_size, entity_length), 可选) — 用于指示实体标记输入的第一和第二部分的段标记索引。索引选自 [0, 1]

    • 0 对应于 A 部分 的实体标记,
    • 1 对应于 B 部分 的实体标记。
  • entity_position_ids (torch.LongTensor,形状为 (batch_size, entity_length, max_mention_length), 可选) — 每个输入实体在位置嵌入中的位置索引。选自范围 [0, config.max_position_embeddings - 1]
  • head_mask (torch.FloatTensor,形状为 (num_heads,)(num_layers, num_heads), 可选) — 用于使自注意力模块的选定头无效的掩码。掩码值选自 [0, 1]

    • 1 表示头未被遮盖
    • 0 表示头被遮盖
  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size), 可选) — 可以选择直接传递嵌入表示,而不是传递 input_ids。如果你想比模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量,这会很有用。
  • 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 而不是普通的元组。

返回

transformers.models.luke.modeling_luke.LukeSequenceClassifierOutputtuple(torch.FloatTensor)

一个 transformers.models.luke.modeling_luke.LukeSequenceClassifierOutput 或一个 torch.FloatTensor 元组(如果传递 return_dict=Falseconfig.return_dict=False),包含各种元素,具体取决于配置(LukeConfig)和输入。

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

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

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

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

  • entity_hidden_states (tuple(torch.FloatTensor)可选,当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(一个用于嵌入层的输出 + 一个用于每层的输出),形状为 (batch_size, entity_length, hidden_size)。模型每层输出的实体隐藏状态加上初始实体嵌入输出。

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

    注意力 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()
>>> 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).loss

LukeForMultipleChoice

class transformers.LukeForMultipleChoice

< >

( config )

参数

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

带有选择题分类头的 Luke 模型(在池化输出之上有一个线性层和一个 softmax),例如用于 RocStories/SWAG 任务。

此模型继承自 PreTrainedModel。请查阅超类文档,了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。

此模型也是 PyTorch 的 torch.nn.Module 子类。可以像常规 PyTorch Module 一样使用它,并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None entity_ids: typing.Optional[torch.LongTensor] = None entity_attention_mask: typing.Optional[torch.FloatTensor] = None entity_token_type_ids: typing.Optional[torch.LongTensor] = None entity_position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.models.luke.modeling_luke.LukeMultipleChoiceModelOutputtuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

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

    • 1 表示标记未被遮盖
    • 0 表示标记被遮盖

    什么是注意力掩码?

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

    • 0 对应于 句子 A 的标记,
    • 1 对应于 句子 B 的标记。

    什么是标记类型 ID?

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

    什么是位置 ID?

  • entity_ids (torch.LongTensor,形状为 (batch_size, entity_length)) — 实体词汇表中实体标记的索引。

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

  • entity_attention_mask (torch.FloatTensor,形状为 (batch_size, entity_length), 可选) — 用于避免对填充实体标记索引执行注意力的掩码。掩码值选自 [0, 1]

    • 1 表示实体标记未被遮盖
    • 0 表示实体标记被遮盖
  • entity_token_type_ids (torch.LongTensor,形状为 (batch_size, entity_length), 可选) — 用于指示实体标记输入的第一和第二部分的段标记索引。索引选自 [0, 1]

    • 0 对应于 A 部分 的实体标记,
    • 1 对应于 B 部分 的实体标记。
  • entity_position_ids (torch.LongTensor,形状为 (batch_size, entity_length, max_mention_length), 可选) — 每个输入实体在位置嵌入中的位置索引。选自范围 [0, config.max_position_embeddings - 1]
  • head_mask (torch.FloatTensor,形状为 (num_heads,)(num_layers, num_heads), 可选) — 用于使自注意力模块的选定头无效的掩码。掩码值选自 [0, 1]

    • 1 表示头未被遮盖
    • 0 表示头被遮盖
  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, num_choices, sequence_length, hidden_size), 可选) — 可以选择直接传递嵌入表示,而不是传递 input_ids。如果你想比模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量,这会很有用。
  • labels (torch.LongTensor,形状为 (batch_size,), 可选) — 用于计算选择题分类损失的标签。索引应在 [0, ..., num_choices-1] 范围内,其中 num_choices 是输入张量第二维的大小。(见上面的 input_ids
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。

返回

transformers.models.luke.modeling_luke.LukeMultipleChoiceModelOutputtuple(torch.FloatTensor)

一个 transformers.models.luke.modeling_luke.LukeMultipleChoiceModelOutput 或一个 torch.FloatTensor 元组(如果传递 return_dict=Falseconfig.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=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于每层的输出),形状为 (batch_size, sequence_length, hidden_size)

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

  • entity_hidden_states (tuple(torch.FloatTensor)可选,当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(一个用于嵌入层的输出 + 一个用于每层的输出),形状为 (batch_size, entity_length, hidden_size)。模型每层输出的实体隐藏状态加上初始实体嵌入输出。

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

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

LukeForMultipleChoice 的前向方法会覆盖 __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

class transformers.LukeForTokenClassification

< >

( config )

参数

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

带有标记分类头的 LUKE 模型(在隐藏状态输出之上有一个线性层)。要使用 LUKE 解决命名实体识别(NER)任务,`LukeForEntitySpanClassification` 比这个类更合适。

此模型继承自 PreTrainedModel。请查阅超类文档,了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。

此模型也是 PyTorch 的 torch.nn.Module 子类。可以像常规 PyTorch Module 一样使用它,并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None entity_ids: typing.Optional[torch.LongTensor] = None entity_attention_mask: typing.Optional[torch.FloatTensor] = None entity_token_type_ids: typing.Optional[torch.LongTensor] = None entity_position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.models.luke.modeling_luke.LukeTokenClassifierOutputtuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

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

    • 1 表示标记未被遮盖
    • 0 表示标记被遮盖

    什么是注意力掩码?

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

    • 0 对应于 句子 A 的标记,
    • 1 对应于 句子 B 的标记。

    什么是标记类型 ID?

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

    什么是位置 ID?

  • entity_ids (torch.LongTensor,形状为 (batch_size, entity_length)) — 实体词汇表中实体标记的索引。

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

  • entity_attention_mask (torch.FloatTensor,形状为 (batch_size, entity_length), 可选) — 用于避免对填充实体标记索引执行注意力的掩码。掩码值选自 [0, 1]

    • 1 表示实体标记未被遮盖
    • 0 表示实体标记被遮盖
  • entity_token_type_ids (torch.LongTensor,形状为 (batch_size, entity_length)可选) — 用于指示实体词元输入第一部分和第二部分的片段词元索引。索引在 [0, 1] 中选择:

    • 0 对应于 A 部分 实体词元,
    • 1 对应于 B 部分 实体词元。
  • entity_position_ids (torch.LongTensor,形状为 (batch_size, entity_length, max_mention_length)可选) — 每个输入实体在位置嵌入中的位置索引。在 [0, config.max_position_embeddings - 1] 范围内选择。
  • head_mask (torch.FloatTensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 用于将自注意力模块中选定的头置为无效的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示头未被掩码
    • 0 表示头被掩码
  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,你可以选择直接传递嵌入表示,而不是传递 input_ids。如果你想比模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为相关向量,这会非常有用。
  • labels (torch.LongTensor,形状为 (batch_size,)可选) — 用于计算多项选择分类损失的标签。索引应在 [0, ..., num_choices-1] 范围内,其中 num_choices 是输入张量第二维的大小。(参见上面的 input_ids
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.models.luke.modeling_luke.LukeTokenClassifierOutputtuple(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=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于每层的输出),形状为 (batch_size, sequence_length, hidden_size)

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

  • entity_hidden_states (tuple(torch.FloatTensor)可选,当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(一个用于嵌入层的输出 + 一个用于每层的输出),形状为 (batch_size, entity_length, hidden_size)。模型每层输出的实体隐藏状态加上初始实体嵌入输出。

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

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

LukeForTokenClassification 的 forward 方法会覆盖 __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]]
>>> predicted_tokens_classes
...

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

LukeForQuestionAnswering

class transformers.LukeForQuestionAnswering

< >

( config )

参数

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

Luke transformer,其顶部带有一个跨度分类头,用于处理如 SQuAD 这类抽取式问答任务(在隐藏状态输出之上是一个线性层,用于计算 span start logitsspan end logits)。

此模型继承自 PreTrainedModel。请查阅超类文档,了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。

此模型也是 PyTorch 的 torch.nn.Module 子类。可以像常规 PyTorch Module 一样使用它,并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.FloatTensor] = None entity_ids: typing.Optional[torch.LongTensor] = None entity_attention_mask: typing.Optional[torch.FloatTensor] = None entity_token_type_ids: typing.Optional[torch.LongTensor] = None entity_position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None start_positions: typing.Optional[torch.LongTensor] = None end_positions: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.models.luke.modeling_luke.LukeQuestionAnsweringModelOutputtuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

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

    • 1 表示词元未被掩码
    • 0 表示词元被掩码

    什么是注意力掩码?

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

    • 0 对应于 句子 A 词元,
    • 1 对应于 句子 B 词元。

    什么是词元类型 ID?

  • position_ids (torch.FloatTensor,形状为 (batch_size, sequence_length)可选) — 每个输入序列词元在位置嵌入中的位置索引。在 [0, config.n_positions - 1] 范围内选择。

    什么是位置 ID?

  • entity_ids (torch.LongTensor,形状为 (batch_size, entity_length)) — 实体词汇表中实体词元的索引。

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

  • entity_attention_mask (torch.FloatTensor,形状为 (batch_size, entity_length)可选) — 用于避免对填充实体词元索引执行注意力的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示实体词元未被掩码
    • 0 表示实体词元被掩码
  • entity_token_type_ids (torch.LongTensor,形状为 (batch_size, entity_length)可选) — 用于指示实体词元输入第一部分和第二部分的片段词元索引。索引在 [0, 1] 中选择:

    • 0 对应于 A 部分 实体词元,
    • 1 对应于 B 部分 实体词元。
  • entity_position_ids (torch.LongTensor,形状为 (batch_size, entity_length, max_mention_length)可选) — 每个输入实体在位置嵌入中的位置索引。在 [0, config.max_position_embeddings - 1] 范围内选择。
  • head_mask (torch.FloatTensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 用于将自注意力模块中选定的头置为无效的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示头未被掩码
    • 0 表示头被掩码
  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,你可以选择直接传递嵌入表示,而不是传递 input_ids。如果你想比模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为相关向量,这会非常有用。
  • start_positions (torch.LongTensor,形状为 (batch_size,)可选) — 标记的跨度开始位置(索引)的标签,用于计算词元分类损失。位置被限制在序列长度(sequence_length)内。序列之外的位置在计算损失时不予考虑。
  • end_positions (torch.LongTensor,形状为 (batch_size,)可选) — 标记的跨度结束位置(索引)的标签,用于计算词元分类损失。位置被限制在序列长度(sequence_length)内。序列之外的位置在计算损失时不予考虑。
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.models.luke.modeling_luke.LukeQuestionAnsweringModelOutputtuple(torch.FloatTensor)

一个 transformers.models.luke.modeling_luke.LukeQuestionAnsweringModelOutput 或一个 torch.FloatTensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),根据配置(LukeConfig)和输入,包含各种元素。

  • loss (torch.FloatTensor of shape (1,), 可选, 当提供 labels 时返回) — 总范围提取损失是起始位置和结束位置的交叉熵之和。

  • start_logits (torch.FloatTensor,形状为 (batch_size, sequence_length)可选,默认为 None) — 跨度开始分数(SoftMax 之前)。

  • end_logits (torch.FloatTensor,形状为 (batch_size, sequence_length)可选,默认为 None) — 跨度结束分数(SoftMax 之前)。

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

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

  • entity_hidden_states (tuple(torch.FloatTensor)可选,当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(一个用于嵌入层的输出 + 一个用于每层的输出),形状为 (batch_size, entity_length, hidden_size)。模型每层输出的实体隐藏状态加上初始实体嵌入输出。

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

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

LukeForQuestionAnswering 的 forward 方法会覆盖 __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]
>>> 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)
...
< > 在 GitHub 上更新