Hugging Face's logo

Transformers documentation

ModernBERT 解码器

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

该模型于 2024-12-18 在 HF papers 上发布，并于 2025-07-15 贡献至 Hugging Face Transformers。

FlashAttention SDPA

ModernBERT 解码器

ModernBERT Decoder 的架构与 ModernBERT 相同，但它是根据 Ettin 论文 中的因果语言建模目标从头开始训练的。这使得我们可以使用相同的架构来比较编码器和解码器。该模型是 ModernBERT 的解码器架构实现，专为自回归文本生成任务而设计。

ModernBERT Decoder 采用滑动窗口注意力机制和旋转位置嵌入，以提升效率并处理更长的序列。

您可以在 jhu-clsp 集合中找到所有原始的 ModernBERT Decoder 检查点。

该模型由 orionw 贡献。

点击右侧边栏中的 ModernBERT Decoder 模型，以查看更多将 ModernBERT Decoder 应用于不同文本生成任务的示例。

以下示例演示了如何使用 ModernBERT Decoder 进行文本生成，包括使用 Pipeline、AutoModel（带量化和不带量化）以及通过命令行。

Pipeline
AutoModel
AutoModel（带量化）
from transformers import pipeline


generator = pipeline(
    task="text-generation",
    model="jhu-clsp/ettin-decoder-17m",
    device=0
)
generator("The future of artificial intelligence is", max_length=50, num_return_sequences=1)

# For sequence classification
classifier = pipeline(
    task="text-classification",
    model="jhu-clsp/ettin-decoder-17m",
    device=0
)
classifier("This movie is really great!")

ModernBertDecoderConfig

class transformers.ModernBertDecoderConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 50368hidden_size: int = 768intermediate_size: int = 1152num_hidden_layers: int = 22num_attention_heads: int = 12hidden_activation: str = 'gelu'max_position_embeddings: int = 8192initializer_range: float = 0.02initializer_cutoff_factor: float = 2.0norm_eps: float = 1e-05norm_bias: bool = Falsepad_token_id: int = 50283eos_token_id: int | list[int] | None = 50282bos_token_id: int = 50281cls_token_id: int = 50281sep_token_id: int = 50282attention_bias: bool = Falseattention_dropout: float | int = 0.0embedding_dropout: float | int = 0.0mlp_bias: bool = Falsemlp_dropout: float | int = 0.0decoder_bias: bool = Trueclassifier_dropout: float | int = 0.0classifier_bias: bool = Falseclassifier_activation: str = 'gelu'use_cache: bool = Truelocal_attention: int | None = 128layer_types: list[str] | None = Nonetie_word_embeddings: bool = Truerope_parameters: dict[typing.Literal['full_attention', 'sliding_attention'], dict] | None = None )

参数

  • vocab_size (int，可选，默认为 50368) — 模型的词汇表大小。定义了 input_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，可选，默认为 gelu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、"relu"、"silu" 等。
  • 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 (Union[int, list[int]]，可选，默认为 50282) — 词汇表中用于表示流结束（end-of-stream）的 token id。
  • bos_token_id (int, 可选，默认为 50281) — 词汇表中用于表示流起始的 Token id。
  • cls_token_id (int，可选，默认为 50281) — 词汇表中用于 CLS 的 token id。
  • sep_token_id (int，可选，默认为 50282) — 词汇表中用于分隔符的 Token id。
  • attention_bias (bool，可选，默认为 False) — 在自注意力机制中，是否在 query、key、value 和 output 投影层中使用偏置。
  • attention_dropout (Union[float, int]，可选，默认为 0.0) — 注意力概率的 dropout 比率。
  • embedding_dropout (Union[float, int]，可选，默认为 0.0) — 嵌入层的 dropout 比率。
  • mlp_bias (bool，可选，默认为 False) — 是否在 MLP 层的 up_proj、down_proj 和 gate_proj 层中使用偏置。
  • mlp_dropout (float，可选，默认值为 0.0) — MLP 层的 dropout 比率。
  • decoder_bias (bool，可选，默认为 True) — 是否在解码器层中使用偏置。
  • classifier_dropout (Union[float, int]，可选，默认为 0.0) — 分类器的 dropout 比率。
  • classifier_bias (bool，可选，默认为 False) — 是否在分类器中使用偏置。
  • classifier_activation (str，可选，默认为 "gelu") — 分类器的激活函数。
  • use_cache (bool，可选，默认为 True) — 模型是否应返回最后一次键/值注意力（并非所有模型都使用）。仅当 config.is_decoder=True 或模型为仅解码器生成式模型时相关。
  • local_attention (int，可选，默认值为 128) — 局部注意力的滑动窗口大小。仅用于使用局部注意力的层。请注意，为了使解码器与 ModernBERT 匹配，该值实际上是滑动窗口大小的一半，因此 128 => 64。
  • layer_types (list[str], 可选) — 一个列表，用于显式地将每个层索引映射到其层类型。如果未提供，将根据 config 值自动生成。
  • tie_word_embeddings (bool，可选，默认为 True) — 是否根据模型的 tied_weights_keys 映射来绑定权重嵌入。
  • rope_parameters (dict[Literal[full_attention, sliding_attention], dict], 可选) — 包含 RoPE 嵌入配置参数的字典。该字典应包含 rope_theta 的值，并且如果希望使用 RoPE 处理更长的 max_position_embeddings，则可选地包含用于缩放的参数。

这是用于存储 Modernbert DecoderModel 配置的类。它根据指定的参数实例化 Modernbert Decoder 模型，并定义模型架构。使用默认值实例化配置将得到与 blab-jhu/test-32m-dec 类似的配置。

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

示例：

>>> from transformers import ModernBertDecoderModel, ModernBertDecoderConfig

>>> # Initializing a ModernBert decoder style configuration
>>> configuration = ModernBertDecoderConfig()

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

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

ModernBertDecoderModel

class transformers.ModernBertDecoderModel

< >

( config: ModernBertDecoderConfig )

参数

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

原始的 Modernbert Decoder 模型，输出原始隐藏状态，顶部未添加任何特定的 head。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID？

  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

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

    什么是位置 ID？

  • past_key_values (~cache_utils.Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由 past_key_values 在解码的先前阶段返回，当 use_cache=True 或 config.use_cache=True.

    仅允许将 Cache 实例作为输入，请参阅我们的 kv cache 指南。 如果未传入 past_key_values，则默认会初始化 DynamicCache。

    模型将输出与输入相同的缓存格式。

    如果使用了 past_key_values，用户应仅输入未处理的 input_ids（即未向该模型提供其过去键值状态的那些），其形状为 (batch_size, unprocessed_length)，而不是形状为 (batch_size, sequence_length) 的全部 input_ids。

  • inputs_embeds（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
  • use_cache (bool，可选) — 如果设置为 True，则会返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。

返回值

BaseModelOutputWithPast 或 tuple(torch.FloatTensor)

一个 BaseModelOutputWithPast 或 torch.FloatTensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（ModernBertDecoderConfig）和输入。

ModernBertDecoderModel 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

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

    如果使用了 past_key_values，则仅输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。

  • past_key_values（Cache，可选，在传入 use_cache=True 或 config.use_cache=True 时返回）—— 它是一个 Cache 实例。更多详情，请参阅我们的 kv cache 指南。

    包含预计算的隐藏状态（自注意力块中的键和值，以及如果 config.is_encoder_decoder=True 则还包括交叉注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。

  • hidden_states (tuple(torch.FloatTensor)，可选，在传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.FloatTensor 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

ModernBertDecoderForCausalLM

class transformers.ModernBertDecoderForCausalLM

< >

( config: ModernBertDecoderConfig )

参数

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

带有语言建模头部的 ModernBert 解码器模型，用于因果语言建模（CLM）。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )

参数

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

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

    什么是输入 ID？

  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

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

    什么是位置 ID？

  • past_key_values (~cache_utils.Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由 past_key_values 在解码的先前阶段返回，当 use_cache=True 或 config.use_cache=True.

    仅允许将 Cache 实例作为输入，请参阅我们的 kv cache 指南。 如果未传入 past_key_values，则默认会初始化 DynamicCache。

    模型将输出与输入相同的缓存格式。

    如果使用了 past_key_values，用户应仅输入未处理的 input_ids（即未向该模型提供其过去键值状态的那些），其形状为 (batch_size, unprocessed_length)，而不是形状为 (batch_size, sequence_length) 的全部 input_ids。

  • inputs_embeds（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
  • labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引值应在 [0, ..., config.vocab_size] 范围内，或为 -100（参见 input_ids 的文档字符串）。索引值设为 -100 的 token 将被忽略（即被掩码），损失仅针对标签位于 [0, ..., config.vocab_size] 范围内的 token 进行计算。
  • use_cache (bool，可选) — 如果设置为 True，则会返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
  • logits_to_keep (Union[int, torch.Tensor], 可选，默认为 0) — 如果为 int，则计算最后 logits_to_keep 个 token 的 logits。如果为 0，则计算所有 input_ids 的 logits（特殊情况）。生成过程只需要最后一个 token 的 logits，仅针对该 token 进行计算可以节省内存，对于长序列或大词汇量而言，这种节省相当显著。 如果为 torch.Tensor，则必须是一维张量，对应于序列长度维度中需要保留的索引。 这在使用打包张量格式（将批次和序列长度合并为单一维度）时非常有用。

ModernBertDecoderForCausalLM 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

示例：

>>> from transformers import AutoTokenizer, ModernBertDecoderForCausalLM

>>> model = ModernBertDecoderForCausalLM.from_pretrained("blab-jhu/test-32m-dec")
>>> tokenizer = AutoTokenizer.from_pretrained("blab-jhu/test-32m-dec")

>>> prompt = "The capital of France is"
>>> inputs = tokenizer(prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=1)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"The capital of France is Paris"

ModernBertDecoderForSequenceClassification

class transformers.ModernBertDecoderForSequenceClassification

< >

( config: ModernBertDecoderConfig )

参数

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

带有序列分类头（线性层）的 ModernBert 解码器模型。

ModernBertDecoderForSequenceClassification 使用最后一个 token 来进行分类，这与其它因果模型（例如 GPT-1、GPT-2）的做法一致。

由于它基于最后一个 token 进行分类，因此需要知道最后一个 token 的位置。如果配置中定义了 pad_token_id，它会找到每一行中最后一个非填充 token。如果未定义 pad_token_id，它就直接取批次中每一行的最后一个值。由于在传入 inputs_embeds 而非 input_ids 时无法推断填充 token，因此它同样采取相同做法（取批次中每一行的最后一个值）。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → SequenceClassifierOutputWithPast or tuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID？

  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

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

    什么是位置 ID？

  • past_key_values (~cache_utils.Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由 past_key_values 在解码的先前阶段返回，当 use_cache=True 或 config.use_cache=True.

    仅允许将 Cache 实例作为输入，请参阅我们的 kv cache 指南。 如果未传入 past_key_values，则默认会初始化 DynamicCache。

    模型将输出与输入相同的缓存格式。

    如果使用了 past_key_values，用户应仅输入未处理的 input_ids（即未向该模型提供其过去键值状态的那些），其形状为 (batch_size, unprocessed_length)，而不是形状为 (batch_size, sequence_length) 的全部 input_ids。

  • inputs_embeds（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
  • labels (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方损失）；如果 config.num_labels > 1，则计算分类损失（交叉熵）。
  • use_cache (bool，可选) — 如果设置为 True，则会返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。

返回值

SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)

SequenceClassifierOutputWithPast 或 torch.FloatTensor 元组（如果传入 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（ModernBertDecoderConfig）和输入。

ModernBertDecoderForSequenceClassification 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

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

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

  • past_key_values（Cache，可选，在传入 use_cache=True 或 config.use_cache=True 时返回）—— 它是一个 Cache 实例。更多详情，请参阅我们的 kv cache 指南。

    包含预计算的隐藏状态（自注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。

  • hidden_states (tuple(torch.FloatTensor)，可选，在传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.FloatTensor 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

单标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, ModernBertDecoderForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("blab-jhu/test-32m-dec")
>>> model = ModernBertDecoderForSequenceClassification.from_pretrained("blab-jhu/test-32m-dec")

>>> 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 = ModernBertDecoderForSequenceClassification.from_pretrained("blab-jhu/test-32m-dec", num_labels=num_labels)

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

多标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, ModernBertDecoderForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("blab-jhu/test-32m-dec")
>>> model = ModernBertDecoderForSequenceClassification.from_pretrained("blab-jhu/test-32m-dec", 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 = ModernBertDecoderForSequenceClassification.from_pretrained(
...     "blab-jhu/test-32m-dec", 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
Update on GitHub

←ModernBert ModernVBert→