Hugging Face 的徽标

Transformers 文档

ALBERT

Hugging Face's logo
加入 Hugging Face 社区

并获取增强的文档体验

开始使用

ALBERT

Models Spaces

概述

ALBERT 模型在 ALBERT: A Lite BERT for Self-supervised Learning of Language Representations 中提出，作者为 Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut。 它提出了两种参数缩减技术，以降低内存消耗并提高 BERT 的训练速度。

  • 将嵌入矩阵拆分为两个较小的矩阵。
  • 使用在组之间拆分的重复层。

以下是论文的摘要：

在预训练自然语言表示时，增加模型大小通常会提高下游任务的性能。然而，在某些时候，由于 GPU/TPU 内存限制、更长的训练时间和意外的模型退化，进一步的模型增加变得更加困难。为了解决这些问题，我们提出了两种参数缩减技术，以降低内存消耗并提高 BERT 的训练速度。全面的经验证据表明，与原始 BERT 相比，我们提出的方法能够更好地扩展模型。我们还使用了一种自监督损失，该损失侧重于建模句子间的连贯性，并表明它始终有助于处理多句输入的下游任务。因此，我们最好的模型在 GLUE、RACE 和 SQuAD 基准测试中建立了新的最先进结果，同时与 BERT-large 相比，参数更少。

此模型由 lysandre 贡献。此模型的 jax 版本由 kamalkraj 贡献。原始代码可以在这里找到。

使用技巧

  • ALBERT 是一个具有绝对位置嵌入的模型，因此通常建议在右侧而不是左侧填充输入。
  • ALBERT 使用重复层，这导致内存占用较小，但是计算成本仍然类似于具有相同隐藏层数的 BERT 架构，因为它必须迭代相同数量的（重复）层。
  • 嵌入大小 E 与隐藏大小 H 不同，这是合理的，因为嵌入是上下文独立的（一个嵌入向量代表一个 token），而隐藏状态是上下文相关的（一个隐藏状态代表一个 token 序列），因此 H >> E 更符合逻辑。此外，嵌入矩阵很大，因为它的大小为 V x E（V 是词汇表大小）。如果 E < H，则其参数较少。
  • 层被分成共享参数的组（以节省内存）。下一个句子预测被句子顺序预测取代：在输入中，我们有两个句子 A 和 B（它们是连续的），我们要么输入 A 后跟 B，要么输入 B 后跟 A。模型必须预测它们是否已被交换。

使用缩放点积注意力 (SDPA)

PyTorch 在 torch.nn.functional 中包含了一个原生的缩放点积注意力 (SDPA) 运算符。此函数包含多种实现方式，可以根据输入和正在使用的硬件应用不同的实现。 请参阅官方文档或 GPU 推理页面以获取更多信息。

当实现可用时，torch>=2.1.1 默认使用 SDPA，但您也可以在 from_pretrained() 中设置 attn_implementation="sdpa" 以显式请求使用 SDPA。

from transformers import AlbertModel
model = AlbertModel.from_pretrained("albert/albert-base-v1", torch_dtype=torch.float16, attn_implementation="sdpa")
...

为了获得最佳加速效果，我们建议以半精度加载模型（例如 torch.float16 或 torch.bfloat16）。

在一个本地基准测试 (GeForce RTX 2060-8GB, PyTorch 2.3.1, OS Ubuntu 20.04) 中，使用 float16，我们看到了以下训练和推理期间的加速。

训练 100 次迭代

batch_size seq_len 每个批次的时间 (eager - s) 每个批次的时间 (sdpa - s) 加速 (%) Eager 峰值内存 (MB) sdpa 峰值内存 (MB) 内存节省 (%)
2 256 0.028 0.024 14.388 358.411 321.088 11.624
2 512 0.049 0.041 17.681 753.458 602.660 25.022
4 256 0.044 0.039 12.246 679.534 602.660 12.756
4 512 0.090 0.076 18.472 1434.820 1134.140 26.512
8 256 0.081 0.072 12.664 1283.825 1134.140 13.198
8 512 0.170 0.143 18.957 2820.398 2219.695 27.062

使用 50 个批次进行推理

batch_size seq_len 每个 token 的延迟 eager (ms) 每个 token 的延迟 SDPA (ms) 加速 (%) 内存 eager (MB) 内存 BT (MB) 内存节省 (%)
4 128 0.083 0.071 16.967 48.319 48.45 -0.268
4 256 0.148 0.127 16.37 63.4 63.922 -0.817
4 512 0.31 0.247 25.473 110.092 94.343 16.693
8 128 0.137 0.124 11.102 63.4 63.66 -0.409
8 256 0.271 0.231 17.271 91.202 92.246 -1.132
8 512 0.602 0.48 25.47 186.159 152.564 22.021
16 128 0.252 0.224 12.506 91.202 91.722 -0.567
16 256 0.526 0.448 17.604 148.378 150.467 -1.388
16 512 1.203 0.96 25.365 338.293 271.102 24.784

此模型由 lysandre 贡献。此模型的 jax 版本由 kamalkraj 贡献。原始代码可以在这里找到。

资源

以下各节中提供的资源包含 Hugging Face 官方和社区（🌎 表示）资源的列表，可帮助您开始使用 AlBERT。如果您有兴趣提交资源以包含在此处，请随时打开 Pull Request，我们将对其进行审核！理想情况下，资源应展示一些新内容，而不是重复现有资源。

文本分类
Token 分类
填充掩码
问答

多项选择

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, optional, 默认为 30000) — ALBERT 模型的词汇表大小。定义了在调用 AlbertModel 或 TFAlbertModel 时传递的 inputs_ids 可以表示的不同 token 的数量。
  • embedding_size (int, optional, 默认为 128) — 词汇嵌入的维度。
  • hidden_size (int, optional, 默认为 4096) — 编码器层和池化器层的维度。
  • num_hidden_layers (int, optional, 默认为 12) — Transformer 编码器中隐藏层的数量。
  • num_hidden_groups (int, optional, 默认为 1) — 隐藏层的组数，同一组中的参数是共享的。
  • num_attention_heads (int, optional, 默认为 64) — Transformer 编码器中每个注意力层的注意力头数。
  • intermediate_size (int, optional, 默认为 16384) — Transformer 编码器中“中间”（通常称为前馈）层的维度。
  • inner_group_num (int, optional, 默认为 1) — 注意力和 ffn 的内部重复次数。
  • hidden_act (str 或 Callable, optional, 默认为 "gelu_new") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持 "gelu"、"relu"、"silu" 和 "gelu_new"。
  • hidden_dropout_prob (float, optional, 默认为 0) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。
  • attention_probs_dropout_prob (float, optional, 默认为 0) — 注意力概率的 dropout 比率。
  • max_position_embeddings (int, optional, 默认为 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值（例如，512 或 1024 或 2048）。
  • type_vocab_size (int, optional, 默认为 2) — 调用 AlbertModel 或 TFAlbertModel 时传递的 token_type_ids 的词汇表大小。
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • layer_norm_eps (float, 可选, 默认为 1e-12) — 层归一化层使用的 epsilon 值。
  • classifier_dropout_prob (float, 可选, 默认为 0.1) — 连接的分类器的 dropout 比率。
  • position_embedding_type (str, 可选, 默认为 "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, 可选, 默认为 0) — Padding token id （填充 token id）。
  • bos_token_id (int, 可选, 默认为 2) — Beginning of stream token id （流开始 token id）。
  • eos_token_id (int, 可选, 默认为 3) — End of stream token id （流结束 token 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.config

AlbertTokenizer

class transformers.AlbertTokenizer

< >

( 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]") — 序列开始 token，在预训练期间使用。 可以用作序列分类 token。

    当使用特殊 token 构建序列时，这并不是用于序列开始的 token。 使用的 token 是 cls_token。
  • eos_token (str, 可选, 默认为 "[SEP]") — 序列结束 token。

    当使用特殊 token 构建序列时，这并不是用于序列结束的 token。 使用的 token 是 sep_token。
  • unk_token (str, 可选, 默认为 "<unk>") — 未知 token。 词汇表中不存在的 token 无法转换为 ID，而是设置为此 token。
  • sep_token (str, 可选, 默认为 "[SEP]") — 分隔符 token，用于从多个序列构建序列时使用，例如用于序列分类的两个序列，或者用于问答的文本和问题。 它也用作使用特殊 token 构建的序列的最后一个 token。
  • pad_token (str, 可选, 默认为 "<pad>") — 用于 padding 的 token，例如在对不同长度的序列进行批处理时。
  • cls_token (str, 可选, 默认为 "[CLS]") — 分类器 token，用于执行序列分类（对整个序列而不是每个 token 进行分类）。 当使用特殊 token 构建时，它是序列的第一个 token。
  • mask_token (str, 可选, 默认为 "[MASK]") — 用于遮蔽值的 token。 这是使用掩码语言建模训练此模型时使用的 token。 这是模型将尝试预测的 token。
  • sp_model_kwargs (dict, 可选) — 将传递给 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 是无限的，并使用前向过滤和后向采样算法从所有假设（格）中采样。

    • alpha: 用于 unigram 采样的平滑参数，以及 BPE-dropout 的合并操作的 dropout 概率。
  • sp_model (SentencePieceProcessor) — 用于每次转换（字符串、token 和 ID）的 SentencePiece 处理器。

构建 ALBERT 分词器。 基于 SentencePiece。

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

build_inputs_with_special_tokens

< >

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

参数

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

返回值

List[int]

带有适当特殊 token 的 input IDs 列表。

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

  • 单序列: [CLS] X [SEP]
  • 序列对: [CLS] A [SEP] B [SEP]

get_special_tokens_mask

< >

( token_ids_0: List token_ids_1: Optional = 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 格式化。默认为 False。

返回值

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: List token_ids_1: Optional = None ) → List[int]

参数

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

返回值

List[int]

根据给定的序列，返回 token type IDs 列表。

从传递的两个序列创建一个 mask，用于序列对分类任务。ALBERT

序列对 mask 具有以下格式

0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果 token_ids_1 为 None，此方法仅返回 mask 的第一部分（0）。

save_vocabulary

< >

( save_directory: str filename_prefix: Optional = None )

AlbertTokenizerFast

class transformers.AlbertTokenizerFast

< >

( 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 扩展名），其中包含实例化 tokenizer 所需的词汇表。
  • do_lower_case (bool, optional, defaults to True) — 是否在 token 化时将输入转换为小写。默认为 True。
  • remove_space (bool, optional, defaults to True) — 是否在 token 化时去除文本 (删除字符串前后多余的空格)。默认为 True。
  • keep_accents (bool, optional, defaults to False) — 是否在 token 化时保留重音符号。默认为 False。
  • bos_token (str, optional, defaults to "[CLS]") — 预训练期间使用的序列开始 token。可以用作序列分类器 token。

    当使用特殊 token 构建序列时，这不是用于序列开始的 token。使用的 token 是 cls_token。
  • eos_token (str, optional, defaults to "[SEP]") — 序列结束 token。 .. note:: 当使用特殊 token 构建序列时，这不是用于序列结束的 token。使用的 token 是 sep_token。
  • unk_token (str, optional, defaults to "<unk>") — 未知 token。词汇表中没有的 token 无法转换为 ID，而是设置为此 token。
  • sep_token (str, optional, defaults to "[SEP]") — 分隔符 token，用于从多个序列构建序列时，例如用于序列分类的两个序列或用于问答的文本和问题。它也用作使用特殊 token 构建的序列的最后一个 token。
  • pad_token (str, optional, defaults to "<pad>") — 用于 padding 的 token，例如当 batch 处理不同长度的序列时。
  • cls_token (str, optional, defaults to "[CLS]") — 分类器 token，用于进行序列分类（对整个序列而不是每个 token 进行分类）。当使用特殊 token 构建时，它是序列的第一个 token。
  • mask_token (str, optional, defaults to "[MASK]") — 用于 masking 值的 token。这是使用 masked language modeling 训练此模型时使用的 token。这是模型将尝试预测的 token。

构建 “fast” ALBERT tokenizer (由 HuggingFace 的 tokenizers 库支持)。基于 Unigram。此 tokenizer 继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息

build_inputs_with_special_tokens

< >

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

参数

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

返回值

List[int]

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

通过连接和添加特殊 token，从序列或序列对构建模型输入，用于序列分类任务。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]

参数

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

返回值

List[int]

根据给定的序列，返回 token type IDs 列表。

从传递的两个序列创建 mask，用于序列对分类任务。ALBERT

序列对 mask 具有以下格式

0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果 token_ids_1 为 None，则仅返回 mask 的第一部分（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 (optional, 当提供 labels 时返回, torch.FloatTensor，形状为 (1,)) — 总损失，为 masked language modeling loss 和 next sequence prediction (分类) loss 的总和。
  • prediction_logits (torch.FloatTensor，形状为 (batch_size, sequence_length, config.vocab_size)) — 语言模型头的预测分数（SoftMax 之前的每个词汇 token 的分数）。
  • sop_logits (torch.FloatTensor，形状为 (batch_size, 2)) — next sequence prediction (分类) 头的预测分数（SoftMax 之前的 True/False 延续的分数）。
  • hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（embeddings 的输出一个，每一层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出的 hidden-states 加上初始 embedding 输出。

  • attentions (tuple(torch.FloatTensor), optional, 当传递 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

< >

( 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 之前的每个词汇 token 的分数）。
  • sop_logits (tf.Tensor，形状为 (batch_size, 2)) — next sequence prediction (分类) 头的预测分数（SoftMax 之前的 True/False 延续的分数）。
  • hidden_states (tuple(tf.Tensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 的元组（embeddings 的输出一个，每一层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出的 hidden-states 加上初始 embedding 输出。

  • attentions (tuple(tf.Tensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — tf.Tensor 的元组（每一层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

TFAlbertForPreTraining 的输出类型。

Pytorch
隐藏 Pytorch 内容

AlbertModel

class transformers.AlbertModel

< >

( config: AlbertConfig add_pooling_layer: bool = True )

参数

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

裸 ALBERT 模型 Transformer，输出原始 hidden-states，顶部没有任何特定的 head。

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch Module，并参阅 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)) — 词汇表中输入序列 tokens 的索引。

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

    什么是输入 IDs？

  • attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的掩码。 掩码值在 [0, 1] 中选择：

    • 1 表示 tokens 未被掩码，
    • 0 表示 tokens 已被掩码。

    什么是 attention masks？

  • token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 片段 token 索引，用于指示输入的第一部分和第二部分。 索引在 [0, 1] 中选择：

    • 0 对应于 sentence A token，
    • 1 对应于 sentence B token。

    什么是 token type IDs？

  • position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 tokens 的位置索引。 在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是 position IDs？

  • head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于 nullify 自注意力模块的选定 head 的掩码。 掩码值在 [0, 1] 中选择：

    • 1 表示 head 未被掩码，
    • 0 表示 head 已被掩码。
  • inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — （可选）您可以选择直接传递嵌入表示，而不是传递 input_ids。 如果您希望比模型的内部嵌入查找矩阵更精确地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
  • output_attentions (bool，可选) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息，请参见返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回张量下的 hidden_states。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通的 tuple。

返回值

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

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

  • last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层的输出端的 hidden-states 序列。

  • pooler_output (torch.FloatTensor，形状为 (batch_size, hidden_size)) — 序列的第一个 token （分类 token）的最后一层 hidden-state，在通过用于辅助预训练任务的层进一步处理之后。 例如，对于 BERT 系列模型，这返回通过线性层和 tanh 激活函数处理后的分类 token。 线性层权重从预训练期间的下一句预测（分类）目标中训练得出。

  • hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的 tuple （如果模型具有嵌入层，则一个用于嵌入的输出；+ 每个层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出端的 Hidden-states，加上可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的 tuple （每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

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

尽管 forward 传递的配方需要在该函数内定义，但是应该在此之后调用 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_state

AlbertForPreTraining

class transformers.AlbertForPreTraining

< >

( config: AlbertConfig )

参数

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

带有两个 head 的 Albert 模型，如同在预训练期间所做的那样：一个 masked language modeling head 和一个 sentence order prediction (classification) head。

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch Module，并参阅 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 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)) — 词汇表中输入序列 tokens 的索引。

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

    什么是输入 IDs？

  • attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的掩码。 掩码值在 [0, 1] 中选择：

    • 1 表示 tokens 未被掩码，
    • 0 表示 tokens 已被掩码。

    什么是 attention masks？

  • token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 片段 token 索引，用于指示输入的第一部分和第二部分。 索引在 [0, 1] 中选择：

    • 0 对应于 sentence A token，
    • 1 对应于 sentence B token。

    什么是 token type IDs？

  • position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 tokens 的位置索引。 在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是 position IDs？

  • head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于 nullify 自注意力模块的选定 head 的掩码。 掩码值在 [0, 1] 中选择：

    • 1 表示 head 未被掩码，
    • 0 表示 head 已被掩码。
  • inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — （可选）您可以选择直接传递嵌入表示，而不是传递 input_ids。 如果您希望比模型的内部嵌入查找矩阵更精确地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
  • output_attentions (bool，可选) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息，请参见返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回张量下的 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)

A 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 之前 True/False 延续的分数）。

  • 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 的 tuple （每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

The AlbertForPreTraining 的 `forward` 方法，覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数内定义，但是应该在此之后调用 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_logits

AlbertForMaskedLM

class transformers.AlbertForMaskedLM

< >

( config )

参数

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

带有语言建模头的 Albert 模型。

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch Module，并参阅 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()。

    什么是输入 ID？

  • 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* 标记。

    什么是标记类型 ID？

  • position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在 [0, config.max_position_embeddings - 1] 范围内选择。

    什么是位置 ID？

  • 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] 中的标记计算。

返回值

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

A transformers.modeling_outputs.MaskedLMOutput 或 torch.FloatTensor 的元组（如果传递 return_dict=False 或当 config.return_dict=False 时），包含取决于配置 (AlbertConfig) 和输入的各种元素。

  • loss (torch.FloatTensor，形状为 (1,)，可选，当提供 labels 时返回) — 掩码语言建模 (MLM) 损失。

  • 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 的 tuple （如果模型具有嵌入层，则一个用于嵌入的输出；+ 每个层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出端的 Hidden-states，加上可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的 tuple （每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

The AlbertForMaskedLM 的 `forward` 方法，覆盖了 `__call__` 特殊方法。

尽管 forward 传递的配方需要在该函数内定义，但是应该在此之后调用 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'
>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)
>>> outputs = model(**inputs, labels=labels)
>>> round(outputs.loss.item(), 2)
0.81

AlbertForSequenceClassification

class transformers.AlbertForSequenceClassification

< >

( config: AlbertConfig )

参数

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

带有序列分类/回归头的 Albert 模型 Transformer（池化输出顶部的线性层），例如用于 GLUE 任务。

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch Module，并参阅 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.SequenceClassifierOutput 或 tuple(torch.FloatTensor)

参数

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

    索引可以通过 AutoTokenizer 获得。 详情请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。

    什么是输入 IDs？

  • attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在 [0, 1] 中选择：

    • 1 表示 tokens 不被 masked，
    • 0 表示 tokens 被 masked。

    什么是 attention masks？

  • token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — Segment token 索引，用于指示输入的第一部分和第二部分。 索引在 [0, 1] 中选择：

    • 0 对应于 sentence A token，
    • 1 对应于 sentence B token。

    什么是 token type IDs？

  • position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 位置 embeddings 中每个输入序列 tokens 的位置索引。 在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是 position IDs？

  • head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于 nullify self-attention 模块中选定 heads 的 Mask。 Mask 值在 [0, 1] 中选择：

    • 1 表示 head 不被 masked，
    • 0 表示 head 被 masked。
  • inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — (可选) 除了传入 input_ids 之外，您还可以选择直接传入嵌入表示。 如果您希望比模型的内部 embedding lookup 矩阵更精细地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
  • output_attentions (bool，可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参阅返回 tensors 下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参阅返回 tensors 下的 hidden_states。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是纯粹的 tuple。
  • 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 的 tuple (如果传递了 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 的 tuple （如果模型具有嵌入层，则一个用于嵌入的输出；+ 每个层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出端的 Hidden-states，加上可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的 tuple （每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

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

尽管 forward 传递的配方需要在该函数内定义，但是应该在此之后调用 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).loss

AlbertForMultipleChoice

class transformers.AlbertForMultipleChoice

< >

( config: AlbertConfig )

参数

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

带有用于多项选择分类 head 的 Albert 模型（pooled output 之上的线性层和一个 softmax），例如用于 RocStories/SWAG 任务。

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch Module，并参阅 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)) — 词汇表中输入序列 tokens 的索引。

    索引可以通过 AutoTokenizer 获得。 详情请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。

    什么是输入 IDs？

  • attention_mask (torch.FloatTensor，形状为 (batch_size, num_choices, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在 [0, 1] 中选择：

    • 1 表示 tokens 不被 masked，
    • 0 表示 tokens 被 masked。

    什么是 attention masks？

  • token_type_ids (torch.LongTensor，形状为 (batch_size, num_choices, sequence_length)，可选) — Segment token 索引，用于指示输入的第一部分和第二部分。 索引在 [0, 1] 中选择：

    • 0 对应于 sentence A token，
    • 1 对应于 sentence B token。

    什么是 token type IDs？

  • position_ids (torch.LongTensor，形状为 (batch_size, num_choices, sequence_length)，可选) — 位置 embeddings 中每个输入序列 tokens 的位置索引。 在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是 position IDs？

  • head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于 nullify self-attention 模块中选定 heads 的 Mask。 Mask 值在 [0, 1] 中选择：

    • 1 表示 head 不被 masked，
    • 0 表示 head 被 masked。
  • inputs_embeds (torch.FloatTensor，形状为 (batch_size, num_choices, sequence_length, hidden_size)，可选) — (可选) 除了传入 input_ids 之外，您还可以选择直接传入嵌入表示。 如果您希望比模型的内部 embedding lookup 矩阵更精细地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
  • output_attentions (bool，可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参阅返回 tensors 下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参阅返回 tensors 下的 hidden_states。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是纯粹的 tuple。
  • labels (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算多项选择分类损失的标签。 索引应在 [0, ..., num_choices-1] 中，其中 num_choices 是输入 tensors 的第二个维度的大小。（请参阅上面的 input_ids）

返回值

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

一个 transformers.modeling_outputs.MultipleChoiceModelOutput 或一个 torch.FloatTensor 的 tuple (如果传递了 return_dict=False 或者当 config.return_dict=False 时) ，包含各种元素，具体取决于配置 (AlbertConfig) 和输入。

  • loss (torch.FloatTensor，形状为 (1,)，可选，当提供 labels 时返回) — 分类损失。

  • logits (torch.FloatTensor，形状为 (batch_size, num_choices)) — num_choices 是输入 tensors 的第二个维度。（请参阅上面的 input_ids）。

    分类得分（SoftMax 之前）。

  • hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的 tuple （如果模型具有嵌入层，则一个用于嵌入的输出；+ 每个层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出端的 Hidden-states，加上可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的 tuple （每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

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

尽管 forward 传递的配方需要在该函数内定义，但是应该在此之后调用 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.logits

AlbertForTokenClassification

class transformers.AlbertForTokenClassification

< >

( config: AlbertConfig )

参数

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

带有 token 分类头的 Albert 模型（位于 hidden-states 输出顶部的线性层），例如用于命名实体识别 (NER) 任务。

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch Module，并参阅 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.TokenClassifierOutput 或 tuple(torch.FloatTensor)

参数

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

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

    什么是 input IDs？

  • attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length), 可选) — 掩码，用于避免在 padding token 索引上执行 attention。 Mask values selected in [0, 1]:

    • 1 表示 tokens 未被掩码，
    • 0 表示 tokens 已被掩码。

    什么是 attention masks？

  • token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length), 可选) — 段落 token 索引，用于指示输入的第一部分和第二部分。索引从 [0, 1] 中选择：

    • 0 对应于 句子 A token，
    • 1 对应于 句子 B token。

    什么是 token type IDs？

  • position_ids (torch.LongTensor，形状为 (batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列 tokens 的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是 position IDs？

  • head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads), 可选) — 掩码，用于置空 self-attention 模块的选定 head。 Mask values selected in [0, 1]:

    • 1 表示 head 未被掩码，
    • 0 表示 head 已被掩码。
  • inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size), 可选) — 或者，您可以选择直接传递嵌入表示而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
  • output_attentions (bool, 可选) — 是否返回所有 attention 层的 attention 张量。 有关更多详细信息，请参见返回张量下的 attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回张量下的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通 tuple。
  • labels (torch.LongTensor，形状为 (batch_size, sequence_length), 可选) — 用于计算 token 分类损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。

返回值

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

一个 transformers.modeling_outputs.TokenClassifierOutput 或一个 torch.FloatTensor 的 tuple (如果传递了 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 的 tuple （如果模型具有嵌入层，则一个用于嵌入的输出；+ 每个层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出端的 Hidden-states，加上可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的 tuple （每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

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

尽管 forward 传递的配方需要在该函数内定义，但是应该在此之后调用 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).loss

AlbertForQuestionAnswering

class transformers.AlbertForQuestionAnswering

< >

( config: AlbertConfig )

参数

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

带有 span 分类头的 Albert 模型，用于抽取式问答任务，如 SQuAD（位于 hidden-states 输出顶部的线性层，用于计算 span start logits 和 span end logits）。

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch Module，并参阅 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 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)) — 词汇表中输入序列 tokens 的索引。

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

    什么是 input IDs？

  • attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length), 可选) — 掩码，用于避免在 padding token 索引上执行 attention。 Mask values selected in [0, 1]:

    • 1 表示 tokens 未被掩码，
    • 0 表示 tokens 已被掩码。

    什么是 attention masks？

  • token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length), 可选) — 段落 token 索引，用于指示输入的第一部分和第二部分。索引从 [0, 1] 中选择：

    • 0 对应于 句子 A token，
    • 1 对应于 句子 B token。

    什么是 token type IDs？

  • position_ids (torch.LongTensor，形状为 (batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列 tokens 的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是 position IDs？

  • head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads), 可选) — 掩码，用于置空 self-attention 模块的选定 head。 Mask values selected in [0, 1]:

    • 1 表示 head 未被掩码，
    • 0 表示 head 已被掩码。
  • inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size), 可选) — 或者，您可以选择直接传递嵌入表示而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
  • output_attentions (bool, 可选) — 是否返回所有 attention 层的 attention 张量。 有关更多详细信息，请参见返回张量下的 attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回张量下的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通 tuple。
  • 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 的 tuple （如果模型具有嵌入层，则一个用于嵌入的输出；+ 每个层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出端的 Hidden-states，加上可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的 tuple （每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

AlbertForQuestionAnswering 的前向传播方法，覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数内定义，但是应该在此之后调用 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.36
TensorFlow
隐藏 TensorFlow 内容

TFAlbertModel

class transformers.TFAlbertModel

< >

( config: AlbertConfig *inputs **kwargs )

参数

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

裸 Albert 模型转换器，输出原始隐藏状态，顶部没有任何特定的 head。

此模型继承自 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 函数一样传递输入！

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)) — 词汇表中输入序列 token 的索引。

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

    什么是输入 IDs？

  • attention_mask (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 掩码，用于避免在 padding token 索引上执行 attention。掩码值在 [0, 1] 中选择：

    • 1 表示 token 未被掩盖，
    • 0 表示 token 已被掩盖。

    什么是 attention 掩码？

  • token_type_ids (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 分段 token 索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：

    • 0 对应于 句子 A token，
    • 1 对应于 句子 B token。

    什么是 token 类型 IDs？

  • position_ids (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列 token 在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 IDs？

  • head_mask (Numpy array 或 tf.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 掩码，用于使自注意力模块的选定 head 失效。掩码值在 [0, 1] 中选择：

    • 1 表示 head 未被掩盖，
    • 0 表示 head 已被掩盖。
  • inputs_embeds (tf.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — （可选）您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
  • output_attentions (bool，可选) — 是否返回所有 attention 层的 attentions 张量。有关更多详细信息，请参阅返回张量下的 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)) — 序列的第一个 token (分类 token) 的最后一层隐藏状态，通过线性层和 Tanh 激活函数进一步处理。线性层权重在预训练期间从下一句预测（分类）目标中训练而来。

    此输出通常不是输入语义内容的良好摘要，通常最好对整个输入序列的隐藏状态序列进行平均或池化。

  • hidden_states (tuple(tf.Tensor)，可选，当传递了 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 元组（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)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

TFAlbertModel 的前向传播方法，覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数内定义，但是应该在此之后调用 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_state

TFAlbertForPreTraining

class transformers.TFAlbertForPreTraining

< >

( config: AlbertConfig *inputs **kwargs )

参数

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

带有两个头的 Albert 模型，用于预训练：一个 masked language modeling 头和一个 sentence order prediction（句子顺序预测）（分类）头。

此模型继承自 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 函数一样传递输入！

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 sentence_order_label: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → transformers.models.albert.modeling_tf_albert.TFAlbertForPreTrainingOutput 或 tuple(tf.Tensor)

参数

  • input_ids (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。

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

    什么是输入 IDs？

  • attention_mask (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — Mask to avoid performing attention on padding token indices. （用于避免在 padding token 索引上执行 attention 的掩码）。掩码值在 [0, 1] 中选择：

    • 1 表示 tokens 未被掩盖，
    • 0 表示 tokens 已被掩盖。

    什么是 attention masks？

  • token_type_ids (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — Segment token indices to indicate first and second portions of the inputs. （分段 token 索引，以指示输入的第一个和第二个部分）。索引在 [0, 1] 中选择：

    • 0 对应于 sentence A token，
    • 1 对应于 sentence B token。

    什么是 token type IDs？

  • position_ids (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — Indices of positions of each input sequence tokens in the position embeddings. （每个输入序列 token 在位置嵌入中的位置索引）。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是 position IDs？

  • head_mask (Numpy array 或 tf.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — Mask to nullify selected heads of the self-attention modules. （用于使 self-attention 模块的选定 head 无效的掩码）。掩码值在 [0, 1] 中选择：

    • 1 表示 head 未被掩盖，
    • 0 表示 head 已被掩盖。
  • inputs_embeds (tf.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — (可选) ，您可以选择直接传递嵌入表示而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
  • output_attentions (bool，可选) — Whether or not to return the attentions tensors of all attention layers. （是否返回所有 attention 层的 attentions tensors）。 有关更多详细信息，请参见返回 tensors 下的 attentions。此参数只能在 eager mode 中使用，在 graph mode 中将使用 config 中的值。
  • output_hidden_states (bool，可选) — Whether or not to return the hidden states of all layers. （是否返回所有层的 hidden states）。 有关更多详细信息，请参见返回 tensors 下的 hidden_states。此参数只能在 eager mode 中使用，在 graph mode 中将使用 config 中的值。
  • return_dict (bool，可选) — Whether or not to return a ModelOutput instead of a plain tuple. （是否返回 ModelOutput 而不是普通的 tuple）。此参数可以在 eager mode 中使用，在 graph mode 中，该值将始终设置为 True。
  • training (bool，可选，默认为 False) — Whether or not to use the model in training mode (some modules like dropout modules have different behaviors between training and evaluation). （是否在训练模式下使用模型（某些模块（如 dropout 模块）在训练和评估之间具有不同的行为））。

返回值

transformers.models.albert.modeling_tf_albert.TFAlbertForPreTrainingOutput 或 tuple(tf.Tensor)

一个 transformers.models.albert.modeling_tf_albert.TFAlbertForPreTrainingOutput 或一个 tf.Tensor 的 tuple （如果传递 return_dict=False 或当 config.return_dict=False 时），包括取决于配置 (AlbertConfig) 和输入的各种元素。

  • prediction_logits (tf.Tensor，形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。

  • 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 元组（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)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

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

尽管 forward 传递的配方需要在该函数内定义，但是应该在此之后调用 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_logits

TFAlbertForMaskedLM

class transformers.TFAlbertForMaskedLM

< >

( config: AlbertConfig *inputs **kwargs )

参数

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

带有语言建模头的 Albert 模型。

此模型继承自 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 函数一样传递输入！

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.TFMaskedLMOutput 或 tuple(tf.Tensor)

参数

  • input_ids (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。

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

    什么是输入 IDs？

  • attention_mask (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — Mask to avoid performing attention on padding token indices. （用于避免在 padding token 索引上执行 attention 的掩码）。掩码值在 [0, 1] 中选择：

    • 1 表示 tokens 未被掩盖，
    • 0 表示 tokens 已被掩盖。

    什么是 attention masks？

  • token_type_ids (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — Segment token indices to indicate first and second portions of the inputs. （分段 token 索引，以指示输入的第一个和第二个部分）。索引在 [0, 1] 中选择：

    • 0 对应于 sentence A token，
    • 1 对应于 sentence B token。

    什么是 token type IDs？

  • position_ids (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — Indices of positions of each input sequence tokens in the position embeddings. （每个输入序列 token 在位置嵌入中的位置索引）。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是 position IDs？

  • head_mask (Numpy array 或 tf.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — Mask to nullify selected heads of the self-attention modules. （用于使 self-attention 模块的选定 head 无效的掩码）。掩码值在 [0, 1] 中选择：

    • 1 表示 head 未被掩盖，
    • 0 表示 head 已被掩盖。
  • inputs_embeds (tf.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — (可选) ，您可以选择直接传递嵌入表示而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
  • output_attentions (bool，可选) — Whether or not to return the attentions tensors of all attention layers. （是否返回所有 attention 层的 attentions tensors）。 有关更多详细信息，请参见返回 tensors 下的 attentions。此参数只能在 eager mode 中使用，在 graph mode 中将使用 config 中的值。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。 详见返回张量下的 hidden_states。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是纯元组。 此参数可以在 eager 模式下使用，在 graph 模式下该值将始终设置为 True。
  • training (bool, optional, defaults to False) — 是否在训练模式下使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。
  • labels (tf.Tensor of shape (batch_size, sequence_length), optional) — 用于计算 masked language modeling loss 的标签。 索引应在 [-100, 0, ..., config.vocab_size] 中（参见 input_ids 文档字符串）。 索引设置为 -100 的 token 将被忽略（masked），loss 仅针对标签在 [0, ..., config.vocab_size] 中的 token 计算。

返回值

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 of shape (n,), optional, 当提供 labels 时返回) — Masked language modeling (MLM) loss。

  • logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言模型头的预测分数（SoftMax 之前的每个词汇 token 的分数）。

  • hidden_states (tuple(tf.Tensor)，可选，当传递了 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 元组（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)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

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

尽管 forward 传递的配方需要在该函数内定义，但是应该在此之后调用 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'
>>> labels = tokenizer("The capital of France is Paris.", return_tensors="tf")["input_ids"]
>>> labels = tf.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)
>>> outputs = model(**inputs, labels=labels)
>>> round(float(outputs.loss), 2)
0.81

TFAlbertForSequenceClassification

class transformers.TFAlbertForSequenceClassification

< >

( config: AlbertConfig *inputs **kwargs )

参数

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

带有序列分类/回归头的 Albert 模型 Transformer（池化输出顶部的线性层），例如用于 GLUE 任务。

此模型继承自 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 函数一样传递输入！

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.TFSequenceClassifierOutput 或 tuple(tf.Tensor)

参数

  • input_ids (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。

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

    什么是输入 IDs？

  • attention_mask (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length), optional) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在 [0, 1] 中选择：

    • 1 表示 token 未被 masked，
    • 0 表示 token 已被 masked。

    什么是 attention masks？

  • token_type_ids (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length), optional) — Segment token 索引，用于指示输入的第一部分和第二部分。 索引在 [0, 1] 中选择：

    • 0 对应于 sentence A token，
    • 1 对应于 sentence B token。

    什么是 token type IDs？

  • position_ids (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length), optional) — 位置嵌入中每个输入序列 token 的位置索引。 在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是 position IDs？

  • head_mask (Numpy array 或 tf.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads), optional) — 用于 nullify self-attention 模块的选定 head 的 Mask。 Mask 值在 [0, 1] 中选择：

    • 1 表示 head 未被 masked，
    • 0 表示 head 已被 masked。
  • inputs_embeds (tf.Tensor，形状为 (batch_size, sequence_length, hidden_size), optional) — （可选）您可以选择直接传递嵌入表示，而不是传递 input_ids。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
  • output_attentions (bool, optional) — 是否返回所有 attention 层的 attention 张量。 详见返回张量下的 attentions。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。 详见返回张量下的 hidden_states。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是纯元组。 此参数可以在 eager 模式下使用，在 graph 模式下该值将始终设置为 True。
  • training (bool, optional, defaults to False) — 是否在训练模式下使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。
  • labels (tf.Tensor，形状为 (batch_size,), optional) — 用于计算序列分类/回归 loss 的标签。 索引应在 [0, ..., config.num_labels - 1] 中。 如果 config.num_labels == 1，则计算回归 loss（均方 loss），如果 config.num_labels > 1，则计算分类 loss（交叉熵）。

返回值

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, ), optional, 当提供 labels 时返回) — 分类（或回归，如果 config.num_labels==1）loss。

  • 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 元组（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)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

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

尽管 forward 传递的配方需要在该函数内定义，但是应该在此之后调用 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.12

TFAlbertForMultipleChoice

class transformers.TFAlbertForMultipleChoice

< >

( config: AlbertConfig *inputs **kwargs )

参数

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

带有用于多项选择分类 head 的 Albert 模型（pooled output 之上的线性层和一个 softmax），例如用于 RocStories/SWAG 任务。

此模型继承自 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 函数一样传递输入！

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 or tuple(tf.Tensor)

参数

  • input_ids (`Numpy array` 或 `tf.Tensor`，形状为 `(batch_size, num_choices, sequence_length)`) — 词汇表中输入序列 tokens 的索引。

    索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.__call__() 和 PreTrainedTokenizer.encode()。[什么是输入 IDs？](../glossary#input-ids)

  • attention_mask (`Numpy array` 或 `tf.Tensor`，形状为 `(batch_size, num_choices, sequence_length)`，*可选*) — 用于避免在 padding token 索引上执行 attention 的掩码。掩码值在 `[0, 1]` 中选择：

    • 1 表示 tokens **未被掩盖**，
    • 0 表示 tokens **被掩盖**。

    [什么是 attention masks？](../glossary#attention-mask)

  • token_type_ids (`Numpy array` 或 `tf.Tensor`，形状为 `(batch_size, num_choices, sequence_length)`，*可选*) — Segment token 索引，用于指示输入的第一部分和第二部分。索引在 `[0, 1]` 中选择：

    • 0 对应于 *sentence A* token，
    • 1 对应于 *sentence B* token。

    [什么是 token type IDs？](../glossary#token-type-ids)

  • position_ids (`Numpy array` 或 `tf.Tensor`，形状为 `(batch_size, num_choices, sequence_length)`，*可选*) — 位置嵌入中每个输入序列 token 的位置索引。在范围 `[0, config.max_position_embeddings - 1]` 中选择。

    [什么是 position IDs？](../glossary#position-ids)

  • head_mask (`Numpy array` 或 `tf.Tensor`，形状为 `(num_heads,)` 或 `(num_layers, num_heads)`，*可选*) — 用于 nullify self-attention 模块中选定 heads 的掩码。掩码值在 `[0, 1]` 中选择：

    • 1 表示 head **未被掩盖**，
    • 0 表示 head **被掩盖**。
  • inputs_embeds (`tf.Tensor`，形状为 `(batch_size, num_choices, sequence_length, hidden_size)`，*可选*) — 可选地，您可以选择直接传递嵌入表示，而不是传递 `input_ids`。如果您想比模型的内部嵌入查找矩阵更精确地控制如何将 `input_ids` 索引转换为关联向量，这将非常有用。
  • output_attentions (`bool`，*可选*) — 是否返回所有 attention 层的 attentions tensors。有关更多详细信息，请参见返回的 tensors 下的 `attentions`。此参数只能在 eager 模式下使用，在 graph 模式下将使用 config 中的值。
  • output_hidden_states (`bool`，*可选*) — 是否返回所有层的 hidden states。有关更多详细信息，请参见返回的 tensors 下的 `hidden_states`。此参数只能在 eager 模式下使用，在 graph 模式下将使用 config 中的值。
  • return_dict (`bool`，*可选*) — 是否返回 ModelOutput 而不是 plain tuple。此参数可以在 eager 模式下使用，在 graph 模式下该值将始终设置为 True。
  • training (`bool`，*可选*，默认为 `False`) — 是否在训练模式下使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。
  • labels (`tf.Tensor`，形状为 `(batch_size,)`，*可选*) — 用于计算多项选择分类损失的标签。索引应在 `[0, ..., num_choices]` 中，其中 `num_choices` 是输入 tensors 的第二个维度的大小。（请参阅上面的 `input_ids`）

返回值

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

[transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput](/docs/transformers/v4.45.2/en/main_classes/output#transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput) 或 `tf.Tensor` 的 tuple (如果传递了 `return_dict=False` 或当 `config.return_dict=False` 时)，包含各种元素，具体取决于配置 ([AlbertConfig](/docs/transformers/v4.45.2/en/model_doc/albert#transformers.AlbertConfig)) 和输入。

  • loss (`tf.Tensor`，形状为 `(batch_size, )`，*可选*，当提供 `labels` 时返回) — 分类损失。

  • logits (`tf.Tensor`，形状为 `(batch_size, num_choices)`) — *num_choices* 是输入 tensors 的第二个维度。（请参阅上面的 `input_ids`）。

    分类得分（SoftMax 之前）。

  • hidden_states (tuple(tf.Tensor)，可选，当传递了 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 元组（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)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

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

尽管 forward 传递的配方需要在该函数内定义，但是应该在此之后调用 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.logits

TFAlbertForTokenClassification

class transformers.TFAlbertForTokenClassification

< >

( config: AlbertConfig *inputs **kwargs )

参数

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

带有 token 分类头的 Albert 模型（位于 hidden-states 输出顶部的线性层），例如用于命名实体识别 (NER) 任务。

此模型继承自 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 函数一样传递输入！

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.TFTokenClassifierOutput or tuple(tf.Tensor)

参数

  • input_ids (`Numpy array` 或 `tf.Tensor`，形状为 `(batch_size, sequence_length)`) — 词汇表中输入序列 tokens 的索引。

    索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.__call__() 和 PreTrainedTokenizer.encode()。[什么是输入 IDs？](../glossary#input-ids)

  • attention_mask (`Numpy array` 或 `tf.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*) — 用于避免在 padding token 索引上执行 attention 的掩码。掩码值在 `[0, 1]` 中选择：

    • 1 表示 tokens **未被掩盖**，
    • 0 表示 tokens **被掩盖**。

    [什么是 attention masks？](../glossary#attention-mask)

  • token_type_ids (`Numpy array` 或 `tf.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*) — Segment token 索引，用于指示输入的第一部分和第二部分。索引在 `[0, 1]` 中选择：

    • 0 对应于 *sentence A* token，
    • 1 对应于 *sentence B* token。

    [什么是 token type IDs？](../glossary#token-type-ids)

  • position_ids (`Numpy array` 或 `tf.Tensor`，形状为 `(batch_size, sequence_length)`) — 位置嵌入中每个输入序列 token 的位置索引。在范围 `[0, config.max_position_embeddings - 1]` 中选择。

    [什么是 position IDs？](../glossary#position-ids)

  • 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。此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的 hidden_states。此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是纯元组。 此参数可以在 eager 模式下使用，在 graph 模式下，该值将始终设置为 True。
  • training (bool，可选，默认为 False) — 是否在训练模式下使用模型（dropout 模块等某些模块在训练和评估之间具有不同的行为）。
  • labels (tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于计算 token 分类损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。

返回值

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

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

  • loss (tf.Tensor，形状为 (n,)，可选，当提供 labels 时返回，其中 n 是未屏蔽标签的数量) — 分类损失。

  • logits (tf.Tensor，形状为 (batch_size, sequence_length, config.num_labels)) — 分类得分（SoftMax 之前）。

  • hidden_states (tuple(tf.Tensor)，可选，当传递了 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 元组（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)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

TFAlbertForTokenClassification 前向传播方法，覆盖了 __call__ 特殊方法。

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

示例

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

>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-base-v2")
>>> model = TFAlbertForTokenClassification.from_pretrained("albert/albert-base-v2")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="tf"
... )

>>> logits = model(**inputs).logits
>>> predicted_token_class_ids = tf.math.argmax(logits, axis=-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] for t in predicted_token_class_ids[0].numpy().tolist()]
>>> labels = predicted_token_class_ids
>>> loss = tf.math.reduce_mean(model(**inputs, labels=labels).loss)

TFAlbertForQuestionAnswering

class transformers.TFAlbertForQuestionAnswering

< >

( config: AlbertConfig *inputs **kwargs )

参数

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

带有跨度分类头的 Albert 模型，用于执行抽取式问答任务，如 SQuAD（在隐藏状态输出之上添加一个线性层，以计算 span start logits 和 span end logits）。

此模型继承自 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 函数一样传递输入！

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

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

    什么是输入 ID？

  • attention_mask (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行注意力的掩码。 掩码值在 [0, 1] 中选择：

    • 1 表示 tokens 不被屏蔽，
    • 0 表示 tokens 被屏蔽。

    什么是注意力掩码？

  • token_type_ids (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 分段 token 索引，用于指示输入的第一部分和第二部分。 索引在 [0, 1] 中选择：

    • 0 对应于 句子 A token，
    • 1 对应于 句子 B token。

    什么是 token 类型 ID？

  • position_ids (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 token 的位置索引。 在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 ID？

  • 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。此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的 hidden_states。此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是纯元组。 此参数可以在 eager 模式下使用，在 graph 模式下，该值将始终设置为 True。
  • training (bool，可选，默认为 False) — 是否在训练模式下使用模型（dropout 模块等某些模块在训练和评估之间具有不同的行为）。
  • start_positions (tf.Tensor，形状为 (batch_size,)，可选) — 用于计算 token 分类损失的标签跨度起始位置（索引）。位置被限制在序列的长度 (sequence_length) 内。序列之外的位置不被考虑用于计算损失。
  • end_positions (tf.Tensor，形状为 (batch_size,)，可选) — 用于计算 token 分类损失的标签跨度结束位置（索引）。位置被限制在序列的长度 (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 元组（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)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

TFAlbertForQuestionAnswering 前向传播方法，覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数内定义，但是应该在此之后调用 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'
>>> # target is "nice puppet"
>>> target_start_index = tf.constant([12])
>>> target_end_index = tf.constant([13])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = tf.math.reduce_mean(outputs.loss)
>>> round(float(loss), 2)
7.36
JAX
隐藏 JAX 内容

FlaxAlbertModel

class transformers.FlaxAlbertModel

< >

( 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。

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

裸 Albert 模型转换器，输出原始隐藏状态，顶部没有任何特定的 head。

此模型继承自 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 (形状为 (batch_size, sequence_length) 的 numpy.ndarray) — 输入序列 token 在词汇表中的索引。

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

    什么是输入 IDs？

  • attention_mask (形状为 (batch_size, sequence_length) 的 numpy.ndarray，可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。Mask 值在 [0, 1] 中选择：

    • 1 表示 未被 Mask 的 token，
    • 0 表示 被 Mask 的 token。

    什么是 attention masks？

  • token_type_ids (形状为 (batch_size, sequence_length) 的 numpy.ndarray，可选) — Segment token 索引，用于指示输入的第一部分和第二部分。 索引在 [0, 1] 中选择：

    • 0 对应于 sentence A token，
    • 1 对应于 sentence B token。

    什么是 token type IDs？

  • position_ids (形状为 (batch_size, sequence_length) 的 numpy.ndarray，可选) — 位置嵌入中每个输入序列 token 的位置索引。在范围 [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 (形状为 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray) — 模型最后一层的输出处的隐藏状态序列。

  • pooler_output (形状为 (batch_size, hidden_size) 的 jnp.ndarray) — 序列的第一个 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)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

FlaxAlbertPreTrainedModel 前向传播方法，覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数内定义，但是应该在此之后调用 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_state

FlaxAlbertForPreTraining

class transformers.FlaxAlbertForPreTraining

< >

( 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。

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

带有两个 head 的 Albert 模型，如同在预训练期间所做的那样：一个 masked language modeling head 和一个 sentence order prediction (classification) head。

此模型继承自 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.models.albert.modeling_flax_albert.FlaxAlbertForPreTrainingOutput 或 tuple(torch.FloatTensor)

参数

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

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

    什么是输入 IDs？

  • attention_mask (形状为 (batch_size, sequence_length) 的 numpy.ndarray，可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。Mask 值在 [0, 1] 中选择：

    • 1 表示 未被 Mask 的 token，
    • 0 表示 被 Mask 的 token。

    什么是 attention masks？

  • token_type_ids (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) — 分段 token 索引，用于指示输入的第一个和第二个部分。索引从 [0, 1] 中选择：

    • 0 对应于 句子 A token，
    • 1 对应于 句子 B token。

    什么是 token 类型 ID？

  • position_ids (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 token 的位置索引。在范围 [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 之前每个词汇 token 的得分）。

  • 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)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

FlaxAlbertPreTrainedModel 前向传播方法，覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数内定义，但是应该在此之后调用 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_logits

FlaxAlbertForMaskedLM

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。

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

带有语言建模头的 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)) — 词汇表中输入序列 token 的索引。

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

    什么是输入 ID？

  • attention_mask (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。Mask 值在 [0, 1] 中选择：

    • 1 表示 未被 Mask 的 token，
    • 0 表示 已被 Mask 的 token。

    什么是 attention mask？

  • token_type_ids (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) — 分段 token 索引，用于指示输入的第一个和第二个部分。索引从 [0, 1] 中选择：

    • 0 对应于 句子 A token，
    • 1 对应于 句子 B token。

    什么是 token 类型 ID？

  • position_ids (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 token 的位置索引。在范围 [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 之前每个词汇 token 的得分）。

  • 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)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

FlaxAlbertPreTrainedModel 前向传播方法，覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数内定义，但是应该在此之后调用 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.logits

FlaxAlbertForSequenceClassification

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。

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

带有序列分类/回归头的 Albert 模型 Transformer（池化输出顶部的线性层），例如用于 GLUE 任务。

此模型继承自 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.FlaxSequenceClassifierOutput 或 tuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID？

  • attention_mask (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。Mask 值在 [0, 1] 中选择：

    • 1 表示 未被 Mask 的 token，
    • 0 表示 已被 Mask 的 token。

    什么是 attention mask？

  • token_type_ids (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) — 分段 token 索引，用于指示输入的第一个和第二个部分。索引从 [0, 1] 中选择：

    • 0 对应于 句子 A token，
    • 1 对应于 句子 B token。

    什么是 token 类型 ID？

  • position_ids (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 token 的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

返回值

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

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

  • logits (jnp.ndarray，形状为 (batch_size, config.num_labels)) — 分类（如果 config.num_labels==1 则为回归）得分（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)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

FlaxAlbertPreTrainedModel 前向传播方法，覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数内定义，但是应该在此之后调用 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.logits

FlaxAlbertForMultipleChoice

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) — Model configuration class with all the parameters of the model. Initializing with a config file does not load the weights associated with the model, only the configuration. Check out the from_pretrained() method to load the model weights.
  • dtype (jax.numpy.dtype, optional, defaults to jax.numpy.float32) — The data type of the computation. Can be one of jax.numpy.float32, jax.numpy.float16 (on GPUs) and jax.numpy.bfloat16 (on TPUs).

    This can be used to enable mixed-precision training or half-precision inference on GPUs or TPUs. If specified all the computation will be performed with the given dtype.

    Note that this only specifies the dtype of the computation and does not influence the dtype of model parameters.

    If you wish to change the dtype of the model parameters, see to_fp16() and to_bf16().

带有用于多项选择分类 head 的 Albert 模型（pooled output 之上的线性层和一个 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 or tuple(torch.FloatTensor)

参数

  • input_ids (numpy.ndarray of shape (batch_size, num_choices, sequence_length)) — Indices of input sequence tokens in the vocabulary.

    Indices can be obtained using AutoTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details.

    What are input IDs?

  • attention_mask (numpy.ndarray of shape (batch_size, num_choices, sequence_length), optional) — Mask to avoid performing attention on padding token indices. Mask values selected in [0, 1]:

    • 1 for tokens that are not masked,
    • 0 for tokens that are masked.

    What are attention masks?

  • token_type_ids (numpy.ndarray of shape (batch_size, num_choices, sequence_length), optional) — Segment token indices to indicate first and second portions of the inputs. Indices are selected in [0, 1]:

    • 0 corresponds to a sentence A token,
    • 1 corresponds to a sentence B token.

    What are token type IDs?

  • position_ids (numpy.ndarray of shape (batch_size, num_choices, sequence_length), optional) — Indices of positions of each input sequence tokens in the position embeddings. Selected in the range [0, config.max_position_embeddings - 1].
  • return_dict (bool, optional) — Whether or not to return a ModelOutput instead of a plain tuple.

返回值

transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput or tuple(torch.FloatTensor)

A transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput or a tuple of torch.FloatTensor (if return_dict=False is passed or when config.return_dict=False) comprising various elements depending on the configuration (AlbertConfig) and inputs.

  • logits (jnp.ndarray of shape (batch_size, num_choices)) — num_choices is the second dimension of the input tensors. (see input_ids above).

    分类得分（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)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

FlaxAlbertPreTrainedModel 前向传播方法，覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数内定义，但是应该在此之后调用 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.logits

FlaxAlbertForTokenClassification

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) — Model configuration class with all the parameters of the model. Initializing with a config file does not load the weights associated with the model, only the configuration. Check out the from_pretrained() method to load the model weights.
  • dtype (jax.numpy.dtype, optional, defaults to jax.numpy.float32) — The data type of the computation. Can be one of jax.numpy.float32, jax.numpy.float16 (on GPUs) and jax.numpy.bfloat16 (on TPUs).

    This can be used to enable mixed-precision training or half-precision inference on GPUs or TPUs. If specified all the computation will be performed with the given dtype.

    Note that this only specifies the dtype of the computation and does not influence the dtype of model parameters.

    If you wish to change the dtype of the model parameters, see to_fp16() and to_bf16().

带有 token 分类头的 Albert 模型（位于 hidden-states 输出顶部的线性层），例如用于命名实体识别 (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 or tuple(torch.FloatTensor)

参数

  • input_ids (numpy.ndarray of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary.

    Indices can be obtained using AutoTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details.

    What are input IDs?

  • attention_mask (numpy.ndarray of shape (batch_size, sequence_length), optional) — Mask to avoid performing attention on padding token indices. Mask values selected in [0, 1]:

    • 1 for tokens that are not masked,
    • 0 for tokens that are masked.

    What are attention masks?

  • token_type_ids (numpy.ndarray of shape (batch_size, sequence_length), optional) — Segment token indices to indicate first and second portions of the inputs. Indices are selected in [0, 1]:

    • 0 corresponds to a sentence A token,
    • 1 corresponds to a sentence B token.

    What are token type IDs?

  • position_ids (numpy.ndarray of shape (batch_size, sequence_length), optional) — Indices of positions of each input sequence tokens in the position embeddings. Selected in the range [0, config.max_position_embeddings - 1].
  • return_dict (bool, optional) — Whether or not to return a ModelOutput instead of a plain tuple.

返回值

transformers.modeling_flax_outputs.FlaxTokenClassifierOutput or tuple(torch.FloatTensor)

A transformers.modeling_flax_outputs.FlaxTokenClassifierOutput or a tuple of torch.FloatTensor (if return_dict=False is passed or when config.return_dict=False) comprising various elements depending on the configuration (AlbertConfig) and inputs.

  • logits (jnp.ndarray of shape (batch_size, sequence_length, config.num_labels)) — Classification scores (before 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)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

FlaxAlbertPreTrainedModel 前向传播方法，覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数内定义，但是应该在此之后调用 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.logits

FlaxAlbertForQuestionAnswering

class transformers.FlaxAlbertForQuestionAnswering

< >

( 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。

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

带有 span 分类头的 Albert 模型，用于抽取式问答任务，如 SQuAD（位于 hidden-states 输出顶部的线性层，用于计算 span start logits 和 span end logits）。

此模型继承自 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.FlaxQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

参数

  • input_ids (numpy.ndarray，形状为 (batch_size, sequence_length)) — 输入序列 tokens 在词汇表中的索引。

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

    什么是输入 IDs？

  • attention_mask (numpy.ndarray，形状为 (batch_size, sequence_length), 可选) — 用于避免在 padding token 索引上执行 attention 的掩码。 Mask 值在 [0, 1] 中选择：

    • 1 表示 未被掩盖 的 tokens，
    • 0 表示 被掩盖 的 tokens。

    什么是 attention masks？

  • token_type_ids (numpy.ndarray，形状为 (batch_size, sequence_length), 可选) — Segment token 索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：

    • 0 对应于 句子 A token，
    • 1 对应于 句子 B token。

    什么是 token type IDs？

  • position_ids (numpy.ndarray，形状为 (batch_size, sequence_length), 可选) — 每个输入序列 token 在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是纯粹的 tuple。

返回值

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

一个 transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput 或一个 torch.FloatTensor 的 tuple (如果传递了 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)。

    attention softmax 之后的 Attentions 权重，用于计算自注意力 head 中的加权平均值。

FlaxAlbertPreTrainedModel 前向传播方法，覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数内定义，但是应该在此之后调用 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
< > 在 GitHub 上更新

←图像处理器 BART→