diff --git a/esm/README.md b/esm/README.md new file mode 100644 index 00000000..b2c9d24c --- /dev/null +++ b/esm/README.md @@ -0,0 +1,156 @@ +# ESM-2 + +This repository provides an implementation of Meta's ESM-2 protein language model +in MLX.[^1] ESM-2 is Meta’s second-generation Evolutionary Scale Model, a +transformer-based protein language model trained on millions of diverse protein +sequences with a masked language modeling objective. + +![Example contact prediction map](assets/contact_prediction.png) + +_Example contact prediction map for a universal stress protein. In this case, ESM-2 650M achieves 86.4% precision at long-range contacts._ + +## Setup + +Install the requirements: + +```bash +pip install -r requirements.txt +``` + +## Usage + +Below are the available ESM-2 models: +| Model | Parameters | Layers | +|-------|------------|--------| +| [`esm2_t6_8M_UR50D`](https://huggingface.co/facebook/esm2_t6_8M_UR50D) | 8M | 6 | +| [`esm2_t12_35M_UR50D`](https://huggingface.co/facebook/esm2_t12_35M_UR50D) | 35M | 12 | +| [`esm2_t30_150M_UR50D`](https://huggingface.co/facebook/esm2_t30_150M_UR50D) | 150M | 30 | +| [`esm2_t33_650M_UR50D`](https://huggingface.co/facebook/esm2_t33_650M_UR50D) | 650M | 33 | +| [`esm2_t36_3B_UR50D`](https://huggingface.co/facebook/esm2_t36_3B_UR50D) | 3B | 36 | +| [`esm2_t48_15B_UR50D`](https://huggingface.co/facebook/esm2_t48_15B_UR50D) | 15B | 48 | + +Convert a model to MLX format: + +```bash +python convert.py --hf-path facebook/esm2_t33_650M_UR50D +``` + +This will save the converted model in a checkpoints directory. + +### Basic Inference + +```python +from esm import ESM2 + +# Load model and tokenizer +tokenizer, model = ESM2.from_pretrained("checkpoints/mlx-esm2_t33_650M_UR50D") + +# Example protein sequence (human insulin) +sequence = "MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN" + +# Tokenize and run inference +tokens = tokenizer.encode(sequence) +result = model(tokens) +logits = result["logits"] # Shape: (batch, length, vocab_size) +``` + +### Masked Language Modeling + +```bash +# For a complete example, see main.py +python main.py --sequence "YOUR_SEQUENCE" --mask-position 50 +``` + +### Embeddings + +```python +# Get sequence-level representations +seq_repr = model.get_sequence_representations(tokens, layer=-1) # Shape: (batch, embed_dim) + +# Extract per-residue representations from specific layers +representations = model.extract_features(tokens, repr_layers=[20, 30, 33]) +final_layer = representations[33] # Shape: (batch, length, embed_dim) +``` + +### Contact Prediction + +```python +# Predict residue-residue contacts +contacts = model.predict_contacts(tokens) # Shape: (batch, length, length) + +# Or compute contacts together with logits, representations, etc. +outputs = model(tokens, return_contacts=True) +contacts = outputs["contacts"] +``` + +### Examples + +**Mutation Effect Prediction**: [notebooks/mutation_effect_prediction.ipynb](notebooks/mutation_effect_prediction.ipynb) + +This notebook demonstrates how to use ESM-2 for zero-shot mutation effect prediction by scoring amino acid substitutions based on their likelihood under the model. We validate the approach using experimental fitness data from β-lactamase TEM, showing how ESM-2 captures functional constraints without requiring structural information. + +**Embeddings**: [notebooks/embeddings.ipynb](notebooks/embeddings.ipynb) + +This notebook explores how ESM-2 generates meaningful protein embeddings that capture evolutionary and functional relationships between proteins. We analyze six diverse human proteins to demonstrate how the learned representations cluster proteins by function and reveal biological similarities. + +**Contact Prediction**: [notebooks/contact_prediction.ipynb](notebooks/contact_prediction.ipynb) + +This notebook shows how to predict residue-residue contacts in protein structures using ESM-2's attention patterns. We evaluate contact prediction performance on three diverse proteins, demonstrating how the model captures both local and long-range structural relationships directly from sequence data. + +### Benchmarking + +Benchmark MLX performance: + +```bash +python benchmarks/benchmark_mx.py +``` + +Benchmark PyTorch MPS performance: + +```bash +python benchmarks/benchmark_pt.py +``` + +Expected performance on M4 MacBook Pro (ESM-2 650M, batch_size = 5): + +- MLX: 299 ms per step, 16.71 sequences/sec +- PyTorch MPS: 402 ms per step, 12.43 sequences/sec + +### Testing + +Verify correctness against original implementation: + +```bash +python test.py +``` + +This tests tokenizer and model outputs (logits, hidden states, and attentions) for equivalence with the original implementation. + +### Citations: + +```bibtex +@article{rives2019biological, + author={Rives, Alexander and Meier, Joshua and Sercu, Tom and Goyal, Siddharth and Lin, Zeming and Liu, Jason and Guo, Demi and Ott, Myle and Zitnick, C. Lawrence and Ma, Jerry and Fergus, Rob}, + title={Biological Structure and Function Emerge from Scaling Unsupervised Learning to 250 Million Protein Sequences}, + year={2019}, + doi={10.1101/622803}, + url={https://www.biorxiv.org/content/10.1101/622803v4}, + journal={PNAS} +} + +``` + +```bibtex +@article{Lin2023, + author={Zeming Lin et al.}, + title={Evolutionary-scale prediction of atomic-level protein structure with a language model}, + journal={Science}, + volume={379}, + pages={1123--1130}, + year={2023}, + doi={10.1126/science.ade2574}, + url={https://doi.org/10.1126/science.ade2574} +} +``` + +[^1]: Refer to the [paper](https://www.science.org/doi/10.1126/science.ade2574) and [code](https://github.com/facebookresearch/esm) for more details. diff --git a/esm/assets/contact_prediction.png b/esm/assets/contact_prediction.png new file mode 100644 index 00000000..8720fb82 Binary files /dev/null and b/esm/assets/contact_prediction.png differ diff --git a/esm/benchmarks/benchmark_mx.py b/esm/benchmarks/benchmark_mx.py new file mode 100644 index 00000000..c970d34e --- /dev/null +++ b/esm/benchmarks/benchmark_mx.py @@ -0,0 +1,47 @@ +import sys +import time +from pathlib import Path + +import mlx.core as mx + +# Add parent directory to Python path +cur_path = Path(__file__).parents[1].resolve() +sys.path.append(str(cur_path)) + +from esm import ESM2 + +# Example protein sequence (Green Fluorescent Protein) +protein_sequence = "MSKGEELFTGVVPILVELDGDVNGHKFSVSGEGEGDATYGKLTLKFICTTGKLPVPWPTLVTTFSYGVQCFSRYPDHMKQHDFFKSAMPEGYVQERTIFFKDDGNYKTRAEVKFEGDTLVNRIELKGIDFKEDGNILGHKLEYNYNSHNVYIMADKQKNGIKVNFKIRHNIEDGSVQLADHYQQNTPIGDGPVLLPDNHYLSTQSALSKDPNEKRDHMVLLEFVTAAGITHGMDELYK" + +# Load pretrained ESM-2 model and its tokenizer from local checkpoint +tokenizer, model = ESM2.from_pretrained("checkpoints/mlx-esm2_t33_650M_UR50D") + +# Number of sequences to process in each forward pass +batch_size = 5 + +# Number of timing iterations for performance measurement +steps = 50 + +# Tokenize the protein sequence into integer IDs for the model +# Replicate the same sequence 'batch_size' times to create a batch +tokens = tokenizer.batch_encode([protein_sequence] * batch_size) + +# Warm-up phase +for _ in range(10): + result = model(tokens) + mx.eval(result["logits"]) # Force computation to complete + +# Measure average inference time over 'steps' iterations +tic = time.time() +for _ in range(steps): + result = model(tokens) + mx.eval(result["logits"]) # Synchronize and ensure computation finishes +toc = time.time() + +# Compute metrics: average time per step (ms) and throughput (sequences/sec) +ms_per_step = 1000 * (toc - tic) / steps +throughput = batch_size * 1000 / ms_per_step + +# Display results +print(f"Time (ms) per step: {ms_per_step:.3f}") +print(f"Throughput: {throughput:.2f} sequences/sec") diff --git a/esm/benchmarks/benchmark_pt.py b/esm/benchmarks/benchmark_pt.py new file mode 100644 index 00000000..44f28e5b --- /dev/null +++ b/esm/benchmarks/benchmark_pt.py @@ -0,0 +1,52 @@ +import time + +import torch +from transformers import AutoTokenizer, EsmForMaskedLM + +# Example protein sequence (Green Fluorescent Protein) +protein_sequence = "MSKGEELFTGVVPILVELDGDVNGHKFSVSGEGEGDATYGKLTLKFICTTGKLPVPWPTLVTTFSYGVQCFSRYPDHMKQHDFFKSAMPEGYVQERTIFFKDDGNYKTRAEVKFEGDTLVNRIELKGIDFKEDGNILGHKLEYNYNSHNVYIMADKQKNGIKVNFKIRHNIEDGSVQLADHYQQNTPIGDGPVLLPDNHYLSTQSALSKDPNEKRDHMVLLEFVTAAGITHGMDELYK" + +# Hugging Face model identifier for ESM-2 (33 layers, 650M params, UR50D training set) +model_name = "facebook/esm2_t33_650M_UR50D" + +# Load tokenizer and model; move model to Apple Metal Performance Shaders (MPS) device +tokenizer = AutoTokenizer.from_pretrained(model_name) +model = EsmForMaskedLM.from_pretrained(model_name).to("mps") + +# Number of sequences per forward pass +batch_size = 5 + +# Number of timing iterations +steps = 50 + +# Tokenize input sequence and replicate for the batch +# Replicate the same sequence 'batch_size' times to create a batch +inputs = tokenizer( + [protein_sequence] * batch_size, + return_tensors="pt", + padding=True, + truncation=True, + max_length=1024, +) +input_ids = inputs["input_ids"].to("mps") +attention_mask = inputs["attention_mask"].to("mps") + +# Warm-up phase +for _ in range(10): + outputs = model(input_ids=input_ids, attention_mask=attention_mask) + torch.mps.synchronize() # Ensure all queued ops on MPS are complete before next step + +# Timed inference loop +tic = time.time() +for _ in range(steps): + outputs = model(input_ids=input_ids, attention_mask=attention_mask) + torch.mps.synchronize() # Wait for computation to finish before timing next iteration +toc = time.time() + +# Compute performance metrics +ms_per_step = 1000 * (toc - tic) / steps +throughput = batch_size * 1000 / ms_per_step + +# Report results +print(f"Time (ms) per step: {ms_per_step:.3f}") +print(f"Throughput: {throughput:.2f} sequences/sec") diff --git a/esm/convert.py b/esm/convert.py new file mode 100644 index 00000000..bfbc4be7 --- /dev/null +++ b/esm/convert.py @@ -0,0 +1,177 @@ +import argparse +import json +import shutil +from pathlib import Path +from typing import Dict + +import mlx.core as mx +import torch +from huggingface_hub import snapshot_download + + +def download(hf_repo: str) -> Path: + """Download model from Hugging Face.""" + return Path( + snapshot_download( + repo_id=hf_repo, + allow_patterns=["*.safetensors", "*.json", "*.bin", "*.txt"], + ) + ) + + +def remap_key(key: str) -> str: + """Remap HuggingFace ESM key names to MLX format.""" + + # Skip position embeddings and position_ids + if "position_embeddings" in key or "position_ids" in key: + return None + + # Map lm_head components properly + if key == "lm_head.decoder.weight": + return "lm_head.weight" + if key == "lm_head.decoder.bias": + return "lm_head.bias" + if key == "lm_head.dense.weight": + return "lm_head.dense.weight" + if key == "lm_head.dense.bias": + return "lm_head.dense.bias" + if key == "lm_head.layer_norm.weight": + return "lm_head.layer_norm.weight" + if key == "lm_head.layer_norm.bias": + return "lm_head.layer_norm.bias" + + # Core remapping patterns + key = key.replace("esm.embeddings.word_embeddings", "embed_tokens") + key = key.replace("esm.encoder.emb_layer_norm_after", "emb_layer_norm_after") + key = key.replace("esm.encoder.layer.", "layer_") + key = key.replace("esm.contact_head", "contact_head") + key = key.replace("lm_head", "lm_head") + + # Attention patterns + key = key.replace(".attention.self.", ".self_attn.") + key = key.replace(".attention.output.dense", ".self_attn.out_proj") + key = key.replace(".attention.LayerNorm", ".self_attn_layer_norm") + key = key.replace(".query", ".q_proj") + key = key.replace(".key", ".k_proj") + key = key.replace(".value", ".v_proj") + key = key.replace(".rotary_embeddings", ".rot_emb") + + # FFN patterns + key = key.replace(".intermediate.dense", ".fc1") + key = key.replace(".output.dense", ".fc2") + key = key.replace(".LayerNorm", ".final_layer_norm") + + return key + + +def load_weights(model_path: Path) -> Dict: + """Load weights from safetensors or PyTorch bin files.""" + + # Check for safetensors file + safetensors_path = model_path / "model.safetensors" + if safetensors_path.exists(): + print("Loading from safetensors...") + return mx.load(str(safetensors_path)) + + # Check for single bin file + single_bin_path = model_path / "pytorch_model.bin" + if single_bin_path.exists(): + print("Loading from pytorch_model.bin...") + state_dict = torch.load(str(single_bin_path), map_location="cpu") + return {k: v.numpy() for k, v in state_dict.items()} + + # Check for sharded bin files + index_file = model_path / "pytorch_model.bin.index.json" + if index_file.exists(): + print("Loading from sharded bin files...") + with open(index_file) as f: + index = json.load(f) + + # Get unique shard files + shard_files = set(index["weight_map"].values()) + + # Load all shards + state_dict = {} + for shard_file in sorted(shard_files): + print(f" Loading shard: {shard_file}") + shard_path = model_path / shard_file + shard_dict = torch.load(str(shard_path), map_location="cpu") + state_dict.update(shard_dict) + + return {k: v.numpy() for k, v in state_dict.items()} + + raise ValueError(f"No model weights found in {model_path}") + + +def convert(model_path: Path) -> Dict[str, mx.array]: + """Convert ESM weights to MLX format.""" + + # Load weights from any format + weights = load_weights(model_path) + + # Convert keys and create MLX arrays + mlx_weights = {} + for key, value in weights.items(): + mlx_key = remap_key(key) + if mlx_key is not None: + mlx_weights[mlx_key] = ( + mx.array(value) if not isinstance(value, mx.array) else value + ) + + # If lm_head.weight is missing but embed_tokens.weight exists, set up weight sharing + # (This is for smaller models that don't have a separate lm_head.decoder.weight) + if "lm_head.weight" not in mlx_weights and "embed_tokens.weight" in mlx_weights: + mlx_weights["lm_head.weight"] = mlx_weights["embed_tokens.weight"] + + return mlx_weights + + +def main(): + parser = argparse.ArgumentParser(description="Convert ESM weights to MLX format") + parser.add_argument( + "--hf-path", default="facebook/esm2_t6_8M_UR50D", help="Hugging Face model path" + ) + parser.add_argument("--mlx-path", default=None, help="Output path for MLX model") + parser.add_argument( + "--checkpoints-dir", + default="checkpoints", + help="Directory to save checkpoints (default: checkpoints)", + ) + + args = parser.parse_args() + + # Download model + print(f"Downloading {args.hf_path}...") + model_path = download(args.hf_path) + + # Set output path + if args.mlx_path is None: + model_name = args.hf_path.split("/")[-1] + checkpoints_dir = Path(args.checkpoints_dir) + checkpoints_dir.mkdir(parents=True, exist_ok=True) + args.mlx_path = checkpoints_dir / f"mlx-{model_name}" + mlx_path = Path(args.mlx_path) + mlx_path.mkdir(parents=True, exist_ok=True) + + # Convert weights + print("Converting weights...") + mlx_weights = convert(model_path) + + # Save weights + print(f"Saving MLX weights to {mlx_path}...") + mx.save_safetensors(str(mlx_path / "model.safetensors"), mlx_weights) + + # Copy config and other files + print("Copying config...") + shutil.copy(model_path / "config.json", mlx_path / "config.json") + + for file_name in ["special_tokens_map.json", "tokenizer.json", "vocab.txt"]: + src_file = model_path / file_name + if src_file.exists(): + shutil.copy(src_file, mlx_path / file_name) + + print(f"Conversion complete! MLX model saved to {mlx_path}") + + +if __name__ == "__main__": + main() diff --git a/esm/esm/__init__.py b/esm/esm/__init__.py new file mode 100644 index 00000000..1c2139d4 --- /dev/null +++ b/esm/esm/__init__.py @@ -0,0 +1,19 @@ +""" +ESM-2 protein language model implementation in MLX +""" + +from .attention import MultiheadAttention +from .model import ESM2 +from .modules import ContactPredictionHead, RobertaLMHead, TransformerLayer +from .rotary_embedding import RotaryEmbedding +from .tokenizer import ProteinTokenizer + +__all__ = [ + "ESM2", + "ProteinTokenizer", + "ContactPredictionHead", + "RobertaLMHead", + "TransformerLayer", + "MultiheadAttention", + "RotaryEmbedding", +] diff --git a/esm/esm/attention.py b/esm/esm/attention.py new file mode 100644 index 00000000..be535b25 --- /dev/null +++ b/esm/esm/attention.py @@ -0,0 +1,153 @@ +from typing import Optional, Tuple + +import mlx.core as mx +import mlx.nn as nn + +from .rotary_embedding import RotaryEmbedding + + +class MultiheadAttention(nn.Module): + """ + Multi-head attention layer with rotary position embeddings, as used in ESM-2. + + This module implements both self-attention (when `key` and `value` are not + provided) and cross-attention. It projects input sequences into queries, + keys, and values, applies rotary position embeddings to encode relative + position information, computes scaled dot-product attention over multiple + heads in parallel, and returns a combined output projection. + + Args: + embed_dim (int): Total embedding dimension of the model input and output. + num_heads (int): Number of parallel attention heads. Must divide `embed_dim`. + """ + + def __init__( + self, + embed_dim, + num_heads, + ): + super().__init__() + self.embed_dim = embed_dim + self.num_heads = num_heads + self.head_dim = embed_dim // num_heads + assert ( + self.head_dim * num_heads == self.embed_dim + ), "embed_dim must be divisible by num_heads" + self.scaling = self.head_dim**-0.5 + + # Linear projections for queries, keys, and values (with bias) + self.q_proj = nn.Linear(embed_dim, embed_dim, bias=True) + self.k_proj = nn.Linear(embed_dim, embed_dim, bias=True) + self.v_proj = nn.Linear(embed_dim, embed_dim, bias=True) + + # Linear projection for output (with bias) + self.out_proj = nn.Linear(embed_dim, embed_dim, bias=True) + + # ESM-2 uses rotary embeddings + self.rot_emb = RotaryEmbedding(dim=self.head_dim) + + def __call__( + self, + query, + key: Optional[mx.array] = None, + value: Optional[mx.array] = None, + key_padding_mask: Optional[mx.array] = None, + attn_mask: Optional[mx.array] = None, + need_head_weights: bool = False, + ) -> Tuple[mx.array, Optional[mx.array]]: + """ + Multi-head attention forward pass. + + Args: + query: Tensor of shape (tgt_len, batch, embed_dim). + key: Optional tensor of shape (src_len, batch, embed_dim). Defaults to `query`. + value: Optional tensor of shape (src_len, batch, embed_dim). Defaults to `query`. + key_padding_mask: Optional mask of shape (batch, src_len) to ignore padded positions. + attn_mask: Optional mask for attention (e.g., causal mask). + need_head_weights: If True, return attention weights for each head separately. + + Returns: + attn_output: Tensor of shape (tgt_len, batch, embed_dim). + attn_weights_out: Attention weights of shape + (num_heads, batch, tgt_len, src_len) if per-head, + or (batch, tgt_len, src_len) if averaged. + """ + + tgt_len, bsz, embed_dim = query.shape + assert embed_dim == self.embed_dim + + # For self-attention, use query as key and value if not provided + if key is None: + key = query + if value is None: + value = query + + # Project queries, keys, values + q = self.q_proj(query) + k = self.k_proj(key) + v = self.v_proj(value) + + q = q * self.scaling + + # Reshape for multi-head attention + q = q.reshape(tgt_len, bsz * self.num_heads, self.head_dim).swapaxes(0, 1) + k = k.reshape(-1, bsz * self.num_heads, self.head_dim).swapaxes(0, 1) + v = v.reshape(-1, bsz * self.num_heads, self.head_dim).swapaxes(0, 1) + + src_len = k.shape[1] + + # Apply rotary embeddings if present + if self.rot_emb: + q, k = self.rot_emb(q, k) + + # Compute attention weights + attn_weights = q @ k.swapaxes(-2, -1) + + assert list(attn_weights.shape) == [bsz * self.num_heads, tgt_len, src_len] + + # Apply attention mask + if attn_mask is not None: + attn_mask = mx.expand_dims(attn_mask, 0) + attn_weights = attn_weights + attn_mask + + # Apply key padding mask + if key_padding_mask is not None: + attn_weights = attn_weights.reshape(bsz, self.num_heads, tgt_len, src_len) + # Convert key_padding_mask to boolean and expand dimensions + # key_padding_mask: [bsz, src_len] -> [bsz, 1, 1, src_len] + mask = mx.expand_dims( + mx.expand_dims(key_padding_mask.astype(mx.bool_), 1), 2 + ) + # Apply mask: set attention to -inf where mask is True (padded positions) + attn_weights = mx.where(mask, -mx.inf, attn_weights) + attn_weights = attn_weights.reshape(bsz * self.num_heads, tgt_len, src_len) + + # Apply softmax + attn_weights_float = mx.softmax(attn_weights.astype(mx.float32), axis=-1) + attn_probs = attn_weights_float + + # Compute attention output + attn = attn_probs @ v + assert list(attn.shape) == [bsz * self.num_heads, tgt_len, self.head_dim] + + # Reshape output + attn = attn.swapaxes(0, 1).reshape(tgt_len, bsz, embed_dim) + attn = self.out_proj(attn) + + # Return attention weights if requested + attn_weights_out: Optional[mx.array] = None + if need_head_weights: + # Return attention weights for each head separately + attn_weights_out = ( + attn_weights_float.reshape(bsz, self.num_heads, tgt_len, src_len) + .astype(attn.dtype) + .swapaxes(0, 1) + ) + else: + # Return averaged attention weights + attn_weights_out = mx.mean( + attn_weights_float.reshape(bsz, self.num_heads, tgt_len, src_len), + axis=1, + ).astype(attn.dtype) + + return attn, attn_weights_out diff --git a/esm/esm/model.py b/esm/esm/model.py new file mode 100644 index 00000000..ee90a071 --- /dev/null +++ b/esm/esm/model.py @@ -0,0 +1,343 @@ +import json +from pathlib import Path +from typing import Dict, List, Optional, Tuple + +import mlx.core as mx +import mlx.nn as nn + +from .modules import ContactPredictionHead, RobertaLMHead, TransformerLayer +from .tokenizer import ProteinTokenizer + + +class ESM2(nn.Module): + """ + ESM-2 protein language model in MLX. + + Args: + num_layers (int): Number of transformer layers. + embed_dim (int): Embedding dimension. + attention_heads (int): Number of attention heads. + tokenizer (Optional[ProteinTokenizer]): Tokenizer to use (created if None). + token_dropout (bool): Apply token-dropout masking behavior. + """ + + def __init__( + self, + num_layers: int = 33, + embed_dim: int = 1280, + attention_heads: int = 20, + tokenizer: Optional[ProteinTokenizer] = None, + token_dropout: bool = True, + ): + super().__init__() + self.num_layers = num_layers + self.embed_dim = embed_dim + self.attention_heads = attention_heads + + # Initialize tokenizer + if tokenizer is None: + tokenizer = ProteinTokenizer() + self.tokenizer = tokenizer + self.vocab_size = len(tokenizer) + + # Special token IDs / config + self.padding_idx = tokenizer.pad_id + self.mask_idx = tokenizer.mask_id + self.cls_idx = tokenizer.cls_id + self.eos_idx = tokenizer.eos_id + self.prepend_bos = tokenizer.prepend_bos + self.append_eos = tokenizer.append_eos + self.token_dropout = token_dropout + + self._init_submodules() + + def _init_submodules(self) -> None: + """Initialize embeddings, transformer stack, and output heads.""" + self.embed_scale = 1 + + # Token embeddings + self.embed_tokens = nn.Embedding(self.vocab_size, self.embed_dim) + + # Transformer layers (register each layer so MLX tracks parameters) + self._layer_indices = list(range(self.num_layers)) + for i in self._layer_indices: + layer = TransformerLayer( + self.embed_dim, + 4 * self.embed_dim, # FFN dimension = 4×embed_dim + self.attention_heads, + ) + setattr(self, f"layer_{i}", layer) + + # Contact prediction head (uses all layers × heads attentions) + self.contact_head = ContactPredictionHead( + self.num_layers * self.attention_heads, + self.prepend_bos, + self.append_eos, + eos_idx=self.eos_idx, + ) + + # Final norm + LM head (tied weights) + self.emb_layer_norm_after = nn.LayerNorm(self.embed_dim) + self.lm_head = RobertaLMHead( + embed_dim=self.embed_dim, + output_dim=self.vocab_size, + weight=self.embed_tokens.weight, + ) + + def __call__( + self, + tokens: mx.array, + repr_layers: List[int] = [], + need_head_weights: bool = False, + return_contacts: bool = False, + ) -> Dict[str, mx.array]: + """ + Forward pass through ESM-2. + + Args: + tokens: Tensor of token IDs with shape (B, T). + repr_layers: Layers to return hidden states from (0..num_layers). + need_head_weights: If True, return attention weights. + return_contacts: If True, compute residue-residue contact probabilities. + + Returns: + dict with: + logits: (B, T, V) + representations: {layer_idx: (B, T, E)} + attentions: (B, L, H, T, T) if requested + contacts: (B, T', T') if requested + """ + if return_contacts: + need_head_weights = True + + # Ensure tokens is 2D (B, T) + if tokens.ndim == 1: + tokens = mx.expand_dims(tokens, axis=0) + assert tokens.ndim == 2 + + # Padding mask (B, T) + padding_mask = mx.equal(tokens, self.padding_idx) + + # Embed tokens (B, T, E) + x = self.embed_scale * self.embed_tokens(tokens) + + # Token dropout: zero masked tokens + rescale based on observed mask ratio + if self.token_dropout: + mask_positions = mx.equal(tokens, self.mask_idx) + x = mx.where(mask_positions[:, :, None], mx.zeros_like(x), x) + + mask_ratio_train = 0.15 * 0.8 + src_lengths = mx.sum(~padding_mask, axis=-1, keepdims=True) + mask_ratio_observed = ( + mx.sum(mask_positions, axis=-1, keepdims=True) / src_lengths + ) + scale_factor = (1 - mask_ratio_train) / mx.maximum( + 1 - mask_ratio_observed, 1e-8 + ) + x = x * scale_factor[:, None, :] + + # Zero out padding positions + if padding_mask.any(): + x = x * (1 - padding_mask[:, :, None].astype(x.dtype)) + + # Track requested representations + repr_layers = set(repr_layers) + hidden_representations: Dict[int, mx.array] = {} + if 0 in repr_layers: + hidden_representations[0] = x + + if need_head_weights: + attn_weights: List[mx.array] = [] + + # (B, T, E) -> (T, B, E) for transformer layers + x = mx.swapaxes(x, 0, 1) + + # If no padding anywhere, skip the mask + if not padding_mask.any(): + padding_mask = None + + # Transformer stack + for layer_idx in self._layer_indices: + layer = getattr(self, f"layer_{layer_idx}") + x, attn = layer( + x, + self_attn_padding_mask=padding_mask, + need_head_weights=need_head_weights, + ) + + # Save hidden representation if requested (store back as (B, T, E)) + if (layer_idx + 1) in repr_layers: + hidden_representations[layer_idx + 1] = mx.swapaxes(x, 0, 1) + + # Save per-layer attentions if requested (H, B, T, T) -> (B, H, T, T) + if need_head_weights: + attn_weights.append(mx.swapaxes(attn, 0, 1)) + + # Final layer norm, back to (B, T, E) + x = self.emb_layer_norm_after(x) + x = mx.swapaxes(x, 0, 1) + + # Save final hidden if requested + if (layer_idx + 1) in repr_layers: + hidden_representations[layer_idx + 1] = x + + # Language modeling logits + x = self.lm_head(x) + + # Build result dict + result: Dict[str, mx.array] = { + "logits": x, + "representations": hidden_representations, + } + + # Collect attentions and optional contacts + if need_head_weights: + # Stack layers -> (B, L, H, T, T) + attentions = mx.stack(attn_weights, axis=1) + + # Mask out padded positions if present + if padding_mask is not None: + attention_mask = 1 - padding_mask.astype(attentions.dtype) + attention_mask = mx.expand_dims(attention_mask, 1) * mx.expand_dims( + attention_mask, 2 + ) + attentions = attentions * attention_mask[:, None, None, :, :] + + result["attentions"] = attentions + + # Compute contacts if requested + if return_contacts: + contacts = self.contact_head(tokens, attentions) + result["contacts"] = contacts + + return result + + def predict_contacts(self, tokens: mx.array) -> mx.array: + """ + Predict residue-residue contacts. + + Args: + tokens: Tensor of shape (B, T). + + Returns: + mx.array: Contact probabilities of shape (B, T', T'). + """ + return self(tokens, return_contacts=True)["contacts"] + + def extract_features( + self, + tokens: mx.array, + repr_layers: Optional[List[int]] = None, + return_all_hiddens: bool = False, + ) -> Dict[int, mx.array]: + """ + Extract hidden representations from selected layers. + + Args: + tokens: Tensor of shape (B, T). + repr_layers: Layer indices to return (default: last layer). + return_all_hiddens: If True, return all layers (0..num_layers). + + Returns: + dict: {layer_idx: (B, T, E)} for requested layers. + """ + if return_all_hiddens: + repr_layers = list(range(self.num_layers + 1)) + elif repr_layers is None: + repr_layers = [self.num_layers] + + result = self(tokens, repr_layers=repr_layers) + return result["representations"] + + def get_sequence_representations( + self, + tokens: mx.array, + layer: int = -1, + ) -> mx.array: + """ + Average token representations into a per-sequence embedding. + + Args: + tokens: Tensor of shape (B, T). + layer: Layer index to use (-1 or num_layers for last). + + Returns: + mx.array: Sequence embeddings of shape (B, E). + """ + if layer == -1: + layer = self.num_layers + + representations = self.extract_features(tokens, repr_layers=[layer]) + repr = representations[layer] + + # Mask: non-padding and not CLS; optionally not EOS + mask = mx.logical_and( + mx.not_equal(tokens, self.padding_idx), + mx.not_equal(tokens, self.cls_idx), + ) + if self.append_eos: + mask = mx.logical_and(mask, mx.not_equal(tokens, self.eos_idx)) + + # Mean over valid positions + mask = mask[:, :, None].astype(repr.dtype) + masked_repr = repr * mask + seq_lens = mx.sum(mask, axis=1, keepdims=True) + seq_repr = mx.sum(masked_repr, axis=1) / mx.maximum(seq_lens[:, :, 0], 1.0) + + return seq_repr + + @classmethod + def from_pretrained(cls, model_path: str) -> Tuple[ProteinTokenizer, "ESM2"]: + """ + Load model weights and config from a directory. + + Expects: + - config.json + - model.safetensors + - vocab.txt (optional, will use default if not found) + - special_tokens_map.json (optional, will use default if not found) + + Args: + model_path: Path to directory with weights and config. + + Returns: + (tokenizer, model): Initialized tokenizer and ESM2 model. + """ + model_dir = Path(model_path) + config_path = model_dir / "config.json" + with open(config_path, "r") as f: + config = json.load(f) + + # Check for vocab and special tokens files + vocab_path = model_dir / "vocab.txt" + special_tokens_path = model_dir / "special_tokens_map.json" + + if vocab_path.exists() and special_tokens_path.exists(): + tokenizer = ProteinTokenizer( + vocab_file=str(vocab_path), + special_tokens_map_file=str(special_tokens_path), + ) + else: + tokenizer = ProteinTokenizer() + + model = cls( + num_layers=config["num_hidden_layers"], + embed_dim=config["hidden_size"], + attention_heads=config["num_attention_heads"], + tokenizer=tokenizer, + token_dropout=config["token_dropout"], + ) + + # Load safetensors as nested dict and update model params + weights_path = model_dir / "model.safetensors" + flat_weights = mx.load(str(weights_path)) + nested_weights: Dict[str, dict] = {} + for key, value in flat_weights.items(): + parts = key.split(".") + cur = nested_weights + for p in parts[:-1]: + cur = cur.setdefault(p, {}) + cur[parts[-1]] = value + + model.update(nested_weights) + return tokenizer, model diff --git a/esm/esm/modules.py b/esm/esm/modules.py new file mode 100644 index 00000000..c44e9fac --- /dev/null +++ b/esm/esm/modules.py @@ -0,0 +1,212 @@ +from typing import Optional + +import mlx.core as mx +import mlx.nn as nn + +from .attention import MultiheadAttention + + +def symmetrize(x: mx.array) -> mx.array: + """ + Make a tensor symmetric over its last two dimensions. + + Args: + x: Tensor with shape (..., L, L). + + Returns: + mx.array: Symmetrized tensor of shape (..., L, L). + """ + # Add tensor to its transpose over the last two dims + return x + mx.swapaxes(x, -1, -2) + + +def apc(x: mx.array) -> mx.array: + """ + Apply Average Product Correction (APC) to remove background co-variation. + + Args: + x: Tensor with shape (..., L, L). + + Returns: + mx.array: APC-corrected tensor of shape (..., L, L). + """ + # Compute row, column, and total sums + a1 = mx.sum(x, axis=-1, keepdims=True) + a2 = mx.sum(x, axis=-2, keepdims=True) + a12 = mx.sum(x, axis=(-1, -2), keepdims=True) + + # Expected co-variation under independence + expected = (a1 * a2) / a12 + return x - expected + + +class TransformerLayer(nn.Module): + """ + Transformer layer used in ESM-2. + + Args: + embed_dim (int): Model embedding dimension. + ffn_embed_dim (int): Hidden dimension of the feed-forward network. + attention_heads (int): Number of attention heads. + """ + + def __init__( + self, + embed_dim: int, + ffn_embed_dim: int, + attention_heads: int, + ): + super().__init__() + self.embed_dim = embed_dim + self.ffn_embed_dim = ffn_embed_dim + self.attention_heads = attention_heads + self._init_submodules() + + def _init_submodules(self) -> None: + """Initialize attention, norms, and feed-forward submodules.""" + self.self_attn = MultiheadAttention(self.embed_dim, self.attention_heads) + self.self_attn_layer_norm = nn.LayerNorm(self.embed_dim) + self.fc1 = nn.Linear(self.embed_dim, self.ffn_embed_dim) + self.fc2 = nn.Linear(self.ffn_embed_dim, self.embed_dim) + self.final_layer_norm = nn.LayerNorm(self.embed_dim) + + def __call__( + self, + x: mx.array, + self_attn_mask: Optional[mx.array] = None, + self_attn_padding_mask: Optional[mx.array] = None, + need_head_weights: bool = False, + ): + """ + Forward pass for the Transformer layer. + + Args: + x: Tensor of shape (seq_len, batch, embed_dim). + self_attn_mask: Optional attention mask. + self_attn_padding_mask: Optional padding mask of shape (batch, seq_len). + need_head_weights: If True, return per-head attention weights. + + Returns: + x: Tensor of shape (seq_len, batch, embed_dim). + attn: Attention weights of shape + (num_heads, batch, tgt_len, src_len) if per-head, + or (batch, tgt_len, src_len) if averaged. + """ + # Self-attention block + residual = x + x = self.self_attn_layer_norm(x) + x, attn = self.self_attn( + query=x, + key_padding_mask=self_attn_padding_mask, + attn_mask=self_attn_mask, + need_head_weights=need_head_weights, + ) + x = residual + x + + # Feed-forward block + residual = x + x = self.final_layer_norm(x) + x = nn.gelu(self.fc1(x)) + x = self.fc2(x) + x = residual + x + + return x, attn + + +class RobertaLMHead(nn.Module): + """ + Masked Language Modeling (MLM) head with tied weights. + + Args: + embed_dim (int): Embedding dimension of the backbone. + output_dim (int): Vocabulary size. + weight (mx.array): Embedding weight matrix for tied projection. + """ + + def __init__(self, embed_dim: int, output_dim: int, weight: mx.array): + super().__init__() + self.dense = nn.Linear(embed_dim, embed_dim) + self.layer_norm = nn.LayerNorm(embed_dim) + self.weight = weight + self.bias = mx.zeros(output_dim) + + def __call__(self, features: mx.array) -> mx.array: + """ + Forward pass for the MLM head. + + Args: + features: Tensor of shape (seq_len, batch, embed_dim). + + Returns: + mx.array: Logits of shape (seq_len, batch, output_dim). + """ + # Transform features before projection to vocab + x = self.dense(features) + x = nn.gelu(x) + x = self.layer_norm(x) + return mx.matmul(x, self.weight.T) + self.bias + + +class ContactPredictionHead(nn.Module): + """ + Predict residue-residue contact probabilities from attention maps. + + Args: + in_features (int): Number of attention channels (layers × heads). + prepend_bos (bool): If True, drop BOS/CLS token attentions. + append_eos (bool): If True, drop EOS token attentions. + bias (bool): Whether the regression layer uses a bias term. + eos_idx (Optional[int]): Token ID for EOS; required if append_eos=True. + """ + + def __init__( + self, + in_features: int, + prepend_bos: bool, + append_eos: bool, + bias: bool = True, + eos_idx: Optional[int] = None, + ): + super().__init__() + self.in_features = in_features + self.prepend_bos = prepend_bos + self.append_eos = append_eos + if append_eos and eos_idx is None: + raise ValueError("append_eos=True but eos_idx was not provided.") + self.eos_idx = eos_idx + self.regression = nn.Linear(in_features, 1, bias=bias) + + def __call__(self, tokens: mx.array, attentions: mx.array) -> mx.array: + """ + Forward pass for contact prediction. + + Args: + tokens: Tensor of shape (B, T). + attentions: Tensor of shape (B, L, H, T, T). + + Returns: + mx.array: Contact probabilities of shape (B, T', T'), + where T' = T - [prepend_bos] - [append_eos]. + """ + # Remove EOS attentions if requested + if self.append_eos: + eos_mask = mx.not_equal(tokens, self.eos_idx).astype(attentions.dtype) + eos_mask = eos_mask[:, None, :] * eos_mask[:, :, None] + attentions = attentions * eos_mask[:, None, None, :, :] + attentions = attentions[..., :-1, :-1] + + # Remove BOS attentions if requested + if self.prepend_bos: + attentions = attentions[..., 1:, 1:] + + # Merge (layers × heads) into channel dimension + batch_size, layers, heads, seqlen, _ = attentions.shape + attentions = attentions.reshape(batch_size, layers * heads, seqlen, seqlen) + + # Symmetrize and apply APC to enhance contact signal + attentions = apc(symmetrize(attentions)) + + # Apply logistic regression over channels + attentions = mx.transpose(attentions, axes=[0, 2, 3, 1]) + logits = self.regression(attentions) + return nn.sigmoid(mx.squeeze(logits, axis=3)) diff --git a/esm/esm/rotary_embedding.py b/esm/esm/rotary_embedding.py new file mode 100644 index 00000000..47f458eb --- /dev/null +++ b/esm/esm/rotary_embedding.py @@ -0,0 +1,114 @@ +from typing import Tuple + +import mlx.core as mx +import mlx.nn as nn + + +def rotate_half(x: mx.array) -> mx.array: + """ + Rotate last dimension by splitting into two halves and swapping. + + Args: + x: Tensor with even-sized last dimension. + + Returns: + mx.array: Tensor of same shape as `x` with halves rotated. + """ + # Split into two equal halves along the last dimension + x1, x2 = mx.split(x, 2, axis=-1) + # Swap halves and negate the second half + return mx.concatenate((-x2, x1), axis=-1) + + +def apply_rotary_pos_emb(x: mx.array, cos: mx.array, sin: mx.array) -> mx.array: + """ + Apply rotary position embeddings to a tensor. + + Args: + x: Input tensor of shape (..., seq_len, dim). + cos: Cosine embedding table of shape (1, seq_len, dim). + sin: Sine embedding table of shape (1, seq_len, dim). + + Returns: + mx.array: Tensor with rotary position embeddings applied. + """ + # Trim cos/sin to match the sequence length of x + cos = cos[:, : x.shape[-2], :] + sin = sin[:, : x.shape[-2], :] + + # Elementwise rotation: (x * cos) + (rotate_half(x) * sin) + return (x * cos) + (rotate_half(x) * sin) + + +class RotaryEmbedding(nn.Module): + """ + Rotary position embedding (RoPE) module. + + Args: + dim (int): Head dimension size (must be even). + """ + + def __init__(self, dim: int, *_, **__): + super().__init__() + # Precompute inverse frequency for each pair of dimensions + self.inv_freq = 1.0 / (10000 ** (mx.arange(0, dim, 2).astype(mx.float32) / dim)) + + # Cache for cosine/sine tables to avoid recomputation + self._seq_len_cached = None + self._cos_cached = None + self._sin_cached = None + + def _update_cos_sin_tables( + self, x: mx.array, seq_dimension: int = 1 + ) -> Tuple[mx.array, mx.array]: + """ + Compute and cache cos/sin tables for the given sequence length. + + Args: + x: Reference tensor for sequence length. + seq_dimension: Axis containing the sequence length. + + Returns: + Tuple of: + cos: Cosine table of shape (1, seq_len, dim). + sin: Sine table of shape (1, seq_len, dim). + """ + seq_len = x.shape[seq_dimension] + # Only update cache if sequence length has changed + if seq_len != self._seq_len_cached: + self._seq_len_cached = seq_len + # Time steps: shape (seq_len,) + t = mx.arange(seq_len).astype(self.inv_freq.dtype) + # Outer product between time and inverse frequency + freqs = mx.einsum("i,j->ij", t, self.inv_freq) + # Duplicate frequencies for cos/sin dimensions + emb = mx.concatenate((freqs, freqs), axis=-1) + + self._cos_cached = mx.cos(emb)[None, :, :] + self._sin_cached = mx.sin(emb)[None, :, :] + + return self._cos_cached, self._sin_cached + + def __call__(self, q: mx.array, k: mx.array) -> Tuple[mx.array, mx.array]: + """ + Apply rotary position embeddings to queries and keys. + + Args: + q: Query tensor of shape (..., seq_len, dim). + k: Key tensor of shape (..., seq_len, dim). + + Returns: + Tuple of: + q_rot: Query tensor with RoPE applied. + k_rot: Key tensor with RoPE applied. + """ + # Get (and cache) cos/sin tables based on key sequence length + self._cos_cached, self._sin_cached = self._update_cos_sin_tables( + k, seq_dimension=-2 + ) + + # Apply rotary embeddings to both q and k + return ( + apply_rotary_pos_emb(q, self._cos_cached, self._sin_cached), + apply_rotary_pos_emb(k, self._cos_cached, self._sin_cached), + ) diff --git a/esm/esm/tokenizer.py b/esm/esm/tokenizer.py new file mode 100644 index 00000000..7c8caf58 --- /dev/null +++ b/esm/esm/tokenizer.py @@ -0,0 +1,241 @@ +import json +from pathlib import Path +from typing import List, Optional, Sequence, Union + +import mlx.core as mx + +# Canonical amino-acid tokens (IUPAC standard + uncommon variants) +PROTEIN_TOKENS = [ + "L", + "A", + "G", + "V", + "S", + "E", + "R", + "T", + "I", + "D", + "P", + "K", + "Q", + "N", + "F", + "Y", + "M", + "H", + "W", + "C", + "X", + "B", + "U", + "Z", + "O", + ".", + "-", +] + +ArrayLike = Union[List[int], mx.array] + + +class ProteinTokenizer: + """ + Protein sequence tokenizer compatible with ESM-2. + + This class converts protein sequences into token IDs and back, following + the vocabulary, special tokens, and formatting rules used by ESM-2. + """ + + def __init__( + self, + vocab_file: Optional[str] = None, + special_tokens_map_file: Optional[str] = None, + ): + """ + Initialize the ProteinTokenizer. + + Args: + vocab_file: Optional path to a file containing the vocabulary, + one token per line. + special_tokens_map_file: Optional path to a JSON file defining + special token names and values. + + If both files are provided, they override the default vocabulary and + special token mappings. Otherwise, defaults are loaded. + """ + + # Load vocabulary from files if given, otherwise use built-in defaults + if vocab_file and special_tokens_map_file: + self._load_from_files(vocab_file, special_tokens_map_file) + else: + self._load_default_vocab() + + # Create token ↔ ID mappings + self.token_to_id = {tok: i for i, tok in enumerate(self.vocab)} + self.id_to_token = {i: tok for i, tok in enumerate(self.vocab)} + + # Cache special token IDs + self.cls_id = self.token_to_id[""] + self.pad_id = self.token_to_id[""] + self.eos_id = self.token_to_id[""] + self.unk_id = self.token_to_id[""] + self.mask_id = self.token_to_id[""] + + # Behavior flags for ESM-2-style BOS/EOS + self.prepend_bos = True + self.append_eos = True + + def _load_from_files(self, vocab_file: str, special_tokens_map_file: str) -> None: + """Load vocabulary and special tokens from the provided files.""" + # Vocabulary file: one token per line + vocab_path = Path(vocab_file) + with open(vocab_path, "r", encoding="utf-8") as f: + self.vocab = [line.strip() for line in f if line.strip()] + + # Special tokens mapping file (JSON) + special_tokens_path = Path(special_tokens_map_file) + with open(special_tokens_path, "r", encoding="utf-8") as f: + self.special_tokens_map = json.load(f) + + def _load_default_vocab(self) -> None: + """Load the built-in ESM vocabulary and special token mapping.""" + # ESM convention: prepend special tokens, then amino acids, then + prepend_toks = ["", "", "", ""] + append_toks = [""] + + self.vocab = prepend_toks + PROTEIN_TOKENS + + # Pad vocab size to multiple of 8 (original implementation detail) + while len(self.vocab) % 8 != 0: + self.vocab.append(f"") + + self.vocab.extend(append_toks) + + # Default special tokens map + self.special_tokens_map = { + "cls_token": "", + "pad_token": "", + "eos_token": "", + "unk_token": "", + "mask_token": "", + } + + def encode( + self, + sequence: str, + *, + add_special_tokens: bool = True, + return_batch_dim: bool = False, + dtype=mx.int32, + ) -> mx.array: + """ + Convert a protein sequence into token IDs. + + Args: + sequence: Protein sequence (case-insensitive). + add_special_tokens: If True, add at the start and at the end. + return_batch_dim: If True, output shape will be (1, L) instead of (L,). + dtype: MLX dtype for the returned array. + + Returns: + mx.array: Token IDs of shape (L,) or (1, L). + """ + ids: List[int] = [] + + if add_special_tokens and self.prepend_bos: + ids.append(self.cls_id) + + # Map each residue to its ID (defaulting to if not in vocab) + for ch in sequence.upper(): + ids.append(self.token_to_id.get(ch, self.unk_id)) + + if add_special_tokens and self.append_eos: + ids.append(self.eos_id) + + arr = mx.array(ids, dtype=dtype) + return mx.expand_dims(arr, axis=0) if return_batch_dim else arr + + def batch_encode( + self, + sequences: Sequence[str], + *, + add_special_tokens: bool = True, + max_length: Optional[int] = None, + dtype=mx.int32, + ) -> mx.array: + """ + Encode multiple protein sequences into a padded batch. + + Args: + sequences: List/sequence of protein strings. + add_special_tokens: If True, add and tokens. + max_length: If provided, truncate sequences to this length before padding. + dtype: MLX dtype for the returned array. + + Returns: + mx.array: Tensor of shape (B, L) with right-padding using IDs. + """ + # Encode each sequence as (L,) + encoded = [ + self.encode(s, add_special_tokens=add_special_tokens, dtype=dtype) + for s in sequences + ] + encoded = [e if e.ndim == 1 else e[0] for e in encoded] + + if max_length is not None: + encoded = [e[:max_length] for e in encoded] + + # Find the longest sequence and right-pad all others + max_len = max((int(e.shape[0]) for e in encoded), default=0) + padded = [] + for e in encoded: + pad_len = max_len - int(e.shape[0]) + if pad_len > 0: + pad = mx.full((pad_len,), self.pad_id, dtype=dtype) + e = mx.concatenate([e, pad], axis=0) + padded.append(e) + + return mx.stack(padded, axis=0) if padded else mx.array([], dtype=dtype) + + def decode( + self, + token_ids: ArrayLike, + *, + skip_special_tokens: bool = False, + ) -> str: + """ + Convert token IDs back into a protein sequence string. + + Args: + token_ids: 1-D or 2-D array/list of IDs. If 2-D, only the first row is decoded. + skip_special_tokens: If True, remove all special tokens from output. + + Returns: + str: Protein sequence. + """ + # Normalize to a 1-D MLX array + if hasattr(token_ids, "shape") and hasattr(token_ids, "tolist"): + ids = token_ids if token_ids.ndim == 1 else token_ids[0] + else: + ids = mx.array(token_ids, dtype=mx.int32) + + ids_list = [int(x) for x in ids.tolist()] + toks: List[str] = [] + + for i in ids_list: + tok = self.id_to_token.get(i, "") + if skip_special_tokens and tok in { + "", + "", + "", + "", + "", + }: + continue + toks.append(tok) + + return "".join(toks) + + def __len__(self) -> int: + """Return the size of the tokenizer’s vocabulary.""" + return len(self.vocab) diff --git a/esm/main.py b/esm/main.py new file mode 100644 index 00000000..9480a03f --- /dev/null +++ b/esm/main.py @@ -0,0 +1,81 @@ +import argparse + +import mlx.core as mx + +from esm import ESM2 + + +def main(): + parser = argparse.ArgumentParser(description="ESM-2 MLX Inference") + parser.add_argument( + "--model-path", + default="checkpoints/mlx-esm2_t33_650M_UR50D", + help="Path to MLX model checkpoint", + ) + parser.add_argument( + "--sequence", + default="MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN", + help="Protein sequence to test (default: human insulin)", + ) + parser.add_argument( + "--mask-position", + type=int, + default=None, + help="Position to mask (default: middle of sequence)", + ) + args = parser.parse_args() + + # Load pretrained ESM-2 model and tokenizer + tokenizer, model = ESM2.from_pretrained(args.model_path) + + # Determine sequence and position to mask + sequence = args.sequence.upper() + mask_pos = ( + args.mask_position if args.mask_position is not None else len(sequence) // 2 + ) + if mask_pos >= len(sequence): + mask_pos = len(sequence) - 1 + original_aa = sequence[mask_pos] # The original amino acid at masked position + + # Display input info + print(f"Original sequence: {sequence}") + print(f"Masked sequence: {sequence[:mask_pos]}{sequence[mask_pos+1:]}") + print(f"Predicting position {mask_pos}: {original_aa}\n") + + # Tokenize sequence before and after the mask + before = tokenizer.encode(sequence[:mask_pos], add_special_tokens=False) + after = tokenizer.encode(sequence[mask_pos + 1 :], add_special_tokens=False) + + # Build token sequence with , , and + tokens = mx.array( + [ + [tokenizer.cls_id] + + before.tolist() + + [tokenizer.mask_id] + + after.tolist() + + [tokenizer.eos_id] + ] + ) + mask_token_pos = 1 + len(before) # Position of token + + # Run model to get logits for each token position + logits = model(tokens)["logits"] + probs = mx.softmax( + logits[0, mask_token_pos, :] + ) # Softmax over vocabulary at mask position + + # Get top-5 most likely tokens + top_indices = mx.argsort(probs)[-5:][::-1] + + # Print predictions + print("Top predictions:") + for i, idx in enumerate(top_indices): + token = tokenizer.vocab[int(idx)] + if token in tokenizer.vocab: + prob = float(probs[idx]) + marker = "✓" if token == original_aa else " " + print(f"{marker} {i+1}. {token}: {prob:.3f} ({prob*100:.1f}%)") + + +if __name__ == "__main__": + main() diff --git a/esm/notebooks/contact_prediction.ipynb b/esm/notebooks/contact_prediction.ipynb new file mode 100644 index 00000000..4098a8a6 --- /dev/null +++ b/esm/notebooks/contact_prediction.ipynb @@ -0,0 +1,748 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3fbacbe4", + "metadata": {}, + "source": [ + "## Predicting Protein Contacts with ESM-2\n", + "\n", + "Understanding how amino acids interact within a folded protein is essential for grasping protein function and stability. Contact prediction, the task of identifying which residues are close together in three-dimensional space, is a key step in the sequence to structure process. ESM-2’s learned attention patterns capture evolutionary signals that encode structural information, which allows the model to predict residue contacts directly from sequence data.\n", + "\n", + "In this notebook, we'll explore ESM-2's ability to predict protein contacts across three diverse proteins from different organisms:\n", + "\n", + "**Bacterial Transport:**\n", + "- **1a3a (PTS Mannitol Component)**: A phosphoenolpyruvate-dependent sugar phosphotransferase system component from *E. coli*, essential for carbohydrate metabolism\n", + "\n", + "**Stress Response:**\n", + "- **5ahw (Universal Stress Protein)**: A conserved stress response protein from *Mycolicibacterium smegmatis* that helps cells survive harsh conditions\n", + "\n", + "**Human Metabolism:**\n", + "- **1xcr (Ester Hydrolase)**: A human enzyme (C11orf54) involved in lipid metabolism and cellular signaling pathways\n", + "\n", + "We will evaluate how effectively ESM-2 captures the structural relationships present in these sequences, measuring precision across different sequence separation ranges to assess both local and long-range contact prediction performance. This notebook is a modified version of a [notebook by the same name](https://github.com/facebookresearch/esm/blob/main/examples/contact_prediction.ipynb) from the [offical ESM repsitory](https://github.com/facebookresearch/esm)." + ] + }, + { + "cell_type": "markdown", + "id": "08352b12", + "metadata": {}, + "source": [ + "### Setup\n", + "\n", + "Here we import all neccessary libraries." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c1047c94", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import List, Tuple, Optional, Dict\n", + "import string\n", + "\n", + "import mlx.core as mx\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from scipy.spatial.distance import squareform, pdist\n", + "import biotite.structure as bs\n", + "from biotite.database import rcsb\n", + "from biotite.structure.io.pdbx import CIFFile, get_structure\n", + "from Bio import SeqIO" + ] + }, + { + "cell_type": "markdown", + "id": "5f0af076", + "metadata": {}, + "source": [ + "Download multiple sequence alignment (MSA) files for our three test proteins from the ESM repository." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3264b66d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 147k 100 147k 0 0 536k 0 --:--:-- --:--:-- --:--:-- 538k\n", + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 127k 100 127k 0 0 485k 0 --:--:-- --:--:-- --:--:-- 486k\n", + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 181k 100 181k 0 0 738k 0 --:--:-- --:--:-- --:--:-- 740k\n" + ] + } + ], + "source": [ + "!mkdir -p data\n", + "!curl -o data/1a3a_1_A.a3m https://raw.githubusercontent.com/facebookresearch/esm/main/examples/data/1a3a_1_A.a3m\n", + "!curl -o data/5ahw_1_A.a3m https://raw.githubusercontent.com/facebookresearch/esm/main/examples/data/5ahw_1_A.a3m\n", + "!curl -o data/1xcr_1_A.a3m https://raw.githubusercontent.com/facebookresearch/esm/main/examples/data/1xcr_1_A.a3m" + ] + }, + { + "cell_type": "markdown", + "id": "cbf1d0cb", + "metadata": {}, + "source": [ + "### Loading the model\n", + "\n", + "Load the ESM-2 model. Change the path below to point to your converted checkpoint." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4406e8a0", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append(\"..\")\n", + "\n", + "from esm import ESM2\n", + "\n", + "esm_checkpoint = \"../checkpoints/mlx-esm2_t33_650M_UR50D\"\n", + "tokenizer, model = ESM2.from_pretrained(esm_checkpoint)" + ] + }, + { + "cell_type": "markdown", + "id": "77596456", + "metadata": {}, + "source": [ + "### Defining functions" + ] + }, + { + "cell_type": "markdown", + "id": "eb5f07ed", + "metadata": {}, + "source": [ + "#### Parsing alignments" + ] + }, + { + "cell_type": "markdown", + "id": "e754abd7", + "metadata": {}, + "source": [ + "This function parses multiple sequence alignment files and clean up insertion artifacts. MSA files often contain lowercase letters and special characters (`.`, `*`) to indicate insertions relative to the reference sequence - these need to be removed to get the core aligned sequences." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "43717bea", + "metadata": {}, + "outputs": [], + "source": [ + "deletekeys = dict.fromkeys(string.ascii_lowercase)\n", + "deletekeys[\".\"] = None\n", + "deletekeys[\"*\"] = None\n", + "translation = str.maketrans(deletekeys)\n", + "\n", + "def read_sequence(filename: str) -> Tuple[str, str]:\n", + " \"\"\" Reads the first (reference) sequences from a fasta or MSA file.\"\"\"\n", + " record = next(SeqIO.parse(filename, \"fasta\"))\n", + " return record.description, str(record.seq)\n", + "\n", + "def remove_insertions(sequence: str) -> str:\n", + " \"\"\" Removes any insertions into the sequence. Needed to load aligned sequences in an MSA. \"\"\"\n", + " return sequence.translate(translation)\n", + "\n", + "def read_msa(filename: str) -> List[Tuple[str, str]]:\n", + " \"\"\" Reads the sequences from an MSA file, automatically removes insertions.\"\"\"\n", + " return [(record.description, remove_insertions(str(record.seq))) for record in SeqIO.parse(filename, \"fasta\")]" + ] + }, + { + "cell_type": "markdown", + "id": "628d7de1", + "metadata": {}, + "source": [ + "#### Converting structures to contacts\n", + "\n", + "There are many ways to define a protein contact. Here we're using the definition of 8 angstroms between carbon beta atoms. Note that the position of the carbon beta is imputed from the position of the N, CA, and C atoms for each residue." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "21e0b44b", + "metadata": {}, + "outputs": [], + "source": [ + "def extend(a, b, c, L, A, D):\n", + " \"\"\"\n", + " input: 3 coords (a,b,c), (L)ength, (A)ngle, and (D)ihedral\n", + " output: 4th coord\n", + " \"\"\"\n", + " def normalize(x):\n", + " return x / np.linalg.norm(x, ord=2, axis=-1, keepdims=True)\n", + "\n", + " bc = normalize(b - c)\n", + " n = normalize(np.cross(b - a, bc))\n", + " m = [bc, np.cross(n, bc), n]\n", + " d = [L * np.cos(A), L * np.sin(A) * np.cos(D), -L * np.sin(A) * np.sin(D)]\n", + " return c + sum([m * d for m, d in zip(m, d)])\n", + "\n", + "def contacts_from_pdb(\n", + " structure: bs.AtomArray,\n", + " distance_threshold: float = 8.0,\n", + " chain: Optional[str] = None,\n", + ") -> np.ndarray:\n", + " \"\"\"Extract contacts from PDB structure.\"\"\"\n", + " mask = ~structure.hetero\n", + " if chain is not None:\n", + " mask &= structure.chain_id == chain\n", + "\n", + " N = structure.coord[mask & (structure.atom_name == \"N\")]\n", + " CA = structure.coord[mask & (structure.atom_name == \"CA\")]\n", + " C = structure.coord[mask & (structure.atom_name == \"C\")]\n", + "\n", + " Cbeta = extend(C, N, CA, 1.522, 1.927, -2.143)\n", + " dist = squareform(pdist(Cbeta))\n", + " \n", + " contacts = dist < distance_threshold\n", + " contacts = contacts.astype(np.int64)\n", + " contacts[np.isnan(dist)] = -1\n", + " return contacts" + ] + }, + { + "cell_type": "markdown", + "id": "5473f306", + "metadata": {}, + "source": [ + "#### Computing contact precisions" + ] + }, + { + "cell_type": "markdown", + "id": "e361a9f3", + "metadata": {}, + "source": [ + "Calculate precision metrics to evaluate contact prediction quality. The `compute_precisions` function ranks predicted contacts by confidence and measures how many of the top predictions are true contacts, while `evaluate_prediction` breaks this down by sequence separation ranges (local, short, medium, long-range) since predicting distant contacts is typically much harder than nearby ones." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "62c37bbd", + "metadata": {}, + "outputs": [], + "source": [ + "def compute_precisions(\n", + " predictions: mx.array,\n", + " targets: mx.array,\n", + " minsep: int = 6,\n", + " maxsep: Optional[int] = None,\n", + " override_length: Optional[int] = None,\n", + ") -> Dict[str, mx.array]:\n", + " \"\"\"Compute precision metrics for contact prediction.\"\"\"\n", + " batch_size, seqlen, _ = predictions.shape\n", + " \n", + " if maxsep is not None:\n", + " sep_mask_2d = mx.abs(mx.arange(seqlen)[None, :] - mx.arange(seqlen)[:, None]) <= maxsep\n", + " targets = targets * sep_mask_2d[None, :]\n", + " \n", + " targets = targets.astype(mx.float32)\n", + " src_lengths = (targets >= 0).sum(axis=-1).sum(axis=-1).astype(mx.float32)\n", + " \n", + " x_ind, y_ind = [], []\n", + " for i in range(seqlen):\n", + " for j in range(i + minsep, seqlen):\n", + " x_ind.append(i)\n", + " y_ind.append(j)\n", + " \n", + " x_ind = mx.array(x_ind)\n", + " y_ind = mx.array(y_ind)\n", + " \n", + " predictions_upper = predictions[:, x_ind, y_ind]\n", + " targets_upper = targets[:, x_ind, y_ind]\n", + "\n", + " topk = seqlen if override_length is None else max(seqlen, override_length)\n", + " indices = mx.argsort(predictions_upper, axis=-1)[:, ::-1][:, :topk]\n", + " \n", + " batch_indices = mx.arange(batch_size)[:, None]\n", + " topk_targets = targets_upper[batch_indices, indices]\n", + " \n", + " if topk_targets.shape[1] < topk:\n", + " pad_shape = (topk_targets.shape[0], topk - topk_targets.shape[1])\n", + " padding = mx.zeros(pad_shape)\n", + " topk_targets = mx.concatenate([topk_targets, padding], 1)\n", + "\n", + " cumulative_dist = mx.cumsum(topk_targets, -1)\n", + "\n", + " gather_lengths = src_lengths[:, None]\n", + " if override_length is not None:\n", + " gather_lengths = override_length * mx.ones_like(gather_lengths)\n", + "\n", + " precision_fractions = mx.arange(0.1, 1.1, 0.1)\n", + " gather_indices = (precision_fractions[None, :] * gather_lengths) - 1\n", + " gather_indices = mx.clip(gather_indices, 0, cumulative_dist.shape[1] - 1)\n", + " gather_indices = gather_indices.astype(mx.int32)\n", + "\n", + " binned_cumulative_dist = cumulative_dist[batch_indices, gather_indices]\n", + " binned_precisions = binned_cumulative_dist / (gather_indices + 1)\n", + "\n", + " pl5 = binned_precisions[:, 1]\n", + " pl2 = binned_precisions[:, 4]\n", + " pl = binned_precisions[:, 9]\n", + " auc = binned_precisions.mean(-1)\n", + "\n", + " return {\"AUC\": auc, \"P@L\": pl, \"P@L2\": pl2, \"P@L5\": pl5}\n", + "\n", + "def evaluate_prediction(\n", + " predictions: mx.array,\n", + " targets: mx.array,\n", + ") -> Dict[str, float]:\n", + " \"\"\"Evaluate contact predictions across different sequence separation ranges.\"\"\"\n", + " contact_ranges = [\n", + " (\"local\", 3, 6),\n", + " (\"short\", 6, 12),\n", + " (\"medium\", 12, 24),\n", + " (\"long\", 24, None),\n", + " ]\n", + " metrics = {}\n", + " \n", + " for name, minsep, maxsep in contact_ranges:\n", + " rangemetrics = compute_precisions(\n", + " predictions,\n", + " targets,\n", + " minsep=minsep,\n", + " maxsep=maxsep,\n", + " )\n", + " for key, val in rangemetrics.items():\n", + " metrics[f\"{name}_{key}\"] = float(val[0])\n", + " return metrics" + ] + }, + { + "cell_type": "markdown", + "id": "5873e052", + "metadata": {}, + "source": [ + "#### Predicting contacts" + ] + }, + { + "cell_type": "markdown", + "id": "2d5778a9", + "metadata": {}, + "source": [ + "This function wraps the tokenization and model inference steps, converting a raw amino acid sequence into token IDs and passing them through ESM-2's contact prediction head to produce a contact probability matrix." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "dddf31a7", + "metadata": {}, + "outputs": [], + "source": [ + "def predict_contacts(sequence: str, model, tokenizer) -> mx.array:\n", + " tokens = tokenizer.encode(sequence)\n", + " tokens = mx.array([tokens])\n", + " contacts = model.predict_contacts(tokens)\n", + " return contacts" + ] + }, + { + "cell_type": "markdown", + "id": "62562401", + "metadata": {}, + "source": [ + "#### Plotting results\n", + "\n", + "This function visualizes contacts as a symmetric matrix where both axes index residue positions. The lower triangle shows the model’s confidence as a blue heatmap, with darker cells indicating higher confidence. The upper triangle overlays evaluation markers: blue dots are correctly predicted contacts (true positives), red dots are predicted but not real (false positives), and grey dots are real contacts the model missed (false negatives)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "03e03791", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_contacts_and_predictions(\n", + " predictions: mx.array,\n", + " contacts: np.ndarray,\n", + " ax,\n", + " title: str,\n", + " cmap: str = \"Blues\",\n", + " ms: float = 1,\n", + "):\n", + " \"\"\"Plot contact predictions and true contacts.\"\"\"\n", + " if isinstance(predictions, mx.array):\n", + " predictions = np.array(predictions)\n", + " \n", + " seqlen = contacts.shape[0]\n", + " relative_distance = np.add.outer(-np.arange(seqlen), np.arange(seqlen))\n", + " bottom_mask = relative_distance < 0\n", + " masked_image = np.ma.masked_where(bottom_mask, predictions)\n", + " invalid_mask = np.abs(np.add.outer(np.arange(seqlen), -np.arange(seqlen))) < 6\n", + " predictions_copy = predictions.copy()\n", + " predictions_copy[invalid_mask] = float(\"-inf\")\n", + "\n", + " topl_val = np.sort(predictions_copy.reshape(-1))[-seqlen]\n", + " pred_contacts = predictions_copy >= topl_val\n", + " true_positives = contacts & pred_contacts & ~bottom_mask\n", + " false_positives = ~contacts & pred_contacts & ~bottom_mask\n", + " other_contacts = contacts & ~pred_contacts & ~bottom_mask\n", + "\n", + " ax.imshow(masked_image, cmap=cmap)\n", + " ax.plot(*np.where(other_contacts), \"o\", c=\"grey\", ms=ms)\n", + " ax.plot(*np.where(false_positives), \"o\", c=\"r\", ms=ms)\n", + " ax.plot(*np.where(true_positives), \"o\", c=\"b\", ms=ms)\n", + " ax.set_title(title)\n", + " ax.axis(\"square\")\n", + " ax.set_xlim([0, seqlen])\n", + " ax.set_ylim([0, seqlen])" + ] + }, + { + "cell_type": "markdown", + "id": "9364c984", + "metadata": {}, + "source": [ + "### Predict and visualize\n", + "Here we'll use ESM-2 contact prediction on our three test proteins and evaluate the results. We'll compute precision metrics across different sequence separation ranges and create contact maps that visualize both the model's predictions and how well they match the true protein structures." + ] + }, + { + "cell_type": "markdown", + "id": "9fa9e59e", + "metadata": {}, + "source": [ + "#### Read Data" + ] + }, + { + "cell_type": "markdown", + "id": "7da50dc2", + "metadata": {}, + "source": [ + "Load experimental protein structures from the Protein Data Bank and extract true contact maps for evaluation, while also parsing the reference sequences from our MSA files that will serve as input to ESM-2." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2d276137", + "metadata": {}, + "outputs": [], + "source": [ + "PDB_IDS = [\"1a3a\", \"5ahw\", \"1xcr\"]\n", + "\n", + "structures = {\n", + " name.lower(): get_structure(CIFFile.read(rcsb.fetch(name, \"cif\")))[0]\n", + " for name in PDB_IDS\n", + "}\n", + "\n", + "contacts = {\n", + " name: contacts_from_pdb(structure, chain=\"A\") \n", + " for name, structure in structures.items()\n", + "}\n", + "\n", + "msas = {\n", + " name: read_msa(f\"data/{name.lower()}_1_A.a3m\")\n", + " for name in PDB_IDS\n", + "}\n", + "\n", + "sequences = {\n", + " name: msa[0] for name, msa in msas.items()\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "4ce64f18", + "metadata": {}, + "source": [ + "#### ESM-2 predictions" + ] + }, + { + "cell_type": "markdown", + "id": "1f2da88f", + "metadata": {}, + "source": [ + "##### Evaluate predictions" + ] + }, + { + "cell_type": "markdown", + "id": "0adb0a11", + "metadata": {}, + "source": [ + "This loop generates contact predictions for each protein using ESM-2, compares them against the experimentally determined structures, and computes precision metrics across different sequence separation ranges to evaluate model performance." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "941b4afa", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idmodellocal_AUClocal_P@Llocal_P@L2local_P@L5short_AUCshort_P@Lshort_P@L2short_P@L5medium_AUCmedium_P@Lmedium_P@L2medium_P@L5long_AUClong_P@Llong_P@L2long_P@L5
01a3aESM-2 (Unsupervised)0.1931030.1931030.1931030.1931030.1724140.1724140.1724140.1724140.2620690.2620690.2620690.2620690.6896550.6896550.6896550.689655
15ahwESM-2 (Unsupervised)0.0240000.0240000.0240000.0240000.1360000.1360000.1360000.1360000.1440000.1440000.1440000.1440000.8640000.8640000.8640000.864000
21xcrESM-2 (Unsupervised)0.1118210.1118210.1118210.1118210.1597440.1597440.1597440.1597440.1757190.1757190.1757190.1757190.4089460.4089460.4089460.408946
\n", + "
" + ], + "text/plain": [ + " id model local_AUC local_P@L local_P@L2 local_P@L5 \\\n", + "0 1a3a ESM-2 (Unsupervised) 0.193103 0.193103 0.193103 0.193103 \n", + "1 5ahw ESM-2 (Unsupervised) 0.024000 0.024000 0.024000 0.024000 \n", + "2 1xcr ESM-2 (Unsupervised) 0.111821 0.111821 0.111821 0.111821 \n", + "\n", + " short_AUC short_P@L short_P@L2 short_P@L5 medium_AUC medium_P@L \\\n", + "0 0.172414 0.172414 0.172414 0.172414 0.262069 0.262069 \n", + "1 0.136000 0.136000 0.136000 0.136000 0.144000 0.144000 \n", + "2 0.159744 0.159744 0.159744 0.159744 0.175719 0.175719 \n", + "\n", + " medium_P@L2 medium_P@L5 long_AUC long_P@L long_P@L2 long_P@L5 \n", + "0 0.262069 0.262069 0.689655 0.689655 0.689655 0.689655 \n", + "1 0.144000 0.144000 0.864000 0.864000 0.864000 0.864000 \n", + "2 0.175719 0.175719 0.408946 0.408946 0.408946 0.408946 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predictions = {}\n", + "results = []\n", + "\n", + "for pdb_id in sequences:\n", + " _, sequence = sequences[pdb_id]\n", + " prediction = predict_contacts(sequence, model, tokenizer)\n", + " predictions[pdb_id] = prediction[0]\n", + " \n", + " true_contacts = mx.array(contacts[pdb_id])\n", + " \n", + " min_len = min(prediction.shape[1], true_contacts.shape[0])\n", + " pred_trimmed = prediction[:, :min_len, :min_len]\n", + " true_trimmed = true_contacts[:min_len, :min_len]\n", + " true_trimmed = mx.expand_dims(true_trimmed, axis=0)\n", + " \n", + " metrics = evaluate_prediction(pred_trimmed, true_trimmed)\n", + " result = {\"id\": pdb_id, \"model\": \"ESM-2 (Unsupervised)\"}\n", + " result.update(metrics)\n", + " results.append(result)\n", + "\n", + "results_df = pd.DataFrame(results)\n", + "display(results_df)" + ] + }, + { + "cell_type": "markdown", + "id": "c5c7418a", + "metadata": {}, + "source": [ + "The results demonstrate that ESM-2 excels at predicting long-range contacts, with precision scores ranging from 40.9% to 86.4% for residues more than 24 positions apart. Performance is consistently higher for distant contacts compared to local ones. For example, the universal stress protein (5ahw) achieves 86.4% precision for long-range contacts but only 2.4% for local contacts between 3 and 6 residues apart. This trend is observed across all three proteins, with medium-range contacts (12–24 residues apart) and short-range contacts (6–12 residues apart) showing intermediate accuracy. These results suggest that ESM-2 has learned to identify evolutionarily conserved structural motifs that connect distant regions of the sequence, which are often critical for protein fold stability and function." + ] + }, + { + "cell_type": "markdown", + "id": "487cff51", + "metadata": {}, + "source": [ + "##### Plot contacts and predictions" + ] + }, + { + "cell_type": "markdown", + "id": "10291191", + "metadata": {}, + "source": [ + "This analysis generates contact map visualizations for all three proteins, presenting ESM-2’s predictions as heatmaps and overlaying the true experimental contacts as colored dots." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "628efc10", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "proteins = [r['id'] for r in results]\n", + "fig, axes = plt.subplots(figsize=(6 * len(proteins), 6), ncols=len(proteins))\n", + "if len(proteins) == 1:\n", + " axes = [axes]\n", + "\n", + "for ax, pdb_id in zip(axes, proteins):\n", + " prediction = predictions[pdb_id]\n", + " target = contacts[pdb_id]\n", + " \n", + " result = next(r for r in results if r['id'] == pdb_id)\n", + " long_pl = result['long_P@L']\n", + " \n", + " plot_contacts_and_predictions(\n", + " prediction, target, ax=ax, \n", + " title=f\"{pdb_id}: Long Range P@L: {100 * long_pl:.1f}%\"\n", + " )\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "99e1edaf", + "metadata": {}, + "source": [ + "The contact maps highlight ESM-2’s strong ability to detect long-range structural relationships. In each panel, the lower triangle shows model predictions, where darker blue regions indicate high-confidence contacts, and the upper triangle shows the corresponding experimental data. Correct predictions appear as blue dots, forming distinct off-diagonal patterns in 5ahw and 1a3a that capture key global fold interactions. Red dots mark false positives, which are relatively rare, while grey dots represent missed contacts. These missed contacts are notably more frequent in 1xcr, consistent with its lower long-range precision. The dense clusters of blue true positives in 5ahw, compared to the sparser, fragmented patterns in 1xcr, clearly illustrate the variation in predictive performance across proteins." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/esm/notebooks/embeddings.ipynb b/esm/notebooks/embeddings.ipynb new file mode 100644 index 00000000..74ca2ad6 --- /dev/null +++ b/esm/notebooks/embeddings.ipynb @@ -0,0 +1,386 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "acfe011d", + "metadata": {}, + "source": [ + "## Exploring Protein Relationships Through ESM-2 Embeddings\n", + "\n", + "Proteins are molecular machines with unique structures that determine their functions. ESM-2 treats protein sequences as a language, learning representations that capture evolutionary and functional relationships without relying on traditional sequence alignment.\n", + "\n", + "In this notebook, we'll explore how ESM-2 embeddings reveal relationships between six human proteins:\n", + "\n", + "**Oxygen Transport & Storage:**\n", + "- **Hemoglobin Beta**: The oxygen-carrying protein in red blood cells, part of the tetrameric hemoglobin complex\n", + "- **Myoglobin**: The oxygen storage protein in muscle tissue, structurally similar to individual hemoglobin subunits\n", + "\n", + "**Defense & Immunity:**\n", + "- **Lysozyme C**: An antimicrobial enzyme that breaks down bacterial cell walls, found in tears, saliva, and mucus\n", + "- **Defensin Beta 4A**: A small antimicrobial peptide that directly kills bacteria and other pathogens\n", + "\n", + "**Structural Support:**\n", + "- **Alpha-1 Type I Collagen**: The most abundant protein in the human body, providing strength to bones, skin, and connective tissues\n", + "- **Elastin**: The protein that gives tissues their elasticity, crucial for arteries, lungs, and skin" + ] + }, + { + "cell_type": "markdown", + "id": "20f98f7f", + "metadata": {}, + "source": [ + "### Setup\n", + "\n", + "Here we import all neccessary libraries." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2bacd1ff", + "metadata": {}, + "outputs": [], + "source": [ + "import mlx.core as mx\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from sklearn.decomposition import PCA\n", + "from sklearn.manifold import TSNE\n", + "import pandas as pd" + ] + }, + { + "cell_type": "markdown", + "id": "5563c495", + "metadata": {}, + "source": [ + "These are our protein sequences, obtained from [UniProt](https://www.uniprot.org/)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b8e9d6d2", + "metadata": {}, + "outputs": [], + "source": [ + "proteins = [\n", + " # Oxygen Transport\n", + " (\"Hemoglobin Beta\", \"MVHLTPEEKSAVTALWGKVNVDEVGGEALGRLLVVYPWTQRFFESFGDLSTPDAVMGNPKVKAHGKKVLGAFSDGLAHLDNLKGTFATLSELHCDKLHVDPENFRLLGNVLVCVLAHHFGKEFTPPVQAAYQKVVAGVANALAHKYH\"),\n", + " (\"Myoglobin\", \"MGLSDGEWQLVLNVWGKVEADIPGHGQEVLIRLFKGHPETLEKFDKFKHLKSEDEMKASEDLKKHGATVLTALGGILKKKGHHEAEIKPLAQSHATKHKIPVKYLEFISECIIQVLQSKHPGDFGADAQGAMNKALELFRKDMASNYKELGFQG\"),\n", + "\n", + " # Antimicrobial Defense\n", + " (\"Lysozyme C\", \"MKALIVLGLVLLSVTVQGKVFERCELARTLKRLGMDGYRGISLANWMCLAKWESGYNTRATNYNAGDRSTDYGIFQINSRYWCNDGKTPGAVNACHLSCSALLQDNIADAVACAKRVVRDPQGIRAWVAWRNRCQNRDVRQYVQGCGV\"),\n", + " (\"Defensin Beta 4A\", \"MRVLYLLFSFLFIFLMPLPGVFGGIGDPVTCLKSGAICHPVFCPRRYKQIGTCGLPGTKCCKKP\"),\n", + "\n", + " # Structural Proteins\n", + " (\"Alpha-1 Type I Collagen\", \"MFSFVDLRLLLLLAATALLTHGQEEGQVEGQDEDIPPITCVQNGLRYHDRDVWKPEPCRICVCDNGKVLCDDVICDETKNCPGAEVPEGECCPVCPDGSESPTDQETTGVEGPKGDTGPRGPRGPAGPPGRDGIPGQPGLPGPPGPPGPPGPPGLGGNFAPQLSYGYDEKSTGGISVPGPMGPSGPRGLPGPPGAPGPQGFQGPPGEPGEPGASGPMGPRGPPGPPGKNGDDGEAGKPGRPGERGPPGPQGARGLPGTAGLPGMKGHRGFSGLDGAKGDAGPAGPKGEPGSPGENGAPGQMGPRGLPGERGRPGAPGPAGARGNDGATGAAGPPGPTGPAGPPGFPGAVGAKGEAGPQGPRGSEGPQGVRGEPGPPGPAGAAGPAGNPGADGQPGAKGANGAPGIAGAPGFPGARGPSGPQGPGGPPGPKGNSGEPGAPGSKGDTGAKGEPGPVGVQGPPGPAGEEGKRGARGEPGPTGLPGPPGERGGPGSRGFPGADGVAGPKGPAGERGSPGPAGPKGSPGEAGRPGEAGLPGAKGLTGSPGSPGPDGKTGPPGPAGQDGRPGPPGPPGARGQAGVMGFPGPKGAAGEPGKAGERGVPGPPGAVGPAGKDGEAGAQGPPGPAGPAGERGEQGPAGSPGFQGLPGPAGPPGEAGKPGEQGVPGDLGAPGPSGARGERGFPGERGVQGPPGPAGPRGANGAPGNDGAKGDAGAPGAPGSQGAPGLQGMPGERGAAGLPGPKGDRGDAGPKGADGSPGKDGVRGLTGPIGPPGPAGAPGDKGESGPSGPAGPTGARGAPGDRGEPGPPGPAGFAGPPGADGQPGAKGEPGDAGAKGDAGPPGPAGPAGPPGPIGNVGAPGAKGARGSAGPPGATGFPGAAGRVGPPGPSGNAGPPGPPGPAGKEGGKGPRGETGPAGRPGEVGPPGPPGPAGEKGSPGADGPAGAPGTPGPQGIAGQRGVVGLPGQRGERGFPGLPGPSGEPGKQGPSGASGERGPPGPMGPPGLAGPPGESGREGAPGAEGSPGRDGSPGAKGDRGETGPAGPPGAPGAPGAPGPVGPAGKSGDRGETGPAGPAGPVGPVGARGPAGPQGPRGDKGETGEQGDRGIKGHRGFSGLQGPPGPPGSPGEQGPSGASGPAGPRGPPGSAGAPGKDGLNGLPGPIGPPGPRGRTGDAGPVGPPGPPGPPGPPGPPSAGFDFSFLPQPPQEKAHDGGRYYRADDANVVRDRDLEVDTTLKSLSQQIENIRSPEGSRKNPARTCRDLKMCHSDWKSGEYWIDPNQGCNLDAIKVFCNMETGETCVYPTQPSVAQKNWYISKNPKDKRHVWFGESMTDGFQFEYGGQGSDPADVAIQLTFLRLMSTEASQNITYHCKNSVAYMDQQTGNLKKALLLQGSNEIEIRAEGNSRFTYSVTVDGCTSHTGAWGKTVIEYKTTKTSRLPIIDVAPLDVGAPDQEFGFDVGPVCFL\"),\n", + " (\"Elastin\", \"MAGLTAAAPRPGVLLLLLSILHPSRPGGVPGAIPGGVPGGVFYPGAGLGALGGGALGPGGKPLKPVPGGLAGAGLGAGLGAFPAVTFPGALVPGGVADAAAAYKAAKAGAGLGGVPGVGGLGVSAGAVVPQPGAGVKPGKVPGVGLPGVYPGGVLPGARFPGVGVLPGVPTGAGVKPKAPGVGGAFAGIPGVGPFGGPQPGVPLGYPIKAPKLPGGYGLPYTTGKLPYGYGPGGVAGAAGKAGYPTGTGVGPQAAAAAAAKAAAKFGAGAAGVLPGVGGAGVPGVPGAIPGIGGIAGVGTPAAAAAAAAAAKAAKYGAAAGLVPGGPGFGPGVVGVPGAGVPGVGVPGAGIPVVPGAGIPGAAVPGVVSPEAAAKAAAKAAKYGARPGVGVGGIPTYGVGAGGFPGFGVGVGGIPGVAGVPGVGGVPGVGGVPGVGISPEAQAAAAAKAAKYGAAGAGVLGGLVPGAPGAVPGVPGTGGVPGVGTPAAAAAKAAAKAAQFGLVPGVGVAPGVGVAPGVGVAPGVGLAPGVGVAPGVGVAPGVGVAPGIGPGGVAAAAKSAAKVAAKAQLRAAAGLGAGIPGLGVGVGVPGLGVGAGVPGLGVGAGVPGFGAGADEGVRRSLSPELREGDPSSSQHLPSTPSSPRVPGALAAAKAAKYGAAVPGVLGGLGALGGVGIPGGVVGAGPAAAAAAAKAAAKAAQFGLVGAAGLGGLGVGGLGVPGVGGLGGIPPAAAAKAAKYGAAGLGGVLGGAGQFPLGGVAARPGFGLSPIFPGGACLGKACGRKRK\"),\n", + "]" + ] + }, + { + "cell_type": "markdown", + "id": "c9621578", + "metadata": {}, + "source": [ + "### Loading the model and tokenizing a sequence\n", + "\n", + "First, load the ESM-2 model. Change the path below to point to your converted checkpoint.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "05696400", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append(\"..\")\n", + "\n", + "from esm import ESM2\n", + "\n", + "esm_checkpoint = \"../checkpoints/mlx-esm2_t33_650M_UR50D\"\n", + "tokenizer, model = ESM2.from_pretrained(esm_checkpoint)" + ] + }, + { + "cell_type": "markdown", + "id": "2916adbb", + "metadata": {}, + "source": [ + "Here, we tokenize and decode the protein sequence for human Insulin." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "47178dcd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sequence: MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN\n", + "Tokens: array([0, 20, 5, ..., 23, 17, 2], dtype=int32)\n", + "Decoded: MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN\n" + ] + } + ], + "source": [ + "human_insulin_sequence = \"MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN\"\n", + "tokens = tokenizer.encode(human_insulin_sequence)\n", + "print(f\"Sequence: {human_insulin_sequence}\")\n", + "print(f\"Tokens: {tokens}\")\n", + "print(f\"Decoded: {tokenizer.decode(tokens)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "c1b73ded", + "metadata": {}, + "source": [ + "### Embedding sequences\n", + "\n", + "To compute the embeddings of our proteins, we pass each protein sequence through ESM-2's tokenizer to convert amino acids into token IDs, then extract the final layer representations using `get_sequence_representations()`. This process gives us a vector for each protein that captures its learned functional and evolutionary features." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cb470957", + "metadata": {}, + "outputs": [], + "source": [ + "def extract_embeddings(model, protein_list):\n", + " embeddings = []\n", + " names = []\n", + " for name, sequence in protein_list:\n", + " tokens = model.tokenizer.encode(sequence, return_batch_dim=True)\n", + " embedding = model.get_sequence_representations(tokens, layer=-1)\n", + " embeddings.append(embedding[0])\n", + " names.append(name)\n", + " return mx.stack(embeddings), names" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "38e83142", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Embedding shape: (6, 1280)\n", + "Each protein represented by 1280 features\n" + ] + } + ], + "source": [ + "embeddings, protein_names = extract_embeddings(model, proteins)\n", + "print(f\"\\nEmbedding shape: {embeddings.shape}\")\n", + "print(f\"Each protein represented by {embeddings.shape[1]} features\")" + ] + }, + { + "cell_type": "markdown", + "id": "fccd2a99", + "metadata": {}, + "source": [ + "### Protein embedding similarity matrix\n", + "\n", + "We can measure how similar the protein embeddings are by calculating a similarity matrix. We normalize each embedding to unit length and compute cosine similarities between all pairs, producing a matrix where values close to 1 indicate highly similar proteins and values close to 0 indicate dissimilar ones." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "93d14fff", + "metadata": {}, + "outputs": [], + "source": [ + "def compute_similarity_matrix(embeddings):\n", + " normalized = embeddings / mx.linalg.norm(embeddings, axis=1, keepdims=True)\n", + " similarity_matrix = normalized @ normalized.T\n", + " return similarity_matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3485f854", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "similarity_matrix = compute_similarity_matrix(embeddings)\n", + "\n", + "plt.figure(figsize=(8, 6))\n", + "similarity_np = np.array(similarity_matrix)\n", + "\n", + "sim_df = pd.DataFrame(similarity_np, \n", + " index=protein_names, \n", + " columns=protein_names)\n", + "\n", + "sns.heatmap(sim_df, annot=True, cmap='viridis', \n", + " fmt='.3f', square=True, cbar_kws={'label': 'Cosine Similarity'})\n", + "plt.title('Protein Similarity Matrix (ESM-2 Embeddings)', fontsize=14)\n", + "plt.xticks(rotation=45, ha='right')\n", + "plt.yticks(rotation=0)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1532dfc5", + "metadata": {}, + "source": [ + "The similarity matrix shows both expected and unexpected relationships in ESM-2’s learned representations. We see clear functional clustering for oxygen-binding proteins such as Hemoglobin Beta and Myoglobin, which have a similarity score of 0.986, and for structural proteins such as Collagen and Elastin, which have a similarity score of 0.852. Interestingly, Lysozyme C shows high similarity to both Myoglobin, with a score of 0.906, and Hemoglobin Beta, with a score of 0.921, even though it is an antimicrobial enzyme. This is because ESM-2 has likely learned that these three proteins share a fundamental blueprint of compact globular proteins, including similar size, folding patterns, and structural stability that go beyond their specific biological functions. We will use PCA and t-SNE to better visualize how these proteins cluster in the high dimensional embedding space." + ] + }, + { + "cell_type": "markdown", + "id": "66794597", + "metadata": {}, + "source": [ + "### PCA visualization\n", + "\n", + "PCA (Principal Component Analysis) reduces high-dimensional data to a lower-dimensional representation by finding the directions of maximum variance in the data. This allows us to visualize our high-dimensional protein embeddings in 2D space while preserving the most important patterns of similarity and difference between proteins." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "67afd74e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pca = PCA(n_components=2)\n", + "pca_result = pca.fit_transform(np.array(embeddings))\n", + "\n", + "plt.figure(figsize=(12, 5))\n", + "\n", + "plt.subplot(1, 2, 1)\n", + "plt.scatter(pca_result[:, 0], pca_result[:, 1], s=100, alpha=0.7)\n", + "for i, name in enumerate(protein_names):\n", + " plt.annotate(name, (pca_result[i, 0], pca_result[i, 1]), \n", + " xytext=(5, 5), textcoords='offset points', fontsize=9)\n", + "plt.xlabel(f'PC1 ({pca.explained_variance_ratio_[0]:.1%} variance)')\n", + "plt.ylabel(f'PC2 ({pca.explained_variance_ratio_[1]:.1%} variance)')\n", + "plt.title('PCA of Protein Embeddings')\n", + "plt.grid(True, alpha=0.3)" + ] + }, + { + "cell_type": "markdown", + "id": "4dd24749", + "metadata": {}, + "source": [ + "The PCA analysis reveals clear groupings among the proteins. Hemoglobin Beta and Myoglobin, both oxygen-binding proteins, cluster tightly in the bottom right, while Lysozyme C and Defensin Beta 4A, both antimicrobial proteins, group together in the middle. In contrast, Collagen and Elastin appear isolated and far apart. However, this apparent separation is misleading. Because PCA is a linear dimensionality reduction method that captures only the directions of maximum variance, the high similarity between Collagen and Elastin (0.852 in our matrix) may lie in dimensions that contribute little to the variance represented by the first two principal components." + ] + }, + { + "cell_type": "markdown", + "id": "9099082f", + "metadata": {}, + "source": [ + "### t-SNE visualization\n", + "\n", + "t-SNE (t-distributed Stochastic Neighbor Embedding) is a non-linear dimensionality reduction method designed to preserve local structure, ensuring that points close in the original high-dimensional space remain close in the low-dimensional representation. Unlike PCA, which captures global variance through a linear transformation, t-SNE can uncover intricate clustering patterns and subtle local relationships that linear methods may obscure." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4f24b218", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tsne = TSNE(n_components=2, random_state=42, perplexity=3)\n", + "tsne_result = tsne.fit_transform(np.array(embeddings))\n", + "plt.figure(figsize=(12, 5))\n", + "plt.subplot(1, 2, 2)\n", + "plt.scatter(tsne_result[:, 0], tsne_result[:, 1], s=100, alpha=0.7)\n", + "for i, name in enumerate(protein_names):\n", + " plt.annotate(name, (tsne_result[i, 0], tsne_result[i, 1]), \n", + " xytext=(5, 5), textcoords='offset points', fontsize=9)\n", + "plt.xlabel('t-SNE 1')\n", + "plt.ylabel('t-SNE 2')\n", + "plt.title('t-SNE of Protein Embeddings')\n", + "plt.grid(True, alpha=0.3)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f312fb11", + "metadata": {}, + "source": [ + "The t-SNE visualization uncovers more nuanced clustering than PCA, revealing relationships that were previously obscured. Notably, the structural proteins Collagen and Elastin now cluster together in the upper right, reflecting their functional similarity that PCA failed to capture. The oxygen-binding proteins Hemoglobin Beta and Myoglobin remain grouped in the bottom left, consistent with both analyses. In contrast, the antimicrobial proteins separate, with Lysozyme C positioned centrally and Defensin Beta 4A isolated in the bottom right. This separation indicates that ESM-2 has likely learned to distinguish between fundamentally different antimicrobial strategies: Lysozyme, a large enzyme (148 amino acids) that enzymatically cleaves bacterial cell walls, and Defensin, a small peptide (64 amino acids) that disrupts bacterial membranes via direct interaction. Despite their shared antimicrobial role, ESM-2 appears to encode them as distinct in both architecture and mechanism." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/esm/notebooks/mutation_effect_prediction.ipynb b/esm/notebooks/mutation_effect_prediction.ipynb new file mode 100644 index 00000000..ac2ffe16 --- /dev/null +++ b/esm/notebooks/mutation_effect_prediction.ipynb @@ -0,0 +1,662 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d28ac072", + "metadata": {}, + "source": [ + "## Zero-Shot Mutation Effect Prediction with ESM-2\n", + "\n", + "Protein function depends on its amino acid sequence, and even one change can alter activity, stability, or binding. Traditional methods to study these effects are costly and slow. ESM-2 offers a faster alternative, predicting mutation impacts from sequence alone. Trained on millions of proteins with masked language modeling, it learns which substitutions preserve function and stability from evolutionary patterns.\n", + "\n", + "In this notebook, we'll be scoring mutations, meaning we will quantify how much each amino acid change is predicted to affect the protein’s function or stability.\n", + "\n", + "To score a mutation, we:\n", + "1. **Mask** the position of interest in the protein sequence\n", + "2. **Predict** probabilities for all 20 amino acids at that position \n", + "3. **Compare** the probabilities of the wild-type vs. mutant amino acid\n", + "4. **Calculate** a log-likelihood ratio (LLR) score\n", + "\n", + "**Negative scores** indicate deleterious mutations (model assigns lower probability to the mutant), while **positive scores** suggest beneficial or neutral changes.\n", + "\n", + "We'll demonstrate mutation effect prediction using **β-lactamase TEM from *E. coli***, a clinically important antibiotic resistance enzyme. This protein hydrolyzes β-lactam antibiotics and is one of the most common resistance mechanisms in clinical isolates. TEM-1 was extensively characterized through deep mutational scanning by [Stiffler et al. (2015)](https://www.cell.com/fulltext/S0092-8674%2815%2900078-1), who measured the fitness effects of nearly 5,000 single amino acid mutations. We'll use their experimental data to validate our ESM-2 predictions and demonstrate how well the model captures functional constraints.\n" + ] + }, + { + "cell_type": "markdown", + "id": "a98816a3", + "metadata": {}, + "source": [ + "### Setup\n", + "\n", + "Here we import all neccessary libraries." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "24652854", + "metadata": {}, + "outputs": [], + "source": [ + "import mlx.core as mx\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.patches import Rectangle\n", + "from tqdm.auto import tqdm\n", + "import pandas as pd\n", + "from scipy.stats import spearmanr" + ] + }, + { + "cell_type": "markdown", + "id": "fb407955", + "metadata": {}, + "source": [ + "Download the experimental deep mutational scanning dataset from Stiffler et al. (2015) for validation of our predictions." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "bd229ffc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 1693k 100 1693k 0 0 7621k 0 --:--:-- --:--:-- --:--:-- 7630k\n" + ] + } + ], + "source": [ + "!mkdir -p data\n", + "!curl -o data/BLAT_ECOLX_Ranganathan2015.csv https://raw.githubusercontent.com/facebookresearch/esm/refs/heads/main/examples/variant-prediction/data/BLAT_ECOLX_Ranganathan2015.csv" + ] + }, + { + "cell_type": "markdown", + "id": "52c8a805", + "metadata": {}, + "source": [ + "Load the ESM-2 model. Change the path below to point to your converted checkpoint." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5e694b81", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append(\"..\")\n", + "\n", + "from esm import ESM2\n", + "\n", + "esm_checkpoint = \"../checkpoints/mlx-esm2_t12_35M_UR50D\"\n", + "tokenizer, model = ESM2.from_pretrained(esm_checkpoint)" + ] + }, + { + "cell_type": "markdown", + "id": "b69be9f9", + "metadata": {}, + "source": [ + "Here we define the mature TEM-1 β-lactamase sequence (263 amino acids, signal peptide removed) and coordinate conversion constants for mapping between UniProt numbering and our sequence indices." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b1b30eae", + "metadata": {}, + "outputs": [], + "source": [ + "UNIPROT_START_OF_MATURE = 24\n", + "\n", + "sequence = (\n", + " \"HPETLVKVKDAEDQLGARVGYIELDLNSGKILESFRPEERFPMMSTFKVLLCGAVLSRVDAGQEQLGRRIHYSQNDLVEYSPVTEKHLTDGMTVRELCSAAITMSDNTAANLLLTTIGGPKELTAFLHNMGDHVTRLDRWEPELNEAIPNDERDTTMPAAMATTLRKLLTGELLTLASRQQLIDWMEADKVAGPLLRSALPAGWFIADKSGAGERGSRGIIAALGPDGKPSRIVVIYTTGSQATMDERNRQIAEIGASLIKHW\"\n", + ")\n", + "\n", + "amino_acids = list(\"ACDEFGHIKLMNPQRSTVWY\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "bd0f037c", + "metadata": {}, + "source": [ + "### Function Definitions" + ] + }, + { + "cell_type": "markdown", + "id": "4c42edf4", + "metadata": {}, + "source": [ + "These functions handle coordinate conversion between UniProt numbering (which includes the signal peptide) and our mature sequence indices, enabling us to map experimental data positions to the correct sequence locations." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6c619e5c", + "metadata": {}, + "outputs": [], + "source": [ + "def u2m0(u_pos):\n", + " \"\"\"Convert UniProt position (1-based) to 0-based index into mature sequence.\"\"\"\n", + " m0 = u_pos - UNIPROT_START_OF_MATURE\n", + " return m0 if 0 <= m0 else None\n", + "\n", + "def urange_to_m0_span(u_start_incl, u_end_incl):\n", + " \"\"\"Convert UniProt range to [start, end) mature 0-based slice.\"\"\"\n", + " s0 = u2m0(u_start_incl)\n", + " e0 = u2m0(u_end_incl)\n", + " if s0 is None: s0 = 0\n", + " if e0 is None: e0 = -1\n", + " s0 = max(0, s0)\n", + " e0 = min(len(sequence) - 1, e0)\n", + " if s0 > e0:\n", + " return None\n", + " return s0, e0 + 1\n" + ] + }, + { + "cell_type": "markdown", + "id": "8ac3e9e4", + "metadata": {}, + "source": [ + "These are the core mutation scoring functions that implement ESM-2's masked language modeling approach. They mask a position in the sequence, predict amino acid probabilities using the model, and calculate log-likelihood ratios (LLR) comparing mutant versus wild-type amino acids." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5c880801", + "metadata": {}, + "outputs": [], + "source": [ + "def get_site_log_probs(m0_pos):\n", + " \"\"\"Get log probabilities for all amino acids at a masked position.\"\"\"\n", + " tokens = tokenizer.encode(sequence)\n", + " input_ids = mx.array(tokens).reshape(1, -1)\n", + " masked = mx.array(input_ids)\n", + " masked[0, m0_pos + 1] = tokenizer.mask_id\n", + " logits = model(masked)[\"logits\"]\n", + " return mx.log(mx.softmax(logits[0, m0_pos + 1], axis=-1))\n", + "\n", + "def score_mutation_llr(u_pos, wt_aa, mut_aa):\n", + " \"\"\"Calculate log-likelihood ratio for a specific mutation.\"\"\"\n", + " m0 = u2m0(u_pos)\n", + " if m0 is None or m0 >= len(sequence):\n", + " return np.nan\n", + " \n", + " log_probs = get_site_log_probs(m0)\n", + " wt_tok = tokenizer.token_to_id.get(wt_aa, tokenizer.unk_id)\n", + " mt_tok = tokenizer.token_to_id.get(mut_aa, tokenizer.unk_id)\n", + " return float(log_probs[mt_tok].item() - log_probs[wt_tok].item())\n", + "\n", + "def score_position_llrs(m0_pos):\n", + " \"\"\"Get LLR scores for all 20 amino acids at a given position.\"\"\"\n", + " log_probs = get_site_log_probs(m0_pos)\n", + " wt = sequence[m0_pos]\n", + " wt_token = tokenizer.token_to_id.get(wt, tokenizer.unk_id)\n", + " wt_lp = float(log_probs[wt_token].item())\n", + " \n", + " scores = np.zeros(len(amino_acids), dtype=float)\n", + " for i, aa in enumerate(amino_acids):\n", + " mt_tok = tokenizer.token_to_id.get(aa, tokenizer.unk_id)\n", + " scores[i] = float(log_probs[mt_tok].item()) - wt_lp\n", + " return scores\n" + ] + }, + { + "cell_type": "markdown", + "id": "b2579edb", + "metadata": {}, + "source": [ + "This function generates a mutation effect heatmap for a specified protein region. It calculates LLR scores for all 20 amino acids at each position within the given UniProt range, creating a matrix that visualizes the predicted functional impact of every possible single amino acid substitution." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b83d7f7d", + "metadata": {}, + "outputs": [], + "source": [ + "def generate_heatmap(u_start_incl, u_end_incl):\n", + " \"\"\"Generate mutation effect heatmap for a UniProt range.\"\"\"\n", + " span = urange_to_m0_span(u_start_incl, u_end_incl)\n", + " if span is None:\n", + " raise ValueError(\"Requested UniProt window lies outside the mature sequence.\")\n", + " \n", + " s0, e0 = span\n", + " n_cols = e0 - s0\n", + " heatmap = np.zeros((len(amino_acids), n_cols), dtype=float)\n", + " \n", + " print(f\"Calculating mutation effects for UniProt {u_start_incl}-{u_end_incl} \")\n", + " \n", + " for j, m0 in enumerate(tqdm(range(s0, e0), desc=\"Positions\")):\n", + " heatmap[:, j] = score_position_llrs(m0)\n", + " \n", + " seq_segment = sequence[s0:e0]\n", + " u_positions = list(range(UNIPROT_START_OF_MATURE + s0, UNIPROT_START_OF_MATURE + e0))\n", + " \n", + " return heatmap, seq_segment, u_positions\n" + ] + }, + { + "cell_type": "markdown", + "id": "737185d5", + "metadata": {}, + "source": [ + "This function generates a heatmap visualizing the predicted impact of all possible amino acid substitutions at each position, highlighting regions or residues of interest and coloring them by their log-likelihood ratio scores." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6570ef2a", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_heatmap(heatmap, seq_seg, u_positions, title,\n", + " col_width=0.42, min_width=8.0, max_width=16.0, height=6.0, dpi=160,\n", + " robust=True, lo=2, hi=98, vmin=None, vmax=None,\n", + " highlight=None, box_color=\"black\", box_lw=3.0, tick_fs=9, aa_fs=11):\n", + " \"\"\"Plot mutation effect heatmap.\"\"\"\n", + " \n", + " n_cols = len(seq_seg)\n", + " width = np.clip(col_width * n_cols, min_width, max_width)\n", + " \n", + " if robust and (vmin is None or vmax is None):\n", + " vals = heatmap[np.isfinite(heatmap)]\n", + " if vals.size:\n", + " p_lo, p_hi = np.percentile(vals, [lo, hi])\n", + " vmin = p_lo if vmin is None else vmin\n", + " vmax = p_hi if vmax is None else vmax\n", + " if vmin is None: vmin = -10\n", + " if vmax is None: vmax = 10\n", + " \n", + " fig, ax = plt.subplots(figsize=(width, height), constrained_layout=True, dpi=dpi)\n", + " im = ax.imshow(heatmap, cmap=\"RdBu_r\", aspect=\"auto\", vmin=vmin, vmax=vmax)\n", + " \n", + " ax.set_xticks(range(n_cols))\n", + " ax.set_xticklabels([f\"{aa}{u}\" for aa, u in zip(seq_seg, u_positions)],\n", + " rotation=90, fontsize=tick_fs)\n", + " ax.set_yticks(range(len(amino_acids)))\n", + " ax.set_yticklabels(amino_acids, fontsize=aa_fs)\n", + " \n", + " ax.set_xlabel(\"Wild-type Residue and Position\", fontsize=12)\n", + " ax.set_ylabel(\"Mutant Amino Acid\", fontsize=12)\n", + " ax.set_title(title, fontsize=14)\n", + " \n", + " cbar = plt.colorbar(im, ax=ax)\n", + " cbar.ax.tick_params(labelsize=tick_fs)\n", + " cbar.set_label(\"Log-Likelihood Ratio\", fontsize=11)\n", + " \n", + " if highlight:\n", + " if not isinstance(highlight, (list, tuple, set)):\n", + " highlight = list(highlight)\n", + " u2col = {u: j for j, u in enumerate(u_positions)}\n", + " for u in highlight:\n", + " j = u2col.get(int(u), None)\n", + " if j is not None:\n", + " ax.add_patch(Rectangle((j - 0.5, -0.5), 1.0, heatmap.shape[0],\n", + " fill=False, edgecolor=box_color, linewidth=box_lw))\n", + " \n", + " plt.show()\n", + " return fig" + ] + }, + { + "cell_type": "markdown", + "id": "aa62650c", + "metadata": {}, + "source": [ + "### Generating Heatmaps" + ] + }, + { + "cell_type": "markdown", + "id": "82c5be68", + "metadata": {}, + "source": [ + "#### SxxK motif" + ] + }, + { + "cell_type": "markdown", + "id": "4e9500f8", + "metadata": {}, + "source": [ + "We start with the SxxK catalytic motif, a signature sequence found in Class A β-lactamases. The highlighted serine (S68) forms a covalent acyl-enzyme intermediate with the β-lactam substrate, while the lysine (K71) plays a crucial role in the catalytic mechanism. This region should show strong purifying selection, with most mutations being highly deleterious, making it an excellent test of whether ESM-2 captures functional constraints." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "cef435f3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculating mutation effects for UniProt 60-80 \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Positions: 100%|██████████| 21/21 [00:00<00:00, 72.60it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hm1, seg1, upos1 = generate_heatmap(60, 80)\n", + "fig1 = plot_heatmap(\n", + " hm1, seg1, upos1,\n", + " title=\"TEM-1 β-lactamase: SxxK motif region (UniProt 60–80)\",\n", + " highlight=[68, 71]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "d4c9b97c", + "metadata": {}, + "source": [ + "The heatmap highlights ESM-2’s ability to pinpoint functionally critical residues. The catalytic serine (S68) and lysine (K71) exhibit extremely negative scores, nearing -10, indicating that almost any substitution at these sites would severely impair enzyme function. In contrast, surrounding positions display a broader range of tolerance, with some accommodating conservative changes. This pattern shows that ESM-2 has captured the precise functional constraints of the active site purely from evolutionary sequence patterns." + ] + }, + { + "cell_type": "markdown", + "id": "d24e211b", + "metadata": {}, + "source": [ + "#### Binding patch" + ] + }, + { + "cell_type": "markdown", + "id": "7142c147", + "metadata": {}, + "source": [ + "We next examine the substrate-binding residues 232–234, which form part of the binding patch that interacts directly with the β-lactam substrate. These residues are key to substrate recognition, making them an ideal test of ESM-2’s ability to detect the functional importance of specific contact points." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "474f1fcc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculating mutation effects for UniProt 226-238 \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Positions: 100%|██████████| 13/13 [00:00<00:00, 78.58it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hm2, seg2, upos2 = generate_heatmap(226, 238)\n", + "fig2 = plot_heatmap(\n", + " hm2, seg2, upos2,\n", + " title=\"TEM-1 β-lactamase: Binding patch (UniProt 226–238)\",\n", + " highlight=[232, 233, 234]\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "8e0450d9", + "metadata": {}, + "source": [ + "The heatmap illustrates ESM-2’s recognition of the substrate-binding residues 232–234 as critical contact points. All three positions display strongly negative scores, often approaching -10, indicating that nearly any substitution would likely disrupt substrate binding. This sharp contrast with the more variable tolerance observed at neighboring sites suggests that ESM-2 has accurately learned the essential role of these residues in substrate recognition from evolutionary sequence data alone." + ] + }, + { + "cell_type": "markdown", + "id": "12cf53a7", + "metadata": {}, + "source": [ + "#### Ω-loop region" + ] + }, + { + "cell_type": "markdown", + "id": "ef967cd4", + "metadata": {}, + "source": [ + "We now focus on the Ω-loop region spanning residues 160–180, which contains the catalytic glutamate at position 166. This residue functions as a proton acceptor during catalysis, playing a central role in the enzyme’s mechanism." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "709e747b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculating mutation effects for UniProt 160-180 \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Positions: 100%|██████████| 21/21 [00:00<00:00, 76.40it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hm3, seg3, upos3 = generate_heatmap(160, 180)\n", + "fig3 = plot_heatmap(\n", + " hm3, seg3, upos3,\n", + " title=\"TEM-1 β-lactamase: Ω-loop region (UniProt 160–180)\",\n", + " highlight=[166]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "d15136f6", + "metadata": {}, + "source": [ + "The heatmap shows that ESM-2 identifies glutamate 166 as an important catalytic residue, with most substitutions producing negative scores, though generally not as extreme as those seen in the previous examples. This more moderate penalty likely reflects the Ω-loop’s inherent flexibility, which may allow certain substitutions to retain partial function or be accommodated structurally. Additionally, E166’s role as a proton acceptor might be more chemically replaceable than the covalent interactions made by S68 for example, meaning the model does not assign uniformly catastrophic scores to all substitutions." + ] + }, + { + "cell_type": "markdown", + "id": "c92d5f28", + "metadata": {}, + "source": [ + "### DMS Benchmark\n", + "\n", + "This function benchmarks ESM-2’s mutation effect predictions against experimental deep mutational scanning (DMS) data from Stiffler et al. (2015). It takes the list of experimentally measured β-lactamase TEM mutations, scores each with ESM-2 using masked-marginal log-likelihood ratios, and then compares the predicted scores to experimental fitness values across antibiotic concentrations. The correlation analysis, reported as Spearman |ρ|, quantifies how well ESM-2’s sequence-only predictions align with measured resistance phenotypes. This provides a direct test of the model’s ability to capture functional effects observed in large-scale experimental screens." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "137fe913", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading DMS mutations from data/BLAT_ECOLX_Ranganathan2015.csv...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Scoring DMS mutations: 100%|██████████| 4996/4996 [00:50<00:00, 98.14it/s] " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Spearman |ρ| vs. experimental fitness:\n", + " 2500 μg/mL: |ρ| = 0.556\n", + " 625 μg/mL: |ρ| = 0.459\n", + " 156 μg/mL: |ρ| = 0.393\n", + " 39 μg/mL: |ρ| = 0.284\n", + " 0 μg/mL: |ρ| = 0.164\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def run_dms_benchmark(csv_path):\n", + " \"\"\"Compare ESM-2 predictions with experimental DMS data.\"\"\"\n", + " print(f\"Loading DMS mutations from {csv_path}...\")\n", + " df = pd.read_csv(csv_path)\n", + " \n", + " preds = []\n", + " for mut in tqdm(df[\"mutant\"], desc=\"Scoring DMS mutations\"):\n", + " wt = mut[0]\n", + " u_pos = int(mut[1:-1])\n", + " mt = mut[-1]\n", + " llr = score_mutation_llr(u_pos, wt, mt)\n", + " preds.append(llr)\n", + " df[\"esm2_llr\"] = preds\n", + " \n", + " exp_cols = [c for c in [\"2500\", \"625\", \"156\", \"39\", \"0\"] if c in df.columns]\n", + " if exp_cols:\n", + " print(\"\\nSpearman |ρ| vs. experimental fitness:\")\n", + " for col in exp_cols:\n", + " mask = ~(df[col].isna() | df[\"esm2_llr\"].isna())\n", + " if mask.sum() > 0:\n", + " rho = spearmanr(df.loc[mask, \"esm2_llr\"], df.loc[mask, col])[0]\n", + " print(f\" {col:5} μg/mL: |ρ| = {abs(rho):.3f}\")\n", + " \n", + " top_col = None\n", + " for candidate in [\"2500\", \"1250\", \"1000\", \"625\", \"156\", \"39\"]:\n", + " if candidate in exp_cols:\n", + " top_col = candidate\n", + " break\n", + " \n", + " if top_col:\n", + " mask = ~(df[top_col].isna() | df[\"esm2_llr\"].isna())\n", + " x = df.loc[mask, \"esm2_llr\"].values\n", + " y = df.loc[mask, top_col].values\n", + " \n", + " plt.figure(figsize=(6, 5), dpi=140)\n", + " plt.scatter(x, y, s=8, alpha=0.6)\n", + " plt.xlabel(\"ESM-2 masked-marginal LLR (mut − wt)\")\n", + " plt.ylabel(f\"Experimental fitness @ {top_col} μg/mL\")\n", + " rho = spearmanr(x, y)[0]\n", + " plt.title(f\"TEM-1 DMS: ESM-2 vs. fitness (ρ = {rho:.3f})\")\n", + " plt.tight_layout()\n", + " plt.show()\n", + " else:\n", + " print(\"No experimental concentration columns found.\")\n", + " \n", + " return df\n", + "\n", + "dms_df = run_dms_benchmark(\n", + " \"data/BLAT_ECOLX_Ranganathan2015.csv\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "8c76a31f", + "metadata": {}, + "source": [ + "The scatter plot shows a moderate correlation (ρ = 0.556) between ESM-2 predictions and experimental fitness, but the relationship is noisy with substantial variation around the trend. In general, more negative ESM-2 scores tend to correspond to lower experimental fitness, yet many individual mutations deviate from this pattern. Some mutations with highly negative LLR scores still maintain reasonable fitness, while others with only modestly negative scores perform poorly. The increase in correlation strength with higher antibiotic concentration (from |ρ| = 0.164 to |ρ| = 0.556) suggests that ESM-2’s evolutionary-based predictions become more relevant under strong selective pressure. However, even at the highest concentration, the considerable scatter indicates that predicting mutation effects remains challenging and that experimental fitness is influenced by factors beyond what ESM-2 can infer from sequence patterns alone. It's important to note that these results are based on the 35M parameter ESM-2 model, and it is likely that larger models would achieve stronger correlations and improved predictive performance." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/esm/requirements.txt b/esm/requirements.txt new file mode 100644 index 00000000..d7dbbe96 --- /dev/null +++ b/esm/requirements.txt @@ -0,0 +1,12 @@ +mlx +torch +transformers +numpy +pandas +seaborn +biopython +biotite +scipy +tqdm +scikit-learn +matplotlib \ No newline at end of file diff --git a/esm/test.py b/esm/test.py new file mode 100644 index 00000000..e9fb3bd8 --- /dev/null +++ b/esm/test.py @@ -0,0 +1,121 @@ +import unittest + +import numpy as np +from transformers import AutoTokenizer, EsmConfig, EsmForMaskedLM + +from esm import ESM2 + +# Paths for MLX and Hugging Face versions of ESM-2 +MLX_PATH = "checkpoints/mlx-esm2_t12_35M_UR50D" +HF_PATH = "facebook/esm2_t12_35M_UR50D" + + +def load_mlx_model(): + """Load MLX ESM-2 model and tokenizer.""" + tokenizer, model = ESM2.from_pretrained(MLX_PATH) + return tokenizer, model + + +def load_hf_model(): + """Load Hugging Face ESM-2 model and tokenizer with hidden states + attentions.""" + tokenizer = AutoTokenizer.from_pretrained(HF_PATH) + config = EsmConfig.from_pretrained( + HF_PATH, output_hidden_states=True, output_attentions=True + ) + model = EsmForMaskedLM.from_pretrained(HF_PATH, config=config) + return tokenizer, model + + +class TestESM2(unittest.TestCase): + @classmethod + def setUpClass(cls): + # Load both MLX and HF models/tokenizers once for all tests + cls.mlx_tokenizer, cls.mlx_model = load_mlx_model() + cls.hf_tokenizer, cls.hf_model = load_hf_model() + + def test_tokenizer(self): + """Verify MLX tokenizer matches Hugging Face tokenizer behavior.""" + self.assertEqual(len(self.mlx_tokenizer), len(self.hf_tokenizer)) + + sequences = [ + "MSKGEELFTGVVPILVELDGDVNGHKFSVSGEGEGDATYGKLTLKFICTTGKLPVPWPTLVTTFSYGVQCFSRYPDHMKQHDFFKSAMPEGYVQERTIFFKDDGNYKTRAEVKFEGDTLVNRIELKGIDFKEDGNILGHKLEYNYNSHNVYIMADKQKNGIKVNFKIRHNIEDGSVQLADHYQQNTPIGDGPVLLPDNHYLSTQSALSKDPNEKRDHMVLLEFVTAAGITHGMDELYK", + "MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN", + ] + + # Compare batched tokenization (padded sequences) + mlx_batch = self.mlx_tokenizer.batch_encode(sequences) + hf_batch = ( + self.hf_tokenizer(sequences, return_tensors="pt", padding=True)["input_ids"] + .cpu() + .numpy() + ) + self.assertEqual(tuple(mlx_batch.shape), tuple(hf_batch.shape)) + self.assertTrue( + np.array_equal(np.array(mlx_batch.tolist(), dtype=hf_batch.dtype), hf_batch) + ) + + # Compare single-sequence encode/decode + for sequence in sequences: + mlx_tokens = self.mlx_tokenizer.encode(sequence) + hf_tokens = ( + self.hf_tokenizer(sequence, return_tensors="pt")["input_ids"] + .cpu() + .numpy() + .tolist()[0] + ) + self.assertTrue(np.array_equal(mlx_tokens, hf_tokens)) + self.assertEqual( + self.mlx_tokenizer.decode(mlx_tokens), + self.hf_tokenizer.decode(hf_tokens).replace(" ", ""), + ) + self.assertEqual( + self.mlx_tokenizer.decode(mlx_tokens, skip_special_tokens=True), + self.hf_tokenizer.decode(hf_tokens, skip_special_tokens=True).replace( + " ", "" + ), + ) + + def test_model(self): + """Verify MLX and HF model outputs match (logits, hidden states, attentions).""" + sequences = [ + "MSKGEELFTGVVPILVELDGDVNGHKFSVSGEGEGDATYGKLTLKFICTTGKLPVPWPTLVTTFSYGVQCFSRYPDHMKQHDFFKSAMPEGYVQERTIFFKDDGNYKTRAEVKFEGDTLVNRIELKGIDFKEDGNILGHKLEYNYNSHNVYIMADKQKNGIKVNFKIRHNIEDGSVQLADHYQQNTPIGDGPVLLPDNHYLSTQSALSKDPNEKRDHMVLLEFVTAAGITHGMDELYK", + "MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN", + ] + for sequence in sequences: + # Tokenize + mlx_tokens = self.mlx_tokenizer.encode(sequence, return_batch_dim=True) + hf_tokens = self.hf_tokenizer(sequence, return_tensors="pt")["input_ids"] + + # Forward pass + mlx_outputs = self.mlx_model( + mlx_tokens, + repr_layers=[self.mlx_model.num_layers], + need_head_weights=True, + ) + hf_outputs = self.hf_model(input_ids=hf_tokens) + + # Compare logits + mlx_logits = np.array(mlx_outputs["logits"]) + hf_logits = hf_outputs["logits"].detach().cpu().numpy() + self.assertTrue(np.allclose(mlx_logits, hf_logits, rtol=1e-4, atol=1e-4)) + + # Compare final-layer hidden states + final_layer = self.mlx_model.num_layers + mlx_hidden_states = np.array(mlx_outputs["representations"][final_layer]) + hf_hidden_states = hf_outputs["hidden_states"][-1].detach().cpu().numpy() + self.assertTrue( + np.allclose(mlx_hidden_states, hf_hidden_states, rtol=1e-4, atol=1e-4) + ) + + # Compare attentions for final layer + mlx_attentions = np.array( + mlx_outputs["attentions"][:, final_layer - 1, :, :, :] + ) + hf_attentions = hf_outputs["attentions"][-1].detach().cpu().numpy() + self.assertTrue( + np.allclose(mlx_attentions, hf_attentions, rtol=1e-4, atol=1e-4) + ) + + +if __name__ == "__main__": + unittest.main()