Transformer XL
该模型目前仅处于维护模式,因此我们不会接受任何更改其代码的新PR。该模型由于与pickle.load
相关的安全问题而被弃用。
我们建议切换到更新的模型以提高安全性。
如果您仍然希望在实验中使用TransfoXL
,我们建议使用Hub checkpoint并指定一个特定的修订版,以确保您从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模型由Zihang Dai、Zhilin Yang、Yiming Yang、Jaime Carbonell、Quoc V. Le和Ruslan Salakhutdinov在Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context中提出。它是一种具有相对位置(正弦)嵌入的因果(单向)变压器,可以重用先前计算的隐藏状态来处理更长的上下文(记忆)。该模型还使用了自适应softmax输入和输出(绑定)。
论文的摘要如下:
Transformer 有潜力学习更长期的依赖关系,但在语言建模的设置中受到固定长度上下文的限制。我们提出了一种新颖的神经架构 Transformer-XL,它能够在保持时间连贯性的同时,学习超出固定长度的依赖关系。它由段级循环机制和一种新颖的位置编码方案组成。我们的方法不仅能够捕捉更长期的依赖关系,还解决了上下文碎片化问题。因此,Transformer-XL 学习的依赖关系比 RNN 长 80%,比普通 Transformer 长 450%,在短序列和长序列上都表现更好,并且在评估时比普通 Transformer 快 1,800 倍以上。值得注意的是,我们将 bpc/困惑度的最新结果提高到 enwiki8 上的 0.99,text8 上的 1.08,WikiText-103 上的 18.3,One Billion Word 上的 21.8,以及 Penn Treebank 上的 54.5(无需微调)。当仅在 WikiText-103 上训练时,Transformer-XL 能够生成合理连贯的、包含数千个标记的新文本文章。
使用提示
- Transformer-XL 使用相对正弦位置嵌入。填充可以在左侧或右侧进行。原始实现在 SQuAD 上进行训练时使用左侧填充,因此填充默认设置为左侧。
- Transformer-XL 是少数没有序列长度限制的模型之一。
- 与常规的GPT模型相同,但引入了两个连续段的递归机制(类似于具有两个连续输入的常规RNN)。在这种情况下,一个段是多个连续标记(例如512个),可能跨越多个文档,并且这些段按顺序输入到模型中。
- 基本上,前一段的隐藏状态会与当前输入连接起来以计算注意力分数。这使得模型能够关注前一段以及当前段中的信息。通过堆叠多个注意力层,感受野可以扩展到多个前段。
- 这将位置嵌入更改为位置相对嵌入(因为常规的位置嵌入在给定位置的当前输入和当前隐藏状态中会给出相同的结果),并且需要在计算注意力分数的方式上做一些调整。
TransformerXL 不 能与 torch.nn.DataParallel 一起使用,原因是 PyTorch 中的一个 bug,详见 issue #36035
资源
TransfoXLConfig
类 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
可以表示的不同标记的数量。 - cutoffs (
List[int]
, 可选, 默认为[20000, 40000, 200000]
) — 自适应softmax的截断值。 - d_model (
int
, optional, 默认为 1024) — 模型隐藏状态的维度。 - d_embed (
int
, optional, 默认为 1024) — 嵌入的维度 - n_head (
int
, optional, 默认为 16) — Transformer 编码器中每个注意力层的注意力头数。 - d_head (
int
, optional, 默认为 64) — 模型头部的维度。 - d_inner (
int
, optional, 默认为 4096) — FF 中的内部维度 - div_val (
int
, 可选, 默认为 4) — 用于自适应输入和softmax的股息值 - pre_lnorm (
boolean
, 可选, 默认为False
) — 是否在块中对输入而不是输出应用LayerNorm。 - n_layer (
int
, optional, 默认为 18) — Transformer 编码器中的隐藏层数。 - mem_len (
int
, optional, defaults to 1600) — 保留的先前头部的长度。 - clamp_len (
int
, 可选, 默认为 1000) — 在 clamp_len 之后使用相同的位置嵌入。 - same_length (
boolean
, optional, defaults toTrue
) — 是否对所有标记使用相同的注意力长度 - proj_share_all_but_first (
boolean
, 可选, 默认为True
) — True 表示共享除第一个项目外的所有项目,False 表示不共享。 - attn_type (
int
, 可选, 默认为 0) — 注意力类型。0 表示 Transformer-XL,1 表示 Shaw 等人,2 表示 Vaswani 等人,3 表示 Al Rfou 等人。 - sample_softmax (
int
, optional, defaults to -1) — 采样softmax中的样本数量。 - 自适应 (
boolean
, 可选, 默认为True
) — 是否使用自适应softmax. - dropout (
float
, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的dropout概率。 - dropatt (
float
, optional, defaults to 0.0) — 注意力概率的丢弃比率。 - untie_r (
boolean
, optional, defaults toTrue
) — 是否解除相对位置偏置的绑定。 - init (
str
, optional, defaults to"normal"
) — 使用的参数初始化器。 - init_range (
float
, 可选, 默认为 0.01) — 参数由 U(-init_range, init_range) 初始化。 - proj_init_std (
float
, optional, 默认值为 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值 - eos_token_id (
int
, optional, defaults to 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
TransfoXLTokenizer
类 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 = '
参数
- 特殊 (
List[str]
, 可选) — 一个特殊标记的列表(由该分词器的原始实现处理)。 - min_freq (
int
, optional, defaults to 0) — 一个词元必须出现的最小次数才能保留在词汇表中(否则它将被映射到unk_token
)。 - max_size (
int
, 可选) — 词汇表的最大大小。如果未设置,将默认为根据min_freq
规则排除标记后找到的词汇表大小。 - lower_case (
bool
, optional, defaults toFalse
) — 是否在分词时将输入转换为小写。 - delimiter (
str
, optional) — 用于分隔标记的分隔符。 - vocab_file (
str
, optional) — 包含词汇表的文件(来自原始实现)。 - pretrained_vocab_file (
str
, optional) — 包含词汇表的文件,该文件是通过save_pretrained()
方法保存的。 - never_split (
List[str]
, optional) — 不应被分割的标记列表。如果未指定列表,将仅使用现有的特殊标记。 - unk_token (
str
, optional, defaults to"
) — 未知标记。不在词汇表中的标记无法转换为ID,而是设置为该标记。" - eos_token (
str
, optional, defaults to"
) — 序列结束标记。" - additional_special_tokens (
List[str]
, 可选, 默认为['
) — 一个额外的特殊标记列表(用于HuggingFace功能)。'] - 语言 (
str
, 可选, 默认为"en"
) — 此分词器的语言(用于大多数预处理)。
构建一个从原始代码中的Vocab类改编的Transformer-XL分词器。Transformer-XL分词器是一个词级别的分词器(不进行子词分词)。
此分词器继承自PreTrainedTokenizer,其中包含了大部分主要方法。用户应参考此超类以获取有关这些方法的更多信息。
TransfoXL 特定输出
类 transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLModelOutput
< source >( last_hidden_state: FloatTensor mems: typing.List[torch.FloatTensor] = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor]] = None )
参数
- last_hidden_state (
torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
) — 模型最后一层输出的隐藏状态序列。 - mems (
List[torch.FloatTensor]
长度为config.n_layers
) — 包含预先计算的隐藏状态(注意力块中的键和值)。可以用于(参见mems
输入)加速顺序解码。已经计算过的过去令牌ID不应作为输入ID传递,因为它们已经被计算过了。 - hidden_states (
tuple(torch.FloatTensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) — Tuple oftorch.FloatTensor
(one for the output of the embeddings + one for the output of each layer) of shape(batch_size, sequence_length, hidden_size)
.模型在每一层输出处的隐藏状态加上初始嵌入输出。
- attentions (
tuple(torch.FloatTensor)
, optional, returned whenoutput_attentions=True
is passed or whenconfig.output_attentions=True
) — Tuple oftorch.FloatTensor
(one for each layer) of shape(batch_size, num_heads, sequence_length, sequence_length)
.注意力权重在注意力softmax之后,用于计算自注意力头中的加权平均值。
模型输出的基类,可能还包含过去的键/值(以加速顺序解码)。
类 transformers.models.deprecated.transfo_xl.modeling_transfo_xl.TransfoXLLMHeadModelOutput
< source >( losses: typing.Optional[torch.FloatTensor] = None prediction_scores: FloatTensor = None mems: typing.List[torch.FloatTensor] = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor]] = None loss: typing.Optional[torch.FloatTensor] = None )
参数
- losses (
torch.FloatTensor
of shape (batch_size, sequence_length-1), optional, 当提供labels
时返回) — 语言建模损失(未减少)。 - prediction_scores (
torch.FloatTensor
of shape(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测分数(SoftMax后每个词汇标记的分数)。 - mems (
List[torch.FloatTensor]
长度为config.n_layers
) — 包含预先计算的隐藏状态(注意力块中的键和值)。可以用于(参见mems
输入)加速顺序解码。已经计算过的过去标记ID不应作为输入ID传递,因为它们已经被计算过了。 - hidden_states (
tuple(torch.FloatTensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) — Tuple oftorch.FloatTensor
(one for the output of the embeddings + one for the output of each layer) of shape(batch_size, sequence_length, hidden_size)
.模型在每一层输出处的隐藏状态加上初始嵌入输出。
- attentions (
tuple(torch.FloatTensor)
, optional, returned whenoutput_attentions=True
is passed or whenconfig.output_attentions=True
) — Tuple oftorch.FloatTensor
(one for each layer) of shape(batch_size, num_heads, sequence_length, sequence_length)
.注意力权重在注意力softmax之后,用于计算自注意力头中的加权平均值。
- loss (
torch.FloatTensor
of shape()
, optional, 当提供labels
时返回) — 简化的语言建模损失。
模型输出的基类,可能还包含过去的键/值(以加速顺序解码)。
类 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
of shape(batch_size, sequence_length, hidden_size)
) — 模型最后一层输出的隐藏状态序列。 - mems (
List[tf.Tensor]
长度为config.n_layers
) — 包含预先计算的隐藏状态(注意力块中的键和值)。可以用于(参见mems
输入)加速顺序解码。已经计算过的过去令牌ID不应作为输入ID传递,因为它们已经被计算过了。 - hidden_states (
tuple(tf.Tensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) — Tuple oftf.Tensor
(one for the output of the embeddings + one for the output of each layer) of shape(batch_size, sequence_length, hidden_size)
.模型在每一层输出处的隐藏状态加上初始嵌入输出。
- attentions (
tuple(tf.Tensor)
, optional, returned whenoutput_attentions=True
is passed or whenconfig.output_attentions=True
) — Tuple oftf.Tensor
(one for each layer) of shape(batch_size, num_heads, sequence_length, sequence_length)
.注意力权重在注意力softmax之后,用于计算自注意力头中的加权平均值。
模型输出的基类,可能还包含过去的键/值(以加速顺序解码)。
类 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
of shape(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测分数(SoftMax后每个词汇标记的分数)。 - mems (
List[tf.Tensor]
长度为config.n_layers
) — 包含预计算的隐藏状态(注意力块中的键和值)。可以用于(参见mems
输入)加速顺序解码。已经将其过去状态提供给此模型的令牌ID不应 作为输入ID传递,因为它们已经被计算过了。 - hidden_states (
tuple(tf.Tensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) — Tuple oftf.Tensor
(one for the output of the embeddings + one for the output of each layer) of shape(batch_size, sequence_length, hidden_size)
.模型在每一层输出处的隐藏状态加上初始嵌入输出。
- attentions (
tuple(tf.Tensor)
, optional, returned whenoutput_attentions=True
is passed or whenconfig.output_attentions=True
) — Tuple oftf.Tensor
(one for each layer) of shape(batch_size, num_heads, sequence_length, sequence_length)
.注意力权重在注意力softmax之后,用于计算自注意力头中的加权平均值。
模型输出的基类,可能还包含过去的键/值(以加速顺序解码)。
TransfoXLModel
类 transformers.TransfoXLModel
< source >( config )
参数
- config (TransfoXLConfig) — 包含模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
裸的Bert模型转换器输出原始隐藏状态,没有任何特定的头部。
该模型继承自PreTrainedModel。请查看超类文档以了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入的大小、修剪头部等)。
该模型也是一个PyTorch torch.nn.Module 子类。 将其作为常规的PyTorch模块使用,并参考PyTorch文档以获取与一般使用和行为相关的所有信息。
前进
< source >( input_ids: typing.Optional[torch.LongTensor] = None mems: typing.Optional[typing.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
of shape(batch_size, sequence_length)
) — Indices of input sequence tokens in the vocabulary.可以使用AutoTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
- mems (
List[torch.FloatTensor]
长度为config.n_layers
) — 包含模型预先计算的隐藏状态(注意力块中的键和值)(参见下面的mems
输出)。可用于加速顺序解码。已经计算过的 token ids 不应作为input_ids
传递给此模型,因为它们已经被计算过了。 - head_mask (
torch.FloatTensor
形状为(num_heads,)
或(num_layers, num_heads)
, 可选) — 用于屏蔽自注意力模块中选定的头部的掩码。掩码值在[0, 1]
中选择:- 1 表示头部 未被屏蔽,
- 0 表示头部 被屏蔽.
- inputs_embeds (
torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 可选地,您可以选择直接传递嵌入表示,而不是传递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
类 transformers.TransfoXLLMHeadModel
< source >( config )
参数
- config (TransfoXLConfig) — 包含模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
Transformer-XL 模型,顶部带有语言建模头(自适应 softmax,权重与自适应输入嵌入绑定)
该模型继承自PreTrainedModel。请查看超类文档以了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入的大小、修剪头部等)。
该模型也是一个PyTorch torch.nn.Module 子类。 将其作为常规的PyTorch模块使用,并参考PyTorch文档以获取与一般使用和行为相关的所有信息。
前进
< source >( input_ids: typing.Optional[torch.LongTensor] = None mems: typing.Optional[typing.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 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) — Indices of input sequence tokens in the vocabulary.可以使用AutoTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
- mems (
List[torch.FloatTensor]
长度为config.n_layers
) — 包含模型计算出的预计算隐藏状态(注意力块中的键和值)(参见下面的mems
输出)。可用于加速顺序解码。已经计算过的 token ids 不应作为input_ids
传递给此模型,因为它们已经被计算过了。 - head_mask (
torch.FloatTensor
形状为(num_heads,)
或(num_layers, num_heads)
, 可选) — 用于屏蔽自注意力模块中选定的头部的掩码。掩码值在[0, 1]
中选择:- 1 表示头部 未被屏蔽,
- 0 表示头部 被屏蔽.
- inputs_embeds (
torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您希望对如何将input_ids
索引转换为相关向量有更多控制,而不是使用模型的内部嵌入查找矩阵,这将非常有用。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。 - labels (
torch.LongTensor
of shape(batch_size, sequence_length)
, optional) — 用于语言建模的标签。请注意,标签在模型内部被移位,即你可以设置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.logits
TransfoXLForSequenceClassification
类 transformers.TransfoXLForSequenceClassification
< source >( config )
参数
- config (TransfoXLConfig) — 包含模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
Transformer-XL 模型变压器,顶部带有序列分类头(线性层)。
TransfoXLForSequenceClassification 使用最后一个标记进行分类,与其他因果模型(例如 GPT-1)相同。
由于它对最后一个标记进行分类,因此需要知道最后一个标记的位置。如果在配置中定义了pad_token_id
,它会在每一行中找到不是填充标记的最后一个标记。如果没有定义pad_token_id
,它只需取批次中每一行的最后一个值。由于在传递inputs_embeds
而不是input_ids
时无法猜测填充标记,它会执行相同的操作(取批次中每一行的最后一个值)。
该模型继承自PreTrainedModel。请查看超类文档以了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入的大小、修剪头部等)。
该模型也是一个PyTorch torch.nn.Module 子类。 将其作为常规的PyTorch模块使用,并参考PyTorch文档以获取与一般使用和行为相关的所有信息。
前进
< source >( input_ids: typing.Optional[torch.LongTensor] = None mems: typing.Optional[typing.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
of shape(batch_size, sequence_length)
) — Indices of input sequence tokens in the vocabulary.可以使用AutoTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
- mems (
List[torch.FloatTensor]
长度为config.n_layers
) — 包含模型计算出的预计算隐藏状态(注意力块中的键和值)(参见下面的mems
输出)。可用于加速顺序解码。已经计算过的 token ids 不应作为input_ids
传递给此模型,因为它们已经被计算过了。 - head_mask (
torch.FloatTensor
形状为(num_heads,)
或(num_layers, num_heads)
, 可选) — 用于屏蔽自注意力模块中选定的头部的掩码。掩码值在[0, 1]
中选择:- 1 表示头部 未被屏蔽,
- 0 表示头部 被屏蔽.
- inputs_embeds (
torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 可选地,您可以选择直接传递嵌入表示,而不是传递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 (
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
输入)加速顺序解码。已经计算过的 token ids 不应作为输入 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 之后,用于计算自注意力头中的加权平均值。
TransfoXLForSequenceClassification 的前向方法,重写了 __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
TFTransfoXLModel
类 transformers.TFTransfoXLModel
< source >( config *inputs **kwargs )
参数
- config (TransfoXLConfig) — 包含模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型相关的权重,仅加载配置。查看 from_pretrained() 方法以加载模型权重。
裸的Bert模型转换器输出原始隐藏状态,没有任何特定的头部。
该模型继承自 TFPreTrainedModel。请查看超类文档以了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入的大小、修剪头部等)。
该模型也是一个keras.Model子类。可以将其作为常规的TF 2.0 Keras模型使用,并参考TF 2.0文档以了解与一般使用和行为相关的所有事项。
TensorFlow 模型和层在 transformers
中接受两种格式作为输入:
- 将所有输入作为关键字参数(如PyTorch模型),或
- 将所有输入作为列表、元组或字典放在第一个位置参数中。
支持第二种格式的原因是,Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持,当使用像 model.fit()
这样的方法时,事情应该“正常工作”——只需以 model.fit()
支持的任何格式传递你的输入和标签!然而,如果你想在 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函数一样传递输入!
调用
< 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
orNumpy array
of shape(batch_size, sequence_length)
) — Indices of input sequence tokens in the vocabulary.可以使用AutoTokenizer获取索引。详情请参见PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。
- mems (
List[tf.Tensor]
长度为config.n_layers
) — 包含模型计算的预计算隐藏状态(注意力块中的键和值)(见下面的mems
输出)。可用于加速顺序解码。已经计算过的 token ids 不应作为input_ids
传递给此模型,因为它们已经被计算过了。 - head_mask (
tf.Tensor
或Numpy array
形状为(num_heads,)
或(num_layers, num_heads)
, 可选) — 用于屏蔽自注意力模块中选定头部的掩码。掩码值在[0, 1]
中选择:- 1 表示头部 未被屏蔽,
- 0 表示头部 被屏蔽.
- inputs_embeds (
tf.Tensor
或Numpy array
形状为(batch_size, sequence_length, hidden_size)
, 可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您希望对如何将input_ids
索引转换为相关向量有更多控制,而不是使用模型的内部嵌入查找矩阵,这将非常有用。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量中的attentions
。此参数只能在eager模式下使用,在graph模式下将使用配置中的值。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。此参数只能在急切模式下使用,在图形模式下将使用配置中的值。 - return_dict (
bool
, 可选) — 是否返回一个ModelOutput而不是一个普通的元组。这个参数可以在eager模式下使用,在graph模式下该值将始终设置为True. - 训练 (
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
形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层输出的隐藏状态序列。 -
mems (
List[tf.Tensor]
长度为config.n_layers
) — 包含预计算的隐藏状态(注意力块中的键和值)。可以用于(参见mems
输入)加速顺序解码。已经将其过去状态提供给此模型的 token ids 不应 作为输入 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 后的注意力权重,用于计算自注意力头中的加权平均值。
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_state
TFTransfoXLLMHeadModel
类 transformers.TFTransfoXLLMHeadModel
< source >( config )
参数
- config (TransfoXLConfig) — 包含模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
Transformer-XL 模型,顶部带有语言建模头(自适应 softmax,权重与自适应输入嵌入绑定)
该模型继承自 TFPreTrainedModel。请查看超类文档以了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入的大小、修剪头部等)。
该模型也是一个keras.Model子类。可以将其作为常规的TF 2.0 Keras模型使用,并参考TF 2.0文档以了解与一般使用和行为相关的所有事项。
TensorFlow 模型和层在 transformers
中接受两种格式作为输入:
- 将所有输入作为关键字参数(如PyTorch模型),或
- 将所有输入作为列表、元组或字典放在第一个位置参数中。
支持第二种格式的原因是,Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持,当使用像 model.fit()
这样的方法时,事情应该“正常工作”——只需以 model.fit()
支持的任何格式传递你的输入和标签!然而,如果你想在 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函数一样传递输入!
调用
< 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 or tuple(tf.Tensor)
参数
- input_ids (
tf.Tensor
orNumpy array
of shape(batch_size, sequence_length)
) — Indices of input sequence tokens in the vocabulary.可以使用AutoTokenizer获取索引。详情请参见PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。
- mems (
List[tf.Tensor]
长度为config.n_layers
) — 包含模型计算出的预计算隐藏状态(注意力块中的键和值)(见下面的mems
输出)。可用于加速顺序解码。已经计算过的 token ids 不应作为input_ids
传递给此模型,因为它们已经被计算过了。 - head_mask (
tf.Tensor
或Numpy array
形状为(num_heads,)
或(num_layers, num_heads)
, 可选) — 用于屏蔽自注意力模块中选定头部的掩码。掩码值在[0, 1]
中选择:- 1 表示头部 未被屏蔽,
- 0 表示头部 被屏蔽.
- inputs_embeds (
tf.Tensor
或Numpy array
形状为(batch_size, sequence_length, hidden_size)
, 可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您希望对如何将input_ids
索引转换为相关向量有更多控制,而不是使用模型的内部嵌入查找矩阵,这将非常有用。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量中的attentions
。此参数只能在eager模式下使用,在graph模式下将使用配置中的值。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。此参数只能在eager模式下使用,在graph模式下将使用配置中的值。 - return_dict (
bool
, 可选) — 是否返回一个ModelOutput而不是一个普通的元组。此参数可以在eager模式下使用,在graph模式下该值将始终设置为True. - 训练 (
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 (
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 后的注意力权重,用于计算自注意力头中的加权平均值。
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
类 transformers.TFTransfoXLForSequenceClassification
< source >( config *inputs **kwargs )
参数
- config (TransfoXLConfig) — 包含模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
Transfo XL 模型变压器,顶部带有序列分类头(线性层)。
TFTransfoXLForSequenceClassification 使用最后一个标记进行分类,与其他因果模型(例如 GPT-1、GPT-2)相同。
由于它对最后一个标记进行分类,因此需要知道最后一个标记的位置。如果在配置中定义了pad_token_id
,它会在每一行中找到不是填充标记的最后一个标记。如果没有定义pad_token_id
,它只需取批次中每一行的最后一个值。由于在传递inputs_embeds
而不是input_ids
时无法猜测填充标记,它会执行相同的操作(取批次中每一行的最后一个值)。
该模型继承自 TFPreTrainedModel。请查看超类文档以了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入的大小、修剪头部等)。
该模型也是一个keras.Model子类。可以将其作为常规的TF 2.0 Keras模型使用,并参考TF 2.0文档以了解与一般使用和行为相关的所有事项。
TensorFlow 模型和层在 transformers
中接受两种格式作为输入:
- 将所有输入作为关键字参数(如PyTorch模型),或
- 将所有输入作为列表、元组或字典放在第一个位置参数中。
支持第二种格式的原因是,Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持,当使用像 model.fit()
这样的方法时,事情应该“正常工作”——只需以 model.fit()
支持的任何格式传递你的输入和标签!然而,如果你想在 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函数一样传递输入!
调用
< 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
orNumpy array
of shape(batch_size, sequence_length)
) — Indices of input sequence tokens in the vocabulary.可以使用AutoTokenizer获取索引。详情请参见PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。
- mems (
List[tf.Tensor]
长度为config.n_layers
) — 包含模型计算出的预计算隐藏状态(注意力块中的键和值)(参见下面的mems
输出)。可用于加速顺序解码。已经计算过的 token ids 不应作为input_ids
传递给此模型,因为它们已经被计算过了。 - head_mask (
tf.Tensor
或Numpy array
形状为(num_heads,)
或(num_layers, num_heads)
, 可选) — 用于屏蔽自注意力模块中选定头部的掩码。掩码值在[0, 1]
中选择:- 1 表示头部 未被屏蔽,
- 0 表示头部 被屏蔽.
- inputs_embeds (
tf.Tensor
或Numpy array
形状为(batch_size, sequence_length, hidden_size)
, 可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您希望对如何将input_ids
索引转换为相关向量有更多控制权,而不是使用模型的内部嵌入查找矩阵,这将非常有用。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量中的attentions
。此参数只能在eager模式下使用,在graph模式下将使用配置中的值。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。此参数只能在eager模式下使用,在graph模式下将使用配置中的值。 - return_dict (
bool
, 可选) — 是否返回一个ModelOutput而不是一个普通的元组。此参数可以在eager模式下使用,在graph模式下该值将始终设置为True. - 训练 (
bool
, 可选, 默认为False
) — 是否在训练模式下使用模型(一些模块如 dropout 模块在训练和评估之间有不同的行为)。 - labels (
tf.Tensor
of shape(batch_size, sequence_length)
, optional) — 用于计算交叉熵分类损失的标签。索引应在[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 (
tf.Tensor
形状为(1,)
, 可选, 当提供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 ids 不应作为输入 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 后的注意力权重,用于计算自注意力头中的加权平均值。
TFTransfoXLForSequenceClassification 的前向方法,重写了 __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
内部层
类 transformers.AdaptiveEmbedding
< source >( n_token d_embed d_proj cutoffs div_val = 1 sample_softmax = False )
类 transformers.TFAdaptiveEmbedding
< source >( n_token d_embed d_proj cutoffs div_val = 1 init_std = 0.02 sample_softmax = False **kwargs )