RoseTTAFold: Three-Track Network for Protein Structure and Interaction Prediction

New
License: Code is MIT; trained weights and data are under the Rosetta-DL software license for internal, non-commercial research use only · Updated 2026-11-12
My rating

1. Overview

RoseTTAFold is the structure prediction system released by the Baker Lab at the University of Washington, published in Science on 15 July 2021 with the title "Accurate prediction of protein structures and interactions using a three-track neural network", volume 374, pages 871 to 876, DOI 10.1126/science.abj8754, published under a CC BY licence. It was the second CASP14 system to be released openly, after DeepMind's AlphaFold2, and it differs from that lineage in a specific architectural choice: instead of predicting a residue frame and side-chain torsions directly, it keeps an explicit distance representation in the middle of the network.

The paper's own framing is comparative and should be quoted with care. The abstract states that the authors explored network architectures incorporating related ideas and obtained the best performance with a three-track network in which information at the one-dimensional sequence level, the two-dimensional distance map level and the three-dimensional coordinate level is successively transformed and integrated. It states that the three-track network produces predictions with accuracies approaching those of DeepMind in CASP14, and that the performance of the three-track model on the CASP14 targets was still not as good as AlphaFold2.

The official repository is RosettaCommons/RoseTTAFold, created on 29 June 2021, written in Python, using main as the default branch, MIT licensed and not archived. At the time of verification it carries roughly 2280 stars, 459 forks and 99 open issues. The repository contains 217 tree entries in total, with the substantive parts being the three-track network under network, a faster two-track variant under network_2track used for yeast protein-protein interaction screening, the Rosetta-style refinement and error prediction under DAN-msa and folding, the input preparation scripts under input_prep, the two run scripts run_pyrosetta_ver.sh and run_e2e_ver.sh, the conda environment files, and a small example directory.

Licensing is split in a way that is easy to misread. The source code is MIT, while the trained weights and the associated data are released under the Rosetta-DL Software License, a non-commercial agreement that permits running, displaying, copying and modifying the material only within the institution, only for internal non-profit non-commercial research, and requires that results be made available to other researchers for non-commercial purposes. Any commercial use, including fee-based service projects, requires a separate licensing agreement with the University of Washington and the payment of a fee. The weights themselves are hosted at files.ipd.uw.edu, so the download path is a direct artefact of the agreement rather than a public release.

The ecosystem around the project is broader than the repository. Robetta at robetta.bakerlab.org provides a hosted RoseTTAFold option alongside the other Baker Lab tools, the Baker Lab maintains a separate RoseTTAFold-All-Atom repository for the full-atom generalisation of the method, and the nucleic-acid extension lives in the uw-ipd/RoseTTAFold2NA repository. A second Science paper from the same group on computed structures of core eukaryotic protein complexes, DOI 10.1126/science.abm4805, applies the method to large assemblies.

2. How It Works

The three-track design runs three representations forward together. The one-dimensional track holds the multiple sequence alignment, with residues as rows and database sequences as columns. The two-dimensional track holds pair representations indexed by residue pairs, from which the network predicts distance maps. The three-dimensional track holds actual coordinates, which start from a generated initial structure and are refined by the network.

Feature extraction is iterative. The code in network/Attention_module_w_str.py implements an IterativeFeatureExtractor that alternates between updating the one-dimensional and two-dimensional representations with attention, updating the three-dimensional structure with an SE3 transformer, and re-injecting the updated structure back into the pair representation. The model definition in network/RoseTTAFoldModel.py gives the default dimensions: d_msa of 64, d_pair of 128, d_templ of 64, four attention heads for the MSA track, eight for the pair track and four for the template track, n_module of 4, n_module_str of 4 and n_layer of 4, with a dropout of 0.1.

The distance head is a two-dimensional residual network. network/DistancePredictor.py defines a DistanceNetwork with four separate ResNet heads predicting four quantities from the pair features: the inter-residue distance, the dihedral omega, and the dihedrals theta and phi. The code symmetrises the features before the symmetric predictions and keeps the asymmetric predictions computed on the unsymmetrised input, which matches the physical distinction between quantities that are symmetric under residue exchange and those that are not. The two-track variant in network_2track/DistancePredictor.py implements the same four heads without the input symmetrisation step.

Coordinates are produced in two stages. The Regen_Network in network/Refine_module.py regenerates initial coordinates from the final pair features and the predicted distance map, using a graph transformer with UniMP blocks and a node dim of 64 against an edge dim of 128, and outputs both the rotation and translation of each residue together with an eight-dimensional state. The Refine_Network then refines that structure through multiple SE3 transformer blocks, with the SE3 parameters configured as 32 input features, 16 output features and 32 edge features. The SE3 transformer implementation under network/equivariant_attention comes from the original SE(3)-Transformers work, and the attention module in network/performer_pytorch.py is based on the Performer architecture, both credited in the README.

Confidence is predicted alongside the structure. The model returns an lDDT value per residue, and the repository writes this into the B-factor column of the output PDB so that it can be read directly in any structure viewer.

Two variants of the runtime exist. The end-to-end version produces a single PDB file with residue-wise predicted lDDT in the B-factor column, named t000_.e2e.pdb. The PyRosetta version runs the network output through Rosetta-style refinement and produces five final models whose estimated C-alpha rms error is stored in the B-factor column, named model_[1-5].crderr.pdb. The PyRosetta path requires a separate commercial licence for PyRosetta itself, obtained from the University of Washington.

The two-track model is a deliberate simplification for a specific task. It lives under network_2track and is invoked through network_2track/predict_msa.py, taking a paired MSA in a3m format, an output npz filename and the length of the first chain. It was developed for high-throughput yeast protein-protein interaction screening, where the distance map alone is sufficient to rank candidate interfaces and running the full three-track refinement for every pair would be too slow.

Complex prediction is a separate script with its own input convention. network/predict_complex.py takes a paired a3m file and a list of chain lengths, for example -i paired.a3m -o complex -Ls 218 310, and the README notes that the window size was corrected to 200 for the complex prediction script in a later commit.

3. Scope and Assumptions

The operating assumptions are explicit in the README. The project targets Linux with a CUDA-capable NVIDIA driver, and the conda environment files distinguish a CUDA 11 build, RoseTTAFold-linux.yml, from a CUDA 10 fallback, RoseTTAFold-linux-cu101.yml. A separate folding environment, folding-linux.yml, is needed only for the PyRosetta version. A PyRosetta licence from the University of Washington is a hard prerequisite for that path.

The database footprint is large and pinned to specific snapshots. The README specifies UniRef30 from the June 2020 release at about 46 GB, BFD at about 272 GB, and structure templates from the March 2021 snapshot at over 100 GB, with the note that the March 2020 template set is the one used for the CASP14 benchmarks. These are archived snapshots rather than live databases, which makes results reproducible but locks the tool to the evolutionary state of mid-2020.

Weights are distributed as a single archive from the Baker Lab servers, weights.tar.gz, which contains the network weights and, since the November 2021 update, the RF2t.pt weights for the two-track model used for yeast protein-protein interaction screening. The README explicitly asks users to re-download the weights to obtain that file, while noting that the original RoseTTAFold weights themselves did not change.

The training regime differs from the AlphaFold lineage in a way that matters for expectations. The paper explains that because of computer hardware memory limitations the authors could not train models on large proteins directly, since the three-track models have many millions of parameters. Instead they presented many discontinuous crops of the input sequence consisting of two discontinuous sequence segments spanning a total of 260 residues. Final models are then assembled by combining and averaging the one-dimensional features and the two-dimensional distance and orientation predictions produced for each crop, followed by two alternative routes to the final three-dimensional structure.

The network was trained on monomers rather than on complexes. The paper states this directly and notes that there may be a training set bias in the monomer structure predictions, which shows up as uncertainty in how the relative arrangement of subunits is resolved.

The repository ships as a guideline pipeline rather than a production scheduler. The README says explicitly that the provided run scripts are a kind of guidelines to show how RoseTTAFold works, and that for more efficient use of computing resources one would want to modify them to submit separate jobs with proper dependencies for each step, allocating more CPUs and memory for the hhblits and hhsearch stages and reserving GPUs for the network runs only.

4. Getting Started

The installation sequence is fixed and short. Clone the repository, create the conda environment from RoseTTAFold-linux.yml or the CUDA 10 variant, create the folding environment from folding-linux.yml if the PyRosetta path is wanted, download and unpack the weights archive, run the third-party dependency installer install_dependencies.sh, then fetch the three databases.

The usage surface has three entry points. For a monomer, the example directory contains run_pyrosetta_ver.sh and run_e2e_ver.sh, invoked as ../run_[pyrosetta, e2e]_ver.sh input.fa with the output directory as the second argument. For a complex, the README points to network/predict_complex.py with a paired a3m input and chain lengths. For high-throughput interaction screening, the two-track model is invoked as python network_2track/predict_msa.py with the MSA, the output npz name and the length of the first chain, with a worked example in the example/complex_2track directory.

Expected outputs differ by path and should be checked explicitly. The PyRosetta version gives five final models with estimated C-alpha rms error in the B-factor column, and the end-to-end version gives a single PDB with residue-wise lDDT in the same place.

The FAQ documents two practical problems. A segmentation fault while running hhblits or hhsearch is attributed to the statically compiled hhsuite shipped through conda, and the suggested workaround is to compile hhsuite from source and substitute that build. The second entry addresses job scheduling on computing nodes, which is the same guidance noted in the assumptions section: split the pipeline so that the MSA tools run on CPU-heavy nodes and only the network inference runs on the GPU.

Additional resources are linked from the README. The Robetta server at robetta.bakerlab.org offers a RoseTTAFold option, and the CASP14 models for the official targets are published at files.ipd.uw.edu as casp14_models.tar.gz, with the input MSA and hhsearch files included. The last commit on the main branch is dated 27 January 2022 and concerns sequencing databases for a better memory cache, so the repository has been effectively frozen since then even though the repository metadata records a later push on a different branch.

For users who cannot host the databases and the weights, the hosted Robetta route removes both the multi-hundred-gigabyte download and the Rosetta-DL redistribution constraint, at the cost of the institutional agreement that the weight licence requires.

5. Comparison with Alternatives

The comparison inside the paper is against the other CASP14 entrants and against the authors' own two-track model. The three-track models with attention operating at the one, two and three dimensional levels and information flowing between the levels were the best models the authors tested, clearly outperforming the top two server groups, Zhang-server and BAKER-ROSETTASERVER, the BAKER human group which ranked second among all groups, and the authors' own two-track attention models on CASP14 targets. The paper then offers a structural explanation: the improved performance of the three-track models over the two-track model with identical training sets, similar attention-based architectures for the one and two dimensional tracks, and similar operations in inference mode suggests that simultaneously reasoning at the alignment, distance map and coordinate representations can more effectively extract sequence-structure relationships than reasoning over only the alignment and distance map information.

AlphaFold2 is the direct comparison and the paper does not overclaim against it. It notes that the correlation between multiple sequence alignment depth and model accuracy is lower for RoseTTAFold than for trRosetta and other methods tested at CASP14, and it attributes the gap to AlphaFold2 in part to hardware limitations that limited the size of the models the authors could explore, along with other differences. The paper also notes a specific architectural difference: in the two-track AlphaFold2 architecture the prediction of atomic coordinates happens after processing of the one- and two-dimensional information is complete, whereas the three-track design interleaves coordinate refinement with the other representations.

The advantage the paper claims over AlphaFold2 is on the application side rather than on the benchmark. It states that the network enables the rapid solution of challenging X-ray crystallography and cryo-electron microscopy structure modelling problems, provides insights into the functions of proteins of currently unknown structure, and enables rapid generation of accurate protein-protein complex models from sequence information alone, short-circuiting the traditional approach of modelling individual subunits followed by docking.

The RosettaFold filter is a distinct contribution with no AlphaFold2 counterpart in this form. The DAN-msa/ErrorPredictorMSA.py module is an error predictor network that takes a predicted distance map in npz format together with a folder of decoy PDBs or a single PDB, and produces a confidence estimate per structure. It offers a --roll option for distance maps that come from the trunk, and a --pdb flag for single-structure mode. This is the component the Baker Lab uses to pick among decoys and to score candidate interfaces, and it is the part of the toolkit that has no direct equivalent in the AlphaFold2 release.

The two-track model is a third option in the comparison, trading the coordinate track for throughput. Its purpose is yeast protein-protein interaction screening, where producing an interface confidence for every candidate pair matters more than producing a refined three-dimensional structure for each.

Against experimental determination the framing is the same as for the AlphaFold lineage: modelling from sequence cannot replace crystallography or cryo-electron microscopy, but it can supply starting models that shorten the experimental path.

6. Benchmarks and Evidence

The primary benchmark is CASP14. The paper reports that the three-track models clearly outperformed the top two server groups, Zhang-server and BAKER-ROSETTASERVER, as well as the BAKER human group and the authors' two-track attention models, while remaining below AlphaFold2. The comparison is on CASP14 targets, and the authors attribute part of the gap to the hardware limits on model size.

The interface and complex results are reported on protein-protein interaction datasets. For two-chain and three-chain targets built on paired sequence alignments for complexes of known structures, the resulting models were often close to the actual structures, with TM-score above 0.8 in many cases. The paper links this to the information on residue-residue co-evolution between the paired sequences, noting that more accurate complex structures were generated when more sequences were available.

The disease-relevant application result is quantified. The authors used RoseTTAFold to generate models for 693 domains from proteins that are homologs of known structure that contain multiple disease-causing mutations or have been the subject of intensive experimental investigation. Over one third of these models have a predicted lDDT above 0.8, which corresponded to an average C-alpha RMSD of 2.6 angstrom on CASP14 targets.

The paper also reports the robustness of the complex prediction in the presence of limited data. Since the network was trained on monomers, the authors note there may be a training set bias in the monomer structure predictions, and they present the complex results with the caveat that the network was not trained on complexes, with further training on protein-protein complex datasets likely to improve modelling of multiprotein assemblies.

What is not in the paper is worth noting as well. The open-access text of the article does not contain a RosettaFold filter performance table, and the runtime figures for inference are not given in the article itself. Those numbers have to be obtained from the repository, the supplementary material or the service documentation, which is a different provenance from the CASP14 and TM-score figures.

The release of the official CASP14 predictions with the input MSA and hhsearch files included makes the benchmark reproducible from the published artefacts, which is a stronger reproducibility position than a table alone.

7. Role in Physics-AI Workflows

RoseTTAFold occupies a specific position in a computational biology workflow, and the transferable part is the architecture rather than the biology. The three-track pattern is a general way to keep an explicit geometric constraint, in this case inter-residue distance, resident in the middle of a learned model instead of compressing everything into a final regression target. That keeps the intermediate representation physically interpretable, since a distance map is directly comparable to an experimental distance map, and it lets the model be interrogated at the level where an experimentalist can check it.

For simulation-driven work the same division of labour as elsewhere applies: the predicted structure is the initial condition, and any downstream molecular dynamics, docking or free-energy calculation inherits its quality. The distinguishing feature here is the distance map. Because the network exposes a full predicted distance map rather than only a final set of coordinates, a workflow can compare the predicted distances against experimental constraints or against distances sampled from a simulation trajectory, which gives a cheap intermediate diagnostic that a coordinates-only output cannot provide.

The error-predictor component is the piece with the clearest workflow value. A distance-map-based error predictor that scores candidate structures turns a generative step into a filterable one, which is the standard generate-filter-verify pattern that many physics AI pipelines already implement. Running it over a folder of decoys and getting a per-structure confidence is exactly the operation needed to rank outputs of a structure generation or docking stage before spending compute on the survivors.

The iterative structure refinement is another transferable idea. Interleaving coordinate updates with the sequence and pair representations, instead of predicting coordinates once at the end, means the network can use the evolving geometry to focus its attention. In a simulation surrogate this maps onto designs that refine a field or a mesh in the loop with the residual representation, rather than regressing the solution in one shot.

The CASP14 case is instructive for workflow design. The Baker Lab released the official predictions together with the input alignments and search results, which means a third party can reproduce the benchmark path without rerunning the alignment search. For a scientific workflow that is a meaningful difference in cost, and it is the same argument that applies to the precomputed-MSA option in the AlphaFold pipeline.

The complexity-control strategy also transfers. Training on discontinuous crops spanning a fixed total residue count, then averaging the per-crop predictions into a full-length model, is a memory-driven decomposition with a clean aggregation rule. Similar decompositions appear in volumetric simulation surrogates that tile large domains and stitch overlapping patches.

8. Limitations and Failure Modes

The most consequential limitation is the weight licence. The Rosetta-DL Software License permits the software, data or weights to be run, displayed, copied and modified only at the recipient's institution, only for internal non-profit non-commercial research, and requires that results generated with it be made available to other researchers for non-commercial purposes. Publication, distribution or transfer to anyone outside institution employees and students involved in research under supervision is prohibited, and commercial use including fee-based service projects requires a separate paid agreement with the University of Washington. A commercial product built on these weights cannot be distributed, which is a different constraint from the CC BY-NC arrangement used elsewhere in this collection because it also restricts redistribution inside the ecosystem.

The training crop limits the achievable scale. The paper states that large proteins could not be trained on directly because the three-track models have many millions of parameters and the hardware memory was insufficient, so training used discontinuous crops of two segments spanning 260 residues in total. Very large domains and large assemblies therefore sit outside the regime in which the model was fitted.

Complex prediction carries a known training bias. The network was trained on monomers and not on complexes, and the paper says so plainly, noting that this may introduce bias into the monomer structure predictions and that the relative placement of subunits is consequently less well determined than the fold itself.

The sequence-depth dependence is weaker than in the competing lineage. The paper reports that the correlation between multiple sequence alignment depth and model accuracy is lower for RoseTTAFold than for trRosetta and other methods tested at CASP14, which means the method extracts less of its signal from deep alignments and correspondingly more from templates and from the learned prior.

The infrastructure requirements are heavy and the official guidance is explicit that the shipped scripts are guidelines rather than a tuned pipeline. The databases total well over 400 GB across UniRef30, BFD and the template sets, the environment requires a specific CUDA generation with a fallback for CUDA 10, and the README documents a segmentation fault in the conda-supplied hhsuite with a source-rebuild workaround. The FAQ also points out that a PyRosetta licence is required for the version that produces the five refined models.

The repository is effectively frozen. The last commit on the main branch is dated 27 January 2022, and the open issue list at the time of verification contained 93 issues and 6 pull requests, including reports of invalid GPU architecture arguments for nvrtc, bus errors while running predict_e2e.py, download failures for the BFD archive, an unpack failure for the UniRef30 archive, and a bug report on write_pdb in the complex prediction script. The issue numbers also show recurring operational questions, such as whether the model can handle proteins shorter than 50 residues and what the TTA flag in the pipeline stands for.

The three-track architecture is also slower than the two-track variant by design, which constrains it in the high-throughput screening regime. That is precisely why the separate network_2track package exists with its own weights file, and choosing between the two is a task-dependent decision rather than a preference.

9. Version and Source Notes

Several versions coexist and each corresponds to a distinct artefact. The paper in Science volume 374, pages 871 to 876 is dated 15 July 2021 with DOI 10.1126/science.abj8754 under a CC BY licence. The repository's own version markers appear in the model preset names and in the weight archive: the original RoseTTAFold weights, and the RF2t.pt weights for the two-track model added in the November 2021 update for yeast protein-protein interaction screening, with the original weights unchanged by that addition.

The push date and the commit date are different facts and the difference matters here. The repository metadata records a push on 15 February 2024, but the commit history on the main branch ends at 27 January 2022 with the merge of the MSA ordering pull request, and querying commits after 16 February 2024 returns none. The 2024 push therefore belongs to another branch, and the effective end of maintenance on the default branch is January 2022.

The template database snapshot differs between the benchmark and the release. The README points to pdb100_2021Mar03.tar.gz for general use and states explicitly that the March 2020 set was the one used for the CASP14 benchmarks. Reproducing the published CASP14 numbers therefore requires the older snapshot, which the README links separately.

The database snapshots are fixed rather than live. UniRef30 is the June 2020 release and BFD is the specific metaclust id30 c90 final sequence archive listed in the README, so a rerun today operates on the same evolutionary data as the original work and will not reflect any sequence added since.

The model dimensions are configurable and the defaults are worth recording because published results depend on them. The defaults in network/RoseTTAFoldModel.py are d_msa of 64, d_pair of 128, d_templ of 64, n_head_msa of 4, n_head_pair of 8, n_head_templ of 4, d_hidden of 64, n_module of 4, n_module_str of 4, n_layer of 4 and p_drop of 0.1, and the distance head predicts 37 bins for distance, omega and theta and 19 bins for phi.

The confidence metric differs between the two runtime paths and this is easy to misquote. The end-to-end version reports residue-wise lDDT in the B-factor column of a single output PDB, while the PyRosetta version reports an estimated C-alpha rms error in the B-factor column of five output models. One is a local similarity score and the other is a global error estimate, so they are not interchangeable.

The two licences have different scopes that should be quoted separately. The repository code is MIT, with copyright 2021 RosettaCommons, while the weights and data are under the Rosetta-DL Software License, which is a non-commercial institutional agreement rather than an open-source licence, and PyRosetta itself is a separate commercial product requiring its own licence from the University of Washington.

10. References

  1. Baek M, DiMaio F, Anishchenko I, et al. Accurate prediction of protein structures and interactions using a three-track neural network. Science, volume 374, pages 871 to 876, 15 July 2021. DOI 10.1126/science.abj8754. CC BY.
  2. Official RoseTTAFold repository at https://github.com/RosettaCommons/RoseTTAFold , MIT licensed code with weights under the Rosetta-DL licence.
  3. Rosetta-DL Software License, Non-Commercial License Agreement, hosted at files.ipd.uw.edu/pub/RoseTTAFold/Rosetta-DL_LICENSE.txt .
  4. Humphreys IR, Pei J, Baek M, et al. Computed structures of core eukaryotic protein complexes. Science, 2021. DOI 10.1126/science.abm4805.
  5. RoseTTAFold All-Atom repository at https://github.com/baker-laboratory/RoseTTAFold-All-Atom , the full-atom generalisation of the method.
  6. RoseTTAFold2NA repository at https://github.com/uw-ipd/RoseTTAFold2NA , the protein and nucleic acid complex extension.
  7. Fuchs FB, Worrall DE, Fischer V, Welling M. SE(3)-Transformers: 3D Roto-Translation Equivariant Attention Networks. arXiv 2006.10503, 2020.
  8. Choromanski K, et al. Rethinking Attention with Performers. arXiv 2009.14794, 2020.
  9. CASP14 official prediction centre scoreboard at https://predictioncenter.org/casp14/zscores_final.cgi .
  10. CASP14 model predictions with input MSA and hhsearch files at files.ipd.uw.edu/pub/RoseTTAFold/casp14_models.tar.gz .
  11. Robetta server at https://robetta.bakerlab.org/ , the hosted RoseTTAFold option.
  12. Jumper J, Evans R, Pritzel A, et al. Highly accurate protein structure prediction with AlphaFold. Nature, volume 596, pages 583 to 589, 2021. DOI 10.1038/s41586-021-03819-2.
  13. Anishchenko I, Chidyausiku TM, Ovchinnikov S, Pellock SJ, Baker D. De novo protein design by deep network hallucination. Nature, volume 600, 2021. DOI 10.1038/s41586-021-04184-w.
  14. Chaudhury S, Lyskov S, Gray JJ. PyRosetta: a script-based interface for implementing molecular modeling algorithms using Rosetta. Bioinformatics, volume 26, pages 689 to 691, 2010. DOI 10.1093/bioinformatics/btq007.
  15. Steinegger M, Söding J. Protein homology clustering with MMseqs2. Nature Biotechnology, volume 35, pages 539 to 542, 2017.
  16. Mirdita M, et al. UniRef30: a unified and consistent reference for sequence comparison and search. bioRxiv, 2021.
Tags: