Transformers 文档

ModernBERT

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

PyTorch FlashAttention SDPA

ModernBERT

ModernBERTBERT 的现代化版本,在 2T 词元上进行了训练。它为原始架构带来了许多改进,例如旋转位置嵌入以支持长达 8192 个词元的序列、unpadding 以避免在填充词元上浪费计算资源、GeGLU 层和交替注意力机制。

你可以在 ModernBERT 合集中找到所有原始的 ModernBERT 检查点。

点击右侧边栏中的 ModernBERT 模型,查看更多关于如何将 ModernBERT 应用于不同语言任务的示例。

下面的示例演示了如何使用 PipelineAutoModel 以及从命令行预测 [MASK] 词元。

流水线
自动模型
Transformers CLI
import torch
from transformers import pipeline

pipeline = pipeline(
    task="fill-mask",
    model="answerdotai/ModernBERT-base",
    torch_dtype=torch.float16,
    device=0
)
pipeline("Plants create [MASK] through a process known as photosynthesis.")

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 可以表示的不同词元的数量。
  • hidden_size (int, 可选, 默认为 768) — 隐藏表示的维度。
  • intermediate_size (int, 可选, 默认为 1152) — MLP 表示的维度。
  • num_hidden_layers (int, 可选, 默认为 22) — Transformer 解码器中的隐藏层数量。
  • num_attention_heads (int, 可选, 默认为 12) — Transformer 解码器中每个注意力层的注意力头数量。
  • hidden_activation (strfunction, 可选, 默认为 "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) — 填充词元的 ID。
  • eos_token_id (int, 可选, 默认为 50282) — 序列结束词元的 ID。
  • bos_token_id (int, 可选, 默认为 50281) — 序列开始词元的 ID。
  • cls_token_id (int, 可选, 默认为 50281) — 分类词元的 ID。
  • sep_token_id (int, 可选, 默认为 50282) — 分隔词元的 ID。
  • global_rope_theta (float, 可选, 默认为 160000.0) — 全局 RoPE 嵌入的基期。
  • attention_bias (bool, 可选, 默认为 False) — 是否在自注意力机制的 query、key、value 和输出投影层中使用偏置。
  • 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 词元在长序列中不关注所有词元。
  • 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 模型,输出原始的隐藏状态,顶部没有任何特定的模型头。

该模型继承自 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.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.BaseModelOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 词汇表中输入序列词元的索引。默认情况下将忽略填充。

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

    什么是输入 ID?

  • attention_mask (torch.Tensor,形状为 (batch_size, sequence_length)可选) — 用于避免在填充词元索引上执行注意力的掩码。掩码值在 [0, 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.Tensor,形状为 (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.BaseModelOutputtuple(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=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组 (如果模型有嵌入层,则一个是嵌入层的输出,+ 每个层的输出一个),形状为 (batch_size, sequence_length, hidden_size)

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

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

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

ModernBertModel 的前向传播方法,重写了 __call__ 特殊方法。

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

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.MaskedLMOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 词汇表中输入序列词元的索引。默认情况下将忽略填充。

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

    什么是输入 ID?

  • attention_mask (torch.Tensor,形状为 (batch_size, sequence_length)可选) — 用于避免在填充词元索引上执行注意力的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示**未被屏蔽**的词元,
    • 0 表示**被屏蔽**的词元。

    什么是注意力掩码?

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

    什么是位置 ID?

  • inputs_embeds (torch.Tensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,你可以不传递 input_ids,而是直接传递嵌入表示。如果你想比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量,这会很有用。
  • labels (torch.Tensor,形状为 (batch_size, sequence_length)可选) — 用于计算掩码语言建模损失的标签。索引应在 [0, ..., config.vocab_size] 或 -100 中 (请参阅 input_ids 文档字符串)。设置为 -100 的词元索引将被忽略 (屏蔽),损失仅针对标签在 [0, ..., config.vocab_size] 中的词元计算。
  • 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.MaskedLMOutputtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.MaskedLMOutput 或一个 torch.FloatTensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),根据配置 (ModernBertConfig) 和输入包含不同的元素。

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

  • logits (形状为 (batch_size, sequence_length, config.vocab_size)torch.FloatTensor) — 语言建模头部的预测分数(SoftMax 之前的每个词汇标记的分数)。

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

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

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

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

ModernBertForMaskedLM 的前向传播方法,重写了 __call__ 特殊方法。

尽管前向传播的配方需要在此函数内定义,但之后应调用 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)
>>> tokenizer.decode(predicted_token_id)
...

>>> 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)
>>> round(outputs.loss.item(), 2)
...

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.SequenceClassifierOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 词汇表中输入序列词元的索引。默认情况下将忽略填充。

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

    什么是输入 ID?

  • attention_mask (torch.Tensor,形状为 (batch_size, sequence_length)可选) — 用于避免在填充词元索引上执行注意力的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示**未被屏蔽**的词元,
    • 0 表示**被屏蔽**的词元。

    什么是注意力掩码?

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

    什么是位置 ID?

  • inputs_embeds (torch.Tensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,你可以选择直接传递嵌入表示而不是 input_ids。如果你想比模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量,这会很有用。
  • labels (torch.LongTensor,形状为 (batch_size,)可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1,则计算回归损失(均方损失);如果 config.num_labels > 1,则计算分类损失(交叉熵)。
  • 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.SequenceClassifierOutputtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个 torch.FloatTensor 的元组(如果传递了 return_dict=Falseconfig.return_dict=False),根据配置 (ModernBertConfig) 和输入包含不同的元素。

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

  • logits (形状为 (batch_size, config.num_labels)torch.FloatTensor) — 分类(如果 config.num_labels==1,则为回归)分数(SoftMax 之前)。

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

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

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

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

ModernBertForSequenceClassification 的 forward 方法会覆盖 __call__ 特殊方法。

尽管前向传播的配方需要在此函数内定义,但之后应调用 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()
>>> model.config.id2label[predicted_class_id]
...

>>> # 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
>>> round(loss.item(), 2)
...

多标签分类示例

>>> 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 模型,例如用于命名实体识别(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.TokenClassifierOutputtuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

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

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

    什么是注意力掩码?

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

    什么是位置 ID?

  • inputs_embeds (torch.Tensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,你可以选择直接传递嵌入表示而不是 input_ids。如果你想比模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量,这会很有用。
  • labels (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 用于计算词元分类损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。
  • 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.TokenClassifierOutputtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.TokenClassifierOutput 或一个 torch.FloatTensor 的元组(如果传递了 return_dict=Falseconfig.return_dict=False),根据配置 (ModernBertConfig) 和输入包含不同的元素。

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

  • logits (形状为 (batch_size, sequence_length, config.num_labels)torch.FloatTensor) — 分类分数(SoftMax 之前)。

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

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

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

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

ModernBertForTokenClassification 的 forward 方法会覆盖 __call__ 特殊方法。

尽管前向传播的配方需要在此函数内定义,但之后应调用 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]]
>>> predicted_tokens_classes
...

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...

ModernBertForQuestionAnswering

class transformers.ModernBertForQuestionAnswering

< >

( config: ModernBertConfig )

参数

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

带有片段分类头的 Modernbert transformer,用于抽取式问答任务,如 SQuAD(在隐藏状态输出之上有一个线性层,用于计算 span start logitsspan end logits)。

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

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

forward

< >

( input_ids: typing.Optional[torch.Tensor] attention_mask: typing.Optional[torch.Tensor] = None sliding_window_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None start_positions: typing.Optional[torch.Tensor] = None end_positions: 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.QuestionAnsweringModelOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.Tensor,形状为 (batch_size, sequence_length)可选) — 词汇表中输入序列标记的索引。默认情况下,将忽略填充。

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

    什么是输入 ID?

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

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

    什么是注意力掩码?

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

    什么是位置 ID?

  • start_positions (torch.Tensor,形状为 (batch_size,)可选) — 用于计算词元分类损失的标记片段开始位置(索引)的标签。位置被限制在序列长度(sequence_length)内。序列之外的位置在计算损失时不予考虑。
  • end_positions (torch.Tensor,形状为 (batch_size,)可选) — 用于计算词元分类损失的标记片段结束位置(索引)的标签。位置被限制在序列长度(sequence_length)内。序列之外的位置在计算损失时不予考虑。
  • 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.QuestionAnsweringModelOutputtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一个 torch.FloatTensor 的元组(如果传递了 return_dict=Falseconfig.return_dict=False),根据配置 (ModernBertConfig) 和输入包含不同的元素。

  • loss (torch.FloatTensor of shape (1,), 可选, 当提供 labels 时返回) — 总范围提取损失是起始位置和结束位置的交叉熵之和。

  • start_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 范围起始分数(SoftMax 之前)。

  • end_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 范围结束分数(SoftMax 之前)。

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

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

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

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

ModernBertForQuestionAnswering 的 forward 方法会覆盖 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, ModernBertForQuestionAnswering
>>> import torch

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

>>> 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)
...

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

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

使用技巧

可以使用 HuggingFace Transformers 库及其用于问答任务的官方脚本对 ModernBert 模型进行微调。

< > 在 GitHub 上更新