Skip to content

DNABERT-2

DNABERT-2

Pre-trained model on multi-species genome using a masked language modeling (MLM) objective.

Disclaimer

This is an UNOFFICIAL implementation of the DNABERT-2: Efficient Foundation Model and Benchmark for Multi-Species Genomes by Zhihan Zhou, et al.

The OFFICIAL repository of DNABERT-2 is at MAGICS-LAB/DNABERT_2.

Tip

The MultiMolecule team has confirmed that the provided model and checkpoints are producing the same intermediate representations as the original implementation.

The team releasing DNABERT-2 did not write this model card for this model so this model card has been written by the MultiMolecule team.

Model Details

DNABERT-2 is a bert-style model pre-trained on a large corpus of multi-species genome sequences in a self-supervised fashion. This means that the model was trained on the raw nucleotides of DNA sequences only, with an automatic process to generate inputs and labels from those texts. Please refer to the Training Details section for more information on the training process.

Model Specification

Num Layers Hidden Size Num Heads Intermediate Size Num Parameters (M) FLOPs (G) MACs (G) Max Num Tokens
12 768 12 3072 117.07 125.83 62.92 512

Usage

The model file depends on the multimolecule library. You can install it using pip:

Bash
1
pip install multimolecule

Direct Use

Masked Language Modeling

You can use this model directly with a pipeline for masked language modeling:

Python
1
2
3
4
5
import multimolecule  # you must import multimolecule to register models
from transformers import pipeline

predictor = pipeline("fill-mask", model="multimolecule/dnabert2")
output = predictor("ATCG<mask>TGCA")

Downstream Use

Extract Features

Here is how to use this model to get the features of a given sequence in PyTorch:

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
from multimolecule import DnaBert2Model
from transformers import AutoTokenizer


tokenizer = AutoTokenizer.from_pretrained("multimolecule/dnabert2")
model = DnaBert2Model.from_pretrained("multimolecule/dnabert2")

text = "ATCGATCGATCGATCG"
input = tokenizer(text, return_tensors="pt")

output = model(**input)

Sequence Classification / Regression

Note

This model is not fine-tuned for any specific task. You will need to fine-tune the model on a downstream task to use it for sequence classification or regression.

Here is how to use this model as backbone to fine-tune for a sequence-level task in PyTorch:

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import torch
from multimolecule import DnaBert2ForSequencePrediction
from transformers import AutoTokenizer


tokenizer = AutoTokenizer.from_pretrained("multimolecule/dnabert2")
model = DnaBert2ForSequencePrediction.from_pretrained("multimolecule/dnabert2")

text = "ATCGATCGATCGATCG"
input = tokenizer(text, return_tensors="pt")
label = torch.tensor([1])

output = model(**input, labels=label)

Token Classification / Regression

Note

This model is not fine-tuned for any specific task. You will need to fine-tune the model on a downstream task to use it for token classification or regression.

Here is how to use this model as backbone to fine-tune for a nucleotide-level task in PyTorch:

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import torch
from multimolecule import DnaBert2ForTokenPrediction
from transformers import AutoTokenizer


tokenizer = AutoTokenizer.from_pretrained("multimolecule/dnabert2")
model = DnaBert2ForTokenPrediction.from_pretrained("multimolecule/dnabert2")

text = "ATCGATCGATCGATCG"
input = tokenizer(text, return_tensors="pt")
label = torch.randint(2, (len(text), ))

output = model(**input, labels=label)

Contact Classification / Regression

Note

This model is not fine-tuned for any specific task. You will need to fine-tune the model on a downstream task to use it for contact classification or regression.

Here is how to use this model as backbone to fine-tune for a contact-level task in PyTorch:

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import torch
from multimolecule import DnaBert2ForContactPrediction
from transformers import AutoTokenizer


tokenizer = AutoTokenizer.from_pretrained("multimolecule/dnabert2")
model = DnaBert2ForContactPrediction.from_pretrained("multimolecule/dnabert2")

text = "ATCGATCGATCGATCG"
input = tokenizer(text, return_tensors="pt")
label = torch.randint(2, (len(text), len(text)))

output = model(**input, labels=label)

Training Details

DNABERT-2 used Masked Language Modeling (MLM) as the pre-training objective: taking a sequence, the model randomly masks 15% of the tokens in the input then runs the entire masked sentence through the model and has to predict the masked tokens. This is comparable to the Cloze task in language modeling.

Training Data

The DNABERT-2 model was pre-trained on multi-species genome sequences from GenBank. The dataset encompasses genomes from 135 species, spread across 6 categories. In total, the dataset includes 32.49 billion nucleotide bases, nearly 12 times the volume of the human genome dataset. All sequences with N are excluded, retaining only sequences that consist of A, T, C, and G.

DNABERT-2 uses Byte Pair Encoding (BPE) tokenization with a vocabulary size of 4096. This replaces the k-mer tokenization used in the original DNABERT, providing improved computational and sample efficiency.

Training Procedure

Preprocessing

DNABERT-2 used masked language modeling (MLM) as the pre-training objective. The masking procedure is similar to the one used in BERT:

  • Mask rate: 15%
  • Replacement: <mask> for 80% of masked tokens
  • Replacement: random token for 10% of masked tokens
  • Replacement: unchanged token for 10% of masked tokens

Pre-training

The model was trained on 8 NVIDIA RTX 2080Ti GPUs.

  • Batch size: 4,096
  • Steps: 500,000
  • Optimizer: AdamW(β1=0.9, β2=0.98, ε=1e-6)
  • Learning rate: 5e-4
  • Learning rate warm-up: 30,000 steps
  • Learning rate scheduler: Linear
  • Minimum learning rate: 0
  • Weight decay: 1e-5

Citation

BibTeX
1
2
3
4
5
6
7
@inproceedings{zhou2024dnabert,
  title={{DNABERT}-2: Efficient Foundation Model and Benchmark For Multi-Species Genomes},
  author={Zhihan Zhou and Yanrong Ji and Weijian Li and Pratik Dutta and Ramana V Davuluri and Han Liu},
  booktitle={The Twelfth International Conference on Learning Representations},
  year={2024},
  url={https://openreview.net/forum?id=oMLQB4EZE1}
}

Note

The artifacts distributed in this repository are part of the MultiMolecule project. If you use MultiMolecule in your research, you must cite the MultiMolecule project as follows:

BibTeX
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
@software{chen_2024_12638419,
  author    = {Chen, Zhiyuan and Zhu, Sophia Y.},
  title     = {MultiMolecule},
  doi       = {10.5281/zenodo.12638419},
  publisher = {Zenodo},
  url       = {https://doi.org/10.5281/zenodo.12638419},
  year      = 2024,
  month     = may,
  day       = 4
}

Contact

Please use GitHub issues of MultiMolecule for any questions or comments on the model card.

Please contact the authors of the DNABERT-2 paper for questions or comments on the paper/model.

License

This model implementation is licensed under the GNU Affero General Public License.

For additional terms and clarifications, please refer to our License FAQ.

Text Only
1
SPDX-License-Identifier: AGPL-3.0-or-later

multimolecule.models.dnabert2

DnaBert2Config

Bases: PreTrainedConfig

This is the configuration class to store the configuration of a DnaBert2Model. It is used to instantiate a DNABERT-2 model according to the specified arguments, defining the model architecture. Instantiating a configuration with the defaults will yield a similar configuration to that of the DNABERT-2 zhihan1996/DNABERT-2-117M architecture.

Configuration objects inherit from PreTrainedConfig and can be used to control the model outputs. Read the documentation from PreTrainedConfig for more information.

Parameters:

Name Type Description Default

vocab_size

int

Vocabulary size of the DnaBert2 model. Defines the number of different tokens that can be represented by the input_ids passed when calling [DnaBert2Model].

 4096

hidden_size

int

Dimensionality of the encoder layers and the pooler layer.

 768

num_hidden_layers

int

Number of hidden layers in the Transformer encoder.

 12

num_attention_heads

int

Number of attention heads for each attention layer in the Transformer encoder.

 12

intermediate_size

int

Dimensionality of the “intermediate” (often named feed-forward) layer in the Transformer encoder.

 3072

hidden_act

str

The non-linear activation function (function or string) in the encoder and pooler. If string, "gelu", "relu", "silu" and "gelu_new" are supported.

 'gelu'

hidden_dropout

float

The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.

 0.1

attention_dropout

float

The dropout ratio for the attention probabilities.

 0.0

max_position_embeddings

int

The maximum sequence length that this model might ever be used with. Typically set this to something large just in case (e.g., 512 or 1024 or 2048).

 512

initializer_range

float

The standard deviation of the truncated_normal_initializer for initializing all weight matrices.

 0.02

layer_norm_eps

float

The epsilon used by the layer normalization layers.

 1e-12

position_embedding_type

str

Type of position embedding. DNABERT-2 uses "alibi" (Attention with Linear Biases).

 'alibi'

alibi_starting_size

int

The starting size for the ALiBi position bias tensor.

 512

is_decoder

bool

Whether the model is used as a decoder or not. If False, the model is used as an encoder.

 False

use_cache

bool

Whether or not the model should return the last key/values attentions (not used by all models). Only relevant if config.is_decoder=True.

 True

head

HeadConfig | None

The configuration of the head.

 None

lm_head

MaskedLMHeadConfig | None

The configuration of the masked language model head.

 None

add_cross_attention

bool

Whether to add cross-attention layers when the model is used as a decoder.

 False

Examples:

Python Console Session
1
2
3
4
5
6
7
>>> from multimolecule import DnaBert2Config, DnaBert2Model
>>> # Initializing a DNABERT-2 multimolecule/dnabert2 style configuration
>>> configuration = DnaBert2Config()
>>> # Initializing a model (with random weights) from the multimolecule/dnabert2 style configuration
>>> model = DnaBert2Model(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
Source code in multimolecule/models/dnabert2/configuration_dnabert2.py
Python
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
class DnaBert2Config(PreTrainedConfig):
    r"""
    This is the configuration class to store the configuration of a
    [`DnaBert2Model`][multimolecule.models.DnaBert2Model]. It is used to instantiate a DNABERT-2 model according
    to the specified arguments, defining the model architecture. Instantiating a configuration with the defaults will
    yield a similar configuration to that of the DNABERT-2
    [zhihan1996/DNABERT-2-117M](https://huggingface.co/zhihan1996/DNABERT-2-117M) architecture.

    Configuration objects inherit from [`PreTrainedConfig`][multimolecule.models.PreTrainedConfig] and can be used to
    control the model outputs. Read the documentation from [`PreTrainedConfig`][multimolecule.models.PreTrainedConfig]
    for more information.

    Args:
        vocab_size:
            Vocabulary size of the DnaBert2 model. Defines the number of different tokens that can be represented by
            the `input_ids` passed when calling [`DnaBert2Model`].
        hidden_size:
            Dimensionality of the encoder layers and the pooler layer.
        num_hidden_layers:
            Number of hidden layers in the Transformer encoder.
        num_attention_heads:
            Number of attention heads for each attention layer in the Transformer encoder.
        intermediate_size:
            Dimensionality of the "intermediate" (often named feed-forward) layer in the Transformer encoder.
        hidden_act:
            The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`,
            `"relu"`, `"silu"` and `"gelu_new"` are supported.
        hidden_dropout:
            The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.
        attention_dropout:
            The dropout ratio for the attention probabilities.
        max_position_embeddings:
            The maximum sequence length that this model might ever be used with. Typically set this to something large
            just in case (e.g., 512 or 1024 or 2048).
        initializer_range:
            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
        layer_norm_eps:
            The epsilon used by the layer normalization layers.
        position_embedding_type:
            Type of position embedding. DNABERT-2 uses `"alibi"` (Attention with Linear Biases).
        alibi_starting_size:
            The starting size for the ALiBi position bias tensor.
        is_decoder:
            Whether the model is used as a decoder or not. If `False`, the model is used as an encoder.
        use_cache:
            Whether or not the model should return the last key/values attentions (not used by all models). Only
            relevant if `config.is_decoder=True`.
        head:
            The configuration of the head.
        lm_head:
            The configuration of the masked language model head.
        add_cross_attention:
            Whether to add cross-attention layers when the model is used as a decoder.

    Examples:
        >>> from multimolecule import DnaBert2Config, DnaBert2Model
        >>> # Initializing a DNABERT-2 multimolecule/dnabert2 style configuration
        >>> configuration = DnaBert2Config()
        >>> # Initializing a model (with random weights) from the multimolecule/dnabert2 style configuration
        >>> model = DnaBert2Model(configuration)
        >>> # Accessing the model configuration
        >>> configuration = model.config
    """

    model_type = "dnabert2"

    def __init__(
        self,
        vocab_size: int = 4096,
        hidden_size: int = 768,
        num_hidden_layers: int = 12,
        num_attention_heads: int = 12,
        intermediate_size: int = 3072,
        hidden_act: str = "gelu",
        hidden_dropout: float = 0.1,
        attention_dropout: float = 0.0,
        max_position_embeddings: int = 512,
        initializer_range: float = 0.02,
        layer_norm_eps: float = 1e-12,
        position_embedding_type: str = "alibi",
        alibi_starting_size: int = 512,
        is_decoder: bool = False,
        use_cache: bool = True,
        head: HeadConfig | None = None,
        lm_head: MaskedLMHeadConfig | None = None,
        add_cross_attention: bool = False,
        **kwargs,
    ):
        super().__init__(**kwargs)
        validate_attention_dimensions(hidden_size, num_attention_heads)
        self.vocab_size = vocab_size
        self.type_vocab_size = 2
        self.hidden_size = hidden_size
        self.num_hidden_layers = num_hidden_layers
        self.num_attention_heads = num_attention_heads
        self.intermediate_size = intermediate_size
        self.hidden_act = hidden_act
        self.hidden_dropout = hidden_dropout
        self.attention_dropout = attention_dropout
        self.max_position_embeddings = max_position_embeddings
        self.initializer_range = initializer_range
        self.layer_norm_eps = layer_norm_eps
        self.position_embedding_type = position_embedding_type
        self.alibi_starting_size = alibi_starting_size
        self.is_decoder = is_decoder
        self.use_cache = use_cache
        self.head = HeadConfig(**head) if head is not None else None
        self.lm_head = MaskedLMHeadConfig(**lm_head) if lm_head is not None else None
        self.add_cross_attention = add_cross_attention

DnaBert2ForContactPrediction

Bases: DnaBert2PreTrainedModel

Examples:

Python Console Session
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
>>> import torch
>>> from multimolecule import DnaBert2Config, DnaBert2ForContactPrediction
>>> config = DnaBert2Config()
>>> model = DnaBert2ForContactPrediction(config)
>>> input_ids = torch.randint(0, config.vocab_size, (1, 16))
>>> output = model(input_ids, labels=torch.randint(2, (1, 14, 14)))
>>> output["logits"].shape
torch.Size([1, 14, 14, 1])
>>> output["loss"]
tensor(..., grad_fn=<BinaryCrossEntropyWithLogitsBackward0>)
Source code in multimolecule/models/dnabert2/modeling_dnabert2.py
Python
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
class DnaBert2ForContactPrediction(DnaBert2PreTrainedModel):
    """
    Examples:
        >>> import torch
        >>> from multimolecule import DnaBert2Config, DnaBert2ForContactPrediction
        >>> config = DnaBert2Config()
        >>> model = DnaBert2ForContactPrediction(config)
        >>> input_ids = torch.randint(0, config.vocab_size, (1, 16))
        >>> output = model(input_ids, labels=torch.randint(2, (1, 14, 14)))
        >>> output["logits"].shape
        torch.Size([1, 14, 14, 1])
        >>> output["loss"]  # doctest:+ELLIPSIS
        tensor(..., grad_fn=<BinaryCrossEntropyWithLogitsBackward0>)
    """

    def __init__(self, config: DnaBert2Config):
        super().__init__(config)
        self.model = DnaBert2Model(config, add_pooling_layer=False)
        self.contact_head = ContactPredictionHead(config)
        self.head_config = self.contact_head.config
        self.require_attentions = self.contact_head.require_attentions

        # Initialize weights and apply final processing
        self.post_init()

    @can_return_tuple
    def forward(
        self,
        input_ids: Tensor | NestedTensor | None = None,
        attention_mask: Tensor | None = None,
        inputs_embeds: Tensor | NestedTensor | None = None,
        labels: Tensor | None = None,
        **kwargs: Unpack[TransformersKwargs],
    ) -> tuple[Tensor, ...] | ContactPredictorOutput:
        if self.require_attentions:
            output_attentions = kwargs.get("output_attentions", self.config.output_attentions)
            if output_attentions is False:
                warn("output_attentions must be True since prediction head requires attentions.")
            kwargs["output_attentions"] = True
        outputs = self.model(
            input_ids,
            attention_mask=attention_mask,
            inputs_embeds=inputs_embeds,
            return_dict=True,
            **kwargs,
        )

        output = self.contact_head(outputs, attention_mask, input_ids, labels)
        logits, loss = output.logits, output.loss

        return ContactPredictorOutput(
            loss=loss,
            logits=logits,
            hidden_states=outputs.hidden_states,
            attentions=outputs.attentions,
        )

DnaBert2ForMaskedLM

Bases: DnaBert2PreTrainedModel

Examples:

Python Console Session
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
>>> import torch
>>> from multimolecule import DnaBert2Config, DnaBert2ForMaskedLM
>>> config = DnaBert2Config()
>>> model = DnaBert2ForMaskedLM(config)
>>> input_ids = torch.randint(0, config.vocab_size, (1, 16))
>>> output = model(input_ids, labels=input_ids)
>>> output["logits"].shape
torch.Size([1, 16, 4096])
>>> output["loss"]
tensor(..., grad_fn=<NllLossBackward0>)
Source code in multimolecule/models/dnabert2/modeling_dnabert2.py
Python
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
class DnaBert2ForMaskedLM(DnaBert2PreTrainedModel):
    """
    Examples:
        >>> import torch
        >>> from multimolecule import DnaBert2Config, DnaBert2ForMaskedLM
        >>> config = DnaBert2Config()
        >>> model = DnaBert2ForMaskedLM(config)
        >>> input_ids = torch.randint(0, config.vocab_size, (1, 16))
        >>> output = model(input_ids, labels=input_ids)
        >>> output["logits"].shape
        torch.Size([1, 16, 4096])
        >>> output["loss"]  # doctest:+ELLIPSIS
        tensor(..., grad_fn=<NllLossBackward0>)
    """

    _tied_weights_keys = {
        "lm_head.decoder.weight": "model.embeddings.word_embeddings.weight",
        "lm_head.decoder.bias": "lm_head.bias",
    }

    def __init__(self, config: DnaBert2Config):
        super().__init__(config)
        if config.is_decoder:
            warn(
                "If you want to use `DnaBert2ForMaskedLM` make sure `config.is_decoder=False` for "
                "bi-directional self-attention."
            )
        self.model = DnaBert2Model(config, add_pooling_layer=False)
        self.lm_head = MaskedLMHead(config)

        # Initialize weights and apply final processing
        self.post_init()

    def get_output_embeddings(self):
        return self.lm_head.decoder

    def set_output_embeddings(self, embeddings):
        self.lm_head.decoder = embeddings
        if hasattr(self.lm_head, "bias"):
            self.lm_head.bias = embeddings.bias

    @can_return_tuple
    def forward(
        self,
        input_ids: Tensor | NestedTensor | None = None,
        attention_mask: Tensor | None = None,
        inputs_embeds: Tensor | NestedTensor | None = None,
        encoder_hidden_states: Tensor | None = None,
        encoder_attention_mask: Tensor | None = None,
        labels: Tensor | None = None,
        **kwargs: Unpack[TransformersKwargs],
    ) -> tuple[Tensor, ...] | MaskedLMOutput:
        outputs = self.model(
            input_ids,
            attention_mask=attention_mask,
            inputs_embeds=inputs_embeds,
            encoder_hidden_states=encoder_hidden_states,
            encoder_attention_mask=encoder_attention_mask,
            return_dict=True,
            **kwargs,
        )

        output = self.lm_head(outputs, labels)
        logits, loss = output.logits, output.loss

        return MaskedLMOutput(
            loss=loss,
            logits=logits,
            hidden_states=outputs.hidden_states,
            attentions=outputs.attentions,
        )

DnaBert2ForSequencePrediction

Bases: DnaBert2PreTrainedModel

Examples:

Python Console Session
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
>>> import torch
>>> from multimolecule import DnaBert2Config, DnaBert2ForSequencePrediction
>>> config = DnaBert2Config()
>>> model = DnaBert2ForSequencePrediction(config)
>>> input_ids = torch.randint(0, config.vocab_size, (1, 16))
>>> output = model(input_ids, labels=torch.tensor([[1]]))
>>> output["logits"].shape
torch.Size([1, 1])
>>> output["loss"]
tensor(..., grad_fn=<BinaryCrossEntropyWithLogitsBackward0>)
Source code in multimolecule/models/dnabert2/modeling_dnabert2.py
Python
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
class DnaBert2ForSequencePrediction(DnaBert2PreTrainedModel):
    """
    Examples:
        >>> import torch
        >>> from multimolecule import DnaBert2Config, DnaBert2ForSequencePrediction
        >>> config = DnaBert2Config()
        >>> model = DnaBert2ForSequencePrediction(config)
        >>> input_ids = torch.randint(0, config.vocab_size, (1, 16))
        >>> output = model(input_ids, labels=torch.tensor([[1]]))
        >>> output["logits"].shape
        torch.Size([1, 1])
        >>> output["loss"]  # doctest:+ELLIPSIS
        tensor(..., grad_fn=<BinaryCrossEntropyWithLogitsBackward0>)
    """

    def __init__(self, config: DnaBert2Config):
        super().__init__(config)
        self.model = DnaBert2Model(config)
        self.sequence_head = SequencePredictionHead(config)
        self.head_config = self.sequence_head.config

        # Initialize weights and apply final processing
        self.post_init()

    @can_return_tuple
    def forward(
        self,
        input_ids: Tensor | NestedTensor | None = None,
        attention_mask: Tensor | None = None,
        inputs_embeds: Tensor | NestedTensor | None = None,
        labels: Tensor | None = None,
        **kwargs: Unpack[TransformersKwargs],
    ) -> tuple[Tensor, ...] | SequencePredictorOutput:
        outputs = self.model(
            input_ids,
            attention_mask=attention_mask,
            inputs_embeds=inputs_embeds,
            return_dict=True,
            **kwargs,
        )

        output = self.sequence_head(outputs, labels)
        logits, loss = output.logits, output.loss

        return SequencePredictorOutput(
            loss=loss,
            logits=logits,
            hidden_states=outputs.hidden_states,
            attentions=outputs.attentions,
        )

DnaBert2ForTokenPrediction

Bases: DnaBert2PreTrainedModel

Examples:

Python Console Session
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
>>> import torch
>>> from multimolecule import DnaBert2Config, DnaBert2ForTokenPrediction
>>> config = DnaBert2Config()
>>> model = DnaBert2ForTokenPrediction(config)
>>> input_ids = torch.randint(0, config.vocab_size, (1, 16))
>>> output = model(input_ids, labels=torch.randint(2, (1, 14)))
>>> output["logits"].shape
torch.Size([1, 14, 1])
>>> output["loss"]
tensor(..., grad_fn=<BinaryCrossEntropyWithLogitsBackward0>)
Source code in multimolecule/models/dnabert2/modeling_dnabert2.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
class DnaBert2ForTokenPrediction(DnaBert2PreTrainedModel):
    """
    Examples:
        >>> import torch
        >>> from multimolecule import DnaBert2Config, DnaBert2ForTokenPrediction
        >>> config = DnaBert2Config()
        >>> model = DnaBert2ForTokenPrediction(config)
        >>> input_ids = torch.randint(0, config.vocab_size, (1, 16))
        >>> output = model(input_ids, labels=torch.randint(2, (1, 14)))
        >>> output["logits"].shape
        torch.Size([1, 14, 1])
        >>> output["loss"]  # doctest:+ELLIPSIS
        tensor(..., grad_fn=<BinaryCrossEntropyWithLogitsBackward0>)
    """

    def __init__(self, config: DnaBert2Config):
        super().__init__(config)
        self.model = DnaBert2Model(config, add_pooling_layer=False)
        self.token_head = TokenPredictionHead(config)
        self.head_config = self.token_head.config

        # Initialize weights and apply final processing
        self.post_init()

    @can_return_tuple
    def forward(
        self,
        input_ids: Tensor | NestedTensor | None = None,
        attention_mask: Tensor | None = None,
        inputs_embeds: Tensor | NestedTensor | None = None,
        labels: Tensor | None = None,
        **kwargs: Unpack[TransformersKwargs],
    ) -> tuple[Tensor, ...] | TokenPredictorOutput:
        outputs = self.model(
            input_ids,
            attention_mask=attention_mask,
            inputs_embeds=inputs_embeds,
            return_dict=True,
            **kwargs,
        )

        output = self.token_head(outputs, attention_mask, input_ids, labels)
        logits, loss = output.logits, output.loss

        return TokenPredictorOutput(
            loss=loss,
            logits=logits,
            hidden_states=outputs.hidden_states,
            attentions=outputs.attentions,
        )

DnaBert2Model

Bases: DnaBert2PreTrainedModel

Examples:

Python Console Session
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
>>> import torch
>>> from multimolecule import DnaBert2Config, DnaBert2Model
>>> config = DnaBert2Config()
>>> model = DnaBert2Model(config)
>>> input_ids = torch.randint(0, config.vocab_size, (1, 16))
>>> output = model(input_ids)
>>> output["last_hidden_state"].shape
torch.Size([1, 16, 768])
>>> output["pooler_output"].shape
torch.Size([1, 768])
Source code in multimolecule/models/dnabert2/modeling_dnabert2.py
Python
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
class DnaBert2Model(DnaBert2PreTrainedModel):
    """
    Examples:
        >>> import torch
        >>> from multimolecule import DnaBert2Config, DnaBert2Model
        >>> config = DnaBert2Config()
        >>> model = DnaBert2Model(config)
        >>> input_ids = torch.randint(0, config.vocab_size, (1, 16))
        >>> output = model(input_ids)
        >>> output["last_hidden_state"].shape
        torch.Size([1, 16, 768])
        >>> output["pooler_output"].shape
        torch.Size([1, 768])
    """

    def __init__(self, config: DnaBert2Config, add_pooling_layer: bool = True):
        super().__init__(config)
        self.pad_token_id = config.pad_token_id
        self.gradient_checkpointing = False
        self.embeddings = DnaBert2Embeddings(config)
        self.encoder = DnaBert2Encoder(config)
        self.pooler = DnaBert2Pooler(config) if add_pooling_layer else None

        # Initialize weights and apply final processing
        self.post_init()

    def get_input_embeddings(self):
        return self.embeddings.word_embeddings

    def set_input_embeddings(self, value):
        self.embeddings.word_embeddings = value

    @merge_with_config_defaults
    @capture_outputs
    def forward(
        self,
        input_ids: Tensor | NestedTensor | None = None,
        attention_mask: Tensor | None = None,
        inputs_embeds: Tensor | NestedTensor | None = None,
        encoder_hidden_states: Tensor | None = None,
        encoder_attention_mask: Tensor | None = None,
        past_key_values: Cache | None = None,
        use_cache: bool | None = None,
        cache_position: Tensor | None = None,
        **kwargs: Unpack[TransformersKwargs],
    ) -> tuple[Tensor, ...] | BaseModelOutputWithPoolingAndCrossAttentions:
        r"""
        Args:
            encoder_hidden_states:
                Shape: `(batch_size, sequence_length, hidden_size)`

                Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if
                the model is configured as a decoder.
            encoder_attention_mask:
                Shape: `(batch_size, sequence_length)`

                Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used
                in the cross-attention if the model is configured as a decoder. Mask values selected in `[0, 1]`:

                - 1 for tokens that are **not masked**,
                - 0 for tokens that are **masked**.
            past_key_values:
                Tuple of length `config.n_layers` with each tuple having 4 tensors of shape
                `(batch_size, num_heads, sequence_length - 1, embed_size_per_head)

                Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up
                decoding.

                If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those
                that don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of
                all `decoder_input_ids` of shape `(batch_size, sequence_length)`.
            use_cache:
                If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding
                (see `past_key_values`).
        """
        if self.config.is_decoder:
            use_cache = use_cache if use_cache is not None else self.config.use_cache
        else:
            use_cache = False
        if use_cache and past_key_values is None:
            past_key_values = (
                EncoderDecoderCache(DynamicCache(config=self.config), DynamicCache(config=self.config))
                if encoder_hidden_states is not None or self.config.is_encoder_decoder
                else DynamicCache(config=self.config)
            )

        if isinstance(input_ids, NestedTensor) and attention_mask is None:
            attention_mask = input_ids.mask
        if (input_ids is None) ^ (inputs_embeds is not None):
            raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
        if input_ids is not None:
            device = input_ids.device
            seq_length = input_ids.shape[1]
        else:
            device = inputs_embeds.device  # type: ignore[union-attr]
            seq_length = inputs_embeds.shape[1]  # type: ignore[union-attr]

        # past_key_values_length
        past_key_values_length = past_key_values.get_seq_length() if past_key_values is not None else 0
        if cache_position is None:
            cache_position = torch.arange(past_key_values_length, past_key_values_length + seq_length, device=device)

        if attention_mask is None and input_ids is not None and self.pad_token_id is not None:
            attention_mask = input_ids.ne(self.pad_token_id)

        embedding_output = self.embeddings(
            input_ids=input_ids,
            inputs_embeds=inputs_embeds,
        )
        attention_mask, encoder_attention_mask = self._create_attention_masks(
            attention_mask=attention_mask,
            encoder_attention_mask=encoder_attention_mask,
            embedding_output=embedding_output,
            encoder_hidden_states=encoder_hidden_states,
            cache_position=cache_position,
            past_key_values=past_key_values,
        )
        encoder_outputs = self.encoder(
            embedding_output,
            attention_mask,
            encoder_hidden_states,
            encoder_attention_mask=encoder_attention_mask,
            past_key_values=past_key_values,
            use_cache=use_cache,
            cache_position=cache_position,
            **kwargs,
        )
        sequence_output = encoder_outputs.last_hidden_state
        pooled_output = self.pooler(sequence_output) if self.pooler is not None else None

        return BaseModelOutputWithPoolingAndCrossAttentions(
            last_hidden_state=sequence_output,
            pooler_output=pooled_output,
            past_key_values=encoder_outputs.past_key_values,
        )

    def _create_attention_masks(
        self,
        attention_mask,
        encoder_attention_mask,
        embedding_output,
        encoder_hidden_states,
        cache_position,
        past_key_values,
    ):
        if self.config.is_decoder:
            attention_mask = create_causal_mask(
                config=self.config,
                inputs_embeds=embedding_output,
                attention_mask=attention_mask,
                cache_position=cache_position,
                past_key_values=past_key_values,
            )
        else:
            attention_mask = create_bidirectional_mask(
                config=self.config, inputs_embeds=embedding_output, attention_mask=attention_mask
            )

        if encoder_attention_mask is not None:
            encoder_attention_mask = create_bidirectional_mask(
                config=self.config,
                inputs_embeds=embedding_output,
                attention_mask=encoder_attention_mask,
                encoder_hidden_states=encoder_hidden_states,
            )

        return attention_mask, encoder_attention_mask

forward

Python
forward(
    input_ids: Tensor | NestedTensor | None = None,
    attention_mask: Tensor | None = None,
    inputs_embeds: Tensor | NestedTensor | None = None,
    encoder_hidden_states: Tensor | None = None,
    encoder_attention_mask: Tensor | None = None,
    past_key_values: Cache | None = None,
    use_cache: bool | None = None,
    cache_position: Tensor | None = None,
    **kwargs: Unpack[TransformersKwargs]
) -> (
    tuple[Tensor, ...]
    | BaseModelOutputWithPoolingAndCrossAttentions
)

Parameters:

Name Type Description Default
encoder_hidden_states
Tensor | None

Shape: (batch_size, sequence_length, hidden_size)

Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if the model is configured as a decoder.

 None
encoder_attention_mask
Tensor | None

Shape: (batch_size, sequence_length)

Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in the cross-attention if the model is configured as a decoder. Mask values selected in [0, 1]:

  • 1 for tokens that are not masked,
  • 0 for tokens that are masked.
 None
past_key_values
Cache | None

Tuple of length config.n_layers with each tuple having 4 tensors of shape `(batch_size, num_heads, sequence_length - 1, embed_size_per_head)

Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.

If past_key_values are used, the user can optionally input only the last decoder_input_ids (those that don’t have their past key value states given to this model) of shape (batch_size, 1) instead of all decoder_input_ids of shape (batch_size, sequence_length).

 None
use_cache
bool | None

If set to True, past_key_values key value states are returned and can be used to speed up decoding (see past_key_values).

 None
Source code in multimolecule/models/dnabert2/modeling_dnabert2.py
Python
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
@merge_with_config_defaults
@capture_outputs
def forward(
    self,
    input_ids: Tensor | NestedTensor | None = None,
    attention_mask: Tensor | None = None,
    inputs_embeds: Tensor | NestedTensor | None = None,
    encoder_hidden_states: Tensor | None = None,
    encoder_attention_mask: Tensor | None = None,
    past_key_values: Cache | None = None,
    use_cache: bool | None = None,
    cache_position: Tensor | None = None,
    **kwargs: Unpack[TransformersKwargs],
) -> tuple[Tensor, ...] | BaseModelOutputWithPoolingAndCrossAttentions:
    r"""
    Args:
        encoder_hidden_states:
            Shape: `(batch_size, sequence_length, hidden_size)`

            Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if
            the model is configured as a decoder.
        encoder_attention_mask:
            Shape: `(batch_size, sequence_length)`

            Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used
            in the cross-attention if the model is configured as a decoder. Mask values selected in `[0, 1]`:

            - 1 for tokens that are **not masked**,
            - 0 for tokens that are **masked**.
        past_key_values:
            Tuple of length `config.n_layers` with each tuple having 4 tensors of shape
            `(batch_size, num_heads, sequence_length - 1, embed_size_per_head)

            Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up
            decoding.

            If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those
            that don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of
            all `decoder_input_ids` of shape `(batch_size, sequence_length)`.
        use_cache:
            If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding
            (see `past_key_values`).
    """
    if self.config.is_decoder:
        use_cache = use_cache if use_cache is not None else self.config.use_cache
    else:
        use_cache = False
    if use_cache and past_key_values is None:
        past_key_values = (
            EncoderDecoderCache(DynamicCache(config=self.config), DynamicCache(config=self.config))
            if encoder_hidden_states is not None or self.config.is_encoder_decoder
            else DynamicCache(config=self.config)
        )

    if isinstance(input_ids, NestedTensor) and attention_mask is None:
        attention_mask = input_ids.mask
    if (input_ids is None) ^ (inputs_embeds is not None):
        raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
    if input_ids is not None:
        device = input_ids.device
        seq_length = input_ids.shape[1]
    else:
        device = inputs_embeds.device  # type: ignore[union-attr]
        seq_length = inputs_embeds.shape[1]  # type: ignore[union-attr]

    # past_key_values_length
    past_key_values_length = past_key_values.get_seq_length() if past_key_values is not None else 0
    if cache_position is None:
        cache_position = torch.arange(past_key_values_length, past_key_values_length + seq_length, device=device)

    if attention_mask is None and input_ids is not None and self.pad_token_id is not None:
        attention_mask = input_ids.ne(self.pad_token_id)

    embedding_output = self.embeddings(
        input_ids=input_ids,
        inputs_embeds=inputs_embeds,
    )
    attention_mask, encoder_attention_mask = self._create_attention_masks(
        attention_mask=attention_mask,
        encoder_attention_mask=encoder_attention_mask,
        embedding_output=embedding_output,
        encoder_hidden_states=encoder_hidden_states,
        cache_position=cache_position,
        past_key_values=past_key_values,
    )
    encoder_outputs = self.encoder(
        embedding_output,
        attention_mask,
        encoder_hidden_states,
        encoder_attention_mask=encoder_attention_mask,
        past_key_values=past_key_values,
        use_cache=use_cache,
        cache_position=cache_position,
        **kwargs,
    )
    sequence_output = encoder_outputs.last_hidden_state
    pooled_output = self.pooler(sequence_output) if self.pooler is not None else None

    return BaseModelOutputWithPoolingAndCrossAttentions(
        last_hidden_state=sequence_output,
        pooler_output=pooled_output,
        past_key_values=encoder_outputs.past_key_values,
    )

DnaBert2PreTrainedModel

Bases: PreTrainedModel

An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained models.

Source code in multimolecule/models/dnabert2/modeling_dnabert2.py
Python
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
class DnaBert2PreTrainedModel(PreTrainedModel):
    """
    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
    models.
    """

    config_class = DnaBert2Config
    base_model_prefix = "model"
    supports_gradient_checkpointing = True
    _supports_flash_attn = True
    _supports_sdpa = True
    _supports_flex_attn = True
    _supports_attention_backend = True
    _can_record_outputs: dict[str, Any] | None = None
    _no_split_modules = ["DnaBert2Layer", "DnaBert2Embeddings"]

    @torch.no_grad()
    def _init_weights(self, module: nn.Module):
        super()._init_weights(module)