Hugging Face's logo

Transformers 文档

ModernBERT

Hugging Face's logo
加入 Hugging Face 社区

并获取增强的文档体验

开始使用

ModernBERT

PyTorch FlashAttention SDPA

概述

ModernBERT 模型由 Benjamin Warner、Antoine Chaffin、Benjamin Clavié、Orion Weller、Oskar Hallström、Said Taghadouini、Alexis Galalgher、Raja Bisas、Faisal Ladhak、Tom Aarsen、Nathan Cooper、Grifin Adams、Jeremy Howard 和 Iacopo Poli 在 Smarter, Better, Faster, Longer: A Modern Bidirectional Encoder for Fast, Memory Efficient, and Long Context Finetuning and Inference 中提出。

它是传统编码器架构的升级，如同之前的模型 BERT 和 RoBERTa 中使用的那样。

它基于 BERT 构建，并实现了自其最初发布以来开发的许多现代架构改进，例如

  • 旋转位置嵌入，以支持最多 8192 个 token 的序列。
  • Unpadding，以确保不会在填充 token 上浪费计算资源，从而加快混合长度序列批次的处理时间。
  • GeGLU 用 GeGLU 层替换原始 MLP 层，经验证可以提高性能。
  • 交替注意力，其中大多数注意力层采用 128 个 token 的滑动窗口，而全局注意力仅每 3 层使用一次。
  • Flash Attention，以加速处理。
  • 该模型的设计遵循最新的 The Case for Co-Designing Model Architectures with Hardware，确保在推理 GPU 上实现最大效率。
  • 现代训练数据规模（2 万亿 token）和混合（包括代码和数学数据）

该论文的摘要如下

仅编码器 Transformer 模型（如 BERT）相对于更大的仅解码器模型，在检索和分类任务中提供了出色的性能与规模的权衡。尽管 BERT 是众多生产管道的主力，但自其发布以来，对 BERT 的帕累托改进有限。在本文中，我们介绍了 ModernBERT，将现代模型优化引入到仅编码器模型中，代表了相对于旧编码器的重大帕累托改进。ModernBERT 模型在 2 万亿 token 上进行训练，原生序列长度为 8192，在包含各种分类任务以及不同领域（包括代码）的单向量和多向量检索的大量评估中，表现出最先进的结果。除了强大的下游性能外，ModernBERT 也是速度和内存效率最高的编码器，专为在常见 GPU 上进行推理而设计。

原始代码可以在这里找到。

资源

Hugging Face 官方和社区（🌎 表示）资源的列表，可帮助您开始使用 ModernBert。

文本分类
句子相似度
填充掩码

ModernBertConfig

class transformers.ModernBertConfig

< >

( vocab_size = 50368 hidden_size = 768 intermediate_size = 1152 num_hidden_layers = 22 num_attention_heads = 12 hidden_activation = 'gelu' max_position_embeddings = 8192 initializer_range = 0.02 initializer_cutoff_factor = 2.0 norm_eps = 1e-05 norm_bias = False pad_token_id = 50283 eos_token_id = 50282 bos_token_id = 50281 cls_token_id = 50281 sep_token_id = 50282 global_rope_theta = 160000.0 attention_bias = False attention_dropout = 0.0 global_attn_every_n_layers = 3 local_attention = 128 local_rope_theta = 10000.0 embedding_dropout = 0.0 mlp_bias = False mlp_dropout = 0.0 decoder_bias = True classifier_pooling: typing.Literal['cls', 'mean'] = 'cls' classifier_dropout = 0.0 classifier_bias = False classifier_activation = 'gelu' deterministic_flash_attn = False sparse_prediction = False sparse_pred_ignore_index = -100 reference_compile = None repad_logits_with_grad = False **kwargs )

参数

  • vocab_size (int, 可选的, 默认为 50368) — ModernBert 模型的词汇表大小。定义了在调用 ModernBertModel 时传递的 inputs_ids 可以表示的不同 token 的数量。
  • hidden_size (int, 可选的, 默认为 768) — 隐藏层表示的维度。
  • intermediate_size (int, 可选的, 默认为 1152) — MLP 表示的维度。
  • num_hidden_layers (int, 可选的, 默认为 22) — Transformer 解码器中的隐藏层数。
  • num_attention_heads (int, 可选的, 默认为 12) — Transformer 解码器中每个注意力层的注意力头数。
  • hidden_activation (str 或 function, 可选的, 默认为 "gelu") — 解码器中的非线性激活函数（函数或字符串）。如果未指定，则默认为 "gelu"。
  • max_position_embeddings (int, 可选的, 默认为 8192) — 此模型可能使用的最大序列长度。
  • initializer_range (float, 可选的, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • initializer_cutoff_factor (float, 可选的, 默认为 2.0) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的截断因子。
  • norm_eps (float, 可选的, 默认为 1e-05) — rms 归一化层使用的 epsilon 值。
  • norm_bias (bool, 可选的, 默认为 False) — 是否在归一化层中使用偏置。
  • pad_token_id (int, 可选的, 默认为 50283) — 填充 token id。
  • eos_token_id (int, 可选的, 默认为 50282) — 流结束 token id。
  • bos_token_id (int, 可选的, 默认为 50281) — 流开始 token id。
  • cls_token_id (int, 可选的, 默认为 50281) — 分类 token id。
  • sep_token_id (int, 可选的, 默认为 50282) — 分隔 token id。
  • global_rope_theta (float, 可选的, 默认为 160000.0) — 全局 RoPE 嵌入的基准周期。
  • attention_bias (bool, 可选的, 默认为 False) — 是否在自注意力期间在查询、键、值和输出投影层中使用偏置。
  • attention_dropout (float, 可选的, 默认为 0.0) — 注意力概率的 dropout 比率。
  • global_attn_every_n_layers (int, 可选的, 默认为 3) — 全局注意力层之间的层数。
  • local_attention (int, 可选的, 默认为 128) — 局部注意力的窗口大小。
  • local_rope_theta (float, 可选, 默认为 10000.0) — 本地 RoPE 嵌入的基期。
  • embedding_dropout (float, 可选, 默认为 0.0) — 嵌入层的 dropout 比率。
  • mlp_bias (bool, 可选, 默认为 False) — 是否在 MLP 层中使用偏置。
  • mlp_dropout (float, 可选, 默认为 0.0) — MLP 层的 dropout 比率。
  • decoder_bias (bool, 可选, 默认为 True) — 是否在解码器层中使用偏置。
  • classifier_pooling (str, 可选, 默认为 "cls") — 分类器的池化方法。应为 "cls" 或 "mean" 之一。在本地注意力层中，CLS token 不会关注长序列上的所有 token。
  • classifier_dropout (float, 可选, 默认为 0.0) — 分类器的 dropout 比率。
  • classifier_bias (bool, 可选, 默认为 False) — 是否在分类器中使用偏置。
  • classifier_activation (str, 可选, 默认为 "gelu") — 分类器的激活函数。
  • deterministic_flash_attn (bool, 可选, 默认为 False) — 是否使用确定性 flash attention。如果为 False，则推理会更快，但不是确定性的。
  • sparse_prediction (bool, 可选, 默认为 False) — 是否为掩码语言模型使用稀疏预测，而不是返回完整的密集 logits。
  • sparse_pred_ignore_index (int, 可选, 默认为 -100) — 用于稀疏预测的忽略索引。
  • reference_compile (bool, 可选) — 是否编译在预训练期间编译的模型层。如果为 None，则如果满足以下条件，将编译模型的部分：1) 安装了 triton，2) 模型不在 MPS 上，3) 模型不在设备之间共享，以及 4) 模型在初始化后未调整大小。如果为 True，则在某些情况下模型可能会更快。
  • repad_logits_with_grad (bool, 可选, 默认为 False) — 当为 True 时，ModernBertForMaskedLM 在为输出重新填充时会跟踪 logits 的梯度。这仅在使用带有传递标签的 Flash Attention 2 时适用。否则，输出 logits 始终具有梯度。

这是用于存储 ModernBertModel 配置的配置类。它用于根据指定的参数实例化 ModernBert 模型，定义模型架构。使用默认值实例化配置将产生与 ModernBERT-base 类似的配置。例如 answerdotai/ModernBERT-base

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

示例

>>> from transformers import ModernBertModel, ModernBertConfig

>>> # Initializing a ModernBert style configuration
>>> configuration = ModernBertConfig()

>>> # Initializing a model from the modernbert-base style configuration
>>> model = ModernBertModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
Pytorch
隐藏 Pytorch 内容

ModernBertModel

class transformers.ModernBertModel

< >

( config: ModernBertConfig )

参数

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

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

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None sliding_window_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None indices: typing.Optional[torch.Tensor] = None cu_seqlens: typing.Optional[torch.Tensor] = None max_seqlen: typing.Optional[int] = None batch_size: typing.Optional[int] = None seq_len: typing.Optional[int] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID？

  • attention_mask (torch.Tensor，形状为 (batch_size, sequence_length), 可选) — 掩码，以避免对填充 token 索引执行 attention。掩码值在 [0, 1] 中选择：

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

    什么是 attention 掩码？

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

    如果您想更改填充行为，则应阅读 modeling_opt._prepare_decoder_attention_mask 并根据您的需要进行修改。有关默认策略的更多信息，请参见 论文 中的图 1。

    • 1 表示 head 未被掩码，
    • 0 表示 head 已被掩码。
  • sliding_window_mask (torch.Tensor，形状为 (batch_size, sequence_length), 可选) — 掩码，以避免对填充或远距离 token 执行 attention。在 ModernBert 中，只有少数层执行全局 attention，而其余层执行本地 attention。当不使用 Flash Attention 时，此掩码用于避免关注本地 attention 层中的远距离 token。
  • position_ids (torch.LongTensor，形状为 (batch_size, sequence_length), 可选) — 每个输入序列 token 在位置嵌入中的位置索引。在范围 [0, config.n_positions - 1] 中选择。

    什么是位置 ID？

  • inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
  • indices (torch.Tensor，形状为 (total_unpadded_tokens,), 可选) — 输入序列中非填充 token 的索引。用于解填充输出。
  • cu_seqlens (torch.Tensor，形状为 (batch + 1,), 可选) — 输入序列的累积序列长度。用于索引未填充的张量。
  • max_seqlen (int, 可选) — 批次中不包括填充标记的最大序列长度。用于解填充 input_ids 和填充输出张量。
  • batch_size (int, 可选) — 输入序列的批次大小。用于填充输出张量。
  • seq_len (int, 可选) — 输入序列的序列长度，包括填充标记。用于填充输出张量。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

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

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

  • last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。

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

    模型在每层输出处的隐藏状态，加上可选的初始嵌入输出。

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

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

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

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

示例

>>> from transformers import AutoTokenizer, ModernBertModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("answerdotai/ModernBERT-base")
>>> model = ModernBertModel.from_pretrained("answerdotai/ModernBERT-base")

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

>>> last_hidden_states = outputs.last_hidden_state

ModernBertForMaskedLM

class transformers.ModernBertForMaskedLM

< >

( config: ModernBertConfig )

参数

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

带有解码器头的 ModernBert 模型，用于掩码语言建模。 此模型继承自 PreTrainedModel。 查看超类文档，了解库为其所有模型实现的通用方法（例如，下载或保存、调整输入嵌入大小、剪枝头等）。

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None sliding_window_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None indices: typing.Optional[torch.Tensor] = None cu_seqlens: typing.Optional[torch.Tensor] = None max_seqlen: typing.Optional[int] = None batch_size: typing.Optional[int] = None seq_len: typing.Optional[int] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID？

  • attention_mask (torch.Tensor，形状为 (batch_size, sequence_length), 可选) — 掩码，以避免对填充标记索引执行注意力机制。 在 [0, 1] 中选择的掩码值：

    • 1 表示未被掩码的标记，
    • 0 表示已被掩码的标记。

    什么是注意力掩码？

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

    如果您想更改填充行为，则应阅读 modeling_opt._prepare_decoder_attention_mask 并根据您的需要进行修改。 有关默认策略的更多信息，请参见 论文 中的图 1。

    • 1 表示头部未被掩码，
    • 0 表示头部已被掩码。
  • sliding_window_mask (torch.Tensor，形状为 (batch_size, sequence_length), 可选) — 掩码，用于避免对填充标记或远处标记执行注意力机制。 在 ModernBert 中，只有少数几层执行全局注意力，而其余层执行局部注意力。 当不使用 Flash Attention 时，此掩码用于避免在局部注意力层中关注远处标记。
  • position_ids (torch.LongTensor，形状为 (batch_size, sequence_length), 可选) — 每个输入序列标记在位置嵌入中的位置索引。 在范围 [0, config.n_positions - 1] 中选择。

    什么是位置 ID？

  • inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。 如果您希望比模型的内部嵌入查找矩阵更精确地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
  • indices (torch.Tensor，形状为 (total_unpadded_tokens,), 可选) — 输入序列中非填充标记的索引。 用于解填充输出。
  • cu_seqlens (torch.Tensor，形状为 (batch + 1,), 可选) — 输入序列的累积序列长度。 用于索引解填充张量。
  • max_seqlen (int, 可选) — 批次中不包括填充标记的最大序列长度。用于解填充 input_ids 和填充输出张量。
  • batch_size (int, 可选) — 输入序列的批次大小。用于填充输出张量。
  • seq_len (int, 可选) — 输入序列的序列长度，包括填充标记。用于填充输出张量。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

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

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

  • 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 元组 (每个层的输出一个，如果模型具有嵌入层，则再加上嵌入层的输出，形状为 (batch_size, sequence_length, hidden_size))。

    模型在每层输出处的隐藏状态，加上可选的初始嵌入输出。

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

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

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

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

示例

>>> from transformers import AutoTokenizer, ModernBertForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("answerdotai/ModernBERT-base")
>>> model = ModernBertForMaskedLM.from_pretrained("answerdotai/ModernBERT-base")

>>> inputs = tokenizer("The capital of France is [MASK].", 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)

>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-[MASK] tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

>>> outputs = model(**inputs, labels=labels)

ModernBertForSequenceClassification

class transformers.ModernBertForSequenceClassification

< >

( config: ModernBertConfig )

参数

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

ModernBert 模型，顶部带有一个执行池化的序列分类头。此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None sliding_window_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None indices: typing.Optional[torch.Tensor] = None cu_seqlens: typing.Optional[torch.Tensor] = None max_seqlen: typing.Optional[int] = None batch_size: typing.Optional[int] = None seq_len: typing.Optional[int] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

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

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

    什么是输入 IDs？

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

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

    什么是 attention 掩码？

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

    如果您想更改填充行为，您应该阅读 modeling_opt._prepare_decoder_attention_mask 并根据您的需要进行修改。 有关默认策略的更多信息，请参见 论文 中的图 1。

    • 1 表示 head 未被掩盖，
    • 0 表示 head 被掩盖。
  • sliding_window_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 掩码，用于避免在填充或远处 tokens 上执行 attention。在 ModernBert 中，只有少数几层执行全局 attention，而其余层执行局部 attention。当不使用 Flash Attention 时，此掩码用于避免在局部 attention 层中关注远处 tokens。
  • position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 tokens 的位置索引。在范围 [0, config.n_positions - 1] 中选择。

    什么是位置 IDs？

  • inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更灵活地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
  • indices (torch.Tensor，形状为 (total_unpadded_tokens,)，可选) — 输入序列中非填充 tokens 的索引。用于解填充输出。
  • cu_seqlens (torch.Tensor，形状为 (batch + 1,)，可选) — 输入序列的累积序列长度。用于索引未填充的张量。
  • max_seqlen (int，可选) — 批次中不包括填充 tokens 的最大序列长度。用于解填充 input_ids 和填充输出张量。
  • batch_size (int，可选) — 输入序列的批次大小。用于填充输出张量。
  • seq_len (int，可选) — 输入序列的序列长度，包括填充 tokens。用于填充输出张量。
  • output_attentions (bool，可选) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
  • labels (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。

返回

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

一个 transformers.modeling_outputs.SequenceClassifierOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包括各种元素，具体取决于配置 (ModernBertConfig) 和输入。

  • loss (torch.FloatTensor，形状为 (1,)，可选，当提供 labels 时返回) — 分类（或回归，如果 config.num_labels==1）损失。

  • logits (torch.FloatTensor，形状为 (batch_size, config.num_labels)) — 分类（或回归，如果 config.num_labels==1）得分（在 SoftMax 之前）。

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

    模型在每层输出处的隐藏状态，加上可选的初始嵌入输出。

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

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

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

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

单标签分类示例

>>> import torch
>>> from transformers import AutoTokenizer, ModernBertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("answerdotai/ModernBERT-base")
>>> model = ModernBertForSequenceClassification.from_pretrained("answerdotai/ModernBERT-base")

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

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = ModernBertForSequenceClassification.from_pretrained("answerdotai/ModernBERT-base", num_labels=num_labels)

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

多标签分类示例

>>> import torch
>>> from transformers import AutoTokenizer, ModernBertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("answerdotai/ModernBERT-base")
>>> model = ModernBertForSequenceClassification.from_pretrained("answerdotai/ModernBERT-base", 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 = ModernBertForSequenceClassification.from_pretrained(
...     "answerdotai/ModernBERT-base", 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

ModernBertForTokenClassification

class transformers.ModernBertForTokenClassification

< >

( config: ModernBertConfig )

参数

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

ModernBert 模型，顶部带有一个 token 分类头，例如用于命名实体识别 (NER) 任务。此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None sliding_window_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None indices: typing.Optional[torch.Tensor] = None cu_seqlens: typing.Optional[torch.Tensor] = None max_seqlen: typing.Optional[int] = None batch_size: typing.Optional[int] = None seq_len: typing.Optional[int] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)

参数

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

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

    什么是输入 IDs？

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

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

    什么是 attention masks？

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

    如果您想更改 padding 行为，您应该阅读 modeling_opt._prepare_decoder_attention_mask 并根据您的需要进行修改。 有关默认策略的更多信息，请参见 论文 中的图 1。

    • 1 表示 head 未被掩码，
    • 0 表示 head 已被掩码。
  • sliding_window_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免对 padding 或距离较远的 token 执行 attention 的掩码。 在 ModernBert 中，只有少数几层执行全局 attention，而其余层执行局部 attention。 当不使用 Flash Attention 时，此掩码用于避免在局部 attention 层中关注距离较远的 token。
  • position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 token 的位置索引。 在范围 [0, config.n_positions - 1] 中选择。

    什么是 position IDs？

  • inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
  • indices (torch.Tensor，形状为 (total_unpadded_tokens,)，可选) — 输入序列中非 padding token 的索引。 用于 unpadding 输出。
  • cu_seqlens (torch.Tensor，形状为 (batch + 1,)，可选) — 输入序列的累积序列长度。 用于索引 unpadded tensors。
  • max_seqlen (int，可选) — 批次中不包括 padding token 的最大序列长度。 用于 unpad input_ids 和 pad 输出 tensors。
  • batch_size (int，可选) — 输入序列的批次大小。 用于 pad 输出 tensors。
  • seq_len (int，可选) — 输入序列的序列长度，包括 padding token。 用于 pad 输出 tensors。
  • 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, 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 时），包括各种元素，具体取决于配置 (ModernBertConfig) 和输入。

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

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

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

    模型在每层输出处的隐藏状态，加上可选的初始嵌入输出。

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

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

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

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

示例

>>> from transformers import AutoTokenizer, ModernBertForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("answerdotai/ModernBERT-base")
>>> model = ModernBertForTokenClassification.from_pretrained("answerdotai/ModernBERT-base")

>>> 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
< > 在 GitHub 上更新

←MobileBERT MPNet→