ESM-IF1 Inverse Fold¶

General-purpose protein inverse folding model that generates amino acid sequences compatible with a given 3D backbone structure, using a GVP-Transformer architecture trained on 12M predicted structures.

License: MIT · Molecules: protein · Tasks: inverse_folding

Actions: generate · Variants: 1

At a glance¶

Use it when

You need lightweight, fast inverse folding on a T4 GPU and the input is a single-chain protein structure
You are screening many backbone structures and need cost-effective sequence design before investing in more comprehensive tools (MPNN) for top candidates
You want to leverage ESM pretrained protein language model representations in your inverse folding pipeline
You are building a domain-specific inverse folding model and need a strong pre-trained backbone to fine-tune (as demonstrated by AntiFold for antibodies)
You need a quick sequence plausibility assessment for a structure-sequence pair via recovery rate, without requiring full multi-chain or ligand-aware analysis
You are performing scaffold-based protein design on computationally generated backbones and benefit from ESM-IF1's training on 12M AlphaFold2-predicted structures

Strengths

Trained on 12M AlphaFold2-predicted structures in addition to experimental PDB structures, giving it exposure to a much wider range of backbone geometries than models trained on experimental structures alone
Lightweight inverse folding model on a single T4 GPU (16 GB RAM), making it significantly cheaper to run than larger structure-conditioned models
Leverages ESM pretrained representations, combining structural geometry understanding with evolutionary sequence knowledge from the ESM protein language model family
Published at ICML 2022 with extensive benchmarking on sequence recovery, demonstrating competitive performance against ProteinMPNN on standard inverse folding benchmarks
Successfully fine-tuned for antibody-specific inverse folding (AntiFold), demonstrating its value as a backbone for domain-specific adaptation
Temperature-controlled sampling enables generation of diverse sequence libraries from a single backbone, from conservative (low T) to exploratory (high T)
MIT license permits unrestricted commercial and academic use
Simple single-action API (generate from PDB) with straightforward input format for rapid integration into protein design pipelines

Limitations

Single-chain only — multichain backbone support is not implemented (raises NotImplementedError), limiting use for protein complex design
Lower sequence recovery than ProteinMPNN on experimental structures in head-to-head benchmarks, particularly for buried core residues
No ligand, cofactor, or metal ion awareness — designs sequences without considering bound small molecules that may be critical for enzyme active sites
No membrane-aware variant — cannot account for the lipid bilayer environment when designing membrane protein sequences
Requires PDB-format backbone structure as input — cannot generate sequences from sequence alone; users must have or predict a 3D structure first
No explicit solubility optimization — unlike SolubleMPNN, does not bias designs toward improved solubility
Performance degrades on intrinsically disordered regions that lack well-defined backbone geometry

Reach for something else when

You need to design sequences for multi-chain protein complexes (use mpnn, which supports multi-chain inputs natively)
You need ligand-aware, cofactor-aware, or metal-aware sequence design for enzyme active sites (use mpnn with the LigandMPNN variant)
You need the highest possible sequence recovery and experimental success rate (use mpnn, which has more extensive experimental validation and slightly higher recovery on standard benchmarks)
You need membrane-aware sequence design that accounts for the lipid bilayer environment (use mpnn with global-membrane or per-residue-membrane variants)
You need antibody-specific inverse folding with CDR awareness and germline knowledge (use antifold, which is fine-tuned from ESM-IF1 for antibodies)
You need to generate protein sequences without a backbone structure (use progen2, zymctrl, or dsm for sequence-based generation)
You need protein embeddings or fitness scoring without structure input (use esm2 for sequence-based analysis)
You need to redesign surface residues with explicit solubility optimization (use mpnn with the SolubleMPNN variant)

Alternatives

Model	Better when	Worse when
mpnn	Higher sequence recovery on experimental structures, six context-aware variants (ligand, membrane, soluble, side-chain), native multi-chain complex support, and the most extensive experimental validation of any inverse-folding model.	ESM-IF1 is a lightweight single-T4 model that leverages ESM pretrained representations and training on 12M AlphaFold2 structures; may generalize better on computationally designed backbones.
antifold	Antibody-specialized inverse folding (fine-tuned from ESM-IF1) with CDR-aware design, IMGT region selection, and germline-preference modeling for antibody engineering.	Antibody/nanobody structures only; ESM-IF1 handles any single-chain protein backbone, making it the general-purpose choice for non-antibody targets.
boltzgen	Structure-conditioned generative all-atom design (Boltz-based diffusion) that co-designs sequence and structure; supports multi-chain complexes, binding-site and secondary-structure constraints, ligand/complex context, and de novo binder design from a target structure.	Much heavier (large-GPU diffusion) and overkill for plain single-chain backbone redesign; ESM-IF1 is a cheap T4 inverse-folding model that directly recovers a sequence for a fixed backbone without diffusion.

API & schema¶

Call an action with POST /api/v1/{slug}/{action} — the request envelope is {"items": [...], "params": {...}} and a success returns {"results": [...]}. See the HTTP API page for the base URL, error shape, and full contract.

`generate`¶

Call it

curl -X POST http://127.0.0.1:8000/api/v1/esm-if1/generate \
  -H "Content-Type: application/json" \
  -d '{
  "items": [
    {
      "pdb": "<contents of a .pdb file>"
    }
  ]
}'

Request — ESMIF1GenerateRequest

Field	Type	Required	Constraints	Description
`params`	ESMIF1GenerateParams	no		Optional parameters controlling this action (defaults are used when omitted).
`items`	list[ESMIF1GenerateRequestItem]	yes	items 1–1	Batch of inputs to process in a single request. Exactly one structure per request.

Nested types

ESMIF1GenerateParams

Field	Type	Required	Constraints	Description
`chain`	string	no	len –1; default `A`	Chain identifier to redesign (e.g. "A").
`num_samples`	integer	no	≥1; ≤3; default `1`	Number of sequences to generate per input.
`temperature`	number	no	≥0.0; ≤8.0; default `0.6`	Sampling temperature; higher values increase diversity.
`multichain_backbone`	boolean	no	default `False`	Use backbone coordinates from all chains while designing only the selected chain (not yet supported).
`seed`	integer \| null	no		Random seed for reproducible sampling.

ESMIF1GenerateRequestItem

Field	Type	Required	Constraints	Description
`pdb`	string	yes	len 1–2500000	Input structure in PDB format.

Raw JSON Schema

{
  "$defs": {
    "ESMIF1GenerateParams": {
      "additionalProperties": false,
      "properties": {
        "chain": {
          "default": "A",
          "description": "Chain identifier to redesign (e.g. \"A\").",
          "maxLength": 1,
          "title": "Chain",
          "type": "string"
        },
        "num_samples": {
          "default": 1,
          "description": "Number of sequences to generate per input.",
          "maximum": 3,
          "minimum": 1,
          "title": "Num Samples",
          "type": "integer"
        },
        "temperature": {
          "default": 0.6,
          "description": "Sampling temperature; higher values increase diversity.",
          "maximum": 8.0,
          "minimum": 0.0,
          "title": "Temperature",
          "type": "number"
        },
        "multichain_backbone": {
          "default": false,
          "description": "Use backbone coordinates from all chains while designing only the selected chain (not yet supported).",
          "title": "Multichain Backbone",
          "type": "boolean"
        },
        "seed": {
          "anyOf": [
            {
              "type": "integer"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Random seed for reproducible sampling.",
          "title": "Seed"
        }
      },
      "title": "ESMIF1GenerateParams",
      "type": "object"
    },
    "ESMIF1GenerateRequestItem": {
      "additionalProperties": false,
      "properties": {
        "pdb": {
          "description": "Input structure in PDB format.",
          "maxLength": 2500000,
          "minLength": 1,
          "title": "Pdb",
          "type": "string"
        }
      },
      "required": [
        "pdb"
      ],
      "title": "ESMIF1GenerateRequestItem",
      "type": "object"
    }
  },
  "additionalProperties": false,
  "properties": {
    "params": {
      "$ref": "#/$defs/ESMIF1GenerateParams",
      "description": "Optional parameters controlling this action (defaults are used when omitted)."
    },
    "items": {
      "description": "Batch of inputs to process in a single request. Exactly one structure per request.",
      "items": {
        "$ref": "#/$defs/ESMIF1GenerateRequestItem"
      },
      "maxItems": 1,
      "minItems": 1,
      "title": "Items",
      "type": "array"
    }
  },
  "required": [
    "items"
  ],
  "title": "ESMIF1GenerateRequest",
  "type": "object"
}

Response — ESMIF1GenerateResponse

Field	Type	Required	Constraints	Description
`results`	list[list[ESMIF1GenerateResponseSample]]	yes		Per-input results, returned in the same order as the request items.

Nested types

ESMIF1GenerateResponseSample

Field	Type	Required	Constraints	Description
`sequence`	string	yes		A protein sequence in single-letter amino-acid codes.
`recovery`	number	yes		Fraction of positions matching the native sequence (0.0–1.0).

Raw JSON Schema

{
  "$defs": {
    "ESMIF1GenerateResponseSample": {
      "properties": {
        "sequence": {
          "description": "A protein sequence in single-letter amino-acid codes.",
          "title": "Sequence",
          "type": "string"
        },
        "recovery": {
          "description": "Fraction of positions matching the native sequence (0.0\u20131.0).",
          "title": "Recovery",
          "type": "number"
        }
      },
      "required": [
        "sequence",
        "recovery"
      ],
      "title": "ESMIF1GenerateResponseSample",
      "type": "object"
    }
  },
  "properties": {
    "results": {
      "description": "Per-input results, returned in the same order as the request items.",
      "items": {
        "items": {
          "$ref": "#/$defs/ESMIF1GenerateResponseSample"
        },
        "type": "array"
      },
      "title": "Results",
      "type": "array"
    }
  },
  "required": [
    "results"
  ],
  "title": "ESMIF1GenerateResponse",
  "type": "object"
}

Usage¶

One-line summary: General-purpose protein inverse folding model that generates amino acid sequences compatible with a given 3D backbone structure, using a GVP-Transformer architecture trained on 12M predicted structures.

Overview¶

ESM-IF1 (ESM Inverse Folding 1) is a protein inverse folding model from Meta AI (Hsu et al. 2022). Given a protein backbone structure in PDB format, it autoregressively samples amino acid sequences that are predicted to fold into that structure. The model uses a GVP-Transformer encoder to process backbone coordinates and a 16-layer Transformer decoder to generate sequences. A key innovation is training on 12 million AlphaFold2-predicted structures in addition to experimental structures from CATH, which significantly improves sequence recovery.

Architecture¶

Property	Value
Architecture	GVP-Transformer (GNN encoder + autoregressive decoder)
Model identifier	`esm_if1_gvp4_t16_142M_UR50`
Parameters	142M
Encoder	GVP-Transformer with 4 GVP layers
Decoder	16-layer autoregressive Transformer
Training data	CATH 4.3 + 12M AlphaFold2 predicted structures
Input	PDB backbone coordinates (N, CA, C)
Output	Sampled amino acid sequences with recovery rates

Capabilities & Limitations¶

CAN be used for: - Generating amino acid sequences compatible with a given protein backbone structure - Sampling multiple diverse sequences from a single structure (up to 3 per request) - Controlling sequence diversity via temperature parameter (0.0--8.0) - Computing sequence recovery rate (fraction matching native sequence) - Working with any single-chain protein structure

CANNOT be used for: - Multichain protein complexes (not yet implemented) - Sequence-only inputs (requires 3D structure in PDB format) - Structure prediction (inverse direction -- use ESMFold or Chai-1) - Antibody-specific design (use AntiFold for better CDR recovery) - Deterministic output without explicit seed (stochastic by default)

Usage Examples¶

Generate sequences from a protein structure¶

from models.esm_if1.schema import (
    ESMIF1GenerateRequest,
    ESMIF1GenerateParams,
    ESMIF1GenerateRequestItem,
)

request = ESMIF1GenerateRequest(
    params=ESMIF1GenerateParams(
        chain="A",
        num_samples=3,
        temperature=0.6,
        seed=42,
    ),
    items=[
        ESMIF1GenerateRequestItem(pdb=pdb_string),
    ],
)

Generate with higher diversity¶

from models.esm_if1.schema import (
    ESMIF1GenerateRequest,
    ESMIF1GenerateParams,
    ESMIF1GenerateRequestItem,
)

request = ESMIF1GenerateRequest(
    params=ESMIF1GenerateParams(
        chain="A",
        num_samples=3,
        temperature=1.0,  # Higher temperature for more diversity
    ),
    items=[
        ESMIF1GenerateRequestItem(pdb=pdb_string),
    ],
)

Architecture & training¶

Architecture¶

Model Type & Innovation¶

ESM-IF1 (ESM Inverse Folding 1) is a general-purpose protein inverse folding model from Meta AI (Hsu et al. 2022). Given a protein backbone structure, it generates amino acid sequences that are predicted to fold into that structure. The key innovation is training on millions of predicted structures from AlphaFold2 in addition to experimentally determined structures, which dramatically improves performance compared to models trained on experimental data alone.

The architecture consists of a GVP-Transformer encoder that processes backbone coordinates using Geometric Vector Perceptrons (GVPs) to capture 3D structural information, followed by an autoregressive Transformer decoder that generates amino acid sequences one position at a time, conditioned on the structural encoding.

Parameters & Layers¶

Component	Details
Architecture	GVP-Transformer (GNN encoder + autoregressive decoder)
Model name	`esm_if1_gvp4_t16_142M_UR50`
Parameters	142M
Encoder	GVP-Transformer with 4 GVP layers
Decoder	16-layer Transformer
Input	Backbone atom coordinates (N, CA, C) from PDB structures
Output	Sampled amino acid sequences with per-sequence recovery rates
Vocabulary	20 standard amino acids

Training Data¶

Property	Details
Experimental structures	CATH 4.3 (~19K protein structures)
Predicted structures	12M AlphaFold2 backbone structures from UniRef50
Total training backbones	~12M
Key innovation	Training on predicted structures dramatically improves performance

Loss Function & Objective¶

ESM-IF1 is trained with autoregressive cross-entropy loss:

L = -sum_i log P(aa_i | aa_1, ..., aa_{i-1}, backbone_coordinates)

The model learns to predict each amino acid conditioned on all previously generated amino acids and the full 3D backbone structure. The autoregressive formulation allows the model to capture sequence dependencies beyond what the structure alone encodes.

Tokenization / Input Processing¶

Input format: PDB-format structure string containing backbone atom coordinates
Coordinate extraction: Backbone atoms (N, CA, C) are extracted per residue using Biotite
Chain specification: Users specify which chain to redesign via the chain parameter (default: "A")
Graph construction: Backbone coordinates are converted to a GVP-compatible graph representation
Batching: Single structure per request (batch_size=1) due to variable structure sizes

Performance & Benchmarks¶

Published Benchmarks¶

From Hsu et al., ICML (2022):

Model	Sequence Recovery (%) ↑	Training Data
ESM-IF1	51.0	CATH + 12M AF2 structures
GVP	39.4	CATH experimental only
StructGNN	35.0	CATH experimental only
GraphTrans	34.8	CATH experimental only

Note: ProteinMPNN (Dauparas et al., Science 2022) reports slightly higher recovery (~52%) on experimental structures, but ESM-IF1's training on predicted structures gives it broader coverage of the protein structure space.

BioLM Verification Results¶

Test Case	Action	Tolerance	Status
Standard PDB structure	generate	rel_tol 0.5, is_generated_seq=True	PASS

Sequence generation is stochastic, so verification confirms that generated sequences are valid amino acid strings with reasonable recovery rates, rather than exact numerical reproduction.

Comparison to Alternatives¶

Model	Strength	When to prefer
ESM-IF1	General protein coverage, trained on 12M structures	General protein sequence design from structure
ProteinMPNN	Slightly higher recovery on experimental structures	Standard protein design, multi-chain
AntiFold	Antibody-specialized, CDR-aware	Antibody-specific inverse folding

Strengths & Limitations¶

Pros¶

General-purpose: works on any single-chain protein structure
Trained on 12M structures (experimental + AlphaFold2 predicted)
Controllable diversity via temperature parameter
Multiple samples per structure for exploring sequence space
Provides sequence recovery metric for each sample

Cons¶

Single-chain only (multichain backbone support not yet implemented)
Stochastic output: different runs produce different sequences
Batch size limited to 1 (one PDB per request)
Autoregressive decoding is inherently sequential (slower than parallel methods)
Requires a 3D structure as input (PDB format)

Known Failure Modes¶

Very large structures may cause CUDA out-of-memory errors (handled gracefully with empty result and cache clearing)
Structures with missing backbone atoms or non-standard formatting may cause parsing errors
Very high temperatures (>4.0) produce near-random sequences
Very low temperatures (<0.1) collapse diversity to near-deterministic output

Implementation Details¶

Inference Pipeline¶

Request
  |-- 1. Validate PDB string
  |-- 2. Set random seeds (user-provided or time-based)
  |-- 3. Extract backbone coordinates (N, CA, C) using Biotite
  |-- 4. For each sample (1 to num_samples):
  |     |-- 4a. Encode backbone with GVP-Transformer
  |     |-- 4b. Autoregressively decode amino acid sequence
  |     |-- 4c. Compute sequence recovery vs native
  |-- 5. Collect all samples with sequences and recovery rates
  |-- 6. Handle CUDA OOM errors gracefully
  |-- 7. Format and return response

Memory & Compute Profile¶

Resource	Value
GPU	T4
Memory	16 GB RAM
CPU	4.0 cores
Batch size	1
Max samples per request	3

Determinism & Reproducibility¶

Setting	Value
Default seed	Time-based (non-deterministic)
User-specified seed	Supported via `params.seed`
Seed scope	Python random, NumPy, Torch, CUDA

When no seed is provided, the model uses time-based entropy for diversity across requests. Providing a seed enables exact reproducibility of generated sequences.

Caching Behavior¶

Response caching is available as an optional, off-by-default gateway feature (BIOLM_CACHE_ENABLED) -- see the gateway docs; it is not handled by the model container. Cache keys are determined by the full request payload (PDB content + parameters + seed).

Versions & Changelog¶

Version	Date	Changes
v1	2024	Initial implementation with generate action

Biology¶

Molecule Coverage¶

Primary Molecule Type(s)¶

ESM-IF1 is designed for proteins broadly. It performs inverse folding: given a 3D protein backbone structure, it generates amino acid sequences that are predicted to fold into that structure. The model was trained on a diverse set of protein structures spanning the CATH classification hierarchy, augmented with millions of AlphaFold2-predicted structures.

Important coverage notes: - Works on single-chain protein structures - Multichain backbone support is not yet implemented (raises NotImplementedError) - Accepts PDB-format structure strings as input - Handles proteins of varying sizes, though very large structures may cause memory issues - Not specialized for any particular protein family

Cross-Applicability¶

Molecule Type	Applicability	Evidence	Caveats
Globular proteins	High	Primary training target (CATH structures)	Standard application
Enzymes	High	Well-represented in training data	Active site residues may need special attention
Membrane proteins	Moderate	Some representation in training data	Transmembrane regions less well-sampled
Antibodies	Moderate	General protein coverage	Use AntiFold for antibody-specific inverse folding
Disordered regions	Low	Training data is structure-based	Intrinsically disordered regions lack defined backbone
Nucleic acid-binding proteins	Moderate	Protein structures included	Does not model nucleic acid interactions
Peptides	Low	Very short chains may lack sufficient context	Minimum structural context needed for meaningful results

Biological Problems Addressed¶

Protein Sequence Design from Structure (Published)¶

Biological context: The inverse protein folding problem asks: given a desired 3D backbone structure, what amino acid sequences will fold into that structure? This is a fundamental problem in computational protein design. The protein structure-function relationship means that the backbone geometry constrains which amino acids are compatible at each position -- buried positions prefer hydrophobic residues, surface positions prefer hydrophilic ones, and specific geometric constraints (hydrogen bonding, salt bridges, steric packing) further narrow the choices.

How ESM-IF1 helps: Given a PDB structure, ESM-IF1 generates one or more amino acid sequences that are compatible with the input backbone. The temperature parameter controls the diversity of generated sequences: lower temperatures produce more conservative designs (closer to the native sequence), while higher temperatures explore more diverse sequence space. Each generated sequence includes a recovery rate indicating what fraction of positions match the native sequence.

Output interpretation: The recovery metric (0.0--1.0) indicates the fraction of positions where the designed sequence matches the native sequence extracted from the PDB. Higher recovery indicates the model "rediscovered" the native solution. For design applications, moderate recovery (0.3--0.6) often represents a good balance between structural compatibility and sequence novelty.

Protein Engineering and Optimization (Published)¶

Biological context: Protein engineers often need to modify a protein's amino acid sequence while maintaining its 3D fold. Applications include improving thermostability, enhancing catalytic activity, reducing immunogenicity, and optimizing expression. Traditional approaches use directed evolution or rational design based on structural knowledge.

How ESM-IF1 helps: By generating multiple sequences compatible with a target backbone structure at different temperatures, ESM-IF1 provides a computationally derived library of structurally compatible variants. Engineers can filter these sequences using additional criteria (conserved active site residues, known beneficial mutations, predicted stability) to identify promising candidates for experimental testing.

Scaffold-Based Protein Design (Published)¶

Biological context: In de novo protein design, researchers first design or select a backbone scaffold with desired geometry (e.g., a specific binding pocket shape), then need to find amino acid sequences that will realize that backbone. This scaffold-based design approach is central to creating novel enzymes, binding proteins, and biosensors.

How ESM-IF1 helps: ESM-IF1 can be applied to computationally designed backbones (not just natural structures) to propose sequences. The model's training on 12M AlphaFold2-predicted structures means it has seen a much wider range of backbone geometries than models trained on experimental structures alone, potentially improving performance on novel scaffold designs.

Fixed-Backbone Enzyme Design (Anticipated)¶

Biological context: Designing enzymes with novel catalytic activities often starts from an existing enzyme scaffold with a known backbone geometry. The goal is to introduce mutations that create or optimize a catalytic site while maintaining the overall fold.

How ESM-IF1 helps: By generating sequences at multiple temperatures, ESM-IF1 can suggest positions where the native amino acid is not strongly preferred by the backbone geometry, indicating positions tolerant to mutation. Conversely, positions with very high native recovery across samples are likely structurally critical and should be preserved. This structural tolerance information can guide enzyme engineering campaigns. However, ESM-IF1 does not explicitly model catalytic function, so designed sequences require additional validation.

Applied Use Cases¶

ESM-IF1 has been used in several published protein design studies since its release in 2022. Selected examples:

AntiFold (Høie et al., 2025): Fine-tunes ESM-IF1 on solved and predicted antibody structures to achieve state-of-the-art antibody sequence recovery and refolding, demonstrating ESM-IF1 as a strong backbone for domain-specific inverse folding. (DOI: 10.1093/bioadv/vbae202)
Peptide binder design (Johansson-Åkhe & Wallner, 2023): Combines ESM-IF1 with Foldseek and AlphaFold2 for de novo peptide binder design, showing ESM-IF1 designs successful binders for 6.5% of heteromeric interfaces versus 1.5% for ProteinMPNN. (DOI: 10.1038/s42004-023-01029-7)
ProteinBench (Gao et al., 2024): Comprehensive benchmark evaluating multiple protein design models including ESM-IF1 and ProteinMPNN across inverse folding and structure prediction tasks. (arXiv: 2409.06744)
AiCE (2025): Samples mutations from inverse folding models (including ESM-IF1) with structural and evolutionary constraints; outperforms other AI methods by 36–90% across 60 deep mutational scanning datasets. (DOI: 10.1016/j.cell.2025.06.014)
Inverse folding consensus ranking (2025): Evaluates ESM-IF1 alongside ProteinMPNN, LigandMPNN, CARBonAra, and ProRefiner on 25,716 protein-ligand complexes; consensus-ranked sequences outperform individual models in stability, binding affinity, and structural fidelity. (DOI: 10.1145/3768322.3769031)

Predecessor Models¶

GVP (Jing et al., 2021): The Geometric Vector Perceptron framework that ESM-IF1's encoder is built upon. GVP introduced the idea of using equivariant neural networks for processing protein structures.
StructGNN and GraphTrans: Earlier structure-based sequence design models that ESM-IF1 outperforms.

Complementary Models¶

ESM-IF1 works well in combination with other models in this catalog:

Structure prediction models (ESMFold, Chai-1, AbodyBuilder3): Generate the input 3D structure needed by ESM-IF1 when an experimental structure is unavailable. Pipeline: predict structure, then design sequences with ESM-IF1.
Protein language models (ESM2, ESMC): Score ESM-IF1-designed sequences using pseudo-log-likelihoods or embeddings for additional fitness assessment.
Stability predictors (ThermoMPNN): Estimate stability changes (ddG) for designed sequences.

Alternative Models¶

Alternative	Advantage over ESM-IF1	Disadvantage vs ESM-IF1
ProteinMPNN	Slightly higher recovery on experimental structures, multi-chain	Not trained on AlphaFold2 structures
AntiFold	Antibody-specialized, CDR-aware	Only works for antibodies
LigandMPNN	Handles ligand context	More specialized setup

Biological Background¶

Inverse Protein Folding¶

The protein folding problem -- predicting 3D structure from amino acid sequence -- has been revolutionized by AlphaFold2 and related methods. The inverse problem -- predicting sequence from structure -- is equally important for protein design but fundamentally different in nature. While folding maps many sequences to one structure (many-to-one), inverse folding maps one structure to many possible sequences (one-to-many). This degeneracy is biologically meaningful: natural proteins with the same fold often share less than 30% sequence identity, demonstrating that backbone geometry alone vastly under-constrains the sequence.

Structure-Based Sequence Design¶

Structure-based sequence design exploits the physical constraints imposed by a protein's 3D backbone geometry on its amino acid sequence. Key principles include:

Packing: Buried positions in the protein core must be filled by residues with compatible van der Waals volumes
Electrostatics: Charged and polar residues at the surface; hydrophobic residues in the core
Backbone geometry: Local backbone angles (phi/psi) constrain which residues can occupy each position
Hydrogen bonding: Secondary structure elements (helices, sheets) require specific backbone hydrogen bonding patterns satisfied by compatible side chains

Sequence Recovery as a Metric¶

Sequence recovery -- the fraction of designed positions that match the native sequence -- is the standard benchmark for inverse folding models. Higher recovery indicates the model better captures the sequence-structure relationship. Typical values for state-of-the-art models are 45--55% overall, compared to ~5% expected by random chance (1/20 amino acids). Recovery varies by position type: buried core residues show higher recovery than solvent-exposed positions, reflecting stronger structural constraints on buried residues.

Sources & license¶

License: MIT (text)

Papers

Learning inverse folding from millions of predicted structures — ICML, 2022 · DOI arXiv

Source repositories

github: https://github.com/facebookresearch/esm

Cite

@inproceedings{hsu2022learning,
  title={Learning inverse folding from millions of predicted structures},
  author={Hsu, Chloe and Verkuil, Robert and Liu, Jason and Lin, Zeming and Hie, Brian and Sercu, Tom and Lerer, Adam and Rives, Alexander},
  booktitle={International Conference on Machine Learning},
  year={2022}
}

ESM-IF1 Inverse Fold¶

At a glance¶

API & schema¶

generate¶

Usage¶

Overview¶

Architecture¶

Capabilities & Limitations¶

Usage Examples¶

Generate sequences from a protein structure¶

Generate with higher diversity¶

Architecture & training¶

Architecture¶

Model Type & Innovation¶

Parameters & Layers¶

Training Data¶

Loss Function & Objective¶

Tokenization / Input Processing¶

Performance & Benchmarks¶

Published Benchmarks¶

BioLM Verification Results¶

Comparison to Alternatives¶

Strengths & Limitations¶

Pros¶

Cons¶

Known Failure Modes¶

Implementation Details¶

Inference Pipeline¶

Memory & Compute Profile¶

Determinism & Reproducibility¶

Caching Behavior¶

Versions & Changelog¶

Biology¶

Molecule Coverage¶

Primary Molecule Type(s)¶

Cross-Applicability¶

Biological Problems Addressed¶

Protein Sequence Design from Structure (Published)¶

Protein Engineering and Optimization (Published)¶

Scaffold-Based Protein Design (Published)¶

Fixed-Backbone Enzyme Design (Anticipated)¶

Applied Use Cases¶

Related Models¶

Predecessor Models¶

Complementary Models¶

Alternative Models¶

Biological Background¶

Inverse Protein Folding¶

Structure-Based Sequence Design¶

Sequence Recovery as a Metric¶

Sources & license¶

`generate`¶