Hugging Face 的 LOGO

Transformers 文档

Transformer XL

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

Transformer XL

PyTorch TensorFlow

此模型仅处于维护模式，因此我们不会接受任何更改其代码的新 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。

Models Spaces

概述

Transformer-XL 模型由 Zihang Dai、Zhilin Yang、Yiming Yang、Jaime Carbonell、Quoc V. Le、Ruslan Salakhutdinov 在 Transformer-XL: 超越固定长度上下文的注意力语言模型中提出。它是一个具有相对位置（正弦）嵌入的因果（单向）Transformer，可以重用先前计算的隐藏状态来关注更长的上下文（内存）。此模型还使用自适应 softmax 输入和输出（绑定）。

论文摘要如下：

Transformer 有学习长期依赖的潜力，但在语言建模设置中受限于固定长度的上下文。我们提出了一种新颖的神经架构 Transformer-XL，它可以在不破坏时间连贯性的情况下学习超出固定长度的依赖关系。它由段级递归机制和新颖的位置编码方案组成。我们的方法不仅能够捕获更长的依赖关系，而且还解决了上下文碎片问题。因此，Transformer-XL 学习的依赖关系比 RNN 长 80%，比普通 Transformer 长 450%，在短序列和长序列上都取得了更好的性能，并且在评估期间比普通 Transformer 快 1800+ 倍。值得注意的是，我们将 enwiki8 上的 bpc/困惑度提升到 0.99，text8 上提升到 1.08，WikiText-103 上提升到 18.3，One Billion Word 上提升到 21.8，Penn Treebank 上提升到 54.5（未经微调）。仅在 WikiText-103 上训练时，Transformer-XL 能够生成具有数千个标记的合理连贯的新颖文本文章。

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

使用技巧

  • Transformer-XL 使用相对正弦位置嵌入。填充可以在左侧或右侧进行。原始实现在 SQuAD 上使用左侧填充进行训练，因此填充默认为左侧。
  • Transformer-XL 是少数没有序列长度限制的模型之一。
  • 与常规 GPT 模型相同，但引入了两个连续段的递归机制（类似于具有两个连续输入的常规 RNN）。在此上下文中，一个段是可能跨越多个文档的连续标记（例如 512）的数量，并且段按顺序输入到模型中。
  • 基本上，前一个段的隐藏状态与当前输入连接起来，以计算注意力分数。这允许模型关注前一个段以及当前段中的信息。通过堆叠多个注意力层，感受野可以增加到多个以前的段。
  • 这将位置嵌入更改为位置相对嵌入（因为常规位置嵌入在给定位置的当前输入和当前隐藏状态中将产生相同的结果），并且需要对注意力分数的计算方式进行一些调整。

由于 PyTorch 中的一个错误，TransformerXL 不支持 torch.nn.DataParallel，请参阅问题 #36035

资源

TransfoXLConfig

class transformers.TransfoXLConfig

< >

( 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 表示的不同标记的数量。
  • cutoffs (list[int], 可选, 默认为 [20000, 40000, 200000]) — 自适应 softmax 的截止点。
  • 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 后使用相同的 pos 嵌入。
  • same_length (boolean, 可选, 默认为 True) — 是否对所有标记使用相同的 attn 长度。
  • proj_share_all_but_first (boolean, 可选, 默认为 True) — True 为共享除第一个之外的所有 projs，False 为不共享。
  • attn_type (int, 可选, 默认为 0) — 注意力类型。0 表示 Transformer-XL，1 表示 Shaw et al，2 表示 Vaswani et al，3 表示 Al Rfou et al。
  • 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, 可选, 默认为 1e-05) — 层归一化层中使用的 epsilon。
  • eos_token_id (int, 可选, 默认为 0) — 流结束符的 ID。

这是一个配置类，用于存储 TransfoXLModel 或 TFTransfoXLModel 的配置。它用于根据指定参数实例化 Transformer-XL 模型，定义模型架构。使用默认值实例化配置将生成与 TransfoXL transfo-xl/transfo-xl-wt103 架构相似的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。有关详细信息，请参阅 PretrainedConfig 的文档。

示例

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

TransfoXL分词器

类 transformers.TransfoXLTokenizer

< >

( special = None min_freq = 0 max_size = None lower_case = False delimiter = None vocab_file = None pretrained_vocab_file: typing.Optional[str] = None never_split = None unk_token = '<unk>' eos_token = '<eos>' additional_special_tokens = ['<formula>'] language = 'en' **kwargs )

参数

  • special (list[str], 可选) — 特殊标记列表（由该分词器的原始实现处理）。
  • min_freq (int, 可选, 默认为 0) — 标记在词汇表中必须出现的最小次数（否则它将被映射到 unk_token）。
  • max_size (int, 可选) — 词汇表的最大大小。如果未设置，将默认为根据 min_freq 规则排除标记后找到的词汇表大小。
  • lower_case (bool, 可选, 默认为 False) — 分词时是否将输入转换为小写。
  • delimiter (str, 可选) — 标记之间使用的分隔符。
  • vocab_file (str, 可选) — 包含词汇表的文件（来自原始实现）。
  • pretrained_vocab_file (str, 可选) — 包含使用 save_pretrained() 方法保存的词汇表的文件。
  • never_split (list[str], 可选) — 永不拆分的标记列表。如果未指定列表，则仅使用现有特殊标记。
  • unk_token (str, 可选, 默认为 "<unk>") — 未知标记。不在词汇表中的标记不能转换为 ID，而是设置为此标记。
  • eos_token (str, 可选, 默认为 "<eos>") — 序列结束符。
  • additional_special_tokens (list[str], 可选, 默认为 ['<formula>']) — 其他特殊标记列表（用于 HuggingFace 功能）。
  • language (str, 可选, 默认为 "en") — 此分词器的语言（用于预处理）。

从 原始代码 中的 Vocab 类改编的 Transformer-XL 分词器。Transformer-XL 分词器是词级分词器（无子词分词）。

此分词器继承自 PreTrainedTokenizer，其中包含大部分主要方法。用户应参阅此超类以获取有关这些方法的更多信息。

保存词汇表

< >

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

TransfoXL 特定输出

类 transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLModelOutput

< >

( last_hidden_state: FloatTensor mems: list = None hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None attentions: typing.Optional[tuple[torch.FloatTensor]] = None )

参数

  • 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 后的注意力权重，用于计算自注意力头中的加权平均值。

模型输出的基类，也可能包含过去的键/值（以加速顺序解码）。

类 transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLLMHeadModelOutput

< >

( losses: typing.Optional[torch.FloatTensor] = None prediction_scores: typing.Optional[torch.FloatTensor] = None mems: list = None hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None attentions: typing.Optional[tuple[torch.FloatTensor]] = None loss: typing.Optional[torch.FloatTensor] = None )

参数

  • 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 时返回) — 减少的语言建模损失。

模型输出的基类，也可能包含过去的键/值（以加速顺序解码）。

类 transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLModelOutput

< >

( last_hidden_state: Optional[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 输入）加速顺序解码。已将其过去状态提供给此模型的标记 ID 不应作为输入 ID 传递，因为它们已被计算。
  • 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 后的注意力权重，用于计算自注意力头中的加权平均值。

模型输出的基类，也可能包含过去的键/值（以加速顺序解码）。

类 transformers.models.deprecated.transfo_xl.modeling_tf_transfo_xl.TFTransfoXLLMHeadModelOutput

< >

( prediction_scores: Optional[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 后每个词汇标记的分数）。
  • mems (list[tf.Tensor]，长度为 config.n_layers) — 包含预计算的隐藏状态（注意力块中的键和值）。可用于（参见 mems 输入）加速顺序解码。已将其过去状态提供给此模型的标记 ID 不应作为输入 ID 传递，因为它们已被计算。
  • 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 后的注意力权重，用于计算自注意力头中的加权平均值。

模型输出的基类，也可能包含过去的键/值（以加速顺序解码）。

PyTorch
隐藏 Pytorch 内容

TransfoXL模型

类 transformers.TransfoXLModel

< >

( config )

参数

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

裸 BERT 模型 Transformer 输出原始隐藏状态，顶部没有任何特定头。

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

此模型也是 PyTorch torch.nn.Module 的子类。将其作为常规 PyTorch 模块使用，并参阅 PyTorch 文档以获取所有与通用用法和行为相关的事项。

前向

< >

( input_ids: typing.Optional[torch.LongTensor] = None mems: typing.Optional[list[torch.FloatTensor]] = 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.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLModelOutput 或 tuple(torch.FloatTensor)

参数

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

    索引可以通过 AutoTokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 ID？

  • 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 而不是普通的元组。

返回

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_state

TransfoXLLMHeadModel

class transformers.TransfoXLLMHeadModel

< >

( config )

参数

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

带有语言模型头的 Transformer-XL 模型（自适应 softmax，权重与自适应输入嵌入绑定）

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

此模型也是 PyTorch torch.nn.Module 的子类。将其作为常规 PyTorch 模块使用，并参阅 PyTorch 文档以获取所有与通用用法和行为相关的事项。

前向

< >

( input_ids: typing.Optional[torch.LongTensor] = None mems: typing.Optional[list[torch.FloatTensor]] = 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.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLLMHeadModelOutput or tuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID？

  • 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 而不是普通元组。
  • 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 后每个词汇 token 的分数）。

  • 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 的 forward 方法，覆盖了 __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.logits

TransfoXLForSequenceClassification

class transformers.TransfoXLForSequenceClassification

< >

( config )

参数

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

Transformer-XL 模型，顶部带有一个序列分类头（线性层）。

TransfoXLForSequenceClassification 使用最后一个 token 进行分类，与其他因果模型（例如 GPT-1）一样。

由于它对最后一个 token 进行分类，因此需要知道最后一个 token 的位置。如果配置中定义了 pad_token_id，它会找到每行中不是填充 token 的最后一个 token。如果未定义 pad_token_id，它只取批处理中每行的最后一个值。由于当传递 inputs_embeds 而不是 input_ids 时无法猜测填充 token，因此它执行相同的操作（取批处理中每行的最后一个值）。

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

此模型也是 PyTorch torch.nn.Module 的子类。将其作为常规 PyTorch 模块使用，并参阅 PyTorch 文档以获取所有与通用用法和行为相关的事项。

前向

< >

( input_ids: typing.Optional[torch.LongTensor] = None mems: typing.Optional[list[torch.FloatTensor]] = 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.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLSequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID？

  • 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 而不是普通元组。
  • 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 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置（TransfoXLConfig）和输入包含各种元素。

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

  • logits (形状为 (batch_size, config.num_labels) 的 torch.FloatTensor) — 分类（如果 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).loss
TensorFlow
隐藏 TensorFlow 内容

TFTransfoXLModel

class transformers.TFTransfoXLModel

< >

( config *inputs **kwargs )

参数

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

裸 BERT 模型 Transformer 输出原始隐藏状态，顶部没有任何特定头。

此模型继承自 TFPreTrainedModel。请查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）

此模型也是 keras.Model 的子类。将其作为常规 TF 2.0 Keras 模型使用，并参考 TF 2.0 文档了解所有与通用用法和行为相关的事项。

transformers 中的 TensorFlow 模型和层接受两种输入格式

  • 所有输入作为关键字参数（如 PyTorch 模型），或
  • 所有输入作为第一个位置参数中的列表、元组或字典。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于此支持，在使用 model.fit() 等方法时，一切都应该“正常工作”——只需以 model.fit() 支持的任何格式传递您的输入和标签即可！但是，如果您想在 fit() 和 predict() 等 Keras 方法之外使用第二种格式，例如在使用 Keras Functional API 创建自己的层或模型时，您可以使用三种可能性来收集第一个位置参数中的所有输入张量

  • 只有一个 input_ids 的单个张量，没有其他：model(input_ids)
  • 长度可变的列表，包含一个或多个输入张量，按文档字符串中给出的顺序：model([input_ids, attention_mask]) 或 model([input_ids, attention_mask, token_type_ids])
  • 一个字典，其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用 子类化 创建模型和层时，您无需担心这些，因为您可以像传递给任何其他 Python 函数一样传递输入！

调用

< >

( 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 数组，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。

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

    什么是输入 ID？

  • mems (list[tf.Tensor] 长度为 config.n_layers) — 包含模型计算的预计算隐藏状态（注意力块中的键和值）（请参阅下面的 mems 输出）。可用于加速顺序解码。已将其 mems 提供给此模型的 token ID 不应作为 input_ids 传递，因为它们已被计算。
  • head_mask (tf.Tensor 或 Numpy 数组，形状为 (num_heads,) 或 (num_layers, num_heads), 可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 中：

    • 1 表示头部未被遮蔽，
    • 0 表示头部被遮蔽。
  • inputs_embeds (tf.Tensor 或 Numpy 数组，形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望对如何将 input_ids 索引转换为关联向量具有比模型内部嵌入查找矩阵更多的控制，这会很有用。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。此参数只能在 eager 模式下使用，在图模式下将使用配置中的值。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。此参数只能在 eager 模式下使用，在图模式下将使用配置中的值。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数只能在 eager 模式下使用，在图模式下将始终设置为 True。
  • training (bool, 可选, 默认为 False) — 是否在训练模式下使用模型（某些模块如 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 of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

  • mems (list[tf.Tensor] 长度为 config.n_layers) — 包含预计算的隐藏状态（注意力块中的键和值）。可用于（参见 mems 输入）加速顺序解码。已将其过去信息提供给此模型的 token ID 不应作为输入 ID 传递，因为它们已被计算。

  • 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 后的注意力权重，用于计算自注意力头中的加权平均值。

TFTransfoXLModel 的 forward 方法，覆盖了 __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_state

TFTransfoXLLMHeadModel

class transformers.TFTransfoXLLMHeadModel

< >

( config )

参数

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

带有语言模型头的 Transformer-XL 模型（自适应 softmax，权重与自适应输入嵌入绑定）

此模型继承自 TFPreTrainedModel。请查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）

此模型也是 keras.Model 的子类。将其作为常规 TF 2.0 Keras 模型使用，并参考 TF 2.0 文档了解所有与通用用法和行为相关的事项。

transformers 中的 TensorFlow 模型和层接受两种输入格式

  • 所有输入作为关键字参数（如 PyTorch 模型），或
  • 所有输入作为第一个位置参数中的列表、元组或字典。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于此支持，在使用 model.fit() 等方法时，一切都应该“正常工作”——只需以 model.fit() 支持的任何格式传递您的输入和标签即可！但是，如果您想在 fit() 和 predict() 等 Keras 方法之外使用第二种格式，例如在使用 Keras Functional API 创建自己的层或模型时，您可以使用三种可能性来收集第一个位置参数中的所有输入张量

  • 只有一个 input_ids 的单个张量，没有其他：model(input_ids)
  • 长度可变的列表，包含一个或多个输入张量，按文档字符串中给出的顺序：model([input_ids, attention_mask]) 或 model([input_ids, attention_mask, token_type_ids])
  • 一个字典，其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用 子类化 创建模型和层时，您无需担心这些，因为您可以像传递给任何其他 Python 函数一样传递输入！

调用

< >

( 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 数组，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。

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

    什么是输入 ID？

  • mems (list[tf.Tensor] 长度为 config.n_layers) — 包含模型计算的预计算隐藏状态（注意力块中的键和值）（请参阅下面的 mems 输出）。可用于加速顺序解码。已将其 mems 提供给此模型的 token ID 不应作为 input_ids 传递，因为它们已被计算。
  • head_mask (tf.Tensor 或 Numpy 数组，形状为 (num_heads,) 或 (num_layers, num_heads), 可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 中：

    • 1 表示头部未被遮蔽，
    • 0 表示头部被遮蔽。
  • inputs_embeds (tf.Tensor 或 Numpy 数组，形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望对如何将 input_ids 索引转换为关联向量具有比模型内部嵌入查找矩阵更多的控制，这会很有用。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。此参数只能在 eager 模式下使用，在图模式下将使用配置中的值。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多详情请参阅返回张量下的hidden_states。此参数只能在即时模式下使用，在图模式下将使用配置中的值。
  • return_dict (bool, 可选) — 是否返回ModelOutput而不是普通元组。此参数可在即时模式下使用，在图模式下该值将始终设置为 True。
  • training (bool, 可选, 默认为False) — 是否在训练模式下使用模型（某些模块如 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 (形状为 (batch_size, sequence_length-1) 的tf.Tensor，可选，当提供 labels 时返回) — 语言模型损失（未减少）。

  • prediction_scores (形状为 (batch_size, sequence_length, config.vocab_size) 的tf.Tensor) — 语言模型头部的预测分数（SoftMax 后每个词汇标记的分数）。

  • mems (list[tf.Tensor] 长度为 config.n_layers) — 包含预计算的隐藏状态（注意力块中的键和值）。可用于（参见 mems 输入）加速顺序解码。已将其过去信息提供给此模型的 token ID 不应作为输入 ID 传递，因为它们已被计算。

  • 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 后的注意力权重，用于计算自注意力头中的加权平均值。

TFTransfoXLLMHeadModel 的 forward 方法，覆盖了 __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.logits

TFTransfoXLForSequenceClassification

class transformers.TFTransfoXLForSequenceClassification

< >

( config *inputs **kwargs )

参数

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

Transfo XL 模型 Transformer，顶部带有一个序列分类头（线性层）。

TFTransfoXLForSequenceClassification 使用最后一个标记进行分类，就像其他因果模型（如 GPT-1、GPT-2）一样。

由于它对最后一个 token 进行分类，因此需要知道最后一个 token 的位置。如果配置中定义了 pad_token_id，它会找到每行中不是填充 token 的最后一个 token。如果未定义 pad_token_id，它只取批处理中每行的最后一个值。由于当传递 inputs_embeds 而不是 input_ids 时无法猜测填充 token，因此它执行相同的操作（取批处理中每行的最后一个值）。

此模型继承自 TFPreTrainedModel。请查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）

此模型也是 keras.Model 的子类。将其作为常规 TF 2.0 Keras 模型使用，并参考 TF 2.0 文档了解所有与通用用法和行为相关的事项。

transformers 中的 TensorFlow 模型和层接受两种输入格式

  • 所有输入作为关键字参数（如 PyTorch 模型），或
  • 所有输入作为第一个位置参数中的列表、元组或字典。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于此支持，在使用 model.fit() 等方法时，一切都应该“正常工作”——只需以 model.fit() 支持的任何格式传递您的输入和标签即可！但是，如果您想在 fit() 和 predict() 等 Keras 方法之外使用第二种格式，例如在使用 Keras Functional API 创建自己的层或模型时，您可以使用三种可能性来收集第一个位置参数中的所有输入张量

  • 只有一个 input_ids 的单个张量，没有其他：model(input_ids)
  • 长度可变的列表，包含一个或多个输入张量，按文档字符串中给出的顺序：model([input_ids, attention_mask]) 或 model([input_ids, attention_mask, token_type_ids])
  • 一个字典，其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用 子类化 创建模型和层时，您无需担心这些，因为您可以像传递给任何其他 Python 函数一样传递输入！

调用

< >

( 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 (形状为 (batch_size, sequence_length) 的tf.Tensor 或 Numpy array) — 词汇表中输入序列标记的索引。

    索引可以使用 AutoTokenizer 获取。详情请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。

    什么是 input IDs？

  • mems (长度为 config.n_layers 的 list[tf.Tensor]) — 包含模型计算的预计算隐藏状态（注意力块中的键和值）（参见下面的 mems 输出）。可用于加速顺序解码。已将 mems 提供给该模型的标记 ID 不应作为 input_ids 传递，因为它们已被计算。
  • head_mask (形状为 (num_heads,) 或 (num_layers, num_heads) 的 tf.Tensor 或 Numpy array，可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 之间：

    • 1 表示头部未被掩码，
    • 0 表示头部被掩码。
  • inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的tf.Tensor 或 Numpy array，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望对 input_ids 索引如何转换为关联向量有比模型内部嵌入查找矩阵更多的控制，这会很有用。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多详情请参阅返回张量下的attentions。此参数只能在即时模式下使用，在图模式下将使用配置中的值。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多详情请参阅返回张量下的hidden_states。此参数只能在即时模式下使用，在图模式下将使用配置中的值。
  • return_dict (bool, 可选) — 是否返回ModelOutput而不是普通元组。此参数可在即时模式下使用，在图模式下该值将始终设置为 True。
  • training (bool, 可选, 默认为False) — 是否在训练模式下使用模型（某些模块如 dropout 模块在训练和评估之间有不同的行为）。
  • labels (形状为 (batch_size, sequence_length) 的tf.Tensor，可选) — 用于计算交叉熵分类损失的标签。索引应在 [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 (tf.Tensor，形状为 (batch_size, config.num_labels)) — 分类（或回归，如果 config.num_labels==1）分数（SoftMax 之前）。

  • mems (list[tf.Tensor] 长度为 config.n_layers) — 包含预计算的隐藏状态（注意力块中的键和值）。可用于（参见 mems 输入）加速顺序解码。已将其过去信息提供给此模型的 token ID 不应作为输入 ID 传递，因为它们已被计算。

  • 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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

< >

( n_token d_embed d_proj cutoffs div_val = 1 sample_softmax = False )

class transformers.TFAdaptiveEmbedding

< >

( n_token d_embed d_proj cutoffs div_val = 1 init_std = 0.02 sample_softmax = False **kwargs )

< > 在 GitHub 上更新

←TAPEX UL2→