ESM2-150M
Model overview
Synthyra/ESM2-150M packages the facebook/esm2_t30_150M_UR50D checkpoint
with the FastPLMs runtime for Hugging Face Transformers. It accepts amino-acid
sequences tokenized to residue IDs.
The repository uses the standard Transformers loading interface with
trust_remote_code=True. See Technical details for each registered class and
whether its weights come from the checkpoint.
The sequence- and token-classification classes reuse the pretrained backbone, but their task heads are newly initialized. Fine-tune those heads before interpreting their logits as predictions.
Install and platform requirements
Install the direct dependencies published with this model:
python -m pip install -r \
"https://huggingface.co/Synthyra/ESM2-150M/resolve/main/requirements.txt"
The FastPLMs implementation itself is embedded in the model repository.
Transformers loads it through trust_remote_code=True.
This model requires Python 3.12-3.14, PyTorch 2.14, and Transformers 5.17.
The artifact requirements include the FlashAttention loader dependency. FlashAttention also requires compatible CUDA hardware and BF16 execution.
The Hub quick start needs network access for the first download. For an air-gapped run, build the manifest-pinned local artifact first and use the offline example.
Quick start
from transformers import AutoModel
model_id = "Synthyra/ESM2-150M"
model = AutoModel.from_pretrained(
model_id,
trust_remote_code=True,
attn_implementation="sdpa",
).eval()
For offline validation, replace model_id with the manifest-built
dist/hub/ESM2-150M path. Pass local_files_only=True.
Attention backends
The quick start uses sdpa.
Available backends are eager, sdpa, flex_attention, flash_attention_2,
flash_attention_3. Requesting an unavailable backend raises instead of
silently changing implementation.
output_attentions=True can use the documented one-call eager fallback to
materialize attention tensors. The configured backend does not change.
Tokenization and forward inference
Load the tokenizer from the same artifact as the model. The attention mask shows padding explicitly:
import torch
from transformers import AutoTokenizer
model_id = "Synthyra/ESM2-150M"
tokenizer = AutoTokenizer.from_pretrained(
model_id,
trust_remote_code=True,
)
batch = tokenizer(
["MSTNPKPQRKTKRNT", "MKTIIALSYIFCLVFA"],
padding=True,
return_tensors="pt",
)
with torch.inference_mode():
output = model(**batch)
print(output.last_hidden_state.shape)
Dataset embeddings
The shared embedding mixin keeps input order and biological-position masking. It accepts sequences, identified records, mappings, or a FASTA path:
pooled = model.embed_dataset(
["MSTNPKPQRKTKRNT", "MKTIIALSYIFCLVFA"],
batch_size=2,
pooling=("mean", "std"),
)
residues = model.embed_dataset(
["MSTNPKPQRKTKRNT"],
full_embeddings=True,
)
print(pooled[0].tensor.shape) # (2 * d,)
print(residues[0].tensor.shape) # (l, d)
Set output and format="safetensors" or "sqlite" for transactional,
bounded-memory storage. Resume checks input order, model state, tokenizer
policy, backend, dtype, and pooling configuration before it appends data.
Downstream prediction
The sequence and token prediction AutoClasses use the checkpoint backbone and
create a new, untrained classifier. Sequence labels have shape (b,).
Residue labels have shape (b, l) and use -100 outside biological positions.
import torch
from transformers import AutoTokenizer
from transformers import (
AutoModelForSequenceClassification,
AutoModelForTokenClassification,
)
model_id = "Synthyra/ESM2-150M"
sequence_model = AutoModelForSequenceClassification.from_pretrained(
model_id, num_labels=2, trust_remote_code=True
).eval()
token_model = AutoModelForTokenClassification.from_pretrained(
model_id, num_labels=3, trust_remote_code=True
).eval()
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
sequences = ["MSTNPKPQRKTKRNT", "MKTIIALSYIFCLVFA"]
batch = tokenizer(sequences, padding=True, return_tensors="pt")
biological = batch["attention_mask"].bool() # (b, l)
for special_id in tokenizer.all_special_ids:
biological &= batch["input_ids"].ne(special_id) # (b, l)
sequence_labels = torch.zeros(len(sequences), dtype=torch.long) # (b,)
token_labels = torch.full_like(batch["input_ids"], -100) # (b, l)
token_labels[biological] = 0 # selected biological positions; labels stay (b, l)
with torch.inference_mode():
sequence_output = sequence_model(**batch, labels=sequence_labels)
token_output = token_model(**batch, labels=token_labels)
print(sequence_output.logits.shape) # (b, 2)
print(token_output.logits.shape) # (b, l, 3)
PEFT fine-tuning
Install the training dependencies. Then attach LoRA to the loaded checkpoint:
python -m pip install "datasets>=5.0" "peft>=0.21"
from peft import LoraConfig, TaskType, get_peft_model
peft_model = get_peft_model(
sequence_model,
LoraConfig(
task_type=TaskType.SEQ_CLS,
r=8,
lora_alpha=16,
target_modules="all-linear",
modules_to_save=["classifier"],
),
)
This checkpoint advertises a classification head. Save the separately trained
classifier with the adapter.
All FastPLMs checkpoints follow the Transformers PreTrainedModel contract and
can use PEFT. The ESM2-specific shipped CLI is an example, not a
support boundary. Record the target modules, base revision, data identity, and
trainable parameter scope.
Test-time training
TTT samples masked views of one protein and updates only injected low-rank adapters. Base checkpoint weights stay frozen:
from transformers import AutoModelForMaskedLM
ttt_model = AutoModelForMaskedLM.from_pretrained(
"Synthyra/ESM2-150M",
trust_remote_code=True,
)
metrics = ttt_model.ttt(
seq="MSTNPKPQRKTKRNT",
ttt_config={"steps": 3, "batch_size": 1, "seed": 7},
)
ttt_model.save_pretrained("adapted", safe_serialization=True)
ttt_model.ttt_reset()
print(metrics)
Saved adapters retain their deterministic reset state. TTT adds latency and memory, can worsen an output, and does not show biological function.
Masked language modeling and contacts
Use the masked-language-model AutoClass when you need logits:
import torch
from transformers import AutoModelForMaskedLM, AutoTokenizer
model_id = "Synthyra/ESM2-150M"
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
masked_model = AutoModelForMaskedLM.from_pretrained(
model_id,
trust_remote_code=True,
).eval()
batch = tokenizer("MSTNPKPQRKTKRNT", return_tensors="pt")
with torch.inference_mode():
logits = masked_model(**batch).logits # (b, l, vocabulary)
# Contacts omit boundary tokens: (b, residues, residues).
contacts = masked_model.predict_contacts(
batch["input_ids"],
batch["attention_mask"],
)
print(logits.shape, contacts.shape)
Contact prediction creates attention maps. Do not enable it in a high-throughput embedding path unless you need these maps.
Plain AutoModel omits the optional ESM pooler because this masked-language-
model checkpoint has no trained pooler weights. Pass add_pooling_layer=True
only when you intend to initialize and train that head.
Technical details
- Inputs: Amino-acid sequences tokenized to residue IDs
- Transformers classes:
AutoConfig,AutoModel,AutoModelForMaskedLM,AutoModelForSequenceClassification,AutoModelForTokenClassification - Checkpoint weights:
AutoConfig=FastPLMs extension,AutoModel=pretrained,AutoModelForMaskedLM=pretrained,AutoModelForSequenceClassification=base weights + untrained task head,AutoModelForTokenClassification=base weights + untrained task head - Attention backends:
eager,sdpa,flex_attention,flash_attention_2,flash_attention_3 - Precision:
default - BF16 execution:
fp32_parameters_autocast - Generation contract:
not_applicable - Dependencies:
core - Weight publication allowed:
true - Weight license status:
resolved - Redistributable:
true - Complete weight publication required:
false
Validation and sources
FastPLMs pins the checkpoint, upstream source revisions, state transformation,
and required files in models.toml. Built artifacts record exact source
identities and conversion details in source-record.json.
- FastPLMs checkpoint:
Synthyra/ESM2-150M - Runtime revision: recorded separately in the built artifact and published commit
- Runtime source identities: recorded in
source-record.json - Official checkpoint:
facebook/esm2_t30_150M_UR50D - Artifact source:
fast - State transform:
esm2_hf_to_fastplms_v1 - Pinned upstreams:
fair-esm - Release tiers:
check,compliance,feature,artifact,benchmark - Unresolved required file identities:
0
Release validation includes the compliance tier. Its evidence identifies the
checkpoint, backend, dtype, hardware, inputs, and reference revision.
Declared tiers compare configuration, tokenizer behavior, state, and representative inference with the pinned reference. A nonzero unresolved count blocks release. Metadata alone does not show that a build passed, that a backend is faster, or that an output is biologically valid.
License
Checkpoint terms: MIT. The Hub model-card identifier is
mit. The local artifact contains applicable source
licenses, notices, attribution, and conversion records. Review them before use.