CaLM
Pre-trained model on protein-coding DNA (cDNA) using a masked language modeling (MLM) objective.
Statement
Codon language embeddings provide strong signals for use in protein engineering is published in Nature Machine Intelligence, which is a Closed Access / Author-Fee journal.
Machine learning has been at the forefront of the movement for free and open access to research.
We see no role for closed access or author-fee publication in the future of machine learning research and believe the adoption of these journals as an outlet of record for the machine learning community would be a retrograde step.
The MultiMolecule team is committed to the principles of open access and open science.
We do NOT endorse the publication of manuscripts in Closed Access / Author-Fee journals and encourage the community to support Open Access journals and conferences.
Please consider signing the Statement on Nature Machine Intelligence.
Disclaimer
This is an UNOFFICIAL implementation of the Codon language embeddings provide strong signals for use in protein engineering by Carlos Outeiral and Charlotte M. Deane.
The OFFICIAL repository of CaLM is at oxpig/CaLM.
Warning
The MultiMolecule team is unable to confirm that the provided model and checkpoints are producing the same intermediate representations as the original implementation.
This is because
The proposed method is published in a Closed Access / Author-Fee journal.
The team releasing CaLM did not write this model card for this model so this model card has been written by the MultiMolecule team.
Model Details
CaLM is a bert-style model pre-trained on a large corpus of protein-coding DNA 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 |
85.75 |
22.36 |
11.17 |
1024 |
Links
Usage
The model file depends on the multimolecule library. You can install it using pip:
| Bash |
|---|
| pip install multimolecule
|
Direct Use
You can use this model directly with a pipeline for masked language modeling:
| Python |
|---|
| >>> import multimolecule # you must import multimolecule to register models
>>> from transformers import pipeline
>>> unmasker = pipeline("fill-mask", model="multimolecule/calm")
>>> unmasker("agc<mask>cattatggcgaaccttggctgctg")
[{'score': 0.011160684749484062,
'token': 100,
'token_str': 'UUN',
'sequence': 'AGC UUN CAU UAU GGC GAA CCU UGG CUG CUG'},
{'score': 0.01067513320595026,
'token': 117,
'token_str': 'NGC',
'sequence': 'AGC NGC CAU UAU GGC GAA CCU UGG CUG CUG'},
{'score': 0.010549729689955711,
'token': 127,
'token_str': 'NNC',
'sequence': 'AGC NNC CAU UAU GGC GAA CCU UGG CUG CUG'},
{'score': 0.0103579331189394,
'token': 51,
'token_str': 'CNA',
'sequence': 'AGC CNA CAU UAU GGC GAA CCU UGG CUG CUG'},
{'score': 0.010322545655071735,
'token': 77,
'token_str': 'GNC',
'sequence': 'AGC GNC CAU UAU GGC GAA CCU UGG CUG CUG'}]
|
Downstream Use
Here is how to use this model to get the features of a given sequence in PyTorch:
| Python |
|---|
| from multimolecule import RnaTokenizer, CaLmModel
tokenizer = RnaTokenizer.from_pretrained("multimolecule/calm")
model = CaLmModel.from_pretrained("multimolecule/calm")
text = "GCCAGTCGCTGACAGCCGCGG"
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 |
|---|
| import torch
from multimolecule import RnaTokenizer, CaLmForSequencePrediction
tokenizer = RnaTokenizer.from_pretrained("multimolecule/calm")
model = CaLmForSequencePrediction.from_pretrained("multimolecule/calm")
text = "GCCAGTCGCTGACAGCCGCGG"
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 nucleotide classification or regression.
Here is how to use this model as backbone to fine-tune for a nucleotide-level task in PyTorch:
| Python |
|---|
| import torch
from multimolecule import RnaTokenizer, CaLmForTokenPrediction
tokenizer = RnaTokenizer.from_pretrained("multimolecule/calm")
model = CaLmForTokenPrediction.from_pretrained("multimolecule/calm")
text = "GCCAGTCGCTGACAGCCGCGG"
input = tokenizer(text, return_tensors="pt")
label = torch.randint(2, (len(text), ))
output = model(**input, labels=label)
|
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 |
|---|
| import torch
from multimolecule import RnaTokenizer, CaLmForContactPrediction
tokenizer = RnaTokenizer.from_pretrained("multimolecule/calm")
model = CaLmForContactPrediction.from_pretrained("multimolecule/calm")
text = "GCCAGTCGCTGACAGCCGCGG"
input = tokenizer(text, return_tensors="pt")
label = torch.randint(2, (len(text), len(text)))
output = model(**input, labels=label)
|
Training Details
CaLM used Masked Language Modeling (MLM) as the pre-training objective: taking a sequence, the model randomly masks 25% 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 CaLM model was pre-trained coding sequences of all organisms available on the European Nucleotide Archive (ENA). European Nucleotide Archive provides a comprehensive record of the world’s nucleotide sequencing information, covering raw sequencing data, sequence assembly information and functional annotation.
CaLM collected coding sequences of all organisms from ENA on April 2022, including 114,214,475 sequences. Only high level assembly information (dataclass CON) were used. Sequences matching the following criteria were filtered out:
- with unknown nucleotides (
N, Y, R)
- start codon is not
ATG
- contains interstitial stop codons
- number of nucleotides is not a multiple of three
To reduce redundancy, CaLM grouped the entries by organism, and apply CD-HIT (CD-HIT-EST) with a cut-off at 40% sequence identity to the translated protein sequences.
The final dataset contains 9,858,385 cDNA sequences.
Note that the alphabet in the original implementation is RNA instead of DNA, therefore, we use RnaTokenizer to tokenize the sequences. RnaTokenizer of multimolecule will convert “U”s to “T”s for you, you may disable this behaviour by passing replace_T_with_U=False.
Training Procedure
Preprocessing
CaLM used masked language modeling (MLM) as the pre-training objective. The masking procedure is similar to the one used in BERT:
- 25% of the tokens are masked.
- In 80% of the cases, the masked tokens are replaced by
<mask>.
- In 10% of the cases, the masked tokens are replaced by a random token (different) from the one they replace.
- In the 10% remaining cases, the masked tokens are left as is.
PreTraining
The model was trained on 4 NVIDIA Quadro RTX4000 GPUs with 8GiB memories.
- Learning rate: 1e-4
- Optimizer: AdamW
- Learning rate scheduler: cosine
- Learning rate warm-up: 1,000 steps
- Epochs: 14
- Batch Size: 1,000
Citation
BibTeX:
| BibTeX |
|---|
| @article {outeiral2022coodn,
author = {Outeiral, Carlos and Deane, Charlotte M.},
title = {Codon language embeddings provide strong signals for protein engineering},
elocation-id = {2022.12.15.519894},
year = {2022},
doi = {10.1101/2022.12.15.519894},
publisher = {Cold Spring Harbor Laboratory},
abstract = {Protein representations from deep language models have yielded state-of-the-art performance across many tasks in computational protein engineering. In recent years, progress has primarily focused on parameter count, with recent models{\textquoteright} capacities surpassing the size of the very datasets they were trained on. Here, we propose an alternative direction. We show that large language models trained on codons, instead of amino acid sequences, provide high-quality representations that outperform comparable state-of-the-art models across a variety of tasks. In some tasks, like species recognition, prediction of protein and transcript abundance, or melting point estimation, we show that a language model trained on codons outperforms every other published protein language model, including some that contain over 50 times more parameters. These results suggest that, in addition to commonly studied scale and model complexity, the information content of biological data provides an orthogonal direction to improve the power of machine learning in biology.Competing Interest StatementThe authors have declared no competing interest.},
URL = {https://www.biorxiv.org/content/early/2022/12/19/2022.12.15.519894},
eprint = {https://www.biorxiv.org/content/early/2022/12/19/2022.12.15.519894.full.pdf},
journal = {bioRxiv}
}
|
Please use GitHub issues of MultiMolecule for any questions or comments on the model card.
Please contact the authors of the CaLM paper for questions or comments on the paper/model.
License
This model is licensed under the AGPL-3.0 License.
| Text Only |
|---|
| SPDX-License-Identifier: AGPL-3.0-or-later
|
Bases: Tokenizer
Tokenizer for RNA sequences.
Parameters:
| Name |
Type |
Description |
Default |
alphabet
|
Alphabet | str | List[str] | None
|
alphabet to use for tokenization.
- If is
None, the standard RNA alphabet will be used.
- If is a
string, it should correspond to the name of a predefined alphabet. The options include
standardextendedstreamlinenucleobase
- If is an alphabet or a list of characters, that specific alphabet will be used.
|
None
|
nmers
|
int
|
Size of kmer to tokenize.
|
1
|
codon
|
bool
|
Whether to tokenize into codons.
|
False
|
replace_T_with_U
|
bool
|
Whether to replace T with U.
|
True
|
do_upper_case
|
bool
|
Whether to convert input to uppercase.
|
True
|
Examples:
Python Console Session>>> from multimolecule import RnaTokenizer
>>> tokenizer = RnaTokenizer()
>>> tokenizer('<pad><cls><eos><unk><mask><null>ACGUNRYSWKMBDHV.X*-I')["input_ids"]
[1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 2]
>>> tokenizer('acgu')["input_ids"]
[1, 6, 7, 8, 9, 2]
>>> tokenizer('acgt')["input_ids"]
[1, 6, 7, 8, 9, 2]
>>> tokenizer = RnaTokenizer(replace_T_with_U=False)
>>> tokenizer('acgt')["input_ids"]
[1, 6, 7, 8, 3, 2]
>>> tokenizer = RnaTokenizer(nmers=3)
>>> tokenizer('uagcuuauc')["input_ids"]
[1, 83, 17, 64, 49, 96, 84, 22, 2]
>>> tokenizer = RnaTokenizer(codon=True)
>>> tokenizer('uagcuuauc')["input_ids"]
[1, 83, 49, 22, 2]
>>> tokenizer('uagcuuauca')["input_ids"]
Traceback (most recent call last):
ValueError: length of input sequence must be a multiple of 3 for codon tokenization, but got 10
Source code in multimolecule/tokenisers/rna/tokenization_rna.py
| Python |
|---|
| class RnaTokenizer(Tokenizer):
"""
Tokenizer for RNA sequences.
Args:
alphabet: alphabet to use for tokenization.
- If is `None`, the standard RNA alphabet will be used.
- If is a `string`, it should correspond to the name of a predefined alphabet. The options include
+ `standard`
+ `extended`
+ `streamline`
+ `nucleobase`
- If is an alphabet or a list of characters, that specific alphabet will be used.
nmers: Size of kmer to tokenize.
codon: Whether to tokenize into codons.
replace_T_with_U: Whether to replace T with U.
do_upper_case: Whether to convert input to uppercase.
Examples:
>>> from multimolecule import RnaTokenizer
>>> tokenizer = RnaTokenizer()
>>> tokenizer('<pad><cls><eos><unk><mask><null>ACGUNRYSWKMBDHV.X*-I')["input_ids"]
[1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 2]
>>> tokenizer('acgu')["input_ids"]
[1, 6, 7, 8, 9, 2]
>>> tokenizer('acgt')["input_ids"]
[1, 6, 7, 8, 9, 2]
>>> tokenizer = RnaTokenizer(replace_T_with_U=False)
>>> tokenizer('acgt')["input_ids"]
[1, 6, 7, 8, 3, 2]
>>> tokenizer = RnaTokenizer(nmers=3)
>>> tokenizer('uagcuuauc')["input_ids"]
[1, 83, 17, 64, 49, 96, 84, 22, 2]
>>> tokenizer = RnaTokenizer(codon=True)
>>> tokenizer('uagcuuauc')["input_ids"]
[1, 83, 49, 22, 2]
>>> tokenizer('uagcuuauca')["input_ids"]
Traceback (most recent call last):
ValueError: length of input sequence must be a multiple of 3 for codon tokenization, but got 10
"""
model_input_names = ["input_ids", "attention_mask"]
def __init__(
self,
alphabet: Alphabet | str | List[str] | None = None,
nmers: int = 1,
codon: bool = False,
replace_T_with_U: bool = True,
do_upper_case: bool = True,
additional_special_tokens: List | Tuple | None = None,
**kwargs,
):
if codon and (nmers > 1 and nmers != 3):
raise ValueError("Codon and nmers cannot be used together.")
if codon:
nmers = 3 # set to 3 to get correct vocab
if not isinstance(alphabet, Alphabet):
alphabet = get_alphabet(alphabet, nmers=nmers)
super().__init__(
alphabet=alphabet,
nmers=nmers,
codon=codon,
replace_T_with_U=replace_T_with_U,
do_upper_case=do_upper_case,
additional_special_tokens=additional_special_tokens,
**kwargs,
)
self.replace_T_with_U = replace_T_with_U
self.nmers = nmers
self.condon = codon
def _tokenize(self, text: str, **kwargs):
if self.do_upper_case:
text = text.upper()
if self.replace_T_with_U:
text = text.replace("T", "U")
if self.condon:
if len(text) % 3 != 0:
raise ValueError(
f"length of input sequence must be a multiple of 3 for codon tokenization, but got {len(text)}"
)
return [text[i : i + 3] for i in range(0, len(text), 3)]
if self.nmers > 1:
return [text[i : i + self.nmers] for i in range(len(text) - self.nmers + 1)] # noqa: E203
return list(text)
|
Bases: PreTrainedConfig
This is the configuration class to store the configuration of a CaLmModel. It
is used to instantiate a CaLM 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 CaLM
oxpig/CaLM 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 CaLM model. Defines the number of different tokens that can be represented by the
inputs_ids passed when calling [CaLmModel].
|
131
|
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
|
|
|
int
|
Dimensionality of the “intermediate” (often named feed-forward) layer in the Transformer encoder.
|
3072
|
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.1
|
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).
|
1026
|
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
|
|
'rotary'
|
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
|
emb_layer_norm_before
|
bool
|
Whether to apply layer normalization after embeddings but before the main stem of the network.
|
False
|
token_dropout
|
bool
|
When this is enabled, masked tokens are treated as if they had been dropped out by input dropout.
|
False
|
Examples:
Python Console Session>>> from multimolecule import CaLmModel, CaLmConfig
>>> # Initializing a CaLM multimolecule/calm style configuration
>>> configuration = CaLmConfig()
>>> # Initializing a model (with random weights) from the multimolecule/calm style configuration
>>> model = CaLmModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
Source code in multimolecule/models/calm/configuration_calm.py
| Python |
|---|
| class CaLmConfig(PreTrainedConfig):
r"""
This is the configuration class to store the configuration of a [`CaLmModel`][multimolecule.models.CaLmModel]. It
is used to instantiate a CaLM 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 CaLM
[oxpig/CaLM](https://github.com/oxpig/CaLM) 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 CaLM model. Defines the number of different tokens that can be represented by the
`inputs_ids` passed when calling [`CaLmModel`].
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_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. Choose one of `"absolute"`, `"relative_key"`, `"relative_key_query", "rotary"`.
For positional embeddings use `"absolute"`. For more information on `"relative_key"`, please refer to
[Self-Attention with Relative Position Representations (Shaw et al.)](https://arxiv.org/abs/1803.02155).
For more information on `"relative_key_query"`, please refer to *Method 4* in [Improve Transformer Models
with Better Relative Position Embeddings (Huang et al.)](https://arxiv.org/abs/2009.13658).
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`.
emb_layer_norm_before:
Whether to apply layer normalization after embeddings but before the main stem of the network.
token_dropout:
When this is enabled, masked tokens are treated as if they had been dropped out by input dropout.
Examples:
>>> from multimolecule import CaLmModel, CaLmConfig
>>> # Initializing a CaLM multimolecule/calm style configuration
>>> configuration = CaLmConfig()
>>> # Initializing a model (with random weights) from the multimolecule/calm style configuration
>>> model = CaLmModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
"""
model_type = "calm"
def __init__(
self,
vocab_size: int = 131,
codon: bool = True,
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.1,
max_position_embeddings: int = 1026,
initializer_range: float = 0.02,
layer_norm_eps: float = 1e-12,
position_embedding_type: str = "rotary",
is_decoder: bool = False,
use_cache: bool = True,
emb_layer_norm_before: bool = False,
token_dropout: bool = False,
head: HeadConfig | None = None,
lm_head: MaskedLMHeadConfig | None = None,
**kwargs,
):
super().__init__(**kwargs)
self.vocab_size = vocab_size
self.codon = codon
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.is_decoder = is_decoder
self.use_cache = use_cache
self.emb_layer_norm_before = emb_layer_norm_before
self.token_dropout = token_dropout
self.head = HeadConfig(**head if head is not None else {})
self.lm_head = MaskedLMHeadConfig(**lm_head if lm_head is not None else {})
|
Bases: CaLmPreTrainedModel
Examples:
Python Console Session>>> from multimolecule import CaLmConfig, CaLmForContactPrediction, RnaTokenizer
>>> config = CaLmConfig()
>>> model = CaLmForContactPrediction(config)
>>> tokenizer = RnaTokenizer.from_pretrained("multimolecule/rna")
>>> input = tokenizer("ACGUN", return_tensors="pt")
>>> output = model(**input, labels=torch.randint(2, (1, 5, 5)))
>>> output["logits"].shape
torch.Size([1, 5, 5, 2])
>>> output["loss"]
tensor(..., grad_fn=<NllLossBackward0>)
Source code in multimolecule/models/calm/modeling_calm.py
| Python |
|---|
| class CaLmForContactPrediction(CaLmPreTrainedModel):
"""
Examples:
>>> from multimolecule import CaLmConfig, CaLmForContactPrediction, RnaTokenizer
>>> config = CaLmConfig()
>>> model = CaLmForContactPrediction(config)
>>> tokenizer = RnaTokenizer.from_pretrained("multimolecule/rna")
>>> input = tokenizer("ACGUN", return_tensors="pt")
>>> output = model(**input, labels=torch.randint(2, (1, 5, 5)))
>>> output["logits"].shape
torch.Size([1, 5, 5, 2])
>>> output["loss"] # doctest:+ELLIPSIS
tensor(..., grad_fn=<NllLossBackward0>)
"""
def __init__(self, config: CaLmConfig):
super().__init__(config)
self.calm = CaLmModel(config, add_pooling_layer=True)
self.contact_head = ContactPredictionHead(config)
self.head_config = self.contact_head.config
# Initialize weights and apply final processing
self.post_init()
def forward(
self,
input_ids: Tensor | NestedTensor,
attention_mask: Tensor | None = None,
position_ids: Tensor | None = None,
head_mask: Tensor | None = None,
inputs_embeds: Tensor | NestedTensor | None = None,
labels: Tensor | None = None,
output_attentions: bool | None = None,
output_hidden_states: bool | None = None,
return_dict: bool | None = None,
**kwargs,
) -> Tuple[Tensor, ...] | ContactPredictorOutput:
if output_attentions is False:
warn("output_attentions must be True for contact classification and will be ignored.")
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
outputs = self.calm(
input_ids,
attention_mask=attention_mask,
position_ids=position_ids,
head_mask=head_mask,
inputs_embeds=inputs_embeds,
output_attentions=True,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
**kwargs,
)
output = self.contact_head(outputs, attention_mask, input_ids, labels)
logits, loss = output.logits, output.loss
if not return_dict:
output = (logits,) + outputs[2:]
return ((loss,) + output) if loss is not None else output
return ContactPredictorOutput(
loss=loss,
logits=logits,
hidden_states=outputs.hidden_states,
attentions=outputs.attentions,
)
|
Bases: CaLmPreTrainedModel
Examples:
Python Console Session>>> from multimolecule import CaLmConfig, CaLmForMaskedLM, RnaTokenizer
>>> config = CaLmConfig()
>>> model = CaLmForMaskedLM(config)
>>> tokenizer = RnaTokenizer.from_pretrained("multimolecule/rna")
>>> input = tokenizer("ACGUN", return_tensors="pt")
>>> output = model(**input, labels=input["input_ids"])
>>> output["logits"].shape
torch.Size([1, 7, 131])
>>> output["loss"]
tensor(..., grad_fn=<NllLossBackward0>)
Source code in multimolecule/models/calm/modeling_calm.py
| Python |
|---|
| class CaLmForMaskedLM(CaLmPreTrainedModel):
"""
Examples:
>>> from multimolecule import CaLmConfig, CaLmForMaskedLM, RnaTokenizer
>>> config = CaLmConfig()
>>> model = CaLmForMaskedLM(config)
>>> tokenizer = RnaTokenizer.from_pretrained("multimolecule/rna")
>>> input = tokenizer("ACGUN", return_tensors="pt")
>>> output = model(**input, labels=input["input_ids"])
>>> output["logits"].shape
torch.Size([1, 7, 131])
>>> output["loss"] # doctest:+ELLIPSIS
tensor(..., grad_fn=<NllLossBackward0>)
"""
_tied_weights_keys = ["lm_head.decoder.weight", "lm_head.decoder.bias"]
def __init__(self, config: CaLmConfig):
super().__init__(config)
if config.is_decoder:
logger.warning(
"If you want to use `CaLmForMaskedLM` make sure `config.is_decoder=False` for "
"bi-directional self-attention."
)
self.calm = CaLmModel(config, add_pooling_layer=False)
self.lm_head = MaskedLMHead(config, self.calm.embeddings.word_embeddings.weight)
# Initialize weights and apply final processing
self.post_init()
def forward(
self,
input_ids: Tensor | NestedTensor,
attention_mask: Tensor | None = None,
position_ids: Tensor | None = None,
head_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,
output_attentions: bool | None = None,
output_hidden_states: bool | None = None,
return_dict: bool | None = None,
**kwargs,
) -> Tuple[Tensor, ...] | MaskedLMOutput:
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
outputs = self.calm(
input_ids,
attention_mask=attention_mask,
position_ids=position_ids,
head_mask=head_mask,
inputs_embeds=inputs_embeds,
encoder_hidden_states=encoder_hidden_states,
encoder_attention_mask=encoder_attention_mask,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
**kwargs,
)
output = self.lm_head(outputs, labels)
logits, loss = output.logits, output.loss
if not return_dict:
output = (logits,) + outputs[2:]
return ((loss,) + output) if loss is not None else output
return MaskedLMOutput(
loss=loss,
logits=logits,
hidden_states=outputs.hidden_states,
attentions=outputs.attentions,
)
|
Bases: CaLmPreTrainedModel
Examples:
Python Console Session>>> from multimolecule import CaLmConfig, CaLmForSequencePrediction, RnaTokenizer
>>> config = CaLmConfig()
>>> model = CaLmForSequencePrediction(config)
>>> tokenizer = RnaTokenizer.from_pretrained("multimolecule/rna")
>>> input = tokenizer("ACGUN", return_tensors="pt")
>>> output = model(**input, labels=torch.tensor([[1]]))
>>> output["logits"].shape
torch.Size([1, 2])
>>> output["loss"]
tensor(..., grad_fn=<NllLossBackward0>)
Source code in multimolecule/models/calm/modeling_calm.py
| Python |
|---|
| class CaLmForSequencePrediction(CaLmPreTrainedModel):
"""
Examples:
>>> from multimolecule import CaLmConfig, CaLmForSequencePrediction, RnaTokenizer
>>> config = CaLmConfig()
>>> model = CaLmForSequencePrediction(config)
>>> tokenizer = RnaTokenizer.from_pretrained("multimolecule/rna")
>>> input = tokenizer("ACGUN", return_tensors="pt")
>>> output = model(**input, labels=torch.tensor([[1]]))
>>> output["logits"].shape
torch.Size([1, 2])
>>> output["loss"] # doctest:+ELLIPSIS
tensor(..., grad_fn=<NllLossBackward0>)
"""
def __init__(self, config: CaLmConfig):
super().__init__(config)
self.calm = CaLmModel(config, add_pooling_layer=True)
self.sequence_head = SequencePredictionHead(config)
self.head_config = self.sequence_head.config
# Initialize weights and apply final processing
self.post_init()
def forward(
self,
input_ids: Tensor | NestedTensor,
attention_mask: Tensor | None = None,
position_ids: Tensor | None = None,
head_mask: Tensor | None = None,
inputs_embeds: Tensor | NestedTensor | None = None,
labels: Tensor | None = None,
output_attentions: bool | None = None,
output_hidden_states: bool | None = None,
return_dict: bool | None = None,
**kwargs,
) -> Tuple[Tensor, ...] | SequencePredictorOutput:
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
outputs = self.calm(
input_ids,
attention_mask=attention_mask,
position_ids=position_ids,
head_mask=head_mask,
inputs_embeds=inputs_embeds,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
**kwargs,
)
output = self.sequence_head(outputs, labels)
logits, loss = output.logits, output.loss
if not return_dict:
output = (logits,) + outputs[2:]
return ((loss,) + output) if loss is not None else output
return SequencePredictorOutput(
loss=loss,
logits=logits,
hidden_states=outputs.hidden_states,
attentions=outputs.attentions,
)
|
Bases: CaLmPreTrainedModel
Examples:
Python Console Session>>> from multimolecule import CaLmConfig, CaLmForTokenPrediction, RnaTokenizer
>>> config = CaLmConfig()
>>> model = CaLmForTokenPrediction(config)
>>> tokenizer = RnaTokenizer.from_pretrained("multimolecule/rna")
>>> input = tokenizer("ACGUN", return_tensors="pt")
>>> output = model(**input, labels=torch.randint(2, (1, 5)))
>>> output["logits"].shape
torch.Size([1, 5, 2])
>>> output["loss"]
tensor(..., grad_fn=<NllLossBackward0>)
Source code in multimolecule/models/calm/modeling_calm.py
| Python |
|---|
| class CaLmForTokenPrediction(CaLmPreTrainedModel):
"""
Examples:
>>> from multimolecule import CaLmConfig, CaLmForTokenPrediction, RnaTokenizer
>>> config = CaLmConfig()
>>> model = CaLmForTokenPrediction(config)
>>> tokenizer = RnaTokenizer.from_pretrained("multimolecule/rna")
>>> input = tokenizer("ACGUN", return_tensors="pt")
>>> output = model(**input, labels=torch.randint(2, (1, 5)))
>>> output["logits"].shape
torch.Size([1, 5, 2])
>>> output["loss"] # doctest:+ELLIPSIS
tensor(..., grad_fn=<NllLossBackward0>)
"""
def __init__(self, config: CaLmConfig):
super().__init__(config)
self.calm = CaLmModel(config, add_pooling_layer=True)
self.token_head = TokenPredictionHead(config)
self.head_config = self.token_head.config
# Initialize weights and apply final processing
self.post_init()
def forward(
self,
input_ids: Tensor | NestedTensor,
attention_mask: Tensor | None = None,
position_ids: Tensor | None = None,
head_mask: Tensor | None = None,
inputs_embeds: Tensor | NestedTensor | None = None,
labels: Tensor | None = None,
output_attentions: bool | None = None,
output_hidden_states: bool | None = None,
return_dict: bool | None = None,
**kwargs,
) -> Tuple[Tensor, ...] | TokenPredictorOutput:
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
outputs = self.calm(
input_ids,
attention_mask=attention_mask,
position_ids=position_ids,
head_mask=head_mask,
inputs_embeds=inputs_embeds,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
**kwargs,
)
output = self.token_head(outputs, attention_mask, input_ids, labels)
logits, loss = output.logits, output.loss
if not return_dict:
output = (logits,) + outputs[2:]
return ((loss,) + output) if loss is not None else output
return TokenPredictorOutput(
loss=loss,
logits=logits,
hidden_states=outputs.hidden_states,
attentions=outputs.attentions,
)
|
Bases: CaLmPreTrainedModel
Examples:
Python Console Session>>> from multimolecule import CaLmConfig, CaLmModel, RnaTokenizer
>>> config = CaLmConfig()
>>> model = CaLmModel(config)
>>> tokenizer = RnaTokenizer.from_pretrained("multimolecule/rna")
>>> input = tokenizer("ACGUN", return_tensors="pt")
>>> output = model(**input)
>>> output["last_hidden_state"].shape
torch.Size([1, 7, 768])
>>> output["pooler_output"].shape
torch.Size([1, 768])
Source code in multimolecule/models/calm/modeling_calm.py
| Python |
|---|
| class CaLmModel(CaLmPreTrainedModel):
"""
Examples:
>>> from multimolecule import CaLmConfig, CaLmModel, RnaTokenizer
>>> config = CaLmConfig()
>>> model = CaLmModel(config)
>>> tokenizer = RnaTokenizer.from_pretrained("multimolecule/rna")
>>> input = tokenizer("ACGUN", return_tensors="pt")
>>> output = model(**input)
>>> output["last_hidden_state"].shape
torch.Size([1, 7, 768])
>>> output["pooler_output"].shape
torch.Size([1, 768])
"""
def __init__(self, config: CaLmConfig, add_pooling_layer: bool = True):
super().__init__(config)
self.pad_token_id = config.pad_token_id
self.embeddings = CaLmEmbeddings(config)
self.encoder = CaLmEncoder(config)
self.pooler = CaLmPooler(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
def _prune_heads(self, heads_to_prune):
"""
Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
class PreTrainedModel
"""
for layer, heads in heads_to_prune.items():
self.encoder.layer[layer].attention.prune_heads(heads)
def forward(
self,
input_ids: Tensor | NestedTensor,
attention_mask: Tensor | None = None,
position_ids: Tensor | None = None,
head_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: Tuple[Tuple[Tensor, Tensor, Tensor, Tensor], ...] | None = None,
use_cache: bool | None = None,
output_attentions: bool | None = None,
output_hidden_states: bool | None = None,
return_dict: bool | None = None,
**kwargs,
) -> 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 kwargs:
warn(
f"Additional keyword arguments `{', '.join(kwargs)}` are detected in "
f"`{self.__class__.__name__}.forward`, they will be ignored.\n"
"This is provided for backward compatibility and may lead to unexpected behavior."
)
output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
output_hidden_states = (
output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
)
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
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 isinstance(input_ids, NestedTensor):
input_ids, attention_mask = input_ids.tensor, input_ids.mask
if input_ids is not None and inputs_embeds is not None:
raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
if input_ids is not None:
self.warn_if_padding_and_no_attention_mask(input_ids, attention_mask)
input_shape = input_ids.size()
elif inputs_embeds is not None:
input_shape = inputs_embeds.size()[:-1]
else:
raise ValueError("You have to specify either input_ids or inputs_embeds")
batch_size, seq_length = input_shape
device = input_ids.device if input_ids is not None else inputs_embeds.device # type: ignore[union-attr]
# past_key_values_length
past_key_values_length = past_key_values[0][0].shape[2] if past_key_values is not None else 0
if attention_mask is None:
attention_mask = (
input_ids.ne(self.pad_token_id)
if self.pad_token_id is not None
else torch.ones(((batch_size, seq_length + past_key_values_length)), device=device)
)
# We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
# ourselves in which case we just need to make it broadcastable to all heads.
extended_attention_mask: Tensor = self.get_extended_attention_mask(attention_mask, input_shape)
# If a 2D or 3D attention mask is provided for the cross-attention
# we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
if self.config.is_decoder and encoder_hidden_states is not None:
encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.size()
encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
if encoder_attention_mask is None:
encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device)
encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask)
else:
encoder_extended_attention_mask = None
# Prepare head mask if needed
# 1.0 in head_mask indicate we keep the head
# attention_probs has shape bsz x n_heads x N x N
# input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
# and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)
embedding_output = self.embeddings(
input_ids=input_ids,
position_ids=position_ids,
attention_mask=attention_mask,
inputs_embeds=inputs_embeds,
past_key_values_length=past_key_values_length,
)
encoder_outputs = self.encoder(
embedding_output,
attention_mask=extended_attention_mask,
head_mask=head_mask,
encoder_hidden_states=encoder_hidden_states,
encoder_attention_mask=encoder_extended_attention_mask,
past_key_values=past_key_values,
use_cache=use_cache,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
)
sequence_output = encoder_outputs[0]
pooled_output = self.pooler(sequence_output) if self.pooler is not None else None
if not return_dict:
return (sequence_output, pooled_output) + encoder_outputs[1:]
return BaseModelOutputWithPoolingAndCrossAttentions(
last_hidden_state=sequence_output,
pooler_output=pooled_output,
past_key_values=encoder_outputs.past_key_values,
hidden_states=encoder_outputs.hidden_states,
attentions=encoder_outputs.attentions,
cross_attentions=encoder_outputs.cross_attentions,
)
|
| Python |
|---|
| forward(input_ids: Tensor | NestedTensor, attention_mask: Tensor | None = None, position_ids: Tensor | None = None, head_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: Tuple[Tuple[Tensor, Tensor, Tensor, Tensor], ...] | None = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) -> 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
|
Tuple[Tuple[Tensor, Tensor, Tensor, Tensor], ...] | 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/calm/modeling_calm.py
| Python |
|---|
| def forward(
self,
input_ids: Tensor | NestedTensor,
attention_mask: Tensor | None = None,
position_ids: Tensor | None = None,
head_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: Tuple[Tuple[Tensor, Tensor, Tensor, Tensor], ...] | None = None,
use_cache: bool | None = None,
output_attentions: bool | None = None,
output_hidden_states: bool | None = None,
return_dict: bool | None = None,
**kwargs,
) -> 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 kwargs:
warn(
f"Additional keyword arguments `{', '.join(kwargs)}` are detected in "
f"`{self.__class__.__name__}.forward`, they will be ignored.\n"
"This is provided for backward compatibility and may lead to unexpected behavior."
)
output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
output_hidden_states = (
output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
)
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
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 isinstance(input_ids, NestedTensor):
input_ids, attention_mask = input_ids.tensor, input_ids.mask
if input_ids is not None and inputs_embeds is not None:
raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
if input_ids is not None:
self.warn_if_padding_and_no_attention_mask(input_ids, attention_mask)
input_shape = input_ids.size()
elif inputs_embeds is not None:
input_shape = inputs_embeds.size()[:-1]
else:
raise ValueError("You have to specify either input_ids or inputs_embeds")
batch_size, seq_length = input_shape
device = input_ids.device if input_ids is not None else inputs_embeds.device # type: ignore[union-attr]
# past_key_values_length
past_key_values_length = past_key_values[0][0].shape[2] if past_key_values is not None else 0
if attention_mask is None:
attention_mask = (
input_ids.ne(self.pad_token_id)
if self.pad_token_id is not None
else torch.ones(((batch_size, seq_length + past_key_values_length)), device=device)
)
# We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
# ourselves in which case we just need to make it broadcastable to all heads.
extended_attention_mask: Tensor = self.get_extended_attention_mask(attention_mask, input_shape)
# If a 2D or 3D attention mask is provided for the cross-attention
# we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
if self.config.is_decoder and encoder_hidden_states is not None:
encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.size()
encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
if encoder_attention_mask is None:
encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device)
encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask)
else:
encoder_extended_attention_mask = None
# Prepare head mask if needed
# 1.0 in head_mask indicate we keep the head
# attention_probs has shape bsz x n_heads x N x N
# input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
# and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)
embedding_output = self.embeddings(
input_ids=input_ids,
position_ids=position_ids,
attention_mask=attention_mask,
inputs_embeds=inputs_embeds,
past_key_values_length=past_key_values_length,
)
encoder_outputs = self.encoder(
embedding_output,
attention_mask=extended_attention_mask,
head_mask=head_mask,
encoder_hidden_states=encoder_hidden_states,
encoder_attention_mask=encoder_extended_attention_mask,
past_key_values=past_key_values,
use_cache=use_cache,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
)
sequence_output = encoder_outputs[0]
pooled_output = self.pooler(sequence_output) if self.pooler is not None else None
if not return_dict:
return (sequence_output, pooled_output) + encoder_outputs[1:]
return BaseModelOutputWithPoolingAndCrossAttentions(
last_hidden_state=sequence_output,
pooler_output=pooled_output,
past_key_values=encoder_outputs.past_key_values,
hidden_states=encoder_outputs.hidden_states,
attentions=encoder_outputs.attentions,
cross_attentions=encoder_outputs.cross_attentions,
)
|
Bases: PreTrainedModel
An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
models.
Source code in multimolecule/models/calm/modeling_calm.py
| Python |
|---|
| class CaLmPreTrainedModel(PreTrainedModel):
"""
An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
models.
"""
config_class = CaLmConfig
base_model_prefix = "calm"
supports_gradient_checkpointing = True
_no_split_modules = ["CaLmLayer", "CaLmEmbeddings"]
# Copied from transformers.models.bert.modeling_bert.BertPreTrainedModel._init_weights
def _init_weights(self, module: nn.Module):
"""Initialize the weights"""
if isinstance(module, nn.Linear):
# Slightly different from the TF version which uses truncated_normal for initialization
# cf https://github.com/pytorch/pytorch/pull/5617
module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
if module.bias is not None:
module.bias.data.zero_()
elif isinstance(module, nn.Embedding):
module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
if module.padding_idx is not None:
module.weight.data[module.padding_idx].zero_()
elif isinstance(module, nn.LayerNorm):
module.bias.data.zero_()
module.weight.data.fill_(1.0)
|