Transformer XL
此模型仅处于维护模式，因此我们不接受任何更改其代码的新 PR。此模型由于与 pickle.load 相关的安全问题而被弃用。
我们建议切换到更新的模型以提高安全性。
如果您仍然希望在实验中使用 TransfoXL，我们建议使用 Hub 检查点 并指定修订版本，以确保您从 Hub 下载安全文件。
您需要将环境变量 TRUST_REMOTE_CODE 设置为 True，以允许使用 pickle.load()
import os
from transformers import TransfoXLTokenizer, TransfoXLLMHeadModel
os.environ["TRUST_REMOTE_CODE"] = "True"
checkpoint = 'transfo-xl/transfo-xl-wt103'
revision = '40a186da79458c9f9de846edfaea79c412137f97'
tokenizer = TransfoXLTokenizer.from_pretrained(checkpoint, revision=revision)
model = TransfoXLLMHeadModel.from_pretrained(checkpoint, revision=revision)如果您在运行此模型时遇到任何问题，请重新安装支持此模型的最后一个版本：v4.35.0。您可以通过运行以下命令来执行此操作：pip install -U transformers==4.35.0。
概述
Transformer-XL 模型在 Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context 中提出，作者为 Zihang Dai、Zhilin Yang、Yiming Yang、Jaime Carbonell、Quoc V. Le、Ruslan Salakhutdinov。它是一个因果（单向）Transformer，具有相对位置（正弦）嵌入，可以重用先前计算的隐藏状态来关注更长的上下文（记忆）。此模型还使用自适应 softmax 输入和输出（绑定）。
该论文的摘要如下：
Transformer 有学习长期依赖的潜力，但在语言建模的设置中受到固定长度上下文的限制。我们提出了一种新颖的神经架构 Transformer-XL，它能够在不破坏时间连贯性的情况下学习超出固定长度的依赖。它由段级循环机制和新颖的位置编码方案组成。我们的方法不仅能够捕获更长期的依赖关系，而且还解决了上下文碎片化问题。因此，Transformer-XL 学习到的依赖关系比 RNN 长 80%，比原始 Transformer 长 450%，在短序列和长序列上都实现了更好的性能，并且在评估期间比原始 Transformer 快 1,800 多倍。值得注意的是，我们将 enwiki8 上的 bpc/困惑度、text8 上的 1.08、WikiText-103 上的 18.3、One Billion Word 上的 21.8 和 Penn Treebank 上的 54.5（无需微调）的最先进结果提高到了 0.99。当仅在 WikiText-103 上训练时，Transformer-XL 能够生成数千个 token 的相当连贯的新文本文章。
使用技巧
- Transformer-XL 使用相对正弦位置嵌入。可以在左侧或右侧进行填充。原始实现使用左侧填充在 SQuAD 上进行训练，因此填充默认设置为左侧。
- Transformer-XL 是少数几个没有序列长度限制的模型之一。
- 与常规 GPT 模型类似，但为两个连续的 segment 引入了循环机制（类似于具有两个连续输入的常规 RNN）。在此上下文中，segment 是指连续的 token 数量（例如 512 个），可能跨越多个文档，并且 segment 按顺序馈送到模型。
- 基本上，前一个 segment 的隐藏状态会与当前输入连接起来，以计算注意力分数。这使得模型能够关注前一个 segment 以及当前 segment 中的信息。通过堆叠多个注意力层，感受野可以扩展到多个之前的 segment。
- 这会将位置嵌入更改为位置相对嵌入（因为常规位置嵌入会在当前输入和给定位置的当前隐藏状态中给出相同的结果），并且需要在计算注意力分数的方式上进行一些调整。
由于 PyTorch 中的一个错误，TransformerXL 不适用于 torch.nn.DataParallel，请参阅 issue #36035
资源
TransfoXLConfig
class transformers.TransfoXLConfig
< source >( vocab_size = 267735 cutoffs = [20000, 40000, 200000] d_model = 1024 d_embed = 1024 n_head = 16 d_head = 64 d_inner = 4096 div_val = 4 pre_lnorm = False n_layer = 18 mem_len = 1600 clamp_len = 1000 same_length = True proj_share_all_but_first = True attn_type = 0 sample_softmax = -1 adaptive = True dropout = 0.1 dropatt = 0.0 untie_r = True init = 'normal' init_range = 0.01 proj_init_std = 0.01 init_std = 0.02 layer_norm_epsilon = 1e-05 eos_token_id = 0 **kwargs )
参数
- vocab_size (
int, 可选, 默认为 267735) — BERT 模型的词汇表大小。定义了在调用 TransfoXLModel 或 TFTransfoXLModel 时传递的inputs_ids可以表示的不同 token 的数量。 - cutoffs (
List[int], 可选, 默认为[20000, 40000, 200000]) — 自适应 softmax 的 cutoff 值。 - d_model (
int, 可选, 默认为 1024) — 模型隐藏状态的维度。 - d_embed (
int, 可选, 默认为 1024) — 嵌入的维度。 - n_head (
int, 可选, 默认为 16) — Transformer 编码器中每个注意力层的注意力头数。 - d_head (
int, 可选, 默认为 64) — 模型头的维度。 - d_inner (
int, 可选, 默认为 4096) — FF 中的内部维度。 - div_val (
int, 可选, 默认为 4) — 自适应输入和 softmax 的除数值。 - pre_lnorm (
boolean, 可选, 默认为False) — 是否对块中的输入而不是输出应用 LayerNorm。 - n_layer (
int, 可选, 默认为 18) — Transformer 编码器中隐藏层的数量。 - mem_len (
int, 可选, 默认为 1600) — 保留的先前头的长度。 - clamp_len (
int, 可选, 默认为 1000) — 在 clamp_len 之后使用相同的位置嵌入。 - same_length (
boolean, 可选, 默认为True) — 是否对所有 token 使用相同的注意力长度。 - proj_share_all_but_first (
boolean, 可选, 默认为True) — 如果为 True，则共享除第一个以外的所有 projs，如果为 False，则不共享。 - attn_type (
int, 可选, 默认为 0) — 注意力类型。0 代表 Transformer-XL，1 代表 Shaw 等人，2 代表 Vaswani 等人，3 代表 Al Rfou 等人。 - sample_softmax (
int, 可选, 默认为 -1) — 采样 softmax 中的样本数。 - adaptive (
boolean, 可选, 默认为True) — 是否使用自适应 softmax。 - dropout (
float, 可选, 默认为 0.1) — 嵌入层、编码器和池化层中所有全连接层的 dropout 概率。 - dropatt (
float, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。 - untie_r (
boolean, 可选, 默认为True) — 是否不对相对位置偏差进行解绑。 - init (
str, 可选, 默认为"normal") — 要使用的参数初始化器。 - init_range (
float, 可选, 默认为 0.01) — 由 U(-init_range, init_range) 初始化的参数。 - proj_init_std (
float, 可选, 默认为 0.01) — 由 N(0, init_std) 初始化的参数。 - init_std (
float, 可选, 默认为 0.02) — 由 N(0, init_std) 初始化的参数。 - layer_norm_epsilon (
float, optional, defaults to 1e-05) — 层归一化层中使用的 epsilon 值 (epsilon to use in the layer normalization layers) - eos_token_id (
int, optional, defaults to 0) — 流结束 token ID (End of stream token id).
This is the configuration class to store the configuration of a TransfoXLModel or a TFTransfoXLModel. 这是一个配置类，用于存储 TransfoXLModel 或 TFTransfoXLModel 的配置。 It is used to instantiate a Transformer-XL model according to the specified arguments, defining the model architecture. 它用于根据指定的参数实例化 Transformer-XL 模型，定义模型架构。 Instantiating a configuration with the defaults will yield a similar configuration to that of the TransfoXL transfo-xl/transfo-xl-wt103 architecture. 使用默认值实例化配置将产生与 TransfoXL transfo-xl/transfo-xl-wt103 架构类似的配置。
Configuration objects inherit from PretrainedConfig and can be used to control the model outputs. 配置对象继承自 PretrainedConfig，可用于控制模型输出。 Read the documentation from PretrainedConfig for more information. 阅读 PretrainedConfig 的文档以获取更多信息。
Examples 示例
>>> from transformers import TransfoXLConfig, TransfoXLModel
>>> # Initializing a Transformer XL configuration
>>> configuration = TransfoXLConfig()
>>> # Initializing a model (with random weights) from the configuration
>>> model = TransfoXLModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configTransfoXLTokenizer
class transformers.TransfoXLTokenizer
< source >( special = None min_freq = 0 max_size = None lower_case = False delimiter = None vocab_file = None pretrained_vocab_file: str = None never_split = None unk_token = '<unk>' eos_token = '<eos>' additional_special_tokens = ['<formula>'] language = 'en' **kwargs )
参数
- special (
List[str], optional) — 特殊 token 列表 (A list of special tokens (to be treated by the original implementation of this tokenizer)). - min_freq (
int, optional, defaults to 0) — token 必须至少出现的次数才能保留在词汇表中 (The minimum number of times a token has to be present in order to be kept in the vocabulary) (否则它将被映射到unk_token) (otherwise it will be mapped tounk_token). - max_size (
int, optional) — 词汇表的最大大小 (The maximum size of the vocabulary). If left unset, it will default to the size of the vocabulary found after excluding the tokens according to themin_freqrule. 如果未设置，则默认为根据min_freq规则排除 token 后找到的词汇表大小。 - lower_case (
bool, optional, defaults toFalse) — 分词时是否将输入转换为小写 (Whether or not to lowercase the input when tokenizing). - delimiter (
str, optional) — token 之间使用的分隔符 (The delimiter used between tokens). - vocab_file (
str, optional) — 包含词汇表的文件 (File containing the vocabulary) (来自原始实现) ((from the original implementation)). - pretrained_vocab_file (
str, optional) — 包含通过save_pretrained()方法保存的词汇表的文件 (File containing the vocabulary as saved with thesave_pretrained()method). - never_split (
List[str], optional) — 永远不应该拆分的 token 列表 (List of tokens that should never be split). If no list is specified, will simply use the existing special tokens. 如果未指定列表，则将简单地使用现有的特殊 token。 - unk_token (
str, optional, defaults to"<unk>") — 未知 token (The unknown token). A token that is not in the vocabulary cannot be converted to an ID and is set to be this token instead. 不在词汇表中的 token 无法转换为 ID，而是设置为此 token。 - eos_token (
str, optional, defaults to"<eos>") — 序列结束 token (The end of sequence token). - additional_special_tokens (
List[str], optional, defaults to['<formula>']) — 附加特殊 token 列表 (A list of additional special tokens) (用于 HuggingFace 功能) ((for the HuggingFace functionality)). - language (
str, optional, defaults to"en") — 此分词器的语言 (The language of this tokenizer) (用于 mose 预处理) ((used for mose preprocessing)).
Construct a Transformer-XL tokenizer adapted from Vocab class in the original code. 构建一个从 原始代码 中的 Vocab 类改编的 Transformer-XL 分词器。 The Transformer-XL tokenizer is a word-level tokenizer (no sub-word tokenization). Transformer-XL 分词器是一个词级别分词器（没有子词分词）。
This tokenizer inherits from PreTrainedTokenizer which contains most of the main methods. 此分词器继承自 PreTrainedTokenizer，后者包含大多数主要方法。 Users should refer to this superclass for more information regarding those methods. 用户应参考此超类以获取有关这些方法的更多信息。
TransfoXL specific outputs TransfoXL 特定的输出
class transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLModelOutput
< source >( last_hidden_state: FloatTensor mems: List = None hidden_states: Optional = None attentions: Optional = None )
参数
- last_hidden_state (
torch.FloatTensorof shape(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列 (Sequence of hidden-states at the output of the last layer of the model). - mems (
List[torch.FloatTensor]of lengthconfig.n_layers) — 包含预先计算的隐藏状态 (Contains pre-computed hidden-states) (注意力块中的键和值) ((key and values in the attention blocks))。 Can be used (seememsinput) to speed up sequential decoding. 可用于（参见mems输入）加速顺序解码。 The token ids which have their past given to this model should not be passed as input ids as they have already been computed. 已经将过去信息提供给此模型的 token ID 不应作为输入 ID 传递，因为它们已经被计算过了。 - hidden_states (
tuple(torch.FloatTensor), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) —torch.FloatTensor元组 (Tuple oftorch.FloatTensor) (每个嵌入输出一个 + 每个层输出一个) ((one for the output of the embeddings + one for the output of each layer))，形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态加上初始嵌入输出 (Hidden-states of the model at the output of each layer plus the initial embedding outputs).
- attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —torch.FloatTensor元组 (Tuple oftorch.FloatTensor) (每层一个) ((one for each layer))，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值 (Attentions weights after the attention softmax, used to compute the weighted average in the self-attention heads).
Base class for model’s outputs that may also contain a past key/values (to speed up sequential decoding). 模型输出的基类，也可能包含过去的键/值（以加速顺序解码）。
class transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLLMHeadModelOutput
< source >( losses: Optional = None prediction_scores: FloatTensor = None mems: List = None hidden_states: Optional = None attentions: Optional = None loss: Optional = None )
参数
- losses (
torch.FloatTensorof shape (batch_size, sequence_length-1), optional, returned whenlabelsis provided) — 语言建模损失 (Language modeling losses) (未缩减) ((not reduced)). - prediction_scores (
torch.FloatTensorof shape(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数 (Prediction scores of the language modeling head) (SoftMax 后每个词汇表 token 的分数) ((scores for each vocabulary token after SoftMax)). - mems (
List[torch.FloatTensor]，长度为config.n_layers) — 包含预先计算的隐藏状态（注意力模块中的键和值）。可以用于（参见mems输入）加速序列解码。 已经将过去信息提供给此模型的 token id 不应作为 input ids 传递，因为它们已经被计算过了。 - hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组 (每个嵌入输出 + 每层输出一个)，形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出端的隐藏状态，加上初始嵌入输出。
- attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组 (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
- loss (
torch.FloatTensor，形状为(), 可选, 当提供labels时返回) — 缩减后的语言建模损失。
Base class for model’s outputs that may also contain a past key/values (to speed up sequential decoding). 模型输出的基类，也可能包含过去的键/值（以加速顺序解码）。
class transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLModelOutput
< source >( last_hidden_state: tf.Tensor = None mems: List[tf.Tensor] = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )
参数
- last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出端的隐藏状态序列。 - mems (
List[tf.Tensor]，长度为config.n_layers) — 包含预先计算的隐藏状态（注意力模块中的键和值）。可以用于（参见mems输入）加速序列解码。 已经将过去信息提供给此模型的 token id 不应作为 input ids 传递，因为它们已经被计算过了。 - hidden_states (
tuple(tf.Tensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组 (每个嵌入输出 + 每层输出一个)，形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出端的隐藏状态，加上初始嵌入输出。
- attentions (
tuple(tf.Tensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组 (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
Base class for model’s outputs that may also contain a past key/values (to speed up sequential decoding). 模型输出的基类，也可能包含过去的键/值（以加速顺序解码）。
class transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLLMHeadModelOutput
< source >( prediction_scores: tf.Tensor = None mems: List[tf.Tensor] = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )
参数
- losses (
tf.Tensor，形状为 (batch_size, sequence_length-1), 可选, 当提供labels时返回) — 语言建模损失 (未缩减)。 - prediction_scores (
tf.Tensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数 (SoftMax 之后每个词汇 token 的分数)。 - mems (
List[tf.Tensor]，长度为config.n_layers) — 包含预先计算的隐藏状态（注意力模块中的键和值）。可以用于（参见mems输入）加速序列解码。 已经将过去信息提供给此模型的 token id 不应作为 input ids 传递，因为它们已经被计算过了。 - hidden_states (
tuple(tf.Tensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组 (每个嵌入输出 + 每层输出一个)，形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出端的隐藏状态，加上初始嵌入输出。
- attentions (
tuple(tf.Tensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组 (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
Base class for model’s outputs that may also contain a past key/values (to speed up sequential decoding). 模型输出的基类，也可能包含过去的键/值（以加速顺序解码）。
TransfoXLModel
class transformers.TransfoXLModel
< source >( config )
参数
- config (TransfoXLConfig) — 包含模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型相关的权重，仅加载配置。 请查看 from_pretrained() 方法来加载模型权重。
不带任何特定头部，输出原始隐藏状态的 Bert 模型 Transformer。
此模型继承自 PreTrainedModel。 请查阅超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是 PyTorch torch.nn.Module 子类。 请将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与通用用法和行为相关的所有事项。
forward
< source >( input_ids: Optional = None mems: Optional = None head_mask: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLModelOutput or tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- mems (
List[torch.FloatTensor]，长度为config.n_layers) — 包含模型计算的预先计算的隐藏状态（注意力模块中的键和值）（参见下面的mems输出）。 可以用于加速序列解码。 已经将 mems 提供给此模型的 token id 不应作为input_ids传递，因为它们已经被计算过了。 - 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.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLModelOutput 或 tuple(torch.FloatTensor)
transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLModelOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (TransfoXLConfig) 和输入。
-
last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。 -
mems (
List[torch.FloatTensor]，长度为config.n_layers) — 包含预先计算的隐藏状态（注意力模块中的键和值）。 可以使用（参见mems输入）来加速顺序解码。 已将其过去状态提供给此模型的令牌 ID 不应作为输入 ID 传递，因为它们已被计算过。 -
hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组（嵌入输出的输出 + 每层输出的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出以及初始嵌入输出处的隐藏状态。
-
attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
TransfoXLModel 前向方法，覆盖了 __call__ 特殊方法。
尽管前向传递的配方需要在该函数中定义，但应在此之后调用 Module 实例，而不是调用此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TransfoXLModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("transfo-xl/transfo-xl-wt103")
>>> model = TransfoXLModel.from_pretrained("transfo-xl/transfo-xl-wt103")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_stateTransfoXLLMHeadModel
class transformers.TransfoXLLMHeadModel
< source >( config )
参数
- config (TransfoXLConfig) — 具有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
带有语言建模头的 Transformer-XL 模型（自适应 softmax，其权重与自适应输入嵌入绑定）
此模型继承自 PreTrainedModel。 请查阅超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是 PyTorch torch.nn.Module 子类。 请将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与通用用法和行为相关的所有事项。
forward
< source >( input_ids: Optional = None mems: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLLMHeadModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列令牌的索引。可以使用 AutoTokenizer 获取索引。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详细信息。
- mems (
List[torch.FloatTensor]，长度为config.n_layers) — 包含模型计算的预先计算的隐藏状态（注意力块中的键和值）（请参阅下面的mems输出）。 可用于加速顺序解码。 已将其 mems 提供给此模型的令牌 ID 不应作为input_ids传递，因为它们已被计算过。 - 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 而不是纯元组。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于语言建模的标签。 请注意，标签在模型内部已移位，即您可以设置labels = input_ids索引在[-100, 0, ..., config.vocab_size]中选择 所有设置为-100的标签都将被忽略（掩蔽），损失仅针对[0, ..., config.vocab_size]中的标签计算
返回
transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLLMHeadModelOutput 或 tuple(torch.FloatTensor)
transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLLMHeadModelOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (TransfoXLConfig) 和输入。
-
losses (
torch.FloatTensor，形状为 (batch_size, sequence_length-1)，可选，当提供labels时返回) — 语言建模损失（未缩减）。 -
prediction_scores (
torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 后每个词汇表令牌的分数）。 -
mems (
List[torch.FloatTensor]，长度为config.n_layers) — 包含预先计算的隐藏状态（注意力模块中的键和值）。 可以使用（参见mems输入）来加速顺序解码。 已将其过去状态提供给此模型的令牌 ID 不应作为输入 ID 传递，因为它们已被计算过。 -
hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组（嵌入输出的输出 + 每层输出的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出以及初始嵌入输出处的隐藏状态。
-
attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
-
loss (
torch.FloatTensor，形状为()，可选，当提供labels时返回) 缩减的语言建模损失。
TransfoXLLMHeadModel 前向方法，覆盖了 __call__ 特殊方法。
尽管前向传递的配方需要在该函数中定义，但应在此之后调用 Module 实例，而不是调用此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> import torch
>>> from transformers import AutoTokenizer, TransfoXLLMHeadModel
>>> tokenizer = AutoTokenizer.from_pretrained("transfo-xl/transfo-xl-wt103")
>>> model = TransfoXLLMHeadModel.from_pretrained("transfo-xl/transfo-xl-wt103")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logitsTransfoXLForSequenceClassification
class transformers.TransfoXLForSequenceClassification
< source >( config )
参数
- config (TransfoXLConfig) — 具有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
带有序列分类头的 Transformer-XL 模型转换器（线性层）。
TransfoXLForSequenceClassification 使用最后一个令牌进行分类，就像其他因果模型（例如 GPT-1）一样。
由于它对最后一个 token 进行分类，因此需要知道最后一个 token 的位置。如果配置中定义了 pad_token_id，它会找到每行中不是 padding token 的最后一个 token。如果未定义 pad_token_id，它将直接取每行 batch 中的最后一个值。由于当传入 inputs_embeds 而不是 input_ids 时，它无法猜测 padding token，因此它也会执行相同的操作（取每行 batch 中的最后一个值）。
此模型继承自 PreTrainedModel。 请查阅超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是 PyTorch torch.nn.Module 子类。 请将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与通用用法和行为相关的所有事项。
forward
< source >( input_ids: Optional = None mems: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLSequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。索引可以使用 AutoTokenizer 获得。 详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- mems (
List[torch.FloatTensor]，长度为config.n_layers) — 包含模型计算的预计算隐藏状态（attention 模块中的键和值）（请参阅下面的mems输出）。 可用于加速顺序解码。 已为其 mems 提供给此模型的 token IDs 不应作为input_ids传递，因为它们已被计算过。 - head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于 nullify self-attention 模块中选定 head 的 Mask。 Mask 值在[0, 1]中选择：- 1 表示 head 未被 mask，
- 0 表示 head 已被 mask。
- inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联向量，这将非常有用。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attention tensors。 有关更多详细信息，请参阅返回 tensors 下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参阅返回 tensors 下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是纯 tuple。 - labels (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。 索引应在[0, ..., config.num_labels - 1]中。 如果config.num_labels == 1，则计算回归损失（均方误差损失）；如果config.num_labels > 1，则计算分类损失（交叉熵损失）。
返回
transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLSequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)
一个 transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLSequenceClassifierOutputWithPast 或 torch.FloatTensor 的 tuple（如果传递 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (TransfoXLConfig) 和输入。
-
loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类（或回归，如果 config.num_labels==1）损失。 -
logits (
torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（或回归，如果 config.num_labels==1）得分（SoftMax 之前）。 -
mems (
List[torch.FloatTensor]，长度为config.n_layers) — 包含预先计算的隐藏状态（注意力模块中的键和值）。 可以使用（参见mems输入）来加速顺序解码。 已将其过去状态提供给此模型的令牌 ID 不应作为输入 ID 传递，因为它们已被计算过。 -
hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组（嵌入输出的输出 + 每层输出的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出以及初始嵌入输出处的隐藏状态。
-
attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
TransfoXLForSequenceClassification forward 方法，覆盖了 __call__ 特殊方法。
尽管前向传递的配方需要在该函数中定义，但应在此之后调用 Module 实例，而不是调用此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
单标签分类示例
>>> import torch
>>> from transformers import AutoTokenizer, TransfoXLForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("transfo-xl/transfo-xl-wt103")
>>> model = TransfoXLForSequenceClassification.from_pretrained("transfo-xl/transfo-xl-wt103")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = TransfoXLForSequenceClassification.from_pretrained("transfo-xl/transfo-xl-wt103", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss多标签分类示例
>>> import torch
>>> from transformers import AutoTokenizer, TransfoXLForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("transfo-xl/transfo-xl-wt103")
>>> model = TransfoXLForSequenceClassification.from_pretrained("transfo-xl/transfo-xl-wt103", 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 = TransfoXLForSequenceClassification.from_pretrained(
... "transfo-xl/transfo-xl-wt103", 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).lossTFTransfoXLModel
class transformers.TFTransfoXLModel
< source >( config *inputs **kwargs )
参数
- config (TransfoXLConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
不带任何特定头部，输出原始隐藏状态的 Bert 模型 Transformer。
此模型继承自 TFPreTrainedModel。 查看超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 keras.Model 子类。 将其用作常规 TF 2.0 Keras 模型，并参阅 TF 2.0 文档，了解与常规用法和行为相关的所有事项。
transformers 中的 TensorFlow 模型和层接受两种格式作为输入
- 将所有输入作为关键字参数（如 PyTorch 模型），或者
- 在第一个位置参数中将所有输入作为列表、tuple 或 dict。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时首选此格式。 由于这种支持，当使用 model.fit() 等方法时，事情应该对您“正常工作” - 只需以 model.fit() 支持的任何格式传递您的输入和标签即可！ 但是，如果您想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建您自己的层或模型时，您可以使用以下三种可能性来收集第一个位置参数中的所有输入 Tensors
- 仅使用
input_ids且不包含其他内容的单个 Tensor：model(input_ids) - 长度可变的列表，其中包含一个或多个输入 Tensors，顺序与文档字符串中给出的顺序相同：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 字典，其中包含一个或多个与文档字符串中给出的输入名称关联的输入 Tensors：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用 subclassing 创建模型和层时，您无需担心任何这些，因为您可以像对待任何其他 Python 函数一样传递输入！
call
< source >( input_ids: TFModelInputType | None = None mems: List[tf.Tensor] | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None training: bool = False ) → transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLModelOutput 或 tuple(tf.Tensor)
参数
- input_ids (
tf.Tensor或Numpy array，形状为(batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。索引可以使用 AutoTokenizer 获得。 详情请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- mems (
List[tf.Tensor]，长度为config.n_layers) — 包含模型计算的预计算隐藏状态（attention 模块中的键和值）（请参阅下面的mems输出）。 可用于加速顺序解码。 已为其 mems 提供给此模型的 token IDs 不应作为input_ids传递，因为它们已被计算过。 - head_mask (
tf.Tensor或Numpy array，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于 nullify self-attention 模块中选定 head 的 Mask。 Mask 值在[0, 1]中选择：- 1 表示 head 未被 mask，
- 0 表示 head 已被 mask。
- inputs_embeds (
tf.Tensor或Numpy array，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联向量，这将非常有用。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attention tensors。 有关更多详细信息，请参阅返回 tensors 下的attentions。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的hidden_states。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是普通元组。 此参数可以在 eager 模式下使用，在 graph 模式下，该值将始终设置为 True。 - training (
bool, optional, defaults toFalse) — 是否在训练模式下使用模型（一些模块，例如 dropout 模块，在训练和评估之间具有不同的行为）。
返回
transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLModelOutput 或 tuple(tf.Tensor)
一个 transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLModelOutput 或一个 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含取决于配置 (TransfoXLConfig) 和输入的各种元素。
-
last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。 -
mems (
List[tf.Tensor]，长度为config.n_layers) — 包含预先计算的隐藏状态（注意力块中的键和值）。 可以使用（参见mems输入）来加速顺序解码。 已将其过去信息提供给此模型的令牌 ID 不应作为输入 ID 传递，因为它们已被计算出来。 -
hidden_states (
tuple(tf.Tensor), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（每个元组对应嵌入输出 + 每个层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出以及初始嵌入输出处的隐藏状态。
-
attentions (
tuple(tf.Tensor), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个元组），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
TFTransfoXLModel 前向方法，覆盖了 __call__ 特殊方法。
尽管前向传递的配方需要在该函数中定义，但应在此之后调用 Module 实例，而不是调用此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFTransfoXLModel
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("transfo-xl/transfo-xl-wt103")
>>> model = TFTransfoXLModel.from_pretrained("transfo-xl/transfo-xl-wt103")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> last_hidden_states = outputs.last_hidden_stateTFTransfoXLLMHeadModel
class transformers.TFTransfoXLLMHeadModel
< source >( config )
参数
- config (TransfoXLConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
带有语言建模头的 Transformer-XL 模型（自适应 softmax，其权重与自适应输入嵌入绑定）
此模型继承自 TFPreTrainedModel。 查看超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 keras.Model 子类。 将其用作常规 TF 2.0 Keras 模型，并参阅 TF 2.0 文档，了解与常规用法和行为相关的所有事项。
transformers 中的 TensorFlow 模型和层接受两种格式作为输入
- 将所有输入作为关键字参数（如 PyTorch 模型），或者
- 在第一个位置参数中将所有输入作为列表、tuple 或 dict。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时首选此格式。 由于这种支持，当使用 model.fit() 等方法时，事情应该对您“正常工作” - 只需以 model.fit() 支持的任何格式传递您的输入和标签即可！ 但是，如果您想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建您自己的层或模型时，您可以使用以下三种可能性来收集第一个位置参数中的所有输入 Tensors
- 仅使用
input_ids且不包含其他内容的单个 Tensor：model(input_ids) - 长度可变的列表，其中包含一个或多个输入 Tensors，顺序与文档字符串中给出的顺序相同：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 字典，其中包含一个或多个与文档字符串中给出的输入名称关联的输入 Tensors：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用 subclassing 创建模型和层时，您无需担心任何这些，因为您可以像对待任何其他 Python 函数一样传递输入！
call
< source >( input_ids: TFModelInputType | None = None mems: List[tf.Tensor] | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None labels: np.ndarray | tf.Tensor | None = None training: bool = False ) → transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLLMHeadModelOutput 或 tuple(tf.Tensor)
参数
- input_ids (
tf.Tensor或Numpy array，形状为(batch_size, sequence_length)) — 输入序列令牌在词汇表中的索引。可以使用 AutoTokenizer 获取索引。 有关详细信息，请参见 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- mems (
List[tf.Tensor]，长度为config.n_layers) — 包含模型计算的预先计算的隐藏状态（注意力块中的键和值）（请参见下面的mems输出）。 可以用于加速顺序解码。 已将其 mems 提供给此模型的令牌 ID 不应作为input_ids传递，因为它们已被计算出来。 - head_mask (
tf.Tensor或Numpy array，形状为(num_heads,)或(num_layers, num_heads), optional) — 用于使自注意力模块的选定头无效的掩码。 在[0, 1]中选择的掩码值：- 1 表示头未被掩蔽，
- 0 表示头被掩蔽。
- inputs_embeds (
tf.Tensor或Numpy array，形状为(batch_size, sequence_length, hidden_size), optional) — 或者，您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参见返回张量下的attentions。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的hidden_states。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是普通元组。 此参数可以在 eager 模式下使用，在 graph 模式下，该值将始终设置为 True。 - training (
bool, optional, defaults toFalse) — 是否在训练模式下使用模型（一些模块，例如 dropout 模块，在训练和评估之间具有不同的行为）。
返回
transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLLMHeadModelOutput 或 tuple(tf.Tensor)
一个 transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLLMHeadModelOutput 或一个 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含取决于配置 (TransfoXLConfig) 和输入的各种元素。
-
losses (
tf.Tensor，形状为 * (batch_size, sequence_length-1) *，optional，当提供labels时返回) — 语言建模损失（未缩减）。 -
prediction_scores (
tf.Tensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之后每个词汇表令牌的分数）。 -
mems (
List[tf.Tensor]，长度为config.n_layers) — 包含预先计算的隐藏状态（注意力块中的键和值）。 可以使用（参见mems输入）来加速顺序解码。 已将其过去信息提供给此模型的令牌 ID 不应作为输入 ID 传递，因为它们已被计算出来。 -
hidden_states (
tuple(tf.Tensor), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（每个元组对应嵌入输出 + 每个层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出以及初始嵌入输出处的隐藏状态。
-
attentions (
tuple(tf.Tensor), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个元组），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
TFTransfoXLLMHeadModel 前向方法，覆盖了 __call__ 特殊方法。
尽管前向传递的配方需要在该函数中定义，但应在此之后调用 Module 实例，而不是调用此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFTransfoXLLMHeadModel
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("transfo-xl/transfo-xl-wt103")
>>> model = TFTransfoXLLMHeadModel.from_pretrained("transfo-xl/transfo-xl-wt103")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> logits = outputs.logitsTFTransfoXLForSequenceClassification
class transformers.TFTransfoXLForSequenceClassification
< source >( config *inputs **kwargs )
参数
- config (TransfoXLConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
Transfo XL 模型转换器，顶部带有序列分类头（线性层）。
TFTransfoXLForSequenceClassification 使用最后一个令牌来执行分类，就像其他因果模型（例如 GPT-1、GPT-2）一样。
由于它对最后一个 token 进行分类，因此需要知道最后一个 token 的位置。如果配置中定义了 pad_token_id，它会找到每行中不是 padding token 的最后一个 token。如果未定义 pad_token_id，它将直接取每行 batch 中的最后一个值。由于当传入 inputs_embeds 而不是 input_ids 时，它无法猜测 padding token，因此它也会执行相同的操作（取每行 batch 中的最后一个值）。
此模型继承自 TFPreTrainedModel。 查看超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 keras.Model 子类。 将其用作常规 TF 2.0 Keras 模型，并参阅 TF 2.0 文档，了解与常规用法和行为相关的所有事项。
transformers 中的 TensorFlow 模型和层接受两种格式作为输入
- 将所有输入作为关键字参数（如 PyTorch 模型），或者
- 在第一个位置参数中将所有输入作为列表、tuple 或 dict。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时首选此格式。 由于这种支持，当使用 model.fit() 等方法时，事情应该对您“正常工作” - 只需以 model.fit() 支持的任何格式传递您的输入和标签即可！ 但是，如果您想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建您自己的层或模型时，您可以使用以下三种可能性来收集第一个位置参数中的所有输入 Tensors
- 仅使用
input_ids且不包含其他内容的单个 Tensor：model(input_ids) - 长度可变的列表，其中包含一个或多个输入 Tensors，顺序与文档字符串中给出的顺序相同：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 字典，其中包含一个或多个与文档字符串中给出的输入名称关联的输入 Tensors：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用 subclassing 创建模型和层时，您无需担心任何这些，因为您可以像对待任何其他 Python 函数一样传递输入！
call
< source >( input_ids: TFModelInputType | None = None mems: List[tf.Tensor] | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLSequenceClassifierOutputWithPast 或 tuple(tf.Tensor)
参数
- input_ids (
tf.Tensor或Numpy array，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。索引可以使用 AutoTokenizer 获得。 详情请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- mems (长度为
config.n_layers的List[tf.Tensor]) — 包含模型计算的预计算隐藏状态（注意力模块中的键和值）（见下面的mems输出）。 可用于加速顺序解码。 已将其 mems 提供给此模型的 token IDs 不应作为input_ids传递，因为它们已被计算。 - head_mask (
tf.Tensor或Numpy array，形状为(num_heads,)或(num_layers, num_heads), 可选) — 用于置空自注意力模块中选定 head 的 Mask。 Mask 值在[0, 1]中选择：- 1 表示 head 未被 Mask，
- 0 表示 head 已被 Mask。
- inputs_embeds (
tf.Tensor或Numpy array，形状为(batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您想比模型的内部嵌入查找矩阵更灵活地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的 attentions tensors。 有关更多详细信息，请参见返回 tensors 下的attentions。 此参数只能在即时模式下使用，在图模式下将使用配置中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回 tensors 下的hidden_states。 此参数只能在即时模式下使用，在图模式下将使用配置中的值。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 此参数可以在即时模式下使用，在图模式下该值将始终设置为 True。 - training (
bool, 可选, 默认为False) — 是否在训练模式下使用模型（dropout 模块等某些模块在训练和评估之间具有不同的行为）。 - labels (形状为
(batch_size, sequence_length)的tf.Tensor, 可选) — 用于计算交叉熵分类损失的标签。 索引应在[0, ..., config.vocab_size - 1]中。
返回
transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLSequenceClassifierOutputWithPast 或 tuple(tf.Tensor)
一个 transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLSequenceClassifierOutputWithPast 或 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (TransfoXLConfig) 和输入。
-
loss (形状为
(1,)的tf.Tensor, 可选, 当提供labels时返回) — 分类（如果 config.num_labels==1，则为回归）损失。 -
logits (形状为
(batch_size, config.num_labels)的tf.Tensor) — 分类（如果 config.num_labels==1，则为回归）得分（在 SoftMax 之前）。 -
mems (
List[tf.Tensor]，长度为config.n_layers) — 包含预先计算的隐藏状态（注意力块中的键和值）。 可以使用（参见mems输入）来加速顺序解码。 已将其过去信息提供给此模型的令牌 ID 不应作为输入 ID 传递，因为它们已被计算出来。 -
hidden_states (
tuple(tf.Tensor), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（每个元组对应嵌入输出 + 每个层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出以及初始嵌入输出处的隐藏状态。
-
attentions (
tuple(tf.Tensor), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个元组），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
TFTransfoXLForSequenceClassification forward 方法，覆盖 __call__ 特殊方法。
尽管前向传递的配方需要在该函数中定义，但应在此之后调用 Module 实例，而不是调用此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFTransfoXLForSequenceClassification
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("transfo-xl/transfo-xl-wt103")
>>> model = TFTransfoXLForSequenceClassification.from_pretrained("transfo-xl/transfo-xl-wt103")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> logits = model(**inputs).logits
>>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = TFTransfoXLForSequenceClassification.from_pretrained("transfo-xl/transfo-xl-wt103", num_labels=num_labels)
>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).loss内部层
class transformers.AdaptiveEmbedding
< source >( n_token d_embed d_proj cutoffs div_val = 1 sample_softmax = False )
class transformers.TFAdaptiveEmbedding
< source >( n_token d_embed d_proj cutoffs div_val = 1 init_std = 0.02 sample_softmax = False **kwargs )