ALBERT
概述
ALBERT 模型由 Zhenzhong Lan、Mingda Chen、Sebastian Goodman、Kevin Gimpel、Piyush Sharma、Radu Soricut 在 ALBERT：用于语言表示的自监督学习的轻量级 BERT 中提出。它提出了两种参数缩减技术，以降低内存消耗并提高 BERT 的训练速度
- 将嵌入矩阵拆分为两个更小的矩阵。
- 在组之间使用重复层。
本文的摘要如下
在预训练自然语言表示时增加模型规模通常会导致下游任务的性能提升。然而，在某种程度上，由于 GPU/TPU 内存限制、更长的训练时间以及意外的模型退化，进一步增加模型变得更加困难。为了解决这些问题，我们提出了两种参数缩减技术，以降低内存消耗并提高 BERT 的训练速度。全面的实证证据表明，与原始 BERT 相比，我们提出的方法可以产生规模大得多的模型。我们还使用了一种自监督损失，重点关注对句间连贯性的建模，并表明它始终有助于使用多句输入的下游任务。因此，我们最好的模型在 GLUE、RACE 和 SQuAD 基准测试中取得了新的最先进结果，同时与 BERT-large 相比参数更少。
该模型由 lysandre 贡献。该模型的 jax 版本由 kamalkraj 贡献。原始代码可以在 这里找到。
使用技巧
- ALBERT 是一个具有绝对位置嵌入的模型，因此通常建议在右侧而不是左侧填充输入。
- ALBERT 使用重复层，这会导致内存占用量很小，但是计算成本与具有相同隐藏层数量的 BERT 类架构类似，因为它必须迭代相同数量的（重复）层。
- 嵌入大小 E 与隐藏大小 H 不同，这是因为嵌入与上下文无关（一个嵌入向量表示一个标记），而隐藏状态与上下文有关（一个隐藏状态表示一个标记序列），因此 H >> E 更有逻辑。此外，嵌入矩阵很大，因为它的大小为 V x E（V 是词汇量）。如果 E < H，则它具有更少的参数。
- 层分为共享参数的组（以节省内存）。下一个句子预测被句子排序预测替换：在输入中，我们有两个句子 A 和 B（它们是连续的），并且我们要么以 A 然后 B 的顺序馈送，要么以 B 然后 A 的顺序馈送。模型必须预测它们是否被交换了。
该模型由 lysandre 贡献。该模型的 jax 版本由 kamalkraj 贡献。原始代码可以在 这里找到。
资源
以下部分提供的资源包括官方 Hugging Face 和社区（由 🌎 指示）资源的列表，可帮助您开始使用 AlBERT。如果您有兴趣提交要在此处包含的资源，请随时打开一个 Pull Request，我们将对其进行审核！理想情况下，该资源应该展示一些新内容，而不是重复现有的资源。
查看 文本分类任务指南，了解如何使用该模型。
- FlaxAlbertForTokenClassification 受此 示例脚本支持。
- 标记分类 是 🤗 Hugging Face 课程的第 7 章。
- 查看 标记分类任务指南，了解如何使用该模型。
- AlbertForMaskedLM 受此 示例脚本和 笔记本支持。
- TFAlbertForMaskedLM 受此 示例脚本和 笔记本支持。
- FlaxAlbertForMaskedLM 受此 示例脚本和 笔记本支持。
- 掩码语言建模 是 🤗 Hugging Face 课程的第 7 章。
- 查看 掩码语言建模任务指南，了解如何使用该模型。
- AlbertForQuestionAnswering 支持此 示例脚本 和 笔记本。
- TFAlbertForQuestionAnswering 支持此 示例脚本 和 笔记本。
- FlaxAlbertForQuestionAnswering 支持此 示例脚本。
- 问答 🤗 Hugging Face 课程的章节。
- 查看 问答任务指南，了解如何使用模型。
多项选择题
AlbertForMultipleChoice 支持此 示例脚本 和 笔记本。
TFAlbertForMultipleChoice 支持此 示例脚本 和 笔记本。
查看 多项选择题任务指南，了解如何使用模型。
AlbertConfig
class transformers.AlbertConfig
< 源代码 >( vocab_size = 30000 embedding_size = 128 hidden_size = 4096 num_hidden_layers = 12 num_hidden_groups = 1 num_attention_heads = 64 intermediate_size = 16384 inner_group_num = 1 hidden_act = 'gelu_new' hidden_dropout_prob = 0 attention_probs_dropout_prob = 0 max_position_embeddings = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 classifier_dropout_prob = 0.1 position_embedding_type = 'absolute' pad_token_id = 0 bos_token_id = 2 eos_token_id = 3 **kwargs )
参数
- vocab_size (
int, 可选, 默认值为 30000) — ALBERT 模型的词汇量大小。定义了调用 AlbertModel 或 TFAlbertModel 时可以由inputs_ids表示的不同标记的数量。 - embedding_size (
int, 可选, 默认值为 128) — 词汇嵌入的维度。 - hidden_size (
int, 可选, 默认值为 4096) — 编码器层和池化层的维度。 - num_hidden_layers (
int, 可选, 默认值为 12) — Transformer 编码器中的隐藏层数量。 - num_hidden_groups (
int, 可选, 默认为 1) — 隐藏层的组数，同一组中的参数共享。 - num_attention_heads (
int, 可选, 默认为 64) — Transformer 编码器中每个注意力层的注意力头数。 - intermediate_size (
int, 可选, 默认为 16384) — Transformer 编码器中“中间”(通常称为前馈)层的维度。 - inner_group_num (
int, 可选, 默认为 1) — 注意力和 ffn 的内部重复次数。 - hidden_act (
str或Callable, 可选, 默认为"gelu_new") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果为字符串，则支持"gelu"、"relu"、"silu"和"gelu_new"。 - hidden_dropout_prob (
float, 可选, 默认为 0) — 嵌入、编码器和池化器中所有全连接层的丢弃概率。 - attention_probs_dropout_prob (
float, 可选, 默认为 0) — 注意力概率的丢弃率。 - max_position_embeddings (
int, 可选, 默认为 512) — 该模型可能使用的最大序列长度。通常将其设置为较大的值(例如，512 或 1024 或 2048)。 - type_vocab_size (
int, 可选, 默认为 2) — 调用 AlbertModel 或 TFAlbertModel 时传递的token_type_ids的词汇量大小。 - initializer_range (
float, 可选, 默认为 0.02) — 初始化所有权重矩阵的截断正态分布初始化器的标准差。 - position_embedding_type (
str, optional, defaults to"absolute") — 位置嵌入类型。选择"absolute"、"relative_key"或"relative_key_query"之一。对于位置嵌入，使用"absolute"。有关"relative_key"的更多信息，请参阅 Self-Attention with Relative Position Representations (Shaw et al.)。有关"relative_key_query"的更多信息，请参阅 Improve Transformer Models with Better Relative Position Embeddings (Huang et al.) 中的方法 4。 - pad_token_id (
int, optional, defaults to 0) — 填充标记 ID。 - bos_token_id (
int, optional, defaults to 2) — 流起始标记 ID。 - eos_token_id (
int, optional, defaults to 3) — 流结束标记 ID。
这是一个用于存储 AlbertModel 或 TFAlbertModel 配置的配置类。它用于根据指定的参数实例化一个 ALBERT 模型，定义模型架构。使用默认值实例化配置将产生与 ALBERT albert/albert-xxlarge-v2 架构类似的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以了解更多信息。
示例
>>> from transformers import AlbertConfig, AlbertModel
>>> # Initializing an ALBERT-xxlarge style configuration
>>> albert_xxlarge_configuration = AlbertConfig()
>>> # Initializing an ALBERT-base style configuration
>>> albert_base_configuration = AlbertConfig(
... hidden_size=768,
... num_attention_heads=12,
... intermediate_size=3072,
... )
>>> # Initializing a model (with random weights) from the ALBERT-base style configuration
>>> model = AlbertModel(albert_xxlarge_configuration)
>>> # Accessing the model configuration
>>> configuration = model.configAlbertTokenizer
class transformers.AlbertTokenizer
< source >( vocab_file do_lower_case = True remove_space = True keep_accents = False bos_token = '[CLS]' eos_token = '[SEP]' unk_token = '<unk>' sep_token = '[SEP]' pad_token = '<pad>' cls_token = '[CLS]' mask_token = '[MASK]' sp_model_kwargs: Optional = None **kwargs )
参数
- vocab_file (
str) — SentencePiece 文件（通常具有 .spm 扩展名），其中包含实例化分词器所需的词汇表。 - do_lower_case (
bool, 可选, 默认值为True) — 在分词时是否将输入转换为小写。 - remove_space (
bool, 可选, 默认值为True) — 在分词时是否去除文本中的空格 (移除字符串前后多余的空格)。 - keep_accents (
bool, 可选, 默认值为False) — 在分词时是否保留重音符号。 - bos_token (
str, 可选, 默认值为"[CLS]") — 预训练期间使用的序列开头标记。可以作为序列分类标记。在使用特殊标记构建序列时，这不是用于序列开头的标记。所使用的标记是
cls_token。 - eos_token (
str, 可选, 默认值为"[SEP]") — 序列结束标记。在使用特殊标记构建序列时，这不是用于序列结束的标记。所使用的标记是
sep_token。 - unk_token (
str, 可选, 默认值为"<unk>") — 未知标记。不在词汇表中的标记无法转换为 ID，因此将设置为该标记。 - sep_token (
str, 可选, 默认值为"[SEP]") — 分隔符标记，用于从多个序列构建序列，例如用于序列分类的两个序列，或者用于问答的文本和问题。它也用作使用特殊标记构建的序列的最后一个标记。 - pad_token (
str, 可选, 默认值为"<pad>") — 用于填充的标记，例如当对不同长度的序列进行批处理时。 - cls_token (
str, 可选, 默认值为"[CLS]") — 分类标记，用于执行序列分类（对整个序列进行分类，而不是对每个标记进行分类）。当使用特殊标记构建时，它是序列的第一个标记。 - mask_token (
str, 可选, 默认值为"[MASK]") — 用于屏蔽值的标记。这是在使用屏蔽语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。 - sp_model_kwargs (
dict, optional) — 将传递给SentencePieceProcessor.__init__()方法。 SentencePiece 的 Python 包装器 可以用于设置以下内容：-
enable_sampling: 启用子词正则化。 -
nbest_size: 一元模型采样的参数，对于 BPE-Dropout 无效。nbest_size = {0,1}: 不执行采样。nbest_size > 1: 从 nbest_size 个结果中采样。nbest_size < 0: 假设 nbest_size 为无穷大，并使用前向过滤和后向采样算法从所有假设（格）中采样。
-
alpha: 一元采样的平滑参数，以及 BPE-dropout 的合并操作的丢弃概率。
-
- sp_model (
SentencePieceProcessor) — 用于每次转换（字符串、词语和 ID）的 SentencePiece 处理器。
构建一个 ALBERT 分词器。基于 SentencePiece.
此分词器继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
build_inputs_with_special_tokens
< source >( token_ids_0: List token_ids_1: Optional = None ) → List[int]
通过连接和添加特殊词语，从序列或序列对中构建用于序列分类任务的模型输入。ALBERT 序列具有以下格式
- 单个序列:
[CLS] X [SEP] - 序列对:
[CLS] A [SEP] B [SEP]
get_special_tokens_mask
< source >( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → List[int]
从没有添加特殊 token 的 token 列表中检索序列 id。此方法在使用 tokenizer 的 prepare_for_model 方法添加特殊 token 时被调用。
create_token_type_ids_from_sequences
< source >( token_ids_0: List token_ids_1: Optional = None ) → List[int]
从传递的两个序列中创建一个掩码，用于序列对分类任务。ALBERT
如果 token_ids_1 为 None，此方法只返回掩码的第一部分 (0s)。
AlbertTokenizerFast
class transformers.AlbertTokenizerFast
< source >( vocab_file = None tokenizer_file = None do_lower_case = True remove_space = True keep_accents = False bos_token = '[CLS]' eos_token = '[SEP]' unk_token = '<unk>' sep_token = '[SEP]' pad_token = '<pad>' cls_token = '[CLS]' mask_token = '[MASK]' **kwargs )
参数
- vocab_file (
str) — 包含实例化分词器所需的词汇表的 SentencePiece 文件（通常具有 .spm 扩展名）。 - keep_accents (
bool, 可选, 默认为False) — 是否在分词时保留重音符号。 - bos_token (
str, 可选, 默认为"[CLS]") — 预训练期间使用的序列起始标记。可用作序列分类标记。使用特殊标记构建序列时，此标记不是用于序列起始的标记。使用的是
cls_token。 - eos_token (
str, 可选, 默认为"[SEP]") — 序列结束标记。 .. 注意:: 使用特殊标记构建序列时，此标记不是用于序列结束的标记。使用的是sep_token。 - unk_token (
str, 可选, 默认为"<unk>") — 未知标记。不在词汇表中的标记无法转换为 ID，而是设置为此标记。 - sep_token (
str, 可选, 默认为"[SEP]") — 分隔标记，用于将多个序列构建成一个序列，例如用于序列分类的两个序列或用于问答的文本和问题。它也用作使用特殊标记构建的序列的最后一个标记。 - pad_token (
str, 可选, 默认为"<pad>") — 用于填充的标记，例如对不同长度的序列进行批处理时。 - cls_token (
str, 可选, 默认为"[CLS]") — 分类标记，用于进行序列分类（对整个序列进行分类，而不是对每个标记进行分类）。使用特殊标记构建时，它是序列的第一个标记。 - mask_token (
str, 可选, 默认为"[MASK]") — 用于掩蔽值的标记。这是在使用掩蔽语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
构建一个“快速”ALBERT分词器（由 HuggingFace 的 tokenizers 库支持）。基于 Unigram。此分词器继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
build_inputs_with_special_tokens
< 源代码 >( token_ids_0: List token_ids_1: Optional = None ) → List[int]
通过连接和添加特殊词语，从序列或序列对中构建用于序列分类任务的模型输入。ALBERT 序列具有以下格式
- 单个序列:
[CLS] X [SEP] - 序列对:
[CLS] A [SEP] B [SEP]
create_token_type_ids_from_sequences
< 源代码 >( token_ids_0: List token_ids_1: Optional = None ) → List[int]
从传递的两个序列中创建掩码，以在序列对分类任务中使用。ALBERT
如果 token_ids_1 为 None，则仅返回掩码的第一部分 (0)。
ALBERT 特定输出
class transformers.models.albert.modeling_albert.AlbertForPreTrainingOutput
< 源代码 >( loss: Optional = None prediction_logits: FloatTensor = None sop_logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
参数
- loss (可选, 当提供
labels时返回,torch.FloatTensor形状为(1,)) — 掩码语言建模损失和下一序列预测 (分类) 损失之和的总损失。 - 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 之后的注意力权重，用于计算自注意力头中的加权平均值。
的输出类型 AlbertForPreTraining.
class transformers.models.albert.modeling_tf_albert.TFAlbertForPreTrainingOutput
< source >( loss: tf.Tensor = None prediction_logits: tf.Tensor = None sop_logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )
参数
- prediction_logits (
tf.Tensor形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前的每个词汇表标记的分数）。 - sop_logits (
tf.Tensor形状为(batch_size, 2)) — 下一个序列预测（分类）头的预测分数（SoftMax 之前的真/假延续分数）。 - hidden_states (
tuple(tf.Tensor), 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor元组（一个用于嵌入的输出 + 一个用于每一层的输出）形状为(batch_size, sequence_length, hidden_size)。每一层输出的模型隐藏状态加上初始嵌入输出。
- attentions (
tuple(tf.Tensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor元组（每一层一个）形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 Softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
的输出类型 TFAlbertForPreTraining.
AlbertModel
class transformers.AlbertModel
< 源代码 >( config: AlbertConfig add_pooling_layer: bool = True )
参数
- config (AlbertConfig) — 模型配置类，包含模型的所有参数。用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看from_pretrained()方法来加载模型权重。
仅输出原始隐藏状态的 ALBERT 模型转换器，没有在顶部添加任何特定头部。
此模型继承自PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头部等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解有关一般用法和行为的所有事项。
forward
< 源代码 >( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
torch.FloatTensor形状为(batch_size, sequence_length), 可选) — 掩码，避免在填充标记索引上执行注意力。掩码值在[0, 1]中选择：- 1 表示 未屏蔽 的标记，
- 0 表示 屏蔽 的标记。
- token_type_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 表示 句子 A 标记，
- 1 表示 句子 B 标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列标记位置的索引。在[0, config.max_position_embeddings - 1]范围内选择。 - head_mask (
torch.FloatTensor形状为(num_heads,)或(num_layers, num_heads), 可选) — 掩码，用于使自注意力模块的选定头部失效。掩码值在[0, 1]中选择：- 1 表示 未屏蔽 的头部，
- 0 表示 屏蔽 的头部。
- inputs_embeds (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望对如何将input_ids索引转换为关联向量（而不是模型的内部嵌入查找矩阵）有更多控制权，这将很有用。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
A transformers.modeling_outputs.BaseModelOutputWithPooling 或 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），其中包含取决于配置（AlbertConfig）和输入的各种元素。
-
last_hidden_state (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出处的隐藏状态序列。 -
pooler_output (
torch.FloatTensor形状为(batch_size, hidden_size)) — 序列第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层的进一步处理。例如，对于 BERT 家族的模型，这将返回分类 token，在经过线性层和 tanh 激活函数处理后。线性层权重是在预训练期间从下一句预测（分类）目标中训练的。 -
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 后的注意力权重，用于计算自注意力头中的加权平均值。
The AlbertModel 前向方法，覆盖了 __call__ 特殊方法。
尽管需要在此函数内定义前向传递的配方，但随后应该调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, AlbertModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-base-v2")
>>> model = AlbertModel.from_pretrained("albert/albert-base-v2")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_stateAlbertForPreTraining
class transformers.AlbertForPreTraining
< source >( config: AlbertConfig )
参数
- config (AlbertConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。
Albert 模型在顶部有两个 head，就像在预训练期间所做的那样：一个 masked language modeling head 和一个 sentence order prediction (classification) head。
此模型继承自PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头部等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解有关一般用法和行为的所有事项。
forward
< source >( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None sentence_order_label: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.models.albert.modeling_albert.AlbertForPreTrainingOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 输入序列标记在词表的索引。可以使用 AutoTokenizer 获取索引。详情请查看 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
torch.FloatTensor形状为(batch_size, sequence_length), 可选) — 掩码，用于避免对填充标记索引执行注意力。掩码值选择在[0, 1]中：- 1 表示未掩码的标记，
- 0 表示掩码的标记。
- token_type_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 段标记索引，用于指示输入的第一部分和第二部分。索引选择在[0, 1]中：- 0 表示句子 A 标记，
- 1 表示句子 B 标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 - head_mask (
torch.FloatTensor形状为(num_heads,)或(num_layers, num_heads), 可选) — 掩码，用于使自注意力模块的选定头部失效。掩码值选择在[0, 1]中：- 1 表示未掩码的头部，
- 0 表示掩码的头部。
- inputs_embeds (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望比模型内部嵌入查找矩阵更精确地控制如何将input_ids索引转换为关联向量，这将非常有用。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。详情请查看返回张量中的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。详情请查看返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 - labels (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 用于计算掩码语言模型损失的标签。索引应在[-100, 0, ..., config.vocab_size]中 (参见input_ids文档字符串)。索引设置为-100的标记被忽略 (掩码)，损失仅针对标签在[0, ..., config.vocab_size]中的标记计算。 - sentence_order_label (
torch.LongTensor形状为(batch_size,), 可选) — 用于计算下一序列预测 (分类) 损失的标签。输入应为序列对 (参见input_ids文档字符串)。索引应在[0, 1]中。0表示原始顺序 (序列 A，然后是序列 B)，1表示切换顺序 (序列 B，然后是序列 A)。
返回
transformers.models.albert.modeling_albert.AlbertForPreTrainingOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.albert.modeling_albert.AlbertForPreTrainingOutput 或 torch.FloatTensor 的元组 (如果传递了 return_dict=False 或者当 config.return_dict=False 时)，包含根据配置 (AlbertConfig) 和输入的不同元素。
-
loss (可选，当提供
labels时返回，torch.FloatTensor形状为(1,)) — 总损失，作为掩码语言模型损失和下一序列预测 (分类) 损失的总和。 -
prediction_logits (
torch.FloatTensor形状为(batch_size, sequence_length, config.vocab_size)) — 语言模型头的预测得分 (SoftMax 之前的每个词汇标记的得分)。 -
sop_logits (
torch.FloatTensor形状为(batch_size, 2)) — 下一序列预测 (分类) 头的预测得分 (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 后的注意力权重，用于计算自注意力头中的加权平均值。
The AlbertForPreTraining 正向方法，覆盖了 __call__ 特殊方法。
尽管需要在此函数内定义前向传递的配方，但随后应该调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, AlbertForPreTraining
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-base-v2")
>>> model = AlbertForPreTraining.from_pretrained("albert/albert-base-v2")
>>> input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(0)
>>> # Batch size 1
>>> outputs = model(input_ids)
>>> prediction_logits = outputs.prediction_logits
>>> sop_logits = outputs.sop_logitsAlbertForMaskedLM
class transformers.AlbertForMaskedLM
< 源代码 >( config )
参数
- config (AlbertConfig) — 模型配置类，包含模型的所有参数。用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained() 方法来加载模型权重。
带有 语言建模 头部的 Albert 模型。
此模型继承自PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头部等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解有关一般用法和行为的所有事项。
forward
< 源代码 >( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
torch.FloatTensor形状为(batch_size, sequence_length), 可选) — 用于避免对填充标记索引执行注意的掩码。掩码值选择在[0, 1]中：- 1 表示 未被掩码 的标记，
- 0 表示 被掩码 的标记。
- token_type_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]中：- 0 对应于 句子 A 标记，
- 1 对应于 句子 B 标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列标记在位置嵌入中的位置索引。选择范围在[0, config.max_position_embeddings - 1]中。 - head_mask (
torch.FloatTensor形状为(num_heads,)或(num_layers, num_heads), 可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值选择在[0, 1]中：- 1 表示 未被掩码 的头部，
- 0 表示 被掩码 的头部。
- inputs_embeds (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望对如何将input_ids索引转换为相关向量比模型的内部嵌入查找矩阵有更多控制，这将非常有用。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 - labels (
torch.LongTensorof shape(batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]中（见input_ids文档字符串）索引设置为-100的标记被忽略（掩码），损失仅针对标签在[0, ..., config.vocab_size]中的标记计算。
返回
transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.MaskedLMOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含取决于配置 (AlbertConfig) 和输入的各种元素。
-
loss (
torch.FloatTensorof shape(1,), optional, 返回时提供labels) — 掩码语言建模 (MLM) 损失。 -
logits (
torch.FloatTensorof shape(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 后的注意力权重，用于计算自注意力头中的加权平均值。
The AlbertForMaskedLM forward method, overrides the __call__ special method.
尽管需要在此函数内定义前向传递的配方，但随后应该调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> import torch
>>> from transformers import AutoTokenizer, AlbertForMaskedLM
>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-base-v2")
>>> model = AlbertForMaskedLM.from_pretrained("albert/albert-base-v2")
>>> # add mask_token
>>> inputs = tokenizer("The capital of [MASK] is Paris.", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> # retrieve index of [MASK]
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]
>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> tokenizer.decode(predicted_token_id)
'france'AlbertForSequenceClassification
class transformers.AlbertForSequenceClassification
< source >( config: AlbertConfig )
参数
- config (AlbertConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。
在顶部带有序列分类/回归头的 Albert 模型转换器（在池化输出的顶部有一个线性层），例如用于 GLUE 任务。
此模型继承自PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头部等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解有关一般用法和行为的所有事项。
forward
< source >( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensorof shape(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。索引可以通过 AutoTokenizer 获取。查看 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode() 获取详细信息。
- attention_mask (
torch.FloatTensorof shape(batch_size, sequence_length), optional) — 掩码以避免对填充标记索引执行注意力。在[0, 1]中选择掩码值：- 1 表示未掩码的标记，
- 0 表示掩码的标记。
- token_type_ids (
torch.LongTensor形状为(batch_size, sequence_length)，可选) — 用于指示输入的第一个和第二个部分的段标记索引。索引选择在[0, 1]中：- 0 对应于句子 A 标记，
- 1 对应于句子 B 标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length)，可选) — 输入序列标记在位置嵌入中的位置索引。选择在范围[0, config.max_position_embeddings - 1]中。 - head_mask (
torch.FloatTensor形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]中：- 1 表示头部未被掩码，
- 0 表示头部被掩码。
- inputs_embeds (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联的向量，这将很有用。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool，可选) — 是否返回一个 ModelOutput 而不是一个简单的元组。 - labels (
torch.LongTensor形状为(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]中。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。
返回
transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.SequenceClassifierOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含取决于配置 (AlbertConfig) 和输入的各种元素。
-
loss (
torch.FloatTensor形状为(1,)，可选，在提供labels时返回) — 分类（如果config.num_labels==1则为回归）损失。 -
logits (
torch.FloatTensor形状为(batch_size, config.num_labels)) — 分类（如果config.num_labels==1则为回归）分数（在 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 后的注意力权重，用于计算自注意力头中的加权平均值。
AlbertForSequenceClassification 正向方法覆盖了 __call__ 特殊方法。
尽管需要在此函数内定义前向传递的配方，但随后应该调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
单标签分类的示例
>>> import torch
>>> from transformers import AutoTokenizer, AlbertForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("textattack/albert-base-v2-imdb")
>>> model = AlbertForSequenceClassification.from_pretrained("textattack/albert-base-v2-imdb")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
'LABEL_1'
>>> # 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 = AlbertForSequenceClassification.from_pretrained("textattack/albert-base-v2-imdb", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
0.12多标签分类的示例
>>> import torch
>>> from transformers import AutoTokenizer, AlbertForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("textattack/albert-base-v2-imdb")
>>> model = AlbertForSequenceClassification.from_pretrained("textattack/albert-base-v2-imdb", 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 = AlbertForSequenceClassification.from_pretrained(
... "textattack/albert-base-v2-imdb", 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).lossAlbertForMultipleChoice
在 Albert 模型之上添加多选分类头（池化输出之上的线性层和 softmax），例如用于 RocStories/SWAG 任务。
此模型继承自PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头部等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解有关一般用法和行为的所有事项。
forward
< 源代码 >( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.MultipleChoiceModelOutput 或者 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, num_choices, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
torch.FloatTensor形状为(batch_size, num_choices, sequence_length), 可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值选择在[0, 1]中：- 1 表示 不掩盖 的标记，
- 0 表示 掩盖 的标记。
- token_type_ids (
torch.LongTensor形状为(batch_size, num_choices, sequence_length), 可选) — 用于指示输入的第一部分和第二部分的段标记索引。索引选择在[0, 1]中：- 0 对应于 句子 A 标记，
- 1 对应于 句子 B 标记。
- position_ids (
torch.LongTensor形状为(batch_size, num_choices, sequence_length), 可选) — 位置嵌入中每个输入序列标记位置的索引。选择在[0, config.max_position_embeddings - 1]范围内。 - head_mask (
torch.FloatTensor形状为(num_heads,)或(num_layers, num_heads), 可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值选择在[0, 1]中：- 1 表示 不掩盖 的头部，
- 0 表示 掩盖 的头部。
- inputs_embeds (
torch.FloatTensor形状为(batch_size, num_choices, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要比模型的内部嵌入查找矩阵对如何将input_ids索引转换为关联向量有更多控制，这将很有用。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通元组。 - labels (
torch.LongTensor形状为(batch_size,), 可选) — 用于计算多项选择分类损失的标签。索引应在[0, ..., num_choices-1]中，其中 num_choices 是输入张量的第二维的大小。(见上面的 input_ids)
返回
transformers.modeling_outputs.MultipleChoiceModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.MultipleChoiceModelOutput 或一个 torch.FloatTensor 的元组(如果传递了 return_dict=False 或 config.return_dict=False)，包含根据配置 (AlbertConfig) 和输入的不同元素。
-
loss (
torch.FloatTensor形状为 (1,), 可选, 当提供labels时返回) — 分类损失。 -
logits (
torch.FloatTensor形状为(batch_size, num_choices)) — num_choices 是输入张量的第二维的大小。(见上面的 input_ids)。分类分数(在 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 后的注意力权重，用于计算自注意力头中的加权平均值。
The AlbertForMultipleChoice forward 方法，覆盖 __call__ 特殊方法。
尽管需要在此函数内定义前向传递的配方，但随后应该调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, AlbertForMultipleChoice
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-base-v2")
>>> model = AlbertForMultipleChoice.from_pretrained("albert/albert-base-v2")
>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0) # choice0 is correct (according to Wikipedia ;)), batch size 1
>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels) # batch size is 1
>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logitsAlbertForTokenClassification
class transformers.AlbertForTokenClassification
< source >( config: AlbertConfig )
参数
- config (AlbertConfig) — 模型配置类，包含模型的所有参数。用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法来加载模型权重。
在顶部带有令牌分类头的 ALBERT 模型(在隐藏状态输出之上有一个线性层)，例如用于命名实体识别(NER)任务。
此模型继承自PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头部等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解有关一般用法和行为的所有事项。
forward
< source >( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。请查看 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode() 获取详细信息。
- attention_mask (
torch.FloatTensor形状为(batch_size, sequence_length), 可选) — 用于避免对填充标记索引执行注意的掩码。掩码值在[0, 1]中选择：- 1 表示未屏蔽的标记
- 0 表示屏蔽的标记
- token_type_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 用于指示输入的第一部分和第二部分的段标记索引。索引在[0, 1]中选择：- 0 对应于句子 A 标记
- 1 对应于句子 B 标记
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列标记的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - head_mask (
torch.FloatTensor形状为(num_heads,)或(num_layers, num_heads), 可选) — 用于使自注意力模块的选定头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未屏蔽
- 0 表示头已屏蔽
- inputs_embeds (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望比模型的内部嵌入查找矩阵更细致地控制如何将input_ids索引转换为关联的向量，这将很有用。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回张量中的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 - labels (
torch.LongTensor形状为(batch_size, sequence_length)，可选) — 用于计算标记分类损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。
返回
transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.TokenClassifierOutput 或者一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或者 config.return_dict=False），包括根据配置 (AlbertConfig) 和输入的不同元素。
-
loss (
torch.FloatTensor形状为(1,)，可选，当提供labels时返回) — 分类损失。 -
logits (
torch.FloatTensor形状为(batch_size, sequence_length, config.num_labels)) — 分类分数（在 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 后的注意力权重，用于计算自注意力头中的加权平均值。
The AlbertForTokenClassification 正向方法，重写了 __call__ 特殊方法。
尽管需要在此函数内定义前向传递的配方，但随后应该调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, AlbertForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-base-v2")
>>> model = AlbertForTokenClassification.from_pretrained("albert/albert-base-v2")
>>> inputs = tokenizer(
... "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_token_class_ids = logits.argmax(-1)
>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).lossAlbertForQuestionAnswering
class transformers.AlbertForQuestionAnswering
< source >( config: AlbertConfig )
参数
- config (AlbertConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法来加载模型权重。
带有跨度分类头的 ALBERT 模型，用于抽取式问答任务，例如 SQuAD（在隐藏状态输出之上添加一个线性层，以计算 span start logits 和 span end logits）。
此模型继承自PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头部等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解有关一般用法和行为的所有事项。
forward
< source >( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。索引可以使用 AutoTokenizer 获取。查看 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode() 了解更多信息。
- attention_mask (
torch.FloatTensor形状为(batch_size, sequence_length)，可选) — 掩码以避免对填充标记索引执行注意力。在[0, 1]中选择掩码值：- 1 表示未掩盖的标记，
- 0 表示已掩盖的标记。
- token_type_ids (
torch.LongTensor形状为(batch_size, sequence_length)，可选) — 分段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 句子 A 标记，
- 1 对应于 句子 B 标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length)，可选) — 输入序列中每个 token 在位置嵌入中的位置索引。选择范围在[0, config.max_position_embeddings - 1]中。 - head_mask (
torch.FloatTensor形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块中选定 head 失效的掩码。掩码值选择在[0, 1]中：- 1 表示 head 未被屏蔽，
- 0 表示 head 被屏蔽。
- 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 而不是普通元组。 - start_positions (
torch.LongTensor形状为(batch_size,)，可选) — 用于计算 token 分类损失的标记跨度开始位置（索引）的标签。位置被限制为序列的长度（sequence_length）。序列外的位置不会被考虑用于计算损失。 - end_positions (
torch.LongTensor形状为(batch_size,)，可选) — 用于计算 token 分类损失的标记跨度结束位置（索引）的标签。位置被限制为序列的长度（sequence_length）。序列外的位置不会被考虑用于计算损失。
返回
transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含根据配置 (AlbertConfig) 和输入的不同元素。
-
loss (
torch.FloatTensor形状为(1,)，可选，在提供labels时返回) — 总跨度提取损失是开始和结束位置的交叉熵之和。 -
start_logits (
torch.FloatTensor形状为(batch_size, sequence_length)) — 跨度开始分数（在 SoftMax 之前）。 -
end_logits (
torch.FloatTensor形状为(batch_size, sequence_length)) — 跨度结束分数（在 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 后的注意力权重，用于计算自注意力头中的加权平均值。
The AlbertForQuestionAnswering 正向方法，覆盖了 __call__ 特殊方法。
尽管需要在此函数内定义前向传递的配方，但随后应该调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, AlbertForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("twmkn9/albert-base-v2-squad2")
>>> model = AlbertForQuestionAnswering.from_pretrained("twmkn9/albert-base-v2-squad2")
>>> 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]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
'a nice puppet'
>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([12])
>>> target_end_index = torch.tensor([13])
>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
7.36TFAlbertModel
基本的 Albert 模型转换器，输出原始隐藏状态，没有顶部的特定头部。
此模型继承自 TFPreTrainedModel。 检查超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头部等）。
此模型也是 keras.Model 子类。 将其用作常规 TF 2.0 Keras 模型，并参考 TF 2.0 文档以了解与一般使用和行为相关的所有事项。
transformers 中的 TensorFlow 模型和层接受两种格式作为输入
- 将所有输入作为关键字参数（如 PyTorch 模型），或
- 将所有输入作为第一个位置参数中的列表、元组或字典。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。 由于这种支持，在使用像 model.fit() 这样的方法时，事情应该“正常工作” - 只需以 model.fit() 支持的任何格式传递你的输入和标签！ 但是，如果你想在像 fit() 和 predict() 这样的 Keras 方法之外使用第二种格式，例如在使用 Keras Functional API 创建你自己的层或模型时，你可以使用三种可能性来收集第一个位置参数中的所有输入张量
- 仅包含
input_ids的单个张量，没有其他内容：model(input_ids) - 一个长度可变的列表，其中包含一个或多个输入张量，按文档字符串中给出的顺序排列：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一个字典，其中一个或多个输入张量与文档字符串中给出的输入名称相关联：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，在使用 子类化 创建模型和层时，你无需担心这些问题，因为你可以像传递给任何其他 Python 函数一样传递输入！
call
< 源代码 >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或 tuple(tf.Tensor)
参数
- input_ids (
Numpy array或tf.Tensor形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。 查看 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode() 以了解详情。
- attention_mask (
Numpy array或tf.Tensor形状为(batch_size, sequence_length), 可选) — 掩码，用于避免对填充标记索引执行注意力。 掩码值在[0, 1]中选择：- 1 代表未掩码的标记，
- 0 代表掩码的标记。
- token_type_ids (
Numpy array或tf.Tensor形状为(batch_size, sequence_length), 可选) — 段标记索引，用于指示输入的第一部分和第二部分。 索引在[0, 1]中选择：- 0 对应于句子 A 标记，
- 1 对应于句子 B 标记。
- position_ids (
Numpy array或tf.Tensor形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列标记的位置索引。 在[0, config.max_position_embeddings - 1]范围内选择。 - head_mask (
Numpy array或tf.Tensor形状为(num_heads,)或(num_layers, num_heads), 可选) — 用于使自注意力模块中选定头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未被屏蔽，
- 0 表示头被屏蔽。
- inputs_embeds (
tf.Tensor形状为(batch_size, sequence_length, hidden_size), 可选) — 可选地，您也可以选择直接传递嵌入表示，而不是传递input_ids。如果您想更精细地控制如何将input_ids索引转换为关联向量，而不是使用模型的内部嵌入查找矩阵，这将很有用。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的attentions。此参数仅可在急切模式下使用，在图模式下，将使用配置中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的hidden_states。此参数仅可在急切模式下使用，在图模式下，将使用配置中的值。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下，该值始终设置为 True。 - training (
bool, 可选，默认为False) — 是否以训练模式使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。
返回
transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或 tf.Tensor 的元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置（AlbertConfig）和输入的不同元素。
-
last_hidden_state (
tf.Tensor形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。 -
pooler_output (
tf.Tensor形状为(batch_size, hidden_size)) — 序列第一个标记（分类标记）的最后一层隐藏状态，经过线性层和 Tanh 激活函数进一步处理。在预训练期间，线性层权重是从下一个句子预测（分类）目标中训练得到的。此输出通常不是输入语义内容的良好总结，您通常最好对整个输入序列的隐藏状态序列进行平均或池化。
-
hidden_states (
tuple(tf.Tensor), 可选，在传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入的输出，一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出处的隐藏状态，加上初始嵌入输出。
-
attentions (
tuple(tf.Tensor), 可选，在传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
The TFAlbertModel 正向方法覆盖了 __call__ 特殊方法。
尽管需要在此函数内定义前向传递的配方，但随后应该调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFAlbertModel
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-base-v2")
>>> model = TFAlbertModel.from_pretrained("albert/albert-base-v2")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> last_hidden_states = outputs.last_hidden_stateTFAlbertForPreTraining
class transformers.TFAlbertForPreTraining
< 来源 >( config: AlbertConfig *inputs **kwargs )
参数
- config (AlbertConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法加载模型权重。
带有两个头部的 Albert 模型，用于预训练：一个掩码语言建模头和一个句子顺序预测（分类）头。
此模型继承自 TFPreTrainedModel。 检查超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头部等）。
此模型也是 keras.Model 子类。 将其用作常规 TF 2.0 Keras 模型，并参考 TF 2.0 文档以了解与一般使用和行为相关的所有事项。
transformers 中的 TensorFlow 模型和层接受两种格式作为输入
- 将所有输入作为关键字参数（如 PyTorch 模型），或
- 将所有输入作为第一个位置参数中的列表、元组或字典。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。 由于这种支持，在使用像 model.fit() 这样的方法时，事情应该“正常工作” - 只需以 model.fit() 支持的任何格式传递你的输入和标签！ 但是，如果你想在像 fit() 和 predict() 这样的 Keras 方法之外使用第二种格式，例如在使用 Keras Functional API 创建你自己的层或模型时，你可以使用三种可能性来收集第一个位置参数中的所有输入张量
- 仅包含
input_ids的单个张量，没有其他内容：model(input_ids) - 一个长度可变的列表，其中包含一个或多个输入张量，按文档字符串中给出的顺序排列：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一个字典，其中一个或多个输入张量与文档字符串中给出的输入名称相关联：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，在使用 子类化 创建模型和层时，你无需担心这些问题，因为你可以像传递给任何其他 Python 函数一样传递输入！
call
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None sentence_order_label: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → transformers.models.albert.modeling_tf_albert.TFAlbertForPreTrainingOutput or tuple(tf.Tensor)
参数
- input_ids (
NumPy 数组或tf.Tensor形状为(batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode() 。
- attention_mask (
NumPy 数组或tf.Tensor形状为(batch_size, sequence_length), 可选) — 掩码以避免对填充标记索引执行注意力。在[0, 1]中选择掩码值：- 1 表示 未掩码 的标记，
- 0 表示 已掩码 的标记。
- token_type_ids (
NumPy 数组或tf.Tensor形状为(batch_size, sequence_length), 可选) — 段标记索引，用于指示输入的第一部分和第二部分。在[0, 1]中选择索引：- 0 对应于 句子 A 标记，
- 1 对应于 句子 B 标记。
- position_ids (
NumPy 数组或tf.Tensor形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列标记的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - head_mask (
NumPy 数组或tf.Tensor形状为(num_heads,)或(num_layers, num_heads), 可选) — 掩码以使自注意力模块中选定的头部失效。在[0, 1]中选择掩码值：- 1 表示 未掩码 的头部，
- 0 表示 已掩码 的头部。
- inputs_embeds (
tf.Tensor形状为(batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想对如何将input_ids索引转换为关联的向量进行更多控制，这将非常有用，而不是模型的内部嵌入查找矩阵。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量下的attentions。此参数仅可在急切模式下使用，在图形模式下，将使用配置中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。此参数只能在急切模式下使用，在图模式下，将使用配置文件中的值。 - return_dict (
bool, 可选) — 是否返回一个ModelOutput而不是一个简单的元组。此参数可以在急切模式下使用，在图模式下，该值将始终设置为True。 - training (
bool, 可选，默认值为False) — 是否以训练模式使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。
返回
transformers.models.albert.modeling_tf_albert.TFAlbertForPreTrainingOutput or tuple(tf.Tensor)
一个transformers.models.albert.modeling_tf_albert.TFAlbertForPreTrainingOutput或一个tf.Tensor元组（如果传递return_dict=False或当config.return_dict=False时），包含取决于配置（AlbertConfig）和输入的不同元素。
-
prediction_logits (
tf.Tensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。 -
sop_logits (
tf.Tensor，形状为(batch_size, 2)) — 下一个序列预测（分类）头的预测分数（SoftMax 之前 True/False 继续的分数）。 -
hidden_states (
tuple(tf.Tensor), 可选，在传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入的输出，一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出处的隐藏状态，加上初始嵌入输出。
-
attentions (
tuple(tf.Tensor), 可选，在传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
The TFAlbertForPreTraining forward method, overrides the __call__ special method.
尽管需要在此函数内定义前向传递的配方，但随后应该调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> import tensorflow as tf
>>> from transformers import AutoTokenizer, TFAlbertForPreTraining
>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-base-v2")
>>> model = TFAlbertForPreTraining.from_pretrained("albert/albert-base-v2")
>>> input_ids = tf.constant(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True))[None, :]
>>> # Batch size 1
>>> outputs = model(input_ids)
>>> prediction_logits = outputs.prediction_logits
>>> sop_logits = outputs.sop_logitsTFAlbertForMaskedLM
class transformers.TFAlbertForMaskedLM
< source >( config: AlbertConfig *inputs **kwargs )
参数
- config (AlbertConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看from_pretrained()方法以加载模型权重。
带有 语言建模 头部的 Albert 模型。
此模型继承自 TFPreTrainedModel。 检查超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头部等）。
此模型也是 keras.Model 子类。 将其用作常规 TF 2.0 Keras 模型，并参考 TF 2.0 文档以了解与一般使用和行为相关的所有事项。
transformers 中的 TensorFlow 模型和层接受两种格式作为输入
- 将所有输入作为关键字参数（如 PyTorch 模型），或
- 将所有输入作为第一个位置参数中的列表、元组或字典。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。 由于这种支持，在使用像 model.fit() 这样的方法时，事情应该“正常工作” - 只需以 model.fit() 支持的任何格式传递你的输入和标签！ 但是，如果你想在像 fit() 和 predict() 这样的 Keras 方法之外使用第二种格式，例如在使用 Keras Functional API 创建你自己的层或模型时，你可以使用三种可能性来收集第一个位置参数中的所有输入张量
- 仅包含
input_ids的单个张量，没有其他内容：model(input_ids) - 一个长度可变的列表，其中包含一个或多个输入张量，按文档字符串中给出的顺序排列：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一个字典，其中一个或多个输入张量与文档字符串中给出的输入名称相关联：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，在使用 子类化 创建模型和层时，你无需担心这些问题，因为你可以像传递给任何其他 Python 函数一样传递输入！
call
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → transformers.modeling_tf_outputs.TFMaskedLMOutput or tuple(tf.Tensor)
参数
- input_ids (
Numpy array或tf.Tensor形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
Numpy array或tf.Tensor形状为(batch_size, sequence_length)，可选) — 掩码，用于避免对填充标记索引执行注意力。掩码值在[0, 1]中选择：- 1 表示 未掩码 的标记，
- 0 表示 掩码 的标记。
- token_type_ids (
Numpy array或tf.Tensor形状为(batch_size, sequence_length)，可选) — 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 句子 A 标记，
- 1 对应于 句子 B 标记。
- position_ids (
Numpy array或tf.Tensor形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列标记的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - head_mask (
Numpy array或tf.Tensor形状为(num_heads,)或(num_layers, num_heads)，可选) — 掩码，用于使自注意力模块的选定头部无效。掩码值在[0, 1]中选择：- 1 表示头部 未掩码，
- 0 表示头部 掩码。
- inputs_embeds (
tf.Tensor形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将input_ids索引转换为关联向量，这很有用。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参见返回张量中的attentions。此参数只能在急切模式下使用，在图形模式下，将使用配置中的值。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关详细信息，请参见返回张量中的hidden_states。此参数只能在急切模式下使用，在图形模式下，将使用配置中的值。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。此参数可以在急切模式下使用，在图形模式下，该值将始终设置为 True。
返回
transformers.modeling_tf_outputs.TFMaskedLMOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFMaskedLMOutput 或一个 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含取决于配置（AlbertConfig）和输入的各种元素。
-
loss (
tf.Tensor形状为(n,)，可选，其中 n 是非掩码标签的数量，在提供labels时返回) — 掩码语言建模 (MLM) 损失。 -
logits (
tf.Tensor形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前的每个词汇表标记的分数）。 -
hidden_states (
tuple(tf.Tensor), 可选，在传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入的输出，一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出处的隐藏状态，加上初始嵌入输出。
-
attentions (
tuple(tf.Tensor), 可选，在传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
The TFAlbertForMaskedLM 正向方法，覆盖了 __call__ 特殊方法。
尽管需要在此函数内定义前向传递的配方，但随后应该调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> import tensorflow as tf
>>> from transformers import AutoTokenizer, TFAlbertForMaskedLM
>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-base-v2")
>>> model = TFAlbertForMaskedLM.from_pretrained("albert/albert-base-v2")
>>> # add mask_token
>>> inputs = tokenizer(f"The capital of [MASK] is Paris.", return_tensors="tf")
>>> logits = model(**inputs).logits
>>> # retrieve index of [MASK]
>>> mask_token_index = tf.where(inputs.input_ids == tokenizer.mask_token_id)[0][1]
>>> predicted_token_id = tf.math.argmax(logits[0, mask_token_index], axis=-1)
>>> tokenizer.decode(predicted_token_id)
'france'TFAlbertForSequenceClassification
class transformers.TFAlbertForSequenceClassification
< source >( config: AlbertConfig *inputs **kwargs )
参数
- config (AlbertConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
在顶部带有序列分类/回归头的 Albert 模型转换器（在池化输出的顶部有一个线性层），例如用于 GLUE 任务。
此模型继承自 TFPreTrainedModel。 检查超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头部等）。
此模型也是 keras.Model 子类。 将其用作常规 TF 2.0 Keras 模型，并参考 TF 2.0 文档以了解与一般使用和行为相关的所有事项。
transformers 中的 TensorFlow 模型和层接受两种格式作为输入
- 将所有输入作为关键字参数（如 PyTorch 模型），或
- 将所有输入作为第一个位置参数中的列表、元组或字典。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。 由于这种支持，在使用像 model.fit() 这样的方法时，事情应该“正常工作” - 只需以 model.fit() 支持的任何格式传递你的输入和标签！ 但是，如果你想在像 fit() 和 predict() 这样的 Keras 方法之外使用第二种格式，例如在使用 Keras Functional API 创建你自己的层或模型时，你可以使用三种可能性来收集第一个位置参数中的所有输入张量
- 仅包含
input_ids的单个张量，没有其他内容：model(input_ids) - 一个长度可变的列表，其中包含一个或多个输入张量，按文档字符串中给出的顺序排列：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一个字典，其中一个或多个输入张量与文档字符串中给出的输入名称相关联：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，在使用 子类化 创建模型和层时，你无需担心这些问题，因为你可以像传递给任何其他 Python 函数一样传递输入！
call
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或 tuple(tf.Tensor)
参数
- input_ids (
Numpy 数组或tf.Tensor形状为(batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。索引可以使用 AutoTokenizer 获取。有关详细信息，请参见 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
Numpy 数组或tf.Tensor形状为(batch_size, sequence_length)，可选) — 掩码以避免对填充标记索引执行注意力。在[0, 1]中选择的掩码值：- 1 表示未掩码的标记，
- 0 表示掩码的标记。
- token_type_ids (
Numpy 数组或tf.Tensor形状为(batch_size, sequence_length), 可选) — 分段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 句子 A 标记
- 1 对应于 句子 B 标记
- position_ids (
Numpy 数组或tf.Tensor形状为(batch_size, sequence_length), 可选) — 输入序列标记在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - head_mask (
Numpy 数组或tf.Tensor形状为(num_heads,)或(num_layers, num_heads), 可选) — 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：- 1 表示头部未被掩盖
- 0 表示头部被掩盖
- inputs_embeds (
tf.Tensor形状为(batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望比模型的内部嵌入查找矩阵更全面地控制如何将input_ids索引转换为相关的向量，这将非常有用。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。此参数仅可在急切模式下使用，在图模式下，将使用配置中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量中的hidden_states。此参数仅可在急切模式下使用，在图模式下，将使用配置中的值。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下，该值将始终设置为 True。 - training (
bool, 可选，默认值为False) — 是否以训练模式使用模型（某些模块，如 dropout 模块，在训练和评估之间有不同的行为）。 - labels (
tf.Tensor形状为(batch_size,), 可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]中。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。
返回
transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或 tf.Tensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包括根据配置 (AlbertConfig) 和输入的不同元素。
-
loss (
tf.Tensor形状为(batch_size, ), 可选，在提供labels时返回) — 分类（或如果 config.num_labels==1 则为回归）损失。 -
logits (
tf.Tensor形状为(batch_size, config.num_labels)) — 分类（如果 config.num_labels==1 则为回归）得分（在 SoftMax 之前）。 -
hidden_states (
tuple(tf.Tensor), 可选，在传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入的输出，一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出处的隐藏状态，加上初始嵌入输出。
-
attentions (
tuple(tf.Tensor), 可选，在传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
TFAlbertForSequenceClassification 的 forward 方法覆盖了 __call__ 特殊方法。
尽管需要在此函数内定义前向传递的配方，但随后应该调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFAlbertForSequenceClassification
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("vumichien/albert-base-v2-imdb")
>>> model = TFAlbertForSequenceClassification.from_pretrained("vumichien/albert-base-v2-imdb")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> logits = model(**inputs).logits
>>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])
>>> model.config.id2label[predicted_class_id]
'LABEL_1'>>> # 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 = TFAlbertForSequenceClassification.from_pretrained("vumichien/albert-base-v2-imdb", num_labels=num_labels)
>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).loss
>>> round(float(loss), 2)
0.12TFAlbertForMultipleChoice
class transformers.TFAlbertForMultipleChoice
< 源代码 >( config: AlbertConfig *inputs **kwargs )
参数
- config (AlbertConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法来加载模型权重。
在 Albert 模型之上添加多选分类头（池化输出之上的线性层和 softmax），例如用于 RocStories/SWAG 任务。
此模型继承自 TFPreTrainedModel。 检查超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头部等）。
此模型也是 keras.Model 子类。 将其用作常规 TF 2.0 Keras 模型，并参考 TF 2.0 文档以了解与一般使用和行为相关的所有事项。
transformers 中的 TensorFlow 模型和层接受两种格式作为输入
- 将所有输入作为关键字参数（如 PyTorch 模型），或
- 将所有输入作为第一个位置参数中的列表、元组或字典。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。 由于这种支持，在使用像 model.fit() 这样的方法时，事情应该“正常工作” - 只需以 model.fit() 支持的任何格式传递你的输入和标签！ 但是，如果你想在像 fit() 和 predict() 这样的 Keras 方法之外使用第二种格式，例如在使用 Keras Functional API 创建你自己的层或模型时，你可以使用三种可能性来收集第一个位置参数中的所有输入张量
- 仅包含
input_ids的单个张量，没有其他内容：model(input_ids) - 一个长度可变的列表，其中包含一个或多个输入张量，按文档字符串中给出的顺序排列：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一个字典，其中一个或多个输入张量与文档字符串中给出的输入名称相关联：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，在使用 子类化 创建模型和层时，你无需担心这些问题，因为你可以像传递给任何其他 Python 函数一样传递输入！
call
< 源代码 >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput 或 tuple(tf.Tensor)
参数
- input_ids (
Numpy 数组或tf.Tensor形状为(batch_size, num_choices, sequence_length)) — 词汇表中输入序列标记的索引。索引可以通过 AutoTokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
Numpy 数组或tf.Tensor形状为(batch_size, num_choices, sequence_length)，可选) — 用于避免对填充标记索引执行注意力的掩码。在[0, 1]中选择掩码值：- 1 表示 未掩码 的标记，
- 0 表示 掩码 的标记。
- token_type_ids (
Numpy 数组或tf.Tensor形状为(batch_size, num_choices, sequence_length)，可选) — 段标记索引，指示输入的第一部分和第二部分。在[0, 1]中选择索引：- 0 对应于 句子 A 标记，
- 1 对应于 句子 B 标记。
- position_ids (
Numpy 数组或tf.Tensor形状为(batch_size, num_choices, sequence_length)，可选) — 位置嵌入中每个输入序列标记的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - head_mask (
NumPy 数组或tf.Tensor形状为(num_heads,)或(num_layers, num_heads), 可选) — 用于使自注意力模块中选定头部无效的掩码。掩码值选在[0, 1]中：- 1 表示头部 未被掩盖，
- 0 表示头部 被掩盖。
- inputs_embeds (
tf.Tensor形状为(batch_size, num_choices, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望对如何将input_ids索引转换为相关向量进行更多控制，而不是模型的内部嵌入查找矩阵，这将很有用。 - output_attentions (
布尔值, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。此参数仅可在急切模式下使用，在图形模式下将使用配置中的值。 - output_hidden_states (
布尔值, 可选) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量中的hidden_states。此参数仅可在急切模式下使用，在图形模式下将使用配置中的值。 - return_dict (
布尔值, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图形模式下，该值将始终设置为 True。 - training (
布尔值, 可选, 默认值为False) — 是否在训练模式下使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。 - labels (
tf.Tensor形状为(batch_size,), 可选) — 用于计算多选分类损失的标签。索引应在[0, ..., num_choices]中，其中num_choices是输入张量的第二维的大小。（参见上面的input_ids）
返回
transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput 或 tf.Tensor 的元组（如果传递 return_dict=False 或当 config.return_dict=False 时），包含取决于配置（AlbertConfig）和输入的各种元素。
-
loss (
tf.Tensor形状为 (batch_size, ), 可选, 当提供labels时返回) — 分类损失。 -
logits (
tf.Tensor形状为(batch_size, num_choices)) — num_choices 是输入张量的第二维。（参见上面的 input_ids）。分类分数(在 SoftMax 之前)。
-
hidden_states (
tuple(tf.Tensor), 可选，在传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入的输出，一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出处的隐藏状态，加上初始嵌入输出。
-
attentions (
tuple(tf.Tensor), 可选，在传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
TFAlbertForMultipleChoice 正向方法，覆盖了 __call__ 特殊方法。
尽管需要在此函数内定义前向传递的配方，但随后应该调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFAlbertForMultipleChoice
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-base-v2")
>>> model = TFAlbertForMultipleChoice.from_pretrained("albert/albert-base-v2")
>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="tf", padding=True)
>>> inputs = {k: tf.expand_dims(v, 0) for k, v in encoding.items()}
>>> outputs = model(inputs) # batch size is 1
>>> # the linear classifier still needs to be trained
>>> logits = outputs.logitsTFAlbertForTokenClassification
class transformers.TFAlbertForTokenClassification
< source >( config: AlbertConfig *inputs **kwargs )
TFAlbertForQuestionAnswering
class transformers.TFAlbertForQuestionAnswering
< 源代码 >( config: AlbertConfig *inputs **kwargs )
参数
- config (AlbertConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。
Albert 模型，顶部有一个跨度分类头，用于提取式问答任务，例如 SQuAD（在隐藏状态输出之上有一个线性层，用于计算 跨度开始 logits 和 跨度结束 logits）。
此模型继承自 TFPreTrainedModel。 检查超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头部等）。
此模型也是 keras.Model 子类。 将其用作常规 TF 2.0 Keras 模型，并参考 TF 2.0 文档以了解与一般使用和行为相关的所有事项。
transformers 中的 TensorFlow 模型和层接受两种格式作为输入
- 将所有输入作为关键字参数（如 PyTorch 模型），或
- 将所有输入作为第一个位置参数中的列表、元组或字典。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。 由于这种支持，在使用像 model.fit() 这样的方法时，事情应该“正常工作” - 只需以 model.fit() 支持的任何格式传递你的输入和标签！ 但是，如果你想在像 fit() 和 predict() 这样的 Keras 方法之外使用第二种格式，例如在使用 Keras Functional API 创建你自己的层或模型时，你可以使用三种可能性来收集第一个位置参数中的所有输入张量
- 仅包含
input_ids的单个张量，没有其他内容：model(input_ids) - 一个长度可变的列表，其中包含一个或多个输入张量，按文档字符串中给出的顺序排列：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一个字典，其中一个或多个输入张量与文档字符串中给出的输入名称相关联：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，在使用 子类化 创建模型和层时，你无需担心这些问题，因为你可以像传递给任何其他 Python 函数一样传递输入！
call
< 源代码 >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None start_positions: np.ndarray | tf.Tensor | None = None end_positions: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput 或 tuple(tf.Tensor)
参数
- input_ids (
Numpy 数组或tf.Tensor形状为(batch_size, sequence_length)) — 输入序列词元在词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
Numpy 数组或tf.Tensor形状为(batch_size, sequence_length)，可选) — 用于避免对填充词元索引执行注意的掩码。在[0, 1]中选择掩码值：- 1 表示未屏蔽的词元，
- 0 表示屏蔽的词元。
- token_type_ids (
Numpy 数组或tf.Tensor形状为(batch_size, sequence_length)，可选) — 分割词元索引，指示输入的第一部分和第二部分。在[0, 1]中选择索引：- 0 表示句子 A 词元，
- 1 表示句子 B 词元。
- position_ids (
Numpy 数组或tf.Tensor形状为(batch_size, sequence_length)，可选) — 输入序列词元在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - head_mask (
Numpy 数组或tf.Tensor形状为(num_heads,)或(num_layers, num_heads)，可选) — 掩码，用于使自注意力模块的选定头部失效。在[0, 1]中选择掩码值：- 1 表示头部未屏蔽，
- 0 表示头部屏蔽。
- inputs_embeds (
tf.Tensor形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想更好地控制如何将input_ids索引转换为相关的向量（而不是模型的内部嵌入查找矩阵），这将非常有用。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。此参数只能在急切模式下使用，在图模式下，将使用配置中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量中的hidden_states。此参数仅可在急切模式下使用，在图模式下，将使用配置中的值。 - return_dict (
bool, 可选) — 是否返回一个 ModelOutput 而不是一个简单的元组。此参数可以在急切模式下使用，在图模式下，该值将始终设置为 True。 - training (
bool, 可选，默认为False) — 是否在训练模式下使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。 - start_positions (
tf.Tensor形状为(batch_size,), 可选) — 用于计算标记分类损失的标记跨度开始位置（索引）的标签。位置被限制为序列的长度 (sequence_length)。序列之外的位置不会被考虑用于计算损失。 - end_positions (
tf.Tensor形状为(batch_size,), 可选) — 用于计算标记分类损失的标记跨度结束位置（索引）的标签。位置被限制为序列的长度 (sequence_length)。序列之外的位置不会被考虑用于计算损失。
返回
transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput 或一个 tf.Tensor 的元组（如果传递了 return_dict=False 或者当 config.return_dict=False 时），包含根据配置 ( AlbertConfig ) 和输入的不同元素。
-
loss (
tf.Tensor形状为(batch_size, ), 可选，当提供start_positions和end_positions时返回) — 总跨度提取损失是开始和结束位置的交叉熵之和。 -
start_logits (
tf.Tensor形状为(batch_size, sequence_length)) — 跨度开始分数（在 SoftMax 之前）。 -
end_logits (
tf.Tensor形状为(batch_size, sequence_length)) — 跨度结束分数（在 SoftMax 之前）。 -
hidden_states (
tuple(tf.Tensor), 可选，在传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入的输出，一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出处的隐藏状态，加上初始嵌入输出。
-
attentions (
tuple(tf.Tensor), 可选，在传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
TFAlbertForQuestionAnswering 正向方法，覆盖了 __call__ 特殊方法。
尽管需要在此函数内定义前向传递的配方，但随后应该调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFAlbertForQuestionAnswering
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("vumichien/albert-base-v2-squad2")
>>> model = TFAlbertForQuestionAnswering.from_pretrained("vumichien/albert-base-v2-squad2")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="tf")
>>> outputs = model(**inputs)
>>> answer_start_index = int(tf.math.argmax(outputs.start_logits, axis=-1)[0])
>>> answer_end_index = int(tf.math.argmax(outputs.end_logits, axis=-1)[0])
>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens)
'a nice puppet'FlaxAlbertModel
class transformers.FlaxAlbertModel
< source >( config: AlbertConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (AlbertConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 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。
基本的 Albert 模型转换器，输出原始隐藏状态，没有顶部的特定头部。
此模型继承自 FlaxPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如，从 PyTorch 模型下载、保存和转换权重）。
此模型也是 flax.linen.Module 子类。将它用作常规 Flax linen 模块，并参考 Flax 文档以了解与一般用法和行为相关的所有事项。
最后，此模型支持固有的 JAX 功能，例如
__call__
< 源代码 >( input_ids attention_mask = None token_type_ids = None position_ids = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- input_ids (
numpy.ndarray形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
numpy.ndarray形状为(batch_size, sequence_length), 可选) — 掩码以避免对填充标记索引执行注意力。在[0, 1]中选择掩码值：- 1 表示未掩码的标记，
- 0 表示掩码的标记。
- token_type_ids (
numpy.ndarray形状为(batch_size, sequence_length), 可选) — 段标记索引，用于指示输入的第一部分和第二部分。在[0, 1]中选择索引：- 0 对应于句子 A 标记，
- 1 对应于句子 B 标记。
- position_ids (
numpy.ndarray形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列标记位置的索引。在[0, config.max_position_embeddings - 1]范围内选择。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含根据配置 (AlbertConfig) 和输入的不同元素。
-
last_hidden_state (
jnp.ndarray形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出处的隐藏状态序列。 -
pooler_output (
jnp.ndarray形状为(batch_size, hidden_size)) — 序列第一个 token（分类 token）的最后一层隐藏状态，经过线性层和 Tanh 激活函数进一步处理。线性层权重在预训练期间从下一个句子预测（分类）目标中训练得到。 -
hidden_states (
tuple(jnp.ndarray), 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每一层的输出）形状为(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 后的注意力权重，用于计算自注意力头中的加权平均值。
FlaxAlbertPreTrainedModel 的前向方法覆盖了 __call__ 特殊方法。
尽管需要在此函数内定义前向传递的配方，但随后应该调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, FlaxAlbertModel
>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-base-v2")
>>> model = FlaxAlbertModel.from_pretrained("albert/albert-base-v2")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="jax")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_stateFlaxAlbertForPreTraining
class transformers.FlaxAlbertForPreTraining
< source >( config: AlbertConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (AlbertConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 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。
Albert 模型在顶部有两个 head，就像在预训练期间所做的那样：一个 masked language modeling head 和一个 sentence order prediction (classification) head。
此模型继承自 FlaxPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如，从 PyTorch 模型下载、保存和转换权重）。
此模型也是 flax.linen.Module 子类。将它用作常规 Flax linen 模块，并参考 Flax 文档以了解与一般用法和行为相关的所有事项。
最后，此模型支持固有的 JAX 功能，例如
__call__
< source >( input_ids attention_mask = None token_type_ids = None position_ids = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.models.albert.modeling_flax_albert.FlaxAlbertForPreTrainingOutput or tuple(torch.FloatTensor)
参数
- input_ids (
numpy.ndarray形状为(batch_size, sequence_length)) — 输入序列 token 在词汇表中的索引。索引可以使用 AutoTokenizer 获取。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 获取详细信息。
- attention_mask (
numpy.ndarray形状为(batch_size, sequence_length), 可选) — 用于避免对填充 token 索引执行注意力的掩码。掩码值在[0, 1]中选择：- 1 表示未掩码的 token，
- 0 表示已掩码的 token。
- token_type_ids (
numpy.ndarray形状为(batch_size, sequence_length), 可选) — 用于指示输入的第一个和第二个部分的段标记索引。索引在[0, 1]中选择：- 0 对应于句子 A 标记，
- 1 对应于句子 B 标记。
- position_ids (
numpy.ndarray形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列标记的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.models.albert.modeling_flax_albert.FlaxAlbertForPreTrainingOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.albert.modeling_flax_albert.FlaxAlbertForPreTrainingOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包括取决于配置 (AlbertConfig) 和输入的各种元素。
-
prediction_logits (
jnp.ndarray形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前的每个词汇标记的分数）。 -
sop_logits (
jnp.ndarray形状为(batch_size, 2)) — 下一个序列预测（分类）头的预测分数（SoftMax 之前的 True/False 继续分数）。 -
hidden_states (
tuple(jnp.ndarray), 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每一层的输出）形状为(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 后的注意力权重，用于计算自注意力头中的加权平均值。
FlaxAlbertPreTrainedModel 的前向方法覆盖了 __call__ 特殊方法。
尽管需要在此函数内定义前向传递的配方，但随后应该调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, FlaxAlbertForPreTraining
>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-base-v2")
>>> model = FlaxAlbertForPreTraining.from_pretrained("albert/albert-base-v2")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="np")
>>> outputs = model(**inputs)
>>> prediction_logits = outputs.prediction_logits
>>> seq_relationship_logits = outputs.sop_logitsFlaxAlbertForMaskedLM
class transformers.FlaxAlbertForMaskedLM
< 源代码 >( config: AlbertConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (AlbertConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 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。
带有 语言建模 头部的 Albert 模型。
此模型继承自 FlaxPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如，从 PyTorch 模型下载、保存和转换权重）。
此模型也是 flax.linen.Module 子类。将它用作常规 Flax linen 模块，并参考 Flax 文档以了解与一般用法和行为相关的所有事项。
最后，此模型支持固有的 JAX 功能，例如
__call__
< 源代码 >( input_ids attention_mask = None token_type_ids = None position_ids = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
numpy.ndarray形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。索引可使用 AutoTokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
numpy.ndarray形状为(batch_size, sequence_length)，可选) — 掩码以避免对填充标记索引执行注意力。掩码值在[0, 1]中选择：- 1 表示未掩码的标记，
- 0 表示掩码的标记。
- token_type_ids (
numpy.ndarray形状为(batch_size, sequence_length)，可选) — 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于句子 A 标记，
- 1 对应于句子 B 标记。
- position_ids (
numpy.ndarray形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列标记的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含取决于配置 (AlbertConfig) 和输入的各种元素。
-
logits (
jnp.ndarray形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前的每个词汇表标记的分数）。 -
hidden_states (
tuple(jnp.ndarray), 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每一层的输出）形状为(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 后的注意力权重，用于计算自注意力头中的加权平均值。
FlaxAlbertPreTrainedModel 的前向方法覆盖了 __call__ 特殊方法。
尽管需要在此函数内定义前向传递的配方，但随后应该调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, FlaxAlbertForMaskedLM
>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-base-v2", revision="refs/pr/11")
>>> model = FlaxAlbertForMaskedLM.from_pretrained("albert/albert-base-v2", revision="refs/pr/11")
>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="jax")
>>> outputs = model(**inputs)
>>> logits = outputs.logitsFlaxAlbertForSequenceClassification
class transformers.FlaxAlbertForSequenceClassification
< 源代码 >( config: AlbertConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (AlbertConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化不会加载与模型关联的权重，只会加载配置。查看 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。
在顶部带有序列分类/回归头的 Albert 模型转换器（在池化输出的顶部有一个线性层），例如用于 GLUE 任务。
此模型继承自 FlaxPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如，从 PyTorch 模型下载、保存和转换权重）。
此模型也是 flax.linen.Module 子类。将它用作常规 Flax linen 模块，并参考 Flax 文档以了解与一般用法和行为相关的所有事项。
最后，此模型支持固有的 JAX 功能，例如
FlaxAlbertPreTrainedModel 的前向方法覆盖了 __call__ 特殊方法。
尽管需要在此函数内定义前向传递的配方，但随后应该调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, FlaxAlbertForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-base-v2")
>>> model = FlaxAlbertForSequenceClassification.from_pretrained("albert/albert-base-v2")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="jax")
>>> outputs = model(**inputs)
>>> logits = outputs.logitsFlaxAlbertForMultipleChoice
class transformers.FlaxAlbertForMultipleChoice
< 源代码 >( config: AlbertConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (AlbertConfig) — 模型配置类，包含模型的所有参数。用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 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。
在 Albert 模型之上添加多选分类头（池化输出之上的线性层和 softmax），例如用于 RocStories/SWAG 任务。
此模型继承自 FlaxPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如，从 PyTorch 模型下载、保存和转换权重）。
此模型也是 flax.linen.Module 子类。将它用作常规 Flax linen 模块，并参考 Flax 文档以了解与一般用法和行为相关的所有事项。
最后，此模型支持固有的 JAX 功能，例如
__call__
< 源代码 >( input_ids attention_mask = None token_type_ids = None position_ids = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
numpy.ndarray形状为(batch_size, num_choices, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
numpy.ndarray形状为(batch_size, num_choices, sequence_length), 可选) — 掩码以避免对填充标记索引执行注意力。在[0, 1]中选择的掩码值：- 1 表示未掩码的标记，
- 0 表示掩码的标记。
- token_type_ids (
numpy.ndarray形状为(batch_size, num_choices, sequence_length), 可选) — 分段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于句子 A 标记，
- 1 对应于句子 B 标记。
- position_ids (
numpy.ndarray形状为(batch_size, num_choices, sequence_length), 可选) — 位置嵌入中每个输入序列标记的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含取决于配置 (AlbertConfig) 和输入的各种元素。
-
logits (
jnp.ndarray形状为(batch_size, num_choices)) — num_choices 是输入张量的第二维。（见上面的 input_ids）。分类分数(在 SoftMax 之前)。
-
hidden_states (
tuple(jnp.ndarray), 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每一层的输出）形状为(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 后的注意力权重，用于计算自注意力头中的加权平均值。
FlaxAlbertPreTrainedModel 的前向方法覆盖了 __call__ 特殊方法。
尽管需要在此函数内定义前向传递的配方，但随后应该调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, FlaxAlbertForMultipleChoice
>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-base-v2")
>>> model = FlaxAlbertForMultipleChoice.from_pretrained("albert/albert-base-v2")
>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="jax", padding=True)
>>> outputs = model(**{k: v[None, :] for k, v in encoding.items()})
>>> logits = outputs.logitsFlaxAlbertForTokenClassification
class transformers.FlaxAlbertForTokenClassification
< 源代码 >( config: AlbertConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (AlbertConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。请查看 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。
在顶部带有令牌分类头的 ALBERT 模型(在隐藏状态输出之上有一个线性层)，例如用于命名实体识别(NER)任务。
此模型继承自 FlaxPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如，从 PyTorch 模型下载、保存和转换权重）。
此模型也是 flax.linen.Module 子类。将它用作常规 Flax linen 模块，并参考 Flax 文档以了解与一般用法和行为相关的所有事项。
最后，此模型支持固有的 JAX 功能，例如
__call__
< 源代码 >( input_ids attention_mask = None token_type_ids = None position_ids = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_flax_outputs.FlaxTokenClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
numpy.ndarray形状为(batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。索引可以使用 AutoTokenizer 获取。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 获取更多细节。
- attention_mask (
numpy.ndarray形状为(batch_size, sequence_length), 可选) — 掩码以避免对填充标记索引执行注意力。掩码值选择在[0, 1]中：- 1 表示未屏蔽的标记
- 0 表示屏蔽的标记
- token_type_ids (
numpy.ndarray形状为(batch_size, sequence_length), 可选) — 分段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]中：- 0 对应于句子 A 标记
- 1 对应于句子 B 标记
- position_ids (
numpy.ndarray形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列标记的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 - return_dict (
bool, 可选) — 是否返回一个 ModelOutput 而不是一个简单的元组。
返回
transformers.modeling_flax_outputs.FlaxTokenClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxTokenClassifierOutput 或者 torch.FloatTensor 元组 (如果传递了 return_dict=False 或者当 config.return_dict=False 时) 包含不同元素，具体取决于配置 (AlbertConfig) 和输入。
-
logits (
jnp.ndarray形状为(batch_size, sequence_length, config.num_labels)) — 分类分数 (在 SoftMax 之前)。 -
hidden_states (
tuple(jnp.ndarray), 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每一层的输出）形状为(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 后的注意力权重，用于计算自注意力头中的加权平均值。
FlaxAlbertPreTrainedModel 的前向方法覆盖了 __call__ 特殊方法。
尽管需要在此函数内定义前向传递的配方，但随后应该调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, FlaxAlbertForTokenClassification
>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-base-v2")
>>> model = FlaxAlbertForTokenClassification.from_pretrained("albert/albert-base-v2")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="jax")
>>> outputs = model(**inputs)
>>> logits = outputs.logitsFlaxAlbertForQuestionAnswering
class transformers.FlaxAlbertForQuestionAnswering
< source >( config: AlbertConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (AlbertConfig) — 模型配置类，包含模型的所有参数。用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 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。
带有跨度分类头的 ALBERT 模型，用于抽取式问答任务，例如 SQuAD（在隐藏状态输出之上添加一个线性层，以计算 span start logits 和 span end logits）。
此模型继承自 FlaxPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如，从 PyTorch 模型下载、保存和转换权重）。
此模型也是 flax.linen.Module 子类。将它用作常规 Flax linen 模块，并参考 Flax 文档以了解与一般用法和行为相关的所有事项。
最后，此模型支持固有的 JAX 功能，例如
__call__
< source >( input_ids attention_mask = None token_type_ids = None position_ids = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
numpy.ndarray形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。索引可以通过 AutoTokenizer 获得。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 获取详细信息。
- attention_mask (
numpy.ndarray形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：- 1 表示未屏蔽的标记，
- 0 表示屏蔽的标记。
- token_type_ids (
numpy.ndarray形状为(batch_size, sequence_length)，可选) — 用于指示输入的第一部分和第二部分的段标记索引。索引在[0, 1]中选择：- 0 对应于句子 A 标记，
- 1 对应于句子 B 标记。
- position_ids (
numpy.ndarray形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 - return_dict (
bool，可选) — 是否返回一个ModelOutput 而不是一个简单的元组。
返回
transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
一个transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或当 config.return_dict=False 时），包含取决于配置 (AlbertConfig) 和输入的各种元素。
-
start_logits (
jnp.ndarray形状为(batch_size, sequence_length)) — 跨度开始分数（在 SoftMax 之前）。 -
end_logits (
jnp.ndarray形状为(batch_size, sequence_length)) — 跨度结束分数（在 SoftMax 之前）。 -
hidden_states (
tuple(jnp.ndarray), 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每一层的输出）形状为(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 后的注意力权重，用于计算自注意力头中的加权平均值。
FlaxAlbertPreTrainedModel 的前向方法覆盖了 __call__ 特殊方法。
尽管需要在此函数内定义前向传递的配方，但随后应该调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, FlaxAlbertForQuestionAnswering
>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-base-v2")
>>> model = FlaxAlbertForQuestionAnswering.from_pretrained("albert/albert-base-v2")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="jax")
>>> outputs = model(**inputs)
>>> start_scores = outputs.start_logits
>>> end_scores = outputs.end_logits