Transformers 文档

XGLM

Transformers

加入 Hugging Face 社区

并获得增强的文档体验

协作处理模型、数据集和 Spaces

通过加速推理获得更快的示例

切换文档主题

开始使用

XGLM

概览

XGLM 模型由 Xi Victoria Lin、Todor Mihaylov、Mikel Artetxe、Tianlu Wang、Shuohui Chen、Daniel Simig、Myle Ott、Naman Goyal、Shruti Bhosale、Jingfei Du、Ramakanth Pasunuru、Sam Shleifer、Punit Singh Koura、Vishrav Chaudhary、Brian O’Horo、Jeff Wang、Luke Zettlemoyer、Zornitsa Kozareva、Mona Diab、Veselin Stoyanov、Xian Li 在 Few-shot Learning with Multilingual Language Models 中提出。

论文摘要如下：

诸如 GPT-3 等大规模自回归语言模型是少样本学习器，无需微调即可执行各种语言任务。虽然已知这些模型能够联合表示多种不同的语言，但它们的训练数据主要以英语为主，这可能会限制其跨语言的泛化能力。在这项工作中，我们训练了涵盖多种语言的平衡语料库上的多语言自回归语言模型，并研究了它们在各种任务中的少样本和零样本学习能力。我们最大的模型拥有 75 亿参数，在 20 多种代表性语言的少样本学习中创下了新的技术水平，在多语言常识推理方面优于同等规模的 GPT-3（在零样本设置中绝对准确率提高了 +7.4%，在 4 样本设置中提高了 +9.4%）和自然语言推理（在零样本和 4 样本设置中均提高了 +5.4%）。在 FLORES-101 机器翻译基准测试中，我们的模型在 182 个翻译方向中的 171 个方向上优于 GPT-3（使用 32 个训练示例），同时在 45 个方向上超过了官方监督基线。我们详细分析了模型成功和失败的地方，特别表明它在某些任务上实现了跨语言的上下文学习，但在表面形式的鲁棒性和适应没有自然完形填空形式的任务方面仍有改进空间。最后，我们在仇恨言论检测等五种语言的社会价值任务中评估了我们的模型，发现它与同等规模的 GPT-3 模型具有相似的局限性。

此模型由 Suraj 贡献。原始代码可以在这里找到。

资源

因果语言建模任务指南

XGLMConfig

class transformers.XGLMConfig

( vocab_size = 256008 max_position_embeddings = 2048 d_model = 1024 ffn_dim = 4096 num_layers = 24 attention_heads = 16 activation_function = 'gelu' dropout = 0.1 attention_dropout = 0.1 activation_dropout = 0.0 layerdrop = 0.0 init_std = 0.02 scale_embedding = True use_cache = True decoder_start_token_id = 2 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 **kwargs )

参数

vocab_size (int, 可选, 默认为 256008) — XGLM 模型的词汇表大小。定义了在调用 XGLMModel 或 FlaxXGLMModel 时传递的 inputs_ids 可以表示的不同 token 的数量。
max_position_embeddings (int, 可选, 默认为 2048) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512 或 1024 或 2048）。
d_model (int, 可选, 默认为 1024) — 层和池化器层的维度。
ffn_dim (int, 可选, 默认为 4096) — 解码器中“中间”层（通常称为前馈层）的维度。
num_layers (int, 可选, 默认为 24) — Transformer 解码器中隐藏层的数量。
attention_heads (int, 可选, 默认为 16) — Transformer 解码器中每个注意力层的注意力头数。
activation_function (str 或 function, 可选, 默认为 "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持 "gelu"、"relu"、"silu" 和 "gelu_new"。
dropout (float, 可选, 默认为 0.1) — 嵌入、解码器和池化器中所有全连接层的 dropout 概率。
attention_dropout (float, 可选, 默认为 0.1) — 注意力概率的 dropout 比率。
activation_dropout (float, 可选, 默认为 0.0) — 全连接层内部激活的 dropout 比率。
layerdrop (float, 可选, 默认为 0.0) — 编码器的 LayerDrop 概率。有关更多详细信息，请参阅 [LayerDrop 论文](see https://arxiv.org/abs/1909.11556)。
init_std (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
scale_embedding (bool, 可选, 默认为 True) — 通过除以 sqrt(d_model) 来缩放嵌入。
use_cache (bool, 可选, 默认为 True) — 模型是否应返回上次的键/值注意力（并非所有模型都使用）。

这是用于存储 XGLMModel 配置的配置类。它用于根据指定的参数实例化 XGLM 模型，定义模型架构。使用默认值实例化配置将产生与 XGLM facebook/xglm-564M 架构类似的配置。

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

示例

>>> from transformers import XGLMModel, XGLMConfig

>>> # Initializing a XGLM facebook/xglm-564M style configuration
>>> configuration = XGLMConfig()

>>> # Initializing a model from the facebook/xglm-564M style configuration
>>> model = XGLMModel(configuration)

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

XGLMTokenizer

class transformers.XGLMTokenizer

( vocab_file bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' sp_model_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = None **kwargs )

参数

vocab_file (str) — 词汇表文件的路径。
bos_token (str, 可选, 默认为 "<s>") — 预训练期间使用的序列开始 token。可以用作序列分类器 token。

当使用特殊 token 构建序列时，这不是用于序列开始的 token。使用的 token 是 cls_token。
eos_token (str, optional, defaults to "</s>") — 序列结束符 (end of sequence token)。

当使用特殊 token 构建序列时，此 token 不是用于序列结尾的 token。用于序列结尾的 token 是 sep_token。
sep_token (str, optional, defaults to "</s>") — 分隔符 token。当从多个序列构建一个序列时使用，例如，用于序列分类的两个序列，或者用于问答的文本和问题。它也用作使用特殊 token 构建的序列的最后一个 token。
cls_token (str, optional, defaults to "<s>") — 分类符 token。用于进行序列分类时（对整个序列而不是每个 token 进行分类）。当使用特殊 token 构建序列时，它是序列的第一个 token。
unk_token (str, optional, defaults to "<unk>") — 未知 token。词汇表中不存在的 token 无法转换为 ID，而是设置为此 token。
pad_token (str, optional, defaults to "<pad>") — 用于填充的 token，例如在批量处理不同长度的序列时。
sp_model_kwargs (dict, optional) — 将会传递给 SentencePieceProcessor.__init__() 方法。SentencePiece 的 Python 封装器可用于设置以下内容，以及其他事项：
- enable_sampling: 启用子词正则化。
- nbest_size: 用于 unigram 的采样参数。对 BPE-Dropout 无效。
  - nbest_size = {0,1}: 不执行采样。
  - nbest_size > 1: 从 nbest_size 结果中采样。
  - nbest_size < 0: 假设 nbest_size 是无限的，并使用前向过滤和后向采样算法从所有假设（lattice）中采样。
- alpha: unigram 采样的平滑参数，以及 BPE-dropout 的合并操作的 dropout 概率。
sp_model (SentencePieceProcessor) — 用于每次转换（字符串、token 和 ID）的 SentencePiece 处理器。

改编自 RobertaTokenizer 和 XLNetTokenizer。基于 SentencePiece。

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

build_inputs_with_special_tokens

( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]

参数

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

返回

List[int]

包含适当特殊 token 的输入 ID 列表。

通过连接和添加特殊 token，从序列或序列对构建模型输入，用于序列分类任务。 XLM-RoBERTa 序列具有以下格式

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

get_special_tokens_mask

( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None already_has_special_tokens: bool = False ) → List[int]

参数

token_ids_0 (List[int]) — ID 列表。
token_ids_1 (List[int], optional) — 序列对的可选第二个 ID 列表。
already_has_special_tokens (bool, optional, defaults to False) — 指示 token 列表是否已使用模型的特殊 token 格式化。

返回

List[int]

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

从没有添加特殊 token 的 token 列表中检索序列 ID。当使用 tokenizer 的 prepare_for_model 方法添加特殊 token 时，将调用此方法。

create_token_type_ids_from_sequences

( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]

参数

token_ids_0 (List[int]) — ID 列表。
token_ids_1 (List[int], optional) — 序列对的可选第二个 ID 列表。

返回

List[int]

零列表。

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

save_vocabulary

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

XGLMTokenizerFast

class transformers.XGLMTokenizerFast

( vocab_file = None tokenizer_file = None bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' **kwargs )

参数

vocab_file (str) — 词汇表文件的路径。
bos_token (str, optional, defaults to "<s>") — 序列开始符 (beginning of sequence token)，在预训练期间使用。可以用作序列分类符 token。

当使用特殊 token 构建序列时，此 token 不是用于序列开头的 token。用于序列开头的 token 是 cls_token。
eos_token (str, optional, defaults to "</s>") — 序列结束符 (end of sequence token)。

当使用特殊 token 构建序列时，此 token 不是用于序列结尾的 token。用于序列结尾的 token 是 sep_token。
sep_token (str, optional, defaults to "</s>") — 分隔符 token。当从多个序列构建一个序列时使用，例如，用于序列分类的两个序列，或者用于问答的文本和问题。它也用作使用特殊 token 构建的序列的最后一个 token。
cls_token (str, optional, defaults to "<s>") — 序列分类符 token。用于进行序列分类时（对整个序列而不是每个 token 进行分类）。当使用特殊 token 构建序列时，它是序列的第一个 token。
unk_token (str, 可选, 默认为 "<unk>") — 未知 token。词汇表中不存在的 token 无法转换为 ID，而是设置为此 token。
pad_token (str, 可选, 默认为 "<pad>") — 用于填充的 token，例如在批量处理不同长度的序列时。
additional_special_tokens (List[str], 可选, 默认为 ["<s>NOTUSED", "</s>NOTUSED"]) — 分词器使用的其他特殊 token。

构建一个“快速” XGLM 分词器（由 HuggingFace 的 tokenizers 库支持）。改编自 RobertaTokenizer 和 XLNetTokenizer。基于 BPE。

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

build_inputs_with_special_tokens

( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]

参数

token_ids_0 (List[int]) — 将向其添加特殊 token 的 ID 列表。
token_ids_1 (List[int], 可选) — 用于序列对的可选的第二个 ID 列表。

返回

List[int]

包含适当特殊 token 的输入 ID 列表。

通过连接和添加特殊 token，从序列或序列对构建模型输入，用于序列分类任务。 XLM-RoBERTa 序列具有以下格式

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

create_token_type_ids_from_sequences

( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]

参数

token_ids_0 (List[int]) — ID 列表。
token_ids_1 (List[int], 可选) — 用于序列对的可选的第二个 ID 列表。

返回

List[int]

零列表。

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

Pytorch

隐藏 Pytorch 内容

XGLMModel

class transformers.XGLMModel

( config: XGLMConfig embed_tokens: typing.Optional[torch.nn.modules.sparse.Embedding] = None )

参数

config (XGLMConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
config — XGLMConfig
embed_tokens (nn.Embedding) — 输出嵌入

裸 XGLM 模型 Transformer，输出原始隐藏状态，顶部没有任何特定的 head。此模型继承自 PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。

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

Transformer 解码器，由 config.num_layers 层组成。每一层都是一个 XGLMDecoderLayer

forward（前向传播）

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None encoder_hidden_states: typing.Optional[torch.Tensor] = None encoder_attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[typing.List[torch.FloatTensor]] = None inputs_embeds: typing.Optional[torch.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。如果您提供 padding，默认情况下将忽略 padding。

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

什么是输入 ID？
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — Mask，用于避免对 padding token 索引执行 attention。Mask 值在 [0, 1] 中选择：
- 1 表示 token 未被 mask，
- 0 表示 token 已被 mask。
什么是 Attention Mask？
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 token 的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是位置 ID？
encoder_hidden_states (torch.FloatTensor，形状为 (batch_size, encoder_sequence_length, hidden_size)，可选) — 编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
encoder_attention_mask (torch.LongTensor，形状为 (batch_size, encoder_sequence_length)，可选) — Mask，用于避免对编码器 input_ids 的 padding token 索引执行交叉注意力。Mask 值在 [0, 1] 中选择：
- 1 表示 token 未被 mask，
- 0 表示 token 已被 mask。
什么是 Attention Mask？
head_mask (torch.Tensor，形状为 (num_layers, attention_heads)，可选) — 用于 nullify attention 模块的选定 head 的 Mask。Mask 值在 [0, 1] 中选择：
- 1 表示 head 未被 mask，
- 0 表示 head 已被 mask。
cross_attn_head_mask (torch.Tensor，形状为 (num_layers, attention_heads)，可选) — 用于 nullify 交叉注意力模块的选定 head 的 Mask。Mask 值在 [0, 1] 中选择：
- 1 表示 head 未被 mask，
- 0 表示 head 已被 mask。
past_key_values (tuple(tuple(torch.FloatTensor))，可选，当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(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 (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — （可选）您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
output_attentions (bool，可选) — 是否返回所有注意力层的 attention 张量。有关更多详细信息，请参见返回张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

返回

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

一个 transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 或一个 torch.FloatTensor 的元组 (如果传递了 return_dict=False，或者当 config.return_dict=False 时)，其中包含取决于配置 (XGLMConfig) 和输入的各种元素。

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 时返回) — tuple(torch.FloatTensor) 的元组，长度为 config.n_layers，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量，并且如果 config.is_encoder_decoder=True，则可选地包含 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的额外张量。

包含预先计算的隐藏状态 (自注意力模块中的键和值，以及如果 config.is_encoder_decoder=True，则可选地包含交叉注意力模块中的键和值)，这些状态可以用于 (参见 past_key_values 输入) 加速顺序解码。
hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组 (如果模型有嵌入层，则为嵌入输出一个，以及每层输出一个)，形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出端的隐藏状态，加上可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 和 config.add_cross_attention=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

XGLMModel 的 forward 方法，覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, XGLMModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/xglm-564M")
>>> model = XGLMModel.from_pretrained("facebook/xglm-564M")

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

>>> last_hidden_states = outputs.last_hidden_state

XGLMForCausalLM

class transformers.XGLMForCausalLM

( config )

参数

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

带有语言建模头的 XGLM 模型 Transformer (线性层，其权重与输入嵌入层绑定)。

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

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

forward（前向传播）

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None encoder_hidden_states: typing.Optional[torch.Tensor] = None encoder_attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[typing.List[torch.FloatTensor]] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。如果您提供填充，默认情况下将忽略填充。

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

什么是输入 IDs？
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 掩码，以避免在填充标记索引上执行注意力机制。掩码值在 [0, 1] 中选择：
- 1 表示标记未被掩盖，
- 0 表示标记被掩盖。
什么是注意力掩码？
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是位置 IDs？
encoder_hidden_states (torch.FloatTensor，形状为 (batch_size, encoder_sequence_length, hidden_size)，可选) — 编码器最后一层输出端的隐藏状态序列。用于解码器的交叉注意力机制。
encoder_attention_mask (torch.LongTensor，形状为 (batch_size, encoder_sequence_length)，可选) — 掩码，以避免在编码器 input_ids 的填充标记索引上执行交叉注意力机制。掩码值在 [0, 1] 中选择：
- 1 表示标记未被掩盖，
- 0 表示标记被掩盖。
什么是注意力掩码？
head_mask (torch.Tensor，形状为 (num_layers, attention_heads)，可选) — 掩码，用于使注意力模块的选定头无效。掩码值在 [0, 1] 中选择：
- 1 表示头未被掩盖，
- 0 表示头被掩盖。
cross_attn_head_mask (torch.Tensor，形状为 (num_layers, attention_heads)，可选) — 掩码，用于使交叉注意力模块的选定头无效。掩码值在 [0, 1] 中选择：
- 1 表示头未被掩盖，
- 0 表示头被掩盖。
past_key_values (tuple(tuple(torch.FloatTensor))，可选，当传递 use_cache=True 或 config.use_cache=True 时返回) — tuple(torch.FloatTensor) 的元组，长度为 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 (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回的张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回的张量下的 hidden_states。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应为 [0, ..., config.vocab_size] 或 -100 (参见 input_ids 文档字符串)。索引设置为 -100 的标记将被忽略 (掩码)，损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算。

返回

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

一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或一个 torch.FloatTensor 的元组 (如果传递了 return_dict=False，或者当 config.return_dict=False 时)，其中包含取决于配置 (XGLMConfig) 和输入的各种元素。

loss (torch.FloatTensor，形状为 (1,)，可选，当提供 labels 时返回) — 语言建模损失 (用于预测下一个标记)。
logits (torch.FloatTensor，形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数 (SoftMax 之前每个词汇表标记的分数)。
hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组 (如果模型有嵌入层，则为嵌入输出一个，以及每层输出一个)，形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出端的隐藏状态，加上可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

交叉注意力 softmax 之后的注意力权重，用于计算交叉注意力头中的加权平均值。
past_key_values (tuple(tuple(torch.FloatTensor))，可选，当传递 use_cache=True 或 config.use_cache=True 时返回) — torch.FloatTensor 元组的元组，长度为 config.n_layers，每个元组包含自注意力和交叉注意力层的缓存键、值状态 (如果模型在编码器-解码器设置中使用)。仅当 config.is_decoder = True 时相关。

包含预先计算的隐藏状态 (注意力模块中的键和值)，这些状态可以用于 (参见 past_key_values 输入) 加速顺序解码。

XGLMForCausalLM 的 forward 方法，覆盖了 __call__ 特殊方法。

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

示例

>>> import torch
>>> from transformers import AutoTokenizer, XGLMForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/xglm-564M")
>>> model = XGLMForCausalLM.from_pretrained("facebook/xglm-564M")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits

TensorFlow

隐藏 TensorFlow 内容

TFXGLMModel

class transformers.TFXGLMModel

( config: XGLMConfig embed_tokens: Optional[TFSharedEmbeddings] = None *inputs: Any **kwargs: Any )

参数

config (XGLMConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
config — XGLMConfig
embed_tokens — [TFSharedEmbeddings]: 输出嵌入

裸 XGLM 模型 Transformer，输出原始隐藏状态，顶部没有任何特定的头。此模型继承自 TFPreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法 (例如下载或保存、调整输入嵌入大小、剪枝头等)。

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

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

所有输入都作为关键字参数 (如 PyTorch 模型)，或
将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用 model.fit() 等方法时，对于您来说，事情应该“正常工作” - 只需以 model.fit() 支持的任何格式传递您的输入和标签即可！但是，如果您想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 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 函数一样传递输入！

Transformer 解码器，由 config.num_layers 层组成。每一层都是一个 TFXGLMDecoderLayer

调用

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None encoder_hidden_states: np.ndarray | tf.Tensor | None = None encoder_attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None cross_attn_head_mask: np.ndarray | tf.Tensor | None = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None inputs_embeds: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False **kwargs: Any ) → transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions 或 tuple(tf.Tensor)

参数

input_ids (形状为 ({0}) 的 tf.Tensor) — 词汇表中输入序列标记的索引。

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

什么是 input IDs？
attention_mask (形状为 ({0}) 的 tf.Tensor, 可选) — 用于避免在 padding 标记索引上执行 attention 的掩码。在 [0, 1] 中选择的掩码值：
- 1 表示未被掩盖的标记，
- 0 表示被掩盖的标记。
什么是 attention masks？
position_ids (形状为 (batch_size, sequence_length) 的 tf.Tensor 或 Numpy array, 可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是 position IDs？
encoder_hidden_states (形状为 (batch_size, encoder_sequence_length, hidden_size) 的 tf.Tensor, 可选) — 编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力机制。
encoder_attention_mask (形状为 (batch_size, encoder_sequence_length) 的 tf.Tensor, 可选) — 用于避免对编码器 input_ids 的 padding 标记索引执行交叉注意力的掩码。在 [0, 1] 中选择的掩码值：
- 1 表示未被掩盖的标记，
- 0 表示被掩盖的标记。
什么是 attention masks？
head_mask (形状为 (num_layers, attention_heads) 的 tf.Tensor, 可选) — 用于使编码器中 attention 模块的选定 head 失效的掩码。在 [0, 1] 中选择的掩码值：
- 1 表示 head 未被掩盖，
- 0 表示 head 被掩盖。
cross_attn_head_mask (形状为 (num_layers, attention_heads) 的 tf.Tensor, 可选) — 用于使交叉注意力模块的选定 head 失效的掩码。在 [0, 1] 中选择的掩码值：
- 1 表示 head 未被掩盖，
- 0 表示 head 被掩盖。
past_key_values (长度为 config.num_layers 的 Tuple[Tuple[tf.Tensor]]) — 包含 attention 块的预先计算的 key 和 value 隐藏状态。可用于加速解码。如果使用了 past_key_values，用户可以选择仅输入最后一次的 decoder_input_ids（那些没有将其过去的 key value 状态提供给此模型的），其形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 decoder_input_ids。
inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor, 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
use_cache (bool, 可选, 默认为 True) — 如果设置为 True，则返回 past_key_values 键值状态，并且可以用于加速解码（请参阅 past_key_values）。在训练期间设置为 False，在生成期间设置为 True
output_attentions (bool, 可选) — 是否返回所有 attention 层的 attention 张量。有关更多详细信息，请参阅返回张量下的 attentions。此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是纯元组。此参数可以在 eager 模式下使用，在 graph 模式下该值将始终设置为 True。
training (bool, 可选, 默认为 False) — 是否在训练模式下使用模型（dropout 模块等某些模块在训练和评估之间具有不同的行为）。

返回

transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions 或 tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions 或一个 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (XGLMConfig) 和输入。

last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor) — 模型最后一层输出的隐藏状态序列。

如果使用了 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))。

包含预先计算的隐藏状态 (注意力模块中的键和值)，这些状态可以用于 (参见 past_key_values 输入) 加速顺序解码。
hidden_states (tuple(tf.FloatTensor), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 元组（每个层的输出一个 + 嵌入输出一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出以及初始嵌入输出处的隐藏状态。
attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — tf.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — tf.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

The TFXGLMModel forward 方法，重写了 __call__ 特殊方法。

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

示例

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

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/xglm-564M")
>>> model = TFXGLMModel.from_pretrained("facebook/xglm-564M")

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

>>> last_hidden_states = outputs.last_hidden_state

TFXGLMForCausalLM

class transformers.TFXGLMForCausalLM

( config: XGLMConfig embed_tokens: Optional[TFSharedEmbeddings] = None *inputs: Any **kwargs: Any )

参数

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

带有语言建模头的 XGLM 模型 Transformer (线性层，其权重与输入嵌入层绑定)。

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

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

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

所有输入都作为关键字参数 (如 PyTorch 模型)，或
将所有输入作为列表、元组或字典放在第一个位置参数中。

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

一个仅包含 input_ids 的张量，不包含其他内容：model(input_ids)
一个长度可变的列表，其中包含一个或多个输入张量，顺序与文档字符串中给出的顺序相同：model([input_ids, attention_mask]) 或 model([input_ids, attention_mask, token_type_ids])
一个字典，其中包含一个或多个输入张量，这些张量与文档字符串中给出的输入名称相关联：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

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

调用

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None encoder_hidden_states: np.ndarray | tf.Tensor | None = None encoder_attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None cross_attn_head_mask: np.ndarray | tf.Tensor | None = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None inputs_embeds: np.ndarray | tf.Tensor | None = None labels: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False **kwargs: Any ) → transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions or tuple(tf.Tensor)

参数

input_ids (tf.Tensor of shape ({0})) — 词汇表中输入序列 tokens 的索引。

可以使用 AutoTokenizer 获取索引。详见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 IDs？
attention_mask (tf.Tensor of shape ({0}), optional) — 用于避免在 padding token 索引上执行 attention 的掩码。掩码值在 [0, 1] 中选择：
- 1 表示 tokens 未被掩盖，
- 0 表示 tokens 已被掩盖。
什么是 attention masks？
position_ids (tf.Tensor or Numpy array of shape (batch_size, sequence_length), optional) — 每个输入序列 tokens 在 position embeddings 中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是 position IDs？
encoder_hidden_states (tf.Tensor of shape (batch_size, encoder_sequence_length, hidden_size), optional) — 编码器最后一层输出的 hidden-states 序列。用于解码器的 cross-attention。
encoder_attention_mask (tf.Tensor of shape (batch_size, encoder_sequence_length), optional) — 用于避免对编码器 input_ids 的 padding tokens 索引执行 cross-attention 的掩码。掩码值在 [0, 1] 中选择：
- 1 表示 tokens 未被掩盖，
- 0 表示 tokens 已被掩盖。
什么是 attention masks？
head_mask (tf.Tensor of shape (num_layers, attention_heads), optional) — 用于 nullify 编码器中 attention 模块的选定 heads 的掩码。掩码值在 [0, 1] 中选择：
- 1 表示 head 未被掩盖，
- 0 表示 head 已被掩盖。
cross_attn_head_mask (tf.Tensor of shape (num_layers, attention_heads), optional) — 用于 nullify cross-attention 模块的选定 heads 的掩码。掩码值在 [0, 1] 中选择：
- 1 表示 head 未被掩盖，
- 0 表示 head 已被掩盖。
past_key_values (Tuple[Tuple[tf.Tensor]] of length config.num_layers) — 包含 attention blocks 的预计算 key 和 value hidden states。可用于加速解码。如果使用 past_key_values，则用户可以选择仅输入最后 decoder_input_ids（那些没有将其 past key value states 提供给此模型的）的形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 decoder_input_ids。
inputs_embeds (tf.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — （可选）您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想比模型的内部 embedding lookup matrix 更好地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
use_cache (bool, optional, defaults to True) — 如果设置为 True，则返回 past_key_values key value states，并可用于加速解码（参见 past_key_values）。在训练期间设置为 False，在生成期间设置为 True
output_attentions (bool, optional) — 是否返回所有 attention 层的 attentions tensors。有关更多详细信息，请参见返回的 tensors 下的 attentions。此参数只能在 eager 模式下使用，在 graph 模式下将使用 config 中的值。
output_hidden_states (bool, optional) — 是否返回所有层的 hidden states。有关更多详细信息，请参见返回的 tensors 下的 hidden_states。此参数只能在 eager 模式下使用，在 graph 模式下将使用 config 中的值。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通的 tuple。此参数可以在 eager 模式下使用，在 graph 模式下，该值将始终设置为 True。
training (bool, optional, defaults to False) — 是否在训练模式下使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。
labels (np.ndarray or tf.Tensor of shape (batch_size, sequence_length), optional) — 用于语言建模的标签。请注意，标签在模型内部已移位，即您可以设置 labels = input_ids 索引在 [-100, 0, ..., config.vocab_size] 中选择。所有设置为 -100 的标签都将被忽略（掩盖），损失仅针对 [0, ..., config.vocab_size] 中的标签计算。

返回

transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions or tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions 或 tf.Tensor 的 tuple（如果传递 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (XGLMConfig) 和输入。

loss (tf.Tensor of shape (n,), optional, 其中 n 是非掩盖标签的数量，当提供 labels 时返回) — 语言建模损失（用于 next-token 预测）。
logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模 head 的预测分数（SoftMax 之前每个词汇表 token 的分数）。
hidden_states (tuple(tf.Tensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 的 Tuple（embeddings 的输出一个，加上每个层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出以及初始嵌入输出处的隐藏状态。
attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — tf.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — tf.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

解码器的交叉注意力层的注意力权重，在注意力 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 输入) 加速顺序解码。

transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions or tuple(tf.Tensor): 一个 transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions 或 tf.Tensor 的 tuple（如果传递 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (XGLMConfig) 和输入。

loss (tf.Tensor of shape (n,), optional, 其中 n 是非掩盖标签的数量，当提供 labels 时返回) — 语言建模损失（用于 next-token 预测）。
logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模 head 的预测分数（SoftMax 之前每个词汇表 token 的分数）。
hidden_states (tuple(tf.Tensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 的 Tuple（embeddings 的输出一个，加上每个层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出以及初始嵌入输出处的隐藏状态。
attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — tf.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — tf.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

解码器的交叉注意力层的注意力权重，在注意力 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 输入) 加速顺序解码。

TFXGLMForCausalLM forward 方法，覆盖了 __call__ 特殊方法。

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

示例

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

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/xglm-564M")
>>> model = TFXGLMForCausalLM.from_pretrained("facebook/xglm-564M")

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

JAX

隐藏 JAX 内容

FlaxXGLMModel

class transformers.FlaxXGLMModel

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

参数

config (XGLMConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
dtype (jax.numpy.dtype, optional, defaults to jax.numpy.float32) — 计算的数据类型。可以是 jax.numpy.float32、jax.numpy.float16（在 GPU 上）和 jax.numpy.bfloat16（在 TPU 上）之一。

这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定，所有计算将使用给定的 dtype 执行。

请注意，这仅指定计算的 dtype，并且不影响模型参数的 dtype。

如果您希望更改模型参数的 dtype，请参阅 to_fp16() 和 to_bf16()。

裸 XGLM 模型 transformer 输出原始 hidden-states，顶部没有任何特定的 head。此模型继承自 FlaxPreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入 embeddings 大小、pruning heads 等）。

此模型也是 Flax Linen flax.nn.Module 子类。将其用作常规 Flax Module，并参考 Flax 文档以了解与常规用法和行为相关的所有事项。

最后，此模型支持固有的 JAX 功能，例如

call

( input_ids: Array attention_mask: typing.Optional[jax.Array] = None position_ids: typing.Optional[jax.Array] = None encoder_hidden_states: typing.Optional[jax.Array] = None encoder_attention_mask: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: dict = None past_key_values: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions or tuple(torch.FloatTensor)

参数

input_ids (形状为 (batch_size, sequence_length) 的 jnp.ndarray) — 词汇表中输入序列 tokens 的索引。默认情况下，如果您提供 padding，则会被忽略。

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

什么是输入 IDs？
attention_mask (形状为 (batch_size, sequence_length) 的 jnp.ndarray，可选) — 掩码，用于避免在 padding token 索引上执行 attention。掩码值在 [0, 1] 中选择：
- 1 表示 未被掩码 的 tokens，
- 0 表示 被掩码 的 tokens。
什么是 attention 掩码？
position_ids (形状为 (batch_size, sequence_length) 的 numpy.ndarray，可选) — 每个输入序列 tokens 在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。
output_attentions (bool，可选) — 是否返回所有 attention 层的 attention tensors。有关更多详细信息，请参阅返回的 tensors 下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的 hidden states。有关更多详细信息，请参阅返回的 tensors 下的 hidden_states。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

返回

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

一个 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (XGLMConfig) 和输入。

last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray) — 模型最后一层的输出处的 hidden-states 序列。

如果使用了 past_key_values，则仅输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。
past_key_values (tuple(tuple(jnp.ndarray))，可选，当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(jnp.ndarray) 元组，每个元组具有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的 tensors，并且可选地，如果 config.is_encoder_decoder=True，则具有 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加 tensors。

包含预先计算的隐藏状态 (自注意力模块中的键和值，以及如果 config.is_encoder_decoder=True，则可选地包含交叉注意力模块中的键和值)，这些状态可以用于 (参见 past_key_values 输入) 加速顺序解码。
hidden_states (tuple(jnp.ndarray)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — jnp.ndarray 元组（embeddings 的输出一个，每层输出一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出以及初始嵌入输出处的隐藏状态。
attentions (tuple(jnp.ndarray)，可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — jnp.ndarray 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(jnp.ndarray)，可选，当传递 output_attentions=True 且 config.add_cross_attention=True 或当 config.output_attentions=True 时返回) — jnp.ndarray 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

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

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

示例

>>> from transformers import AutoTokenizer, FlaxXGLMModel

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/xglm-564M")
>>> model = FlaxXGLMModel.from_pretrained("facebook/xglm-564M")

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

>>> last_hidden_states = outputs.last_hidden_state

FlaxXGLMForCausalLM

class transformers.FlaxXGLMForCausalLM

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

参数

config (XGLMConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
dtype (jax.numpy.dtype，可选，默认为 jax.numpy.float32) — 计算的数据类型。可以是 jax.numpy.float32、jax.numpy.float16 (在 GPU 上) 和 jax.numpy.bfloat16 (在 TPU 上) 之一。

这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定，所有计算都将使用给定的 dtype 执行。

请注意，这仅指定计算的 dtype，不影响模型参数的 dtype。

如果您希望更改模型参数的 dtype，请参阅 to_fp16() 和 to_bf16()。

带有语言建模头的 XGLM 模型 Transformer (线性层，其权重与输入嵌入层绑定)。

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

此模型也是 Flax Linen flax.nn.Module 子类。将其用作常规 Flax Module，并参考 Flax 文档以了解与常规用法和行为相关的所有事项。

最后，此模型支持固有的 JAX 功能，例如

call

( input_ids: Array attention_mask: typing.Optional[jax.Array] = None position_ids: typing.Optional[jax.Array] = None encoder_hidden_states: typing.Optional[jax.Array] = None encoder_attention_mask: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: dict = None past_key_values: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)

参数

input_ids (形状为 (batch_size, sequence_length) 的 jnp.ndarray) — 词汇表中输入序列 tokens 的索引。默认情况下，如果您提供 padding，则会被忽略。

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

什么是输入 IDs？
attention_mask (形状为 (batch_size, sequence_length) 的 jnp.ndarray，可选) — 掩码，用于避免在 padding token 索引上执行 attention。掩码值在 [0, 1] 中选择：
- 1 表示 未被掩码 的 tokens，
- 0 表示 被掩码 的 tokens。
什么是 attention 掩码？
position_ids (形状为 (batch_size, sequence_length) 的 numpy.ndarray，可选) — 每个输入序列 tokens 在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。
output_attentions (bool，可选) — 是否返回所有 attention 层的 attention tensors。有关更多详细信息，请参阅返回的 tensors 下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的 hidden states。有关更多详细信息，请参阅返回的 tensors 下的 hidden_states。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

返回

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

一个 transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (XGLMConfig) 和输入。

logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 jnp.ndarray) — 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。
hidden_states (tuple(jnp.ndarray)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — jnp.ndarray 元组（embeddings 的输出一个，每层输出一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出以及初始嵌入输出处的隐藏状态。
attentions (tuple(jnp.ndarray)，可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — jnp.ndarray 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(jnp.ndarray)，可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — jnp.ndarray 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

交叉注意力 softmax 之后的注意力权重，用于计算交叉注意力头中的加权平均值。
past_key_values (tuple(tuple(jnp.ndarray))，可选，当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 jnp.ndarray 元组的元组，每个元组包含自注意力层和交叉注意力层的缓存 key、value 状态（如果模型在 encoder-decoder 设置中使用）。仅当 config.is_decoder = True 时相关。

包含预先计算的隐藏状态 (注意力模块中的键和值)，这些状态可以用于 (参见 past_key_values 输入) 加速顺序解码。

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

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

示例

>>> from transformers import AutoTokenizer, FlaxXGLMForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/xglm-564M")
>>> model = FlaxXGLMForCausalLM.from_pretrained("facebook/xglm-564M")

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

>>> # retrieve logts for next token
>>> next_token_logits = outputs.logits[:, -1]

< > 在 GitHub 上更新

←X-MOD XLM→