Transformers 4.37 中文文档（三十九）

原文：huggingface.co/docs/transformers

Jukebox

huggingface.co/docs/transformers/v4.37.2/en/model_doc/jukebox

概述

Jukebox 模型在 Jukebox: A generative model for music 中由 Prafulla Dhariwal, Heewoo Jun, Christine Payne, Jong Wook Kim, Alec Radford, Ilya Sutskever 提出。它引入了一个生成音乐模型，可以生成可以根据艺术家、流派和歌词进行条件化的一分钟长样本。

论文摘要如下：

我们推出了 Jukebox，这是一个在原始音频领域生成带有歌唱的音乐的模型。我们使用多尺度 VQ-VAE 来压缩原始音频的长上下文为离散代码，并使用自回归 Transformers 对其进行建模。我们展示了规模上的组合模型可以生成高保真度和多样化的歌曲，连贯性可达多分钟。我们可以根据艺术家和流派来引导音乐和声音风格，并根据不对齐的歌词来使歌唱更可控。我们发布了数千个非精选样本，以及模型权重和代码。

如下图所示，Jukebox 由 3 个仅解码器模型的 priors 组成。它们遵循使用稀疏 Transformers 生成长序列中描述的架构，经过修改以支持更长的上下文长度。首先，使用自编码器对文本歌词进行编码。接下来，第一个（也称为 top_prior）prior 关注从歌词编码器提取的最后隐藏状态。先前的 priors 通过 AudioConditionner 模块分别连接到前一个 priors。AudioConditioner 将先前 prior 的输出上采样到特定音频帧每秒的原始标记。元数据，如 艺术家、流派和时间，以起始标记和时间数据的位置嵌入的形式传递给每个 prior。隐藏状态被映射到 VQVAE 中最接近的码书向量，以将它们转换为原始音频。

该模型由 Arthur Zucker 贡献。原始代码可以在这里找到。

使用提示

该模型仅支持推理。这主要是因为训练需要大量内存。欢迎提交 PR 并添加缺失的内容，以实现与 Hugging Face Trainer 的完全集成！
该模型非常慢，使用 V100 GPU 上的 5b 顶部 prior 生成一分钟长的音频需要 8 小时。为了自动处理模型应在其上执行的设备，请使用 accelerate。
与论文相反，prior 的顺序从 0 到 1，因为这样更直观：我们从 0 开始采样。
基于预先采样（在原始音频上进行采样）需要比祖先采样更多的内存，并且应该将 fp16 设置为 True。

该模型由 Arthur Zucker 贡献。原始代码可以在这里找到。

JukeboxConfig

transformers.JukeboxConfig 类

< source >

代码语言：javascript复制

( vqvae_config = None prior_config_list = None nb_priors = 3 sampling_rate = 44100 timing_dims = 64 min_duration = 0 max_duration = 600.0 max_nb_genres = 5 metadata_conditioning = True **kwargs )

参数

vqvae_config (JukeboxVQVAEConfig, 可选) — JukeboxVQVAE 模型的配置。
prior_config_list (List[JukeboxPriorConfig], 可选) — 模型中每个 JukeboxPrior 的配置列表。原始架构使用了 3 个 priors。
nb_priors (int, 可选, 默认为 3) — 将依次采样标记的先前模型数量。每个 prior 都是条件自回归（解码器）模型，除了顶部 prior 可以包括歌词编码器。可用的模型是使用顶部 prior 和 2 个上采样 prior 进行训练的。
sampling_rate (int, optional, defaults to 44100) — 原始音频的采样率。
timing_dims (int, optional, defaults to 64) — JukeboxRangeEmbedding 层的维度，相当于传统的位置嵌入层。定时嵌入层将当前采样音频中的绝对位置和相对位置转换为长度为timing_dims的张量，该张量将添加到音乐标记中。
min_duration (int, optional, defaults to 0) — 生成音频的最小持续时间
max_duration (float, optional, defaults to 600.0) — 生成音频的最大持续时间
max_nb_genres (int, optional, defaults to 5) — 可用于调节单个样本的最大流派数量。
metadata_conditioning (bool, optional, defaults to True) — 是否使用元数据调节，对应于艺术家、流派和最小/最大持续时间。

这是一个配置类，用于存储 JukeboxModel 的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。使用默认值实例化配置将产生类似于openai/jukebox-1b-lyrics架构的配置。

下采样和步幅用于确定输入序列的下采样。例如，下采样 = (5,3)，步幅 = (2, 2) 将使音频下采样为 2⁵ = 32，以获得第一级代码，以及 2**8 = 256，以获得第二级代码。这在训练顶层先验和上采样器时通常是正确的。

示例：

代码语言：javascript复制

>>> from transformers import JukeboxModel, JukeboxConfig

>>> # Initializing a Jukebox configuration
>>> configuration = JukeboxConfig()

>>> # Initializing a model from the configuration
>>> model = JukeboxModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

`from_configs`

< source >

代码语言：javascript复制

( prior_configs: List vqvae_config: JukeboxVQVAEConfig **kwargs ) → export const metadata = 'undefined';JukeboxConfig

JukeboxConfig

配置对象的一个实例

从剪辑文本模型配置和剪辑视觉模型配置实例化一个 JukeboxConfig（或派生类）的实例。

JukeboxPriorConfig

`class transformers.JukeboxPriorConfig`

< source >

代码语言：javascript复制

( act_fn = 'quick_gelu' level = 0 alignment_head = 2 alignment_layer = 68 attention_multiplier = 0.25 attention_pattern = 'enc_dec_with_lyrics' attn_dropout = 0 attn_res_scale = False blocks = 64 conv_res_scale = None num_layers = 72 emb_dropout = 0 encoder_config = None encoder_loss_fraction = 0.4 hidden_size = 2048 init_scale = 0.2 is_encoder_decoder = True lyric_vocab_size = 80 mask = False max_duration = 600 max_nb_genres = 1 merged_decoder = True metadata_conditioning = True metadata_dims = [604, 7898] min_duration = 0 mlp_multiplier = 1.0 music_vocab_size = 2048 n_ctx = 6144 n_heads = 2 nb_relevant_lyric_tokens = 384 res_conv_depth = 3 res_conv_width = 128 res_convolution_multiplier = 1 res_dilation_cycle = None res_dilation_growth_rate = 1 res_downs_t = [3, 2, 2] res_strides_t = [2, 2, 2] resid_dropout = 0 sampling_rate = 44100 spread = None timing_dims = 64 zero_out = False **kwargs )

参数

act_fn (str, optional, defaults to "quick_gelu") — 激活函数。
alignment_head (int, optional, defaults to 2) — 负责歌词和音乐之间对齐的头部。仅用于计算歌词到音频的对齐
alignment_layer (int, optional, defaults to 68) — 负责歌词和音乐之间对齐的层的索引。仅用于计算歌词到音频的对齐
attention_multiplier (float, optional, defaults to 0.25) — 用于定义注意力层隐藏维度的乘数系数。0.25 表示将使用模型宽度的 0.25。
attention_pattern (str, optional, defaults to "enc_dec_with_lyrics") — 解码器使用的注意力模式
attn_dropout (int, optional, defaults to 0) — 解码器中注意力层后的丢弃概率。
attn_res_scale (bool, optional, defaults to False) — 是否在注意力调节器块中缩放残差。
blocks (int, optional, defaults to 64) — block_attn 中使用的块数。长度为 seq_len 的序列在JukeboxAttention层中被分解为[blocks, seq_len // blocks]。
conv_res_scale (int, optional) — 是否要在条件块中缩放残差。由于顶层先验没有条件块，因此默认值为None，不应修改。
num_layers (int, optional, 默认为 72) — 变压器架构的层数。
emb_dropout (int, optional, 默认为 0) — 歌词解码器中使用的嵌入丢失。
encoder_config (JukeboxPriorConfig, optional) — 对歌词先验进行建模的编码器配置。
encoder_loss_fraction (float, optional, 默认为 0.4) — 用于歌词编码器损失前面的乘法因子。
hidden_size (int, optional, 默认为 2048) — 注意力层的隐藏维度。
init_scale (float, optional, 默认为 0.2) — 先验模块的初始化比例。
is_encoder_decoder (bool, optional, 默认为True) — 先验是否为编码器-解码器模型。如果不是，并且nb_relevant_lyric_tokens大于 0，则应为歌词编码指定encoder参数。
mask (bool, optional, 默认为False) — 是否要屏蔽注意力中的先前位置。
max_duration (int, optional, 默认为 600) — 生成歌曲的最大支持持续时间（以秒为单位）。
max_nb_genres (int, optional, 默认为 1) — 可用于条件模型的最大流派数量。
merged_decoder (bool, optional, 默认为True) — 解码器和编码器输入是否合并。这用于分离的编码器-解码器架构
metadata_conditioning (bool, optional, 默认为True) — 是否要在艺术家和流派元数据上进行条件。
metadata_dims (List[int], optional, 默认为[604, 7898]) — 用于训练先验模型的嵌入层的流派数量和艺术家数量。
min_duration (int, optional, 默认为 0) — 模型训练的生成音频的最小持续时间。
mlp_multiplier (float, optional, 默认为 1.0) — 用于定义 MLP 层隐藏维度的乘数系数。0.25 表示将使用模型宽度的 0.25。
music_vocab_size (int, optional, 默认为 2048) — 不同音乐标记的数量。应与JukeboxVQVAEConfig.nb_discrete_codes类似。
n_ctx (int, optional, 默认为 6144) — 每个先验的上下文标记数量。上下文标记是在生成音乐标记时所关注的音乐标记。
n_heads (int, optional, 默认为 2) — 注意力头的数量。
nb_relevant_lyric_tokens (int, optional, 默认为 384) — 在采样长度为n_ctx的单个窗口时使用的歌词标记数量
res_conv_depth (int, optional, 默认为 3) — 用于在JukeboxMusicTokenConditioner中上采样先前采样音频的JukeboxDecoderConvBock的深度。
res_conv_width (int, optional, 默认为 128) — 用于在JukeboxMusicTokenConditioner中上采样先前采样音频的JukeboxDecoderConvBock的宽度。
res_convolution_multiplier (int, optional, 默认为 1) — 用于缩放JukeboxResConv1DBlock的hidden_dim的乘数。
res_dilation_cycle (int, optional) — 用于定义JukeboxMusicTokenConditioner的扩张周期。通常类似于 VQVAE 相应级别中使用的周期。第一个先验不使用它，因为它不是基于上一级标记的。
res_dilation_growth_rate (int, optional, 默认为 1) — 用于JukeboxMusicTokenConditioner的每个卷积块之间的扩张增长率
res_downs_t (List[int], optional, 默认为[3, 2, 2]) — 音频调节网络中使用的下采样率
res_strides_t (List[int], optional, 默认为[2, 2, 2]) — 音频调节网络中使用的步幅
resid_dropout (int, optional, defaults to 0) — 注意力模式中使用的残差丢失。
sampling_rate (int, optional, defaults to 44100) — 用于训练的采样率。
spread (int, optional) — summary_spread_attention模式中使用的扩展
timing_dims (int, optional, defaults to 64) — 时间嵌入的维度。
zero_out (bool, optional, defaults to False) — 初始化时是否将卷积权重归零。

这是配置类，用于存储 JukeboxPrior 的配置。根据指定的参数实例化JukeboxPrior，定义模型架构。使用默认值实例化配置将产生类似于 openai/jukebox-1b-lyrics -1b-lyrics)架构顶级先验的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

JukeboxVQVAEConfig

`class transformers.JukeboxVQVAEConfig`

<来源>

代码语言：javascript复制

( act_fn = 'relu' nb_discrete_codes = 2048 commit = 0.02 conv_input_shape = 1 conv_res_scale = False embed_dim = 64 hop_fraction = [0.125, 0.5, 0.5] levels = 3 lmu = 0.99 multipliers = [2, 1, 1] res_conv_depth = 4 res_conv_width = 32 res_convolution_multiplier = 1 res_dilation_cycle = None res_dilation_growth_rate = 3 res_downs_t = [3, 2, 2] res_strides_t = [2, 2, 2] sample_length = 1058304 init_scale = 0.2 zero_out = False **kwargs )

参数

act_fn (str, optional, defaults to "relu") — 模型的激活函数。
nb_discrete_codes (int, optional, defaults to 2048) — VQVAE 的代码数量。
commit (float, optional, defaults to 0.02) — 提交损失乘数。
conv_input_shape (int, optional, defaults to 1) — 音频通道数。
conv_res_scale (bool, optional, defaults to False) — 是否对JukeboxResConv1DBlock的残差进行缩放。
embed_dim (int, optional, defaults to 64) — 码书向量的嵌入维度。
hop_fraction (List[int], optional, defaults to [0.125, 0.5, 0.5]) — 在继续采样过程时使用的非交叉窗口的比例。
levels (int, optional, defaults to 3) — VQVAE 中使用的分层级别数。
lmu (float, optional, defaults to 0.99) — 用于码书更新的指数移动平均系数。有关详细信息，请参阅原始VQVAE 论文的附录 A.1
multipliers (List[int], optional, defaults to [2, 1, 1]) — 每个级别使用的深度和宽度乘数。用于res_conv_width和res_conv_depth
res_conv_depth (int, optional, defaults to 4) — 编码器和解码器块的深度。如果没有使用multipliers，则每个级别的深度相同。
res_conv_width (int, optional, defaults to 32) — 编码器和解码器块的宽度。如果没有使用multipliers，则每个级别的宽度相同。
res_convolution_multiplier (int, optional, defaults to 1) — JukeboxResConv1DBlock中使用的隐藏维度的缩放因子。
res_dilation_cycle (int, optional) — JukeboxResnet中使用的膨胀周期值。如果使用 int，每个新的 Conv1 块的深度将减少res_dilation_cycle的幂。
res_dilation_growth_rate (int, optional, defaults to 3) — VQVAE 中使用的 Resnet 膨胀增长率（膨胀增长率 ** 深度）
res_downs_t (List[int], optional, defaults to [3, 2, 2]) — 分层 VQ-VAE 每个级别的下采样率。
res_strides_t (List[int], optional, defaults to [2, 2, 2]) — 分层 VQ-VAE 每个级别使用的步幅。
sample_length (int, optional, defaults to 1058304) — 提供 VQVAE 的最大输入形状。用于计算每个级别的输入形状。
init_scale (float, optional, defaults to 0.2) — 初始化比例。
zero_out (bool, optional, defaults to False) — 是否在初始化时将卷积权重归零。

这是用于存储 JukeboxVQVAE 配置的配置类。它用于根据指定的参数实例化JukeboxVQVAE，定义模型架构。使用默认值实例化配置将产生与openai/jukebox-1b-lyrics架构的 VQVAE 类似的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

JukeboxTokenizer

`class transformers.JukeboxTokenizer`

<来源>

代码语言：javascript复制

( artists_file genres_file lyrics_file version = ['v3', 'v2', 'v2'] max_n_lyric_tokens = 512 n_genres = 5 unk_token = '<|endoftext|>' **kwargs )

参数

artists_file (str) — 包含艺术家和 id 之间映射的词汇文件的路径。默认文件支持“v2”和“v3”。
genres_file (str) — 包含流派和 id 之间映射的词汇文件的路径。
lyrics_file (str) — 包含歌词分词所需字符的词汇文件的路径。
version (List[str], optional, default to ["v3", "v2", "v2"]) — 分词器版本的列表。5b-lyrics的顶级先验模型是使用v3而不是v2进行训练的。
n_genres (int, optional, defaults to 1) — 用于作曲的最大流派数量。
max_n_lyric_tokens (int, optional, defaults to 512) — 保留的最大歌词标记数量。
unk_token（str，optional，默认为"<|endoftext|>"）–未知令牌。词汇表中没有的令牌无法转换为 ID，而是设置为该令牌。

构建一个 Jukebox 分词器。Jukebox 可以根据 3 种不同的输入进行条件化：

艺术家，唯一的 id 与提供的字典中的每位艺术家相关联。
流派，唯一的 id 与提供的字典中的每个流派相关联。
歌词，基于字符的分词。必须使用词汇表中包含的字符列表进行初始化。

这个分词器不需要训练。它应该能够处理不同数量的输入：因为模型的条件化可以在三个不同的查询上进行。如果未提供 None，则将使用默认值。

取决于模型应该被条件化的流派数量（n_genres）。

代码语言：javascript复制

>>> from transformers import JukeboxTokenizer

>>> tokenizer = JukeboxTokenizer.from_pretrained("openai/jukebox-1b-lyrics")
>>> tokenizer("Alan Jackson", "Country Rock", "old town road")["input_ids"]
[tensor([[   0,    0,    0, 6785,  546,   41,   38,   30,   76,   46,   41,   49,
           40,   76,   44,   41,   27,   30]]), tensor([[  0,   0,   0, 145,   0]]), tensor([[  0,   0,   0, 145,   0]])]

您可以通过在实例化此分词器时或在对某些文本调用它时传递add_prefix_space=True来避免这种行为，但由于模型不是以这种方式进行预训练的，因此可能会导致性能下降。

如果未提供任何内容，则流派和艺术家将随机选择或设置为 None

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

但是代码不允许这样做，只支持从各种流派进行作曲。

`save_vocabulary`

<来源>

代码语言：javascript复制

( save_directory: str filename_prefix: Optional = None )

参数

save_directory (str) — 保存的目录路径。如果不存在，将创建该目录。
filename_prefix (Optional[str], optional) — 添加到分词器保存的文件名称前缀。

将分词器的词汇字典保存到提供的保存目录中。

JukeboxModel

`class transformers.JukeboxModel`

<来源>

代码语言：javascript复制

( config )

参数

config（JukeboxConfig）- 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

用于音乐生成的基本 JUKEBOX 模型。支持 4 种采样技术：primed_sample、upsample、continue_sample和ancestral_sample。它没有forward方法，因为训练不是端到端的。如果要微调模型，建议使用JukeboxPrior类并分别训练每个先验。

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

这个模型也是 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

`ancestral_sample`

<来源>

代码语言：javascript复制

( labels n_samples = 1 **sampling_kwargs )

参数

labels（List[torch.LongTensor]）- 长度为n_sample的列表，形状为(self.levels, 4 self.config.max_nb_genre lyric_sequence_length)，元数据，例如artist_id、genre_id和用于条件生成的完整歌词标记列表。
n_samples（int，可选，默认为 1）- 要并行生成的样本数量。

根据提供的labels生成音乐标记。将从所需的先验级别开始，并自动上采样序列。如果要创建音频，应调用model.decode(tokens)，这将使用 VQ-VAE 解码器将音乐标记转换为原始音频。

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, JukeboxModel, set_seed

>>> model = JukeboxModel.from_pretrained("openai/jukebox-1b-lyrics", min_duration=0).eval()
>>> tokenizer = AutoTokenizer.from_pretrained("openai/jukebox-1b-lyrics")

>>> lyrics = "Hey, are you awake? Can you talk to me?"
>>> artist = "Zac Brown Band"
>>> genre = "Country"
>>> metas = tokenizer(artist=artist, genres=genre, lyrics=lyrics)
>>> set_seed(0)
>>> music_tokens = model.ancestral_sample(metas.input_ids, sample_length=400)

>>> with torch.no_grad():
...     model.decode(music_tokens)[:, :10].squeeze(-1)
tensor([[-0.0219, -0.0679, -0.1050, -0.1203, -0.1271, -0.0936, -0.0396, -0.0405,
    -0.0818, -0.0697]])

`primed_sample`

<来源>

代码语言：javascript复制

( raw_audio labels **sampling_kwargs )

参数

raw_audio（长度为n_samples的List[torch.Tensor]）- 用作每个将生成的样本的条件信息的原始音频列表。
labels（长度为n_sample的List[torch.LongTensor]，形状为(self.levels, self.config.max_nb_genre lyric_sequence_length)）- 元数据列表，例如artist_id、genre_id和用于条件生成的完整歌词标记列表。
sampling_kwargs（Dict[Any]）- _sample函数使用的各种额外采样参数。可以在_sample函数文档中看到参数的详细列表。

根据提供的raw_audio生成原始音频，该音频将用作每个生成级别的条件。音频被编码为音乐标记，使用 VQ-VAE 的 3 个级别。这些标记被用作每个级别的条件，这意味着不需要祖先抽样。

`continue_sample`

<来源>

代码语言：javascript复制

( music_tokens labels **sampling_kwargs )

参数

music_tokens（长度为self.levels的List[torch.LongTensor]）- 一系列音乐标记，将用作继续采样过程的上下文。应该有self.levels个张量，每个对应于特定级别的生成。
labels（长度为n_sample的List[torch.LongTensor]，形状为(self.levels, self.config.max_nb_genre lyric_sequence_length)）- 元数据列表，例如artist_id、genre_id和用于条件生成的完整歌词标记列表。
sampling_kwargs (Dict[Any]) — 由_sample函数使用的各种额外采样参数。参数的详细列表可以在_sample函数文档中看到。

生成先前生成标记的延续。

`upsample`

<来源>

代码语言：javascript复制

( music_tokens labels **sampling_kwargs )

参数

music_tokens (List[torch.LongTensor]，长度为self.levels) — 一系列音乐标记，将用作继续采样过程的上下文。应该有self.levels个张量，每个对应于某个级别的生成。
labels (List[torch.LongTensor]，长度为n_sample，形状为(self.levels, self.config.max_nb_genre lyric_sequence_length) — 包括元数据，如artist_id、genre_id以及用于条件生成的完整歌词标记列表。
sampling_kwargs (Dict[Any]) — 由_sample函数使用的各种额外采样参数。参数的详细列表可以在_sample函数文档中看到。

使用级别level的先验对音乐标记序列进行上采样。

`_sample`

<来源>

代码语言：javascript复制

( music_tokens labels sample_levels metas = None chunk_size = 32 sampling_temperature = 0.98 lower_batch_size = 16 max_batch_size = 16 sample_length_in_seconds = 24 compute_alignments = False sample_tokens = None offset = 0 save_results = True sample_length = None )

参数

music_tokens (List[torch.LongTensor]) — 音乐标记序列，长度为self.levels，将用作继续采样过程的上下文。应该有self.levels个张量，每个对应于某个级别的生成。
labels (List[torch.LongTensor]) — 长度为n_sample的列表，形状为(self.levels, 4 self.config.max_nb_genre lyric_sequence_length)，包括artist_id、genre_id等元数据以及用于条件生成的完整歌词标记列表。
sample_levels (List[int]) — 要进行采样的期望级别列表。级别等同于先验列表中的先验索引
metas (List[Any], 可选) — 用于生成labels的元数据
chunk_size (int, 可选, 默认为 32) — 音频块的大小，用于以块的形式填充内存，以防止 OOM 错误。更大的块意味着更快的内存填充但更多的消耗。
sampling_temperature (float, 可选, 默认为 0.98) — 用于调整采样随机性的温度。
lower_batch_size (int, 可选, 默认为 16) — 低级别先验的最大批处理大小
max_batch_size (int, 可选, 默认为 16) — 顶层先验的最大批处理大小
sample_length_in_seconds (int, 可选, 默认为 24) — 生成的长度（秒数）
compute_alignments (bool, 可选, 默认为False) — 是否计算歌词和音频之间的对齐，使用顶级先验
sample_tokens (int, 可选) — 每个级别应采样的精确标记数。这对于运行虚拟实验非常有用
offset (int, 可选, 默认为 0) — 用作条件的音频偏移，对应于音乐中的起始样本。如果偏移大于 0，则歌词将被移位以考虑这一点
save_results (bool, 可选, 默认为True) — 是否保存中间结果。如果为True，将生成一个以开始时间命名的文件夹。
sample_length (int, 可选) — 生成的长度（样本数）。

用于生成音乐标记的核心采样函数。在每一步保存生成的原始音频，遍历提供的级别列表。

返回：torch.Tensor

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, JukeboxModel, set_seed
>>> import torch

>>> metas = dict(artist="Zac Brown Band", genres="Country", lyrics="I met a traveller from an antique land")
>>> tokenizer = AutoTokenizer.from_pretrained("openai/jukebox-1b-lyrics")
>>> model = JukeboxModel.from_pretrained("openai/jukebox-1b-lyrics", min_duration=0).eval()

>>> labels = tokenizer(**metas)["input_ids"]
>>> set_seed(0)
>>> zs = [torch.zeros(1, 0, dtype=torch.long) for _ in range(3)]
>>> zs = model._sample(zs, labels, [0], sample_length=40 * model.priors[0].raw_to_tokens, save_results=False)
>>> zs[0]
tensor([[1853, 1369, 1150, 1869, 1379, 1789,  519,  710, 1306, 1100, 1229,  519,
      353, 1306, 1379, 1053,  519,  653, 1631, 1467, 1229, 1229,   10, 1647,
     1254, 1229, 1306, 1528, 1789,  216, 1631, 1434,  653,  475, 1150, 1528,
     1804,  541, 1804, 1434]])

JukeboxPrior

`class transformers.JukeboxPrior`

<来源>

代码语言：javascript复制

( config: JukeboxPriorConfig level = None nb_priors = 3 vqvae_encoder = None vqvae_decoder = None )

参数

config（JukeboxPriorConfig）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。
level（int，可选）— 先验的当前级别。应在范围[0,nb_priors]内。
nb_priors（int，可选，默认为 3）— 先验总数。
vqvae_encoder（Callable，可选）— VQVAE 编码器在模型前向传递中使用的编码方法。传递函数而不是 vqvae 模块以避免获取参数。
vqvae_decoder（Callable，可选）— 在模型的前向传递中使用的 VQVAE 解码器的解码方法。传递函数而不是 vqvae 模块以避免获取参数。

JukeboxPrior 类是各种条件和变压器的包装器。JukeboxPrior 可以被视为在音乐上训练的语言模型。它们对下一个音乐标记预测任务进行建模。如果定义了（歌词）编码器，它还对歌词上的下一个字符预测进行建模。可以基于定时、艺术家、流派、歌词和来自较低级先验的代码进行条件化。

`sample`

<来源>

代码语言：javascript复制

( n_samples music_tokens = None music_tokens_conds = None metadata = None temp = 1.0 top_k = 0 top_p = 0.0 chunk_size = None sample_tokens = None )

参数

n_samples（int）— 要生成的样本数。
music_tokens（List[torch.LongTensor]，可选）— 当前级别上先前生成的标记。用作生成的上下文。
music_tokens_conds（List[torch.FloatTensor]，可选）— 由先前先验模型生成的上层音乐标记。如果生成不是基于上层标记的，则为None。
metadata（List[torch.LongTensor]，可选）— 包含包含艺术家、流派和歌词标记的元数据张量的列表。
temp（float，可选，默认为 1.0）— 采样温度。
top_k（int，可选，默认为 0）— 用于过滤的前 k 个概率。
top_p（float，可选，默认为 0.0）— 用于过滤的前 p 个概率。
chunk_size（int，可选）— 用于准备变压器缓存的块的大小。
sample_tokens（int，可选）— 要采样的标记数。

使用提供的条件和元数据对标记窗口进行祖先/主要采样。

`forward`

<来源>

代码语言：javascript复制

( hidden_states: Tensor metadata: Optional decode: Optional = False get_preds: Optional = False )

参数

hidden_states（torch.Tensor）— 应为原始音频的隐藏状态
metadata（List[torch.LongTensor]，可选）— 包含歌词和元数据标记的元数据条件张量的列表。
decode（bool，可选，默认为False）— 是否解码编码为标记。
get_preds（bool，可选，默认为False）— 是否返回模型的实际预测。

使用vqvae编码器对隐藏状态进行编码，然后在forward_tokens函数中预测下一个标记。损失是encoder损失和decoder损失的总和。

JukeboxVQVAE

`class transformers.JukeboxVQVAE`

<来源>

代码语言：javascript复制

( config: JukeboxVQVAEConfig )

参数

config（JukeboxConfig）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

Jukebox 中使用的分层 VQ-VAE 模型。该模型遵循Will Williams, Sam Ringer, Tom Ash, John Hughes, David MacLeod, Jamie Dougherty的 Hierarchical VQVAE 论文。

该模型继承自 PreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法（例如下载或保存，调整输入嵌入，修剪头等）。

该模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

`forward`

<来源>

代码语言：javascript复制

( raw_audio: FloatTensor )

参数

raw_audio (torch.FloatTensor) — 音频输入，将被编码和解码。

VQ-VAE 的前向传递，将raw_audio编码为潜在状态，然后为每个级别解码。计算提交损失，确保编码器计算的嵌入接近码书向量。

示例：

代码语言：javascript复制

>>> from transformers import JukeboxVQVAE, set_seed
>>> import torch

>>> model = JukeboxVQVAE.from_pretrained("openai/jukebox-1b-lyrics").eval()
>>> set_seed(0)
>>> zs = [torch.randint(100, (4, 1))]
>>> model.decode(zs).shape
torch.Size([4, 8, 1])

`encode`

<来源>

代码语言：javascript复制

( input_audio start_level = 0 end_level = None bs_chunks = 1 )

参数

input_audio（torch.Tensor）— 将被编码为其离散表示的原始音频，使用码书。将为每个样本序列计算最接近码书的code。
start_level（int，可选，默认为 0）— 编码过程将开始的级别。默认为 0。
end_level（int，可选）— 编码过程将开始的级别。默认为 None。
bs_chunks（int，可选，默认为 1）— 要同时处理的原始音频块数。

将input_audio转换为由music_tokens组成的离散表示。

`decode`

<来源>

代码语言：javascript复制

( music_tokens start_level = 0 end_level = None bs_chunks = 1 )

参数

music_tokens（torch.LongTensor）— 将通过使用码书解码为原始音频的音乐标记张量。每个音乐标记应该是码书中对应code向量的索引。
start_level（int，可选）— 解码过程将开始的级别。默认为 0。
end_level（int，可选）— 解码过程将开始的级别。默认为 None。
bs_chunks（int，可选）— 要同时处理的块数。

将输入的music_tokens转换为它们的raw_audio表示。

LED

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/led

概述

LED 模型是由 Iz Beltagy、Matthew E. Peters、Arman Cohan 在Longformer: The Long-Document Transformer中提出的。

论文的摘要如下：

基于 Transformer 的模型由于其自注意力操作，无法处理长序列，其操作随着序列长度呈二次方增长。为了解决这一限制，我们引入了 Longformer，其注意力机制与序列长度呈线性增长，使得处理数千个标记或更长文档变得容易。Longformer 的注意力机制是标准自注意力的替代品，结合了局部窗口注意力和任务驱动的全局注意力。在长序列 Transformer 的先前工作基础上，我们在字符级语言建模上评估 Longformer，并在 text8 和 enwik8 上取得了最先进的结果。与大多数先前的工作相比，我们还对 Longformer 进行预训练，并在各种下游任务上进行微调。我们的预训练 Longformer 在长文档任务上始终优于 RoBERTa，并在 WikiHop 和 TriviaQA 上取得了最新的最先进结果。最后，我们介绍了 Longformer-Encoder-Decoder（LED），这是 Longformer 的一种变体，用于支持长文档生成的序列到序列任务，并展示了其在 arXiv 摘要数据集上的有效性。

使用提示

LEDForConditionalGeneration 是 BartForConditionalGeneration 的扩展，用Longformer的分块自注意力层替换传统的自注意力层。LEDTokenizer 是 BartTokenizer 的别名。
LED 在长距离序列到序列任务中表现非常出色，其中input_ids大部分超过 1024 个标记的长度。
如果需要，LED 会将input_ids填充为config.attention_window的倍数。因此，当 LEDTokenizer 与pad_to_multiple_of参数一起使用时，可以获得一定的加速。
LED 通过global_attention_mask（参见 LongformerModel）利用全局注意力。对于摘要，建议仅在第一个<s>标记上放置全局注意力。对于问答，建议在问题的所有标记上放置全局注意力。
要在所有 16384 上微调 LED，如果训练导致内存不足（OOM）错误，可以启用梯度检查点。这可以通过执行model.gradient_checkpointing_enable()来实现。此外，可以使用use_cache=False标志来禁用缓存机制以节省内存。
LED 是一个具有绝对位置嵌入的模型，因此通常建议在右侧而不是左侧填充输入。

此模型由patrickvonplaten贡献。

资源

展示如何评估 LED 的笔记本。
展示如何微调 LED 的笔记本。
文本分类任务指南
问答任务指南
翻译任务指南
总结任务指南

LEDConfig

`class transformers.LEDConfig`

< source >

代码语言：javascript复制

( vocab_size = 50265 max_encoder_position_embeddings = 16384 max_decoder_position_embeddings = 1024 encoder_layers = 12 encoder_ffn_dim = 4096 encoder_attention_heads = 16 decoder_layers = 12 decoder_ffn_dim = 4096 decoder_attention_heads = 16 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 use_cache = True is_encoder_decoder = True activation_function = 'gelu' d_model = 1024 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 decoder_start_token_id = 2 classifier_dropout = 0.0 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 attention_window: Union = 512 **kwargs )

参数

vocab_size (int, optional, defaults to 50265) — LED 模型的词汇表大小。定义了在调用 LEDModel 或 TFLEDModel 时可以表示的不同标记数量。
d_model (int, optional, defaults to 1024) — 层和池化器层的维度。
encoder_layers (int, optional, defaults to 12) — 编码器层数。
decoder_layers (int, optional, defaults to 12) — 解码器层数。
encoder_attention_heads (int, optional, defaults to 16) — Transformer 编码器中每个注意力层的注意力头数。
decoder_attention_heads (int, optional, defaults to 16) — Transformer 解码器中每个注意力层的注意力头数。
decoder_ffn_dim (int, optional, defaults to 4096) — 解码器中“中间”（通常称为前馈）层的维度。
encoder_ffn_dim (int, optional, defaults to 4096) — 解码器中“中间”（通常称为前馈）层的维度。
activation_function (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。
dropout (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
attention_dropout (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。
activation_dropout (float, optional, defaults to 0.0) — 全连接层内激活的 dropout 比率。
classifier_dropout (float, optional, defaults to 0.0) — 分类器的 dropout 比率。
max_encoder_position_embeddings (int, optional, defaults to 16384) — 编码器可能使用的最大序列长度。
max_decoder_position_embeddings (int, optional, defaults to 16384) — 解码器可能使用的最大序列长度。
init_std (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
encoder_layerdrop (float, optional, defaults to 0.0) — 编码器的 LayerDrop 概率。更多细节请参阅 LayerDrop paper)。
decoder_layerdrop (float, optional, defaults to 0.0) — 解码器的 LayerDrop 概率。更多细节请参阅 LayerDrop paper)。
use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。

这是用于存储 LEDModel 配置的配置类。根据指定的参数实例化一个 LED 模型，定义模型架构。使用默认值实例化配置将产生类似于allenai/led-base-16384架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

代码语言：javascript复制

>>> from transformers import LEDModel, LEDConfig

>>> # Initializing a LED allenai/led-base-16384 style configuration
>>> configuration = LEDConfig()

>>> # Initializing a model from the allenai/led-base-16384 style configuration
>>> model = LEDModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

LEDTokenizer

`class transformers.LEDTokenizer`

< source >

代码语言：javascript复制

( vocab_file merges_file errors = 'replace' bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' add_prefix_space = False **kwargs )

参数

vocab_file (str) — 词汇文件的路径。
merges_file (str) — 合并文件的路径。
errors (str, optional, defaults to "replace") — 解码字节为 UTF-8 时要遵循的范例。有关更多信息，请参阅bytes.decode。
bos_token (str, optional, defaults to "<s>") — 在预训练期间使用的序列开头标记。可用作序列分类器标记。在使用特殊标记构建序列时，不是用于序列开头的标记。使用的标记是 cls_token。
eos_token (str, optional, defaults to "</s>") — 序列结束标记。在使用特殊标记构建序列时，不是用于序列结尾的标记。使用的标记是 sep_token。
sep_token (str, optional, defaults to "</s>") — 分隔符标记，在从多个序列构建序列时使用，例如用于序列分类的两个序列或用于问答的文本和问题。它还用作使用特殊标记构建的序列的最后一个标记。
cls_token (str, optional, defaults to "<s>") — 在进行序列分类（整个序列的分类而不是每个标记的分类）时使用的分类器标记。在使用特殊标记构建时，它是序列的第一个标记。
unk_token (str, optional, defaults to "<unk>") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。
pad_token (str, optional, defaults to "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时。
mask_token (str, optional, defaults to "<mask>") — 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
add_prefix_space (bool, optional, defaults to False) — 是否在输入前添加一个初始空格。这允许将前导单词视为任何其他单词。（BART 分词器通过前面的空格检测单词的开头）。

构建一个 LED 分词器，类似于 ROBERTa 分词器，使用字节级字节对编码。

此分词器已经训练过，将空格视为标记的一部分（有点像 sentencepiece），因此一个单词将

在句子开头（无空格）或不在句子开头时，将以不同方式编码：

代码语言：javascript复制

>>> from transformers import LEDTokenizer

>>> tokenizer = LEDTokenizer.from_pretrained("allenai/led-base-16384")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]

>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]

您可以通过在实例化此分词器时或在对某些文本调用它时传递 add_prefix_space=True 来避免这种行为，但由于模型不是以这种方式进行预训练的，因此可能会降低性能。

当与 is_split_into_words=True 一起使用时，此分词器将在每个单词之前添加一个空格（甚至是第一个单词）。

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

`build_inputs_with_special_tokens`

< source >

代码语言：javascript复制

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表。
token_ids_1 (List[int], optional) — 序列对的可选第二个 ID 列表。

List[int]

具有适当特殊标记的输入 ID 列表。

通过连接和添加特殊标记从序列或序列对构建用于序列分类任务的模型输入。LED 序列的格式如下：

单个序列：<s> X </s>
序列对：<s> A </s></s> B </s>

`get_special_tokens_mask`

<来源>

代码语言：javascript复制

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

token_ids_0（List[int]）— ID 列表。
token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。
already_has_special_tokens（bool，可选，默认为False）— 标记列表是否已经格式化为模型的特殊标记。

List[int]

一个整数列表，范围为[0, 1]：1 表示特殊标记，0 表示序列标记。

从没有添加特殊标记的标记列表中检索序列 ID。在使用标记器prepare_for_model方法添加特殊标记时调用此方法。

`create_token_type_ids_from_sequences`

<来源>

代码语言：javascript复制

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0（List[int]）— ID 列表。
token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。

List[int]

零列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。LED 不使用标记类型 ID，因此返回一个零列表。

`save_vocabulary`

<来源>

代码语言：javascript复制

( save_directory: str filename_prefix: Optional = None )

LEDTokenizerFast

`class transformers.LEDTokenizerFast`

<来源>

代码语言：javascript复制

( vocab_file = None merges_file = None tokenizer_file = None errors = 'replace' bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' add_prefix_space = False trim_offsets = True **kwargs )

参数

vocab_file（str）— 词汇文件的路径。
merges_file（str）— 合并文件的路径。
errors（str，可选，默认为"replace"）— 解码字节为 UTF-8 时要遵循的范例。有关更多信息，请参见bytes.decode。
bos_token（str，可选，默认为"<s>"）— 在预训练期间使用的序列开头标记。可以用作序列分类器标记。在使用特殊标记构建序列时，这不是用于序列开头的标记。使用的标记是cls_token。
eos_token（str，可选，默认为"</s>"）— 序列结束标记。在使用特殊标记构建序列时，这不是用于序列结尾的标记。使用的标记是sep_token。
sep_token（str，可选，默认为"</s>"）— 分隔符标记，在从多个序列构建序列时使用，例如用于序列分类的两个序列或用于文本和问题的问题回答。它还用作使用特殊标记构建的序列的最后一个标记。
cls_token（str，可选，默认为"<s>"）— 在进行序列分类（对整个序列而不是每个标记进行分类）时使用的分类器标记。在使用特殊标记构建序列时，它是序列的第一个标记。
unk_token（str，可选，默认为"<unk>"）— 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。
pad_token（str，可选，默认为"<pad>"）— 用于填充的标记，例如在批处理不同长度的序列时。
mask_token（str，可选，默认为"<mask>"）— 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
add_prefix_space（bool，可选，默认为False）— 是否在输入前添加一个初始空格。这允许将前导单词视为任何其他单词。（LED 标记器通过前导空格检测单词的开头）。
trim_offsets（bool，可选，默认为True）— 后处理步骤是否应修剪偏移以避免包含空格。

构建一个“快速”LED 分词器（由 HuggingFace 的tokenizers库支持），源自 GPT-2 分词器，使用字节级字节对编码。

这个分词器已经训练过，将空格视为标记的一部分（有点像 sentencepiece），所以一个单词会被编码成不同的方式

无论是在句子开头（没有空格）还是不是，都会被编码成不同的方式：

代码语言：javascript复制

>>> from transformers import LEDTokenizerFast

>>> tokenizer = LEDTokenizerFast.from_pretrained("allenai/led-base-16384")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]

>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]

您可以通过在实例化这个分词器时或在对一些文本调用它时传递add_prefix_space=True来避免这种行为，但由于模型不是以这种方式进行预训练的，可能会导致性能下降。

当与is_split_into_words=True一起使用时，这个分词器需要用add_prefix_space=True实例化。

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

`create_token_type_ids_from_sequences`

<来源>

代码语言：javascript复制

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0（List[int]）— ID 列表。
token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。

List[int]

零的列表。

从传递的两个序列中创建一个用于序列对分类任务的掩码。LED 不使用标记类型 ID，因此返回一个零的列表。

LED 特定的输出

class transformers.models.led.modeling_led.LEDEncoderBaseModelOutput

<来源>

代码语言：javascript复制

( last_hidden_state: FloatTensor hidden_states: Optional = None attentions: Optional = None global_attentions: Optional = None )

参数

last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）— 模型最后一层的隐藏状态的序列。
hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，一个用于每一层的输出）。模型在每一层输出的隐藏状态加上初始嵌入输出。
attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, x attention_window 1)的torch.FloatTensor元组（每层一个），其中x是具有全局注意力掩码的标记数。在注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是从序列中的每个标记到具有全局注意力的每个标记（前x个值）和到注意力窗口中的每个标记（剩余attention_window个值）的注意力权重
- 1values)。注意，前x个值是指文本中固定位置的标记，但剩余的attention_window 1个值是指相对位置的标记：一个标记到自身的注意力权重位于索引x attention_window / 2，前（后）attention_window / 2个值是指到前（后）attention_window / 2个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，相应索引处的注意力权重设置为 0；值应该从前x个注意力权重中访问。如果一个标记具有全局注意力，那么attentions中所有其他标记的注意力权重都设置为 0，值应该从global_attentions`中访问。
global_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, x)的torch.FloatTensor元组（每层一个），其中x是具有全局注意力掩码的令牌数。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个令牌与序列中每个令牌的全局注意力的注意力权重。

LEDEncoder 输出的基类，具有潜在的隐藏状态、局部和全局注意力。

`class transformers.models.led.modeling_led.LEDSeq2SeqModelOutput`

<来源>

代码语言：javascript复制

( last_hidden_state: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None encoder_global_attentions: Optional = None )

参数

last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的隐藏状态序列输出。如果使用past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后隐藏状态。
past_key_values (List[torch.FloatTensor]，可选，当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的torch.FloatTensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。包含解码器的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码。
decoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出一个用于每层的输出）。每层解码器的隐藏状态加上初始嵌入输出。
decoder_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的隐藏状态序列输出。
encoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出一个用于每层的输出）。每层解码器的隐藏状态加上初始嵌入输出。
encoder_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
encoder_global_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, x)的torch.FloatTensor元组，其中x是具有全局注意力掩码的令牌数。在注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个令牌对序列中每个令牌的全局注意力的注意力权重。

模型编码器输出的基类，还包含：可加速顺序解码的预计算隐藏状态。

`class transformers.models.led.modeling_led.LEDSeq2SeqLMOutput`

<来源>

代码语言：javascript复制

( loss: Optional = None logits: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None encoder_global_attentions: Optional = None )

参数

loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）- 语言建模损失。
logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）- 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
past_key_values（List[torch.FloatTensor]，可选，当传递use_cache=True或当config.use_cache=True时返回）- 长度为config.n_layers的torch.FloatTensor列表，每个张量形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。包含解码器的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。
decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。解码器在每一层输出的隐藏状态加上初始嵌入输出。
decoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
cross_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
encoder_last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 模型编码器最后一层的隐藏状态序列。
encoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。编码器在每一层输出的隐藏状态加上初始嵌入输出。
encoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
encoder_global_attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x)的torch.FloatTensor元组（每层一个），其中x是具有全局注意力掩码的令牌数。在注意力 SoftMax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是来自每个具有全局注意力的令牌对序列中每个令牌的注意力权重。

用于序列到序列语言模型输出的基类。

`class transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput`

<来源>

代码语言：javascript复制

( loss: Optional = None logits: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None encoder_global_attentions: Optional = None )

参数

loss (torch.FloatTensor，形状为(1,), 可选, 当提供label时返回) — 分类（如果config.num_labels==1则为回归）损失。
logits (torch.FloatTensor，形状为(batch_size, config.num_labels)) — SoftMax 之前的分类（如果config.num_labels==1则为回归）分数。
past_key_values (List[torch.FloatTensor], 可选, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的torch.FloatTensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。包含解码器的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。
decoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入输出，一个用于每层输出）。每层解码器的隐藏状态以及初始嵌入输出。
decoder_attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器的注意力权重，在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器交叉注意力层的注意力权重，在注意力 SoftMax 之后，用于计算交叉注意力头中的加权平均值。
encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的隐藏状态序列。
encoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入输出，一个用于每层输出）。每层编码器的隐藏状态以及初始嵌入输出。
encoder_attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。编码器的注意力权重，在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。
encoder_global_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x)的torch.FloatTensor元组，其中x是具有全局注意力掩码的令牌数量。全局注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。这些是来自具有全局注意力的每个令牌到序列中每个令牌的注意力权重。

用于序列到序列句子分类模型输出的基类。

`class transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput`

<来源>

代码语言：javascript复制

( loss: Optional = None start_logits: FloatTensor = None end_logits: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None encoder_global_attentions: Optional = None )

参数

loss (torch.FloatTensor，形状为(1,)，optional, 当提供labels时返回) — 总跨度提取损失是起始位置和结束位置的交叉熵之和。
start_logits (torch.FloatTensor，形状为(batch_size, sequence_length)) — 跨度起始分数（SoftMax 之前）。
end_logits (torch.FloatTensor，形状为(batch_size, sequence_length)) — 跨度结束分数（SoftMax 之前）。
past_key_values (List[torch.FloatTensor], optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的torch.FloatTensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。包含解码器的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。
decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。解码器在每一层输出的隐藏状态加上初始嵌入输出。
decoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型编码器最后一层的隐藏状态序列。
encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。编码器在每一层输出的隐藏状态加上初始嵌入输出。
encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
encoder_global_attentions (tuple(torch.FloatTensor), 可选的, 当传递 output_attentions=True 或者当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, x) 的 torch.FloatTensor 元组（每层一个），其中 x 是具有全局注意力掩码的令牌数量。在注意力 softmax 后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是从具有全局注意力的每个令牌到序列中的每个令牌的注意力权重。

用于序列到序列问答模型输出的基类。

`class transformers.models.led.modeling_tf_led.TFLEDEncoderBaseModelOutput`

<来源>

代码语言：javascript复制

( last_hidden_state: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None global_attentions: Tuple[tf.Tensor] | None = None )

参数

last_hidden_state (tf.Tensor，形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
hidden_states (tuple(tf.Tensor)，可选的，当传递 output_hidden_states=True 或者当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组（一个用于嵌入的输出一个用于每一层的输出）。模型在每一层输出的隐藏状态以及初始嵌入输出。
attentions (tuple(tf.Tensor)，可选的，当传递 output_attentions=True 或者当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, x attention_window 1) 的 tf.Tensor 元组（每层一个），其中 x 是具有全局注意力掩码的令牌数量。在注意力 softmax 后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是从序列中的每个令牌到具有全局注意力的每个令牌（前 x 个值）以及到注意力窗口中的每个令牌（剩余的 attention_window）的注意力权重。
- 注意：前 x 个值指的是文本中具有固定位置的令牌，但剩余的 attention_window 1 个值指的是具有相对位置的令牌：一个令牌到自身的注意力权重位于索引 x attention_window / 2，前（后）的 attention_window / 2 个值是到前（后）的令牌的注意力权重。如果注意力窗口包含具有全局注意力的令牌，则相应索引处的注意力权重设置为 0；该值应从前 x 个注意力权重中获取。如果一个令牌具有全局注意力，则到attentions中的所有其他令牌的注意力权重设置为 0，应从global_attentions中获取值。
global_attentions (tuple(tf.Tensor)，可选的，当传递 output_attentions=True 或者当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, x) 的 tf.Tensor 元组（每层一个），其中 x 是具有全局注意力掩码的令牌数量。在注意力 softmax 后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是从具有全局注意力的每个令牌到序列中的每个令牌的注意力权重。

Longformer 输出的基类，具有潜在的隐藏状态、局部和全局注意力。

`class transformers.models.led.modeling_tf_led.TFLEDSeq2SeqModelOutput`

<来源>

代码语言：javascript复制

( last_hidden_state: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None decoder_hidden_states: Tuple[tf.Tensor] | None = None decoder_attentions: Tuple[tf.Tensor] | None = None cross_attentions: Tuple[tf.Tensor] | None = None encoder_last_hidden_state: tf.Tensor | None = None encoder_hidden_states: Tuple[tf.Tensor] | None = None encoder_attentions: Tuple[tf.Tensor] | None = None encoder_global_attentions: Tuple[tf.Tensor] | None = None )

参数

last_hidden_state (tf.Tensor，形状为 (batch_size, sequence_length, hidden_size)) — 解码器模型最后一层的隐藏状态序列。如果使用 past_key_values，则仅输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。
past_key_values（List[tf.Tensor]，可选，当传递use_cache=True或config.use_cache=True时返回）- 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。包含解码器的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码。
decoder_hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入输出，一个用于每层输出）。每层解码器的隐藏状态加上初始嵌入输出。
decoder_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。解码器的注意力权重，在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。
cross_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。解码器的交叉注意力层的注意力权重，在注意力 SoftMax 之后，用于计算交叉注意力头中的加权平均值。
encoder_last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）- 模型编码器最后一层的隐藏状态序列。
encoder_hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入输出，一个用于每层输出）。每层编码器的隐藏状态加上初始嵌入输出。
encoder_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。编码器的注意力权重，在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。
encoder_global_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, x)的tf.Tensor元组（每层一个），其中x是具有全局注意力掩码的令牌数。在注意力 SoftMax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的令牌对序列中每个令牌的注意力权重。

模型编码器输出的基类，还包含：可加速顺序解码的预计算隐藏状态。

`class transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput`

<来源>

代码语言：javascript复制

( loss: tf.Tensor | None = None logits: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None decoder_hidden_states: Tuple[tf.Tensor] | None = None decoder_attentions: Tuple[tf.Tensor] | None = None cross_attentions: Tuple[tf.Tensor] | None = None encoder_last_hidden_state: tf.Tensor | None = None encoder_hidden_states: Tuple[tf.Tensor] | None = None encoder_attentions: Tuple[tf.Tensor] | None = None encoder_global_attentions: Tuple[tf.Tensor] | None = None )

参数

loss（形状为(1,)的tf.Tensor，可选，当提供labels时返回）- 语言建模损失。
logits（形状为(batch_size, sequence_length, config.vocab_size)的tf.Tensor）- 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
past_key_values (List[tf.Tensor], optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。包含解码器的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。
decoder_hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出一个用于每个层的输出）。解码器在每个层输出的隐藏状态加上初始嵌入输出。
decoder_attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每个层一个）。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每个层一个）。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
encoder_last_hidden_state (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型编码器最后一层的隐藏状态序列。
encoder_hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出一个用于每个层的输出）。编码器在每个层输出的隐藏状态加上初始嵌入输出。
encoder_attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每个层一个）。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
encoder_global_attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x)的tf.Tensor元组（每个层一个），其中x是具有全局注意力掩码的令牌数。全局注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。这些是来自每个令牌对整个序列中每个令牌的全局注意力权重。

用于序列到序列语言模型输出的基类。

PytorchHide Pytorch content

LEDModel

`class transformers.LEDModel`

< source >

代码语言：javascript复制

( config: LEDConfig )

参数

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

裸 LED 模型输出原始隐藏状态，没有特定的头部。该模型继承自 PreTrainedModel。请参阅超类文档，了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头部等）。

该模型还是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取一般用法和行为。

`forward`

<来源>

代码语言：javascript复制

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None global_attention_mask: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqModelOutput or tuple(torch.FloatTensor)

参数

input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。默认情况下将忽略填充。可以使用 AutoTokenizer 来获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：
- 1 表示未被屏蔽的标记，
- 0 表示被屏蔽的标记。
什么是注意力掩码？
decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 词汇表中解码器输入序列标记的索引。可以使用LedTokenizer来获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是输入 ID？ LED 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则可以选择仅输入最后的decoder_input_ids（请参阅past_key_values）。
decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果掩码也将默认使用。如果要更改填充行为，应阅读modeling_led._prepare_decoder_inputs并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。
global_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于决定每个标记的注意力，编码器的局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于任务特定的微调非常重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予全局注意力。对于问答，所有问题标记也应该具有全局注意力。有关更多详细信息，请参阅Longformer 论文。掩码值选在[0, 1]之间：
- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（关注所有其他标记的标记，所有其他标记也关注它们）。
head_mask（形状为(encoder_layers, encoder_attention_heads)的torch.Tensor，可选）— 用于使编码器中注意力模块的选定头部失效的掩码。掩码值选在[0, 1]之间：
- 1 表示头部未被屏蔽，
- 0 表示头部被masked。
decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于使解码器中注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]中：
- 1 表示头部未被masked。
- 0 表示头部被masked。
cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于使解码器中交叉注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]中：
- 1 表示头部未被masked，
- 0 表示头部被masked。
encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）— 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的tuple(torch.FloatTensor)的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。如果使用了past_key_values，用户可以选择仅输入最后的decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的）的形状为(batch_size, 1)的张量，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。
decoder_inputs_embeds（形状为(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示而不是传递decoder_input_ids。如果使用了past_key_values，则只需输入最后的decoder_inputs_embeds（参见past_key_values）。如果您想要更多控制如何将decoder_input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。如果decoder_input_ids和decoder_inputs_embeds都未设置，则decoder_inputs_embeds取inputs_embeds的值。
use_cache（bool，可选）— 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。

transformers.modeling_outputs.Seq2SeqModelOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.Seq2SeqModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时），包含根据配置(LEDConfig)和输入的不同元素。

last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的隐藏状态序列。如果使用past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。
past_key_values (tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的元组tuple(torch.FloatTensor)，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。
decoder_hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 解码器隐藏状态的元组，形状为(batch_size, sequence_length, hidden_size)，其中包括嵌入层的输出和每个层的输出。解码器在每一层的输出的隐藏状态，以及可选的初始嵌入输出。
decoder_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 元组torch.FloatTensor（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 元组torch.FloatTensor（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的隐藏状态序列。
encoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 元组torch.FloatTensor（如果模型有嵌入层，则为一个，每个层的输出为一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层的输出的隐藏状态，以及可选的初始嵌入输出。
encoder_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 元组torch.FloatTensor（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, LEDModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = LEDModel.from_pretrained("allenai/led-base-16384")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

LEDForConditionalGeneration

`class transformers.LEDForConditionalGeneration`

<来源>

代码语言：javascript复制

( config: LEDConfig )

参数

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

具有语言建模头的 LED 模型。可用于摘要。此模型继承自 PreTrainedModel。请参阅超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

此模型还是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取一般用法和行为。

`forward`

<来源>

代码语言：javascript复制

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None global_attention_mask: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)

参数

input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）— 避免对填充标记索引执行注意力的掩码。掩码值选在[0, 1]中：
- 1 表示“未屏蔽”的标记，
- 0 表示“屏蔽”的标记。
什么是注意力掩码？
decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 词汇表中解码器输入序列标记的索引。可以使用LedTokenizer获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是输入 ID？ LED 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则只需选择最后的decoder_input_ids作为输入（请参阅past_key_values）。
decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。默认情况下还将使用因果掩码。如果要更改填充行为，应阅读modeling_led._prepare_decoder_inputs并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。
global_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于决定每个标记的注意力分配，编码器的局部注意力或全局注意力。具有全局注意力的标记关注所有其他标记，所有其他标记也关注它们。这对于任务特定的微调很重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予全局注意力。对于问答，所有问题标记也应该具有全局注意力。有关更多详细信息，请参考Longformer paper。掩码值选在[0, 1]之间：
- 0 表示局部注意力（滑动窗口注意力），
- 全局注意力为 1（关注所有其他标记，所有其他标记也关注它们）。
head_mask（形状为(encoder_layers, encoder_attention_heads)的torch.Tensor，可选）— 用于在编码器中使注意力模块的特定头部失效的掩码。掩码值选在[0, 1]之间：
- 1 表示头部未被遮蔽。
- 0 表示头部被遮蔽。
decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于在解码器中使注意力模块的特定头部失效的掩码。掩码值选在[0, 1]之间：
- 1 表示头部未被遮蔽，
- 0 表示头部被遮蔽。
cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于在解码器中使交叉注意力模块的特定头部失效的掩码。掩码值选在[0, 1]之间：
- 1 表示头部未被遮蔽，
- 0 表示头部被遮蔽。
encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）— 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的tuple(torch.FloatTensor)的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。如果使用了past_key_values，用户可以选择只输入最后的decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是模型内部的嵌入查找矩阵，则这很有用。
decoder_inputs_embeds（形状为(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选择直接传递嵌入表示，而不是传递decoder_input_ids。如果使用了past_key_values，可以选择只输入最后的decoder_inputs_embeds（参见past_key_values）。如果您想要更多控制如何将decoder_input_ids索引转换为相关向量，而不是模型内部的嵌入查找矩阵，则这很有用。如果decoder_input_ids和decoder_inputs_embeds都未设置，则decoder_inputs_embeds取inputs_embeds的值。
use_cache（bool，可选）- 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。
output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回的张量下的attentions。
output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回的张量下的hidden_states。
return_dict（bool，可选）- 是否返回一个 ModelOutput 而不是一个普通元组。
labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]范围内，或者为-100（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有[0, ..., config.vocab_size]标签的标记。

transformers.modeling_outputs.Seq2SeqLMOutput 或tuple(torch.FloatTensor)

transformers.modeling_outputs.Seq2SeqLMOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（LEDConfig）和输入的不同元素。

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

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

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

条件生成示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, LEDForConditionalGeneration

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> TXT = "My friends are <mask> but they eat too many carbs."

>>> model = LEDForConditionalGeneration.from_pretrained("allenai/led-base-16384")
>>> input_ids = tokenizer([TXT], return_tensors="pt")["input_ids"]

>>> prediction = model.generate(input_ids)[0]
>>> print(tokenizer.decode(prediction, skip_special_tokens=True))

摘要示例：

代码语言：javascript复制

>>> import torch
>>> from transformers import AutoTokenizer, LEDForConditionalGeneration

>>> model = LEDForConditionalGeneration.from_pretrained("allenai/led-large-16384-arxiv")
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-large-16384-arxiv")

>>> ARTICLE_TO_SUMMARIZE = '''Transformers (Vaswani et al., 2017) have achieved state-of-the-art
...     results in a wide range of natural language tasks including generative language modeling
...     (Dai et al., 2019; Radford et al., 2019) and discriminative ... language understanding (Devlin et al., 2019).
...     This success is partly due to the self-attention component which enables the network to capture contextual
...     information from the entire sequence. While powerful, the memory and computational requirements of
...     self-attention grow quadratically with sequence length, making it infeasible (or very expensive) to
...     process long sequences. To address this limitation, we present Longformer, a modified Transformer
...     architecture with a self-attention operation that scales linearly with the sequence length, making it
...     versatile for processing long documents (Fig 1). This is an advantage for natural language tasks such as
...     long document classification, question answering (QA), and coreference resolution, where existing approaches
...     partition or shorten the long context into smaller sequences that fall within the typical 512 token limit
...     of BERT-style pretrained models. Such partitioning could potentially result in loss of important
...     cross-partition information, and to mitigate this problem, existing methods often rely on complex
...     architectures to address such interactions. On the other hand, our proposed Longformer is able to build
...     contextual representations of the entire context using multiple layers of attention, reducing the need for
...     task-specific architectures.'''
>>> inputs = tokenizer.encode(ARTICLE_TO_SUMMARIZE, return_tensors="pt")

>>> # Global attention on the first token (cf. Beltagy et al. 2020)
>>> global_attention_mask = torch.zeros_like(inputs)
>>> global_attention_mask[:, 0] = 1

>>> # Generate Summary
>>> summary_ids = model.generate(inputs, global_attention_mask=global_attention_mask, num_beams=3, max_length=32)
>>> print(tokenizer.decode(summary_ids[0], skip_special_tokens=True, clean_up_tokenization_spaces=True))

LEDForSequenceClassification

`class transformers.LEDForSequenceClassification`

<来源>

代码语言：javascript复制

( config: LEDConfig **kwargs )

参数

config（LEDConfig） — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

在顶部具有序列分类/头（在汇总输出的顶部有一个线性层）的 LED 模型，例如用于 GLUE 任务。

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

该模型也是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取一般用法和行为。

`forward`

<来源>

代码语言：javascript复制

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None global_attention_mask: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput or tuple(torch.FloatTensor)

参数

input_ids（形状为(batch_size, sequence_length)的torch.LongTensor） — 词汇表中输入序列标记的索引。默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选） — 避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：
- 对于未被掩盖的标记为 1，
- 对于被掩盖的标记为 0。
什么是注意力掩码？
decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）- 词汇表中解码器输入序列标记的索引。可以使用LedTokenizer获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是输入 ID？ LED 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则只需输入最后的decoder_input_ids（参见past_key_values）。
decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）- 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。如果要更改填充行为，应阅读modeling_led._prepare_decoder_inputs并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。
global_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 用于决定每个标记上给定的注意力，编码器的局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，而所有其他标记会关注它们。这对于任务特定的微调很重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予全局注意力。对于问答，所有问题标记也应该具有全局注意力。有关更多详细信息，请参阅Longformer paper。在[0, 1]中选择的掩码值：
- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（关注所有其他标记的标记，所有其他标记也关注它们）。
head_mask（形状为(encoder_layers, encoder_attention_heads)的torch.Tensor，可选）- 用于在编码器中的注意力模块中使选定的头部失效的掩码。在[0, 1]中选择的掩码值：
- 1 表示头部未被遮罩，
- 0 表示头部被遮罩。
decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）- 用于在解码器中的注意力模块中使选定的头部失效的掩码。在[0, 1]中选择的掩码值：
- 1 表示头部未被遮罩，
- 0 表示头部被遮罩。
cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）- 用于在解码器中的交叉注意力模块中使选定的头部失效的掩码。在[0, 1]中选择的掩码值：
- 1 表示头部未被遮罩。
- 0 表示头部被遮罩。
encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）- 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）- 长度为config.n_layers的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（请参见past_key_values输入）。如果使用了past_key_values，用户可以选择仅输入形状为(batch_size, 1)的最后一个decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的）而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。
decoder_inputs_embeds（形状为(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选择直接传递嵌入表示，而不是传递decoder_input_ids。如果使用了past_key_values，则可以选择仅输入最后一个decoder_inputs_embeds（参见past_key_values）。如果您想要更多控制如何将decoder_input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。如果decoder_input_ids和decoder_inputs_embeds都未设置，则decoder_inputs_embeds取inputs_embeds的值。
use_cache（bool，可选）— 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的attentions。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的hidden_states。
return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。
labels（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels > 1，则计算分类损失（交叉熵）。

transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput 或tuple(torch.FloatTensor)

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

loss（形状为(1,)的torch.FloatTensor，可选，当提供label时返回）— 分类（如果config.num_labels==1则为回归）损失。
logits（形状为(batch_size, config.num_labels)的torch.FloatTensor）— 分类（如果config.num_labels==1则为回归）得分（SoftMax 之前）。
past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。
decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的一个每层输出的一个）。解码器在每一层输出的隐藏状态加上初始嵌入输出。
decoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
cross_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
encoder_last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选） — 模型编码器最后一层的隐藏状态序列。
encoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的一个每层输出的一个）。编码器在每一层输出的隐藏状态加上初始嵌入输出。
encoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

单标签分类示例：

代码语言：javascript复制

>>> import torch
>>> from transformers import AutoTokenizer, LEDForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = LEDForSequenceClassification.from_pretrained("allenai/led-base-16384")

>>> 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 = LEDForSequenceClassification.from_pretrained("allenai/led-base-16384", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss

多标签分类示例：

代码语言：javascript复制

>>> import torch
>>> from transformers import AutoTokenizer, LEDForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = LEDForSequenceClassification.from_pretrained("allenai/led-base-16384", 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 = LEDForSequenceClassification.from_pretrained(
...     "allenai/led-base-16384", 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

LEDForQuestionAnswering

`class transformers.LEDForQuestionAnswering`

<来源>

代码语言：javascript复制

( config )

参数

config（LEDConfig） — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

LED 模型顶部带有用于类似 SQuAD 的抽取式问答任务的跨度分类头（在隐藏状态输出顶部的线性层上计算span start logits和span end logits）。

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

此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取一般用法和行为。

`forward`

< source >

代码语言：javascript复制

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None global_attention_mask: Optional = None start_positions: Optional = None end_positions: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput or tuple(torch.FloatTensor)

参数

input_ids（形状为 (batch_size, sequence_length) 的 torch.LongTensor）— 词汇表中输入序列标记的索引。默认情况下会忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？
attention_mask（形状为 (batch_size, sequence_length) 的 torch.Tensor，可选）— 避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1]：
- 1 表示未被屏蔽的标记，
- 0 表示被屏蔽的标记。
什么是注意力掩码？
decoder_input_ids（形状为 (batch_size, target_sequence_length) 的 torch.LongTensor，可选）— 词汇表中解码器输入序列标记的索引。可以使用 LedTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？ LED 使用 eos_token_id 作为 decoder_input_ids 生成的起始标记。如果使用 past_key_values，则可选择仅输入最后的 decoder_input_ids（参见 past_key_values）。
decoder_attention_mask（形状为 (batch_size, target_sequence_length) 的 torch.LongTensor，可选）— 默认行为：生成一个张量，忽略 decoder_input_ids 中的填充标记。默认情况下也会使用因果掩码。如果要更改填充行为，应阅读 modeling_led._prepare_decoder_inputs 并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。
global_attention_mask（形状为 (batch_size, sequence_length) 的 torch.FloatTensor，可选）— 决定给予每个标记的注意力，编码器的局部注意力或全局注意力。具有全局注意力的标记关注所有其他标记，所有其他标记也关注它们。这对于任务特定的微调很重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给予全局注意力。对于问答，所有问题标记也应该具有全局注意力。有关更多详细信息，请参阅 Longformer 论文。掩码值选在 [0, 1]：
- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（关注所有其他标记，所有其他标记也关注它们）。
head_mask（形状为 (encoder_layers, encoder_attention_heads) 的 torch.Tensor，可选）— 在编码器中使注意力模块的选定头部失效的掩码。掩码值选在 [0, 1]：
- 1 表示头部未被屏蔽，
- 0 表示头部被屏蔽。
decoder_head_mask（torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选）- 用于在解码器中使注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]中：
- 1 表示头部未被掩码，
- 0 表示头部被掩码。
cross_attn_head_mask（torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选）- 用于在解码器中使交叉注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]中：
- 1 表示头部未被掩码，
- 0 表示头部被掩码。
encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）- 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）- 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，以及 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。如果使用了past_key_values，用户可以选择仅输入最后的decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）的形状为(batch_size, 1)的张量，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。
inputs_embeds（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
decoder_inputs_embeds（torch.FloatTensor，形状为(batch_size, target_sequence_length, hidden_size)，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。如果使用了past_key_values，则可以选择仅输入最后的decoder_inputs_embeds（请参见past_key_values）。如果您希望更多地控制如何将decoder_input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。如果decoder_input_ids和decoder_inputs_embeds都未设置，则decoder_inputs_embeds取inputs_embeds的值。
use_cache（bool，可选）- 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（请参见past_key_values）。
output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict（bool，可选）- 是否返回一个 ModelOutput 而不是一个普通元组。
start_positions（torch.LongTensor，形状为(batch_size,)，可选）- 用于计算标记跨度的开始位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会用于计算损失。
end_positions (torch.LongTensor of shape (batch_size,), optional) — 用于计算标记跨度结束位置的位置（索引）标签。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内计算损失。

transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（LEDConfig）和输入的不同元素。

loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 总跨度提取损失是开始和结束位置的交叉熵之和。
start_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 跨度开始得分（SoftMax 之前）。
end_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 跨度结束得分（SoftMax 之前）。
past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。
decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的输出每层的输出）。解码器在每一层的隐藏状态加上初始嵌入输出。
decoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器的注意力权重，在注意力 Softmax 之后，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器的交叉注意力层的注意力权重，在注意力 Softmax 之后，用于计算交叉注意力头中的加权平均值。
encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层的隐藏状态序列。
encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的输出每层的输出）。编码器在每一层的隐藏状态加上初始嵌入输出。
encoder_attentions (tuple(torch.FloatTensor), 可选, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每层一个）。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, LEDForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = LEDForQuestionAnswering.from_pretrained("allenai/led-base-16384")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index   1]

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss

TensorFlow 隐藏 TensorFlow 内容

TFLEDModel

`class transformers.TFLEDModel`

< source >

代码语言：javascript复制

( config *inputs **kwargs )

参数

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

裸 LED 模型输出原始隐藏状态，没有特定的头部。此模型继承自 TFPreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型也是 tf.keras.Model 的子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。

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

将所有输入作为关键字参数（类似于 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 函数一样传递输入！

`call`

< source >

代码语言：javascript复制

( input_ids: TFModelInputType | None = None attention_mask: tf.Tensor | None = None decoder_input_ids: tf.Tensor | None = None decoder_attention_mask: tf.Tensor | None = None head_mask: tf.Tensor | None = None decoder_head_mask: tf.Tensor | None = None encoder_outputs: tf.Tensor | None = None global_attention_mask: tf.Tensor | None = None past_key_values: Tuple[Tuple[tf.Tensor]] | None = None inputs_embeds: tf.Tensor | None = None decoder_inputs_embeds: tf.Tensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None training: bool = False **kwargs ) → export const metadata = 'undefined';transformers.models.led.modeling_tf_led.TFLEDSeq2SeqModelOutput or tuple(tf.Tensor)

参数

input_ids (tf.Tensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的tf.Tensor，可选）— 用于避免在填充标记索引上执行注意力的遮罩。在[0, 1]中选择的遮罩值：
- 1 表示未被遮罩的标记，
- 0 表示被遮罩的标记。
什么是注意力遮罩？
decoder_input_ids（形状为(batch_size, target_sequence_length)的tf.Tensor，可选）— 词汇表中解码器输入序列标记的索引。可以使用LedTokenizer获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是输入 ID？ LED 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则只需输入最后的decoder_input_ids（参见past_key_values）。
decoder_attention_mask（形状为(batch_size, target_sequence_length)的tf.Tensor，可选）— 默认情况下将忽略填充标记并生成。不建议为大多数用例设置此选项。
head_mask（形状为(encoder_layers, encoder_attention_heads)的tf.Tensor，可选）— 用于在编码器中使注意力模块中的选定头部失效的遮罩。在[0, 1]中选择的遮罩值：
- 1 表示头部未被遮罩，
- 0 表示头部被遮罩。
decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的tf.Tensor，可选）— 用于在解码器中使注意力模块中的选定头部失效的遮罩。在[0, 1]中选择的遮罩值：
- 1 表示头部未被遮罩，
- 0 表示头部被遮罩，
encoder_outputs（tf.Tensor，可选）— 编码器最后一层的隐藏状态的输出。在解码器的交叉注意力中使用。形状为(batch_size, sequence_length, hidden_size)的序列是
past_key_values（长度为config.n_layers的Tuple[Tuple[tf.Tensor]]）— 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用past_key_values，用户可以选择仅输入最后的decoder_input_ids（即未将其过去的键值状态提供给此模型的那些）的形状为(batch_size, 1)的张量，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。
use_cache（bool，可选，默认为True）— 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。在训练期间设置为False，在生成期间设置为True。
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数仅在急切模式下使用，在图模式下，将使用配置中的值。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式下，将使用配置中的值。
return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下，该值将始终设置为 True。
training (bool，optional，默认为 False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

transformers.models.led.modeling_tf_led.TFLEDSeq2SeqModelOutput 或 tuple(tf.Tensor)

一个 transformers.models.led.modeling_tf_led.TFLEDSeq2SeqModelOutput 或一个 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置（LEDConfig）和输入而异的各种元素。

last_hidden_state (tf.Tensor，形状为 (batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的隐藏状态序列。如果仅使用 past_key_values，则输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。
past_key_values (List[tf.Tensor], optional, returned when use_cache=True is passed or when config.use_cache=True) — 长度为 config.n_layers 的 tf.Tensor 列表，每个张量的形状为 (2, batch_size, num_heads, sequence_length, embed_size_per_head)。包含解码器的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码（参见 past_key_values 输入）。
decoder_hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组（一个用于嵌入输出，一个用于每一层的输出）。解码器在每一层的隐藏状态加上初始嵌入输出。
decoder_attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
encoder_last_hidden_state (tf.Tensor，形状为 (batch_size, sequence_length, hidden_size)，optional) — 模型编码器最后一层的隐藏状态序列。
encoder_hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组（一个用于嵌入输出，一个用于每一层的输出）。编码器在每一层的隐藏状态加上初始嵌入输出。
encoder_attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
encoder_global_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, x)的tf.Tensor元组，其中x是具有全局注意掩码的令牌数。在注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是来自具有全局注意力的每个令牌到序列中每个令牌的注意力权重。

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

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

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, TFLEDModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = TFLEDModel.from_pretrained("allenai/led-base-16384")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)

>>> last_hidden_states = outputs.last_hidden_state

TFLEDForConditionalGeneration

`class transformers.TFLEDForConditionalGeneration`

<来源>

代码语言：javascript复制

( config *inputs **kwargs )

参数

config（LEDConfig）- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

具有语言建模头的 LED 模型。可用于摘要。此模型继承自 TFPreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型还是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有信息。

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

将所有输入作为关键字参数（类似于 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 函数一样传递输入！

`call`

<来源>

代码语言：javascript复制

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None decoder_head_mask: np.ndarray | tf.Tensor | None = None encoder_outputs: TFLEDEncoderBaseModelOutput | None = None global_attention_mask: np.ndarray | tf.Tensor | None = None past_key_values: Tuple[Tuple[Union[np.ndarray, tf.Tensor]]] | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None decoder_inputs_embeds: np.ndarray | tf.Tensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None labels: tf.Tensor | None = None training: bool = False ) → export const metadata = 'undefined';transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput or tuple(tf.Tensor)

参数

input_ids（形状为({0})的tf.Tensor）- 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是输入 ID？
attention_mask（形状为({0})的tf.Tensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值为[0, 1]：
- 1 用于未被“掩码”的标记，
- 0 用于被“掩码”的标记。
什么是注意力掩码？
decoder_input_ids（形状为(batch_size, target_sequence_length)的tf.Tensor，可选）- 词汇表中解码器输入序列标记的索引。可以使用LedTokenizer获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是输入 ID？ LED 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用了past_key_values，则可选择仅输入最后的decoder_input_ids（参见past_key_values）。
decoder_attention_mask（形状为(batch_size, target_sequence_length)的tf.Tensor，可选）- 将默认生成并忽略填充标记。不建议为大多数用例设置此项。
head_mask（形状为(encoder_layers, encoder_attention_heads)的tf.Tensor，可选）- 用于使编码器中的注意力模块中的选定头部无效的掩码。选择的掩码值为[0, 1]：
- 1 表示头部未被“掩码”，
- 0 表示头部被“掩码”。
decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的tf.Tensor，可选）- 用于使解码器中的注意力模块中的选定头部无效的掩码。选择的掩码值为[0, 1]：
- 1 表示头部未被“掩码”，
- 0 表示头部被“掩码”。
encoder_outputs（tf.Tensor，可选）- 编码器最后一层的隐藏状态输出。用于解码器的交叉注意力。形状为(batch_size, sequence_length, hidden_size)的序列是
past_key_values（长度为config.n_layers的Tuple[Tuple[tf.Tensor]]）- 包含预先计算的注意力块的键和值隐藏状态。可用于加速解码。如果使用了past_key_values，用户可以选择仅输入最后的decoder_input_ids（即未将其过去的键值状态提供给此模型的那些）的形状为(batch_size, 1)的张量，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
use_cache（bool，可选，默认为True）- 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。在训练期间设置为False，在生成期间设置为True。
output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数仅可在急切模式下使用，在图模式中将使用配置中的值。
output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅可在急切模式下使用，在图模式中将使用配置中的值。
return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式中该值将始终设置为 True。
training (bool, 可选, 默认为False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput 或 tuple(tf.Tensor)

transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput 或 tf.Tensor元组（如果传递return_dict=False或config.return_dict=False）包括不同元素，取决于配置（LEDConfig）和输入。

loss (形状为(1,)的tf.Tensor, *可选*, 当提供labels`时返回) — 语言建模损失。
logits (形状为(batch_size, sequence_length, config.vocab_size)的tf.Tensor`) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
past_key_values (List[tf.Tensor], 可选, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。包含解码器的预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。
decoder_hidden_states (tuple(tf.Tensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入输出，一个用于每一层的输出）。解码器在每一层输出的隐藏状态加上初始嵌入输出。
decoder_attentions (tuple(tf.Tensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(tf.Tensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
encoder_last_hidden_state (形状为(batch_size, sequence_length, hidden_size)的tf.Tensor`, 可选) — 模型编码器最后一层的隐藏状态序列。
encoder_hidden_states (tuple(tf.Tensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入输出，一个用于每一层的输出）。编码器在每一层输出的隐藏状态加上初始嵌入输出。
encoder_attentions (tuple(tf.Tensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
encoder_global_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, x)的tf.Tensor元组（每层一个），其中x是具有全局注意力掩码的令牌数。在注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是来自每个令牌的注意力权重，对序列中的每个令牌进行全局注意力。

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

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

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, TFLEDForConditionalGeneration
>>> import tensorflow as tf

>>> mname = "allenai/led-base-16384"
>>> tokenizer = AutoTokenizer.from_pretrained(mname)
>>> TXT = "My friends are <mask> but they eat too many carbs."
>>> model = TFLEDForConditionalGeneration.from_pretrained(mname)
>>> batch = tokenizer([TXT], return_tensors="tf")
>>> logits = model(inputs=batch.input_ids).logits
>>> probs = tf.nn.softmax(logits[0])
>>> # probs[5] is associated with the mask token

decoder_hidden_states (tuple(tf.Tensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入输出，一个用于每一层的输出）。解码器在每一层输出的隐藏状态加上初始嵌入输出。
decoder_attentions (tuple(tf.Tensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(tf.Tensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
encoder_last_hidden_state (形状为(batch_size, sequence_length, hidden_size)的tf.Tensor`, 可选) — 模型编码器最后一层的隐藏状态序列。
encoder_hidden_states (tuple(tf.Tensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入输出，一个用于每一层的输出）。编码器在每一层输出的隐藏状态加上初始嵌入输出。
encoder_attentions (tuple(tf.Tensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
encoder_global_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, x)的tf.Tensor元组（每层一个），其中x是具有全局注意力掩码的令牌数。在注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是来自每个令牌的注意力权重，对序列中的每个令牌进行全局注意力。

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

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, TFLEDForConditionalGeneration
>>> import tensorflow as tf

>>> mname = "allenai/led-base-16384"
>>> tokenizer = AutoTokenizer.from_pretrained(mname)
>>> TXT = "My friends are <mask> but they eat too many carbs."
>>> model = TFLEDForConditionalGeneration.from_pretrained(mname)
>>> batch = tokenizer([TXT], return_tensors="tf")
>>> logits = model(inputs=batch.input_ids).logits
>>> probs = tf.nn.softmax(logits[0])
>>> # probs[5] is associated with the mask token

size 模型配置索引音频

0 人点赞