Transformers 4.37 中文文档（四十一）（3）

Transformers 4.37 中文文档（四十一）（2）https://developer.aliyun.com/article/1565234

FlaxLongT5ForConditionalGeneration

class transformers.FlaxLongT5ForConditionalGeneration

< source >

( config: LongT5Config input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

__call__

< source >

( input_ids: Array attention_mask: Optional = None decoder_input_ids: Array = None decoder_attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的jnp.ndarray）- 词汇表中输入序列标记的索引。LongT5 是一个具有相对位置嵌入的模型，因此您应该能够在右侧和左侧都填充输入。
  可以使用 AutoTokenizer 获取索引。详细信息请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  了解如何为预训练准备input_ids，请查看 LONGT5 Training。
  
• attention_mask（形状为(batch_size, sequence_length)的jnp.ndarray，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

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

• 什么是注意力掩码？
  
• decoder_input_ids（形状为(batch_size, target_sequence_length)的jnp.ndarray，可选）- 词汇表中解码器输入序列标记的索引。
  可以使用 AutoTokenizer 获取索引。详细信息请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是解码器输入 ID？
  LONGT5 使用pad_token_id作为decoder_input_ids生成的起始标记。如果使用了past_key_values，可选择只需输入最后的decoder_input_ids（查看past_key_values）。
  了解如何为预训练准备decoder_input_ids，请查看 LONGT5 Training。
  
• decoder_attention_mask（形状为(batch_size, target_sequence_length)的jnp.ndarray，可选）- 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果膜也将默认使用。
  
• encoder_outputs（tuple(tuple(jnp.ndarray)，可选）- 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  
• past_key_values（长度为config.n_layers的tuple(tuple(jnp.ndarray))，每个元组有 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的张量）- 包含注意力块的预先计算的键和值隐藏状态。可用于加速解码。
  如果使用了past_key_values，用户可以选择性地只输入最后一个形状为(batch_size, 1)的decoder_input_ids（那些没有将它们的过去键值状态提供给该模型的输入），而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
  

返回

transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或tuple(torch.FloatTensor)

transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包括根据配置（LongT5Config）和输入的不同元素。

• logits（形状为(batch_size, sequence_length, config.vocab_size)的jnp.ndarray）- 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  
• past_key_values（tuple(tuple(jnp.ndarray))，可选，当传递use_cache=True或config.use_cache=True时返回）- 长度为config.n_layers的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。
  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值）可以用（参见past_key_values输入）加速顺序解码。
  
• decoder_hidden_states（tuple(jnp.ndarray)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 元组包括（嵌入输出的输出+每层输出的输出）的jnp.ndarray（每层一个）的形状为(batch_size, sequence_length, hidden_size)。
  解码器在每一层输出的隐藏状态以及初始嵌入输出。
  
• decoder_attentions（tuple(jnp.ndarray)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。
  解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  
• cross_attentions（tuple(jnp.ndarray)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。
  解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  
• encoder_last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray，可选）- 模型编码器最后一层的隐藏状态序列。
  
• encoder_hidden_states（tuple(jnp.ndarray)，可选，当传递output_hidden_states=True或者当config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入输出，一个用于每一层的输出）。
  编码器在每一层输出的隐藏状态加上初始嵌入输出。
  
• encoder_attentions（tuple(jnp.ndarray)，可选，当传递output_attentions=True或者当config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。
  编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  

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

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

示例：

>>> from transformers import AutoTokenizer, FlaxLongT5ForConditionalGeneration
>>> tokenizer = AutoTokenizer.from_pretrained("t5-base")
>>> model = FlaxLongT5ForConditionalGeneration.from_pretrained("google/long-t5-local-base")
>>> ARTICLE_TO_SUMMARIZE = "summarize: My friends are cool but they eat too many carbs."
>>> inputs = tokenizer([ARTICLE_TO_SUMMARIZE], return_tensors="np")
>>> # Generate Summary
>>> summary_ids = model.generate(inputs["input_ids"]).sequences
>>> print(tokenizer.decode(summary_ids[0], skip_special_tokens=True, clean_up_tokenization_spaces=False))

encode

< source >

( input_ids: Array attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxBaseModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的jnp.ndarray） — 词汇表中输入序列标记的索引。LongT5 是一个带有相对位置嵌入的模型，因此您应该能够在右侧和左侧都填充输入。
  可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。
  要了解有关如何为预训练准备input_ids的更多信息，请查看长 T5 训练。
  
• attention_mask（形状为(batch_size, sequence_length)的jnp.ndarray，可选） — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]范围内：

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

• 什么是注意力掩码？
  
• output_attentions（bool，可选） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回张量下的attentions。
  
• output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的hidden_states。
  
• return_dict（bool，可选） — 是否返回一个 ModelOutput 而不是一个普通元组。
  

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutput 或者tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或者一个torch.FloatTensor元组（如果传递了return_dict=False或者当config.return_dict=False时）包括各种元素，取决于配置（）和输入。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray） — 模型最后一层的隐藏状态序列。
  
• hidden_states（tuple(jnp.ndarray)，可选，当传递output_hidden_states=True或者当config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入输出，一个用于每一层的输出）。
  模型每一层的隐藏状态加上初始嵌入输出。
  
• attentions (tuple(jnp.ndarray), optional, 当传递 output_attentions=True 或者 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 jnp.ndarray 元组（每层一个）。
  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
  

示例：

>>> from transformers import AutoTokenizer, FlaxLongT5ForConditionalGeneration
>>> tokenizer = AutoTokenizer.from_pretrained("t5-base")
>>> model = FlaxLongT5ForConditionalGeneration.from_pretrained("google/long-t5-local-base")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)

decode

< source >

( decoder_input_ids encoder_outputs encoder_attention_mask: Optional = None decoder_attention_mask: Optional = None past_key_values: dict = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

• decoder_input_ids (jnp.ndarray 形状为 (batch_size, target_sequence_length)) — 词汇表中解码器输入序列标记的索引。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
  什么是解码器输入 ID？
  对于训练，应提供 decoder_input_ids。
  
• encoder_outputs (tuple(tuple(jnp.ndarray)) — 元组包括 (last_hidden_state, optional: hidden_states, optional: attentions) last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，optional) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  
• encoder_attention_mask (jnp.ndarray 形状为 (batch_size, sequence_length)，optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1]：

• 1 代表 未被掩码 的标记，
  
• 0 代表 被掩码 的标记。
  

• 什么是注意力掩码？
  
• decoder_attention_mask (jnp.ndarray 形状为 (batch_size, target_sequence_length)，optional) — 默认行为：生成一个忽略 decoder_input_ids 中填充标记的张量。因果掩码也将默认使用。
  如果要更改填充行为，应根据需要进行修改。有关默认策略的更多信息，请参见 论文 中的图表 1。
  
• past_key_values (Dict[str, np.ndarray], optional, 由 init_cache 返回或传递先前的 past_key_values 时返回) — 预先计算的隐藏状态字典（注意力块中的键和值），可用于快速自回归解码。预先计算的键和值隐藏状态的形状为 [batch_size, max_length]。
  
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 attentions。
  
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
  
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
  

返回

transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)

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

• logits（形状为(batch_size, sequence_length, config.vocab_size)的jnp.ndarray）- 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  
• hidden_states（tuple(jnp.ndarray)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出，一个用于每个层的输出）。
  模型在每一层输出的隐藏状态以及初始嵌入输出。
  
• attentions（tuple(jnp.ndarray)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。
  在自注意力头中用于计算加权平均的注意力权重 softmax 后的值。
  
• cross_attentions（tuple(jnp.ndarray)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。
  在交叉注意力头中用于计算加权平均的注意力权重 softmax 后的值。
  
• past_key_values（tuple(tuple(jnp.ndarray))，可选，当传递use_cache=True或config.use_cache=True时返回）- 长度为config.n_layers的jnp.ndarray元组的元组，每个元组包含自注意力和交叉注意力层的缓存键、值状态，如果模型在编码器-解码器设置中使用，则相关。仅在config.is_decoder = True时相关。
  包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码。
  

示例：

>>> from transformers import AutoTokenizer, FlaxLongT5ForConditionalGeneration
>>> import jax.numpy as jnp
>>> tokenizer = AutoTokenizer.from_pretrained("t5-base")
>>> model = FlaxLongT5ForConditionalGeneration.from_pretrained("google/long-t5-local-base")
>>> text = "summarize: My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)
>>> decoder_start_token_id = model.config.decoder_start_token_id
>>> decoder_input_ids = jnp.ones((inputs.input_ids.shape[0], 1), dtype="i4") * decoder_start_token_id
>>> outputs = model.decode(decoder_input_ids, encoder_outputs)
>>> logits = outputs.logits

卢克

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/luke

概述

LUKE 模型是由 Ikuya Yamada、Akari Asai、Hiroyuki Shindo、Hideaki Takeda 和 Yuji Matsumoto 在LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention中提出的。它基于 RoBERTa，并添加了实体嵌入以及实体感知自注意机制，有助于提高在涉及推理实体的各种下游任务上的性能，如命名实体识别、提取式和填空式问答、实体类型划分和关系分类。

以下是论文摘要：

*实体表示在涉及实体的自然语言任务中非常有用。在本文中，我们提出了基于双向变换器的新的预训练上下文化单词和实体表示。所提出的模型将给定文本中的单词和实体视为独立标记，并输出它们的上下文化表示。我们的模型使用基于  BERT  的遮蔽语言模型的新预训练任务进行训练。该任务涉及在从维基百科检索的大型实体注释语料库中预测随机屏蔽的单词和实体。我们还提出了一种实体感知自注意机制，它是变换器自注意机制的扩展，并在计算注意力分数时考虑标记类型（单词或实体）。所提出的模型在广泛的与实体相关任务上取得了令人印象深刻的实证性表现。特别是，在五个知名数据集上取得了最新成果：Open  Entity（实体类型划分）、TACRED（关系分类）、CoNLL-2003（命名实体识别）、ReCoRD（填空式问答）和 SQuAD  1.1（提取式问答）。

此模型由ikuyamada和nielsr贡献。原始代码可在此处找到。

使用提示

• 此实现与 RobertaModel 相同，只是添加了实体嵌入以及实体感知自注意机制，从而提高了在涉及推理实体的任务中的性能。
  
• LUKE 将实体视为输入标记；因此，它接受entity_ids、entity_attention_mask、entity_token_type_ids和entity_position_ids作为额外输入。您可以使用 LukeTokenizer 来获取这些信息。
  
• LukeTokenizer 接受entities和entity_spans（实体在输入文本中基于字符的起始和结束位置）作为额外输入。entities通常包括[MASK]实体或维基百科实体。输入这些实体时的简要描述如下：

• 输入[MASK]实体以计算实体表示：[MASK]实体用于在预训练期间屏蔽待预测的实体。当 LUKE 接收到[MASK]实体时，它会尝试通过从输入文本中收集有关实体的信息来预测原始实体。因此，[MASK]实体可用于处理需要文本中实体信息的下游任务，如实体类型划分、关系分类和命名实体识别。
  
• 输入维基百科实体以计算知识增强的令牌表示：LUKE 在预训练期间学习关于维基百科实体的丰富信息（或知识），并将信息存储在其实体嵌入中。通过使用维基百科实体作为输入令牌，LUKE 输出由这些实体嵌入中存储的信息丰富的令牌表示。这对于需要现实世界知识的任务（如问答）特别有效。
  

• 前一用例有三个头模型：

• 用于实体分类的 LukeForEntityClassification，用于对输入文本中的单个实体进行分类，例如实体类型标注，例如Open Entity 数据集。该模型在输出实体表示上放置了一个线性头。
  
• 用于实体对分类的 LukeForEntityPairClassification，用于对两个实体之间的关系进行分类，例如关系分类，例如TACRED 数据集。该模型在给定实体对的连接输出表示上放置了一个线性头。
  
• 用于实体跨度分类的 LukeForEntitySpanClassification，用于对实体跨度序列进行分类，例如命名实体识别（NER）。该模型在输出实体表示上放置了一个线性头。您可以通过将文本中的所有可能实体跨度输入到模型中来使用此模型来处理 NER。
  

• LukeTokenizer 有一个task参数，通过指定task="entity_classification"、task="entity_pair_classification"或task="entity_span_classification"，可以轻松地创建这些头模型的输入。请参考每个头模型的示例代码。
  

用法示例：

>>> from transformers import LukeTokenizer, LukeModel, LukeForEntityPairClassification
>>> model = LukeModel.from_pretrained("studio-ousia/luke-base")
>>> tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-base")
# Example 1: Computing the contextualized entity representation corresponding to the entity mention "Beyoncé"
>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [(0, 7)]  # character-based entity span corresponding to "Beyoncé"
>>> inputs = tokenizer(text, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt")
>>> outputs = model(**inputs)
>>> word_last_hidden_state = outputs.last_hidden_state
>>> entity_last_hidden_state = outputs.entity_last_hidden_state
# Example 2: Inputting Wikipedia entities to obtain enriched contextualized representations
>>> entities = [
...     "Beyoncé",
...     "Los Angeles",
... ]  # Wikipedia entity titles corresponding to the entity mentions "Beyoncé" and "Los Angeles"
>>> entity_spans = [(0, 7), (17, 28)]  # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
>>> inputs = tokenizer(text, entities=entities, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt")
>>> outputs = model(**inputs)
>>> word_last_hidden_state = outputs.last_hidden_state
>>> entity_last_hidden_state = outputs.entity_last_hidden_state
# Example 3: Classifying the relationship between two entities using LukeForEntityPairClassification head model
>>> model = LukeForEntityPairClassification.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
>>> tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
>>> entity_spans = [(0, 7), (17, 28)]  # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_idx = int(logits[0].argmax())
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])

Transformers 4.37 中文文档（四十一）（4）https://developer.aliyun.com/article/1565236