Upload 1791 files

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+benchmarks/FoldBench/evaluation/DockQv2/operations.cp310-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text

benchmarks/FoldBench/.gitignore

@@ -0,0 +1,9 @@
+*.pyc
+__pycache__/
+*.sif
+*.ninja_deps
+*.ninja
+*.ninja_deps
+*.ninja_deps.d
+*.ninja_deps.d.tmp
+*.ninja_deps.d.tmp.d

benchmarks/FoldBench/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 FoldBench Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

benchmarks/FoldBench/README.md

@@ -0,0 +1,238 @@
+# Benchmarking all-atom biomolecular structure prediction with FoldBench
+
+![Abstract](./assets/fig1_abstract.png)
+
+
+FoldBench is a low-homology benchmark spanning proteins, nucleic acids, ligands, and six major interaction types, enabling assessments that were previously infeasible with task-specific datasets.
+
+## 📢 Updates
++ **2025-12-31**: The evaluation results for RosettaFold3 (latest) have been updated.
++ **2025-12-05**: The evaluation results for Boltz-2 and OpenFold3-preview have been updated.
++ **2025-12-04**: FoldBench has been published in [Nature Communications](https://www.nature.com/articles/s41467-025-67127-3).
+
+## 🎯 FoldBench Targets
+The FoldBench benchmark targets are open source. This comprehensive dataset, located in the `targets` directory, is organized into two primary collections:
+
+### **Interfaces**
+
+* **Protein–Protein:** 279 interfaces
+* **Antibody–Antigen:** 172 interfaces
+* **Protein–Ligand:** 558 interfaces
+* **Protein–Peptide:** 51 interfaces
+* **Protein–RNA:** 70 interfaces
+* **Protein–DNA:** 330 interfaces
+
+### **Monomeric Structures**
+
+* **Protein Monomers:** 330 structures
+* **RNA Monomers:**  15 structures
+* **DNA Monomers:** 14 structures
+
+## 🏆 Leaderboard
+
+**Evaluation Metrics:** Interface prediction tasks are evaluated by success rate, while monomer prediction tasks use LDDT (Local Distance Difference Test) scores. All results are based on comprehensive evaluations across our low-homology benchmark dataset.
+
+### Results on targets released after 2023-01 (full set)
+#### Protein Interactions
+
+| Model | Protein-Protein | Antibody–Antigen | Protein-Ligand |
+|:--------------:|:--------------:|:-----:|:--------------:|
+| AlphaFold 3    | 72.93%          | 47.90% | 64.90%          |
+| Boltz-1        | 68.25%          | 33.54% | 55.04%          |
+| Chai-1         | 68.53%          | 23.64% | 51.23%          |
+| HelixFold 3    | 66.27%          | 28.40% | 51.82%          |
+| Protenix       | 68.18%          | 34.13% | 50.70%          |
+| OpenFold 3 (preview)     | 69.96%          | 28.83% | 44.49%          |
+
+#### Nucleic acids
+
+| Model | Protein-RNA | Protein-DNA | RNA Monomer | DNA Monomer |
+|:--------------:|:-----------:|:-----------:|:-----------:|:-----------:|
+| AlphaFold 3    | 62.32%       | 79.18%       | 0.61         | 0.53         |
+| Boltz-1        | 56.90%       | 70.97%       | 0.44         | 0.34         |
+| Chai-1         | 50.91%       | 69.97%       | 0.49         | 0.46         |
+| HelixFold 3    | 48.28%       | 50.00%       | 0.55         | 0.29         |
+| Protenix       | 44.78%       | 68.39%       | 0.59         | 0.44         |
+| OpenFold 3 (preview)    | 18.84%       | 5.88%        | 0.63         | 0.51         |
+
+### Results on targets released after 2024-01
+#### Protein Interactions
+| Model | Protein-Protein | Antibody–Antigen | Protein-Ligand |
+|:--------------:|:--------------:|:-----:|:--------------:|
+| AlphaFold 3    | 70.87%          | 47.95% | 67.59%          |
+| Boltz-1        | 64.10%          | 31.43% | 51.33%          |
+| Chai-1         | 66.95%          | 18.31% | 49.28%          |
+| HelixFold 3    | 66.67%          | 28.17% | 50.68%          |
+| Protenix       | 64.80%          | 38.36% | 53.25%          |
+| OpenFold 3 (preview)     | 68.22%          | 34.29% | 40.85%          |
+| Boltz-2*       | 70.54%          | 25.00% | 53.90%          |
+| RosettaFold3*       | 72.44%          | 37.50% | 57.28%     |
+
+
+#### Nucleic acids
+
+| Model | Protein-RNA | Protein-DNA |
+|:--------------:|:-----------:|:-----------:|
+| AlphaFold 3    | 72.50%       | 80.45%       | 
+| Boltz-1        | 70.00%       | 69.77%       |
+| Chai-1         | 55.56%       | 69.14%       | 
+| HelixFold 3    | 54.29%       | 61.18%       | 
+| Protenix       | 56.41%       | 67.63%       | 
+| OpenFold 3 (preview)     | 25.00%       | 5.81%        |
+| Boltz-2*       | 76.92%       | 73.84%  |
+| RosettaFold3*^  | -       | 66.07%       |
+
+
+
+
+*Models marked with * have a training cutoff later than FoldBench's reference date (2023-01-13). FoldBench targets are constructed to ensure **low homology specifically against the PDB data prior to 2023-01-13**. Consequently, models trained on data released after this date may have observed these targets or their close homologs during training (potential data leakage), compromising the low-homology evaluation condition. Results for these models are provided for reference only and should not be directly compared with strictly valid models.
+
+**Nucleic acid monomer results are omitted due to insufficient target availability. 
+
+^Results are not shown due to insufficient targets caused by errors during inference or evaluation stages.
+
+**Note:**
+- Interface prediction is evaluated by success rate.
+- Monomer prediction is evaluated by LDDT.
+- Success is defined as:
+  - For protein–ligand interfaces: LRMSD < 2 Å and LDDT-PLI > 0.8
+  - For all other interfaces: DockQ ≥ 0.23
+- We developed an algorithm to identify and prevent overfitting of models on FoldBench, ensuring fair and reliable evaluation.
+
+## 📈 Detailed Performance Analysis
+
+### Results on targets released after 2023-01 (full set)
+![Protein-Protein Interactions](./assets/detail_full.png)
+
+### Results on targets released after 2024-01
+![Protein-Ligand Interactions](./assets/detail_24.png)
+
+## 🚀 Getting Started
+
+To get started with FoldBench, clone the repository and set up the Conda environment.
+
+```bash
+# 1. Clone the repository
+git clone https://github.com/BEAM-Labs/FoldBench.git
+cd FoldBench
+
+# 2. Create and activate the Conda environment for evaluation
+conda env create -f environment.yml
+conda activate foldbench
+```
+
+## ⚙️ Evaluation
+You can use our provided evaluation samples to reproduce the evaluation workflow. The final results will be generated in `examples/summary_table.csv`.
+
+```bash
+# Ensure you are in the FoldBench root directory and the conda environment is active
+
+# Step 1: Calculate per-target scores from prediction files
+# This uses OpenStructure (ost) and DockQ to score each prediction against its ground truth
+python evaluate.py \
+  --targets_dir ./examples/targets \
+  --evaluation_dir ./examples/outputs/evaluation \
+  --algorithm_name Protenix \
+  --ground_truth_dir ./examples/ground_truths
+
+# Step 2: Aggregate scores and calculate the final success rates/LDDT
+# This summarizes the results for specified models and tasks into a final table
+python task_score_summary.py \
+  --evaluation_dir ./examples/outputs/evaluation \
+  --target_dir ./examples/targets \
+  --output_path ./examples/summary_table.csv \
+  --algorithm_names Protenix \
+  --targets interface_protein_ligand interface_protein_dna monomer_protein \
+  --metric_type rank
+```
+
+### Evaluate more structures
+To evaluate more structures in FoldBench, you'll need to follow these steps:
+
+#### **1. Prepare Your Data**
+
+* **Edit the target CSV files:** Modify the CSV files located in the `examples/targets` directory. These files should contain information about the structures you want to evaluate.
+* **Download ground truth CIF files:** A package containing the specific original CIF files referenced during the benchmark's creation is available for download here: [FoldBench Referenced CIFs](https://drive.google.com/file/d/17KdWDXKATaeHF6inPxhPHIRuIzeqiJxS/view?usp=sharing). Save these files in the `examples/ground_truths` directory. Ensure the filenames correspond to your data in the CSV files.
+
+
+#### **2. Update Evaluation Outputs**
+
+* **Modify `prediction_reference.csv`:** After preparing your data, you'll need to adjust the `./outputs/evaluation/{algorithm_name}/prediction_reference.csv` file to specify the model's ranking scores and the paths to the predicted structures. Please refer to the **[Integrating a New Model into FoldBench](./algorithms/README.md)**.
+
+
+## ✨ Integrating a New Model into FoldBench
+
+We enthusiastically welcome community submissions!
+
+You can submit your algorithm for us to run the tests.
+
+For detailed instructions on how to package your model for submission, please see the contributor's guide:
+**[Integrating a New Model into FoldBench](./algorithms/README.md)**.
+
+
+## 🏠 Repository Structure
+
+The FoldBench repository is organized to separate benchmark data, evaluation code, and evaluation samples. 
+
+```
+FoldBench/
+├── targets/               # FoldBench targets csv files
+│   ├── interface_antibody_antigen.csv
+│   └── ...
+├── algorithms/
+│   ├── algorithm_name/              # Custom model's code and definition files go here
+│   └── ...
+├── examples/
+│   ├── outputs/
+│   │   ├── input/                   # Preprocessed inputs for each algorithm
+│   │   │   └── algorithm_name/
+│   │   ├── prediction/              # Model predictions (e.g., .cif files)
+│   │   │   └── algorithm_name/
+│   │   └── evaluation/              # Final scores and summaries
+│   │       └── algorithm_name/
+│   ├── targets/                     # Target definitions
+│   ├── ground_truths/               # Ground truth cif files
+│   └── alphafold3_inputs.json       # Alphafold3 input json
+├── build_apptainer_images.sh        # Script to build all algorithm containers
+├── environment.yml                  # Conda environment for evaluation scripts
+├── run.sh                           # Master script to run inference and evaluation
+├── evaluate.py                      # Prediction evaluation
+├── task_score_summary.py            # Benchmark score summary
+└── ...
+```
+
+## 🙏 Acknowledgements
+
+We gratefully acknowledge the developers of the following projects, which are essential to FoldBench:
+
++ [Alphafold3](https://github.com/google-deepmind/alphafold3)
++ [Protenix](https://github.com/bytedance/Protenix)
++ [Chai-1](https://github.com/chaidiscovery/chai-lab)
++ [Boltz-1/2](https://github.com/jwohlwend/boltz)
++ [Helixfold3](https://github.com/PaddlePaddle/PaddleHelix/tree/dev/apps/protein_folding/helixfold3)
++ [OpenFold 3](https://github.com/aqlaboratory/openfold-3)
++ [OpenStructure](https://git.scicore.unibas.ch/schwede/openstructure)
++ [DockQ](https://github.com/bjornwallner/DockQ)
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+The MIT License is a permissive open source license that allows for commercial and non-commercial use, modification, distribution, and private use of the software, provided that the original copyright notice and license terms are included.
+
+## ✍️ How to Cite
+
+If you use FoldBench in your research, please cite our paper:
+
+```bibtex
+@article{xu_benchmarking_2025,
+	title = {Benchmarking all-atom biomolecular structure prediction with {FoldBench}},
+	issn = {2041-1723},
+	url = {https://doi.org/10.1038/s41467-025-67127-3},
+	doi = {10.1038/s41467-025-67127-3},
+	journal = {Nature Communications},
+	author = {Xu, Sheng and Feng, Qiantai and Qiao, Lifeng and Wu, Hao and Shen, Tao and Cheng, Yu and Zheng, Shuangjia and Sun, Siqi},
+	month = dec,
+	year = {2025},
+}
+```

benchmarks/FoldBench/algorithms/Protenix/Protenix/LICENSE

@@ -0,0 +1,208 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2024 ByteDance and/or its affiliates.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+Implementation of the `LayerNorm` operators (in protenix/model/layer_norm/) referred to [OneFlow]
+(https://github.com/Oneflow-Inc/oneflow) and [FastFold](https://github.com/hpcaitech/FastFold). 
+We used [OpenFold](https://github.com/aqlaboratory/openfold) for some 
+(in protenix/openfold_local/) implementations, except the `LayerNorm` part. the worker OneFlow,  
+FastFold and openfold are licensed under Apache License 2.0.

benchmarks/FoldBench/algorithms/Protenix/Protenix/configs/configs_base.py

@@ -0,0 +1,353 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# pylint: disable=C0114,C0301
+from protenix.config.extend_types import (
+    GlobalConfigValue,
+    ListValue,
+    RequiredValue,
+    ValueMaybeNone,
+)
+
+basic_configs = {
+    "project": RequiredValue(str),
+    "run_name": RequiredValue(str),
+    "base_dir": RequiredValue(str),
+    # training
+    "eval_interval": RequiredValue(int),
+    "log_interval": RequiredValue(int),
+    "checkpoint_interval": -1,
+    "eval_first": False,  # run evaluate() before training steps
+    "iters_to_accumulate": 1,
+    "eval_only": False,
+    "load_checkpoint_path": "",
+    "load_ema_checkpoint_path": "",
+    "load_strict": False,
+    "load_params_only": True,
+    "skip_load_step": False,
+    "skip_load_optimizer": False,
+    "skip_load_scheduler": False,
+    "train_confidence_only": False,
+    "use_wandb": True,
+    "wandb_id": "",
+    "seed": 42,
+    "deterministic": False,
+    "ema_decay": -1.0,
+    "eval_ema_only": False,  # whether wandb only tracking ema checkpoint metrics
+    "ema_mutable_param_keywords": [""],
+}
+data_configs = {
+    # Data
+    "train_crop_size": 256,
+    "test_max_n_token": -1,
+    "train_lig_atom_rename": False,
+    "train_shuffle_mols": False,
+    "train_shuffle_sym_ids": False,
+    "test_lig_atom_rename": False,
+    "test_shuffle_mols": False,
+    "test_shuffle_sym_ids": False,
+}
+optim_configs = {
+    # Optim
+    "lr": 0.0018,
+    "lr_scheduler": "af3",
+    "warmup_steps": 10,
+    "max_steps": RequiredValue(int),
+    "min_lr_ratio": 0.1,
+    "decay_every_n_steps": 50000,
+    "grad_clip_norm": 10,
+    # Optim - Adam
+    "adam": {
+        "beta1": 0.9,
+        "beta2": 0.95,
+        "weight_decay": 1e-8,
+        "lr": GlobalConfigValue("lr"),
+        "use_adamw": False,
+    },
+    # Optim - LRScheduler
+    "af3_lr_scheduler": {
+        "warmup_steps": GlobalConfigValue("warmup_steps"),
+        "decay_every_n_steps": GlobalConfigValue("decay_every_n_steps"),
+        "decay_factor": 0.95,
+        "lr": GlobalConfigValue("lr"),
+    },
+}
+model_configs = {
+    # Model
+    "c_s": 384,
+    "c_z": 128,
+    "c_s_inputs": 449,  # c_s_inputs == c_token + 32 + 32 + 1
+    "c_atom": 128,
+    "c_atompair": 16,
+    "c_token": 384,
+    "n_blocks": 48,
+    "max_atoms_per_token": 24,  # DNA G max_atoms = 23
+    "no_bins": 64,
+    "sigma_data": 16.0,
+    "diffusion_batch_size": 48,
+    "diffusion_chunk_size": ValueMaybeNone(4),  # chunksize of diffusion_batch_size
+    "blocks_per_ckpt": ValueMaybeNone(
+        1
+    ),  # NOTE: Number of blocks in each activation checkpoint, if None, no checkpointing is performed.
+    # switch of kernels
+    "use_memory_efficient_kernel": False,
+    "use_deepspeed_evo_attention": True,
+    "use_flash": False,
+    "use_lma": False,
+    "use_xformer": False,
+    "find_unused_parameters": False,
+    "dtype": "bf16",  # default training dtype: bf16
+    "loss_metrics_sparse_enable": True,  # the swicth for both sparse lddt metrics and sparse bond/smooth lddt loss
+    "skip_amp": {
+        "sample_diffusion": True,
+        "confidence_head": True,
+        "sample_diffusion_training": True,
+        "loss": True,
+    },
+    "infer_setting": {
+        "chunk_size": ValueMaybeNone(
+            64
+        ),  # should set to null for normal training and small dataset eval [for efficiency]
+        "sample_diffusion_chunk_size": ValueMaybeNone(
+            1
+        ),  # should set to null for normal training and small dataset eval [for efficiency]
+        "lddt_metrics_sparse_enable": GlobalConfigValue("loss_metrics_sparse_enable"),
+        "lddt_metrics_chunk_size": ValueMaybeNone(
+            1
+        ),  # only works if loss_metrics_sparse_enable, can set as default 1
+    },
+    "train_noise_sampler": {
+        "p_mean": -1.2,
+        "p_std": 1.5,
+        "sigma_data": 16.0,  # NOTE: in EDM, this is 1.0
+    },
+    "inference_noise_scheduler": {
+        "s_max": 160.0,
+        "s_min": 4e-4,
+        "rho": 7,
+        "sigma_data": 16.0,  # NOTE: in EDM, this is 1.0
+    },
+    "sample_diffusion": {
+        "gamma0": 0.8,
+        "gamma_min": 1.0,
+        "noise_scale_lambda": 1.003,
+        "step_scale_eta": 1.5,
+        "N_step": 200,
+        "N_sample": 5,
+        "N_step_mini_rollout": 20,
+        "N_sample_mini_rollout": 1,
+    },
+    "model": {
+        "N_model_seed": 1,  # for inference
+        "N_cycle": 4,
+        "input_embedder": {
+            "c_atom": GlobalConfigValue("c_atom"),
+            "c_atompair": GlobalConfigValue("c_atompair"),
+            "c_token": GlobalConfigValue("c_token"),
+        },
+        "relative_position_encoding": {
+            "r_max": 32,
+            "s_max": 2,
+            "c_z": GlobalConfigValue("c_z"),
+        },
+        "template_embedder": {
+            "c": 64,
+            "c_z": GlobalConfigValue("c_z"),
+            "n_blocks": 0,
+            "dropout": 0.25,
+            "blocks_per_ckpt": GlobalConfigValue("blocks_per_ckpt"),
+        },
+        "msa_module": {
+            "c_m": 64,
+            "c_z": GlobalConfigValue("c_z"),
+            "c_s_inputs": GlobalConfigValue("c_s_inputs"),
+            "n_blocks": 4,
+            "msa_dropout": 0.15,
+            "pair_dropout": 0.25,
+            "blocks_per_ckpt": GlobalConfigValue("blocks_per_ckpt"),
+        },
+        "pairformer": {
+            "n_blocks": GlobalConfigValue("n_blocks"),
+            "c_z": GlobalConfigValue("c_z"),
+            "c_s": GlobalConfigValue("c_s"),
+            "n_heads": 16,
+            "dropout": 0.25,
+            "blocks_per_ckpt": GlobalConfigValue("blocks_per_ckpt"),
+        },
+        "diffusion_module": {
+            "use_fine_grained_checkpoint": True,
+            "sigma_data": GlobalConfigValue("sigma_data"),
+            "c_token": 768,
+            "c_atom": GlobalConfigValue("c_atom"),
+            "c_atompair": GlobalConfigValue("c_atompair"),
+            "c_z": GlobalConfigValue("c_z"),
+            "c_s": GlobalConfigValue("c_s"),
+            "c_s_inputs": GlobalConfigValue("c_s_inputs"),
+            "initialization": {
+                "zero_init_condition_transition": False,
+                "zero_init_atom_encoder_residual_linear": False,
+                "he_normal_init_atom_encoder_small_mlp": False,
+                "he_normal_init_atom_encoder_output": False,
+                "glorot_init_self_attention": False,
+                "zero_init_adaln": True,
+                "zero_init_residual_condition_transition": False,
+                "zero_init_dit_output": True,
+                "zero_init_atom_decoder_linear": False,
+            },
+            "atom_encoder": {
+                "n_blocks": 3,
+                "n_heads": 4,
+            },
+            "transformer": {
+                "n_blocks": 24,
+                "n_heads": 16,
+            },
+            "atom_decoder": {
+                "n_blocks": 3,
+                "n_heads": 4,
+            },
+            "blocks_per_ckpt": GlobalConfigValue("blocks_per_ckpt"),
+        },
+        "confidence_head": {
+            "c_z": GlobalConfigValue("c_z"),
+            "c_s": GlobalConfigValue("c_s"),
+            "c_s_inputs": GlobalConfigValue("c_s_inputs"),
+            "n_blocks": 4,
+            "max_atoms_per_token": GlobalConfigValue("max_atoms_per_token"),
+            "pairformer_dropout": 0.0,
+            "blocks_per_ckpt": GlobalConfigValue("blocks_per_ckpt"),
+            "distance_bin_start": 3.25,
+            "distance_bin_end": 52.0,
+            "distance_bin_step": 1.25,
+            "stop_gradient": True,
+        },
+        "distogram_head": {
+            "c_z": GlobalConfigValue("c_z"),
+            "no_bins": GlobalConfigValue("no_bins"),
+        },
+    },
+}
+perm_configs = {
+    # Chain and Atom Permutation
+    "chain_permutation": {
+        "train": {
+            "mini_rollout": True,
+            "diffusion_sample": False,
+        },
+        "test": {
+            "diffusion_sample": True,
+        },
+        "permute_by_pocket": True,
+        "configs": {
+            "use_center_rmsd": False,
+            "find_gt_anchor_first": False,
+            "accept_it_as_it_is": False,
+            "enumerate_all_anchor_pairs": False,
+            "selection_metric": "aligned_rmsd",
+        },
+    },
+    "atom_permutation": {
+        "train": {
+            "mini_rollout": True,
+            "diffusion_sample": False,
+        },
+        "test": {
+            "diffusion_sample": True,
+        },
+        "permute_by_pocket": True,
+        "global_align_wo_symmetric_atom": False,
+    },
+}
+loss_configs = {
+    "loss": {
+        "diffusion_lddt_chunk_size": ValueMaybeNone(1),
+        "diffusion_bond_chunk_size": ValueMaybeNone(1),
+        "diffusion_chunk_size_outer": ValueMaybeNone(-1),
+        "diffusion_sparse_loss_enable": GlobalConfigValue("loss_metrics_sparse_enable"),
+        "diffusion_lddt_loss_dense": True,  # only set true in initial training for training speed
+        "resolution": {"min": 0.1, "max": 4.0},
+        "weight": {
+            "alpha_confidence": 1e-4,
+            "alpha_pae": 0.0,  # or 1 in finetuning stage 3
+            "alpha_except_pae": 1.0,
+            "alpha_diffusion": 4.0,
+            "alpha_distogram": 3e-2,
+            "alpha_bond": 0.0,  # or 1 in finetuning stages
+            "smooth_lddt": 1.0,  # or 0 in finetuning stages
+        },
+        "plddt": {
+            "min_bin": 0,
+            "max_bin": 1.0,
+            "no_bins": 50,
+            "normalize": True,
+            "eps": 1e-6,
+        },
+        "pde": {
+            "min_bin": 0,
+            "max_bin": 32,
+            "no_bins": 64,
+            "eps": 1e-6,
+        },
+        "resolved": {
+            "eps": 1e-6,
+        },
+        "pae": {
+            "min_bin": 0,
+            "max_bin": 32,
+            "no_bins": 64,
+            "eps": 1e-6,
+        },
+        "diffusion": {
+            "mse": {
+                "weight_mse": 1 / 3,
+                "weight_dna": 5.0,
+                "weight_rna": 5.0,
+                "weight_ligand": 10.0,
+                "eps": 1e-6,
+            },
+            "bond": {
+                "eps": 1e-6,
+            },
+            "smooth_lddt": {
+                "eps": 1e-6,
+            },
+        },
+        "distogram": {
+            "min_bin": 2.3125,
+            "max_bin": 21.6875,
+            "no_bins": 64,
+            "eps": 1e-6,
+        },
+    },
+    "metrics": {
+        "lddt": {
+            "eps": 1e-6,
+        },
+        "complex_ranker_keys": ListValue(["plddt", "gpde", "ranking_score"]),
+        "chain_ranker_keys": ListValue(["chain_ptm", "chain_plddt"]),
+        "interface_ranker_keys": ListValue(
+            ["chain_pair_iptm", "chain_pair_iptm_global", "chain_pair_plddt"]
+        ),
+        "clash": {"af3_clash_threshold": 1.1, "vdw_clash_threshold": 0.75},
+    },
+}
+
+configs = {
+    **basic_configs,
+    **data_configs,
+    **optim_configs,
+    **model_configs,
+    **perm_configs,
+    **loss_configs,
+}

benchmarks/FoldBench/algorithms/Protenix/Protenix/configs/configs_data.py

@@ -0,0 +1,199 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# pylint: disable=C0114,C0301
+import os
+from copy import deepcopy
+
+from protenix.config.extend_types import GlobalConfigValue, ListValue
+
+default_test_configs = {
+    "sampler_configs": {
+        "sampler_type": "uniform",
+    },
+    "cropping_configs": {
+        "method_weights": [
+            0.0,  # ContiguousCropping
+            0.0,  # SpatialCropping
+            1.0,  # SpatialInterfaceCropping
+        ],
+        "crop_size": -1,
+    },
+    "lig_atom_rename": GlobalConfigValue("test_lig_atom_rename"),
+    "shuffle_mols": GlobalConfigValue("test_shuffle_mols"),
+    "shuffle_sym_ids": GlobalConfigValue("test_shuffle_sym_ids"),
+}
+
+default_weighted_pdb_configs = {
+    "sampler_configs": {
+        "sampler_type": "weighted",
+        "beta_dict": {
+            "chain": 0.5,
+            "interface": 1,
+        },
+        "alpha_dict": {
+            "prot": 3,
+            "nuc": 3,
+            "ligand": 1,
+        },
+        "force_recompute_weight": True,
+    },
+    "cropping_configs": {
+        "method_weights": ListValue([0.2, 0.4, 0.4]),
+        "crop_size": GlobalConfigValue("train_crop_size"),
+    },
+    "sample_weight": 0.5,
+    "limits": -1,
+    "lig_atom_rename": GlobalConfigValue("train_lig_atom_rename"),
+    "shuffle_mols": GlobalConfigValue("train_shuffle_mols"),
+    "shuffle_sym_ids": GlobalConfigValue("train_shuffle_sym_ids"),
+}
+
+# DATA_ROOT_DIR = "/af3-dev/release_data/"
+DATA_ROOT_DIR = "/af3-dev/release_data/"
+# CCD_COMPONENTS_FILE_PATH = '/data1/qtfeng/dev/af3_benchmark/data/components.cif'
+# CCD_COMPONENTS_RDKIT_MOL_FILE_PATH='/data1/qtfeng/dev/af3_benchmark/data/components.cif.rdkit_mol.pkl'
+
+CCD_COMPONENTS_FILE_PATH = os.path.join(DATA_ROOT_DIR, "components.v20240608.cif")
+CCD_COMPONENTS_RDKIT_MOL_FILE_PATH = os.path.join(
+    DATA_ROOT_DIR, "components.v20240608.cif.rdkit_mol.pkl"
+)
+
+# This is a patch in inference stage for users that do not have root permission.
+# If you run
+# ```
+# bash inference_demo.sh
+# ```
+# or
+# ```
+# protenix predict --input examples/example.json --out_dir  ./output
+# ````
+# The checkpoint and the data cache will be downloaded to the current code directory.
+if (not os.path.exists(CCD_COMPONENTS_FILE_PATH)) or (
+    not os.path.exists(CCD_COMPONENTS_RDKIT_MOL_FILE_PATH)
+):
+    print("Try to find the ccd cache data in the code directory for inference.")
+    current_file_path = os.path.abspath(__file__)
+    current_directory = os.path.dirname(current_file_path)
+    code_directory = os.path.dirname(current_directory)
+
+    data_cache_dir = os.path.join(code_directory, "release_data/ccd_cache")
+    CCD_COMPONENTS_FILE_PATH = os.path.join(data_cache_dir, "components.v20240608.cif")
+    CCD_COMPONENTS_RDKIT_MOL_FILE_PATH = os.path.join(
+        data_cache_dir, "components.v20240608.cif.rdkit_mol.pkl"
+    )
+
+
+data_configs = {
+    "num_dl_workers": 16,
+    "epoch_size": 10000,
+    "train_ref_pos_augment": True,
+    "test_ref_pos_augment": True,
+    "train_sets": ListValue(["weightedPDB_before2109_wopb_nometalc_0925"]),
+    "train_sampler": {
+        "train_sample_weights": ListValue([1.0]),
+        "sampler_type": "weighted",
+    },
+    "test_sets": ListValue(["recentPDB_1536_sample384_0925"]),
+    "weightedPDB_before2109_wopb_nometalc_0925": {
+        "base_info": {
+            "mmcif_dir": os.path.join(DATA_ROOT_DIR, "mmcif"),
+            "bioassembly_dict_dir": os.path.join(DATA_ROOT_DIR, "mmcif_bioassembly"),
+            "indices_fpath": os.path.join(
+                DATA_ROOT_DIR,
+                "indices/weightedPDB_indices_before_2021-09-30_wo_posebusters_resolution_below_9.csv.gz",
+            ),
+            "pdb_list": "",
+            "random_sample_if_failed": True,
+            "max_n_token": -1,  # can be used for removing data with too many tokens.
+            "use_reference_chains_only": False,
+            "exclusion": {  # do not sample the data based on ions.
+                "mol_1_type": ListValue(["ions"]),
+                "mol_2_type": ListValue(["ions"]),
+            },
+        },
+        **deepcopy(default_weighted_pdb_configs),
+    },
+    "recentPDB_1536_sample384_0925": {
+        "base_info": {
+            "mmcif_dir": os.path.join(DATA_ROOT_DIR, "mmcif"),
+            "bioassembly_dict_dir": os.path.join(
+                DATA_ROOT_DIR, "recentPDB_bioassembly"
+            ),
+            "indices_fpath": os.path.join(
+                DATA_ROOT_DIR, "indices/recentPDB_low_homology_maxtoken1536.csv"
+            ),
+            "pdb_list": os.path.join(
+                DATA_ROOT_DIR,
+                "indices/recentPDB_low_homology_maxtoken1024_sample384_pdb_id.txt",
+            ),
+            "max_n_token": GlobalConfigValue("test_max_n_token"),  # filter data
+            "sort_by_n_token": False,
+            "group_by_pdb_id": True,
+            "find_eval_chain_interface": True,
+        },
+        **deepcopy(default_test_configs),
+    },
+    "posebusters_0925": {
+        "base_info": {
+            "mmcif_dir": os.path.join(DATA_ROOT_DIR, "posebusters_mmcif"),
+            "bioassembly_dict_dir": os.path.join(
+                DATA_ROOT_DIR, "posebusters_bioassembly"
+            ),
+            "indices_fpath": os.path.join(
+                DATA_ROOT_DIR, "indices/posebusters_indices_mainchain_interface.csv"
+            ),
+            "pdb_list": "",
+            "find_pocket": True,
+            "find_all_pockets": False,
+            "max_n_token": GlobalConfigValue("test_max_n_token"),  # filter data
+        },
+        **deepcopy(default_test_configs),
+    },
+    "msa": {
+        "enable": True,
+        "enable_rna_msa": False,
+        "prot": {
+            "pairing_db": "uniref100",
+            "non_pairing_db": "mmseqs_other",
+            "pdb_mmseqs_dir": os.path.join(DATA_ROOT_DIR, "mmcif_msa"),
+            "seq_to_pdb_idx_path": os.path.join(DATA_ROOT_DIR, "seq_to_pdb_index.json"),
+            "indexing_method": "sequence",
+        },
+        "rna": {
+            "seq_to_pdb_idx_path": "",
+            "rna_msa_dir": "",
+            "indexing_method": "sequence",
+        },
+        "strategy": "random",
+        "merge_method": "dense_max",
+        "min_size": {
+            "train": 1,
+            "test": 2048,
+        },
+        "max_size": {
+            "train": 16384,
+            "test": 16384,
+        },
+        "sample_cutoff": {
+            "train": 2048,
+            "test": 2048,
+        },
+    },
+    "template": {
+        "enable": False,
+    },
+    "ccd_components_file": CCD_COMPONENTS_FILE_PATH,
+    "ccd_components_rdkit_mol_file": CCD_COMPONENTS_RDKIT_MOL_FILE_PATH,
+}

benchmarks/FoldBench/algorithms/Protenix/Protenix/configs/configs_inference.py

@@ -0,0 +1,35 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# pylint: disable=C0114
+import os
+
+from protenix.config.extend_types import ListValue, RequiredValue
+
+current_file_path = os.path.abspath(__file__)
+current_directory = os.path.dirname(current_file_path)
+code_directory = os.path.dirname(current_directory)
+# The model will be download to the following dir if not exists:
+# "./release_data/checkpoint/model_v0.2.0.pt"
+inference_configs = {
+    "seeds": ListValue([101]),
+    "dump_dir": "./output",
+    "need_atom_confidence": False,
+    "input_json_path": RequiredValue(str),
+    "load_checkpoint_path": os.path.join(
+        code_directory, "./release_data/checkpoint/model_v0.2.0.pt"
+    ),
+    "num_workers": 16,
+    "use_msa": True,
+}

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/config/__init__.py

@@ -0,0 +1,14 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from .config import load_config, parse_configs, parse_sys_args, save_config

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/config/config.py

@@ -0,0 +1,288 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import copy
+import sys
+from typing import Any, Optional, Union
+
+import yaml
+from ml_collections.config_dict import ConfigDict
+
+from protenix.config.extend_types import (
+    DefaultNoneWithType,
+    GlobalConfigValue,
+    ListValue,
+    RequiredValue,
+    ValueMaybeNone,
+    get_bool_value,
+)
+
+
+class ArgumentNotSet(object):
+    pass
+
+
+class ConfigManager(object):
+    def __init__(self, global_configs: dict, fill_required_with_null: bool = False):
+        """
+        Initialize the ConfigManager instance.
+
+        Args:
+            global_configs (dict): A dictionary containing global configuration settings.
+            fill_required_with_null (bool, optional):
+                A boolean flag indicating whether required values should be filled with `None` if not provided. Defaults to False.
+        """
+        self.global_configs = global_configs
+        self.fill_required_with_null = fill_required_with_null
+        self.config_infos, self.default_configs = self.get_config_infos()
+
+    def get_value_info(
+        self, value
+    ) -> tuple[Any, Optional[Any], Optional[bool], Optional[bool]]:
+        """
+        Return the type, default value, whether it allows None, and whether it is required for a given value.
+
+        Args:
+            value: The value to determine the information for.
+
+        Returns:
+            tuple: A tuple containing the following elements:
+                - dtype: The type of the value.
+                - default_value: The default value for the value.
+                - allow_none: A boolean indicating whether the value can be None.
+                - required: A boolean indicating whether the value is required.
+        """
+        if isinstance(value, DefaultNoneWithType):
+            return value.dtype, None, True, False
+        elif isinstance(value, ValueMaybeNone):
+            return value.dtype, value.value, True, False
+        elif isinstance(value, RequiredValue):
+            if self.fill_required_with_null:
+                return value.dtype, None, True, False
+            else:
+                return value.dtype, None, False, True
+        elif isinstance(value, GlobalConfigValue):
+            return self.get_value_info(self.global_configs[value.global_key])
+        elif isinstance(value, ListValue):
+            return (value.dtype, value.value, False, False)
+        elif isinstance(value, list):
+            return (type(value[0]), value, False, False)
+        else:
+            return type(value), value, False, False
+
+    def _get_config_infos(self, config_dict: dict) -> dict:
+        """
+        Recursively extracts configuration information from a given dictionary.
+
+        Args:
+            config_dict (dict): The dictionary containing configuration settings.
+
+        Returns:
+            tuple: A tuple containing two dictionaries:
+                - all_keys: A dictionary mapping keys to their corresponding configuration information.
+                - default_configs: A dictionary mapping keys to their default configuration values.
+
+        Raises:
+            AssertionError: If a key contains a period (.), which is not allowed.
+        """
+        all_keys = {}
+        default_configs = {}
+        for key, value in config_dict.items():
+            assert "." not in key
+            if isinstance(value, (dict)):
+                children_keys, children_configs = self._get_config_infos(value)
+                all_keys.update(
+                    {
+                        f"{key}.{child_key}": child_value_type
+                        for child_key, child_value_type in children_keys.items()
+                    }
+                )
+                default_configs[key] = children_configs
+            else:
+                value_info = self.get_value_info(value)
+                all_keys[key] = value_info
+                default_configs[key] = value_info[1]
+        return all_keys, default_configs
+
+    def get_config_infos(self):
+        return self._get_config_infos(self.global_configs)
+
+    def _merge_configs(
+        self,
+        new_configs: dict,
+        global_configs: dict,
+        local_configs: dict,
+        prefix="",
+    ) -> ConfigDict:
+        """Overwrite default configs with new configs recursively.
+        Args:
+            new_configs: global flattern config dict with all hierarchical config keys joined by '.', i.e.
+                {
+                    'c_z': 32,
+                    'model.evoformer.c_z': 16,
+                    ...
+                }
+            global_configs: global hierarchical merging configs, i.e.
+                {
+                    'c_z' 32,
+                    'c_m': 128,
+                    'model': {
+                        'evoformer': {
+                            ...
+                        }
+                    }
+                }
+            local_configs: hierarchical merging config dict in current level, i.e. for 'model' level, this maybe
+                {
+                    'evoformer': {
+                        'c_z': GlobalConfigValue("c_z"),
+                    },
+                    'embedder': {
+                        ...
+                    }
+                }
+            prefix (str, optional): A prefix string to prepend to keys during recursion. Defaults to an empty string.
+
+        Returns:
+            ConfigDict: The merged configuration dictionary.
+
+        Raises:
+            Exception: If a required config value is not allowed to be None.
+        """
+        # Merge configs in current level first, since these configs maybe referenced by lower level
+        for key, value in local_configs.items():
+            if isinstance(value, dict):
+                continue
+            full_key = f"{prefix}.{key}" if prefix else key
+            dtype, default_value, allow_none, required = self.config_infos[full_key]
+            if full_key in new_configs and not isinstance(
+                new_configs[full_key], ArgumentNotSet
+            ):
+                if allow_none and new_configs[full_key] in [
+                    "None",
+                    "none",
+                    "null",
+                ]:
+                    local_configs[key] = None
+                elif dtype == bool:
+                    local_configs[key] = get_bool_value(new_configs[full_key])
+                elif isinstance(value, (ListValue, list)):
+                    local_configs[key] = (
+                        [dtype(s) for s in new_configs[full_key].strip().split(",")]
+                        if new_configs[full_key].strip()
+                        else []
+                    )
+                else:
+                    local_configs[key] = dtype(new_configs[full_key])
+            elif isinstance(value, GlobalConfigValue):
+                local_configs[key] = global_configs[value.global_key]
+            else:
+                if not allow_none and default_value is None:
+                    raise Exception(f"config {full_key} not allowed to be none")
+                local_configs[key] = default_value
+        for key, value in local_configs.items():
+            if not isinstance(value, dict):
+                continue
+            self._merge_configs(
+                new_configs, global_configs, value, f"{prefix}.{key}" if prefix else key
+            )
+
+    def merge_configs(self, new_configs: dict) -> ConfigDict:
+        configs = copy.deepcopy(self.global_configs)
+        self._merge_configs(new_configs, configs, configs)
+        return ConfigDict(configs)
+
+
+def parse_configs(
+    configs: dict, arg_str: str = None, fill_required_with_null: bool = False
+) -> ConfigDict:
+    """
+    Parses and merges configuration settings from a dictionary and command-line arguments.
+
+    Args:
+        configs (dict): A dictionary containing initial configuration settings.
+        arg_str (str, optional): A string representing command-line arguments. Defaults to None.
+        fill_required_with_null (bool, optional):
+            A boolean flag indicating whether required values should be filled with `None` if not provided. Defaults to False.
+
+    Returns:
+        ConfigDict: The merged configuration dictionary.
+    """
+    manager = ConfigManager(configs, fill_required_with_null=fill_required_with_null)
+    parser = argparse.ArgumentParser()
+    # Register arguments
+    for key, (
+        dtype,
+        default_value,
+        allow_none,
+        required,
+    ) in manager.config_infos.items():
+        # All config use str type, strings will be converted to real dtype later
+        parser.add_argument(
+            "--" + key, type=str, default=ArgumentNotSet(), required=required
+        )
+    # Merge user commandline pargs with default ones
+    merged_configs = manager.merge_configs(
+        vars(parser.parse_args(arg_str.split())) if arg_str else {}
+    )
+    return merged_configs
+
+
+def parse_sys_args() -> str:
+    """
+    Check whether command-line arguments are valid.
+    Each argument is expected to be in the format `--key value`.
+
+    Returns:
+        str: A string formatted as command-line arguments.
+
+    Raises:
+        AssertionError: If any key does not start with `--`.
+    """
+    args = sys.argv[1:]
+    arg_str = ""
+    for k, v in zip(args[::2], args[1::2]):
+        assert k.startswith("--")
+        arg_str += f"{k} {v} "
+    return arg_str
+
+
+def load_config(path: str) -> dict:
+    """
+    Loads a configuration from a YAML file.
+
+    Args:
+        path (str): The path to the YAML file containing the configuration.
+
+    Returns:
+        dict: A dictionary containing the configuration loaded from the YAML file.
+    """
+    with open(path, "r") as f:
+        return yaml.safe_load(f)
+
+
+def save_config(config: Union[ConfigDict, dict], path: str) -> None:
+    """
+    Saves a configuration to a YAML file.
+
+    Args:
+        config (ConfigDict or dict): The configuration to be saved.
+            If it is a ConfigDict, it will be converted to a dictionary.
+        path (str): The path to the YAML file where the configuration will be saved.
+    """
+    with open(path, "w") as f:
+        if isinstance(config, ConfigDict):
+            config = config.to_dict()
+        yaml.safe_dump(config, f)

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/config/extend_types.py

@@ -0,0 +1,55 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class DefaultNoneWithType(object):
+    def __init__(self, dtype):
+        self.dtype = dtype
+
+
+class ValueMaybeNone(object):
+    def __init__(self, value):
+        assert value is not None
+        self.dtype = type(value)
+        self.value = value
+
+
+class GlobalConfigValue(object):
+    def __init__(self, global_key):
+        self.global_key = global_key
+
+
+class RequiredValue(object):
+    def __init__(self, dtype):
+        self.dtype = dtype
+
+
+class ListValue(object):
+    def __init__(self, value, dtype=None):
+        if value is not None:
+            self.value = value
+            self.dtype = type(value[0])
+        else:
+            self.value = None
+            self.dtype = dtype
+
+
+def get_bool_value(bool_str: str):
+    bool_str_lower = bool_str.lower()
+    if bool_str_lower in ("false", "f", "no", "n", "0"):
+        return False
+    elif bool_str_lower in ("true", "t", "yes", "y", "1"):
+        return True
+    else:
+        raise ValueError(f"Cannot interpret {bool_str} as bool")

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/data/ccd.py

@@ -0,0 +1,450 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import functools
+import logging
+import pickle
+from collections import defaultdict
+from pathlib import Path
+from typing import Any, Optional, Union
+
+import biotite
+import biotite.structure as struc
+import biotite.structure.io.pdbx as pdbx
+import numpy as np
+from biotite.structure import AtomArray
+from rdkit import Chem
+
+from configs.configs_data import data_configs
+from protenix.data.substructure_perms import get_substructure_perms
+
+logger = logging.getLogger(__name__)
+
+COMPONENTS_FILE = data_configs["ccd_components_file"]
+RKDIT_MOL_PKL = Path(data_configs["ccd_components_rdkit_mol_file"])
+
+
+@functools.lru_cache
+def biotite_load_ccd_cif() -> pdbx.CIFFile:
+    """biotite load CCD components file
+
+    Returns:
+        pdbx.CIFFile: ccd components file
+    """
+    return pdbx.CIFFile.read(COMPONENTS_FILE)
+
+
+def _map_central_to_leaving_groups(component) -> Optional[dict[str, list[list[str]]]]:
+    """map each central atom (bonded atom) index to leaving atom groups in component (atom_array).
+
+    Returns:
+        dict[str, list[list[str]]]: central atom name to leaving atom groups (atom names).
+    """
+    comp = component.copy()
+    # Eg: ions
+    if comp.bonds is None:
+        return {}
+    central_to_leaving_groups = defaultdict(list)
+    for c_idx in np.flatnonzero(~comp.leaving_atom_flag):
+        bonds, _ = comp.bonds.get_bonds(c_idx)
+        for l_idx in bonds:
+            if comp.leaving_atom_flag[l_idx]:
+                comp.bonds.remove_bond(c_idx, l_idx)
+                group_idx = struc.find_connected(comp.bonds, l_idx)
+                if not np.all(comp.leaving_atom_flag[group_idx]):
+                    return None
+                central_to_leaving_groups[comp.atom_name[c_idx]].append(
+                    comp.atom_name[group_idx].tolist()
+                )
+    return central_to_leaving_groups
+
+
+@functools.lru_cache
+def get_component_atom_array(
+    ccd_code: str, keep_leaving_atoms: bool = False, keep_hydrogens=False
+) -> AtomArray:
+    """get component atom array
+
+    Args:
+        ccd_code (str): ccd code
+        keep_leaving_atoms (bool, optional): keep leaving atoms. Defaults to False.
+        keep_hydrogens (bool, optional): keep hydrogens. Defaults to False.
+
+    Returns:
+        AtomArray: Biotite AtomArray of CCD component
+            with additional attribute: leaving_atom_flag (bool)
+    """
+    ccd_cif = biotite_load_ccd_cif()
+    if ccd_code not in ccd_cif:
+        logger.warning(f"Warning: get_component_atom_array() can not parse {ccd_code}")
+        return None
+    try:
+        comp = pdbx.get_component(ccd_cif, data_block=ccd_code, use_ideal_coord=True)
+    except biotite.InvalidFileError as e:
+        # Eg: UNL without atom.
+        logger.warning(
+            f"Warning: get_component_atom_array() can not parse {ccd_code} for {e}"
+        )
+        return None
+    atom_category = ccd_cif[ccd_code]["chem_comp_atom"]
+    leaving_atom_flag = atom_category["pdbx_leaving_atom_flag"].as_array()
+    comp.set_annotation("leaving_atom_flag", leaving_atom_flag == "Y")
+
+    for atom_id in ["alt_atom_id", "pdbx_component_atom_id"]:
+        comp.set_annotation(atom_id, atom_category[atom_id].as_array())
+    if not keep_leaving_atoms:
+        comp = comp[~comp.leaving_atom_flag]
+    if not keep_hydrogens:
+        # EG: ND4
+        comp = comp[~np.isin(comp.element, ["H", "D"])]
+
+    # Map central atom index to leaving group (atom_indices) in component (atom_array).
+    comp.central_to_leaving_groups = _map_central_to_leaving_groups(comp)
+    if comp.central_to_leaving_groups is None:
+        logger.warning(
+            f"Warning: ccd {ccd_code} has leaving atom group bond to more than one central atom, central_to_leaving_groups is None."
+        )
+    return comp
+
+
+@functools.lru_cache(maxsize=None)
+def get_one_letter_code(ccd_code: str) -> Union[str, None]:
+    """get one_letter_code from CCD components file.
+
+    normal return is one letter: ALA --> A, DT --> T
+    unknown protein: X
+    unknown DNA or RNA: N
+    other unknown: None
+    some ccd_code will return more than one letter:
+    eg: XXY --> THG
+
+    Args:
+        ccd_code (str): _description_
+
+    Returns:
+        str: one letter code
+    """
+    ccd_cif = biotite_load_ccd_cif()
+    if ccd_code not in ccd_cif:
+        return None
+    one = ccd_cif[ccd_code]["chem_comp"]["one_letter_code"].as_item()
+    if one == "?":
+        return None
+    else:
+        return one
+
+
+@functools.lru_cache(maxsize=None)
+def get_mol_type(ccd_code: str) -> str:
+    """get mol_type from CCD components file.
+
+    based on _chem_comp.type
+    http://mmcif.rcsb.org/dictionaries/mmcif_pdbx_v50.dic/Items/_chem_comp.type.html
+
+    not use _chem_comp.pdbx_type, because it is not consistent with _chem_comp.type
+    e.g. ccd 000 --> _chem_comp.type="NON-POLYMER" _chem_comp.pdbx_type="ATOMP"
+    https://mmcif.wwpdb.org/dictionaries/mmcif_pdbx_v5_next.dic/Items/_struct_asym.pdbx_type.html
+
+    Args:
+        ccd_code (str): ccd code
+
+    Returns:
+        str: mol_type, one of {"protein", "rna", "dna", "ligand"}
+    """
+    ccd_cif = biotite_load_ccd_cif()
+    if ccd_code not in ccd_cif:
+        return "ligand"
+
+    link_type = ccd_cif[ccd_code]["chem_comp"]["type"].as_item().upper()
+
+    if "PEPTIDE" in link_type and link_type != "PEPTIDE-LIKE":
+        return "protein"
+    if "DNA" in link_type:
+        return "dna"
+    if "RNA" in link_type:
+        return "rna"
+    return "ligand"
+
+
+def get_all_ccd_code() -> list:
+    """get all ccd code from components file"""
+    ccd_cif = biotite_load_ccd_cif()
+    return list(ccd_cif.keys())
+
+
+_ccd_rdkit_mols: dict[str, Chem.Mol] = {}
+
+
+def get_component_rdkit_mol(ccd_code: str) -> Union[Chem.Mol, None]:
+    """get rdkit mol by PDBeCCDUtils
+    https://github.com/PDBeurope/ccdutils
+
+    preprocessing all ccd components in _components_file at first time run.
+
+    Args:
+        ccd_code (str): ccd code
+
+    Returns
+        rdkit.Chem.Mol: rdkit mol with ref coord
+    """
+    global _ccd_rdkit_mols
+    # _ccd_rdkit_mols is not empty
+    if _ccd_rdkit_mols:
+        return _ccd_rdkit_mols.get(ccd_code, None)
+
+    rdkit_mol_pkl = RKDIT_MOL_PKL
+    if rdkit_mol_pkl.exists():
+        with open(rdkit_mol_pkl, "rb") as f:
+            _ccd_rdkit_mols = pickle.load(f)
+        return _ccd_rdkit_mols.get(ccd_code, None)
+    else:
+        raise FileNotFoundError(
+            f"CCD components file {rdkit_mol_pkl} not found, please download it to your DATA_ROOT_DIR before running."
+            "See https://github.com/bytedance/Protenix"
+        )
+
+
+@functools.lru_cache
+def get_ccd_ref_info(ccd_code: str, return_perm: bool = True) -> dict[str, Any]:
+    """
+    Ref: AlphaFold3 SI Chapter 2.8
+    Reference features. Features derived from a residue, nucleotide or ligand’s reference conformer.
+    Given an input CCD code or SMILES string, the conformer is typically generated
+    with RDKit v.2023_03_3 [25] using ETKDGv3 [26]. On error, we fall back to using the CCD ideal coordinates,
+    or finally the representative coordinates
+    if they are from before our training date cut-off (2021-09-30 unless otherwise stated).
+    At the end, any atom coordinates still missing are set to zeros.
+
+    Get reference atom mapping and coordinates.
+
+    Args:
+        name (str): CCD name
+        return_perm (bool): return atom permutations.
+
+    Returns:
+        Dict:
+            ccd: ccd code
+            atom_map: atom name to atom index
+            coord: atom coordinates
+            charge: atom formal charge
+            perm: atom permutation
+    """
+    mol = get_component_rdkit_mol(ccd_code)
+    if mol is None:
+        return {}
+    if mol.GetNumAtoms() == 0:  # eg: "UNL"
+        logger.warning(
+            f"Warning: mol {ccd_code} from get_component_rdkit_mol() has no atoms,"
+            "get_ccd_ref_info() return empty dict"
+        )
+        return {}
+    conf = mol.GetConformer(mol.ref_conf_id)
+    coord = conf.GetPositions()
+    charge = np.array([atom.GetFormalCharge() for atom in mol.GetAtoms()])
+
+    results = {
+        "ccd": ccd_code,  # str
+        "atom_map": mol.atom_map,  # dict[str,int]: atom name to atom index
+        "coord": coord,  # np.ndarray[float]: atom coordinates, shape:(n_atom,3)
+        "mask": mol.ref_mask,  # np.ndarray[bool]: atom mask, shape:(n_atom,)
+        "charge": charge,  # np.ndarray[int]: atom formal charge, shape:(n_atom,)
+    }
+
+    if return_perm:
+        try:
+            Chem.SanitizeMol(mol)
+            perm = get_substructure_perms(mol, MaxMatches=1000)
+
+        except:
+            # Sanitize failed, permutation is unavailable
+            perm = np.array(
+                [
+                    [
+                        i
+                        for i, atom in enumerate(mol.GetAtoms())
+                        if atom.GetAtomicNum() != 1
+                    ]
+                ]
+            )
+        # np.ndarray[int]: atom permutation, shape:(n_atom_wo_h, n_perm)
+        results["perm"] = perm.T
+
+    return results
+
+
+# Modified from biotite to use consistent ccd components file
+def _connect_inter_residue(
+    atoms: AtomArray, residue_starts: np.ndarray
+) -> struc.BondList:
+    """
+    Create a :class:`BondList` containing the bonds between adjacent
+    amino acid or nucleotide residues.
+
+    Parameters
+    ----------
+    atoms : AtomArray or AtomArrayStack
+        The structure to create the :class:`BondList` for.
+    residue_starts : ndarray, dtype=int
+        Return value of
+        ``get_residue_starts(atoms, add_exclusive_stop=True)``.
+
+    Returns
+    -------
+    BondList
+        A bond list containing all inter residue bonds.
+    """
+
+    bonds = []
+
+    atom_names = atoms.atom_name
+    res_names = atoms.res_name
+    res_ids = atoms.res_id
+    chain_ids = atoms.chain_id
+
+    # Iterate over all starts excluding:
+    #   - the last residue and
+    #   - exclusive end index of 'atoms'
+    for i in range(len(residue_starts) - 2):
+        curr_start_i = residue_starts[i]
+        next_start_i = residue_starts[i + 1]
+        after_next_start_i = residue_starts[i + 2]
+
+        # Check if the current and next residue is in the same chain
+        if chain_ids[next_start_i] != chain_ids[curr_start_i]:
+            continue
+        # Check if the current and next residue
+        # have consecutive residue IDs
+        # (Same residue ID is also possible if insertion code is used)
+        if res_ids[next_start_i] - res_ids[curr_start_i] > 1:
+            continue
+
+        # Get link type for this residue from RCSB components.cif
+        curr_link = get_mol_type(res_names[curr_start_i])
+        next_link = get_mol_type(res_names[next_start_i])
+
+        if curr_link == "protein" and next_link in "protein":
+            curr_connect_atom_name = "C"
+            next_connect_atom_name = "N"
+        elif curr_link in ["dna", "rna"] and next_link in ["dna", "rna"]:
+            curr_connect_atom_name = "O3'"
+            next_connect_atom_name = "P"
+        else:
+            # Create no bond if the connection types of consecutive
+            # residues are not compatible
+            continue
+
+        # Index in atom array for atom name in current residue
+        # Addition of 'curr_start_i' is necessary, as only a slice of
+        # 'atom_names' is taken, beginning at 'curr_start_i'
+        curr_connect_indices = np.where(
+            atom_names[curr_start_i:next_start_i] == curr_connect_atom_name
+        )[0]
+        curr_connect_indices += curr_start_i
+
+        # Index in atom array for atom name in next residue
+        next_connect_indices = np.where(
+            atom_names[next_start_i:after_next_start_i] == next_connect_atom_name
+        )[0]
+        next_connect_indices += next_start_i
+
+        if len(curr_connect_indices) == 0 or len(next_connect_indices) == 0:
+            # The connector atoms are not found in the adjacent residues
+            # -> skip this bond
+            continue
+
+        bonds.append(
+            (curr_connect_indices[0], next_connect_indices[0], struc.BondType.SINGLE)
+        )
+
+    return struc.BondList(atoms.array_length(), np.array(bonds, dtype=np.uint32))
+
+
+def add_inter_residue_bonds(
+    atom_array: AtomArray,
+    exclude_struct_conn_pairs: bool = False,
+    remove_far_inter_chain_pairs: bool = False,
+) -> AtomArray:
+    """
+    add polymer bonds (C-N or O3'-P) between adjacent residues based on auth_seq_id.
+
+    exclude_struct_conn_pairs: if True, do not add bond between adjacent residues already has non-standard polymer bonds
+                  on atom C or N or O3' or P.
+
+    remove_far_inter_chain_pairs: if True, remove inter chain (based on label_asym_id) bonds that are far away from each other.
+
+    returns:
+        AtomArray: Biotite AtomArray merged inter residue bonds into atom_array.bonds
+    """
+    res_starts = struc.get_residue_starts(atom_array, add_exclusive_stop=True)
+    inter_bonds = _connect_inter_residue(atom_array, res_starts)
+
+    if atom_array.bonds is None:
+        atom_array.bonds = inter_bonds
+        return atom_array
+
+    select_mask = np.ones(len(inter_bonds._bonds), dtype=bool)
+    if exclude_struct_conn_pairs:
+        for b_idx, (atom_i, atom_j, b_type) in enumerate(inter_bonds._bonds):
+            atom_k = atom_i if atom_array.atom_name[atom_i] in ("N", "O3'") else atom_j
+            bonds, types = atom_array.bonds.get_bonds(atom_k)
+            if len(bonds) == 0:
+                continue
+            for b in bonds:
+                if (
+                    # adjacent residues
+                    abs((res_starts <= b).sum() - (res_starts <= atom_k).sum()) == 1
+                    and atom_array.chain_id[b] == atom_array.chain_id[atom_k]
+                    and atom_array.atom_name[b] not in ("C", "P")
+                ):
+                    select_mask[b_idx] = False
+                    break
+
+    if remove_far_inter_chain_pairs:
+        if not hasattr(atom_array, "label_asym_id"):
+            logging.warning(
+                "label_asym_id not found, far inter chain bonds will not be removed"
+            )
+        for b_idx, (atom_i, atom_j, b_type) in enumerate(inter_bonds._bonds):
+            if atom_array.label_asym_id[atom_i] != atom_array.label_asym_id[atom_j]:
+                coord_i = atom_array.coord[atom_i]
+                coord_j = atom_array.coord[atom_j]
+                if np.linalg.norm(coord_i - coord_j) > 2.5:
+                    select_mask[b_idx] = False
+
+    # filter out removed_inter_bonds from atom_array.bonds
+    remove_bonds = inter_bonds._bonds[~select_mask]
+    remove_mask = np.isin(atom_array.bonds._bonds[:, 0], remove_bonds[:, 0]) & np.isin(
+        atom_array.bonds._bonds[:, 1], remove_bonds[:, 1]
+    )
+    atom_array.bonds._bonds = atom_array.bonds._bonds[~remove_mask]
+
+    # merged normal inter_bonds into atom_array.bonds
+    inter_bonds._bonds = inter_bonds._bonds[select_mask]
+    atom_array.bonds = atom_array.bonds.merge(inter_bonds)
+    return atom_array
+
+
+def res_names_to_sequence(res_names: list[str]) -> str:
+    """convert res_names to sequences {chain_id: canonical_sequence} based on CCD
+
+    Return
+        str: canonical_sequence
+    """
+    seq = ""
+    for res_name in res_names:
+        one = get_one_letter_code(res_name)
+        one = "X" if one is None else one
+        one = "X" if len(one) > 1 else one
+        seq += one
+    return seq

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/data/constants.py

@@ -0,0 +1,964 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+EvaluationChainInterface = [
+    "intra_ligand",
+    "intra_dna",
+    "intra_rna",
+    "intra_prot",
+    "ligand_prot",
+    "rna_prot",
+    "dna_prot",
+    "prot_prot",
+    "antibody_antigen",
+    "antibody",
+]
+
+EntityPolyTypeDict = {
+    "nuc": [
+        "peptide nucleic acid",
+        "polydeoxyribonucleotide",
+        "polydeoxyribonucleotide/polyribonucleotide hybrid",
+        "polyribonucleotide",
+    ],
+    "protein": ["polypeptide(D)", "polypeptide(L)"],
+    "ligand": ["cyclic-pseudo-peptide", "other"],
+}
+
+
+### Protein Constants ###
+# https://mmcif.wwpdb.org/dictionaries/mmcif_pdbx_v40.dic/Items/_entity_poly.pdbx_seq_one_letter_code_can.html
+from rdkit.Chem import GetPeriodicTable
+
+mmcif_restype_1to3 = {
+    "A": "ALA",
+    "R": "ARG",
+    "N": "ASN",
+    "D": "ASP",
+    "C": "CYS",
+    "Q": "GLN",
+    "E": "GLU",
+    "G": "GLY",
+    "H": "HIS",
+    "I": "ILE",
+    "L": "LEU",
+    "K": "LYS",
+    "M": "MET",
+    "F": "PHE",
+    "P": "PRO",
+    "S": "SER",
+    "T": "THR",
+    "W": "TRP",
+    "Y": "TYR",
+    "V": "VAL",
+    "B": "ASX",  # additional
+    "Z": "GLX",  # additional
+    # "X": "UNK",
+}
+
+mmcif_restype_3to1 = {v: k for k, v in mmcif_restype_1to3.items()}
+
+"""
+vdw table from rdkit; indices match those of the ligand atom_types.
+https://github.com/rdkit/rdkit/blob/master/Code/GraphMol/atomic_data.cpp#L46
+"""
+
+rdkit_vdws = [
+    1.2,
+    1.4,
+    2.2,
+    1.9,
+    1.8,
+    1.7,
+    1.6,
+    1.55,
+    1.5,
+    1.54,
+    2.4,
+    2.2,
+    2.1,
+    2.1,
+    1.95,
+    1.8,
+    1.8,
+    1.88,
+    2.8,
+    2.4,
+    2.3,
+    2.15,
+    2.05,
+    2.05,
+    2.05,
+    2.05,
+    2.0,
+    2.0,
+    2.0,
+    2.1,
+    2.1,
+    2.1,
+    2.05,
+    1.9,
+    1.9,
+    2.02,
+    2.9,
+    2.55,
+    2.4,
+    2.3,
+    2.15,
+    2.1,
+    2.05,
+    2.05,
+    2.0,
+    2.05,
+    2.1,
+    2.2,
+    2.2,
+    2.25,
+    2.2,
+    2.1,
+    2.1,
+    2.16,
+    3.0,
+    2.7,
+    2.5,
+    2.48,
+    2.47,
+    2.45,
+    2.43,
+    2.42,
+    2.4,
+    2.38,
+    2.37,
+    2.35,
+    2.33,
+    2.32,
+    2.3,
+    2.28,
+    2.27,
+    2.25,
+    2.2,
+    2.1,
+    2.05,
+    2.0,
+    2.0,
+    2.05,
+    2.1,
+    2.05,
+    2.2,
+    2.3,
+    2.3,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.4,
+    2.0,
+    2.3,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+    2.0,
+]
+
+
+"""
+atom37 vdw table. Orders match atom37 indices. Note: the vdw's for N and O are different from rdkit_van_der_waals in this file. 
+We used the rdkit values for consistency.
+Ref to https://github.com/aqlaboratory/openfold/blob/80c85b54e1a81d9a66df3f1b6c257ff97f10acd3/openfold/utils/loss.py#L1208C5-L1211C6
+rdkit_van_der_waals_radius = {
+    "C": 1.7,
+    "N": 1.6,
+    "O": 1.55,
+    "S": 1.8,
+}
+
+atom37_vdw = [
+        rdkit_van_der_waals_radius[name[0]]
+        for name in residue_constants.atom_types
+    ]
+
+"""
+atom37_vdw = [
+    1.55,
+    1.7,
+    1.7,
+    1.7,
+    1.52,
+    1.7,
+    1.7,
+    1.7,
+    1.52,
+    1.52,
+    1.8,
+    1.7,
+    1.7,
+    1.7,
+    1.55,
+    1.55,
+    1.52,
+    1.52,
+    1.8,
+    1.7,
+    1.7,
+    1.7,
+    1.7,
+    1.55,
+    1.55,
+    1.55,
+    1.52,
+    1.52,
+    1.7,
+    1.55,
+    1.55,
+    1.52,
+    1.7,
+    1.7,
+    1.7,
+    1.55,
+    1.52,
+]
+
+
+# Standard residues (AlphaFold3 SI Talbe 13)
+PRO_STD_RESIDUES = {
+    "ALA": 0,
+    "ARG": 1,
+    "ASN": 2,
+    "ASP": 3,
+    "CYS": 4,
+    "GLN": 5,
+    "GLU": 6,
+    "GLY": 7,
+    "HIS": 8,
+    "ILE": 9,
+    "LEU": 10,
+    "LYS": 11,
+    "MET": 12,
+    "PHE": 13,
+    "PRO": 14,
+    "SER": 15,
+    "THR": 16,
+    "TRP": 17,
+    "TYR": 18,
+    "VAL": 19,
+    "UNK": 20,
+}
+
+RNA_STD_RESIDUES = {
+    "A": 21,
+    "G": 22,
+    "C": 23,
+    "U": 24,
+    "N": 29,
+}
+
+DNA_STD_RESIDUES = {
+    "DA": 25,
+    "DG": 26,
+    "DC": 27,
+    "DT": 28,
+    "DN": 30,
+}
+
+STD_RESIDUES = PRO_STD_RESIDUES | RNA_STD_RESIDUES | DNA_STD_RESIDUES
+
+rna_order_with_x = {
+    "A": 0,
+    "G": 1,
+    "C": 2,
+    "U": 3,
+    "N": 4,
+}
+
+RNA_NT_TO_ID = {
+    "A": 0,
+    "G": 1,
+    "C": 2,
+    "U": 3,
+    "N": 4,
+    "R": 4,  # A or G
+    "Y": 4,  # C or U
+    "S": 4,  # G or C
+    "W": 4,  # A or U
+    "K": 4,  # G or U
+    "M": 4,  # A or C
+    "B": 4,  # C, G, U
+    "D": 4,  # A, G, U
+    "H": 4,  # A, C, U
+    "V": 4,  # A, C, G
+    "X": 4,
+    "I": 4,
+    "T": 4,
+    "-": 5,
+}
+
+# Partial inversion of RNA_NT_TO_ID
+RNA_ID_TO_NT = {
+    0: "A",
+    1: "G",
+    2: "C",
+    3: "U",
+    4: "N",  # Also R, Y, S, W, K, M, B, D, H
+    5: "-",
+}
+
+
+def get_all_elems():
+    """
+    Retrieve a list of all element symbols from the RDKit periodic table up to a specified cutoff.
+
+    Returns:
+        list: A list of element symbols strings.
+    """
+    elem_list = []
+    pt = GetPeriodicTable()
+    for i in range(1, 119):
+        elem_list.append(pt.GetElementSymbol(i).upper())
+
+    # 128 elements in the AlphaFold3 SI Table 5 ref_element
+    elem_list += [f"UNK_ELEM_{i}" for i in range(119, 129)]
+    return elem_list
+
+
+# len(STD_RESIDUES) + Atomic number up to 118 + 10 UNK_ELEM
+ELEMS = dict([(i, len(STD_RESIDUES) + idx) for idx, i in enumerate(get_all_elems())])
+
+RES_ATOMS_DICT = {
+    "ALA": {"N": 0, "CA": 1, "C": 2, "O": 3, "CB": 4, "OXT": 5},
+    "ARG": {
+        "N": 0,
+        "CA": 1,
+        "C": 2,
+        "O": 3,
+        "CB": 4,
+        "CG": 5,
+        "CD": 6,
+        "NE": 7,
+        "CZ": 8,
+        "NH1": 9,
+        "NH2": 10,
+        "OXT": 11,
+    },
+    "ASN": {
+        "N": 0,
+        "CA": 1,
+        "C": 2,
+        "O": 3,
+        "CB": 4,
+        "CG": 5,
+        "OD1": 6,
+        "ND2": 7,
+        "OXT": 8,
+    },
+    "ASP": {
+        "N": 0,
+        "CA": 1,
+        "C": 2,
+        "O": 3,
+        "CB": 4,
+        "CG": 5,
+        "OD1": 6,
+        "OD2": 7,
+        "OXT": 8,
+    },
+    "CYS": {"N": 0, "CA": 1, "C": 2, "O": 3, "CB": 4, "SG": 5, "OXT": 6},
+    "GLN": {
+        "N": 0,
+        "CA": 1,
+        "C": 2,
+        "O": 3,
+        "CB": 4,
+        "CG": 5,
+        "CD": 6,
+        "OE1": 7,
+        "NE2": 8,
+        "OXT": 9,
+    },
+    "GLU": {
+        "N": 0,
+        "CA": 1,
+        "C": 2,
+        "O": 3,
+        "CB": 4,
+        "CG": 5,
+        "CD": 6,
+        "OE1": 7,
+        "OE2": 8,
+        "OXT": 9,
+    },
+    "GLY": {"N": 0, "CA": 1, "C": 2, "O": 3, "OXT": 4},
+    "HIS": {
+        "N": 0,
+        "CA": 1,
+        "C": 2,
+        "O": 3,
+        "CB": 4,
+        "CG": 5,
+        "ND1": 6,
+        "CD2": 7,
+        "CE1": 8,
+        "NE2": 9,
+        "OXT": 10,
+    },
+    "ILE": {
+        "N": 0,
+        "CA": 1,
+        "C": 2,
+        "O": 3,
+        "CB": 4,
+        "CG1": 5,
+        "CG2": 6,
+        "CD1": 7,
+        "OXT": 8,
+    },
+    "LEU": {
+        "N": 0,
+        "CA": 1,
+        "C": 2,
+        "O": 3,
+        "CB": 4,
+        "CG": 5,
+        "CD1": 6,
+        "CD2": 7,
+        "OXT": 8,
+    },
+    "LYS": {
+        "N": 0,
+        "CA": 1,
+        "C": 2,
+        "O": 3,
+        "CB": 4,
+        "CG": 5,
+        "CD": 6,
+        "CE": 7,
+        "NZ": 8,
+        "OXT": 9,
+    },
+    "MET": {
+        "N": 0,
+        "CA": 1,
+        "C": 2,
+        "O": 3,
+        "CB": 4,
+        "CG": 5,
+        "SD": 6,
+        "CE": 7,
+        "OXT": 8,
+    },
+    "PHE": {
+        "N": 0,
+        "CA": 1,
+        "C": 2,
+        "O": 3,
+        "CB": 4,
+        "CG": 5,
+        "CD1": 6,
+        "CD2": 7,
+        "CE1": 8,
+        "CE2": 9,
+        "CZ": 10,
+        "OXT": 11,
+    },
+    "PRO": {"N": 0, "CA": 1, "C": 2, "O": 3, "CB": 4, "CG": 5, "CD": 6, "OXT": 7},
+    "SER": {"N": 0, "CA": 1, "C": 2, "O": 3, "CB": 4, "OG": 5, "OXT": 6},
+    "THR": {"N": 0, "CA": 1, "C": 2, "O": 3, "CB": 4, "OG1": 5, "CG2": 6, "OXT": 7},
+    "TRP": {
+        "N": 0,
+        "CA": 1,
+        "C": 2,
+        "O": 3,
+        "CB": 4,
+        "CG": 5,
+        "CD1": 6,
+        "CD2": 7,
+        "NE1": 8,
+        "CE2": 9,
+        "CE3": 10,
+        "CZ2": 11,
+        "CZ3": 12,
+        "CH2": 13,
+        "OXT": 14,
+    },
+    "TYR": {
+        "N": 0,
+        "CA": 1,
+        "C": 2,
+        "O": 3,
+        "CB": 4,
+        "CG": 5,
+        "CD1": 6,
+        "CD2": 7,
+        "CE1": 8,
+        "CE2": 9,
+        "CZ": 10,
+        "OH": 11,
+        "OXT": 12,
+    },
+    "VAL": {"N": 0, "CA": 1, "C": 2, "O": 3, "CB": 4, "CG1": 5, "CG2": 6, "OXT": 7},
+    "UNK": {"N": 0, "CA": 1, "C": 2, "O": 3, "CB": 4, "CG": 5, "OXT": 6},
+    "DA": {
+        "OP3": 0,
+        "P": 1,
+        "OP1": 2,
+        "OP2": 3,
+        "O5'": 4,
+        "C5'": 5,
+        "C4'": 6,
+        "O4'": 7,
+        "C3'": 8,
+        "O3'": 9,
+        "C2'": 10,
+        "C1'": 11,
+        "N9": 12,
+        "C8": 13,
+        "N7": 14,
+        "C5": 15,
+        "C6": 16,
+        "N6": 17,
+        "N1": 18,
+        "C2": 19,
+        "N3": 20,
+        "C4": 21,
+    },
+    "DC": {
+        "OP3": 0,
+        "P": 1,
+        "OP1": 2,
+        "OP2": 3,
+        "O5'": 4,
+        "C5'": 5,
+        "C4'": 6,
+        "O4'": 7,
+        "C3'": 8,
+        "O3'": 9,
+        "C2'": 10,
+        "C1'": 11,
+        "N1": 12,
+        "C2": 13,
+        "O2": 14,
+        "N3": 15,
+        "C4": 16,
+        "N4": 17,
+        "C5": 18,
+        "C6": 19,
+    },
+    "DG": {
+        "OP3": 0,
+        "P": 1,
+        "OP1": 2,
+        "OP2": 3,
+        "O5'": 4,
+        "C5'": 5,
+        "C4'": 6,
+        "O4'": 7,
+        "C3'": 8,
+        "O3'": 9,
+        "C2'": 10,
+        "C1'": 11,
+        "N9": 12,
+        "C8": 13,
+        "N7": 14,
+        "C5": 15,
+        "C6": 16,
+        "O6": 17,
+        "N1": 18,
+        "C2": 19,
+        "N2": 20,
+        "N3": 21,
+        "C4": 22,
+    },
+    "DT": {
+        "OP3": 0,
+        "P": 1,
+        "OP1": 2,
+        "OP2": 3,
+        "O5'": 4,
+        "C5'": 5,
+        "C4'": 6,
+        "O4'": 7,
+        "C3'": 8,
+        "O3'": 9,
+        "C2'": 10,
+        "C1'": 11,
+        "N1": 12,
+        "C2": 13,
+        "O2": 14,
+        "N3": 15,
+        "C4": 16,
+        "O4": 17,
+        "C5": 18,
+        "C7": 19,
+        "C6": 20,
+    },
+    "DN": {
+        "OP3": 0,
+        "P": 1,
+        "OP1": 2,
+        "OP2": 3,
+        "O5'": 4,
+        "C5'": 5,
+        "C4'": 6,
+        "O4'": 7,
+        "C3'": 8,
+        "O3'": 9,
+        "C2'": 10,
+        "C1'": 11,
+    },
+    "A": {
+        "OP3": 0,
+        "P": 1,
+        "OP1": 2,
+        "OP2": 3,
+        "O5'": 4,
+        "C5'": 5,
+        "C4'": 6,
+        "O4'": 7,
+        "C3'": 8,
+        "O3'": 9,
+        "C2'": 10,
+        "O2'": 11,
+        "C1'": 12,
+        "N9": 13,
+        "C8": 14,
+        "N7": 15,
+        "C5": 16,
+        "C6": 17,
+        "N6": 18,
+        "N1": 19,
+        "C2": 20,
+        "N3": 21,
+        "C4": 22,
+    },
+    "C": {
+        "OP3": 0,
+        "P": 1,
+        "OP1": 2,
+        "OP2": 3,
+        "O5'": 4,
+        "C5'": 5,
+        "C4'": 6,
+        "O4'": 7,
+        "C3'": 8,
+        "O3'": 9,
+        "C2'": 10,
+        "O2'": 11,
+        "C1'": 12,
+        "N1": 13,
+        "C2": 14,
+        "O2": 15,
+        "N3": 16,
+        "C4": 17,
+        "N4": 18,
+        "C5": 19,
+        "C6": 20,
+    },
+    "G": {
+        "OP3": 0,
+        "P": 1,
+        "OP1": 2,
+        "OP2": 3,
+        "O5'": 4,
+        "C5'": 5,
+        "C4'": 6,
+        "O4'": 7,
+        "C3'": 8,
+        "O3'": 9,
+        "C2'": 10,
+        "O2'": 11,
+        "C1'": 12,
+        "N9": 13,
+        "C8": 14,
+        "N7": 15,
+        "C5": 16,
+        "C6": 17,
+        "O6": 18,
+        "N1": 19,
+        "C2": 20,
+        "N2": 21,
+        "N3": 22,
+        "C4": 23,
+    },
+    "U": {
+        "OP3": 0,
+        "P": 1,
+        "OP1": 2,
+        "OP2": 3,
+        "O5'": 4,
+        "C5'": 5,
+        "C4'": 6,
+        "O4'": 7,
+        "C3'": 8,
+        "O3'": 9,
+        "C2'": 10,
+        "O2'": 11,
+        "C1'": 12,
+        "N1": 13,
+        "C2": 14,
+        "O2": 15,
+        "N3": 16,
+        "C4": 17,
+        "O4": 18,
+        "C5": 19,
+        "C6": 20,
+    },
+    "N": {
+        "OP3": 0,
+        "P": 1,
+        "OP1": 2,
+        "OP2": 3,
+        "O5'": 4,
+        "C5'": 5,
+        "C4'": 6,
+        "O4'": 7,
+        "C3'": 8,
+        "O3'": 9,
+        "C2'": 10,
+        "O2'": 11,
+        "C1'": 12,
+    },
+}
+
+CRYSTALLIZATION_AIDS = (
+    "SO4",
+    "GOL",
+    "EDO",
+    "PO4",
+    "ACT",
+    "PEG",
+    "DMS",
+    "TRS",
+    "PGE",
+    "PG4",
+    "FMT",
+    "EPE",
+    "MPD",
+    "MES",
+    "CD",
+    "IOD",
+)
+
+PROT_STD_RESIDUES_ONE_TO_THREE = {
+    "A": "ALA",
+    "R": "ARG",
+    "N": "ASN",
+    "D": "ASP",
+    "C": "CYS",
+    "Q": "GLN",
+    "E": "GLU",
+    "G": "GLY",
+    "H": "HIS",
+    "I": "ILE",
+    "L": "LEU",
+    "K": "LYS",
+    "M": "MET",
+    "F": "PHE",
+    "P": "PRO",
+    "S": "SER",
+    "T": "THR",
+    "W": "TRP",
+    "Y": "TYR",
+    "V": "VAL",
+    "X": "UNK",
+}
+
+CRYSTALLIZATION_AIDS = (
+    "SO4",
+    "GOL",
+    "EDO",
+    "PO4",
+    "ACT",
+    "PEG",
+    "DMS",
+    "TRS",
+    "PGE",
+    "PG4",
+    "FMT",
+    "EPE",
+    "MPD",
+    "MES",
+    "CD",
+    "IOD",
+)
+
+
+### Molecule Constants ###
+# AlphaFold3 SI Tabel 9
+LIGAND_EXCLUSION = {'144', 'SEP', 'PG0', 'BEN', 'NH4', 'PO4', '3SY', 'BO3', 'UNL', 'MES', 'FLC', 'PGR', '15P', 'MYR', 
+                    'POL', 'CIT', 'N', 'SPD', 'CAQ', 'IPA', 'EGL', 'SAR', 'NO3', 'STU', 'NHE', 'BU1', 'OXA', 'TPO', 
+                    'EEE', 'CAD', 'CBM', 'SPM', 'BCN', 'FMT', 'PEP', 'CM', 'BAM', 'ETF', 'IOD', 'MLI', 'MRD', 'SCN', 
+                    'GSH', 'CCN', 'SR', '1PE', 'ACY', 'STE', '9JE', 'SEO', 'IHS', 'MLA', 'TBU', 'DEP', 'STO', 'ACE', 
+                    'NA', 'TRS', 'CPT', 'OHE', 'TME', 'CL', 'BME', 'DN', '3HR', 'LDA', 'SO4', 'MPD', 'OLC', 'DOD', 
+                    'PE4', 'DOX', 'CMO', 'POP', 'PG4', '2F2', 'DMS', 'IMD', 'NH2', 'EOX', 'IPH', 'ACT', '7PE', 'UNX', 
+                    'GTT', '7N5', 'AZI', 'FCY', 'SIN', 'AAE', 'BTB', 'BTC', 'PGE', 'PE3', 'MB3', 'EDO', 'PLM', 'BCT', 
+                    'EOH', 'P6G', 'ACN', 'D10', 'EPE', 'DIO', 'CO3', 'PVO', 'TAR', 'URE', 'BDN', 'GOL', 'MSE', 'HED', 
+                    'CLR', 'MEG', 'IHP', 'PEO', 'CXS', 'MOH', 'GYF', 'PEG', 'FJO', 'FW5', 'OLA', '2JC', 'ABA', 'O4B', 
+                    'UPL', 'OME', 'C8E', 'OMB', 'UNK'}  # fmt: skip
+
+
+# AlphaFold3 SI Tabel 11
+GLYCANS = {'79J', 'LXZ', 'KO1', 'Z57', 'XDX', '8OQ', 'G0S', '14T', 'ZB3', '9PG', 'BGL', 'GYU', 'AHG', 'SUC', 'ADA', 'NGR', 
+           '4R1', 'EBQ', 'GAF', 'NAA', 'GYP', 'NDG', 'U2D', 'ISL', '9GP', 'KDM', 'HSX', 'NYT', 'V3P', '4NN', 'Z3L', 'ZCZ', 
+           'D5E', 'RIP', '3LR', 'GL1', 'K99', 'MQG', 'RAM', 'TUP', 'KDB', 'SIO', 'Z5L', 'GUL', 'GU2', 'EQV', '0V4', 'ABD', 
+           'RY7', '5II', 'GAL', '2GL', 'DR5', '4RS', 'MNA', 'DFX', '0WK', 'HTG', 'RP5', 'A1Q', 'B1N', 'GUF', 'NGA', 'TMR', 
+           'C3X', '9S7', 'XLS', 'MAG', 'RST', 'SDY', 'HSH', 'GN4', 'GTR', 'KBA', '6YR', 'CKB', 'DDA', 'RHC', 'OPM', 'SIZ', 
+           'GE3', 'TS8', 'Z6W', 'BZD', '56N', 'RIB', 'GL6', '8GA', 'GLC', 'TAG', 'QIF', 'TA6', 'UAP', 'TVY', 'GC1', 'ARW', 
+           'GU3', 'LBS', 'KDD', 'NPF', '49V', 'CDR', '12E', '6LA', '2M4', 'SA0', 'HNW', 'AOG', 'G8Z', '8LR', 'GPH', 'XXX', 
+           'GPM', 'MTT', 'JFZ', 'LOG', 'LMO', '5TH', '8I4', 'GUP', '5KQ', 'R2G', 'SSG', 'P8E', 'RF5', 'TOC', 'CT3', '2FL', 
+           '73E', 'VJ4', '0H0', 'ERI', 'AMG', '3GR', 'BO1', 'AFD', 'FYJ', 'IDF', 'NBY', 'DOM', 'MBF', 'QDK', 'TDG', '6GR', 
+           'MAV', '1X4', 'AF1', 'EEN', 'ZB1', 'Z2D', '445', 'KHP', 'LKS', '10M', '491', 'OTU', 'BNG', 'AY9', 'KDR', 'LEC', 
+           'FFX', 'AFO', 'SGA', '16F', 'X34', 'SEJ', 'LAG', 'DNO', '6PZ', 'LBT', 'OSU', '3BU', '6K3', 'SFU', 'YDR', 'SIA', 
+           '2WP', '25E', 'SMD', 'NBG', 'DO8', 'LGU', 'S81', 'Z3Q', 'TWA', 'G6S', '2WS', 'G6D', '18D', 'IN1', '64K', 'QPS', 
+           'PTQ', 'FX1', 'RVM', '8GP', 'NLC', 'FCA', 'JLT', 'AH8', 'MFB', 'RRJ', 'SOL', 'TM5', 'TCB', 'GU5', 'TWY', 'ETT', 
+           '8YV', 'SG6', 'XMM', '17T', 'BGC', 'MLR', 'Z6J', '9SJ', 'R2B', 'BBK', 'BEM', 'LTG', '0NZ', 'DKZ', '3YW', 'ASO', 
+           'FUB', '4GL', 'GLT', 'KTU', 'CBF', 'ARI', 'FIF', 'LCN', 'SG5', 'AC1', 'SUP', 'ZMR', 'GU8', 'YYH', 'XKJ', 'JSV', 
+           'DQR', 'M6D', 'FBP', 'AFP', 'F6P', 'GLG', 'JZR', 'DLG', '9C1', 'AAL', 'RRY', 'ZDC', 'TVS', 'B1H', 'XXM', '8B7', 
+           'RCD', 'UBO', '7D1', 'XYT', 'WZ2', 'X1X', 'LRH', 'GDA', 'GLS', 'G6P', '49A', 'NM9', 'DVC', 'MG5', 'SCR', 'MAF', 
+           '149', 'LFC', 'FMF', 'FRU', 'BG8', 'GP4', 'GU1', 'XXR', '4V5', 'MA2', '293', '6KH', 'GAA', 'MXY', 'QV4', 'MSX', 
+           'GU6', '95Z', 'Z9M', 'ARB', 'FNY', 'H1S', 'VG1', 'VTB', 'Z61', 'H6Z', '7K3', 'XGP', 'SOE', 'Z6H', 'GYV', 'MLB', 
+           'DR3', 'ISD', 'BGN', 'AXR', 'SCG', 'Z8T', '6UD', 'KDF', 'GLA', 'BNX', '3MG', 'BDP', 'KFN', 'Z9N', '2FG', 'PNA', 
+           'MUB', 'ZDO', '9WJ', 'GMB', 'LER', 'TVM', '89Y', 'Z4Y', '9SM', 'NGS', 'LAO', 'KGM', 'FKD', 'M1F', 'BG6', 'LAK', 
+           '8GG', '6LS', 'GBH', 'CEG', 'BDR', 'RR7', 'SOG', 'AZC', 'AMU', 'BS7', '3S6', 'MXZ', 'Z3U', 'MDP', '6MJ', 'M3M', 
+           'DT6', 'PRP', 'TUG', 'Z16', 'IDG', 'TUR', 'Z4S', 'GM0', 'A0K', 'GCN', 'ZEE', 'UEA', 'HVC', 'CE5', 'FUD', 'NAG', 
+           'GPO', '22S', '3J4', 'DKX', 'FMO', 'BXP', 'NSQ', '50A', 'MAT', '5TM', '0MK', '9OK', 'RI2', 'SZZ', 'IDS', 'JRV', 
+           '18O', '1CF', 'RAO', 'P53', '27C', 'Z3K', 'Z4U', 'Z4R', 'B4G', '6KU', 'HBZ', '07E', 'KBG', '98U', 'GFP', 'LFR', 
+           'G2F', '51N', 'FUF', 'LGC', '6S2', 'E3M', 'G7P', 'OTN', 'MVP', 'TVD', 'BBV', 'E5G', 'MJJ', 'IEM', 'FSA', 'CE8', 
+           'U1Y', '1FT', 'HTM', 'DLD', 'YO5', 'W9T', '5N6', 'PNG', 'NGY', 'DSR', 'M3N', 'GP0', '3MK', 'RBL', 'GTM', 'FSW', 
+           '4JA', 'YYM', 'Z4V', '3HD', '2DR', 'AIG', 'GL0', 'BND', 'TM6', 'TUJ', 'DAN', '5GF', '4QY', '3FM', '6KW', 'LNV', 
+           '289', 'BFN', 'PSG', 'U9J', 'YX0', 'EQP', 'YZ0', '0BD', 'GAT', 'LVZ', 'FUL', '22O', 'DLF', 'MA1', 'BXY', 'C3G', 
+           'CR6', 'GNS', 'EEQ', 'IDY', 'FFC', 'NBX', 'SID', '9KJ', '9WZ', 'M2F', 'FK9', 'SSH', 'TWG', 'RVG', 'BXX', '24S', 
+           'FSM', 'GDL', 'F1X', '3R3', 'ALX', '4GC', 'GL2', 'DL6', 'GS1', 'AMV', 'TVV', '2DG', 'RGG', 'TFU', '1GN', 'N3U', 
+           'SOR', 'MA3', 'GCT', 'H1M', '16G', '49T', 'BCD', 'GPW', 'DAG', 'GN1', 'IAB', 'EBG', 'GPU', '38J', '1LL', 'DR2', 
+           'YIO', 'YKR', '15L', 'WZ1', 'BTG', 'GPK', '5MM', '26O', 'AMN', 'DEL', 'CTT', '83Y', 'GMT', 'CTO', 'MBE', '1SD', 
+           '6ZC', 'AXP', 'OX2', '5LT', 'MRH', '6BG', 'MDA', 'SG7', '045', 'GC4', 'LDY', 'YYJ', '07Y', 'KDO', 'GP1', 'BHG', 
+           'DPC', 'BM3', 'GU4', 'ISX', 'P6P', 'GPQ', '1S4', '475', 'GYE', 'CBK', 'CEZ', 'SGD', 'TH1', 'V3M', 'RWI', 'RM4', 
+           'U9M', 'U2A', '7GP', '05L', 'Z0F', 'GLO', 'LXB', 'TGA', '61J', 'GYG', 'GCU', 'GE1', 'F1P', 'GLP', 'CTR', 'AHR', 
+           '3LJ', 'FUY', 'JVA', 'LAT', 'NHF', 'RB5', 'XYS', 'LXC', 'SLT', 'U8V', 'GMH', 'EAG', 'GCV', 'B6D', 'IDU', 'KG1', 
+           'BDF', 'NTP', 'IXD', 'RZM', 'PH5', 'SHB', 'X6Y', 'B16', 'Z9E', '9VP', 'LAH', 'H2P', 'TNX', '5GO', 'TGY', '5SP', 
+           'RHA', '5KV', 'GTK', 'SUS', 'DAF', '6DM', '8S0', '6MN', 'G4D', 'NT1', 'XYF', '5TJ', '46Z', '9AM', '7K2', '6C2', 
+           'WIA', '9YW', 'G4S', '46D', 'Z9W', 'ABL', 'XYZ', 'G3I', 'S7P', 'GC9', 'GQ1', 'GCO', 'M6P', 'WUN', 'U63', 'ZB2', 
+           'GLD', 'T6P', 'ZEL', '145', '2OS', 'BGP', 'C4W', 'IDX', 'MUR', '3SA', 'CR1', '34V', 'DEG', 'F55', 'L0W', 'TYV', 
+           'CJB', 'TW7', 'DDL', '5L3', 'NGC', 'ACX', 'JVS', 'NA1', 'GAD', '7JZ', 'BOG', 'GCW', 'BDG', 'Z15', '0LP', 'ABE', 
+           'RG1', 'DGU', 'N1L', 'NGE', 'PUF', 'B9D', '49S', '5LS', '4N2', '23V', 'RUU', 'B0D', 'RTV', '42D', 'M1P', 'MAB', 
+           '2F8', 'TQY', 'L6S', 'V71', '2H5', 'M8C', 'NTF', 'H3S', 'LM2', 'MN0', 'JV4', '9WN', 'U9G', 'LZ0', 'X0X', 'TXB', 
+           '3DO', 'SG4', 'IDR', '8B9', 'TOA', 'CRA', 'HSJ', '0HX', 'FDQ', 'FUC', 'ABF', 'ALL', 'G20', 'GL9', 'IDC', 'LOX', 
+           'Z2T', 'RP6', '2HA', 'AHM', 'DRI', 'EMZ', 'GMZ', 'HD4', 'GU9', 'L1L', 'PNW', 'PPC', 'MMA', 'CE6', '5KS', 'MGC', 
+           'XLF', 'KO2', 'RUG', 'HSG', 'SF6', 'IPT', 'TF0', 'GCD', 'B8D', '0YT', 'GRX', 'HNV', 'FVQ', 'RV7', 'J5B', 'ERE', 
+           'DFR', 'LVO', '4GP', 'BQY', 'BMA', 'KDA', 'ARA', 'KDN', 'ZCD', 'A5C', 'T68', 'XYL', 'YJM', 'NM6', '9CD', 'CNP', 
+           'U97', '9T1', 'C5X', 'R1X', 'BW3', '09X', 'GNX', 'PDX', 'Z9D', 'DGO', 'SLM', '66O', '4CQ', 'X6X', 'RTG', 'HSY', 
+           '20X', 'GCB', 'EUS', 'FNG', '1S3', 'EGA', 'MQT', 'NXD', '5TK', 'Z9K', 'TGR', '9MR', 'M7P', 'PA1', 'MFU', 'UBH', 
+           'CBI', 'TMX', 'T6D', '32O', 'JHM', 'X2F', '4SG', '3DY', 'SGC', 'PAV', 'A2G', 'LAI', '0UB', 'BXF', '3J3', '9T7', 
+           'T6T', 'OI7', 'ANA', '9QG', 'K5B', 'KOT', 'GIV', 'MGL', 'GL4', '9SP', 'FDP', 'GPV', '6KS', 'GXV', 'NFG', 'M7B', 
+           'DG0', '57S', 'GUZ', '96O', 'GCS', 'MAN', 'YYB', 'TWD', 'MGS', 'TT7', 'PNJ', 'GXL', 'TRE', 'G28', '7NU', '8PK', 
+           'LKA', 'ASG', 'SF9', '2M8', '1GL', '5KT', 'BWG', 'OTG', 'VJ1', 'ZGE', '40J', 'Z4K', 'F58', 'KME', 'SR1', 'ZB0', 
+           'UDC', '6KL', '6LW', '8EX', 'D1M', '62I', 'H6Q', 'RAE', 'SHD', 'AGL', 'DGS', 'VKN', 'TWJ', 'MRP', 'TGK', 'HSQ', 
+           'ASC', 'F8X', '6GB', '0XY', 'BMX', 'SN5', 'Z5J', 'ZD0', 'DJB', 'KDE', 'TEU', 'M55', 'YYQ', 'DK4', 'D6G', 'KD5', 
+           'AH2', '4AM', 'RER', '16O', 'C3B', 'G1P', 'NG6', 'MBG', 'Z4W', 'MAW', '147', 'NGK', 'CKP', 'DJE', 'GL5', 'TVG', 
+           'PKM', 'L6T', 'XS2', '2GS', 'BTU', 'G16', 'PSV', 'AQA', 'MCU', 'SNG', '2M5', 'SLB', 'BM7', 'H53', 'MA8', 'OAK', 
+           'GRF', 'BGS', 'NTO', 'YYK', 'EPG', '6GP', 'MYG', 'FCT', 'Z9H', 'GL7', '48Z', '4UZ', '7CV', 'DYM', 'GLF', 'GU0', 
+           'CGF', 'STZ', '44S', 'LB2', 'TU4', 'Z8H', '5QP', 'A6P', 'XYP', 'B2G', 'U9A', 'SWE', 'NGZ', 'SGN', 'B7G', 'MAL', 
+           '291', 'FSI', 'R1P', 'ACR', 'PZU', 'X2Y', 'Z9L', 'STW', 'U9D', 'X1P', 'TTV', 'GS9', 'QKH', 'SHG', 'N9S', 'NNG', 
+           'RP3', 'G3F', 'YX1', 'EMP', 'XIL', '08U', 'WOO', 'FCB', 'NG1', 'TRV', '20S', 'RAF', 'GZL', 'C4B', '9SG', 'GAC'}  # fmt: skip
+
+
+# AlphaFold3 SI Tabel 12
+IONS = {'XGP', 'Z4K', '147', 'B0D', 'G6D', 'RIB', 'AXR', 'SOG', 'NTF', 'SHB', 'RG1', 'G6S', 'GPO', 'BTG', '5LT', 'CEG', 'KG1', 
+        'TDG', 'TRV', 'WZ1', 'ARI', 'HVC', 'TM6', '2DG', '6K3', 'ARA', 'ASO', '6GB', 'NBX', 'OTG', 'ASG', 'YO5', 'MRH', 'GYP', 
+        'C4B', 'GDA', 'MUB', 'XXM', 'M6D', 'OPM', 'GYV', 'DKX', '9SG', 'LOG', 'TRE', 'DLG', 'FNG', 'BBK', 'ABF', 'AQA', '3BU', 
+        'SIA', 'CGF', 'LBS', 'QV4', 'NAA', 'GLC', 'BHG', 'MSX', 'ZB1', 'YYJ', 'TUP', '6ZC', '0WK', 'RY7', 'L1L', 'RRY', 'M55', 
+        '9PG', '5GF', '4V5', 'FMO', 'SWE', 'KDA', 'P8E', '14T', 'DL6', 'CKB', '2M8', 'AHR', 'NGY', '8GP', 'YYQ', 'LVO', 'CRA', 
+        'GU9', 'PPC', '6GP', 'CR1', 'G20', 'T6P', 'EMZ', 'RHA', 'GC4', 'AH2', 'FCT', 'QDK', 'DDA', 'RTV', '8S0', 'TVG', 'HNV', 
+        'FYJ', 'BDP', 'GYE', 'TS8', 'CEZ', '42D', 'NHF', 'NT1', 'WOO', '0LP', 'HBZ', 'SG5', 'NM9', 'CJB', 'DLF', 'EUS', 'IDY', 
+        '2GL', 'NTO', 'PNG', 'B2G', '7NU', '4UZ', '5LS', '475', 'DJE', 'Z9E', 'GC9', 'QPS', '0NZ', 'F1X', 'G8Z', '2F8', '3SA', 
+        '46D', '3DO', '6PZ', 'OI7', 'SLM', 'A0K', '9SJ', 'TWD', 'AOG', 'TW7', '2WS', 'GU5', 'NSQ', 'FUD', 'GLO', 'TNX', 'XYP', 
+        'JFZ', '2HA', 'G16', 'V3M', 'RTG', 'C4W', 'R2G', 'HD4', '66O', 'MFB', 'GXL', '8YV', 'NFG', 'FFC', '3YW', 'XYZ', '445', 
+        'IXD', 'GUL', 'CTO', '05L', 'Z3L', 'RBL', 'DR5', 'S81', 'CTR', '15L', 'GLP', '7K3', 'LDY', 'Z4S', 'H2P', '4GP', '5SP', 
+        '18O', 'DGS', 'OX2', 'DFR', 'GN1', 'BGL', 'Z9K', 'GU4', '0V4', 'MA2', 'U2A', 'MXZ', 'PA1', '9YW', 'GS9', '3MK', 'AAL', 
+        'NBY', 'XXX', 'ISD', 'SEJ', 'DKZ', 'GL9', '23V', 'AMN', 'AHG', '25E', 'DJB', '7K2', 'GDL', '08U', 'TT7', 'DRI', 'HSY', 
+        'LB2', 'GCV', 'X1P', 'MN0', 'BW3', 'U9J', 'FFX', 'Z3U', 'LOX', 'MQG', 'HSG', 'GCO', 'GPQ', 'IDR', '2GS', 'AGL', 'RUU', 
+        '5KV', 'R1X', 'LZ0', 'P6P', '0H0', '32O', 'LAG', 'YYK', '07E', '6KS', 'KOT', '17T', 'TQY', 'RM4', 'LNV', 'BGN', 'STW', 
+        'NGC', 'GLF', '2WP', 'GL5', 'KHP', '9SP', 'LAI', 'KDB', 'JVA', 'OTN', 'NA1', 'RR7', 'B16', 'PSV', 'NXD', 'C5X', 'G1P', 
+        'RRJ', 'DAF', '5N6', 'SG4', 'KDN', '95Z', 'FDQ', 'K5B', 'MDP', 'GTK', '4SG', 'ALL', 'LXC', 'TM5', 'NGA', '98U', '7JZ', 
+        'A6P', 'UBH', '293', '9T7', 'PUF', '5TM', 'VTB', 'BGP', 'JV4', 'SN5', 'FSA', 'LAK', 'G7P', 'BGC', 'ZCD', '7GP', '79J', 
+        'FKD', 'TWY', 'ZGE', 'OAK', 'FMF', 'ZCZ', 'GL2', 'MAV', 'ZB3', 'SA0', '3LR', 'SHD', 'XLS', 'DOM', 'Z4R', 'GP0', '5KS', 
+        'KO1', 'FCB', 'LFC', 'AC1', 'NPF', 'X6Y', 'IDF', '20X', '6KL', '6LW', '49S', '0YT', 'BDR', 'GBH', 'LAH', 'KO2', '40J', 
+        '4CQ', 'D5E', 'T6D', 'SUP', 'TGR', 'Z57', 'SDY', '4NN', 'MNA', 'Z5J', '20S', 'CT3', 'DQR', '5MM', '83Y', '49T', 'BDG', 
+        'GL1', 'TOC', '6UD', 'GM0', 'GU3', '18D', 'ADA', '4AM', '9WZ', 'HSX', 'QIF', '6DM', '4RS', 'KDF', 'GAL', 'ISL', 'Z9H', 
+        'GC1', 'Z9W', 'NBG', 'MAL', 'BGS', 'W9T', 'U9A', '62I', 'M6P', 'AFO', 'C3G', 'M2F', 'RUG', 'ARW', 'LEC', 'B8D', '61J', 
+        'GL7', 'F58', 'GP4', 'GFP', 'TVY', 'ZB0', 'FSM', 'BDF', 'TCB', 'ZEL', 'IDG', '9CD', 'PNA', 'SF9', 'DSR', 'MG5', 'E5G', 
+        'PNW', 'TH1', '1S4', 'PTQ', 'KDD', 'SSH', 'F55', 'V71', 'VG1', '9T1', '145', 'GU2', '2M5', '8I4', 'H1S', 'YYB', '1LL', 
+        '4N2', 'BG6', 'R2B', 'MAT', 'LMO', 'OSU', 'PSG', 'RCD', '26O', 'DGO', 'SID', 'FUB', '2FL', '3HD', '34V', 'FK9', 'AMG', 
+        'G4D', 'EPG', 'BWG', 'KTU', '491', 'JHM', 'NG1', 'DLD', 'MCU', 'MQT', 'EQV', 'CBF', '4GL', 'GS1', 'DEG', 'DDL', 'SGA', 
+        '16O', 'X6X', 'H53', 'FUC', 'IDS', 'LTG', 'TMX', '9SM', '045', 'DAN', 'FRU', 'Z5L', 'AHM', 'BNG', 'AFP', 'MAF', 'UBO', 
+        'BOG', '2H5', 'NG6', '10M', 'NM6', 'RST', 'C3X', '9S7', '49A', 'AXP', 'PH5', 'ISX', 'B6D', 'GU6', 'TWG', '6GR', 'H3S', 
+        'Z61', '9WJ', 'BMA', 'U63', 'LKA', 'GRF', 'VJ1', 'RZM', 'MA3', '0XY', 'GAF', 'GAD', '1FT', '149', 'DPC', 'LFR', 'B9D', 
+        'CE5', 'SOR', '6KU', 'SFU', 'BEM', 'YKR', '38J', 'N3U', 'ARB', 'CBK', 'SGD', '8EX', 'WZ2', '8B9', 'TF0', 'X2Y', 'PKM', 
+        'RF5', 'D1M', 'AF1', 'DR2', 'EQP', 'AMV', 'PRP', 'VJ4', 'BCD', '1GN', 'SMD', '9QG', 'GCW', 'A5C', 'M3N', 'SZZ', 'B1H', 
+        'GPH', 'NDG', '5KT', 'TYV', 'KDM', 'A2G', 'CE6', 'H1M', 'JVS', 'ABL', 'LAO', 'P53', 'GCN', 'QKH', 'U2D', 'YYH', '6S2', 
+        'L0W', 'DEL', 'G2F', 'LER', 'MGC', 'RI2', '5KQ', 'DT6', 'U97', 'BG8', '1X4', 'GYG', 'U9D', 'SG7', '8B7', 'FCA', 'RWI', 
+        '8GG', 'TAG', 'ERE', '46Z', '5QP', 'UDC', '51N', 'SGN', 'NLC', '8LR', 'L6T', 'WIA', 'TMR', 'IDC', 'GLT', 'FDP', 'GCT', 
+        'FSW', 'XYS', 'GAA', 'N9S', 'DO8', 'UAP', 'TUG', 'F1P', '2FG', '12E', '56N', 'IAB', 'LAT', 'X1X', 'MBE', 'GP1', 'X34', 
+        '6MJ', '6KH', 'G3F', '3DY', 'XYF', 'GE1', 'MAB', 'Z9L', '289', 'GIV', 'F8X', '9WN', 'KDO', 'GLA', 'SIZ', 'G0S', 'EGA', 
+        'MJJ', 'B7G', 'BND', 'JRV', '1S3', 'DAG', 'GL0', 'GPV', 'HTM', '3R3', 'SHG', 'DR3', 'TTV', 'DK4', '22S', 'IDU', 'XIL', 
+        'RER', '6BG', 'GXV', 'BTU', 'GE3', 'H6Z', 'ZD0', 'SF6', 'VKN', 'GYU', '16F', 'K99', 'KGM', 'FX1', 'NGS', 'RVG', 'YX1', 
+        '4GC', 'EEQ', 'XDX', 'MVP', 'PNJ', 'BS7', 'M7B', '0BD', 'AIG', 'TVV', 'BXY', 'T68', 'SIO', '8OQ', '2OS', 'S7P', 'GNX', 
+        'TUR', 'YX0', 'DVC', 'NGK', 'M8C', 'RHC', 'GPM', 'LKS', '64K', 'GMT', 'JLT', 'XS2', 'LBT', 'TVM', '6MN', 'DYM', 'E3M', 
+        'NGR', 'G6P', 'RAO', 'SCR', 'YJM', 'MRP', 'YIO', 'ACR', '291', '3GR', 'M1F', 'L6S', 'XLF', 'GU1', 'LVZ', 'DNO', '22O', 
+        'SOL', 'GPW', 'KD5', 'GCU', 'ERI', 'YZ0', 'TXB', 'ABD', 'YYM', 'BFN', 'G4S', 'GAC', 'PAV', 'MMA', 'RV7', 'MBG', '16G', 
+        'MA8', 'GU8', '4JA', 'NTP', 'FNY', '07Y', '1CF', 'KDE', 'Z16', 'CBI', '50A', 'Z4W', 'U9G', 'D6G', 'JSV', 'YDR', 'DGU', 
+        'Z15', 'G3I', 'XKJ', 'IEM', 'CDR', 'GLG', '0HX', 'TA6', '57S', 'LGU', '27C', 'BO1', 'EEN', 'HSJ', 'GLD', 'RP3', 'FSI', 
+        'LRH', '8PK', 'GTR', 'B1N', 'XXR', 'TFU', 'RAF', 'ETT', 'AY9', '3FM', 'G28', '2DR', 'FUL', 'CE8', 'GQ1', 'TGA', '6C2', 
+        'NGZ', '6LS', 'SOE', 'BQY', 'HSH', 'XYL', '5TH', 'A1Q', 'HTG', 'Z3K', '3MG', 'GMH', 'M1P', 'ASC', '73E', 'Z8T', 'STZ', 
+        'RAE', 'GL6', '7CV', 'GPU', '5L3', '7D1', 'CKP', 'BXP', 'M7P', 'RVM', 'TWA', '4R1', 'N1L', 'X2F', 'TVD', '3J3', 'TOA', 
+        'B4G', 'WUN', '0MK', '6YR', 'H6Q', 'CNP', 'TEU', 'MBF', '44S', 'Z9N', 'BM7', 'NGE', 'U9M', 'GMB', 'MTT', '9GP', 'DG0', 
+        'RP5', 'KBA', 'ALX', 'FVQ', 'TGY', 'EBG', 'BXF', '9C1', 'BBV', 'AFD', '4QY', 'GCD', 'FBP', '96O', 'GNS', 'OTU', 'ACX', 
+        'RP6', 'UEA', 'SGC', 'Z4V', 'RAM', 'AZC', 'J5B', '1GL', 'TGK', 'HSQ', 'LM2', 'MYG', 'PDX', 'Z6W', 'ZDC', '09X', 'IDX', 
+        '9MR', 'MFU', 'CR6', 'Z8H', 'SUS', 'PZU', '89Y', '5TK', 'KME', 'U1Y', 'Z4U', 'LCN', 'GPK', 'MUR', '5TJ', 'NYT', '24S', 
+        'SR1', '0UB', '48Z', 'MGL', 'Z6J', 'BMX', 'C3B', 'TVS', 'SLB', 'IPT', 'MLB', 'SLT', 'Z9D', 'GRX', 'AH8', 'F6P', 'BNX', 
+        'JZR', 'LXB', 'M3M', 'XYT', 'MA1', 'GTM', 'SCG', 'Z3Q', 'KFN', 'LGC', 'ZB2', 'FIF', 'GLS', 'SSG', 'Z4Y', 'T6T', 'GCS', 
+        'GZL', 'U8V', 'V3P', 'ABE', 'MGS', '6KW', '8GA', 'BZD', 'FUF', 'GMZ', 'FUY', 'HNW', 'LXZ', 'IN1', 'SNG', 'GAT', 'Z9M', 
+        'BM3', 'ZDO', '9AM', '3LJ', 'X0X', 'MAN', '5GO', 'AMU', 'GUF', 'XMM', 'EAG', 'SUC', 'BXX', 'Z0F', '9OK', 'CTT', 'MLR', 
+        '49V', 'ZMR', 'TWJ', 'MAW', '5II', 'ZEE', 'KBG', 'EMP', 'GUZ', 'TUJ', 'RB5', 'GCB', '9KJ', 'MAG', 'Z2D', '6LA', '2M4', 
+        'GN4', 'MDA', 'TU4', 'Z2T', 'GL4', 'EBQ', 'NNG', '1SD', 'ANA', 'MXY', 'Z6H', 'GU0', 'GUP', 'SG6', 'NAG', '9VP', 'RIP', 
+        '3S6', 'KDR', 'R1P', '3J4', 'DFX', 'RGG'}  # fmt: skip
+
+
+# AlphaFold3 SI Tabel 15
+PBV2_COMMON_NATURAL_LIGANDS = {'UPG', 'CDP', 'DSG', 'APC', 'GSP', 'FAD', 'IPE', 'NAI', '2BA', 'PGA', 'A3P', 'PRP', 'NAD', 'PLG', 
+                               'SFG', 'MFU', 'APR', 'GTP', 'PLP', 'UDP', 'SAH', 'ACP', 'GSH', 'CTP', 'AKG', 'F15', '5AD', 'BCN', 
+                               'BDP', 'H4B', 'PHO', 'FMN', 'MTA', 'NGA', 'OGA', 'SLB', 'SIN', 'C5P', 'TPP', 'BGC', 'NCA', 'UD1', 
+                               'ANP', 'DGL', 'FDA', 'URI', 'ADP', 'MTE', 'PJ8', 'ATP'}  # fmt: skip

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/data/data_pipeline.py

@@ -0,0 +1,310 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+from collections import defaultdict
+from pathlib import Path
+from typing import Any, Optional, Union
+
+import biotite.structure.io as strucio
+import numpy as np
+import pandas as pd
+import torch
+from biotite.structure import AtomArray
+
+from protenix.data.msa_featurizer import MSAFeaturizer
+from protenix.data.tokenizer import TokenArray
+from protenix.utils.cropping import CropData
+from protenix.utils.file_io import load_gzip_pickle
+
+torch.multiprocessing.set_sharing_strategy("file_system")
+
+
+class DataPipeline(object):
+
+    @staticmethod
+    def get_label_entity_id_to_asym_id_int(atom_array: AtomArray) -> dict[str, int]:
+        """
+        Get a dictionary that associates each label_entity_id with its corresponding asym_id_int.
+
+        Args:
+            atom_array (AtomArray): AtomArray object
+
+        Returns:
+            dict[str, int]: label_entity_id to its asym_id_int
+        """
+        entity_to_asym_id = defaultdict(set)
+        for atom in atom_array:
+            entity_id = atom.label_entity_id
+            entity_to_asym_id[entity_id].add(atom.asym_id_int)
+        return entity_to_asym_id
+
+    @staticmethod
+    def get_data_bioassembly(
+        bioassembly_dict_fpath: Union[str, Path],
+    ) -> dict[str, Any]:
+        """
+        Get the bioassembly dict.
+
+        Args:
+            bioassembly_dict_fpath (Union[str, Path]): The path to the bioassembly dictionary file.
+
+        Returns:
+            dict[str, Any]: The bioassembly dict with sequence, atom_array and token_array.
+
+        Raises:
+            AssertionError: If the bioassembly dictionary file does not exist.
+        """
+        assert os.path.exists(
+            bioassembly_dict_fpath
+        ), f"File not exists {bioassembly_dict_fpath}"
+        bioassembly_dict = load_gzip_pickle(bioassembly_dict_fpath)
+
+        return bioassembly_dict
+
+    @staticmethod
+    def _map_ref_chain(
+        one_sample: pd.Series, bioassembly_dict: dict[str, Any]
+    ) -> list[int]:
+        """
+        Map the chain or interface chain_x_id to the reference chain asym_id.
+
+        Args:
+            one_sample (pd.Series): A dict of one chain or interface from indices list.
+            bioassembly_dict (dict[str, Any]): The bioassembly dict with sequence, atom_array and token_array.
+
+        Returns:
+            list[int]: A list of asym_id_lnt of the chosen chain or interface, length 1 or 2.
+        """
+        atom_array = bioassembly_dict["atom_array"]
+        ref_chain_indices = []
+        for chain_id_field in ["chain_1_id", "chain_2_id"]:
+            chain_id = one_sample[chain_id_field]
+            assert np.isin(
+                chain_id, np.unique(atom_array.chain_id)
+            ), f"PDB {bioassembly_dict['pdb_id']} {chain_id_field}:{chain_id} not in atom_array"
+            chain_asym_id = atom_array[atom_array.chain_id == chain_id].asym_id_int[0]
+            ref_chain_indices.append(chain_asym_id)
+            if one_sample["type"] == "chain":
+                break
+        return ref_chain_indices
+
+    @staticmethod
+    def get_msa_raw_features(
+        bioassembly_dict: dict[str, Any],
+        selected_indices: np.ndarray,
+        msa_featurizer: Optional[MSAFeaturizer],
+    ) -> Optional[dict[str, np.ndarray]]:
+        """
+        Get tokenized MSA features of the bioassembly
+
+        Args:
+            bioassembly_dict (Mapping[str, Any]): The bioassembly dict with sequence, atom_array and token_array.
+            selected_indices (torch.Tensor): Cropped token indices.
+            msa_featurizer (MSAFeaturizer): MSAFeaturizer instance.
+
+        Returns:
+            Optional[dict[str, np.ndarray]]: The tokenized MSA features of the bioassembly.
+        """
+        if msa_featurizer is None:
+            return None
+
+        entity_to_asym_id_int = dict(
+            DataPipeline.get_label_entity_id_to_asym_id_int(
+                bioassembly_dict["atom_array"]
+            )
+        )
+
+        msa_feats = msa_featurizer(
+            bioassembly_dict=bioassembly_dict,
+            selected_indices=selected_indices,
+            entity_to_asym_id_int=entity_to_asym_id_int,
+        )
+
+        return msa_feats
+
+    @staticmethod
+    def get_template_raw_features(
+        bioassembly_dict: dict[str, Any],
+        selected_indices: np.ndarray,
+        template_featurizer: None,
+    ) -> Optional[dict[str, np.ndarray]]:
+        """
+        Get tokenized template features of the bioassembly.
+
+        Args:
+            bioassembly_dict (dict[str, Any]): The bioassembly dict with sequence, atom_array and token_array.
+            selected_indices (np.ndarray): Cropped token indices.
+            template_featurizer (None): Placeholder for the template featurizer.
+
+        Returns:
+            Optional[dict[str, np.ndarray]]: The tokenized template features of the bioassembly,
+                or None if the template featurizer is not provided.
+        """
+        if template_featurizer is None:
+            return None
+
+        entity_to_asym_id_int = dict(
+            DataPipeline.get_label_entity_id_to_asym_id_int(
+                bioassembly_dict["atom_array"]
+            )
+        )
+
+        template_feats = template_featurizer(
+            bioassembly_dict=bioassembly_dict,
+            selected_indices=selected_indices,
+            entity_to_asym_id_int=entity_to_asym_id_int,
+        )
+        return template_feats
+
+    @staticmethod
+    def crop(
+        one_sample: pd.Series,
+        bioassembly_dict: dict[str, Any],
+        crop_size: int,
+        msa_featurizer: Optional[MSAFeaturizer],
+        template_featurizer: None,
+        method_weights: list[float] = [0.2, 0.4, 0.4],
+        contiguous_crop_complete_lig: bool = False,
+        spatial_crop_complete_lig: bool = False,
+        drop_last: bool = False,
+        remove_metal: bool = False,
+    ) -> tuple[str, TokenArray, AtomArray, dict[str, Any], dict[str, Any]]:
+        """
+        Crop data based on the crop size and reference chain indices.
+
+        Args:
+            one_sample (pd.Series): A dict of one chain or interface from indices list.
+            bioassembly_dict (dict[str, Any]): A dict of bioassembly dict with sequence, atom_array and token_array.
+            crop_size (int): the crop size.
+            msa_featurizer (MSAFeaturizer): Default to an empty replacement for msa featurizer.
+            template_featurizer (None): Placeholder for the template featurizer.
+            method_weights (list[float]): The weights corresponding to these three cropping methods:
+                                          ["ContiguousCropping", "SpatialCropping", "SpatialInterfaceCropping"].
+            contiguous_crop_complete_lig (bool): Whether to crop the complete ligand in ContiguousCropping method.
+            spatial_crop_complete_lig (bool): Whether to crop the complete ligand in SpatialCropping method.
+            drop_last (bool): Whether to drop the last fragment in ContiguousCropping.
+            remove_metal (bool): Whether to remove metal atoms from the crop.
+
+        Returns:
+            tuple[str, TokenArray, AtomArray, dict[str, Any], dict[str, Any]]:
+                crop_method (str): The crop method.
+                cropped_token_array (TokenArray): TokenArray after cropping.
+                cropped_atom_array (AtomArray): AtomArray after cropping.
+                cropped_msa_features (dict[str, Any]): The cropped msa features.
+                cropped_template_features (dict[str, Any]): The cropped template features.
+        """
+        if crop_size <= 0:
+            selected_indices = None
+            # Prepare msa
+            msa_features = DataPipeline.get_msa_raw_features(
+                bioassembly_dict=bioassembly_dict,
+                selected_indices=selected_indices,
+                msa_featurizer=msa_featurizer,
+            )
+            # Prepare template
+            template_features = DataPipeline.get_template_raw_features(
+                bioassembly_dict=bioassembly_dict,
+                selected_indices=selected_indices,
+                template_featurizer=template_featurizer,
+            )
+            return (
+                "no_crop",
+                bioassembly_dict["token_array"],
+                bioassembly_dict["atom_array"],
+                msa_features or {},
+                template_features or {},
+                -1,
+            )
+
+        ref_chain_indices = DataPipeline._map_ref_chain(
+            one_sample=one_sample, bioassembly_dict=bioassembly_dict
+        )
+
+        crop = CropData(
+            crop_size=crop_size,
+            ref_chain_indices=ref_chain_indices,
+            token_array=bioassembly_dict["token_array"],
+            atom_array=bioassembly_dict["atom_array"],
+            method_weights=method_weights,
+            contiguous_crop_complete_lig=contiguous_crop_complete_lig,
+            spatial_crop_complete_lig=spatial_crop_complete_lig,
+            drop_last=drop_last,
+            remove_metal=remove_metal,
+        )
+        # Get crop method
+        crop_method = crop.random_crop_method()
+        # Get crop indices based crop method
+        selected_indices, reference_token_index = crop.get_crop_indices(
+            crop_method=crop_method
+        )
+        # Prepare msa
+        msa_features = DataPipeline.get_msa_raw_features(
+            bioassembly_dict=bioassembly_dict,
+            selected_indices=selected_indices,
+            msa_featurizer=msa_featurizer,
+        )
+        # Prepare template
+        template_features = DataPipeline.get_template_raw_features(
+            bioassembly_dict=bioassembly_dict,
+            selected_indices=selected_indices,
+            template_featurizer=template_featurizer,
+        )
+
+        (
+            cropped_token_array,
+            cropped_atom_array,
+            cropped_msa_features,
+            cropped_template_features,
+        ) = crop.crop_by_indices(
+            selected_token_indices=selected_indices,
+            msa_features=msa_features,
+            template_features=template_features,
+        )
+
+        if crop_method == "ContiguousCropping":
+            resovled_atom_num = cropped_atom_array.is_resolved.sum()
+            # The criterion of “more than 4 atoms” is chosen arbitrarily.
+            assert (
+                resovled_atom_num > 4
+            ), f"{resovled_atom_num=} <= 4 after ContiguousCropping"
+
+        return (
+            crop_method,
+            cropped_token_array,
+            cropped_atom_array,
+            cropped_msa_features,
+            cropped_template_features,
+            reference_token_index,
+        )
+
+    @staticmethod
+    def save_atoms_to_cif(
+        output_cif_file: str, atom_array: AtomArray, include_bonds: bool = False
+    ) -> None:
+        """
+        Save atom array data to a CIF file.
+
+        Args:
+            output_cif_file (str): The output path for saving atom array in cif
+            atom_array (AtomArray): The atom array to be saved
+            include_bonds (bool): Whether to include bond information in the CIF file. Default is False.
+
+        """
+        strucio.save_structure(
+            file_path=output_cif_file,
+            array=atom_array,
+            data_block=os.path.basename(output_cif_file).replace(".cif", ""),
+            include_bonds=include_bonds,
+        )

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/data/dataloader.py

@@ -0,0 +1,372 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+from typing import Iterator, Optional, Sequence
+
+import torch
+import torch.distributed as dist
+from ml_collections.config_dict import ConfigDict
+from torch.utils.data import DataLoader, DistributedSampler, Sampler
+
+from protenix.data.dataset import Dataset, get_datasets
+from protenix.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class WeightedSampler(Sampler):
+    """
+    A weighted sampler for single node.
+    """
+
+    def __init__(
+        self,
+        weights: Sequence[float],
+        num_samples: int,
+        replacement: bool,
+        seed: int = 0,
+    ):
+        """
+        Args:
+            weights (list or numpy array): A list or numpy array of weights.
+            num_samples (int): The number of samples to be drawn.
+            replacement (bool): Whether sampling is done with replacement.
+            seed (int): The seed for the random number generator.
+        """
+        self.weights = torch.as_tensor(weights, dtype=torch.double)
+        self.replacement = replacement
+        self.seed = seed
+        self.epoch = 0
+        self.num_samples = num_samples
+
+    def __iter__(self) -> Iterator[int]:
+        """
+        Generates an iterator over the sampled indices.
+
+        This method uses a random number generator to sample indices based on the provided weights.
+        The generator is seeded with the current seed and epoch to ensure reproducibility.
+
+        Returns:
+            iter: An iterator over the sampled indices.
+        """
+        g = torch.Generator()
+        g.manual_seed(self.seed + self.epoch)
+        indices = torch.multinomial(
+            self.weights, self.num_samples, self.replacement, generator=g
+        ).tolist()
+        return iter(indices)
+
+    def __len__(self) -> int:
+        return self.num_samples
+
+    def set_epoch(self, epoch: int) -> None:
+        self.epoch = epoch
+
+
+class DistributedWeightedSampler(DistributedSampler):
+    """
+    A distributed weighted sampler for multiple nodes.
+    """
+
+    def __init__(
+        self,
+        dataset: Dataset,
+        weights: Sequence[float],
+        num_samples: int,
+        num_replicas: Optional[int] = None,
+        rank: Optional[int] = None,
+        replacement: bool = True,
+        seed: int = 0,
+    ):
+        """
+        Args:
+            dataset (Dataset): The dataset to be loaded.
+            weights (list): The weights associated with the dataset.
+            num_samples (int): The total number of samples to be drawn.
+            num_replicas (int, optional): The number of replicas to use for distributed sampling. Defaults to None.
+            rank (int, optional): The rank of the current process in a distributed environment. Defaults to None.
+            replacement (bool, optional): Whether to sample with replacement. Defaults to True.
+            seed (int, optional): The random seed for reproducibility. Defaults to 0.
+        """
+        super().__init__(dataset, num_replicas=num_replicas, rank=rank, shuffle=False)
+        self.weights = torch.as_tensor(weights, dtype=torch.double)
+        self.replacement = replacement
+        self.seed = seed
+        self.epoch = 0
+        self.num_samples = num_samples
+
+        self.num_samples_per_replica = int(
+            math.ceil(self.num_samples / self.num_replicas)
+        )
+        self.total_size = self.num_samples_per_replica * self.num_replicas
+
+    def __iter__(self) -> Iterator[int]:
+        """
+        Generates an iterator over the sampled indices for the current process in a distributed environment.
+
+        This method uses a random number generator to sample indices based on the provided weights.
+        The generator is seeded with the current seed and epoch to ensure reproducibility.
+        The sampled indices are then distributed across the replicas according to the rank of the current process.
+
+        Returns:
+            iter: An iterator over the sampled indices for the current process.
+        """
+        g = torch.Generator()
+        g.manual_seed(self.seed + self.epoch)
+        indices = torch.multinomial(
+            self.weights, self.num_samples, self.replacement, generator=g
+        ).tolist()
+        indices = indices[self.rank : self.total_size : self.num_replicas]
+        return iter(indices)
+
+    def __len__(self) -> int:
+        return self.num_samples // self.num_replicas
+
+    def set_epoch(self, epoch: int) -> None:
+        self.epoch = epoch
+
+
+class KeySumBalancedSampler(Sampler):
+    def __init__(
+        self,
+        dataset: Dataset,
+        key: str,
+        value_scale: float = 1.0,
+        seed: Optional[int] = None,
+        num_replicas: Optional[int] = None,
+        rank: Optional[int] = None,
+    ):
+        """
+        This method initializes the KeySumBalancedSampler.
+        It calls the `get_balanced_assignments` method to distribute the dataset indices across workers based on the key sum.
+
+        Args:
+            dataset (Dataset): The dataset to sample from.
+            key (str): The key by which data will be balanced (integer value).
+            value_scale (float): The multiplier of key value when computing the worker assignment weight
+            num_replicas (int, optional): Number of processes participating in distributed training.
+            rank (int, optional): Rank of the current process within num_replicas.
+        """
+        self.dataset = dataset
+        self.key = key
+        self.value_scale = value_scale
+        self.seed = seed
+        self.num_replicas = num_replicas or dist.get_world_size()
+        self.rank = rank or dist.get_rank()
+
+        # Get indices for this process after balancing by key sum
+        worker_assignments = self.get_balanced_assignments()
+        self.indices = worker_assignments[self.rank]
+
+    def get_balanced_assignments(self):
+        """
+        Distribute dataset indices across workers such that the sum of key values
+        assigned to each worker is as balanced as possible.
+        """
+        if self.seed is not None:
+            # deterministically shuffle based on seed
+            g = torch.Generator()
+            g.manual_seed(self.seed)
+            indices = torch.randperm(len(self.dataset), generator=g).tolist()
+        else:
+            indices = list(range(len(self.dataset)))
+
+        # pad for len(dataset) to self.num_replicas if len(dataset) < self.num_replicas
+        while len(indices) < self.num_replicas:
+            indices += indices[: (self.num_replicas - len(indices))]
+
+        if isinstance(self.dataset.indices_list, list):
+            # e.g. recentPDB test set
+            dataset_values = [
+                x[self.key].astype(int)[0] for x in self.dataset.indices_list
+            ]
+        else:
+            # e.g. posebuster test set
+            dataset_values = self.dataset.indices_list[self.key].astype(int).to_numpy()
+
+        # Sort indices by key value
+        key_value_pairs = [(idx, dataset_values[idx]) for idx in indices]
+        key_value_pairs.sort(key=lambda x: x[1], reverse=True)
+
+        # Calculate the target number of samples per worker
+        num_samples_per_worker = len(self.dataset) // self.num_replicas
+
+        # Initialize containers for worker assignments and their current key sum
+        worker_assignments = [[] for _ in range(self.num_replicas)]
+        worker_sums = [0] * self.num_replicas
+        total_samples = num_samples_per_worker * self.num_replicas
+
+        # Distribute samples using a greedy strategy to balance the key sum
+        for idx, key_value in key_value_pairs[:total_samples]:
+            # Find the worker with the smallest sum that hasn't exceeded its target sample count
+            min_worker = min(
+                range(self.num_replicas),
+                key=lambda i: (
+                    worker_sums[i]
+                    if len(worker_assignments[i]) < num_samples_per_worker
+                    else float("inf")
+                ),
+            )
+            worker_assignments[min_worker].append(idx)
+            worker_sums[min_worker] += key_value**2
+
+        # Fix any discrepancies in the number of samples
+        all_indices = [idx for idx, _ in key_value_pairs]
+
+        # Assign remaining samples if the dataset isn't divisible perfectly
+        if len(all_indices) > total_samples:
+            for i in range(len(all_indices) - total_samples):
+                worker_assignments[i % self.num_replicas].append(
+                    all_indices[total_samples + i]
+                )
+
+        # Return the indices assigned to the current worker
+        return worker_assignments
+
+    def __iter__(self):
+        return iter(self.indices)
+
+    def __len__(self):
+        return len(self.indices)
+
+
+class IterDataLoader(DataLoader):
+    """
+    Iterative dataloader for single node.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super(IterDataLoader, self).__init__(*args, **kwargs)
+        assert self.sampler is not None
+        self.counter = 0
+
+    def __iter__(self):
+        self.sampler.set_epoch(self.counter)
+        self.counter += 1
+        _iterator = super(IterDataLoader, self).__iter__()
+        return _iterator
+
+
+class DistributedDataLoader(DataLoader):
+    """
+    Distributed dataloader for multiple nodes.
+    """
+
+    def __init__(
+        self,
+        dataset: Dataset,
+        batch_size: int,
+        num_workers: int = 0,
+        collate_fn=None,
+        seed: int = 42,
+        drop_last: bool = True,
+        shuffle: bool = True,
+        sampler: Sampler = None,
+    ):
+        if sampler is not None:
+            self.sampler = sampler
+        else:
+            self.sampler = DistributedSampler(
+                dataset, shuffle=shuffle, seed=seed, drop_last=drop_last
+            )
+
+        super(DistributedDataLoader, self).__init__(
+            dataset=dataset,
+            batch_size=batch_size,
+            num_workers=num_workers,
+            sampler=self.sampler,
+            shuffle=False,
+            collate_fn=collate_fn,
+        )
+        self.counter = 0
+
+    def __iter__(self):
+        self.sampler.set_epoch(self.counter)
+        self.counter += 1
+        _iterator = super(DistributedDataLoader, self).__iter__()
+        return _iterator
+
+
+def get_dataloaders(
+    configs: ConfigDict, world_size: int, seed: int, error_dir: Optional[str] = None
+):
+    """
+    Generate data loaders for training and testing based on the given configurations and seed.
+
+    Args:
+        configs (ConfigDict): An object containing the data configuration information.
+        world_size (int): The number of processes in the distributed environment.
+        seed (int): The random seed used for data sampling.
+        error_dir (str, optional): The directory to store error information. Defaults to None.
+
+    Returns:
+        tuple: A tuple containing the training data loader and a dictionary of testing data loaders.
+
+    """
+    train_dataset, test_datasets = get_datasets(configs, error_dir)
+    if world_size > 1:
+        train_sampler = DistributedWeightedSampler(
+            train_dataset,
+            train_dataset.merged_datapoint_weights,
+            num_samples=configs.data.epoch_size,
+            replacement=True,
+            seed=seed,
+        )
+        train_dl = DistributedDataLoader(
+            dataset=train_dataset,
+            batch_size=1,
+            shuffle=False,
+            num_workers=configs.data.num_dl_workers,
+            collate_fn=lambda batch: batch[0],
+            sampler=train_sampler,
+        )
+    else:
+
+        train_sampler = WeightedSampler(
+            weights=train_dataset.merged_datapoint_weights,
+            num_samples=configs.data.epoch_size,
+            replacement=True,
+            seed=seed,
+        )
+        train_dl = IterDataLoader(
+            dataset=train_dataset,
+            batch_size=1,
+            shuffle=False,
+            num_workers=configs.data.num_dl_workers,
+            collate_fn=lambda batch: batch[0],
+            sampler=train_sampler,
+        )
+
+    test_dls = {}
+    test_dataset_sizes = {}
+    for test_name, test_dataset in test_datasets.items():
+        test_dataset_sizes[test_name] = len(test_dataset)
+        test_sampler = (
+            KeySumBalancedSampler(test_dataset, key="num_tokens", seed=configs.seed)
+            if world_size > 1
+            else None
+        )
+        test_dls[test_name] = DataLoader(
+            test_dataset,
+            batch_size=1,
+            shuffle=False,
+            num_workers=configs.data.num_dl_workers,
+            sampler=test_sampler,
+            collate_fn=lambda batch: batch[0],
+        )
+    logger.info(
+        f"train data size: {len(train_dataset)}, test size: {test_dataset_sizes}"
+    )
+    return train_dl, test_dls

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/data/dataset.py

@@ -0,0 +1,1100 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import os
+import random
+import traceback
+from copy import deepcopy
+from pathlib import Path
+from typing import Any, Callable, Optional, Union
+
+import numpy as np
+import pandas as pd
+import torch
+from biotite.structure.atoms import AtomArray
+from ml_collections.config_dict import ConfigDict
+from torch.utils.data import Dataset
+
+from protenix.data.constants import EvaluationChainInterface
+from protenix.data.data_pipeline import DataPipeline
+from protenix.data.featurizer import Featurizer
+from protenix.data.msa_featurizer import MSAFeaturizer
+from protenix.data.tokenizer import TokenArray
+from protenix.data.utils import data_type_transform, make_dummy_feature
+from protenix.utils.cropping import CropData
+from protenix.utils.file_io import read_indices_csv
+from protenix.utils.logger import get_logger
+from protenix.utils.torch_utils import dict_to_tensor
+
+logger = get_logger(__name__)
+
+
+class BaseSingleDataset(Dataset):
+    """
+    dataset for a single data source
+    data = self.__item__(idx)
+    return a dict of features and labels, the keys and the shape are defined in protenix.data.utils
+    """
+
+    def __init__(
+        self,
+        mmcif_dir: Union[str, Path],
+        bioassembly_dict_dir: Optional[Union[str, Path]],
+        indices_fpath: Union[str, Path],
+        cropping_configs: dict[str, Any],
+        msa_featurizer: Optional[MSAFeaturizer] = None,
+        template_featurizer: Optional[Any] = None,
+        name: str = None,
+        **kwargs,
+    ) -> None:
+        super(BaseSingleDataset, self).__init__()
+
+        # Configs
+        self.mmcif_dir = mmcif_dir
+        self.bioassembly_dict_dir = bioassembly_dict_dir
+        self.indices_fpath = indices_fpath
+        self.cropping_configs = cropping_configs
+        self.name = name
+        # General dataset configs
+        self.ref_pos_augment = kwargs.get("ref_pos_augment", True)
+        self.lig_atom_rename = kwargs.get("lig_atom_rename", False)
+        self.reassign_continuous_chain_ids = kwargs.get(
+            "reassign_continuous_chain_ids", False
+        )
+        self.shuffle_mols = kwargs.get("shuffle_mols", False)
+        self.shuffle_sym_ids = kwargs.get("shuffle_sym_ids", False)
+
+        # Typically used for test sets
+        self.find_pocket = kwargs.get("find_pocket", False)
+        self.find_all_pockets = kwargs.get("find_all_pockets", False)  # for dev
+        self.find_eval_chain_interface = kwargs.get("find_eval_chain_interface", False)
+        self.group_by_pdb_id = kwargs.get("group_by_pdb_id", False)  # for test set
+        self.sort_by_n_token = kwargs.get("sort_by_n_token", False)
+
+        # Typically used for training set
+        self.random_sample_if_failed = kwargs.get("random_sample_if_failed", False)
+        self.use_reference_chains_only = kwargs.get("use_reference_chains_only", False)
+        self.is_distillation = kwargs.get("is_distillation", False)
+
+        # Configs for data filters
+        self.max_n_token = kwargs.get("max_n_token", -1)
+        self.pdb_list = kwargs.get("pdb_list", None)
+        if len(self.pdb_list) == 0:
+            self.pdb_list = None
+        # Used for removing rows in the indices list. Column names and excluded values are specified in this dict.
+        self.exclusion_dict = kwargs.get("exclusion", {})
+        self.limits = kwargs.get(
+            "limits", -1
+        )  # Limit number of indices rows, mainly for test
+
+        self.error_dir = kwargs.get("error_dir", None)
+        if self.error_dir is not None:
+            os.makedirs(self.error_dir, exist_ok=True)
+
+        self.msa_featurizer = msa_featurizer
+        self.template_featurizer = template_featurizer
+
+        # Read data
+        self.indices_list = self.read_indices_list(indices_fpath)
+
+    @staticmethod
+    def read_pdb_list(pdb_list: Union[list, str]) -> Optional[list]:
+        """
+        Reads a list of PDB IDs from a file or directly from a list.
+
+        Args:
+            pdb_list: A list of PDB IDs or a file path containing PDB IDs.
+
+        Returns:
+            A list of PDB IDs if the input is valid, otherwise None.
+        """
+        if pdb_list is None:
+            return None
+
+        if isinstance(pdb_list, list):
+            return pdb_list
+
+        with open(pdb_list, "r") as f:
+            pdb_filter_list = []
+            for l in f.readlines():
+                l = l.strip()
+                if l:
+                    pdb_filter_list.append(l)
+        return pdb_filter_list
+
+    def read_indices_list(self, indices_fpath: Union[str, Path]) -> pd.DataFrame:
+        """
+        Reads and processes a list of indices from a CSV file.
+
+        Args:
+            indices_fpath: Path to the CSV file containing the indices.
+
+        Returns:
+            A DataFrame containing the processed indices.
+        """
+        indices_list = read_indices_csv(indices_fpath)
+        num_data = len(indices_list)
+        logger.info(f"#Rows in indices list: {num_data}")
+        # Filter by pdb_list
+        if self.pdb_list is not None:
+            pdb_filter_list = set(self.read_pdb_list(pdb_list=self.pdb_list))
+            indices_list = indices_list[indices_list["pdb_id"].isin(pdb_filter_list)]
+            logger.info(f"[filtered by pdb_list] #Rows: {len(indices_list)}")
+
+        # Filter by max_n_token
+        if self.max_n_token > 0:
+            valid_mask = indices_list["num_tokens"].astype(int) <= self.max_n_token
+            removed_list = indices_list[~valid_mask]
+            indices_list = indices_list[valid_mask]
+            logger.info(f"[removed] #Rows: {len(removed_list)}")
+            logger.info(f"[removed] #PDB: {removed_list['pdb_id'].nunique()}")
+            logger.info(
+                f"[filtered by n_token ({self.max_n_token})] #Rows: {len(indices_list)}"
+            )
+
+        # Filter by exclusion_dict
+        for col_name, exclusion_list in self.exclusion_dict.items():
+            cols = col_name.split("|")
+            exclusion_set = {tuple(excl.split("|")) for excl in exclusion_list}
+
+            def is_valid(row):
+                return tuple(row[col] for col in cols) not in exclusion_set
+
+            valid_mask = indices_list.apply(is_valid, axis=1)
+            indices_list = indices_list[valid_mask].reset_index(drop=True)
+            logger.info(
+                f"[Excluded by {col_name} -- {exclusion_list}] #Rows: {len(indices_list)}"
+            )
+        self.print_data_stats(indices_list)
+
+        # Group by pdb_id
+        # A list of dataframe. Each contains one pdb with multiple rows.
+        if self.group_by_pdb_id:
+            indices_list = [
+                df.reset_index() for _, df in indices_list.groupby("pdb_id", sort=True)
+            ]
+
+        if self.sort_by_n_token:
+            # Sort the dataset in a descending order, so that if OOM it will raise Error at an early stage.
+            if self.group_by_pdb_id:
+                indices_list = sorted(
+                    indices_list,
+                    key=lambda df: int(df["num_tokens"].iloc[0]),
+                    reverse=True,
+                )
+            else:
+                indices_list = indices_list.sort_values(
+                    by="num_tokens", key=lambda x: x.astype(int), ascending=False
+                ).reset_index(drop=True)
+
+        if self.find_eval_chain_interface:
+            # Remove data that does not contain eval_type in the EvaluationChainInterface list
+            if self.group_by_pdb_id:
+                indices_list = [
+                    df
+                    for df in indices_list
+                    if len(
+                        set(df["eval_type"].to_list()).intersection(
+                            set(EvaluationChainInterface)
+                        )
+                    )
+                    > 0
+                ]
+            else:
+                indices_list = indices_list[
+                    indices_list["eval_type"].apply(
+                        lambda x: x in EvaluationChainInterface
+                    )
+                ]
+        if self.limits > 0 and len(indices_list) > self.limits:
+            logger.info(
+                f"Limit indices list size from {len(indices_list)} to {self.limits}"
+            )
+            indices_list = indices_list[: self.limits]
+        return indices_list
+
+    def print_data_stats(self, df: pd.DataFrame) -> None:
+        """
+        Prints statistics about the dataset, including the distribution of molecular group types.
+
+        Args:
+            df: A DataFrame containing the indices list.
+        """
+        if self.name:
+            logger.info("-" * 10 + f" Dataset {self.name}" + "-" * 10)
+        df["mol_group_type"] = df.apply(
+            lambda row: "_".join(
+                sorted(
+                    [
+                        str(row["mol_1_type"]),
+                        str(row["mol_2_type"]).replace("nan", "intra"),
+                    ]
+                )
+            ),
+            axis=1,
+        )
+
+        group_size_dict = dict(df["mol_group_type"].value_counts())
+        for i, n_i in group_size_dict.items():
+            logger.info(f"{i}: {n_i}/{len(df)}({round(n_i*100/len(df), 2)}%)")
+
+        logger.info("-" * 30)
+        if "cluster_id" in df.columns:
+            n_cluster = df["cluster_id"].nunique()
+            for i in group_size_dict:
+                n_i = df[df["mol_group_type"] == i]["cluster_id"].nunique()
+                logger.info(f"{i}: {n_i}/{n_cluster}({round(n_i*100/n_cluster, 2)}%)")
+            logger.info("-" * 30)
+
+        logger.info(f"Final pdb ids: {len(set(df.pdb_id.tolist()))}")
+        logger.info("-" * 30)
+
+    def __len__(self) -> int:
+        return len(self.indices_list)
+
+    def save_error_data(self, idx: int, error_message: str) -> None:
+        """
+        Saves the error data for a specific index to a JSON file in the error directory.
+
+        Args:
+            idx: The index of the data sample that caused the error.
+            error_message: The error message to be saved.
+        """
+        if self.error_dir is not None:
+            sample_indice = self._get_sample_indice(idx=idx)
+            data = sample_indice.to_dict()
+            data["error"] = error_message
+
+            filename = f"{sample_indice.pdb_id}-{sample_indice.chain_1_id}-{sample_indice.chain_2_id}.json"
+            fpath = os.path.join(self.error_dir, filename)
+            if not os.path.exists(fpath):
+                with open(fpath, "w") as f:
+                    json.dump(data, f)
+
+    def __getitem__(self, idx: int):
+        """
+        Retrieves a data sample by processing the given index.
+        If an error occurs, it attempts to handle it by either saving the error data or randomly sampling another index.
+
+        Args:
+            idx: The index of the data sample to retrieve.
+
+        Returns:
+            A dictionary containing the processed data sample.
+        """
+        # Try at most 10 times
+        for _ in range(10):
+            try:
+                data = self.process_one(idx)
+                return data
+            except Exception as e:
+                error_message = f"{e} at idx {idx}:\n{traceback.format_exc()}"
+                self.save_error_data(idx, error_message)
+
+                if self.random_sample_if_failed:
+                    logger.exception(f"[skip data {idx}] {error_message}")
+                    # Random sample an index
+                    idx = random.choice(range(len(self.indices_list)))
+                    continue
+                else:
+                    raise Exception(e)
+        return data
+
+    def _get_bioassembly_data(
+        self, idx: int
+    ) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+        sample_indice = self._get_sample_indice(idx=idx)
+        if self.bioassembly_dict_dir is not None:
+            bioassembly_dict_fpath = os.path.join(
+                self.bioassembly_dict_dir, sample_indice.pdb_id + ".pkl.gz"
+            )
+        else:
+            bioassembly_dict_fpath = None
+
+        bioassembly_dict = DataPipeline.get_data_bioassembly(
+            bioassembly_dict_fpath=bioassembly_dict_fpath
+        )
+        bioassembly_dict["pdb_id"] = sample_indice.pdb_id
+        return sample_indice, bioassembly_dict, bioassembly_dict_fpath
+
+    @staticmethod
+    def _reassign_atom_array_chain_id(atom_array: AtomArray):
+        """
+        In experiments conducted to observe overfitting effects using training sets,
+        the pre-stored AtomArray in the training set may experience issues with discontinuous chain IDs due to filtering.
+        Consequently, a temporary patch has been implemented to resolve this issue.
+
+        e.g. 3x6u asym_id_int = [0, 1, 2, ... 18, 20] -> reassigned_asym_id_int [0, 1, 2, ..., 18, 19]
+        """
+
+        def _get_contiguous_array(array):
+            array_uniq = np.sort(np.unique(array))
+            map_dict = {i: idx for idx, i in enumerate(array_uniq)}
+            new_array = np.vectorize(map_dict.get)(array)
+            return new_array
+
+        atom_array.asym_id_int = _get_contiguous_array(atom_array.asym_id_int)
+        atom_array.entity_id_int = _get_contiguous_array(atom_array.entity_id_int)
+        atom_array.sym_id_int = _get_contiguous_array(atom_array.sym_id_int)
+        return atom_array
+
+    @staticmethod
+    def _shuffle_array_based_on_mol_id(token_array: TokenArray, atom_array: AtomArray):
+        """
+        Shuffle both token_array and atom_array.
+        Atoms/tokens with the same mol_id will be shuffled as a integrated component.
+        """
+
+        # Get token mol_id
+        centre_atom_indices = token_array.get_annotation("centre_atom_index")
+        token_mol_id = atom_array[centre_atom_indices].mol_id
+
+        # Get unique molecule IDs and shuffle them in place
+        shuffled_mol_ids = np.unique(token_mol_id).copy()
+        np.random.shuffle(shuffled_mol_ids)
+
+        # Get shuffled token indices
+        original_token_indices = np.arange(len(token_mol_id))
+        shuffled_token_indices = []
+        for mol_id in shuffled_mol_ids:
+            mol_token_indices = original_token_indices[token_mol_id == mol_id]
+            shuffled_token_indices.append(mol_token_indices)
+        shuffled_token_indices = np.concatenate(shuffled_token_indices)
+
+        # Get shuffled token and atom array
+        # Use `CropData.select_by_token_indices` to shuffle safely
+        token_array, atom_array, _, _ = CropData.select_by_token_indices(
+            token_array=token_array,
+            atom_array=atom_array,
+            selected_token_indices=shuffled_token_indices,
+        )
+
+        return token_array, atom_array
+
+    @staticmethod
+    def _assign_random_sym_id(atom_array: AtomArray):
+        """
+        Assign random sym_id for chains of the same entity_id
+        e.g.
+        when entity_id = 0
+            sym_id_int = [0, 1, 2] -> random_sym_id_int = [2, 0, 1]
+        when entity_id = 1
+            sym_id_int = [0, 1, 2, 3] -> random_sym_id_int = [3, 0, 1, 2]
+        """
+
+        def _shuffle(x):
+            x_unique = np.sort(np.unique(x))
+            x_shuffled = x_unique.copy()
+            np.random.shuffle(x_shuffled)  # shuffle in-place
+            map_dict = dict(zip(x_unique, x_shuffled))
+            new_x = np.vectorize(map_dict.get)(x)
+            return new_x.copy()
+
+        for entity_id in np.unique(atom_array.label_entity_id):
+            mask = atom_array.label_entity_id == entity_id
+            atom_array.sym_id_int[mask] = _shuffle(atom_array.sym_id_int[mask])
+        return atom_array
+
+    def process_one(
+        self, idx: int, return_atom_token_array: bool = False
+    ) -> dict[str, dict]:
+        """
+        Processes a single data sample by retrieving bioassembly data, applying various transformations, and cropping the data.
+        It then extracts features and labels, and optionally returns the processed atom and token arrays.
+
+        Args:
+            idx: The index of the data sample to process.
+            return_atom_token_array: Whether to return the processed atom and token arrays.
+
+        Returns:
+            A dict containing the input features, labels, basic_info and optionally the processed atom and token arrays.
+        """
+
+        sample_indice, bioassembly_dict, bioassembly_dict_fpath = (
+            self._get_bioassembly_data(idx=idx)
+        )
+
+        if self.use_reference_chains_only:
+            # Get the reference chains
+            ref_chain_ids = [sample_indice.chain_1_id, sample_indice.chain_2_id]
+            if sample_indice.type == "chain":
+                ref_chain_ids.pop(-1)
+            # Remove other chains from the bioassembly_dict
+            # Remove them safely using the crop method
+            token_centre_atom_indices = bioassembly_dict["token_array"].get_annotation(
+                "centre_atom_index"
+            )
+            token_chain_id = bioassembly_dict["atom_array"][
+                token_centre_atom_indices
+            ].chain_id
+            is_ref_chain = np.isin(token_chain_id, ref_chain_ids)
+            bioassembly_dict["token_array"], bioassembly_dict["atom_array"], _, _ = (
+                CropData.select_by_token_indices(
+                    token_array=bioassembly_dict["token_array"],
+                    atom_array=bioassembly_dict["atom_array"],
+                    selected_token_indices=np.arange(len(is_ref_chain))[is_ref_chain],
+                )
+            )
+
+        if self.shuffle_mols:
+            bioassembly_dict["token_array"], bioassembly_dict["atom_array"] = (
+                self._shuffle_array_based_on_mol_id(
+                    token_array=bioassembly_dict["token_array"],
+                    atom_array=bioassembly_dict["atom_array"],
+                )
+            )
+
+        if self.shuffle_sym_ids:
+            bioassembly_dict["atom_array"] = self._assign_random_sym_id(
+                bioassembly_dict["atom_array"]
+            )
+
+        if self.reassign_continuous_chain_ids:
+            bioassembly_dict["atom_array"] = self._reassign_atom_array_chain_id(
+                bioassembly_dict["atom_array"]
+            )
+
+        # Crop
+        (
+            crop_method,
+            cropped_token_array,
+            cropped_atom_array,
+            cropped_msa_features,
+            cropped_template_features,
+            reference_token_index,
+        ) = self.crop(
+            sample_indice=sample_indice,
+            bioassembly_dict=bioassembly_dict,
+            **self.cropping_configs,
+        )
+
+        feat, label, label_full = self.get_feature_and_label(
+            idx=idx,
+            token_array=cropped_token_array,
+            atom_array=cropped_atom_array,
+            msa_features=cropped_msa_features,
+            template_features=cropped_template_features,
+            full_atom_array=bioassembly_dict["atom_array"],
+            is_spatial_crop="spatial" in crop_method.lower(),
+        )
+
+        # Basic info, e.g. dimension related items
+        basic_info = {
+            "pdb_id": (
+                bioassembly_dict["pdb_id"]
+                if self.is_distillation is False
+                else sample_indice["pdb_id"]
+            ),
+            "N_asym": torch.tensor([len(torch.unique(feat["asym_id"]))]),
+            "N_token": torch.tensor([feat["token_index"].shape[0]]),
+            "N_atom": torch.tensor([feat["atom_to_token_idx"].shape[0]]),
+            "N_msa": torch.tensor([feat["msa"].shape[0]]),
+            "bioassembly_dict_fpath": bioassembly_dict_fpath,
+            "N_msa_prot_pair": torch.tensor([feat["prot_pair_num_alignments"]]),
+            "N_msa_prot_unpair": torch.tensor([feat["prot_unpair_num_alignments"]]),
+            "N_msa_rna_pair": torch.tensor([feat["rna_pair_num_alignments"]]),
+            "N_msa_rna_unpair": torch.tensor([feat["rna_unpair_num_alignments"]]),
+        }
+
+        for mol_type in ("protein", "ligand", "rna", "dna"):
+            abbr = {"protein": "prot", "ligand": "lig"}
+            abbr_type = abbr.get(mol_type, mol_type)
+            mol_type_mask = feat[f"is_{mol_type}"].bool()
+            n_atom = int(mol_type_mask.sum(dim=-1).item())
+            n_token = len(torch.unique(feat["atom_to_token_idx"][mol_type_mask]))
+            basic_info[f"N_{abbr_type}_atom"] = torch.tensor([n_atom])
+            basic_info[f"N_{abbr_type}_token"] = torch.tensor([n_token])
+
+        # Add chain level chain_id
+        asymn_id_to_chain_id = {
+            atom.asym_id_int: atom.chain_id for atom in cropped_atom_array
+        }
+        chain_id_list = [
+            asymn_id_to_chain_id[asymn_id_int]
+            for asymn_id_int in sorted(asymn_id_to_chain_id.keys())
+        ]
+        basic_info["chain_id"] = chain_id_list
+
+        data = {
+            "input_feature_dict": feat,
+            "label_dict": label,
+            "label_full_dict": label_full,
+            "basic": basic_info,
+        }
+
+        if return_atom_token_array:
+            data["cropped_atom_array"] = cropped_atom_array
+            data["cropped_token_array"] = cropped_token_array
+        return data
+
+    def crop(
+        self,
+        sample_indice: pd.Series,
+        bioassembly_dict: dict[str, Any],
+        crop_size: int,
+        method_weights: list[float],
+        contiguous_crop_complete_lig: bool = True,
+        spatial_crop_complete_lig: bool = True,
+        drop_last: bool = True,
+        remove_metal: bool = True,
+    ) -> tuple[str, TokenArray, AtomArray, dict[str, Any], dict[str, Any]]:
+        """
+        Crops the bioassembly data based on the specified configurations.
+
+        Returns:
+            A tuple containing the cropping method, cropped token array, cropped atom array,
+                cropped MSA features, and cropped template features.
+        """
+        return DataPipeline.crop(
+            one_sample=sample_indice,
+            bioassembly_dict=bioassembly_dict,
+            crop_size=crop_size,
+            msa_featurizer=self.msa_featurizer,
+            template_featurizer=self.template_featurizer,
+            method_weights=method_weights,
+            contiguous_crop_complete_lig=contiguous_crop_complete_lig,
+            spatial_crop_complete_lig=spatial_crop_complete_lig,
+            drop_last=drop_last,
+            remove_metal=remove_metal,
+        )
+
+    def _get_sample_indice(self, idx: int) -> pd.Series:
+        """
+        Retrieves the sample indice for a given index. If the dataset is grouped by PDB ID, it returns the first row of the PDB-idx.
+        Otherwise, it returns the row at the specified index.
+
+        Args:
+            idx: The index of the data sample to retrieve.
+
+        Returns:
+            A pandas Series containing the sample indice.
+        """
+        if self.group_by_pdb_id:
+            # Row-0 of PDB-idx
+            sample_indice = self.indices_list[idx].iloc[0]
+        else:
+            sample_indice = self.indices_list.iloc[idx]
+        return sample_indice
+
+    def _get_eval_chain_interface_mask(
+        self, idx: int, atom_array_chain_id: np.ndarray
+    ) -> tuple[np.ndarray, np.ndarray, torch.Tensor, torch.Tensor]:
+        """
+        Retrieves the evaluation chain/interface mask for a given index.
+
+        Args:
+            idx: The index of the data sample.
+            atom_array_chain_id: An array containing the chain IDs of the atom array.
+
+        Returns:
+            A tuple containing the evaluation type, cluster ID, chain 1 mask, and chain 2 mask.
+        """
+        if self.group_by_pdb_id:
+            df = self.indices_list[idx]
+        else:
+            df = self.indices_list.iloc[idx : idx + 1]
+
+        # Only consider chain/interfaces defined in EvaluationChainInterface
+        df = df[df["eval_type"].apply(lambda x: x in EvaluationChainInterface)].copy()
+        if len(df) < 1:
+            raise ValueError(
+                f"Cannot find a chain/interface for evaluation in the PDB."
+            )
+
+        def get_atom_mask(row):
+            chain_1_mask = atom_array_chain_id == row["chain_1_id"]
+            if row["type"] == "chain":
+                chain_2_mask = chain_1_mask
+            else:
+                chain_2_mask = atom_array_chain_id == row["chain_2_id"]
+            chain_1_mask = torch.tensor(chain_1_mask).bool()
+            chain_2_mask = torch.tensor(chain_2_mask).bool()
+            if chain_1_mask.sum() == 0 or chain_2_mask.sum() == 0:
+                return None, None
+            return chain_1_mask, chain_2_mask
+
+        df["chain_1_mask"], df["chain_2_mask"] = zip(*df.apply(get_atom_mask, axis=1))
+        df = df[df["chain_1_mask"].notna()]  # drop NaN
+
+        if len(df) < 1:
+            raise ValueError(
+                f"Cannot find a chain/interface for evaluation in the atom_array."
+            )
+
+        eval_type = np.array(df["eval_type"].tolist())
+        cluster_id = np.array(df["cluster_id"].tolist())
+        # [N_eval, N_atom]
+        chain_1_mask = torch.stack(df["chain_1_mask"].tolist())
+        # [N_eval, N_atom]
+        chain_2_mask = torch.stack(df["chain_2_mask"].tolist())
+
+        return eval_type, cluster_id, chain_1_mask, chain_2_mask
+
+    def get_feature_and_label(
+        self,
+        idx: int,
+        token_array: TokenArray,
+        atom_array: AtomArray,
+        msa_features: dict[str, Any],
+        template_features: dict[str, Any],
+        full_atom_array: AtomArray,
+        is_spatial_crop: bool = True,
+    ) -> tuple[dict[str, torch.Tensor], dict[str, torch.Tensor]]:
+        """
+        Get feature and label information for a given data point.
+        It uses a Featurizer object to obtain input features and labels, and applies several
+        steps to add other features and labels. Finally, it returns the feature dictionary, label
+        dictionary, and a full label dictionary.
+
+        Args:
+            idx: Index of the data point.
+            token_array: Token array representing the amino acid sequence.
+            atom_array: Atom array containing atomic information.
+            msa_features: Dictionary of MSA features.
+            template_features: Dictionary of template features.
+            full_atom_array: Full atom array containing all atoms.
+            is_spatial_crop: Flag indicating whether spatial cropping is applied, by default True.
+
+        Returns:
+            A tuple containing the feature dictionary and the label dictionary.
+
+        Raises:
+            ValueError: If the ligand cannot be found in the data point.
+        """
+        # Get feature and labels from Featurizer
+        feat = Featurizer(
+            cropped_token_array=token_array,
+            cropped_atom_array=atom_array,
+            ref_pos_augment=self.ref_pos_augment,
+            lig_atom_rename=self.lig_atom_rename,
+        )
+        features_dict = feat.get_all_input_features()
+        labels_dict = feat.get_labels()
+
+        # Permutation list for atom permutation
+        features_dict["atom_perm_list"] = feat.get_atom_permutation_list()
+
+        # Labels for multi-chain permutation
+        # Note: the returned full_atom_array may contain fewer atoms than the input
+        label_full_dict, full_atom_array = Featurizer.get_gt_full_complex_features(
+            atom_array=full_atom_array,
+            cropped_atom_array=atom_array,
+            get_cropped_asym_only=is_spatial_crop,
+        )
+
+        # Masks for Pocket Metrics
+        if self.find_pocket:
+            # Get entity_id of the interested ligand
+            sample_indice = self._get_sample_indice(idx=idx)
+            if sample_indice.mol_1_type == "ligand":
+                lig_entity_id = str(sample_indice.entity_1_id)
+                lig_chain_id = str(sample_indice.chain_1_id)
+            elif sample_indice.mol_2_type == "ligand":
+                lig_entity_id = str(sample_indice.entity_2_id)
+                lig_chain_id = str(sample_indice.chain_2_id)
+            else:
+                raise ValueError(f"Cannot find ligand from this data point.")
+            # Make sure the cropped array contains interested ligand
+            assert lig_entity_id in set(atom_array.label_entity_id)
+            assert lig_chain_id in set(atom_array.chain_id)
+
+            # Get asym ID of the specific ligand in the `main` pocket
+            lig_asym_id = atom_array.label_asym_id[atom_array.chain_id == lig_chain_id]
+            assert len(np.unique(lig_asym_id)) == 1
+            lig_asym_id = lig_asym_id[0]
+            ligands = [lig_asym_id]
+
+            if self.find_all_pockets:
+                # Get asym ID of other ligands with the same entity_id
+                all_lig_asym_ids = set(
+                    full_atom_array[
+                        full_atom_array.label_entity_id == lig_entity_id
+                    ].label_asym_id
+                )
+                ligands.extend(list(all_lig_asym_ids - set([lig_asym_id])))
+
+            # Note: the `main` pocket is the 0-indexed one.
+            # [N_pocket, N_atom], [N_pocket, N_atom].
+            # If not find_all_pockets, then N_pocket = 1.
+            interested_ligand_mask, pocket_mask = feat.get_lig_pocket_mask(
+                atom_array=full_atom_array, lig_label_asym_id=ligands
+            )
+
+            label_full_dict["pocket_mask"] = pocket_mask
+            label_full_dict["interested_ligand_mask"] = interested_ligand_mask
+
+        # Masks for Chain/Interface Metrics
+        if self.find_eval_chain_interface:
+            eval_type, cluster_id, chain_1_mask, chain_2_mask = (
+                self._get_eval_chain_interface_mask(
+                    idx=idx, atom_array_chain_id=full_atom_array.chain_id
+                )
+            )
+            labels_dict["eval_type"] = eval_type  # [N_eval]
+            labels_dict["cluster_id"] = cluster_id  # [N_eval]
+            labels_dict["chain_1_mask"] = chain_1_mask  # [N_eval, N_atom]
+            labels_dict["chain_2_mask"] = chain_2_mask  # [N_eval, N_atom]
+
+        # Make dummy features for not implemented features
+        dummy_feats = []
+        if len(msa_features) == 0:
+            dummy_feats.append("msa")
+        else:
+            msa_features = dict_to_tensor(msa_features)
+            features_dict.update(msa_features)
+        if len(template_features) == 0:
+            dummy_feats.append("template")
+        else:
+            template_features = dict_to_tensor(template_features)
+            features_dict.update(template_features)
+
+        features_dict = make_dummy_feature(
+            features_dict=features_dict, dummy_feats=dummy_feats
+        )
+        # Transform to right data type
+        features_dict = data_type_transform(feat_or_label_dict=features_dict)
+        labels_dict = data_type_transform(feat_or_label_dict=labels_dict)
+
+        # Is_distillation
+        features_dict["is_distillation"] = torch.tensor([self.is_distillation])
+        if self.is_distillation is True:
+            features_dict["resolution"] = torch.tensor([-1.0])
+        return features_dict, labels_dict, label_full_dict
+
+
+def get_msa_featurizer(configs, dataset_name: str, stage: str) -> Optional[Callable]:
+    """
+    Creates and returns an MSAFeaturizer object based on the provided configurations.
+
+    Args:
+        configs: A dictionary containing the configurations for the MSAFeaturizer.
+        dataset_name: The name of the dataset.
+        stage: The stage of the dataset (e.g., 'train', 'test').
+
+    Returns:
+        An MSAFeaturizer object if MSA is enabled in the configurations, otherwise None.
+    """
+    if "msa" in configs["data"] and configs["data"]["msa"]["enable"]:
+        msa_info = configs["data"]["msa"]
+        msa_args = deepcopy(msa_info)
+
+        if "msa" in (dataset_config := configs["data"][dataset_name]):
+            for k, v in dataset_config["msa"].items():
+                if k not in ["prot", "rna"]:
+                    msa_args[k] = v
+                else:
+                    for kk, vv in dataset_config["msa"][k].items():
+                        msa_args[k][kk] = vv
+
+        prot_msa_args = msa_args["prot"]
+        prot_msa_args.update(
+            {
+                "dataset_name": dataset_name,
+                "merge_method": msa_args["merge_method"],
+                "max_size": msa_args["max_size"][stage],
+            }
+        )
+
+        rna_msa_args = msa_args["rna"]
+        rna_msa_args.update(
+            {
+                "dataset_name": dataset_name,
+                "merge_method": msa_args["merge_method"],
+                "max_size": msa_args["max_size"][stage],
+            }
+        )
+
+        return MSAFeaturizer(
+            prot_msa_args=prot_msa_args,
+            rna_msa_args=rna_msa_args,
+            enable_rna_msa=configs.data.msa.enable_rna_msa,
+        )
+
+    else:
+        return None
+
+
+class WeightedMultiDataset(Dataset):
+    """
+    A weighted dataset composed of multiple datasets with weights.
+    """
+
+    def __init__(
+        self,
+        datasets: list[Dataset],
+        dataset_names: list[str],
+        datapoint_weights: list[list[float]],
+        dataset_sample_weights: list[torch.tensor],
+    ):
+        """
+        Initializes the WeightedMultiDataset.
+        Args:
+            datasets: A list of Dataset objects.
+            dataset_names: A list of dataset names corresponding to the datasets.
+            datapoint_weights: A list of lists containing sampling weights for each datapoint in the datasets.
+            dataset_sample_weights: A list of torch tensors containing sampling weights for each dataset.
+        """
+        self.datasets = datasets
+        self.dataset_names = dataset_names
+        self.datapoint_weights = datapoint_weights
+        self.dataset_sample_weights = torch.Tensor(dataset_sample_weights)
+        self.iteration = 0
+        self.offset = 0
+        self.init_datasets()
+
+    def init_datasets(self):
+        """Calculate global weights of each datapoint in datasets for future sampling."""
+        self.merged_datapoint_weights = []
+        self.weight = 0.0
+        self.dataset_indices = []
+        self.within_dataset_indices = []
+        for dataset_index, (
+            dataset,
+            datapoint_weight_list,
+            dataset_weight,
+        ) in enumerate(
+            zip(self.datasets, self.datapoint_weights, self.dataset_sample_weights)
+        ):
+            # normalize each dataset weights
+            weight_sum = sum(datapoint_weight_list)
+            datapoint_weight_list = [
+                dataset_weight * w / weight_sum for w in datapoint_weight_list
+            ]
+            self.merged_datapoint_weights.extend(datapoint_weight_list)
+            self.weight += dataset_weight
+            self.dataset_indices.extend([dataset_index] * len(datapoint_weight_list))
+            self.within_dataset_indices.extend(list(range(len(datapoint_weight_list))))
+        self.merged_datapoint_weights = torch.tensor(
+            self.merged_datapoint_weights, dtype=torch.float64
+        )
+
+    def __len__(self) -> int:
+        return len(self.merged_datapoint_weights)
+
+    def __getitem__(self, index: int) -> dict[str, dict]:
+        return self.datasets[self.dataset_indices[index]][
+            self.within_dataset_indices[index]
+        ]
+
+
+def get_weighted_pdb_weight(
+    data_type: str,
+    cluster_size: int,
+    chain_count: dict,
+    eps: float = 1e-9,
+    beta_dict: dict = {
+        "chain": 0.5,
+        "interface": 1,
+    },
+    alpha_dict: dict = {
+        "prot": 3,
+        "nuc": 3,
+        "ligand": 1,
+    },
+) -> float:
+    """
+    Get sample weight for each examples in weighted pdb dataset. AF3-SI (1)
+    Args:
+        data_type: chain or interface
+        cluster_size: cluster size of this chain/interface
+        chain_count: count of each kinds of chains, {"prot": int, "nuc": int, "ligand": int}
+    Returns:
+        weights: float
+    """
+    assert cluster_size > 0
+    assert data_type in ["chain", "interface"]
+    beta = beta_dict[data_type]
+    assert set(chain_count.keys()).issubset(set(alpha_dict.keys()))
+    weight = (
+        beta
+        * sum(
+            [alpha * chain_count[data_mode] for data_mode, alpha in alpha_dict.items()]
+        )
+        / (cluster_size + eps)
+    )
+    return weight
+
+
+def calc_weights_for_df(
+    indices_df: pd.DataFrame, beta_dict: dict[str, Any], alpha_dict: dict[str, Any]
+) -> pd.DataFrame:
+    """
+    Calculate weights for each example in the dataframe.
+
+    Args:
+        indices_df: A pandas DataFrame containing the indices.
+        beta_dict: A dictionary containing beta values for different data types.
+        alpha_dict: A dictionary containing alpha values for different data types.
+
+    Returns:
+        A pandas DataFrame with an column 'weights' containing the calculated weights.
+    """
+    # Specific to assembly, and entities (chain or interface)
+    indices_df["pdb_sorted_entity_id"] = indices_df.apply(
+        lambda x: f"{x['pdb_id']}_{x['assembly_id']}_{'_'.join(sorted([str(x['entity_1_id']), str(x['entity_2_id'])]))}",
+        axis=1,
+    )
+
+    entity_member_num_dict = {}
+    for pdb_sorted_entity_id, sub_df in indices_df.groupby("pdb_sorted_entity_id"):
+        # Number of repeatative entities in the same assembly
+        entity_member_num_dict[pdb_sorted_entity_id] = len(sub_df)
+    indices_df["pdb_sorted_entity_id_member_num"] = indices_df.apply(
+        lambda x: entity_member_num_dict[x["pdb_sorted_entity_id"]], axis=1
+    )
+
+    cluster_size_record = {}
+    for cluster_id, sub_df in indices_df.groupby("cluster_id"):
+        cluster_size_record[cluster_id] = len(set(sub_df["pdb_sorted_entity_id"]))
+
+    weights = []
+    for _, row in indices_df.iterrows():
+        data_type = row["type"]
+        cluster_size = cluster_size_record[row["cluster_id"]]
+        chain_count = {"prot": 0, "nuc": 0, "ligand": 0}
+        for mol_type in [row["mol_1_type"], row["mol_2_type"]]:
+            if chain_count.get(mol_type) is None:
+                continue
+            chain_count[mol_type] += 1
+        # Weight specific to (assembly, entity(chain/interface))
+        weight = get_weighted_pdb_weight(
+            data_type=data_type,
+            cluster_size=cluster_size,
+            chain_count=chain_count,
+            beta_dict=beta_dict,
+            alpha_dict=alpha_dict,
+        )
+        weights.append(weight)
+    indices_df["weights"] = weights / indices_df["pdb_sorted_entity_id_member_num"]
+    return indices_df
+
+
+def get_sample_weights(
+    sampler_type: str,
+    indices_df: pd.DataFrame = None,
+    beta_dict: dict = {
+        "chain": 0.5,
+        "interface": 1,
+    },
+    alpha_dict: dict = {
+        "prot": 3,
+        "nuc": 3,
+        "ligand": 1,
+    },
+    force_recompute_weight: bool = False,
+) -> Union[pd.Series, list[float]]:
+    """
+    Computes sample weights based on the specified sampler type.
+
+    Args:
+        sampler_type: The type of sampler to use ('weighted' or 'uniform').
+        indices_df: A pandas DataFrame containing the indices.
+        beta_dict: A dictionary containing beta values for different data types.
+        alpha_dict: A dictionary containing alpha values for different data types.
+        force_recompute_weight: Whether to force recomputation of weights even if they already exist.
+
+    Returns:
+        A list of sample weights.
+
+    Raises:
+        ValueError: If an unknown sampler type is provided.
+    """
+    if sampler_type == "weighted":
+        assert indices_df is not None
+        if "weights" not in indices_df.columns or force_recompute_weight:
+            indices_df = calc_weights_for_df(
+                indices_df=indices_df,
+                beta_dict=beta_dict,
+                alpha_dict=alpha_dict,
+            )
+        return indices_df["weights"].astype("float32")
+    elif sampler_type == "uniform":
+        assert indices_df is not None
+        return [1 / len(indices_df) for _ in range(len(indices_df))]
+    else:
+        raise ValueError(f"Unknown sampler type: {sampler_type}")
+
+
+def get_datasets(
+    configs: ConfigDict, error_dir: Optional[str]
+) -> tuple[WeightedMultiDataset, dict[str, BaseSingleDataset]]:
+    """
+    Get training and testing datasets given configs
+
+    Args:
+        configs: A ConfigDict containing the dataset configurations.
+        error_dir: The directory where error logs will be saved.
+
+    Returns:
+        A tuple containing the training dataset and a dictionary of testing datasets.
+    """
+
+    def _get_dataset_param(config_dict, dataset_name: str, stage: str):
+        # Template_featurizer is under development
+        # Lig_atom_rename/shuffle_mols/shuffle_sym_ids do not affect the performance very much
+        return {
+            "name": dataset_name,
+            **config_dict["base_info"],
+            "cropping_configs": config_dict["cropping_configs"],
+            "error_dir": error_dir,
+            "msa_featurizer": get_msa_featurizer(configs, dataset_name, stage),
+            "template_featurizer": None,
+            "lig_atom_rename": config_dict.get("lig_atom_rename", False),
+            "shuffle_mols": config_dict.get("shuffle_mols", False),
+            "shuffle_sym_ids": config_dict.get("shuffle_sym_ids", False),
+        }
+
+    data_config = configs.data
+    logger.info(f"Using train sets {data_config.train_sets}")
+    assert len(data_config.train_sets) == len(
+        data_config.train_sampler.train_sample_weights
+    )
+    train_datasets = []
+    datapoint_weights = []
+    for train_name in data_config.train_sets:
+        config_dict = data_config[train_name].to_dict()
+        dataset_param = _get_dataset_param(
+            config_dict, dataset_name=train_name, stage="train"
+        )
+        dataset_param["ref_pos_augment"] = data_config.get(
+            "train_ref_pos_augment", True
+        )
+        dataset_param["limits"] = data_config.get("limits", -1)
+        train_dataset = BaseSingleDataset(**dataset_param)
+        train_datasets.append(train_dataset)
+        datapoint_weights.append(
+            get_sample_weights(
+                **data_config[train_name]["sampler_configs"],
+                indices_df=train_dataset.indices_list,
+            )
+        )
+    train_dataset = WeightedMultiDataset(
+        datasets=train_datasets,
+        dataset_names=data_config.train_sets,
+        datapoint_weights=datapoint_weights,
+        dataset_sample_weights=data_config.train_sampler.train_sample_weights,
+    )
+
+    test_datasets = {}
+    test_sets = data_config.test_sets
+    for test_name in test_sets:
+        config_dict = data_config[test_name].to_dict()
+        dataset_param = _get_dataset_param(
+            config_dict, dataset_name=test_name, stage="test"
+        )
+        dataset_param["ref_pos_augment"] = data_config.get("test_ref_pos_augment", True)
+        test_dataset = BaseSingleDataset(**dataset_param)
+        test_datasets[test_name] = test_dataset
+    return train_dataset, test_datasets

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/data/featurizer.py

@@ -0,0 +1,802 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import copy
+from collections import defaultdict
+from typing import Union
+
+import numpy as np
+import torch
+from biotite.structure import Atom, AtomArray, get_residue_starts
+from sklearn.neighbors import KDTree
+
+from protenix.data.constants import STD_RESIDUES, get_all_elems
+from protenix.data.tokenizer import Token, TokenArray
+from protenix.data.utils import get_ligand_polymer_bond_mask
+from protenix.utils.geometry import angle_3p, random_transform
+
+
+class Featurizer(object):
+    def __init__(
+        self,
+        cropped_token_array: TokenArray,
+        cropped_atom_array: AtomArray,
+        ref_pos_augment: bool = True,
+        lig_atom_rename: bool = False,
+    ) -> None:
+        """
+        Args:
+            cropped_token_array (TokenArray): TokenArray object after cropping
+            cropped_atom_array (AtomArray): AtomArray object after cropping
+            ref_pos_augment (bool): Boolean indicating whether apply random rotation and translation on ref_pos
+            lig_atom_rename (bool): Boolean indicating whether rename atom name for ligand atoms
+        """
+        self.cropped_token_array = cropped_token_array
+
+        self.cropped_atom_array = cropped_atom_array
+        self.ref_pos_augment = ref_pos_augment
+        self.lig_atom_rename = lig_atom_rename
+
+    @staticmethod
+    def encoder(encode_def_list: list[str], input_list: list[str]) -> torch.Tensor:
+        """
+        Encode a list of input values into a binary format using a specified encoding definition list.
+
+        Args:
+            encode_def_list (list): A list of encoding definitions.
+            input_list (list): A list of input values to be encoded.
+
+        Returns:
+            torch.Tensor: A tensor representing the binary encoding of the input values.
+        """
+        onehot_dict = {}
+        num_keys = len(encode_def_list)
+        for index, key in enumerate(encode_def_list):
+            onehot = [0] * num_keys
+            onehot[index] = 1
+            onehot_dict[key] = onehot
+
+        onehot_encoded_data = [onehot_dict[item] for item in input_list]
+        onehot_tensor = torch.Tensor(onehot_encoded_data)
+        return onehot_tensor
+
+    @staticmethod
+    def restype_onehot_encoded(restype_list: list[str]) -> torch.Tensor:
+        """
+        Ref: AlphaFold3 SI Table 5 "restype"
+        One-hot encoding of the sequence. 32 possible values: 20 amino acids + unknown,
+        4 RNA nucleotides + unknown, 4 DNA nucleotides + unknown, and gap.
+        Ligands represented as “unknown amino acid”.
+
+        Args:
+            restype_list (List[str]): A list of residue types.
+                                      The residue type of ligand should be "UNK" in the input list.
+
+        Returns:
+            torch.Tensor:  A Tensor of one-hot encoded residue types
+        """
+
+        return Featurizer.encoder(list(STD_RESIDUES.keys()) + ["-"], restype_list)
+
+    @staticmethod
+    def elem_onehot_encoded(elem_list: list[str]) -> torch.Tensor:
+        """
+        Ref: AlphaFold3 SI Table 5 "ref_element"
+        One-hot encoding of the element atomic number for each atom
+        in the reference conformer, up to atomic number 128.
+
+        Args:
+            elem_list (List[str]): A list of element symbols.
+
+        Returns:
+            torch.Tensor:  A Tensor of one-hot encoded elements
+        """
+        return Featurizer.encoder(get_all_elems(), elem_list)
+
+    @staticmethod
+    def ref_atom_name_chars_encoded(atom_names: list[str]) -> torch.Tensor:
+        """
+        Ref: AlphaFold3 SI Table 5 "ref_atom_name_chars"
+        One-hot encoding of the unique atom names in the reference conformer.
+        Each character is encoded as ord(c) − 32, and names are padded to length 4.
+
+        Args:
+            atom_name_list (List[str]): A list of atom names.
+
+        Returns:
+            torch.Tensor:  A Tensor of character encoded atom names
+        """
+        onehot_dict = {}
+        for index, key in enumerate(range(64)):
+            onehot = [0] * 64
+            onehot[index] = 1
+            onehot_dict[key] = onehot
+        # [N_atom, 4, 64]
+        mol_encode = []
+        for atom_name in atom_names:
+            # [4, 64]
+            atom_encode = []
+            for name_str in atom_name.ljust(4):
+                atom_encode.append(onehot_dict[ord(name_str) - 32])
+            mol_encode.append(atom_encode)
+        onehot_tensor = torch.Tensor(mol_encode)
+        return onehot_tensor
+
+    @staticmethod
+    def get_prot_nuc_frame(token: Token, centre_atom: Atom) -> tuple[int, list[int]]:
+        """
+        Ref: AlphaFold3 SI Chapter 4.3.2
+        For proteins/DNA/RNA, we use the three atoms [N, CA, C] / [C1', C3', C4']
+
+        Args:
+            token (Token): Token object.
+            centre_atom (Atom): Biotite Atom object of Token centre atom.
+
+        Returns:
+            has_frame (int): 1 if the token has frame, 0 otherwise.
+            frame_atom_index (List[int]): The index of the atoms used to construct the frame.
+        """
+        if centre_atom.mol_type == "protein":
+            # For protein
+            abc_atom_name = ["N", "CA", "C"]
+        else:
+            # For DNA and RNA
+            abc_atom_name = [r"C1'", r"C3'", r"C4'"]
+
+        idx_in_atom_indices = []
+        for i in abc_atom_name:
+            if centre_atom.mol_type == "protein" and "N" not in token.atom_names:
+                return 0, [-1, -1, -1]
+            elif centre_atom.mol_type != "protein" and "C1'" not in token.atom_names:
+                return 0, [-1, -1, -1]
+            idx_in_atom_indices.append(token.atom_names.index(i))
+        # Protein/DNA/RNA always has frame
+        has_frame = 1
+        frame_atom_index = [token.atom_indices[i] for i in idx_in_atom_indices]
+        return has_frame, frame_atom_index
+
+    @staticmethod
+    def get_lig_frame(
+        token: Token,
+        centre_atom: Atom,
+        lig_res_ref_conf_kdtree: dict[str, tuple[KDTree, list[int]]],
+        ref_pos: torch.Tensor,
+        ref_mask: torch.Tensor,
+    ) -> tuple[int, list[int]]:
+        """
+        Ref: AlphaFold3 SI Chapter 4.3.2
+        For ligands, we use the reference conformer of the ligand to construct the frame.
+
+        Args:
+            token (Token): Token object.
+            centre_atom (Atom): Biotite Atom object of Token centre atom.
+            lig_res_ref_conf_kdtree (Dict[str, Tuple[KDTree, List[int]]]): A dictionary of KDTree objects and atom indices.
+            ref_pos (torch.Tensor): Atom positions in the reference conformer. Size=[N_atom, 3]
+            ref_mask (torch.Tensor): Mask indicating which atom slots are used in the reference conformer. Size=[N_atom]
+
+        Returns:
+            tuple[int, List[int]]:
+                has_frame (int): 1 if the token has frame, 0 otherwise.
+                frame_atom_index (List[int]): The index of the atoms used to construct the frame.
+        """
+        kdtree, atom_ids = lig_res_ref_conf_kdtree[centre_atom.ref_space_uid]
+        b_ref_pos = ref_pos[token.centre_atom_index]
+        b_idx = token.centre_atom_index
+        if kdtree is None:
+            # Atom num < 3
+            frame_atom_index = [-1, b_idx, -1]
+            has_frame = 0
+        else:
+            _dist, ind = kdtree.query([b_ref_pos], k=3)
+            a_idx, c_idx = atom_ids[ind[0][1]], atom_ids[ind[0][2]]
+            frame_atom_index = [a_idx, b_idx, c_idx]
+
+            # Check if reference confomrer vaild
+            has_frame = all([ref_mask[idx] for idx in frame_atom_index])
+
+            # Colinear check
+            if has_frame:
+                theta_degrees = angle_3p(*[ref_pos[idx] for idx in frame_atom_index])
+                if theta_degrees <= 25 or theta_degrees >= 155:
+                    has_frame = 0
+        return has_frame, frame_atom_index
+
+    @staticmethod
+    def get_token_frame(
+        token_array: TokenArray,
+        atom_array: AtomArray,
+        ref_pos: torch.Tensor,
+        ref_mask: torch.Tensor,
+    ) -> TokenArray:
+        """
+        Ref: AlphaFold3 SI Chapter 4.3.2
+        The atoms (a_i, b_i, c_i) used to construct token i’s frame depend on the chain type of i:
+        Protein tokens use their residue’s backbone (N, Cα, C),
+        while DNA and RNA tokens use (C1′, C3′, C4′) atoms of their residue.
+        All other tokens (small molecules, glycans, ions) contain only one atom per token.
+        The token atom is assigned to b_i, the closest atom to the token atom is a_i,
+        and the second closest atom to the token atom is c_i.
+        If this set of three atoms is close to colinear (less than 25 degree deviation),
+        or if three atoms do not exist in the chain (e.g. a sodium ion),
+        then the frame is marked as invalid.
+
+        Note: frames constucted from reference conformer
+
+        Args:
+            token_array (TokenArray): A list of tokens.
+            atom_array (AtomArray): An atom array.
+            ref_pos (torch.Tensor): Atom positions in the reference conformer. Size=[N_atom, 3]
+            ref_mask (torch.Tensor): Mask indicating which atom slots are used in the reference conformer. Size=[N_atom]
+
+        Returns:
+            TokenArray: A TokenArray with updated frame annotations.
+                        - has_frame: 1 if the token has frame, 0 otherwise.
+                        - frame_atom_index: The index of the atoms used to construct the frame.
+        """
+        token_array_w_frame = copy.deepcopy(token_array)
+
+        # Construct a KDTree for queries to avoid redundant distance calculations
+        lig_res_ref_conf_kdtree = {}
+        # Ligand and non-standard residues need to use ref to identify frames
+        lig_atom_array = atom_array[
+            (atom_array.mol_type == "ligand")
+            | (~np.isin(atom_array.res_name, list(STD_RESIDUES.keys())))
+        ]
+        for ref_space_uid in np.unique(lig_atom_array.ref_space_uid):
+            # The ref_space_uid is the unique identifier ID for each residue.
+            atom_ids = np.where(atom_array.ref_space_uid == ref_space_uid)[0]
+            if len(atom_ids) >= 3:
+                kdtree = KDTree(ref_pos[atom_ids], metric="euclidean")
+            else:
+                # Invalid frame
+                kdtree = None
+            lig_res_ref_conf_kdtree[ref_space_uid] = (kdtree, atom_ids)
+
+        has_frame = []
+        for token in token_array_w_frame:
+            centre_atom = atom_array[token.centre_atom_index]
+            if (
+                centre_atom.mol_type != "ligand"
+                and centre_atom.res_name in STD_RESIDUES
+            ):
+                has_frame, frame_atom_index = Featurizer.get_prot_nuc_frame(
+                    token, centre_atom
+                )
+
+            else:
+                has_frame, frame_atom_index = Featurizer.get_lig_frame(
+                    token, centre_atom, lig_res_ref_conf_kdtree, ref_pos, ref_mask
+                )
+
+            token.has_frame = has_frame
+            token.frame_atom_index = frame_atom_index
+        return token_array_w_frame
+
+    def get_token_features(self) -> dict[str, torch.Tensor]:
+        """
+        Ref: AlphaFold3 SI Chapter 2.8
+
+        Get token features.
+        The size of these features is [N_token].
+
+        Returns:
+            Dict[str, torch.Tensor]: A dict of token features.
+        """
+        token_features = {}
+
+        centre_atoms_indices = self.cropped_token_array.get_annotation(
+            "centre_atom_index"
+        )
+        centre_atoms = self.cropped_atom_array[centre_atoms_indices]
+
+        restype = centre_atoms.cano_seq_resname
+        restype_onehot = self.restype_onehot_encoded(restype)
+
+        token_features["token_index"] = torch.arange(0, len(self.cropped_token_array))
+        token_features["residue_index"] = torch.Tensor(
+            centre_atoms.res_id.astype(int)
+        ).long()
+        token_features["asym_id"] = torch.Tensor(centre_atoms.asym_id_int).long()
+        token_features["entity_id"] = torch.Tensor(centre_atoms.entity_id_int).long()
+        token_features["sym_id"] = torch.Tensor(centre_atoms.sym_id_int).long()
+        token_features["restype"] = restype_onehot
+
+        return token_features
+
+    def get_chain_perm_features(self) -> dict[str, torch.Tensor]:
+        """
+        The chain permutation use "entity_mol_id", "mol_id" and "mol_atom_index"
+        instead of the "entity_id", "asym_id" and "residue_index".
+
+        The shape of these features is [N_atom].
+
+        Returns:
+            Dict[str, torch.Tensor]: A dict of chain permutation features.
+        """
+
+        chain_perm_features = {}
+        chain_perm_features["mol_id"] = torch.Tensor(
+            self.cropped_atom_array.mol_id
+        ).long()
+        chain_perm_features["mol_atom_index"] = torch.Tensor(
+            self.cropped_atom_array.mol_atom_index
+        ).long()
+        chain_perm_features["entity_mol_id"] = torch.Tensor(
+            self.cropped_atom_array.entity_mol_id
+        ).long()
+        return chain_perm_features
+
+    def get_renamed_atom_names(self) -> np.ndarray:
+        """
+        Rename the atom names of ligands to avioid information leakage.
+
+        Returns:
+            np.ndarray: A numpy array of renamed atom names.
+        """
+        res_starts = get_residue_starts(
+            self.cropped_atom_array, add_exclusive_stop=True
+        )
+        new_atom_names = copy.deepcopy(self.cropped_atom_array.atom_name)
+        for start, stop in zip(res_starts[:-1], res_starts[1:]):
+            res_mol_type = self.cropped_atom_array.mol_type[start]
+            if res_mol_type != "ligand":
+                continue
+
+            elem_count = defaultdict(int)
+            new_res_atom_names = []
+            for elem in self.cropped_atom_array.element[start:stop]:
+                elem_count[elem] += 1
+                new_res_atom_names.append(f"{elem.upper()}{elem_count[elem]}")
+            new_atom_names[start:stop] = new_res_atom_names
+        return new_atom_names
+
+    def get_reference_features(self) -> dict[str, torch.Tensor]:
+        """
+        Ref: AlphaFold3 SI Chapter 2.8
+
+        Get reference features.
+        The size of these features is [N_atom].
+
+        Returns:
+            Dict[str, torch.Tensor]: a dict of reference features.
+        """
+        ref_pos = []
+        for ref_space_uid in np.unique(self.cropped_atom_array.ref_space_uid):
+            res_ref_pos = random_transform(
+                self.cropped_atom_array.ref_pos[
+                    self.cropped_atom_array.ref_space_uid == ref_space_uid,
+                ],
+                apply_augmentation=self.ref_pos_augment,
+                centralize=True,
+            )
+            ref_pos.append(res_ref_pos)
+        ref_pos = np.concatenate(ref_pos)
+
+        ref_features = {}
+        ref_features["ref_pos"] = torch.Tensor(ref_pos)
+        ref_features["ref_mask"] = torch.Tensor(self.cropped_atom_array.ref_mask).long()
+        ref_features["ref_element"] = Featurizer.elem_onehot_encoded(
+            self.cropped_atom_array.element
+        ).long()
+        ref_features["ref_charge"] = torch.Tensor(
+            self.cropped_atom_array.ref_charge
+        ).long()
+
+        if self.lig_atom_rename:
+            atom_names = self.get_renamed_atom_names()
+        else:
+            atom_names = self.cropped_atom_array.atom_name
+
+        ref_features["ref_atom_name_chars"] = Featurizer.ref_atom_name_chars_encoded(
+            atom_names
+        ).long()
+        ref_features["ref_space_uid"] = torch.Tensor(
+            self.cropped_atom_array.ref_space_uid
+        ).long()
+
+        token_array_with_frame = self.get_token_frame(
+            token_array=self.cropped_token_array,
+            atom_array=self.cropped_atom_array,
+            ref_pos=ref_features["ref_pos"],
+            ref_mask=ref_features["ref_mask"],
+        )
+        ref_features["has_frame"] = torch.Tensor(
+            token_array_with_frame.get_annotation("has_frame")
+        ).long()  # [N_token]
+        ref_features["frame_atom_index"] = torch.Tensor(
+            token_array_with_frame.get_annotation("frame_atom_index")
+        ).long()  # [N_token, 3]
+        return ref_features
+
+    def get_bond_features(self) -> dict[str, torch.Tensor]:
+        """
+        Ref: AlphaFold3 SI Chapter 2.8
+        A 2D matrix indicating if there is a bond between any atom in token i and token j,
+        restricted to just polymer-ligand and ligand-ligand bonds and bonds less than 2.4 Å during training.
+        The size of bond feature is [N_token, N_token].
+
+        Returns:
+            Dict[str, torch.Tensor]: A dict of bond features.
+        """
+        bond_features = {}
+        num_tokens = len(self.cropped_token_array)
+        adj_matrix = self.cropped_atom_array.bonds.adjacency_matrix().astype(int)
+
+        token_adj_matrix = np.zeros((num_tokens, num_tokens), dtype=int)
+        atom_bond_mask = adj_matrix > 0
+
+        for i in range(num_tokens):
+            atoms_i = self.cropped_token_array[i].atom_indices
+            token_i_mol_type = self.cropped_atom_array.mol_type[atoms_i[0]]
+            token_i_res_name = self.cropped_atom_array.res_name[atoms_i[0]]
+            token_i_ref_space_uid = self.cropped_atom_array.ref_space_uid[atoms_i[0]]
+            unstd_res_token_i = (
+                token_i_res_name not in STD_RESIDUES and token_i_mol_type != "ligand"
+            )
+            is_polymer_i = token_i_mol_type in ["protein", "dna", "rna"]
+
+            for j in range(i + 1, num_tokens):
+                atoms_j = self.cropped_token_array[j].atom_indices
+                token_j_mol_type = self.cropped_atom_array.mol_type[atoms_j[0]]
+                token_j_res_name = self.cropped_atom_array.res_name[atoms_j[0]]
+                token_j_ref_space_uid = self.cropped_atom_array.ref_space_uid[
+                    atoms_j[0]
+                ]
+                unstd_res_token_j = (
+                    token_j_res_name not in STD_RESIDUES
+                    and token_j_mol_type != "ligand"
+                )
+                is_polymer_j = token_j_mol_type in ["protein", "dna", "rna"]
+
+                # The polymer-polymer (std-std, std-unstd, and inter-unstd) bond will not be included in token_bonds.
+                if is_polymer_i and is_polymer_j:
+                    is_same_res = token_i_ref_space_uid == token_j_ref_space_uid
+                    unstd_res_bonds = unstd_res_token_i and unstd_res_token_j
+                    if not (is_same_res and unstd_res_bonds):
+                        continue
+
+                sub_matrix = atom_bond_mask[np.ix_(atoms_i, atoms_j)]
+                if np.any(sub_matrix):
+                    token_adj_matrix[i, j] = 1
+                    token_adj_matrix[j, i] = 1
+        bond_features["token_bonds"] = torch.Tensor(token_adj_matrix)
+        return bond_features
+
+    def get_extra_features(self) -> dict[str, torch.Tensor]:
+        """
+        Get other features not listed in AlphaFold3 SI Chapter 2.8 Table 5.
+        The size of these features is [N_atom].
+
+        Returns:
+            Dict[str, torch.Tensor]: a dict of extra features.
+        """
+        atom_to_token_idx_dict = {}
+        for idx, token in enumerate(self.cropped_token_array.tokens):
+            for atom_idx in token.atom_indices:
+                atom_to_token_idx_dict[atom_idx] = idx
+
+        # Ensure the order of the atom_to_token_idx is the same as the atom_array
+        atom_to_token_idx = [
+            atom_to_token_idx_dict[atom_idx]
+            for atom_idx in range(len(self.cropped_atom_array))
+        ]
+
+        extra_features = {}
+        extra_features["atom_to_token_idx"] = torch.Tensor(atom_to_token_idx).long()
+        extra_features["atom_to_tokatom_idx"] = torch.Tensor(
+            self.cropped_atom_array.tokatom_idx
+        ).long()
+
+        extra_features["is_protein"] = torch.Tensor(
+            self.cropped_atom_array.is_protein
+        ).long()
+        extra_features["is_ligand"] = torch.Tensor(
+            self.cropped_atom_array.is_ligand
+        ).long()
+        extra_features["is_dna"] = torch.Tensor(self.cropped_atom_array.is_dna).long()
+        extra_features["is_rna"] = torch.Tensor(self.cropped_atom_array.is_rna).long()
+        if "resolution" in self.cropped_atom_array._annot:
+            extra_features["resolution"] = torch.Tensor(
+                [self.cropped_atom_array.resolution[0]]
+            )
+        else:
+            extra_features["resolution"] = torch.Tensor([-1])
+        return extra_features
+
+    @staticmethod
+    def get_lig_pocket_mask(
+        atom_array: AtomArray, lig_label_asym_id: Union[str, list]
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Ref: AlphaFold3 Chapter Methods.Metrics
+
+        the pocket is defined as all heavy atoms within 10 Å of any heavy atom of the ligand,
+        restricted to the primary polymer chain for the ligand or modified residue being scored,
+        and further restricted to only backbone atoms for proteins. The primary polymer chain is defined variously:
+        for PoseBusters it is the protein chain with the most atoms within 10 Å of the ligand,
+        for bonded ligand scores it is the bonded polymer chain and for modified residues it
+        is the chain that the residue is contained in (minus that residue).
+
+        Args:
+            atom_array (AtomArray): atoms in the complex.
+            lig_label_asym_id (Union[str, List]): The label_asym_id of the ligand of interest.
+
+        Returns:
+            tuple[torch.Tensor, torch.Tensor]: A tuple of ligand pocket mask and pocket mask.
+        """
+
+        if isinstance(lig_label_asym_id, str):
+            lig_label_asym_ids = [lig_label_asym_id]
+        else:
+            lig_label_asym_ids = list(lig_label_asym_id)
+
+        # Get backbone mask
+        prot_backbone = (
+            atom_array.is_protein & np.isin(atom_array.atom_name, ["C", "N", "CA"])
+        ).astype(bool)
+
+        kdtree = KDTree(atom_array.coord)
+
+        ligand_mask_list = []
+        pocket_mask_list = []
+        for lig_label_asym_id in lig_label_asym_ids:
+            assert np.isin(
+                lig_label_asym_id, atom_array.label_asym_id
+            ), f"{lig_label_asym_id} is not in the label_asym_id of the cropped atom array."
+
+            ligand_mask = atom_array.label_asym_id == lig_label_asym_id
+            lig_pos = atom_array.coord[ligand_mask]
+
+            # Get atoms in 10 Angstrom radius
+            near_atom_indices = np.unique(
+                np.concatenate(kdtree.query_radius(lig_pos, 10.0))
+            )
+            near_atoms = [
+                True if i in near_atom_indices else False
+                for i in range(len(atom_array))
+            ]
+
+            # Get primary chain (protein backone in 10 Angstrom radius)
+            primary_chain_candidates = near_atoms & prot_backbone
+            primary_chain_candidates_atoms = atom_array[primary_chain_candidates]
+
+            max_atom = 0
+            primary_chain_asym_id_int = None
+            for asym_id_int in np.unique(primary_chain_candidates_atoms.asym_id_int):
+                n_atoms = np.sum(
+                    primary_chain_candidates_atoms.asym_id_int == asym_id_int
+                )
+                if n_atoms > max_atom:
+                    max_atom = n_atoms
+                    primary_chain_asym_id_int = asym_id_int
+            assert (
+                primary_chain_asym_id_int is not None
+            ), f"No primary chain found for ligand ({lig_label_asym_id=})."
+
+            pocket_mask = primary_chain_candidates & (
+                atom_array.asym_id_int == primary_chain_asym_id_int
+            )
+            ligand_mask_list.append(ligand_mask)
+            pocket_mask_list.append(pocket_mask)
+
+        ligand_mask_by_pockets = torch.Tensor(
+            np.array(ligand_mask_list).astype(int)
+        ).long()
+        pocket_mask_by_pockets = torch.Tensor(
+            np.array(pocket_mask_list).astype(int)
+        ).long()
+        return ligand_mask_by_pockets, pocket_mask_by_pockets
+
+    def get_mask_features(self) -> dict[str, torch.Tensor]:
+        """
+        Generate mask features for the cropped atom array.
+
+        Returns:
+            Dict[str, torch.Tensor]: A dictionary containing various mask features.
+        """
+        mask_features = {}
+
+        mask_features["pae_rep_atom_mask"] = torch.Tensor(
+            self.cropped_atom_array.centre_atom_mask
+        ).long()
+
+        mask_features["plddt_m_rep_atom_mask"] = torch.Tensor(
+            self.cropped_atom_array.plddt_m_rep_atom_mask
+        ).long()  # [N_atom]
+
+        mask_features["distogram_rep_atom_mask"] = torch.Tensor(
+            self.cropped_atom_array.distogram_rep_atom_mask
+        ).long()  # [N_atom]
+
+        mask_features["modified_res_mask"] = torch.Tensor(
+            self.cropped_atom_array.modified_res_mask
+        ).long()
+
+        lig_polymer_bonds = get_ligand_polymer_bond_mask(self.cropped_atom_array)
+        num_atoms = len(self.cropped_atom_array)
+        bond_mask_mat = np.zeros((num_atoms, num_atoms))
+        for i, j, _ in lig_polymer_bonds:
+            bond_mask_mat[i, j] = 1
+            bond_mask_mat[j, i] = 1
+        mask_features["bond_mask"] = torch.Tensor(
+            bond_mask_mat
+        ).long()  # [N_atom, N_atom]
+        return mask_features
+
+    def get_all_input_features(self):
+        """
+        Get input features from cropped data.
+
+        Returns:
+            Dict[str, torch.Tensor]: a dict of features.
+        """
+        features = {}
+        token_features = self.get_token_features()
+        features.update(token_features)
+
+        bond_features = self.get_bond_features()
+        features.update(bond_features)
+
+        reference_features = self.get_reference_features()
+        features.update(reference_features)
+
+        extra_features = self.get_extra_features()
+        features.update(extra_features)
+
+        chain_perm_features = self.get_chain_perm_features()
+        features.update(chain_perm_features)
+
+        mask_features = self.get_mask_features()
+        features.update(mask_features)
+        return features
+
+    def get_labels(self) -> dict[str, torch.Tensor]:
+        """
+        Get the input labels required for the training phase.
+
+        Returns:
+            Dict[str, torch.Tensor]: a dict of labels.
+        """
+
+        labels = {}
+
+        labels["coordinate"] = torch.Tensor(
+            self.cropped_atom_array.coord
+        )  # [N_atom, 3]
+
+        labels["coordinate_mask"] = torch.Tensor(
+            self.cropped_atom_array.is_resolved.astype(int)
+        ).long()  # [N_atom]
+        return labels
+
+    def get_atom_permutation_list(
+        self,
+    ) -> list[list[int]]:
+        """
+        Generate info of permutations.
+
+        Returns:
+            List[List[int]]: a list of atom permutations.
+        """
+        atom_perm_list = []
+        for i in self.cropped_atom_array.res_perm:
+            # Decode list[str] -> list[list[int]]
+            atom_perm_list.append([int(j) for j in i.split("_")])
+
+        # Atoms connected to different residue are fixed.
+        # Bonds array: [[atom_idx_i, atom_idx_j, bond_type]]
+        idx_i = self.cropped_atom_array.bonds._bonds[:, 0]
+        idx_j = self.cropped_atom_array.bonds._bonds[:, 1]
+        diff_mask = (
+            self.cropped_atom_array.ref_space_uid[idx_i]
+            != self.cropped_atom_array.ref_space_uid[idx_j]
+        )
+        inter_residue_bonds = self.cropped_atom_array.bonds._bonds[diff_mask]
+        fixed_atom_mask = np.isin(
+            np.arange(len(self.cropped_atom_array)),
+            np.unique(inter_residue_bonds[:, :2]),
+        )
+
+        # Get fixed atom permutation for each residue.
+        fixed_atom_perm_list = []
+        res_starts = get_residue_starts(
+            self.cropped_atom_array, add_exclusive_stop=True
+        )
+        for r_start, r_stop in zip(res_starts[:-1], res_starts[1:]):
+            atom_res_perm = np.array(
+                atom_perm_list[r_start:r_stop]
+            )  # [N_res_atoms, N_res_perm]
+            res_fixed_atom_mask = fixed_atom_mask[r_start:r_stop]
+
+            if np.sum(res_fixed_atom_mask) == 0:
+                # If all atoms in the residue are not fixed, e.g. ions
+                fixed_atom_perm_list.extend(atom_res_perm.tolist())
+                continue
+
+            # Create a [N_res_atoms, N_res_perm] template of indices
+            n_res_atoms, n_perm = atom_res_perm.shape
+            indices_template = (
+                atom_res_perm[:, 0].reshape(n_res_atoms, 1).repeat(n_perm, axis=1)
+            )
+
+            # Identify the column where the positions of the fixed atoms remain unchanged
+            fixed_atom_perm = atom_res_perm[
+                res_fixed_atom_mask
+            ]  # [N_fixed_res_atoms, N_res_perm]
+            fixed_indices_template = indices_template[
+                res_fixed_atom_mask
+            ]  # [N_fixed_res_atoms, N_res_perm]
+            unchanged_columns_mask = np.all(
+                fixed_atom_perm == fixed_indices_template, axis=0
+            )
+
+            # Remove the columns related to the position changes of fixed atoms.
+            fiedx_atom_res_perm = atom_res_perm[:, unchanged_columns_mask]
+            fixed_atom_perm_list.extend(fiedx_atom_res_perm.tolist())
+        return fixed_atom_perm_list
+
+    @staticmethod
+    def get_gt_full_complex_features(
+        atom_array: AtomArray,
+        cropped_atom_array: AtomArray = None,
+        get_cropped_asym_only: bool = True,
+    ) -> dict[str, torch.Tensor]:
+        """Get full ground truth complex features.
+        It is used for multi-chain permutation alignment.
+
+        Args:
+            atom_array (AtomArray): all atoms in the complex.
+            cropped_atom_array (AtomArray, optional): cropped atoms. Defaults to None.
+            get_cropped_asym_only (bool, optional): Defaults to True.
+                - If true, a chain is returned only if its asym_id (mol_id) appears in the
+                cropped_atom_array. It should be a favored setting for the spatial cropping.
+                - If false, a chain is returned if its entity_id (entity_mol_id) appears in
+                the cropped_atom_array.
+
+        Returns:
+            Dict[str, torch.Tensor]: a dictionary containing
+                coordinate, coordinate_mask, etc.
+        """
+        gt_features = {}
+
+        if cropped_atom_array is not None:
+            # Get the cropped part of gt entities
+            entity_atom_set = set(
+                zip(
+                    cropped_atom_array.entity_mol_id,
+                    cropped_atom_array.mol_atom_index,
+                )
+            )
+            mask = [
+                (entity, atom) in entity_atom_set
+                for (entity, atom) in zip(
+                    atom_array.entity_mol_id, atom_array.mol_atom_index
+                )
+            ]
+
+            if get_cropped_asym_only:
+                # Restrict to asym chains appeared in cropped_atom_array
+                asyms = np.unique(cropped_atom_array.mol_id)
+                mask = mask * np.isin(atom_array.mol_id, asyms)
+            atom_array = atom_array[mask]
+
+        gt_features["coordinate"] = torch.Tensor(atom_array.coord)
+        gt_features["coordinate_mask"] = torch.Tensor(atom_array.is_resolved).long()
+        gt_features["entity_mol_id"] = torch.Tensor(atom_array.entity_mol_id).long()
+        gt_features["mol_id"] = torch.Tensor(atom_array.mol_id).long()
+        gt_features["mol_atom_index"] = torch.Tensor(atom_array.mol_atom_index).long()
+        gt_features["pae_rep_atom_mask"] = torch.Tensor(
+            atom_array.centre_atom_mask
+        ).long()
+        return gt_features, atom_array

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/data/filter.py

@@ -0,0 +1,82 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import biotite.structure as struc
+import numpy as np
+from biotite.structure import AtomArray
+
+from protenix.data.constants import CRYSTALLIZATION_AIDS
+
+
+class Filter(object):
+    """
+    Ref: AlphaFold3 SI Chapter 2.5.4
+    """
+
+    @staticmethod
+    def remove_hydrogens(atom_array: AtomArray) -> AtomArray:
+        """remove hydrogens and deuteriums"""
+        return atom_array[~np.isin(atom_array.element, ["H", "D"])]
+
+    @staticmethod
+    def remove_water(atom_array: AtomArray) -> AtomArray:
+        """remove water (HOH) and deuterated water (DOD)"""
+        return atom_array[~np.isin(atom_array.res_name, ["HOH", "DOD"])]
+
+    @staticmethod
+    def remove_element_X(atom_array: AtomArray) -> AtomArray:
+        """
+        remove element X
+        following residues have element X:
+        - UNX: unknown one atom or ion
+        - UNL: unknown ligand, some atoms are marked as X
+        - ASX: ASP/ASN ambiguous, two ambiguous atoms are marked as X, 6 entries in the PDB
+        - GLX: GLU/GLN ambiguous, two ambiguous atoms are marked as X, 5 entries in the PDB
+        """
+        X_mask = np.zeros(len(atom_array), dtype=bool)
+        starts = struc.get_residue_starts(atom_array, add_exclusive_stop=True)
+        for start, stop in zip(starts[:-1], starts[1:]):
+            res_name = atom_array.res_name[start]
+            if res_name in ["UNX", "UNL"]:
+                X_mask[start:stop] = True
+        atom_array = atom_array[~X_mask]
+
+        # map ASX to ASP, as ASP is more symmetric than ASN
+        mask = atom_array.res_name == "ASX"
+        atom_array.res_name[mask] = "ASP"
+        atom_array.atom_name[mask & (atom_array.atom_name == "XD1")] = "OD1"
+        atom_array.atom_name[mask & (atom_array.atom_name == "XD2")] = "OD2"
+        atom_array.element[mask & (atom_array.element == "X")] = "O"
+
+        # map GLX to GLU, as GLU is more symmetric than GLN
+        mask = atom_array.res_name == "GLX"
+        atom_array.res_name[mask] = "GLU"
+        atom_array.atom_name[mask & (atom_array.atom_name == "XE1")] = "OE1"
+        atom_array.atom_name[mask & (atom_array.atom_name == "XE2")] = "OE2"
+        atom_array.element[mask & (atom_array.element == "X")] = "O"
+        return atom_array
+
+    @staticmethod
+    def remove_crystallization_aids(
+        atom_array: AtomArray, entity_poly_type: dict
+    ) -> AtomArray:
+        """remove crystallization aids, eg: SO4, GOL, etc.
+
+        Only remove crystallization aids if the chain is not polymer.
+
+        Ref: AlphaFold3 SI Chapter 2.5.4
+        """
+        non_aids_mask = ~np.isin(atom_array.res_name, CRYSTALLIZATION_AIDS)
+        poly_mask = np.isin(atom_array.label_entity_id, list(entity_poly_type.keys()))
+        return atom_array[poly_mask | non_aids_mask]

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/data/infer_data_pipeline.py

@@ -0,0 +1,220 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import logging
+import time
+import traceback
+import warnings
+from typing import Any, Mapping
+
+import torch
+from biotite.structure import AtomArray
+from torch.utils.data import DataLoader, Dataset, DistributedSampler
+
+from protenix.data.data_pipeline import DataPipeline
+from protenix.data.json_to_feature import SampleDictToFeatures
+from protenix.data.msa_featurizer import InferenceMSAFeaturizer
+from protenix.data.utils import data_type_transform, make_dummy_feature
+from protenix.utils.distributed import DIST_WRAPPER
+from protenix.utils.torch_utils import dict_to_tensor
+
+logger = logging.getLogger(__name__)
+
+warnings.filterwarnings("ignore", module="biotite")
+
+
+def get_inference_dataloader(configs: Any) -> DataLoader:
+    """
+    Creates and returns a DataLoader for inference using the InferenceDataset.
+
+    Args:
+        configs: A configuration object containing the necessary parameters for the DataLoader.
+
+    Returns:
+        A DataLoader object configured for inference.
+    """
+    inference_dataset = InferenceDataset(
+        input_json_path=configs.input_json_path,
+        dump_dir=configs.dump_dir,
+        use_msa=configs.use_msa,
+    )
+    sampler = DistributedSampler(
+        dataset=inference_dataset,
+        num_replicas=DIST_WRAPPER.world_size,
+        rank=DIST_WRAPPER.rank,
+        shuffle=False,
+    )
+    dataloader = DataLoader(
+        dataset=inference_dataset,
+        batch_size=1,
+        sampler=sampler,
+        collate_fn=lambda batch: batch,
+        num_workers=configs.num_workers,
+    )
+    return dataloader
+
+
+class InferenceDataset(Dataset):
+    def __init__(
+        self,
+        input_json_path: str,
+        dump_dir: str,
+        use_msa: bool = True,
+    ) -> None:
+
+        self.input_json_path = input_json_path
+        self.dump_dir = dump_dir
+        self.use_msa = use_msa
+        with open(self.input_json_path, "r") as f:
+            self.inputs = json.load(f)
+
+    def process_one(
+        self,
+        single_sample_dict: Mapping[str, Any],
+    ) -> tuple[dict[str, torch.Tensor], AtomArray, dict[str, float]]:
+        """
+        Processes a single sample from the input JSON to generate features and statistics.
+
+        Args:
+            single_sample_dict: A dictionary containing the sample data.
+
+        Returns:
+            A tuple containing:
+                - A dictionary of features.
+                - An AtomArray object.
+                - A dictionary of time tracking statistics.
+        """
+        # general features
+        t0 = time.time()
+        sample2feat = SampleDictToFeatures(
+            single_sample_dict,
+        )
+        features_dict, atom_array, token_array = sample2feat.get_feature_dict()
+        features_dict["distogram_rep_atom_mask"] = torch.Tensor(
+            atom_array.distogram_rep_atom_mask
+        ).long()
+        entity_poly_type = sample2feat.entity_poly_type
+        t1 = time.time()
+
+        # Msa features
+        entity_to_asym_id = DataPipeline.get_label_entity_id_to_asym_id_int(atom_array)
+        msa_features = (
+            InferenceMSAFeaturizer.make_msa_feature(
+                bioassembly=single_sample_dict["sequences"],
+                entity_to_asym_id=entity_to_asym_id,
+                token_array=token_array,
+                atom_array=atom_array,
+            )
+            if self.use_msa
+            else {}
+        )
+
+        # Make dummy features for not implemented features
+        dummy_feats = ["template"]
+        if len(msa_features) == 0:
+            dummy_feats.append("msa")
+        else:
+            msa_features = dict_to_tensor(msa_features)
+            features_dict.update(msa_features)
+        features_dict = make_dummy_feature(
+            features_dict=features_dict,
+            dummy_feats=dummy_feats,
+        )
+
+        # Transform to right data type
+        feat = data_type_transform(feat_or_label_dict=features_dict)
+
+        t2 = time.time()
+
+        data = {}
+        data["input_feature_dict"] = feat
+
+        # Add dimension related items
+        N_token = feat["token_index"].shape[0]
+        N_atom = feat["atom_to_token_idx"].shape[0]
+        N_msa = feat["msa"].shape[0]
+
+        stats = {}
+        for mol_type in ["ligand", "protein", "dna", "rna"]:
+            mol_type_mask = feat[f"is_{mol_type}"].bool()
+            stats[f"{mol_type}/atom"] = int(mol_type_mask.sum(dim=-1).item())
+            stats[f"{mol_type}/token"] = len(
+                torch.unique(feat["atom_to_token_idx"][mol_type_mask])
+            )
+
+        N_asym = len(torch.unique(data["input_feature_dict"]["asym_id"]))
+        data.update(
+            {
+                "N_asym": torch.tensor([N_asym]),
+                "N_token": torch.tensor([N_token]),
+                "N_atom": torch.tensor([N_atom]),
+                "N_msa": torch.tensor([N_msa]),
+            }
+        )
+
+        def formatted_key(key):
+            type_, unit = key.split("/")
+            if type_ == "protein":
+                type_ = "prot"
+            elif type_ == "ligand":
+                type_ = "lig"
+            else:
+                pass
+            return f"N_{type_}_{unit}"
+
+        data.update(
+            {
+                formatted_key(k): torch.tensor([stats[k]])
+                for k in [
+                    "protein/atom",
+                    "ligand/atom",
+                    "dna/atom",
+                    "rna/atom",
+                    "protein/token",
+                    "ligand/token",
+                    "dna/token",
+                    "rna/token",
+                ]
+            }
+        )
+        data.update({"entity_poly_type": entity_poly_type})
+        t3 = time.time()
+        time_tracker = {
+            "crop": t1 - t0,
+            "featurizer": t2 - t1,
+            "added_feature": t3 - t2,
+        }
+
+        return data, atom_array, time_tracker
+
+    def __len__(self) -> int:
+        return len(self.inputs)
+
+    def __getitem__(self, index: int) -> tuple[dict[str, torch.Tensor], AtomArray, str]:
+        try:
+            single_sample_dict = self.inputs[index]
+            sample_name = single_sample_dict["name"]
+            logger.info(f"Featurizing {sample_name}...")
+
+            data, atom_array, _ = self.process_one(
+                single_sample_dict=single_sample_dict
+            )
+            error_message = ""
+        except Exception as e:
+            data, atom_array = {}, None
+            error_message = f"{e}:\n{traceback.format_exc()}"
+        data["sample_name"] = single_sample_dict["name"]
+        data["sample_index"] = index
+        return data, atom_array, error_message

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/data/json_maker.py

@@ -0,0 +1,296 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import copy
+import json
+import os
+from collections import defaultdict
+
+import numpy as np
+from biotite.structure import AtomArray, get_chain_starts, get_residue_starts
+
+from protenix.data.constants import STD_RESIDUES
+from protenix.data.filter import Filter
+from protenix.data.parser import AddAtomArrayAnnot, MMCIFParser
+from protenix.data.utils import get_lig_lig_bonds, get_ligand_polymer_bond_mask
+
+
+def merge_covalent_bonds(
+    covalent_bonds: list[dict], all_entity_counts: dict[str, int]
+) -> list[dict]:
+    """
+    Merge covalent bonds with same entity and position.
+
+    Args:
+        covalent_bonds (list[dict]): A list of covalent bond dicts.
+        all_entity_counts (dict[str, int]): A dict of entity id to chain count.
+
+    Returns:
+        list[dict]: A list of merged covalent bond dicts.
+    """
+    bonds_recorder = defaultdict(list)
+    bonds_entity_counts = {}
+    for bond_dict in covalent_bonds:
+        bond_unique_string = []
+        entity_counts = (
+            all_entity_counts[str(bond_dict["left_entity"])],
+            all_entity_counts[str(bond_dict["right_entity"])],
+        )
+        for i in ["left", "right"]:
+            for j in ["entity", "position", "atom"]:
+                k = f"{i}_{j}"
+                bond_unique_string.append(str(bond_dict[k]))
+        bond_unique_string = "_".join(bond_unique_string)
+        bonds_recorder[bond_unique_string].append(bond_dict)
+        bonds_entity_counts[bond_unique_string] = entity_counts
+
+    merged_covalent_bonds = []
+    for k, v in bonds_recorder.items():
+        left_counts = bonds_entity_counts[k][0]
+        right_counts = bonds_entity_counts[k][1]
+        if left_counts == right_counts == len(v):
+            bond_dict_copy = copy.deepcopy(v[0])
+            del bond_dict_copy["left_copy"]
+            del bond_dict_copy["right_copy"]
+            merged_covalent_bonds.append(bond_dict_copy)
+        else:
+            merged_covalent_bonds.extend(v)
+    return merged_covalent_bonds
+
+
+def atom_array_to_input_json(
+    atom_array: AtomArray,
+    parser: MMCIFParser,
+    assembly_id: str = None,
+    output_json: str = None,
+    sample_name=None,
+    save_entity_and_asym_id=False,
+) -> dict:
+    """
+    Convert a Biotite AtomArray to a dict that can be used as input to the model.
+
+    Args:
+        atom_array (AtomArray): Biotite Atom array.
+        parser (MMCIFParser): Instantiated Protenix MMCIFParer.
+        assembly_id (str, optional): Assembly ID. Defaults to None.
+        output_json (str, optional): Output json file path. Defaults to None.
+        sample_name (_type_, optional): The "name" filed in json file. Defaults to None.
+        save_entity_and_asym_id (bool, optional): Whether to save entity and asym ids to json.
+                                                  Defaults to False.
+
+    Returns:
+        dict: Protenix input json dict.
+    """
+    # get sequences after modified AtomArray
+    entity_seq = parser.get_sequences(atom_array)
+
+    # add unique chain id
+    atom_array = AddAtomArrayAnnot.unique_chain_and_add_ids(atom_array)
+
+    # get lig entity sequences and position
+    label_entity_id_to_sequences = {}
+    lig_chain_ids = []  # record chain_id of the first asym chain
+    for label_entity_id in np.unique(atom_array.label_entity_id):
+        if label_entity_id not in parser.entity_poly_type:
+            current_lig_chain_ids = np.unique(
+                atom_array.chain_id[atom_array.label_entity_id == label_entity_id]
+            ).tolist()
+            lig_chain_ids += current_lig_chain_ids
+            for chain_id in current_lig_chain_ids:
+                lig_atom_array = atom_array[atom_array.chain_id == chain_id]
+                starts = get_residue_starts(lig_atom_array, add_exclusive_stop=True)
+                seq = lig_atom_array.res_name[starts[:-1]].tolist()
+                label_entity_id_to_sequences[label_entity_id] = seq
+
+    # find polymer modifications
+    entity_id_to_mod_list = {}
+    for entity_id, res_names in parser.get_poly_res_names(atom_array).items():
+        modifications_list = []
+        for idx, res_name in enumerate(res_names):
+            if res_name not in STD_RESIDUES:
+                position = idx + 1
+                modifications_list.append([position, f"CCD_{res_name}"])
+        if modifications_list:
+            entity_id_to_mod_list[entity_id] = modifications_list
+
+    chain_starts = get_chain_starts(atom_array, add_exclusive_stop=False)
+    chain_starts_atom_array = atom_array[chain_starts]
+
+    json_dict = {
+        "sequences": [],
+    }
+    if assembly_id is not None:
+        json_dict["assembly_id"] = assembly_id
+
+    unique_label_entity_id = np.unique(atom_array.label_entity_id)
+    label_entity_id_to_entity_id_in_json = {}
+    chain_id_to_copy_id_dict = {}
+    for idx, label_entity_id in enumerate(unique_label_entity_id):
+        entity_id_in_json = str(idx + 1)
+        label_entity_id_to_entity_id_in_json[label_entity_id] = entity_id_in_json
+        chain_ids_in_entity = chain_starts_atom_array.chain_id[
+            chain_starts_atom_array.label_entity_id == label_entity_id
+        ]
+        for chain_count, chain_id in enumerate(chain_ids_in_entity):
+            chain_id_to_copy_id_dict[chain_id] = chain_count + 1
+    copy_id = np.vectorize(chain_id_to_copy_id_dict.get)(atom_array.chain_id)
+    atom_array.set_annotation("copy_id", copy_id)
+
+    all_entity_counts = {}
+    skipped_entity_id = []
+    for label_entity_id in unique_label_entity_id:
+        entity_dict = {}
+        asym_chains = chain_starts_atom_array[
+            chain_starts_atom_array.label_entity_id == label_entity_id
+        ]
+        entity_type = parser.entity_poly_type.get(label_entity_id, "ligand")
+        if entity_type != "ligand":
+            if entity_type == "polypeptide(L)":
+                entity_type = "proteinChain"
+            elif entity_type == "polydeoxyribonucleotide":
+                entity_type = "dnaSequence"
+            elif entity_type == "polyribonucleotide":
+                entity_type = "rnaSequence"
+            else:
+                # DNA/RNA hybrid, polypeptide(D), etc.
+                skipped_entity_id.append(label_entity_id)
+                continue
+
+            sequence = entity_seq.get(label_entity_id)
+            entity_dict["sequence"] = sequence
+        else:
+            # ligand
+            lig_ccd = "_".join(label_entity_id_to_sequences[label_entity_id])
+            entity_dict["ligand"] = f"CCD_{lig_ccd}"
+        entity_dict["count"] = len(asym_chains)
+        all_entity_counts[label_entity_id_to_entity_id_in_json[label_entity_id]] = len(
+            asym_chains
+        )
+        if save_entity_and_asym_id:
+            entity_dict["label_entity_id"] = str(label_entity_id)
+            entity_dict["label_asym_id"] = asym_chains.label_asym_id.tolist()
+
+        # add PTM info
+        if label_entity_id in entity_id_to_mod_list:
+            modifications = entity_id_to_mod_list[label_entity_id]
+            if entity_type == "proteinChain":
+                entity_dict["modifications"] = [
+                    {"ptmPosition": position, "ptmType": mod_ccd_code}
+                    for position, mod_ccd_code in modifications
+                ]
+            else:
+                entity_dict["modifications"] = [
+                    {"basePosition": position, "modificationType": mod_ccd_code}
+                    for position, mod_ccd_code in modifications
+                ]
+
+        json_dict["sequences"].append({entity_type: entity_dict})
+
+    # skip some uncommon entities
+    atom_array = atom_array[~np.isin(atom_array.label_entity_id, skipped_entity_id)]
+
+    # add covalent bonds
+    atom_array = AddAtomArrayAnnot.add_token_mol_type(
+        atom_array, parser.entity_poly_type
+    )
+    lig_polymer_bonds = get_ligand_polymer_bond_mask(atom_array, lig_include_ions=False)
+    lig_lig_bonds = get_lig_lig_bonds(atom_array, lig_include_ions=False)
+    inter_entity_bonds = np.vstack((lig_polymer_bonds, lig_lig_bonds))
+
+    lig_indices = np.where(np.isin(atom_array.chain_id, lig_chain_ids))[0]
+    lig_bond_mask = np.any(np.isin(inter_entity_bonds[:, :2], lig_indices), axis=1)
+    inter_entity_bonds = inter_entity_bonds[lig_bond_mask]  # select bonds of ligands
+    if inter_entity_bonds.size != 0:
+        covalent_bonds = []
+        for atoms in inter_entity_bonds[:, :2]:
+            bond_dict = {}
+            for idx, i in enumerate(["left", "right"]):
+                atom = atom_array[atoms[idx]]
+                positon = atom.res_id
+                bond_dict[f"{i}_entity"] = int(
+                    label_entity_id_to_entity_id_in_json[atom.label_entity_id]
+                )
+                bond_dict[f"{i}_position"] = int(positon)
+                bond_dict[f"{i}_atom"] = atom.atom_name
+                bond_dict[f"{i}_copy"] = int(atom.copy_id)
+
+            covalent_bonds.append(bond_dict)
+
+        # merge covalent_bonds for same entity
+        merged_covalent_bonds = merge_covalent_bonds(covalent_bonds, all_entity_counts)
+        json_dict["covalent_bonds"] = merged_covalent_bonds
+
+    json_dict["name"] = sample_name
+
+    if output_json is not None:
+        with open(output_json, "w") as f:
+            json.dump([json_dict], f, indent=4)
+    return json_dict
+
+
+def cif_to_input_json(
+    mmcif_file: str,
+    assembly_id: str = None,
+    altloc="first",
+    output_json: str = None,
+    sample_name=None,
+    save_entity_and_asym_id=False,
+) -> dict:
+    """
+    Convert mmcif file to Protenix input json file.
+
+    Args:
+        mmcif_file (str): mmCIF file path.
+        assembly_id (str, optional): Assembly ID. Defaults to None.
+        altloc (str, optional): Altloc selection. Defaults to "first".
+        output_json (str, optional): Output json file path. Defaults to None.
+        sample_name (_type_, optional): The "name" filed in json file. Defaults to None.
+        save_entity_and_asym_id (bool, optional): Whether to save entity and asym ids to json.
+                                                  Defaults to False.
+
+    Returns:
+        dict: Protenix input json dict.
+    """
+    parser = MMCIFParser(mmcif_file)
+    atom_array = parser.get_structure(altloc, model=1, bond_lenth_threshold=None)
+
+    # remove HOH from entities
+    atom_array = Filter.remove_water(atom_array)
+    atom_array = Filter.remove_hydrogens(atom_array)
+    atom_array = parser.mse_to_met(atom_array)
+    atom_array = Filter.remove_element_X(atom_array)
+
+    # remove crystallization_aids
+    if any(["DIFFRACTION" in m for m in parser.methods]):
+        atom_array = Filter.remove_crystallization_aids(
+            atom_array, parser.entity_poly_type
+        )
+
+    if assembly_id is not None:
+        # expand created AtomArray by expand bioassembly
+        atom_array = parser.expand_assembly(atom_array, assembly_id)
+
+    if sample_name is None:
+        sample_name = os.path.basename(mmcif_file).split(".")[0]
+
+    json_dict = atom_array_to_input_json(
+        atom_array,
+        parser,
+        assembly_id,
+        output_json,
+        sample_name,
+        save_entity_and_asym_id=save_entity_and_asym_id,
+    )
+    return json_dict

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/data/json_parser.py

@@ -0,0 +1,608 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import copy
+import logging
+import random
+import warnings
+from collections import Counter
+from typing import Any
+
+import biotite.structure as struc
+import numpy as np
+from biotite.structure import AtomArray
+from rdkit import Chem
+from rdkit.Chem import AllChem
+
+from protenix.data import ccd
+
+logger = logging.getLogger(__name__)
+
+
+DNA_1to3 = {
+    "A": "DA",
+    "G": "DG",
+    "C": "DC",
+    "T": "DT",
+    "X": "DN",
+    "I": "DI",  # eg: pdb 114d
+    "N": "DN",  # eg: pdb 7r6t-3DR
+    "U": "DU",  # eg: pdb 7sd8
+}
+RNA_1to3 = {
+    "A": "A",
+    "G": "G",
+    "C": "C",
+    "U": "U",
+    "X": "N",
+    "I": "I",  # eg: pdb 7wv5
+    "N": "N",
+}
+
+PROTEIN_1to3 = {
+    "A": "ALA",
+    "R": "ARG",
+    "N": "ASN",
+    "D": "ASP",
+    "C": "CYS",
+    "Q": "GLN",
+    "E": "GLU",
+    "G": "GLY",
+    "H": "HIS",
+    "I": "ILE",
+    "L": "LEU",
+    "K": "LYS",
+    "M": "MET",
+    "F": "PHE",
+    "P": "PRO",
+    "S": "SER",
+    "T": "THR",
+    "W": "TRP",
+    "Y": "TYR",
+    "V": "VAL",
+    "X": "UNK",
+}
+
+
+def add_reference_features(atom_array: AtomArray) -> AtomArray:
+    """
+    Add reference features of each resiude to atom_array
+
+    Args:
+        atom_array (AtomArray): biotite AtomArray
+
+    Returns:
+        AtomArray: biotite AtomArray with reference features
+        - ref_pos: reference conformer atom positions
+        - ref_charge (n): reference conformer atom charges
+        - ref_mask: reference conformer atom masks
+    """
+    atom_count = len(atom_array)
+    ref_pos = np.zeros((atom_count, 3), dtype=np.float32)
+    ref_charge = np.zeros(atom_count, dtype=int)
+    ref_mask = np.zeros(atom_count, dtype=int)
+
+    starts = struc.get_residue_starts(atom_array, add_exclusive_stop=True)
+    for start, stop in zip(starts[:-1], starts[1:]):
+        res_name = atom_array.res_name[start]
+        if res_name == "UNL":
+            # UNL is smiles ligand, copy info from atom_array
+            ref_pos[start:stop] = atom_array.coord[start:stop]
+            ref_charge[start:stop] = atom_array.charge[start:stop]
+            ref_mask[start:stop] = 1
+            continue
+
+        ref_info = ccd.get_ccd_ref_info(res_name)
+        if ref_info:
+            atom_sub_idx = [
+                *map(ref_info["atom_map"].get, atom_array.atom_name[start:stop])
+            ]
+            ref_pos[start:stop] = ref_info["coord"][atom_sub_idx]
+            ref_charge[start:stop] = ref_info["charge"][atom_sub_idx]
+            ref_mask[start:stop] = ref_info["mask"][atom_sub_idx]
+        else:
+            logging.warning(f"no reference info for {res_name}")
+
+    atom_array.set_annotation("ref_pos", ref_pos)
+    atom_array.set_annotation("ref_charge", ref_charge)
+    atom_array.set_annotation("ref_mask", ref_mask)
+    return atom_array
+
+
+def _remove_non_std_ccd_leaving_atoms(atom_array: AtomArray) -> AtomArray:
+    """
+    Check polymer connections and remove non-standard leaving atoms
+
+    Args:
+        atom_array (AtomArray): biotite AtomArray
+
+    Returns:
+        AtomArray: biotite AtomArray with leaving atoms removed.
+    """
+    connected = np.zeros(atom_array.res_id[-1], dtype=bool)
+    for i, j, t in atom_array.bonds._bonds:
+        if abs(atom_array.res_id[i] - atom_array.res_id[j]) == 1:
+            connected[atom_array.res_id[[i, j]].min()] = True
+
+    leaving_atoms = np.zeros(len(atom_array), dtype=bool)
+    for res_id, conn in enumerate(connected):
+        if res_id == 0 or conn:
+            continue
+
+        # Res_id start from 1
+        res_name_i = atom_array.res_name[atom_array.res_id == res_id][0]
+        res_name_j = atom_array.res_name[atom_array.res_id == res_id + 1][0]
+        warnings.warn(
+            f"No C-N or O3'-P bond between residue {res_name_i}({res_id}) and residue {res_name_j}({res_id+1}). \n"
+            f"all leaving atoms will be removed for both residues."
+        )
+        for idx, res_name in zip([res_id, res_id + 1], [res_name_i, res_name_j]):
+            staying_atoms = ccd.get_component_atom_array(
+                res_name, keep_leaving_atoms=False, keep_hydrogens=False
+            ).atom_name
+            if idx == 1 and ccd.get_mol_type(res_name) in ("dna", "rna"):
+                staying_atoms = np.append(staying_atoms, ["OP3"])
+            if idx == atom_array.res_id[-1] and ccd.get_mol_type(res_name) == "protein":
+                staying_atoms = np.append(staying_atoms, ["OXT"])
+            leaving_atoms |= (atom_array.res_id == idx) & (
+                ~np.isin(atom_array.atom_name, staying_atoms)
+            )
+    return atom_array[~leaving_atoms]
+
+
+def find_range_by_index(starts: np.ndarray, atom_index: int) -> tuple[int, int]:
+    """
+    Find the residue range of an atom index
+
+    Args:
+        starts (np.ndarray): Residue starts or Chain starts with exclusive stop.
+        atom_index (int): Atom index.
+
+    Returns:
+        tuple[int, int]: range (start, stop).
+    """
+    for start, stop in zip(starts[:-1], starts[1:]):
+        if start <= atom_index < stop:
+            return start, stop
+    raise ValueError(f"atom_index {atom_index} not found in starts {starts}")
+
+
+def remove_leaving_atoms(atom_array: AtomArray, bond_count: dict) -> AtomArray:
+    """
+    Remove leaving atoms based on ccd info
+
+    Args:
+        atom_array (AtomArray): Biotite Atom array.
+        bond_count (dict): atom index -> Bond count.
+
+    Returns:
+        AtomArray: Biotite Atom array with leaving atoms removed.
+    """
+    remove_indices = []
+    res_starts = struc.get_residue_starts(atom_array, add_exclusive_stop=True)
+    for centre_idx, b_count in bond_count.items():
+        res_name = atom_array.res_name[centre_idx]
+        centre_name = atom_array.atom_name[centre_idx]
+
+        comp = ccd.get_component_atom_array(
+            res_name, keep_leaving_atoms=True, keep_hydrogens=False
+        )
+        if comp is None:
+            continue
+
+        leaving_groups = comp.central_to_leaving_groups.get(centre_name)
+        if leaving_groups is None:
+            continue
+
+        if b_count > len(leaving_groups):
+            warnings.warn(
+                f"centre atom {centre_name=} {res_name=} {centre_idx=} has {b_count} inter residue bonds, greater than number of leaving groups:{leaving_groups}, remove all leaving atoms.\n"
+                f"atom info: {atom_array[centre_idx]=}"
+            )
+            remove_groups = leaving_groups
+        else:
+            remove_groups = random.sample(leaving_groups, b_count)
+
+        start, stop = find_range_by_index(res_starts, centre_idx)
+
+        # Find leaving atom indices
+        for group in remove_groups:
+            for atom_name in group:
+                leaving_idx = np.where(atom_array.atom_name[start:stop] == atom_name)[0]
+                if len(leaving_idx) == 0:
+                    logging.info(f"{atom_name=} not found in residue {res_name}, ")
+                    continue
+
+                remove_indices.append(leaving_idx[0] + start)
+
+    if not remove_indices:
+        return atom_array
+
+    keep_mask = np.ones(len(atom_array), dtype=bool)
+    keep_mask[remove_indices] = False
+    return atom_array[keep_mask]
+
+
+def _add_bonds_to_terminal_residues(atom_array: AtomArray) -> AtomArray:
+    """
+    Add bonds to terminal residues (eg: ACE, NME)
+
+    Args:
+        atom_array (AtomArray): Biotite AtomArray
+
+    Returns:
+        AtomArray: Biotite AtomArray with non-standard polymer bonds
+    """
+
+    if atom_array.res_name[0] == "ACE":
+        term_res_idx = atom_array.res_id[0]
+        next_res_idx = term_res_idx + 1
+        term_atom_idx = np.where(
+            (atom_array.res_id == term_res_idx) & (atom_array.atom_name == "C")
+        )[0]
+        next_atom_idx = np.where(
+            (atom_array.res_id == next_res_idx) & (atom_array.atom_name == "N")
+        )[0]
+        if len(term_atom_idx) > 0 and len(next_atom_idx) > 0:
+            atom_array.bonds.add_bond(term_atom_idx[0], next_atom_idx[0], 1)
+
+    if atom_array.res_name[-1] == "NME":
+        term_res_idx = atom_array.res_id[-1]
+        prev_res_idx = term_res_idx - 1
+        term_atom_idx = np.where(
+            (atom_array.res_id == term_res_idx) & (atom_array.atom_name == "N")
+        )[0]
+        prev_atom_idx = np.where(
+            (atom_array.res_id == prev_res_idx) & (atom_array.atom_name == "C")
+        )[0]
+        if len(prev_atom_idx) > 0 and len(term_atom_idx) > 0:
+            atom_array.bonds.add_bond(prev_atom_idx[0], term_atom_idx[0], 1)
+
+    return atom_array
+
+
+def _build_polymer_atom_array(ccd_seqs: list[str]) -> tuple[AtomArray, struc.BondList]:
+    """
+    Build polymer atom_array from ccd codes, but not remove leaving atoms
+
+    Args:
+        ccd_seqs: a list of ccd code in sequence, ["MET", "ALA"] or ["DA", "DT"]
+
+    Returns:
+        AtomArray: Biotite AtomArray of chain
+        BondList: Biotite BondList of polymer bonds (C-N or O3'-P)
+    """
+    chain = struc.AtomArray(0)
+    for res_id, res_name in enumerate(ccd_seqs):
+        # Keep all leaving atoms, will remove leaving atoms later
+        residue = ccd.get_component_atom_array(
+            res_name, keep_leaving_atoms=True, keep_hydrogens=False
+        )
+        residue.res_id[:] = res_id + 1
+        chain += residue
+    res_starts = struc.get_residue_starts(chain, add_exclusive_stop=True)
+    polymer_bonds = ccd._connect_inter_residue(chain, res_starts)
+
+    if chain.bonds is None:
+        chain.bonds = polymer_bonds
+    else:
+        chain.bonds = chain.bonds.merge(polymer_bonds)
+
+    chain = _add_bonds_to_terminal_residues(chain)
+
+    bond_count = {}
+    for i, j, t in polymer_bonds._bonds:
+        bond_count[i] = bond_count.get(i, 0) + 1
+        bond_count[j] = bond_count.get(j, 0) + 1
+
+    chain = remove_leaving_atoms(chain, bond_count)
+
+    chain = _remove_non_std_ccd_leaving_atoms(chain)
+
+    return chain
+
+
+def build_polymer(entity_info: dict) -> dict:
+    """
+    Build a polymer from a polymer info dict
+    example: {
+        "name": "polymer",
+        "sequence": "GPDSMEEVVVPEEPPKLVSALATYVQQERLCTMFLSIANKLLPLKP",
+        "count": 1
+        }
+
+    Args:
+        item (dict): polymer info dict
+
+    Returns:
+        dict: {"atom_array": biotite_AtomArray_object}
+    """
+    poly_type, info = list(entity_info.items())[0]
+    if poly_type == "proteinChain":
+        ccd_seqs = [PROTEIN_1to3[x] for x in info["sequence"]]
+        if modifications := info.get("modifications"):
+            for m in modifications:
+                index = m["ptmPosition"] - 1
+                mtype = m["ptmType"]
+                if mtype.startswith("CCD_"):
+                    ccd_seqs[index] = mtype[4:]
+                else:
+                    raise ValueError(f"unknown modification type: {mtype}")
+        if glycans := info.get("glycans"):
+            logging.warning(f"glycans not supported: {glycans}")
+        chain_array = _build_polymer_atom_array(ccd_seqs)
+
+    elif poly_type in ("dnaSequence", "rnaSequence"):
+        map_1to3 = DNA_1to3 if poly_type == "dnaSequence" else RNA_1to3
+        ccd_seqs = [map_1to3[x] for x in info["sequence"]]
+        if modifications := info.get("modifications"):
+            for m in modifications:
+                index = m["basePosition"] - 1
+                mtype = m["modificationType"]
+                if mtype.startswith("CCD_"):
+                    ccd_seqs[index] = mtype[4:]
+                else:
+                    raise ValueError(f"unknown modification type: {mtype}")
+        chain_array = _build_polymer_atom_array(ccd_seqs)
+
+    else:
+        raise ValueError(
+            "polymer type must be proteinChain, dnaSequence or rnaSequence"
+        )
+    chain_array = add_reference_features(chain_array)
+    return {"atom_array": chain_array}
+
+
+def rdkit_mol_to_atom_array(mol: Chem.Mol, removeHs: bool = True) -> AtomArray:
+    """
+    Convert rdkit mol to biotite AtomArray
+
+    Args:
+        mol (Chem.Mol): rdkit mol
+        removeHs (bool): whether to remove hydrogens in atom_array
+
+    Returns:
+        AtomArray: biotite AtomArray
+    """
+    atom_count = mol.GetNumAtoms()
+    atom_array = AtomArray(atom_count)
+    atom_array.hetero[:] = True
+    atom_array.res_name[:] = "UNL"
+    atom_array.add_annotation("charge", int)
+
+    conf = mol.GetConformer()
+    coord = conf.GetPositions()
+
+    element_count = Counter()
+    for i, atom in enumerate(mol.GetAtoms()):
+        element = atom.GetSymbol().upper()
+        element_count[element] += 1
+        atom_name = f"{element}{element_count[element]}"
+
+        atom.SetProp("name", atom_name)
+
+        atom_array.atom_name[i] = atom_name
+        atom_array.element[i] = element
+        atom_array.charge[i] = atom.GetFormalCharge()
+        atom_array.coord[i, :] = coord[i, :]
+
+    bonds = []
+    for bond in mol.GetBonds():
+        bonds.append([bond.GetBeginAtomIdx(), bond.GetEndAtomIdx()])
+    atom_array.bonds = struc.BondList(atom_count, np.array(bonds))
+    if removeHs:
+        atom_array = atom_array[atom_array.element != "H"]
+    return atom_array
+
+
+def rdkit_mol_to_atom_info(mol: Chem.Mol) -> dict[str, Any]:
+    """
+    Convert RDKit Mol to atom_info dict.
+
+    Args:
+        mol (Chem.Mol): rdkit mol
+
+    Returns:
+        dict: info of atoms
+        example: {
+            "atom_array": biotite_AtomArray_object,
+            "atom_map_to_atom_name": {1: "C2"}, # only for smiles
+            }
+    """
+    atom_info = {}
+    atom_map_to_atom_name = {}
+    atom_idx_to_atom_name = {}
+
+    element_count = Counter()
+    for atom in mol.GetAtoms():
+        element = atom.GetSymbol().upper()
+        element_count[element] += 1
+        atom_name = f"{element}{element_count[element]}"
+        atom.SetProp("name", atom_name)
+        if atom.GetAtomMapNum() != 0:
+            atom_map_to_atom_name[atom.GetAtomMapNum()] = atom_name
+        atom_idx_to_atom_name[atom.GetIdx()] = atom_name
+
+    if atom_map_to_atom_name:
+        # Atom map for input SMILES
+        atom_info["atom_map_to_atom_name"] = atom_map_to_atom_name
+    else:
+        # Atom index for input file
+        atom_info["atom_map_to_atom_name"] = atom_idx_to_atom_name
+
+    # Atom_array without hydrogens
+    atom_info["atom_array"] = rdkit_mol_to_atom_array(mol, removeHs=True)
+    return atom_info
+
+
+def lig_file_to_atom_info(lig_file_path: str) -> dict[str, Any]:
+    """
+    Convert ligand file to biotite AtomArray.
+
+    Args:
+        lig_file_path (str): ligand file path with one of the following suffixes: [mol, mol2, sdf, pdb]
+
+    Returns:
+        dict: info of atoms
+        example: {
+            "atom_array": biotite_AtomArray_object,
+            "atom_map_to_atom_name": {1: "C2"}, # only for smiles
+            }
+    """
+    if lig_file_path.endswith(".mol"):
+        mol = Chem.MolFromMolFile(lig_file_path)
+    elif lig_file_path.endswith(".sdf"):
+        suppl = Chem.SDMolSupplier(lig_file_path)
+        mol = next(suppl)
+    elif lig_file_path.endswith(".pdb"):
+        mol = Chem.MolFromPDBFile(lig_file_path)
+    elif lig_file_path.endswith(".mol2"):
+        mol = Chem.MolFromMol2File(lig_file_path)
+    else:
+        raise ValueError(f"Invalid ligand file type: .{lig_file_path.split('.')[-1]}")
+    assert (
+        mol is not None
+    ), f"Failed to retrieve molecule from file, invalid ligand file: {lig_file_path}. \
+        Please provide a file with one of the following suffixes: [mol, mol2, sdf, pdb]."
+
+    assert (
+        mol.GetConformer().Is3D()
+    ), f"3D conformer not found in ligand file: {lig_file_path}"
+    atom_info = rdkit_mol_to_atom_info(mol)
+    return atom_info
+
+
+def smiles_to_atom_info(smiles: str) -> dict:
+    """
+    Convert smiles to atom_array, and atom_map_to_atom_name
+
+    Args:
+        smiles (str): smiles string, like "CCCC", or "[C:1]NC(=O)" (use num to label covalent bond atom.)
+
+    Returns:
+        dict: info of atoms
+        example: {
+            "atom_array": biotite_AtomArray_object,
+            "atom_map_to_atom_name": {1: "C2"}, # only for smiles
+            }
+    """
+    atom_info = {}
+    mol = Chem.MolFromSmiles(smiles)
+    mol = Chem.AddHs(mol)
+    ret_code = AllChem.EmbedMolecule(mol)
+    assert ret_code == 0, f"Conformer generation failed for input SMILES: {smiles}"
+    atom_info = rdkit_mol_to_atom_info(mol)
+    return atom_info
+
+
+def build_ligand(entity_info: dict) -> dict:
+    """
+    Build a ligand from a ligand entity info dict
+    example1: {
+        "ligand": {
+          "ligand": "CCD_ATP",
+          "count": 1
+        }
+      },
+    example2:{
+        "ligand": {
+          "ligand": "CCC=O",  # smiles
+          "count": 1
+        }
+      },
+    example3:{
+        "ion": {
+          "ion": "NA",
+          "count": 3
+        }
+      },
+
+    Args:
+        entity_info (dict): ligand entity info
+
+    Returns:
+        dict: info of atoms
+        example: {
+            "atom_array": biotite_AtomArray_object,
+            "index_to_atom_name": {1: "C2"}, # only for smiles
+            }
+    """
+    if info := entity_info.get("ion"):
+        ccd_code = [info["ion"]]
+    elif info := entity_info.get("ligand"):
+        ligand_str = info["ligand"]
+        if ligand_str.startswith("CCD_"):
+            ccd_code = ligand_str[4:].split("_")
+        else:
+            ccd_code = None
+
+    atom_info = {}
+    if ccd_code is not None:
+        atom_array = AtomArray(0)
+        res_ids = []
+        for idx, code in enumerate(ccd_code):
+            ccd_atom_array = ccd.get_component_atom_array(
+                code, keep_leaving_atoms=True, keep_hydrogens=False
+            )
+            atom_array += ccd_atom_array
+            res_id = idx + 1
+            res_ids += [res_id] * len(ccd_atom_array)
+        atom_info["atom_array"] = atom_array
+        atom_info["atom_array"].res_id[:] = res_ids
+    else:
+        if info["ligand"].startswith("FILE_"):
+            lig_file_path = ligand_str[5:]
+            atom_info = lig_file_to_atom_info(lig_file_path)
+        else:
+            atom_info = smiles_to_atom_info(ligand_str)
+        atom_info["atom_array"].res_id[:] = 1
+    atom_info["atom_array"] = add_reference_features(atom_info["atom_array"])
+    return atom_info
+
+
+def add_entity_atom_array(single_job_dict: dict) -> dict:
+    """
+    Add atom_array to each entity in single_job_dict
+
+    Args:
+        single_job_dict (dict): input job dict
+
+    Returns:
+        dict: deepcopy and updated job dict with atom_array
+    """
+    single_job_dict = copy.deepcopy(single_job_dict)
+    sequences = single_job_dict["sequences"]
+    smiles_ligand_count = 0
+    for entity_info in sequences:
+        if info := entity_info.get("proteinChain"):
+            atom_info = build_polymer(entity_info)
+        elif info := entity_info.get("dnaSequence"):
+            atom_info = build_polymer(entity_info)
+        elif info := entity_info.get("rnaSequence"):
+            atom_info = build_polymer(entity_info)
+        elif info := entity_info.get("ligand"):
+            atom_info = build_ligand(entity_info)
+            if not info["ligand"].startswith("CCD_"):
+                smiles_ligand_count += 1
+                assert smiles_ligand_count <= 99, "too many smiles ligands"
+                # use lower case res_name (l01, l02, ..., l99) to avoid conflict with CCD code
+                atom_info["atom_array"].res_name[:] = f"l{smiles_ligand_count:02d}"
+        elif info := entity_info.get("ion"):
+            atom_info = build_ligand(entity_info)
+        else:
+            raise ValueError(
+                "entity type must be proteinChain, dnaSequence, rnaSequence, ligand or ion"
+            )
+        info.update(atom_info)
+    return single_job_dict

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/data/json_to_feature.py

@@ -0,0 +1,310 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import copy
+import logging
+
+import numpy as np
+import torch
+from biotite.structure import AtomArray
+
+from protenix.data.featurizer import Featurizer
+from protenix.data.json_parser import add_entity_atom_array, remove_leaving_atoms
+from protenix.data.parser import AddAtomArrayAnnot
+from protenix.data.tokenizer import AtomArrayTokenizer, TokenArray
+from protenix.data.utils import int_to_letters
+
+logger = logging.getLogger(__name__)
+
+
+class SampleDictToFeatures:
+    def __init__(self, single_sample_dict):
+        self.single_sample_dict = single_sample_dict
+        self.input_dict = add_entity_atom_array(single_sample_dict)
+        self.entity_poly_type = self.get_entity_poly_type()
+
+    def get_entity_poly_type(self) -> dict[str, str]:
+        """
+        Get the entity type for each entity.
+
+        Allowed Value for "_entity_poly.type":
+        · cyclic-pseudo-peptide
+        · other
+        · peptide nucleic acid
+        · polydeoxyribonucleotide
+        · polydeoxyribonucleotide/polyribonucleotide hybrid
+        · polypeptide(D)
+        · polypeptide(L)
+        · polyribonucleotide
+
+        Returns:
+            dict[str, str]: a dict of polymer entity id to entity type.
+        """
+        entity_type_mapping_dict = {
+            "proteinChain": "polypeptide(L)",
+            "dnaSequence": "polydeoxyribonucleotide",
+            "rnaSequence": "polyribonucleotide",
+        }
+        entity_poly_type = {}
+        for idx, type2entity_dict in enumerate(self.input_dict["sequences"]):
+            assert len(type2entity_dict) == 1, "Only one entity type is allowed."
+            for entity_type, entity in type2entity_dict.items():
+                if "sequence" in entity:
+                    assert entity_type in [
+                        "proteinChain",
+                        "dnaSequence",
+                        "rnaSequence",
+                    ], 'The "sequences" field accepts only these entity types: ["proteinChain", "dnaSequence", "rnaSequence"].'
+                    entity_poly_type[str(idx + 1)] = entity_type_mapping_dict[
+                        entity_type
+                    ]
+        return entity_poly_type
+
+    def build_full_atom_array(self) -> AtomArray:
+        """
+        By assembling the AtomArray of each entity, a complete AtomArray is created.
+
+        Returns:
+            AtomArray: Biotite Atom array.
+        """
+        atom_array = None
+        asym_chain_idx = 0
+        for idx, type2entity_dict in enumerate(self.input_dict["sequences"]):
+            for entity_type, entity in type2entity_dict.items():
+                entity_id = str(idx + 1)
+
+                entity_atom_array = None
+                for asym_chain_count in range(1, entity["count"] + 1):
+                    asym_id_str = int_to_letters(asym_chain_idx + 1)
+                    asym_chain = copy.deepcopy(entity["atom_array"])
+                    chain_id = [asym_id_str] * len(asym_chain)
+                    copy_id = [asym_chain_count] * len(asym_chain)
+                    asym_chain.set_annotation("label_asym_id", chain_id)
+                    asym_chain.set_annotation("auth_asym_id", chain_id)
+                    asym_chain.set_annotation("chain_id", chain_id)
+                    asym_chain.set_annotation("label_seq_id", asym_chain.res_id)
+                    asym_chain.set_annotation("copy_id", copy_id)
+                    # breakpoint()
+                    if entity_atom_array is None:
+                        entity_atom_array = asym_chain
+                    else:
+                        entity_atom_array += asym_chain
+                    asym_chain_idx += 1
+
+                entity_atom_array.set_annotation(
+                    "label_entity_id", [entity_id] * len(entity_atom_array)
+                )
+
+                if entity_type in ["proteinChain", "dnaSequence", "rnaSequence"]:
+                    entity_atom_array.hetero[:] = False
+                else:
+                    entity_atom_array.hetero[:] = True
+
+                if atom_array is None:
+                    atom_array = entity_atom_array
+                else:
+                    atom_array += entity_atom_array
+        return atom_array
+
+    @staticmethod
+    def get_a_bond_atom(
+        atom_array: AtomArray,
+        entity_id: int,
+        position: int,
+        atom_name: str,
+        copy_id: int = None,
+    ) -> np.ndarray:
+        """
+        Get the atom index of a bond atom.
+
+        Args:
+            atom_array (AtomArray): Biotite Atom array.
+            entity_id (int): Entity id.
+            position (int): Residue index of the atom.
+            atom_name (str): Atom name.
+            copy_id (copy_id): A asym chain id in N copies of an entity.
+
+        Returns:
+            np.ndarray: Array of indices for specified atoms on each asym chain.
+        """
+        entity_mask = atom_array.label_entity_id == str(entity_id)
+        position_mask = atom_array.res_id == int(position)
+        atom_name_mask = atom_array.atom_name == str(atom_name)
+
+        if copy_id is not None:
+            copy_mask = atom_array.copy_id == int(copy_id)
+            mask = entity_mask & position_mask & atom_name_mask & copy_mask
+        else:
+            mask = entity_mask & position_mask & atom_name_mask
+        atom_indices = np.where(mask)[0]
+        return atom_indices
+
+    def add_bonds_between_entities(self, atom_array: AtomArray) -> AtomArray:
+        """
+        Based on the information in the "covalent_bonds",
+        add a bond between specified atoms on each pair of asymmetric chains of the two entities.
+        Note that this requires the number of asymmetric chains in both entities to be equal.
+
+        Args:
+            atom_array (AtomArray): Biotite Atom array.
+
+        Returns:
+            AtomArray: Biotite Atom array with bonds added.
+        """
+        if "covalent_bonds" not in self.input_dict:
+            return atom_array
+
+        bond_count = {}
+        for bond_info_dict in self.input_dict["covalent_bonds"]:
+            bond_atoms = []
+            for i in ["left", "right"]:
+                entity_id = int(bond_info_dict[f"{i}_entity"])
+                copy_id = int(bond_info_dict.get(f"{i}_copy"))
+                position = int(bond_info_dict[f"{i}_position"])
+                atom_name = bond_info_dict[f"{i}_atom"]
+
+                if isinstance(atom_name, str):
+                    if atom_name.isdigit():
+                        # Convert SMILES atom index to int
+                        atom_name = int(atom_name)
+
+                if isinstance(atom_name, int):
+                    # Convert AtomMap in SMILES to atom name in AtomArray
+                    entity_dict = self.input_dict["sequences"][
+                        int(entity_id - 1)
+                    ].values()
+                    assert "atom_map_to_atom_name" in entity_dict
+                    atom_name = entity_dict["atom_map_to_atom_name"][atom_name]
+
+                # Get bond atoms by entity_id, position, atom_name
+                atom_indices = self.get_a_bond_atom(
+                    atom_array, entity_id, position, atom_name, copy_id
+                )
+                assert (
+                    atom_indices.size > 0
+                ), f"No atom found for {atom_name} in entity {entity_id} at position {position}."
+                bond_atoms.append(atom_indices)
+
+            assert len(bond_atoms[0]) == len(
+                bond_atoms[1]
+            ), f'Can not create bonds because the "count" of entity {bond_info_dict["left_entity"]} \
+                and {bond_info_dict["right_entity"]} are not equal. '
+
+            # Create bond between each asym chain pair
+            for atom_idx1, atom_idx2 in zip(bond_atoms[0], bond_atoms[1]):
+                atom_array.bonds.add_bond(atom_idx1, atom_idx2, 1)
+                bond_count[atom_idx1] = bond_count.get(atom_idx1, 0) + 1
+                bond_count[atom_idx2] = bond_count.get(atom_idx2, 0) + 1
+
+        atom_array = remove_leaving_atoms(atom_array, bond_count)
+
+        return atom_array
+
+    @staticmethod
+    def add_atom_array_attributes(
+        atom_array: AtomArray, entity_poly_type: dict[str, str]
+    ) -> AtomArray:
+        """
+        Add attributes to the Biotite AtomArray.
+
+        Args:
+            atom_array (AtomArray): Biotite Atom array.
+            entity_poly_type (dict[str, str]): a dict of polymer entity id to entity type.
+
+        Returns:
+            AtomArray: Biotite Atom array with attributes added.
+        """
+        atom_array = AddAtomArrayAnnot.add_token_mol_type(atom_array, entity_poly_type)
+        atom_array = AddAtomArrayAnnot.add_centre_atom_mask(atom_array)
+        atom_array = AddAtomArrayAnnot.add_atom_mol_type_mask(atom_array)
+        atom_array = AddAtomArrayAnnot.add_distogram_rep_atom_mask(atom_array)
+        atom_array = AddAtomArrayAnnot.add_plddt_m_rep_atom_mask(atom_array)
+        atom_array = AddAtomArrayAnnot.add_cano_seq_resname(atom_array)
+        atom_array = AddAtomArrayAnnot.add_tokatom_idx(atom_array)
+        atom_array = AddAtomArrayAnnot.add_modified_res_mask(atom_array)
+        atom_array = AddAtomArrayAnnot.unique_chain_and_add_ids(atom_array)
+        atom_array = AddAtomArrayAnnot.find_equiv_mol_and_assign_ids(
+            atom_array, check_final_equiv=False
+        )
+        atom_array = AddAtomArrayAnnot.add_ref_space_uid(atom_array)
+        return atom_array
+
+    @staticmethod
+    def mse_to_met(atom_array: AtomArray) -> AtomArray:
+        """
+        Ref: AlphaFold3 SI chapter 2.1
+        MSE residues are converted to MET residues.
+
+        Args:
+            atom_array (AtomArray): Biotite AtomArray object.
+
+        Returns:
+            AtomArray: Biotite AtomArray object after converted MSE to MET.
+        """
+        mse = atom_array.res_name == "MSE"
+        se = mse & (atom_array.atom_name == "SE")
+        atom_array.atom_name[se] = "SD"
+        atom_array.element[se] = "S"
+        atom_array.res_name[mse] = "MET"
+        atom_array.hetero[mse] = False
+        return atom_array
+
+    def get_atom_array(self) -> AtomArray:
+        """
+        Create a Biotite AtomArray and add attributes from the input dict.
+
+        Returns:
+            AtomArray: Biotite Atom array.
+        """
+        atom_array = self.build_full_atom_array()
+        atom_array = self.add_bonds_between_entities(atom_array)
+        atom_array = self.mse_to_met(atom_array)
+        atom_array = self.add_atom_array_attributes(atom_array, self.entity_poly_type)
+        return atom_array
+
+    def get_feature_dict(self) -> tuple[dict[str, torch.Tensor], AtomArray, TokenArray]:
+        """
+        Generates a feature dictionary from the input sample dictionary.
+
+        Returns:
+            A tuple containing:
+                - A dictionary of features.
+                - An AtomArray object.
+                - A TokenArray object.
+        """
+        atom_array = self.get_atom_array()
+
+        aa_tokenizer = AtomArrayTokenizer(atom_array)
+        token_array = aa_tokenizer.get_token_array()
+
+        featurizer = Featurizer(token_array, atom_array)
+        feature_dict = featurizer.get_all_input_features()
+
+        token_array_with_frame = featurizer.get_token_frame(
+            token_array=token_array,
+            atom_array=atom_array,
+            ref_pos=feature_dict["ref_pos"],
+            ref_mask=feature_dict["ref_mask"],
+        )
+
+        # [N_token]
+        feature_dict["has_frame"] = torch.Tensor(
+            token_array_with_frame.get_annotation("has_frame")
+        ).long()
+
+        # [N_token, 3]
+        feature_dict["frame_atom_index"] = torch.Tensor(
+            token_array_with_frame.get_annotation("frame_atom_index")
+        ).long()
+        return feature_dict, atom_array, token_array

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/data/msa_featurizer.py

@@ -0,0 +1,1162 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import os
+import shutil
+from abc import ABC, abstractmethod
+from collections import defaultdict
+from copy import deepcopy
+from os.path import exists as opexists
+from os.path import join as opjoin
+from typing import Any, Mapping, Optional, Sequence, Union
+
+import numpy as np
+import torch
+from biotite.structure import AtomArray
+
+from protenix.data.constants import STD_RESIDUES, rna_order_with_x
+from protenix.data.msa_utils import (
+    PROT_TYPE_NAME,
+    FeatureDict,
+    add_assembly_features,
+    clip_msa,
+    convert_monomer_features,
+    get_identifier_func,
+    load_and_process_msa,
+    make_sequence_features,
+    merge_features_from_prot_rna,
+    msa_parallel,
+    pair_and_merge,
+    rna_merge,
+)
+from protenix.data.tokenizer import TokenArray
+from protenix.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+SEQ_LIMITS = {
+    "uniref100": -1,
+    "mmseqs_other": -1,
+    "uniclust30": -1,
+    "rfam": 10000,
+    "rnacentral": 10000,
+    "nucleotide": 10000,
+}
+MSA_MAX_SIZE = 16384
+
+
+class BaseMSAFeaturizer(ABC):
+    def __init__(
+        self,
+        indexing_method: str = "sequence",
+        merge_method: str = "dense_max",
+        seq_limits: Optional[dict[str, int]] = {},
+        max_size: int = 16384,
+        **kwargs,
+    ):
+        """
+        Initializes the BaseMSAFeaturizer with the specified parameters.
+
+        Args:
+            indexing_method (str): The method used for indexing the MSA. Defaults to "sequence".
+            merge_method (str): The method used for merging MSA features. Defaults to "dense_max".
+            seq_limits (Optional[dict[str, int]]): Dictionary specifying sequence limits for different databases. Defaults to an empty dictionary.
+            max_size (int): The maximum size of the MSA. Defaults to 16384.
+            **kwargs: Additional keyword arguments.
+
+        Raises:
+            AssertionError: If the provided `merge_method` or `indexing_method` is not valid.
+        """
+        assert merge_method in ["dense_max", "dense_min", "sparse"]
+        assert indexing_method in [
+            "sequence",
+            "pdb_id",
+            "pdb_id_entity_id",
+        ], f"Unknown indexing method: {indexing_method}"
+        self.indexing_method = indexing_method
+        self.merge_method = merge_method
+        self.seq_limits = seq_limits
+        self.max_size = max_size
+
+    @abstractmethod
+    def get_msa_path(self):
+        pass
+
+    @abstractmethod
+    def process_single_sequence(self):
+        pass
+
+    def get_entity_ids(
+        self, bioassembly_dict: Mapping[str, Any], msa_entity_type: str = "prot"
+    ) -> set[str]:
+        """
+        Extracts the entity IDs that match the specified MSA entity type from the bioassembly dictionary.
+
+        Args:
+            bioassembly_dict (Mapping[str, Any]): The bioassembly dictionary containing entity information.
+            msa_entity_type (str): The type of MSA entity to filter by. Defaults to "prot".
+
+        Returns:
+            set[str]: A set of entity IDs that match the specified MSA entity type.
+
+        Raises:
+            AssertionError: If the provided `msa_entity_type` is not "prot" or "rna".
+        """
+        assert msa_entity_type in ["prot", "rna"], "only protein and rna might have msa"
+        poly_type_mapping = {
+            "prot": "polypeptide",
+            "rna": "polyribonucleotide",
+            "dna": "polydeoxyribonucleotide",
+        }
+        entity_poly_type = bioassembly_dict["entity_poly_type"]
+
+        entity_ids: set[str] = {
+            entity_id
+            for entity_id, poly_type in entity_poly_type.items()
+            if poly_type_mapping[msa_entity_type] in poly_type
+        }
+        return entity_ids
+
+    def get_selected_asym_ids(
+        self,
+        bioassembly_dict: Mapping[str, Any],
+        entity_to_asym_id_int: Mapping[str, Sequence[int]],
+        selected_token_indices: Optional[torch.Tensor],
+        entity_ids: set[str],
+    ) -> tuple[set[int], set[int], dict[int, str], dict[int, str], dict[str, str]]:
+        """
+        Extracts the selected asym IDs based on the provided bioassembly dictionary and entity IDs.
+
+        Args:
+            bioassembly_dict (Mapping[str, Any]): The bioassembly dictionary containing entity information.
+            entity_to_asym_id_int (Mapping[str, Sequence[int]]): Mapping from entity ID to asym ID integers.
+            selected_token_indices (Optional[torch.Tensor]): Indices of selected tokens.
+            entity_ids (set[str]): Set of entity IDs to consider.
+
+        Returns:
+            tuple: A tuple containing:
+                - selected_asym_ids (set[int]): Set of selected asym IDs.
+                - asym_id_ints (set[int]): Set of asym ID integers.
+                - asym_to_entity_id (dict[int, str]): Mapping from asym ID integers to entity IDs.
+                - asym_id_int_to_sequence (dict[int, str]): Mapping from asym ID integers to sequences.
+                - entity_id_to_sequence (dict[str, str]): Mapping from entity IDs to sequences.
+        """
+        asym_to_entity_id: dict[int, str] = {}
+        # Only count the selected Prot/RNA entities, many-to-one mapping
+        for entity_id, asym_id_int_list in entity_to_asym_id_int.items():
+            if entity_id in entity_ids:
+                for asym_id_int in asym_id_int_list:
+                    asym_to_entity_id[asym_id_int] = entity_id
+        entity_id_to_sequence = {
+            k: v
+            for (k, v) in bioassembly_dict["sequences"].items()
+            if k in entity_ids and k in entity_to_asym_id_int
+        }
+        asym_id_ints = set(
+            [
+                asym_id_int
+                for (asym_id_int, entity_id) in asym_to_entity_id.items()
+                if entity_id in entity_ids
+            ]
+        )
+        # Only count Prot/RNA chains, many-to-one mapping
+        asym_id_int_to_sequence = {
+            asym_id_int: entity_id_to_sequence[entity_id]
+            for (asym_id_int, entity_id) in asym_to_entity_id.items()
+        }
+        atom_array = bioassembly_dict["atom_array"]
+        token_array = bioassembly_dict["token_array"]
+
+        if selected_token_indices is None:
+            selected_asym_ids = set(
+                [
+                    atom_array[idx].asym_id_int
+                    for idx in token_array.get_annotation("centre_atom_index")
+                ]
+            )
+        else:
+            selected_asym_ids = set(
+                [
+                    atom_array[idx].asym_id_int
+                    for idx in token_array[selected_token_indices].get_annotation(
+                        "centre_atom_index"
+                    )
+                ]
+            )
+        return (
+            selected_asym_ids,
+            asym_id_ints,
+            asym_to_entity_id,
+            asym_id_int_to_sequence,
+            entity_id_to_sequence,
+        )
+
+    def get_msa_pipeline(
+        self,
+        is_homomer_or_monomer: bool,
+        selected_asym_ids: set[int],
+        asym_to_entity_id: dict[int, str],
+        asym_id_int_to_sequence: dict[int, str],
+        entity_id_to_sequence: dict[str, str],
+        bioassembly_dict: Mapping[str, Any],
+        entity_to_asym_id_int: Mapping[str, Sequence[int]],
+        msa_entity_type="prot",
+    ) -> Optional[dict[str, np.ndarray]]:
+        """
+        Processes the MSA pipeline for the given bioassembly dictionary and selected asym IDs.
+
+        Args:
+            is_homomer_or_monomer (bool): Indicates if the sequence is a homomer or monomer.
+            selected_asym_ids (set[int]): Set of selected asym IDs.
+            asym_to_entity_id (dict[int, str]): Mapping from asym ID integers to entity IDs.
+            asym_id_int_to_sequence (dict[int, str]): Mapping from asym ID integers to sequences.
+            entity_id_to_sequence (dict[str, str]): Mapping from entity IDs to sequences.
+            bioassembly_dict (Mapping[str, Any]): The bioassembly dictionary containing entity information.
+            entity_to_asym_id_int (Mapping[str, Sequence[int]]): Mapping from entity ID to asym ID integers.
+            msa_entity_type (str): The type of MSA entity to process. Defaults to "prot".
+
+        Returns:
+            Optional[dict[str, np.ndarray]]: A dictionary containing the processed MSA features, or None if no features are processed.
+
+        Raises:
+            AssertionError: If `msa_entity_type` is "rna" and `is_homomer_or_monomer` is False.
+        """
+        if msa_entity_type == "rna":
+            assert is_homomer_or_monomer, "RNA MSAs do not pairing"
+        pdb_id = bioassembly_dict["pdb_id"]
+        sequence_to_features: dict[str, dict[str, Any]] = {}
+
+        for entity_id, sequence in entity_id_to_sequence.items():
+            if sequence in sequence_to_features:
+                # It is possible that different entity ids correspond to the same sequence
+                continue
+
+            if all(
+                [
+                    asym_id_int not in selected_asym_ids
+                    for asym_id_int in entity_to_asym_id_int[entity_id]
+                ]
+            ):
+                # All chains corresponding to this entity are not selected
+                continue
+
+            sequence_feat = self.process_single_sequence(
+                pdb_name=f"{pdb_id}_{entity_id}",
+                sequence=sequence,
+                pdb_id=pdb_id,
+                is_homomer_or_monomer=is_homomer_or_monomer,
+            )
+            sequence_feat = convert_monomer_features(sequence_feat)
+            sequence_to_features[sequence] = sequence_feat
+
+        all_chain_features = {
+            asym_id_int: deepcopy(sequence_to_features[seq])
+            for asym_id_int, seq in asym_id_int_to_sequence.items()
+            if seq in sequence_to_features
+        }
+        del sequence_to_features
+
+        if len(all_chain_features) == 0:
+            return None
+        np_example = merge_all_chain_features(
+            pdb_id=pdb_id,
+            all_chain_features=all_chain_features,
+            asym_to_entity_id=asym_to_entity_id,
+            is_homomer_or_monomer=is_homomer_or_monomer,
+            merge_method=self.merge_method,
+            max_size=self.max_size,
+            msa_entity_type=msa_entity_type,
+        )
+        return np_example
+
+
+class PROTMSAFeaturizer(BaseMSAFeaturizer):
+    def __init__(
+        self,
+        dataset_name: str = "",
+        seq_to_pdb_idx_path: str = "",
+        distillation_index_file: str = None,
+        indexing_method: str = "sequence",
+        pairing_db: Optional[str] = "",
+        non_pairing_db: str = "mmseqs_all",
+        merge_method: str = "dense_max",
+        seq_limits: Optional[dict[str, int]] = {},
+        max_size: int = 16384,
+        pdb_jackhmmer_dir: str = None,
+        pdb_mmseqs_dir: str = None,
+        distillation_mmseqs_dir: str = None,
+        distillation_uniclust_dir: str = None,
+        **kwargs,
+    ):
+        super().__init__(
+            indexing_method=indexing_method,
+            merge_method=merge_method,
+            seq_limits=seq_limits,
+            max_size=max_size,
+            **kwargs,
+        )
+        self.dataset_name = dataset_name
+        self.pdb_jackhmmer_dir = pdb_jackhmmer_dir
+        self.pdb_mmseqs_dir = pdb_mmseqs_dir
+        self.distillation_mmseqs_dir = distillation_mmseqs_dir
+        self.distillation_uniclust_dir = distillation_uniclust_dir
+        self.pairing_db = pairing_db if len(pairing_db) > 0 else None
+
+        if non_pairing_db == "mmseqs_all":
+            self.non_pairing_db = ["uniref100", "mmseqs_other"]
+        else:
+            self.non_pairing_db = [db_name for db_name in non_pairing_db.split(",")]
+
+        with open(seq_to_pdb_idx_path, "r") as f:
+            self.seq_to_pdb_idx = json.load(f)
+        # If distillation data is avaiable
+        if distillation_index_file is not None:
+            with open(distillation_index_file, "r") as f:
+                self.distillation_pdb_id_to_msa_dir = json.load(f)
+        else:
+            self.distillation_pdb_id_to_msa_dir = None
+
+    def get_msa_path(self, db_name: str, sequence: str, pdb_id: str) -> str:
+        """
+        Get the path of an MSA file
+
+        Args:
+            db_name (str): name of genomics database
+            sequence (str): input sequence
+            pdb_id (str): pdb_id of input sequence
+
+        Returns:
+            str: file path
+        """
+
+        if self.indexing_method == "pdb_id" and self.distillation_pdb_id_to_msa_dir:
+            rel_path = self.distillation_pdb_id_to_msa_dir[pdb_id]
+
+            if db_name == "uniclust30":
+                msa_dir_path = opjoin(self.distillation_uniclust_dir, rel_path)
+            elif db_name in ["uniref100", "mmseqs_other"]:
+                msa_dir_path = opjoin(self.distillation_mmseqs_dir, rel_path)
+            else:
+                raise ValueError(
+                    f"Indexing with {self.indexing_method} is not supported for {db_name}"
+                )
+
+            if opexists(msa_path := opjoin(msa_dir_path, f"{db_name}_hits.a3m")):
+                return msa_path
+            else:
+                return opjoin(msa_dir_path, f"{db_name}.a3m")
+        else:
+            # indexing_method == "sequence"
+            pdb_index = self.seq_to_pdb_idx[sequence]
+            if db_name in ["uniref100", "mmseqs_other"]:
+                return opjoin(
+                    self.pdb_mmseqs_dir, str(pdb_index), f"{db_name}_hits.a3m"
+                )
+            else:
+                return opjoin(
+                    self.pdb_jackhmmer_dir,
+                    f"pdb_on_{db_name}",
+                    "results",
+                    f"{pdb_index}.a3m",
+                )
+
+    def process_single_sequence(
+        self,
+        pdb_name: str,
+        sequence: str,
+        pdb_id: str,
+        is_homomer_or_monomer: bool,
+    ) -> dict[str, np.ndarray]:
+        """
+        Get basic MSA features for a single sequence.
+
+        Args:
+            pdb_name (str): f"{pdb_id}_{entity_id}" of the input entity
+            sequence (str): input sequnce
+            pdb_id (str): pdb_id of input sequence
+            is_homomer_or_monomer (bool): True if the input sequence is a homomer or a monomer
+
+        Returns:
+            Dict[str, np.ndarray]: the basic MSA features of the input sequence
+        """
+
+        raw_msa_paths, seq_limits = [], []
+        for db_name in self.non_pairing_db:
+            if opexists(
+                path := self.get_msa_path(db_name, sequence, pdb_id)
+            ) and path.endswith(".a3m"):
+                raw_msa_paths.append(path)
+                seq_limits.append(self.seq_limits.get(db_name, SEQ_LIMITS[db_name]))
+
+        # Get sequence and non-pairing msa features
+        sequence_features = process_single_sequence(
+            pdb_name=pdb_name,
+            sequence=sequence,
+            raw_msa_paths=raw_msa_paths,
+            seq_limits=seq_limits,
+            msa_entity_type="prot",
+            msa_type="non_pairing",
+        )
+
+        # Get pairing msa features
+        if not is_homomer_or_monomer:
+            # Separately process the MSA needed for pairing
+            raw_msa_paths, seq_limits = [], []
+            if opexists(
+                path := self.get_msa_path(self.pairing_db, sequence, pdb_id)
+            ) and path.endswith(".a3m"):
+                raw_msa_paths = [
+                    path,
+                ]
+                seq_limits.append(
+                    self.seq_limits.get(self.pairing_db, SEQ_LIMITS[self.pairing_db])
+                )
+
+            if len(raw_msa_paths) == 0:
+                raise ValueError(f"{pdb_name} does not have MSA for pairing")
+
+            all_seq_msa_features = load_and_process_msa(
+                pdb_name=pdb_name,
+                msa_type="pairing",
+                raw_msa_paths=raw_msa_paths,
+                seq_limits=seq_limits,
+                identifier_func=get_identifier_func(pairing_db=self.pairing_db),
+                handle_empty="raise_error",
+            )
+            sequence_features.update(all_seq_msa_features)
+
+        return sequence_features
+
+    def get_msa_features_for_assembly(
+        self,
+        bioassembly_dict: Mapping[str, Any],
+        entity_to_asym_id_int: Mapping[str, Sequence[int]],
+        selected_token_indices: Optional[torch.Tensor],
+    ) -> dict[str, np.ndarray]:
+        """
+        Get MSA features for the bioassembly.
+
+        Args:
+            bioassembly_dict (Mapping[str, Any]): the bioassembly dict with sequence, atom_array and token_array.
+            entity_to_asym_id_int (Mapping[str, Sequence[int]]): mapping from entity_id to asym_id_int.
+            selected_token_indices (torch.Tensor): Cropped token indices.
+
+        Returns:
+            Dict[str, np.ndarray]: the basic MSA features of the bioassembly.
+        """
+        protein_entity_ids = self.get_entity_ids(
+            bioassembly_dict, msa_entity_type="prot"
+        )
+        if len(protein_entity_ids) == 0:
+            return None
+        (
+            selected_asym_ids,
+            asym_id_ints,
+            asym_to_entity_id,
+            asym_id_int_to_sequence,
+            entity_id_to_sequence,
+        ) = self.get_selected_asym_ids(
+            bioassembly_dict=bioassembly_dict,
+            entity_to_asym_id_int=entity_to_asym_id_int,
+            selected_token_indices=selected_token_indices,
+            entity_ids=protein_entity_ids,
+        )
+        # No pairing_db specified (all proteins are treated as monomers) or only one sequence
+        is_homomer_or_monomer = (self.pairing_db is None) or (
+            len(
+                set(
+                    [
+                        asym_id_int_to_sequence[asym_id_int]
+                        for asym_id_int in selected_asym_ids
+                        if asym_id_int in asym_id_ints
+                    ]
+                )
+            )
+            == 1
+        )
+        np_example = self.get_msa_pipeline(
+            is_homomer_or_monomer=is_homomer_or_monomer,
+            selected_asym_ids=selected_asym_ids,
+            asym_to_entity_id=asym_to_entity_id,
+            asym_id_int_to_sequence=asym_id_int_to_sequence,
+            entity_id_to_sequence=entity_id_to_sequence,
+            bioassembly_dict=bioassembly_dict,
+            entity_to_asym_id_int=entity_to_asym_id_int,
+            msa_entity_type="prot",
+        )
+        return np_example
+
+
+class RNAMSAFeaturizer(BaseMSAFeaturizer):
+    def __init__(
+        self,
+        seq_to_pdb_idx_path: str = "",
+        indexing_method: str = "sequence",
+        merge_method: str = "dense_max",
+        seq_limits: Optional[dict[str, int]] = {},
+        max_size: int = 16384,
+        rna_msa_dir: str = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(
+            indexing_method=indexing_method,
+            merge_method=merge_method,
+            seq_limits=seq_limits,
+            max_size=max_size,
+            **kwargs,
+        )
+        # By default, use all the database in paper
+        self.rna_msa_dir = rna_msa_dir
+        self.non_pairing_db = ["rfam", "rnacentral", "nucleotide"]
+        with open(seq_to_pdb_idx_path, "r") as f:
+            self.seq_to_pdb_idx = json.load(f)  # it's rna sequence to pdb list
+
+    def get_msa_path(
+        self, db_name: str, sequence: str, pdb_id_entity_id: str, reduced: bool = True
+    ) -> str:
+        """
+        Get the path of an RNA MSA file
+
+        Args:
+            db_name (str): genetics databases for RNA chains
+            sequence (str): input sequence
+            pdb_id_entity_id (str): pdb_id_entity_id of input sequence
+            reduced (bool): whether reduce the sto files to max 1w
+
+        Returns:
+            str: file path
+        """
+        assert self.indexing_method in [
+            "pdb_id_entity_id",
+            "sequence",
+        ], "use the pdb_id_entity_id or sequence to search msa dir"
+        if reduced:
+            suffix = "_max_1w"
+        else:
+            suffix = ""
+        if self.indexing_method == "sequence":
+            # only the first pdb save the rna msa
+            if sequence in self.seq_to_pdb_idx:
+                pdb_id_entity_id = self.seq_to_pdb_idx[sequence][0]
+            else:
+                logger.info(f"{pdb_id_entity_id} not in seq_to_pdb_idx")
+                pdb_id_entity_id = "not_exist"
+
+        rel_path = f"{pdb_id_entity_id}/{db_name}.sto"
+        msa_dir_path = opjoin(f"{self.rna_msa_dir}{suffix}", rel_path)
+        return msa_dir_path
+
+    def process_single_sequence(
+        self,
+        pdb_name: str,
+        sequence: str,
+        pdb_id: str,
+        is_homomer_or_monomer: bool,
+    ) -> dict[str, np.ndarray]:
+        """
+        Get basic MSA features for a single sequence.
+
+        Args:
+            pdb_name (str): f"{pdb_id}_{entity_id}" of the input entity
+            sequence (str): input sequnce
+            pdb_id (str): pdb_id of input sequence
+            is_homomer_or_monomer (bool): True if the input sequence is a homomer or a monomer
+
+        Returns:
+            Dict[str, np.ndarray]: the basic MSA features of the input sequence
+        """
+        raw_msa_paths, seq_limits = [], []
+        for db_name in self.non_pairing_db:
+            if opexists(
+                path := self.get_msa_path(db_name, sequence, pdb_name)
+            ) and path.endswith(".sto"):
+                raw_msa_paths.append(path)
+                seq_limits.append(self.seq_limits.get(db_name, SEQ_LIMITS[db_name]))
+
+        sequence_features = process_single_sequence(
+            pdb_name=pdb_name,
+            sequence=sequence,
+            raw_msa_paths=raw_msa_paths,
+            seq_limits=seq_limits,
+            msa_entity_type="rna",
+            msa_type="non_pairing",
+        )
+
+        return sequence_features
+
+    def get_msa_features_for_assembly(
+        self,
+        bioassembly_dict: Mapping[str, Any],
+        entity_to_asym_id_int: Mapping[str, Sequence[int]],
+        selected_token_indices: Optional[torch.Tensor],
+    ) -> dict[str, np.ndarray]:
+        """
+        Get MSA features for the bioassembly.
+
+        Args:
+            bioassembly_dict (Mapping[str, Any]): the bioassembly dict with sequence, atom_array and token_array.
+            entity_to_asym_id_int (Mapping[str, Sequence[int]]): mapping from entity_id to asym_id_int.
+            selected_token_indices (torch.Tensor): Cropped token indices.
+
+        Returns:
+            Dict[str, np.ndarray]: the basic MSA features of the bioassembly.
+        """
+        rna_entity_ids = self.get_entity_ids(bioassembly_dict, msa_entity_type="rna")
+        if len(rna_entity_ids) == 0:
+            return None
+        (
+            selected_asym_ids,
+            asym_id_ints,
+            asym_to_entity_id,
+            asym_id_int_to_sequence,
+            entity_id_to_sequence,
+        ) = self.get_selected_asym_ids(
+            bioassembly_dict=bioassembly_dict,
+            entity_to_asym_id_int=entity_to_asym_id_int,
+            selected_token_indices=selected_token_indices,
+            entity_ids=rna_entity_ids,
+        )
+        is_homomer_or_monomer = True
+        np_example = self.get_msa_pipeline(
+            is_homomer_or_monomer=is_homomer_or_monomer,
+            selected_asym_ids=selected_asym_ids,
+            asym_to_entity_id=asym_to_entity_id,
+            asym_id_int_to_sequence=asym_id_int_to_sequence,
+            entity_id_to_sequence=entity_id_to_sequence,
+            bioassembly_dict=bioassembly_dict,
+            entity_to_asym_id_int=entity_to_asym_id_int,
+            msa_entity_type="rna",
+        )
+        return np_example
+
+
+class MSAFeaturizer:
+    def __init__(
+        self,
+        prot_msa_args: dict = {},
+        rna_msa_args: dict = {},
+        enable_rna_msa: bool = False,
+    ):
+        self.prot_msa_featurizer = PROTMSAFeaturizer(**prot_msa_args)
+        self.enable_rna_msa = enable_rna_msa
+        if self.enable_rna_msa:
+            self.rna_msa_featurizer = RNAMSAFeaturizer(**rna_msa_args)
+
+    def __call__(
+        self,
+        bioassembly_dict: dict[str, Any],
+        selected_indices: np.ndarray,
+        entity_to_asym_id_int: Mapping[str, int],
+    ) -> Optional[dict[str, np.ndarray]]:
+        """
+        Processes the bioassembly dictionary to generate MSA features for both protein and RNA entities, if enabled.
+
+        Args:
+            bioassembly_dict (dict[str, Any]): The bioassembly dictionary containing entity information.
+            selected_indices (np.ndarray): Indices of selected tokens.
+            entity_to_asym_id_int (Mapping[str, int]): Mapping from entity ID to asym ID integers.
+
+        Returns:
+            Optional[dict[str, np.ndarray]]: A dictionary containing the merged MSA features for the bioassembly, or None if no features are generated.
+        """
+        prot_msa_feats = self.prot_msa_featurizer.get_msa_features_for_assembly(
+            bioassembly_dict=bioassembly_dict,
+            entity_to_asym_id_int=entity_to_asym_id_int,
+            selected_token_indices=selected_indices,
+        )
+        if self.enable_rna_msa:
+            rna_msa_feats = self.rna_msa_featurizer.get_msa_features_for_assembly(
+                bioassembly_dict=bioassembly_dict,
+                entity_to_asym_id_int=entity_to_asym_id_int,
+                selected_token_indices=selected_indices,
+            )
+        else:
+            rna_msa_feats = None
+        np_chains_list = []
+        if prot_msa_feats is not None:
+            np_chains_list.append(prot_msa_feats)
+        if rna_msa_feats is not None:
+            np_chains_list.append(rna_msa_feats)
+        if len(np_chains_list) == 0:
+            return None
+
+        msa_feats = merge_features_from_prot_rna(np_chains_list)
+        msa_feats = self.tokenize(
+            msa_feats=msa_feats,
+            token_array=bioassembly_dict["token_array"],
+            atom_array=bioassembly_dict["atom_array"],
+        )
+
+        return msa_feats
+
+    def tokenize(
+        self,
+        msa_feats: Mapping[str, np.ndarray],
+        token_array: TokenArray,
+        atom_array: AtomArray,
+    ) -> dict[str, np.ndarray]:
+        """
+        Tokenize raw MSA features.
+
+        Args:
+            msa_feats (Dict[str, np.ndarray]): raw MSA features.
+            token_array (TokenArray): token array of this bioassembly
+            atom_array (AtomArray): atom array of this bioassembly
+
+        Returns:
+            Dict[str, np.ndarray]: the tokenized MSA features of the bioassembly.
+        """
+        msa_feats = tokenize_msa(
+            msa_feats=msa_feats, token_array=token_array, atom_array=atom_array
+        )
+        # Add to tracking for msa analysis
+        msa_feats.update(
+            {
+                "prot_pair_num_alignments": msa_feats.get(
+                    "prot_pair_num_alignments", np.asarray(0, dtype=np.int32)
+                ),
+                "prot_unpair_num_alignments": msa_feats.get(
+                    "prot_unpair_num_alignments", np.asarray(0, dtype=np.int32)
+                ),
+                "rna_pair_num_alignments": msa_feats.get(
+                    "rna_pair_num_alignments", np.asarray(0, dtype=np.int32)
+                ),
+                "rna_unpair_num_alignments": msa_feats.get(
+                    "rna_unpair_num_alignments", np.asarray(0, dtype=np.int32)
+                ),
+            }
+        )
+        return {
+            k: v
+            for (k, v) in msa_feats.items()
+            if k
+            in ["msa", "has_deletion", "deletion_value", "deletion_mean", "profile"]
+            + [
+                "prot_pair_num_alignments",
+                "prot_unpair_num_alignments",
+                "rna_pair_num_alignments",
+                "rna_unpair_num_alignments",
+            ]
+        }
+
+
+# Common function for train and inference
+def process_single_sequence(
+    pdb_name: str,
+    sequence: str,
+    raw_msa_paths: Optional[list[str]],
+    seq_limits: Optional[list[str]],
+    msa_entity_type: str = "prot",
+    msa_type: str = "non_pairing",
+) -> FeatureDict:
+    """
+    Processes a single sequence to generate sequence and MSA features.
+
+    Args:
+        pdb_name (str): The name of the PDB entry.
+        sequence (str): The input sequence.
+        raw_msa_paths (Optional[list[str]]): List of paths to raw MSA files.
+        seq_limits (Optional[list[str]]): List of sequence limits for different databases.
+        msa_entity_type (str): The type of MSA entity, either "prot" or "rna". Defaults to "prot".
+        msa_type (str): The type of MSA, either "non_pairing" or "pairing". Defaults to "non_pairing".
+
+    Returns:
+        FeatureDict: A dictionary containing the sequence and MSA features.
+
+    Raises:
+        AssertionError: If `msa_entity_type` is not "prot" or "rna".
+    """
+    assert msa_entity_type in ["prot", "rna"]
+    num_res = len(sequence)
+
+    if msa_entity_type == "prot":
+        sequence_features = make_sequence_features(
+            sequence=sequence,
+            num_res=num_res,
+        )
+    elif msa_entity_type == "rna":
+        sequence_features = make_sequence_features(
+            sequence=sequence,
+            num_res=num_res,
+            mapping=rna_order_with_x,
+            x_token="N",
+        )
+
+    msa_features = load_and_process_msa(
+        pdb_name=pdb_name,
+        msa_type=msa_type,
+        raw_msa_paths=raw_msa_paths,
+        seq_limits=seq_limits,
+        input_sequence=sequence,
+        msa_entity_type=msa_entity_type,
+    )
+    sequence_features.update(msa_features)
+    return sequence_features
+
+
+# Common function for train and inference
+def tokenize_msa(
+    msa_feats: Mapping[str, np.ndarray],
+    token_array: TokenArray,
+    atom_array: AtomArray,
+) -> dict[str, np.ndarray]:
+    """
+    Tokenize raw MSA features.
+
+    Args:
+        msa_feats (Dict[str, np.ndarray]): raw MSA features.
+        token_array (TokenArray): token array of this bioassembly
+        atom_array (AtomArray): atom array of this bioassembly
+
+    Returns:
+        Dict[str, np.ndarray]: the tokenized MSA features of the bioassembly.
+    """
+    token_center_atom_idxs = token_array.get_annotation("centre_atom_index")
+    # res_id: (asym_id, residue_index)
+    # msa_idx refers to the column number of a residue in the msa array
+    res_id_2_msa_idx = {
+        (msa_feats["asym_id"][idx], msa_feats["residue_index"][idx]): idx
+        for idx in range(msa_feats["msa"].shape[1])
+    }
+
+    restypes = []
+    col_idxs_in_msa = []
+    col_idxs_in_new_msa = []
+    for token_idx, center_atom_idx in enumerate(token_center_atom_idxs):
+        restypes.append(STD_RESIDUES[atom_array.cano_seq_resname[center_atom_idx]])
+        if (
+            res_id := (
+                atom_array[center_atom_idx].asym_id_int,
+                atom_array[center_atom_idx].res_id,
+            )
+        ) in res_id_2_msa_idx:
+            col_idxs_in_msa.append(res_id_2_msa_idx[res_id])
+            col_idxs_in_new_msa.append(token_idx)
+
+    num_msa_seq, _ = msa_feats["msa"].shape
+    num_tokens = len(token_center_atom_idxs)
+
+    restypes = np.array(restypes)
+    col_idxs_in_new_msa = np.array(col_idxs_in_new_msa)
+    col_idxs_in_msa = np.array(col_idxs_in_msa)
+
+    # msa
+    # For non-amino acid tokens, copy the token itself
+    feat_name = "msa"
+    new_feat = np.repeat(restypes[None, ...], num_msa_seq, axis=0)
+    new_feat[:, col_idxs_in_new_msa] = msa_feats[feat_name][:, col_idxs_in_msa]
+    msa_feats[feat_name] = new_feat
+
+    # has_deletion, deletion_value
+    # Assign 0 to non-amino acid tokens
+    for feat_name in ["has_deletion", "deletion_value"]:
+        new_feat = np.zeros((num_msa_seq, num_tokens), dtype=msa_feats[feat_name].dtype)
+        new_feat[:, col_idxs_in_new_msa] = msa_feats[feat_name][:, col_idxs_in_msa]
+        msa_feats[feat_name] = new_feat
+
+    # deletion_mean
+    # Assign 0 to non-amino acid tokens
+    feat_name = "deletion_mean"
+    new_feat = np.zeros((num_tokens,))
+    new_feat[col_idxs_in_new_msa] = msa_feats[feat_name][col_idxs_in_msa]
+    msa_feats[feat_name] = new_feat
+
+    # profile
+    # Assign one-hot enbedding (one-hot distribution) to non-amino acid tokens corresponding to restype
+    feat_name = "profile"
+    new_feat = np.zeros((num_tokens, 32))
+    new_feat[np.arange(num_tokens), restypes] = 1
+    new_feat[col_idxs_in_new_msa, :] = msa_feats[feat_name][col_idxs_in_msa, :]
+    msa_feats[feat_name] = new_feat
+    return msa_feats
+
+
+# Common function for train and inference
+def merge_all_chain_features(
+    pdb_id: str,
+    all_chain_features: dict[str, FeatureDict],
+    asym_to_entity_id: dict,
+    is_homomer_or_monomer: bool = False,
+    merge_method: str = "dense_max",
+    max_size: int = 16384,
+    msa_entity_type: str = "prot",
+) -> dict[str, np.ndarray]:
+    """
+    Merges features from all chains in the bioassembly.
+
+    Args:
+        pdb_id (str): The PDB ID of the bioassembly.
+        all_chain_features (dict[str, FeatureDict]): Features for each chain in the bioassembly.
+        asym_to_entity_id (dict): Mapping from asym ID to entity ID.
+        is_homomer_or_monomer (bool): Indicates if the bioassembly is a homomer or monomer. Defaults to False.
+        merge_method (str): Method used for merging features. Defaults to "dense_max".
+        max_size (int): Maximum size of the MSA. Defaults to 16384.
+        msa_entity_type (str): Type of MSA entity, either "prot" or "rna". Defaults to "prot".
+
+    Returns:
+        dict[str, np.ndarray]: Merged features for the bioassembly.
+    """
+    all_chain_features = add_assembly_features(
+        pdb_id,
+        all_chain_features,
+        asym_to_entity_id=asym_to_entity_id,
+    )
+    if msa_entity_type == "rna":
+        np_example = rna_merge(
+            is_homomer_or_monomer=is_homomer_or_monomer,
+            all_chain_features=all_chain_features,
+            merge_method=merge_method,
+            msa_crop_size=max_size,
+        )
+    elif msa_entity_type == "prot":
+        np_example = pair_and_merge(
+            is_homomer_or_monomer=is_homomer_or_monomer,
+            all_chain_features=all_chain_features,
+            merge_method=merge_method,
+            msa_crop_size=max_size,
+        )
+    np_example = clip_msa(np_example, max_num_msa=max_size)
+    return np_example
+
+
+class InferenceMSAFeaturizer(object):
+    # Now we only support protein msa in inference
+
+    @staticmethod
+    def process_prot_single_sequence(
+        sequence: str,
+        description: str,
+        is_homomer_or_monomer: bool,
+        msa_dir: Union[str, None],
+        pairing_db: str,
+    ) -> FeatureDict:
+        """
+        Processes a single protein sequence to generate sequence and MSA features.
+
+        Args:
+            sequence (str): The input protein sequence.
+            description (str): Description of the sequence, typically the PDB name.
+            is_homomer_or_monomer (bool): Indicates if the sequence is a homomer or monomer.
+            msa_dir (Union[str, None]): Directory containing the MSA files, or None if no pre-computed MSA is provided.
+            pairing_db (str): Database used for pairing.
+
+        Returns:
+            FeatureDict: A dictionary containing the sequence and MSA features.
+
+        Raises:
+            AssertionError: If the pairing MSA file does not exist when `is_homomer_or_monomer` is False.
+        """
+        # For non-pairing MSA
+        if msa_dir is None:
+            # No pre-computed MSA was provided, and the MSA search failed
+            raw_msa_paths = []
+        else:
+            raw_msa_paths = [opjoin(msa_dir, "non_pairing.a3m")]
+        pdb_name = description
+
+        sequence_features = process_single_sequence(
+            pdb_name=pdb_name,
+            sequence=sequence,
+            raw_msa_paths=raw_msa_paths,
+            seq_limits=[-1],
+            msa_entity_type="prot",
+            msa_type="non_pairing",
+        )
+        if not is_homomer_or_monomer:
+            # Separately process the pairing MSA
+            assert opexists(
+                raw_msa_path := opjoin(msa_dir, "pairing.a3m")
+            ), f"No pairing-MSA of {pdb_name} (please check {raw_msa_path})"
+
+            all_seq_msa_features = load_and_process_msa(
+                pdb_name=pdb_name,
+                msa_type="pairing",
+                raw_msa_paths=[raw_msa_path],
+                seq_limits=[-1],
+                identifier_func=get_identifier_func(
+                    pairing_db=pairing_db,
+                ),
+                handle_empty="raise_error",
+            )
+            sequence_features.update(all_seq_msa_features)
+
+        return sequence_features
+
+    @staticmethod
+    def get_inference_prot_msa_features_for_assembly(
+        bioassembly: Sequence[Mapping[str, Mapping[str, Any]]],
+        entity_to_asym_id: Mapping[str, set[int]],
+    ) -> FeatureDict:
+        """
+        Processes the bioassembly to generate MSA features for protein entities in inference mode.
+
+        Args:
+            bioassembly (Sequence[Mapping[str, Mapping[str, Any]]]): The bioassembly containing entity information.
+            entity_to_asym_id (Mapping[str, set[int]]): Mapping from entity ID to asym ID integers.
+
+        Returns:
+            FeatureDict: A dictionary containing the MSA features for the protein entities.
+
+        Raises:
+            AssertionError: If the provided precomputed MSA path does not exist.
+        """
+        entity_to_asym_id_int = dict(entity_to_asym_id)
+        asym_to_entity_id = {}
+        entity_id_to_sequence = {}
+        # In inference mode, the keys in bioassembly is different from training
+        # Only contains protein entity, many-to-one mapping
+        entity_id_to_sequence = {}
+        for i, entity_info_wrapper in enumerate(bioassembly):
+            entity_id = str(i + 1)
+            entity_type = list(entity_info_wrapper.keys())[0]
+            entity_info = entity_info_wrapper[entity_type]
+
+            if entity_type == PROT_TYPE_NAME:
+                # Update entity_id_to_sequence
+                entity_id_to_sequence[entity_id] = entity_info["sequence"]
+
+                # Update asym_to_entity_id
+                for asym_id_int in entity_to_asym_id_int[entity_id]:
+                    asym_to_entity_id[asym_id_int] = entity_id
+        if len(entity_id_to_sequence) == 0:
+            # No protein entity
+            return None
+        is_homomer_or_monomer = (
+            len(set(entity_id_to_sequence.values())) == 1
+        )  # Only one protein sequence
+        sequence_to_entity = defaultdict(list)
+        for entity_id, seq in entity_id_to_sequence.items():
+            sequence_to_entity[seq].append(entity_id)
+
+        sequence_to_features: dict[str, dict[str, Any]] = {}
+        msa_sequences = {}
+        msa_dirs = {}
+        for idx, (sequence, entity_id_list) in enumerate(sequence_to_entity.items()):
+            msa_info = bioassembly[int(entity_id_list[0]) - 1][PROT_TYPE_NAME]["msa"]
+            msa_dir = msa_info.get("precomputed_msa_dir", None)
+            if msa_dir is not None:
+                assert opexists(
+                    msa_dir
+                ), f"The provided precomputed MSA path of entities {entity_id_list} does not exists: \n{msa_dir}"
+                msa_dirs[idx] = msa_dir
+            else:
+                pairing_db_fpath = msa_info.get("pairing_db_fpath", None)
+                non_pairing_db_fpath = msa_info.get("non_pairing_db_fpath", None)
+                assert (
+                    pairing_db_fpath is not None
+                ), "Path of pairing MSA database is not given."
+                assert (
+                    non_pairing_db_fpath is not None
+                ), "Path of non-pairing MSA database is not given."
+                assert msa_info["pairing_db"] in ["uniprot", "", None], (
+                    f"Using {msa_info['pairing_db']} as the source for MSA pairing "
+                    f"is not supported in online MSA searching."
+                )
+
+                msa_info["pairing_db"] = "uniprot"
+                msa_sequences[idx] = (sequence, pairing_db_fpath, non_pairing_db_fpath)
+        if len(msa_sequences) > 0:
+            msa_dirs.update(msa_parallel(msa_sequences))
+
+        for idx, (sequence, entity_id_list) in enumerate(sequence_to_entity.items()):
+
+            if len(entity_id_list) > 1:
+                logger.info(
+                    f"Entities {entity_id_list} correspond to the same sequence."
+                )
+            msa_info = bioassembly[int(entity_id_list[0]) - 1][PROT_TYPE_NAME]["msa"]
+            msa_dir = msa_dirs[idx]
+
+            description = f"entity_{'_'.join(map(str, entity_id_list))}"
+            sequence_feat = InferenceMSAFeaturizer.process_prot_single_sequence(
+                sequence=sequence,
+                description=description,
+                is_homomer_or_monomer=is_homomer_or_monomer,
+                msa_dir=msa_dir,
+                pairing_db=msa_info["pairing_db"],
+            )
+            sequence_feat = convert_monomer_features(sequence_feat)
+            sequence_to_features[sequence] = sequence_feat
+            if msa_dir and opexists(msa_dir) and idx in msa_sequences.keys():
+                if (msa_save_dir := msa_info.get("msa_save_dir", None)) is not None:
+                    if opexists(dst_dir := opjoin(msa_save_dir, str(idx + 1))):
+                        shutil.rmtree(dst_dir)
+                    shutil.copytree(msa_dir, dst_dir)
+                    for fname in os.listdir(dst_dir):
+                        if not fname.endswith(".a3m"):
+                            os.remove(opjoin(dst_dir, fname))
+                else:
+                    shutil.rmtree(msa_dir)
+
+        all_chain_features = {
+            asym_id_int: deepcopy(
+                sequence_to_features[entity_id_to_sequence[entity_id]]
+            )
+            for asym_id_int, entity_id in asym_to_entity_id.items()
+            if seq in sequence_to_features
+        }
+        if len(all_chain_features) == 0:
+            return None
+
+        np_example = merge_all_chain_features(
+            pdb_id="test_assembly",
+            all_chain_features=all_chain_features,
+            asym_to_entity_id=asym_to_entity_id,
+            is_homomer_or_monomer=is_homomer_or_monomer,
+            merge_method="dense_max",
+            max_size=MSA_MAX_SIZE,
+            msa_entity_type="prot",
+        )
+
+        return np_example
+
+    def make_msa_feature(
+        bioassembly: Sequence[Mapping[str, Mapping[str, Any]]],
+        entity_to_asym_id: Mapping[str, Sequence[str]],
+        token_array: TokenArray,
+        atom_array: AtomArray,
+    ) -> Optional[dict[str, np.ndarray]]:
+        """
+        Processes the bioassembly to generate MSA features for protein entities in inference mode and tokenizes the features.
+
+        Args:
+            bioassembly (Sequence[Mapping[str, Mapping[str, Any]]]): The bioassembly containing entity information.
+            entity_to_asym_id (Mapping[str, Sequence[str]]): Mapping from entity ID to asym ID strings.
+            token_array (TokenArray): Token array of the bioassembly.
+            atom_array (AtomArray): Atom array of the bioassembly.
+
+        Returns:
+            Optional[dict[str, np.ndarray]]: A dictionary containing the tokenized MSA features for the protein entities,
+                or an empty dictionary if no features are generated.
+        """
+        msa_feats = InferenceMSAFeaturizer.get_inference_prot_msa_features_for_assembly(
+            bioassembly=bioassembly,
+            entity_to_asym_id=entity_to_asym_id,
+        )
+
+        if msa_feats is None:
+            return {}
+
+        msa_feats = tokenize_msa(
+            msa_feats=msa_feats,
+            token_array=token_array,
+            atom_array=atom_array,
+        )
+        return {
+            k: v
+            for (k, v) in msa_feats.items()
+            if k
+            in ["msa", "has_deletion", "deletion_value", "deletion_mean", "profile"]
+        }

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/data/msa_utils.py

@@ -0,0 +1,1416 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import os
+import shutil
+import string
+import subprocess
+import time
+import uuid
+from collections import OrderedDict, defaultdict
+from os.path import exists as opexists
+from typing import (
+    Any,
+    Callable,
+    Iterable,
+    Mapping,
+    MutableMapping,
+    Optional,
+    Sequence,
+    Union,
+)
+
+import numpy as np
+
+from protenix.data.constants import (
+    PRO_STD_RESIDUES,
+    PROT_STD_RESIDUES_ONE_TO_THREE,
+    RNA_ID_TO_NT,
+    RNA_NT_TO_ID,
+    RNA_STD_RESIDUES,
+)
+from protenix.openfold_local.data import parsers
+from protenix.openfold_local.data.msa_identifiers import (
+    Identifiers,
+    _extract_sequence_identifier,
+    _parse_sequence_identifier,
+)
+from protenix.openfold_local.data.msa_pairing import (
+    CHAIN_FEATURES,
+    MSA_FEATURES,
+    MSA_GAP_IDX,
+    MSA_PAD_VALUES,
+    SEQ_FEATURES,
+    block_diag,
+    create_paired_features,
+    deduplicate_unpaired_sequences,
+)
+from protenix.openfold_local.np import residue_constants
+from protenix.utils.distributed import DIST_WRAPPER
+
+# FeatureDict, make_dummy_msa_obj, convert_monomer_features
+# These are modified from openfold: data/data_pipeline
+try:
+    from protenix.openfold_local.data.tools import jackhmmer
+except ImportError:
+    print(
+        "Failed to import packages for searching MSA; can only run with precomputed MSA"
+    )
+
+logger = logging.getLogger(__name__)
+FeatureDict = MutableMapping[str, np.ndarray]
+
+
+SEQ_FEATURES = list(SEQ_FEATURES) + ["profile"]
+
+HHBLITS_INDEX_TO_OUR_INDEX = {
+    hhblits_index: (
+        PRO_STD_RESIDUES[PROT_STD_RESIDUES_ONE_TO_THREE[hhblits_letter]]
+        if hhblits_letter != "-"
+        else 31
+    )
+    for hhblits_index, hhblits_letter in residue_constants.ID_TO_HHBLITS_AA.items()
+}
+NEW_ORDER_LIST = tuple(
+    HHBLITS_INDEX_TO_OUR_INDEX[idx] for idx in range(len(HHBLITS_INDEX_TO_OUR_INDEX))
+)
+
+RNA_ID_TO_OUR_INDEX = {
+    key: RNA_STD_RESIDUES[value] if value != "-" else 31
+    for key, value in RNA_ID_TO_NT.items()
+}
+RNA_NEW_ORDER_LIST = tuple(
+    RNA_ID_TO_OUR_INDEX[idx] for idx in range(len(RNA_ID_TO_OUR_INDEX))
+)
+
+RNA_MSA_GAP_IDX = RNA_NT_TO_ID["-"]
+
+RNA_MSA_PAD_VALUES = {
+    "msa_all_seq": RNA_MSA_GAP_IDX,
+    "msa_mask_all_seq": 1,
+    "deletion_matrix_all_seq": 0,
+    "deletion_matrix_int_all_seq": 0,
+    "msa": RNA_MSA_GAP_IDX,
+    "msa_mask": 1,
+    "deletion_matrix": 0,
+    "deletion_matrix_int": 0,
+}
+
+REQUIRED_FEATURES = frozenset(
+    {
+        "asym_id",
+        "entity_id",
+        "sym_id",
+        "has_deletion",
+        "deletion_mean",
+        "deletion_value",
+        "msa",
+        "profile",
+        "num_alignments",
+        "residue_index",
+        "prot_pair_num_alignments",
+        "prot_unpair_num_alignments",
+        "rna_pair_num_alignments",
+        "rna_unpair_num_alignments",
+    }
+)
+
+PROT_TYPE_NAME = "proteinChain"  # inference protein name in json
+
+
+def make_dummy_msa_obj(input_sequence) -> parsers.Msa:
+    deletion_matrix = [[0 for _ in input_sequence]]
+    return parsers.Msa(
+        sequences=[input_sequence],
+        deletion_matrix=deletion_matrix,
+        descriptions=["dummy"],
+    )
+
+
+def convert_monomer_features(monomer_features: FeatureDict) -> FeatureDict:
+    """Reshapes and modifies monomer features for multimer models."""
+    converted = {}
+    unnecessary_leading_dim_feats = {
+        "sequence",
+        "domain_name",
+        "num_alignments",
+        "seq_length",
+    }
+    for feature_name, feature in monomer_features.items():
+        if feature_name in unnecessary_leading_dim_feats:
+            # asarray ensures it's a np.ndarray.
+            feature = np.asarray(feature[0], dtype=feature.dtype)
+        elif feature_name == "aatype":
+            # The multimer model performs the one-hot operation itself.
+            feature = np.argmax(feature, axis=-1).astype(np.int32)
+        converted[feature_name] = feature
+    return converted
+
+
+def make_sequence_features(
+    sequence: str,
+    num_res: int,
+    mapping: dict = residue_constants.restype_order_with_x,
+    x_token: str = "X",
+) -> FeatureDict:
+    """
+    Construct a feature dict of sequence features
+
+    Args:
+        sequence (str): input sequence
+        num_res (int): number of residues in the input sequence
+
+    Returns:
+        FeatureDict: basic features of the input sequence
+    """
+    features = {}
+    features["aatype"] = residue_constants.sequence_to_onehot(
+        sequence=sequence,
+        mapping=mapping,
+        map_unknown_to_x=True,
+        x_token=x_token,
+    )
+    features["between_segment_residues"] = np.zeros((num_res,), dtype=np.int32)
+    features["residue_index"] = np.array(range(num_res), dtype=np.int32) + 1
+    features["seq_length"] = np.array([num_res] * num_res, dtype=np.int32)
+    features["sequence"] = np.array([sequence.encode("utf-8")], dtype=object)
+    return features
+
+
+def make_msa_features(
+    msas: Sequence[parsers.Msa],
+    identifier_func: Callable,
+    mapping: tuple[dict] = (
+        residue_constants.HHBLITS_AA_TO_ID,
+        residue_constants.ID_TO_HHBLITS_AA,
+    ),
+) -> FeatureDict:
+    """
+        Constructs a feature dict of MSA features
+
+    Args:
+        msas (Sequence[parsers.Msa]): input MSA arrays
+        identifier_func (Callable): the function extracting species identifier from MSA
+
+    Returns:
+        FeatureDict: raw MSA features
+    """
+    if not msas:
+        raise ValueError("At least one MSA must be provided.")
+
+    int_msa = []
+    deletion_matrix = []
+    species_ids = []
+    seen_sequences = set()
+    for msa_index, msa in enumerate(msas):
+        if not msa:
+            raise ValueError(f"MSA {msa_index} must contain at least one sequence.")
+        for sequence_index, sequence in enumerate(msa.sequences):
+            if sequence in seen_sequences:
+                continue
+            seen_sequences.add(sequence)
+            int_msa.append([mapping[0][res] for res in sequence])
+            deletion_matrix.append(msa.deletion_matrix[sequence_index])
+
+            identifiers = identifier_func(
+                msa.descriptions[sequence_index],
+            )
+
+            species_ids.append(identifiers.species_id.encode("utf-8"))
+
+    # residue type from HHBLITS_AA_TO_ID
+    num_res = len(msas[0].sequences[0])
+    num_alignments = len(int_msa)
+    features = {}
+    features["deletion_matrix_int"] = np.array(deletion_matrix, dtype=np.int32)
+    features["msa"] = np.array(int_msa, dtype=np.int32)
+    features["num_alignments"] = np.array([num_alignments] * num_res, dtype=np.int32)
+    features["msa_species_identifiers"] = np.array(species_ids, dtype=np.object_)
+    features["profile"] = _make_msa_profile(
+        msa=features["msa"], dict_size=len(mapping[1])
+    )  # [num_res, 27]
+    return features
+
+
+def _make_msa_profile(msa: np.ndarray, dict_size: int) -> np.ndarray:
+    """
+    Make MSA profile (distribution over residues)
+
+    Args:
+        msas (Sequence[parsers.Msa]): input MSA arrays
+        dict_size (int): number of residue types
+
+    Returns:
+        np.array: MSA profile
+    """
+    num_seqs = msa.shape[0]
+    all_res_types = np.arange(dict_size)
+    res_type_hits = msa[..., None] == all_res_types[None, ...]
+    res_type_counts = res_type_hits.sum(axis=0)
+    profile = res_type_counts / num_seqs
+    return profile
+
+
+def parse_a3m(path: str, seq_limit: int) -> tuple[list[str], list[str]]:
+    """
+    Parse a .a3m file
+
+    Args:
+        path (str): file path
+        seq_limit (int): the max number of MSA sequences read from the file
+            seq_limit > 0: real limit
+            seq_limit = 0: return empty results
+            seq_limit < 0: no limit, return all results
+
+    Returns:
+        tuple[list[str], list[str]]: parsed MSA sequences and their corresponding descriptions
+    """
+    sequences, descriptions = [], []
+    if seq_limit == 0:
+        return sequences, descriptions
+
+    index = -1
+    with open(path, "r") as f:
+        for i, line in enumerate(f):
+            line = line.strip()
+            if line.startswith(">"):
+                if seq_limit > 0 and len(sequences) > seq_limit:
+                    break
+                index += 1
+                descriptions.append(line[1:])  # Remove the '>' at the beginning.
+                sequences.append("")
+                continue
+            elif line.startswith("#"):
+                continue
+            elif not line:
+                continue  # Skip blank lines.
+            sequences[index] += line
+
+    return sequences, descriptions
+
+
+def calc_stockholm_RNA_msa(
+    name_to_sequence: OrderedDict, query: Optional[str]
+) -> dict[str, parsers.Msa]:
+    """
+    Parses sequences and deletion matrix from stockholm format alignment.
+
+    Args:
+      stockholm_string: The string contents of a stockholm file. The first
+        sequence in the file should be the query sequence.
+
+    Returns:
+      A tuple of:
+        * A list of sequences that have been aligned to the query. These
+          might contain duplicates.
+        * The deletion matrix for the alignment as a list of lists. The element
+          at `deletion_matrix[i][j]` is the number of residues deleted from
+          the aligned sequence i at residue position j.
+        * The names of the targets matched, including the jackhmmer subsequence
+          suffix.
+    """
+    msa = []
+    deletion_matrix = []
+
+    if query is not None:
+        # Add query string to the alignment
+        if len(name_to_sequence.keys()) == 0:
+            # name_to_sequence = OrderedDict({"query": query})
+            return OrderedDict()
+        else:
+            query = align_query_to_sto(query, list(name_to_sequence.values())[0])
+            new_name_to_sequence = OrderedDict({"query": query})
+            new_name_to_sequence.update(name_to_sequence)
+            name_to_sequence = new_name_to_sequence
+
+    keep_columns = []
+    for seq_index, sequence in enumerate(name_to_sequence.values()):
+        if seq_index == 0:
+            # Gather the columns with gaps from the query
+            query = sequence
+            keep_columns = [i for i, res in enumerate(query) if res != "-"]
+
+        if len(sequence) < len(query):
+            sequence = sequence + "-" * (len(query) - len(sequence))
+
+        # Remove the columns with gaps in the query from all sequences.
+        aligned_sequence = "".join([sequence[c] for c in keep_columns])
+        # Convert lower case letter to upper case
+        aligned_sequence = aligned_sequence.upper()
+        msa.append(aligned_sequence)
+
+        # Count the number of deletions w.r.t. query.
+        deletion_vec = []
+        deletion_count = 0
+        for seq_res, query_res in zip(sequence, query):
+            if seq_res not in ["-", "."] or query_res != "-":
+                if query_res == "-":
+                    deletion_count += 1
+                else:
+                    deletion_vec.append(deletion_count)
+                    deletion_count = 0
+        deletion_matrix.append(deletion_vec)
+
+    return parsers.Msa(
+        sequences=msa,
+        deletion_matrix=deletion_matrix,
+        descriptions=list(name_to_sequence.keys()),
+    )
+
+
+def align_query_to_sto(query: str, sto_sequence: str):
+    """
+    Aligns the query sequence to a Stockholm sequence by inserting gaps where necessary.
+
+    Args:
+        query (str): The query sequence to be aligned.
+        sto_sequence (str): The Stockholm sequence to which the query is aligned.
+
+    Returns:
+        str: The aligned query sequence.
+    """
+    query = query.strip()
+    sto_sequence = sto_sequence.strip()
+
+    query_chars = []
+    j = 0
+
+    for i in range(len(sto_sequence)):
+        if sto_sequence[i].islower() or sto_sequence[i] == ".":
+            query_chars.append("-")
+        else:
+            query_chars.append(query[j])
+            j += 1
+
+    aligned_query = "".join(query_chars)
+
+    if j < len(query):
+        aligned_query += query[-(len(query) - j) :]
+
+    return aligned_query
+
+
+def parse_sto(path: str) -> OrderedDict:
+    """
+    Parses a Stockholm file and returns an ordered dictionary mapping sequence names to their sequences.
+
+    Args:
+        path (str): The path to the Stockholm file.
+
+    Returns:
+        OrderedDict: An ordered dictionary where keys are sequence names and values are the corresponding sequences.
+    """
+    name_to_sequence = OrderedDict()
+    with open(path, "r") as f:
+        for i, line in enumerate(f):
+            line = line.strip()
+            if not line or line.startswith(("#", "//")):
+                continue
+            name, sequence = line.split()
+            if name not in name_to_sequence:
+                name_to_sequence[name] = ""
+            name_to_sequence[name] += sequence
+    return name_to_sequence
+
+
+def parse_msa_data(
+    raw_msa_paths: Sequence[str],
+    seq_limits: Sequence[int],
+    msa_entity_type: str,
+    query: Optional[str] = None,
+) -> dict[str, parsers.Msa]:
+    """
+    Parses MSA data based on the entity type (protein or RNA).
+
+    Args:
+        raw_msa_paths (Sequence[str]): Paths to the MSA files.
+        seq_limits (Sequence[int]): Limits on the number of sequences to read from each file.
+        msa_entity_type (str): Type of MSA entity, either "prot" for protein or "rna" for RNA.
+        query (Optional[str]): The query sequence for RNA MSA parsing. Defaults to None.
+
+    Returns:
+        dict[str, parsers.Msa]: A dictionary containing the parsed MSA data.
+
+    Raises:
+        ValueError: If `msa_entity_type` is not "prot" or "rna".
+    """
+    if msa_entity_type == "prot":
+        return parse_prot_msa_data(raw_msa_paths, seq_limits)
+
+    if msa_entity_type == "rna":
+        return parse_rna_msa_data(raw_msa_paths, seq_limits, query=query)
+    return []
+
+
+def parse_rna_msa_data(
+    raw_msa_paths: Sequence[str],
+    seq_limits: Sequence[int],
+    query: Optional[str] = None,
+) -> dict[str, parsers.Msa]:
+    """
+    Parse MSAs for a sequence
+
+    Args:
+        raw_msa_paths (Sequence[str]): Paths of MSA files
+        seq_limits (Sequence[int]): The max number of MSA sequences read from each file
+
+    Returns:
+        Dict[str, parsers.Msa]: MSAs parsed from each file
+    """
+    msa_data = {}
+    for path, seq_limit in zip(raw_msa_paths, seq_limits):
+        name_to_sequence = parse_sto(path)
+        # The sto file has been truncated to a maximum length of seq_limit
+        msa = calc_stockholm_RNA_msa(
+            name_to_sequence=name_to_sequence,
+            query=query,
+        )
+        if len(msa) > 0:
+            msa_data[path] = msa
+    return msa_data
+
+
+def parse_prot_msa_data(
+    raw_msa_paths: Sequence[str],
+    seq_limits: Sequence[int],
+) -> dict[str, parsers.Msa]:
+    """
+    Parse MSAs for a sequence
+
+    Args:
+        raw_msa_paths (Sequence[str]): Paths of MSA files
+        seq_limits (Sequence[int]): The max number of MSA sequences read from each file
+
+    Returns:
+        Dict[str, parsers.Msa]: MSAs parsed from each file
+    """
+    msa_data = {}
+    for path, seq_limit in zip(raw_msa_paths, seq_limits):
+        sequences, descriptions = parse_a3m(path, seq_limit)
+
+        deletion_matrix = []
+        for msa_sequence in sequences:
+            deletion_vec = []
+            deletion_count = 0
+            for j in msa_sequence:
+                if j.islower():
+                    deletion_count += 1
+                else:
+                    deletion_vec.append(deletion_count)
+                    deletion_count = 0
+            deletion_matrix.append(deletion_vec)
+
+        # Make the MSA matrix out of aligned (deletion-free) sequences.
+        deletion_table = str.maketrans("", "", string.ascii_lowercase)
+        aligned_sequences = [s.translate(deletion_table) for s in sequences]
+        assert all([len(seq) == len(aligned_sequences[0]) for seq in aligned_sequences])
+        assert all([len(vec) == len(deletion_matrix[0]) for vec in deletion_matrix])
+
+        if len(aligned_sequences) > 0:
+            # skip empty file
+            msa = parsers.Msa(
+                sequences=aligned_sequences,
+                deletion_matrix=deletion_matrix,
+                descriptions=descriptions,
+            )
+            msa_data[path] = msa
+
+    return msa_data
+
+
+def load_and_process_msa(
+    pdb_name: str,
+    msa_type: str,
+    raw_msa_paths: Sequence[str],
+    seq_limits: Sequence[int],
+    identifier_func: Optional[Callable] = lambda x: Identifiers(),
+    input_sequence: Optional[str] = None,
+    handle_empty: str = "return_self",
+    msa_entity_type: str = "prot",
+) -> dict[str, Any]:
+    """
+    Load and process MSA features of a single sequence
+
+    Args:
+        pdb_name (str): f"{pdb_id}_{entity_id}" of the input entity
+        msa_type (str): Type of MSA ("pairing" or "non_pairing")
+        raw_msa_paths (Sequence[str]): Paths of MSA files
+        identifier_func (Optional[Callable]): The function extracting species identifier from MSA
+        input_sequence (str): The input sequence
+        handle_empty (str): How to handle empty MSA ("return_self" or "raise_error")
+        entity_type (str): rna or prot
+
+    Returns:
+        Dict[str, Any]: processed MSA features
+    """
+    msa_data = parse_msa_data(
+        raw_msa_paths, seq_limits, msa_entity_type=msa_entity_type, query=input_sequence
+    )
+    if len(msa_data) == 0:
+        if handle_empty == "return_self":
+            msa_data["dummy"] = make_dummy_msa_obj(input_sequence)
+        elif handle_empty == "raise_error":
+            ValueError(f"No valid {msa_type} MSA for {pdb_name}")
+        else:
+            raise NotImplementedError(
+                f"Unimplemented empty-handling method: {handle_empty}"
+            )
+    msas = list(msa_data.values())
+
+    if msa_type == "non_pairing":
+        return make_msa_features(
+            msas=msas,
+            identifier_func=identifier_func,
+            mapping=(
+                (residue_constants.HHBLITS_AA_TO_ID, residue_constants.ID_TO_HHBLITS_AA)
+                if msa_entity_type == "prot"
+                else (RNA_NT_TO_ID, RNA_ID_TO_NT)
+            ),
+        )
+    elif msa_type == "pairing":
+        all_seq_features = make_msa_features(
+            msas=msas,
+            identifier_func=identifier_func,
+            mapping=(
+                (residue_constants.HHBLITS_AA_TO_ID, residue_constants.ID_TO_HHBLITS_AA)
+                if msa_entity_type == "prot"
+                else (RNA_NT_TO_ID, RNA_ID_TO_NT)
+            ),
+        )
+        valid_feats = MSA_FEATURES + ("msa_species_identifiers",)
+        return {
+            f"{k}_all_seq": v for k, v in all_seq_features.items() if k in valid_feats
+        }
+
+
+def add_assembly_features(
+    pdb_id: str,
+    all_chain_features: MutableMapping[str, FeatureDict],
+    asym_to_entity_id: Mapping[int, str],
+) -> dict[str, FeatureDict]:
+    """
+    Add features to distinguish between chains.
+
+    Args:
+        all_chain_features (MutableMapping[str, FeatureDict]): A dictionary which maps chain_id to a dictionary of features for each chain.
+        asym_to_entity_id (Mapping[int, str]): A mapping from asym_id_int to entity_id
+
+    Returns:
+        all_chain_features (MutableMapping[str, FeatureDict]): all_chain_features with assembly features added
+    """
+    # Group the chains by entity
+    grouped_chains = defaultdict(list)
+    for asym_id_int, chain_features in all_chain_features.items():
+        entity_id = asym_to_entity_id[asym_id_int]
+        chain_features["asym_id"] = asym_id_int
+        grouped_chains[entity_id].append(chain_features)
+
+    new_all_chain_features = {}
+    for entity_id, group_chain_features in grouped_chains.items():
+        assert int(entity_id) >= 0
+        for sym_id, chain_features in enumerate(group_chain_features, start=1):
+            new_all_chain_features[f"{entity_id}_{sym_id}"] = chain_features
+            seq_length = chain_features["seq_length"]
+            chain_features["asym_id"] = (
+                chain_features["asym_id"] * np.ones(seq_length)
+            ).astype(np.int64)
+            chain_features["sym_id"] = (sym_id * np.ones(seq_length)).astype(np.int64)
+            chain_features["entity_id"] = (int(entity_id) * np.ones(seq_length)).astype(
+                np.int64
+            )
+            chain_features["pdb_id"] = pdb_id
+    return new_all_chain_features
+
+
+def process_unmerged_features(
+    all_chain_features: MutableMapping[str, Mapping[str, np.ndarray]]
+):
+    """
+    Postprocessing stage for per-chain features before merging
+
+    Args:
+        all_chain_features (MutableMapping[str, Mapping[str, np.ndarray]]): MSA features of all chains
+
+    Returns:
+        post-processed per-chain features
+    """
+    for chain_features in all_chain_features.values():
+        # Convert deletion matrices to float.
+        chain_features["deletion_matrix"] = np.asarray(
+            chain_features.pop("deletion_matrix_int"), dtype=np.float32
+        )
+        if "deletion_matrix_int_all_seq" in chain_features:
+            chain_features["deletion_matrix_all_seq"] = np.asarray(
+                chain_features.pop("deletion_matrix_int_all_seq"), dtype=np.float32
+            )
+
+        chain_features["deletion_mean"] = np.mean(
+            chain_features["deletion_matrix"], axis=0
+        )
+
+
+def pair_and_merge(
+    is_homomer_or_monomer: bool,
+    all_chain_features: MutableMapping[str, Mapping[str, np.ndarray]],
+    merge_method: str,
+    msa_crop_size: int,
+) -> dict[str, np.ndarray]:
+    """
+    Runs processing on features to augment, pair and merge
+
+    Args:
+        is_homomer_or_monomer (bool): True if the bioassembly is a homomer or a monomer
+        all_chain_features (MutableMapping[str, Mapping[str, np.ndarray]]):
+            A MutableMap of dictionaries of features for each chain.
+        merge_method (str): How to merge unpaired MSA features
+
+    Returns:
+        Dict[str, np.ndarray]: A dictionary of features
+    """
+
+    process_unmerged_features(all_chain_features)
+
+    np_chains_list = list(all_chain_features.values())
+
+    pair_msa_sequences = not is_homomer_or_monomer
+
+    if pair_msa_sequences:
+        np_chains_list = create_paired_features(chains=np_chains_list)
+        np_chains_list = deduplicate_unpaired_sequences(np_chains_list)
+
+    np_chains_list = crop_chains(
+        np_chains_list,
+        msa_crop_size=msa_crop_size,
+        pair_msa_sequences=pair_msa_sequences,
+    )
+
+    np_example = merge_chain_features(
+        np_chains_list=np_chains_list,
+        pair_msa_sequences=pair_msa_sequences,
+        merge_method=merge_method,
+        msa_entity_type="prot",
+    )
+
+    np_example = process_prot_final(np_example)
+
+    return np_example
+
+
+def rna_merge(
+    all_chain_features: MutableMapping[str, Mapping[str, np.ndarray]],
+    merge_method: str,
+    msa_crop_size: int,
+) -> dict[str, np.ndarray]:
+    """
+    Runs processing on features to augment and merge
+
+    Args:
+        all_chain_features (MutableMapping[str, Mapping[str, np.ndarray]]):
+            A MutableMap of dictionaries of features for each chain.
+        merge_method (str): how to merge unpaired MSA features
+
+    Returns:
+        Dict[str, np.ndarray]: A dictionary of features
+    """
+    process_unmerged_features(all_chain_features)
+    np_chains_list = list(all_chain_features.values())
+    np_chains_list = crop_chains(
+        np_chains_list,
+        msa_crop_size=msa_crop_size,
+        pair_msa_sequences=False,
+    )
+    np_example = merge_chain_features(
+        np_chains_list=np_chains_list,
+        pair_msa_sequences=False,
+        merge_method=merge_method,
+        msa_entity_type="rna",
+    )
+    np_example = process_rna_final(np_example)
+
+    return np_example
+
+
+def merge_chain_features(
+    np_chains_list: list[Mapping[str, np.ndarray]],
+    pair_msa_sequences: bool,
+    merge_method: str,
+    msa_entity_type: str = "prot",
+) -> Mapping[str, np.ndarray]:
+    """
+    Merges features for multiple chains to single FeatureDict
+
+    Args:
+        np_chains_list (List[Mapping[str, np.ndarray]]): List of FeatureDicts for each chain
+        pair_msa_sequences (bool): Whether to merge paired MSAs
+        merge_method (str): how to merge unpaired MSA features
+        msa_entity_type (str): protein or rna
+
+    Returns:
+        Single FeatureDict for entire bioassembly
+    """
+    np_chains_list = _merge_homomers_dense_features(
+        np_chains_list, merge_method, msa_entity_type=msa_entity_type
+    )
+
+    # Unpaired MSA features will be always block-diagonalised; paired MSA
+    # features will be concatenated.
+    np_example = _merge_features_from_multiple_chains(
+        np_chains_list,
+        pair_msa_sequences=False,
+        merge_method=merge_method,
+        msa_entity_type=msa_entity_type,
+    )
+
+    if pair_msa_sequences:
+        np_example = _concatenate_paired_and_unpaired_features(np_example)
+
+    np_example = _correct_post_merged_feats(
+        np_example=np_example,
+    )
+
+    return np_example
+
+
+def _merge_homomers_dense_features(
+    chains: Iterable[Mapping[str, np.ndarray]],
+    merge_method: str,
+    msa_entity_type: str = "prot",
+) -> list[dict[str, np.ndarray]]:
+    """
+    Merge all identical chains, making the resulting MSA dense
+
+    Args:
+        chains (Iterable[Mapping[str, np.ndarray]]): An iterable of features for each chain
+        merge_method (str): how to merge unpaired MSA features
+        msa_entity_type (str): protein or rna
+    Returns:
+        List[Dict[str, np.ndarray]]: A list of feature dictionaries. All features with the same entity_id
+        will be merged - MSA features will be concatenated along the num_res dimension - making them dense.
+    """
+    entity_chains = defaultdict(list)
+    for chain in chains:
+        entity_id = chain["entity_id"][0]
+        entity_chains[entity_id].append(chain)
+
+    grouped_chains = []
+    for entity_id in sorted(entity_chains):
+        chains = entity_chains[entity_id]
+        grouped_chains.append(chains)
+    chains = [
+        _merge_features_from_multiple_chains(
+            chains,
+            pair_msa_sequences=True,
+            merge_method=merge_method,
+            msa_entity_type=msa_entity_type,
+        )
+        for chains in grouped_chains
+    ]
+    return chains
+
+
+def _merge_msa_features(
+    *feats: np.ndarray,
+    feature_name: str,
+    merge_method: str,
+    msa_entity_type: str = "prot",
+) -> np.ndarray:
+    """
+    Merge unpaired MSA features
+
+    Args:
+        feats (np.ndarray): input features
+        feature_name (str): feature name
+        merge_method (str): how to merge unpaired MSA features
+        msa_entity_type (str): protein or rna
+    Returns:
+        np.ndarray: merged feature
+    """
+    assert msa_entity_type in ["prot", "rna"]
+    if msa_entity_type == "prot":
+        mapping = MSA_PAD_VALUES
+    elif msa_entity_type == "rna":
+        mapping = RNA_MSA_PAD_VALUES
+    if merge_method == "sparse":
+        merged_feature = block_diag(*feats, pad_value=mapping[feature_name])
+    elif merge_method in ["dense_min"]:
+        merged_feature = truncate_at_min(*feats)
+    elif merge_method in ["dense_max"]:
+        merged_feature = pad_to_max(*feats, pad_value=mapping[feature_name])
+    else:
+        raise NotImplementedError(
+            f"Unknown merge method {merge_method}! Allowed merged methods are: "
+        )
+    return merged_feature
+
+
+def _merge_features_from_multiple_chains(
+    chains: Sequence[Mapping[str, np.ndarray]],
+    pair_msa_sequences: bool,
+    merge_method: str,
+    msa_entity_type: str = "prot",
+) -> dict[str, np.ndarray]:
+    """
+    Merge features from multiple chains.
+
+    Args:
+        chains (Sequence[Mapping[str, np.ndarray]]):
+            A list of feature dictionaries that we want to merge
+        pair_msa_sequences (bool): Whether to concatenate MSA features along the
+            num_res dimension (if True), or to block diagonalize them (if False)
+        merge_method (str): how to merge unpaired MSA features
+        msa_entity_type (str): protein or rna
+    Returns:
+        Dict[str, np.ndarray]: A feature dictionary for the merged example
+    """
+    merged_example = {}
+    for feature_name in chains[0]:
+        feats = [x[feature_name] for x in chains]
+        feature_name_split = feature_name.split("_all_seq")[0]
+        if feature_name_split in MSA_FEATURES:
+            if pair_msa_sequences or "_all_seq" in feature_name:
+                merged_example[feature_name] = np.concatenate(feats, axis=1)
+            else:
+                merged_example[feature_name] = _merge_msa_features(
+                    *feats,
+                    merge_method=merge_method,
+                    feature_name=feature_name,
+                    msa_entity_type=msa_entity_type,
+                )
+        elif feature_name_split in SEQ_FEATURES:
+            merged_example[feature_name] = np.concatenate(feats, axis=0)
+        elif feature_name_split in CHAIN_FEATURES:
+            merged_example[feature_name] = np.sum([x for x in feats]).astype(np.int32)
+        else:
+            merged_example[feature_name] = feats[0]
+    return merged_example
+
+
+def merge_features_from_prot_rna(
+    chains: Sequence[Mapping[str, np.ndarray]],
+) -> dict[str, np.ndarray]:
+    """
+    Merge features from prot and rna chains.
+
+    Args:
+        chains (Sequence[Mapping[str, np.ndarray]]):
+            A list of feature dictionaries that we want to merge
+
+    Returns:
+        Dict[str, np.ndarray]: A feature dictionary for the merged example
+    """
+    merged_example = {}
+    if len(chains) == 1:  # only prot or rna msa exists
+        return chains[0]
+    final_msa_pad_values = {
+        "msa": 31,
+        "has_deletion": False,
+        "deletion_value": 0,
+    }
+    for feature_name in set(chains[0].keys()).union(chains[1].keys()):
+        feats = [x[feature_name] for x in chains if feature_name in x]
+        if (
+            feature_name in SEQ_FEATURES
+        ):  # ["residue_index", "profile", "asym_id", "sym_id", "entity_id", "deletion_mean"]
+            merged_example[feature_name] = np.concatenate(feats, axis=0)
+        elif feature_name in ["msa", "has_deletion", "deletion_value"]:
+            merged_example[feature_name] = pad_to_max(
+                *feats, pad_value=final_msa_pad_values[feature_name]
+            )
+        elif feature_name in [
+            "prot_pair_num_alignments",
+            "prot_unpair_num_alignments",
+            "rna_pair_num_alignments",
+            "rna_unpair_num_alignments",
+        ]:  # unmerged keys keep for tracking
+            merged_example[feature_name] = feats[0]
+        else:
+            continue
+    merged_example["num_alignments"] = np.asarray(
+        merged_example["msa"].shape[0], dtype=np.int32
+    )
+    return merged_example
+
+
+def _concatenate_paired_and_unpaired_features(
+    np_example: Mapping[str, np.ndarray]
+) -> dict[str, np.ndarray]:
+    """
+    Concatenate paired and unpaired features
+
+    Args:
+        np_example (Mapping[str, np.ndarray]): input features
+
+    Returns:
+        Dict[str, np.ndarray]: features with paired and unpaired features concatenated
+    """
+    features = MSA_FEATURES
+    for feature_name in features:
+        if feature_name in np_example:
+            feat = np_example[feature_name]
+            feat_all_seq = np_example[feature_name + "_all_seq"]
+            merged_feat = np.concatenate([feat_all_seq, feat], axis=0)
+            np_example[feature_name] = merged_feat
+    np_example["num_alignments"] = np.array(np_example["msa"].shape[0], dtype=np.int32)
+    return np_example
+
+
+def _correct_post_merged_feats(
+    np_example: Mapping[str, np.ndarray],
+) -> dict[str, np.ndarray]:
+    """
+    Adds features that need to be computed/recomputed post merging
+
+    Args:
+        np_example (Mapping[str, np.ndarray]): input features
+
+    Returns:
+        Dict[str, np.ndarray]: processed features
+    """
+
+    np_example["seq_length"] = np.asarray(np_example["aatype"].shape[0], dtype=np.int32)
+    np_example["num_alignments"] = np.asarray(
+        np_example["msa"].shape[0], dtype=np.int32
+    )
+    return np_example
+
+
+def _add_msa_num_alignment(
+    np_example: Mapping[str, np.ndarray], msa_entity_type: str = "prot"
+) -> dict[str, np.ndarray]:
+    """
+    Adds pair and unpair msa alignments num
+
+    Args:
+        np_example (Mapping[str, np.ndarray]): input features
+
+    Returns:
+        Dict[str, np.ndarray]: processed features
+    """
+    assert msa_entity_type in ["prot", "rna"]
+    if "msa_all_seq" in np_example:
+        pair_num_alignments = np.asarray(
+            np_example["msa_all_seq"].shape[0], dtype=np.int32
+        )
+    else:
+        pair_num_alignments = np.asarray(0, dtype=np.int32)
+    np_example[f"{msa_entity_type}_pair_num_alignments"] = pair_num_alignments
+    np_example[f"{msa_entity_type}_unpair_num_alignments"] = (
+        np_example["num_alignments"] - pair_num_alignments
+    )
+    return np_example
+
+
+def process_prot_final(np_example: Mapping[str, np.ndarray]) -> dict[str, np.ndarray]:
+    """
+    Final processing steps in data pipeline, after merging and pairing
+
+    Args:
+        np_example (Mapping[str, np.ndarray]): input features
+
+    Returns:
+        Dict[str, np.ndarray]: processed features
+    """
+    np_example = correct_msa_restypes(np_example)
+    np_example = final_transform(np_example)
+    np_example = _add_msa_num_alignment(np_example, msa_entity_type="prot")
+    np_example = filter_features(np_example)
+
+    return np_example
+
+
+def correct_msa_restypes(np_example: Mapping[str, np.ndarray]) -> dict[str, np.ndarray]:
+    """
+    Correct MSA restype to have the same order as residue_constants
+
+    Args:
+        np_example (Mapping[str, np.ndarray]): input features
+
+    Returns:
+        Dict[str, np.ndarray]: processed features
+    """
+    # remap msa
+    np_example["msa"] = np.take(NEW_ORDER_LIST, np_example["msa"], axis=0)
+    np_example["msa"] = np_example["msa"].astype(np.int32)
+
+    seq_len, profile_dim = np_example["profile"].shape
+    assert profile_dim == len(NEW_ORDER_LIST)
+    profile = np.zeros((seq_len, 32))
+    profile[:, np.array(NEW_ORDER_LIST)] = np_example["profile"]
+
+    np_example["profile"] = profile
+    return np_example
+
+
+def process_rna_final(np_example: Mapping[str, np.ndarray]) -> dict[str, np.ndarray]:
+    """
+    Final processing steps in data pipeline, after merging and pairing
+
+    Args:
+        np_example (Mapping[str, np.ndarray]): input features
+
+    Returns:
+        Dict[str, np.ndarray]: processed features
+    """
+    np_example = correct_rna_msa_restypes(np_example)
+    np_example = final_transform(np_example)
+    np_example = _add_msa_num_alignment(np_example, msa_entity_type="rna")
+    np_example = filter_features(np_example)
+
+    return np_example
+
+
+def correct_rna_msa_restypes(
+    np_example: Mapping[str, np.ndarray]
+) -> dict[str, np.ndarray]:
+    """
+    Correct MSA restype to have the same order as residue_constants
+
+    Args:
+        np_example (Mapping[str, np.ndarray]): input features
+
+    Returns:
+        Dict[str, np.ndarray]: processed features
+    """
+    # remap msa
+    np_example["msa"] = np.take(RNA_NEW_ORDER_LIST, np_example["msa"], axis=0)
+    np_example["msa"] = np_example["msa"].astype(np.int32)
+
+    seq_len, profile_dim = np_example["profile"].shape
+    assert profile_dim == len(RNA_NEW_ORDER_LIST)
+    profile = np.zeros((seq_len, 32))
+    profile[:, np.array(RNA_NEW_ORDER_LIST)] = np_example["profile"]
+
+    np_example["profile"] = profile
+    return np_example
+
+
+def final_transform(np_example: Mapping[str, np.ndarray]) -> dict[str, np.ndarray]:
+    """
+    Performing some transformations related to deletion_matrix
+
+    Args:
+        np_example (Mapping[str, np.ndarray]): input features
+
+    Returns:
+        Dict[str, np.ndarray]: processed features
+    """
+    deletion_mat = np_example.pop("deletion_matrix")
+    np_example["has_deletion"] = np.clip(deletion_mat, a_min=0, a_max=1).astype(
+        np.bool_
+    )
+
+    np_example["deletion_value"] = (2 / np.pi) * np.arctan(deletion_mat / 3)
+    assert np.all(-1e-5 < np_example["deletion_value"]) and np.all(
+        np_example["deletion_value"] < (1 + 1e-5)
+    )
+    return np_example
+
+
+def filter_features(np_example: Mapping[str, np.ndarray]) -> dict[str, np.ndarray]:
+    """
+    Filters features of example to only those requested
+
+    Args:
+        np_example (Mapping[str, np.ndarray]): input features
+
+    Returns:
+        Dict[str, np.ndarray]: processed features
+    """
+    return {k: v for (k, v) in np_example.items() if k in REQUIRED_FEATURES}
+
+
+def crop_chains(
+    chains_list: Sequence[Mapping[str, np.ndarray]],
+    msa_crop_size: int,
+    pair_msa_sequences: bool,
+) -> list[Mapping[str, np.ndarray]]:
+    """
+    Crops the MSAs for a set of chains.
+
+    Args:
+        chains_list (Sequence[Mapping[str, np.ndarray]]): A list of chains to be cropped.
+        msa_crop_size (int): The total number of sequences to crop from the MSA.
+        pair_msa_sequences (bool): Whether we are operating in sequence-pairing mode.
+
+    Returns:
+        List[Mapping[str, np.ndarray]]: The chains cropped
+    """
+
+    # Apply the cropping.
+    cropped_chains = []
+    for chain in chains_list:
+        cropped_chain = _crop_single_chain(
+            chain,
+            msa_crop_size=msa_crop_size,
+            pair_msa_sequences=pair_msa_sequences,
+        )
+        cropped_chains.append(cropped_chain)
+
+    return cropped_chains
+
+
+def _crop_single_chain(
+    chain: Mapping[str, np.ndarray],
+    msa_crop_size: int,  # 2048
+    pair_msa_sequences: bool,
+) -> dict[str, np.ndarray]:
+    """
+    Crops msa sequences to msa_crop_size
+
+    Args:
+        chain (Mapping[str, np.ndarray]): The chain to be cropped
+        msa_crop_size (int): The total number of sequences to crop from the MSA
+        pair_msa_sequences (bool): Whether we are operating in sequence-pairing mode
+
+    Returns:
+        Dict[str, np.ndarray]: The chains cropped
+    """
+    msa_size = chain["num_alignments"]
+
+    if pair_msa_sequences:
+        msa_size_all_seq = chain["num_alignments_all_seq"]
+        msa_crop_size_all_seq = np.minimum(msa_size_all_seq, msa_crop_size // 2)
+
+        # We reduce the number of un-paired sequences, by the number of times a
+        # sequence from this chain's MSA is included in the paired MSA.  This keeps
+        # the MSA size for each chain roughly constant.
+        msa_all_seq = chain["msa_all_seq"][:msa_crop_size_all_seq, :]
+        num_non_gapped_pairs = np.sum(np.any(msa_all_seq != MSA_GAP_IDX, axis=1))
+        num_non_gapped_pairs = np.minimum(num_non_gapped_pairs, msa_crop_size_all_seq)
+
+        # Restrict the unpaired crop size so that paired+unpaired sequences do not
+        # exceed msa_seqs_per_chain for each chain.
+        max_msa_crop_size = np.maximum(msa_crop_size - num_non_gapped_pairs, 0)
+        msa_crop_size = np.minimum(msa_size, max_msa_crop_size)
+    else:
+        msa_crop_size = np.minimum(msa_size, msa_crop_size)
+
+    for k in chain:
+        k_split = k.split("_all_seq")[0]
+        if k_split in MSA_FEATURES:
+            if "_all_seq" in k and pair_msa_sequences:
+                chain[k] = chain[k][:msa_crop_size_all_seq, :]
+            else:
+                chain[k] = chain[k][:msa_crop_size, :]
+
+    chain["num_alignments"] = np.asarray(msa_crop_size, dtype=np.int32)
+    if pair_msa_sequences:
+        chain["num_alignments_all_seq"] = np.asarray(
+            msa_crop_size_all_seq, dtype=np.int32
+        )
+    return chain
+
+
+def truncate_at_min(*arrs: np.ndarray) -> np.ndarray:
+    """
+    Processing unpaired features by truncating at the min length
+
+    Args:
+        arrs (np.ndarray): input features
+
+    Returns:
+        np.ndarray: truncated features
+    """
+    min_num_msa = min([x.shape[0] for x in arrs])
+    truncated_arrs = [x[:min_num_msa, :] for x in arrs]
+    new_arrs = np.concatenate(truncated_arrs, axis=1)
+    return new_arrs
+
+
+def pad_to_max(*arrs: np.ndarray, pad_value: float = 0.0) -> np.ndarray:
+    """
+    Processing unpaired features by padding to the max length
+
+    Args:
+        arrs (np.ndarray): input features
+
+    Returns:
+        np.ndarray: padded features
+    """
+    max_num_msa = max([x.shape[0] for x in arrs])
+    padded_arrs = [
+        np.pad(
+            x,
+            ((0, (max_num_msa - x.shape[0])), (0, 0)),
+            mode="constant",
+            constant_values=pad_value,
+        )
+        for x in arrs
+    ]
+    new_arrs = np.concatenate(padded_arrs, axis=1)
+    return new_arrs
+
+
+def clip_msa(
+    np_example: Mapping[str, np.ndarray], max_num_msa: int
+) -> dict[str, np.ndarray]:
+    """
+    Clip MSA features to a maximum length
+
+    Args:
+        np_example (Mapping[str, np.ndarray]): input MSA features
+        pad_value (float): pad value
+
+    Returns:
+        Dict[str, np.ndarray]: clipped MSA features
+    """
+    if np_example["msa"].shape[0] > max_num_msa:
+        for k in ["msa", "has_deletion", "deletion_value"]:
+            np_example[k] = np_example[k][:max_num_msa, :]
+        np_example["num_alignments"] = max_num_msa
+        assert np_example["num_alignments"] == np_example["msa"].shape[0]
+    return np_example
+
+
+def get_identifier_func(pairing_db: str) -> Callable:
+    """
+    Get the function the extracts species identifier from sequence descriptions
+
+    Args:
+        pairing_db (str): the database from which MSAs for pairing are searched
+
+    Returns:
+        Callable: the function the extracts species identifier from sequence descriptions
+    """
+    if pairing_db.startswith("uniprot"):
+
+        def func(description: str) -> Identifiers:
+            sequence_identifier = _extract_sequence_identifier(description)
+            if sequence_identifier is None:
+                return Identifiers()
+            else:
+                return _parse_sequence_identifier(sequence_identifier)
+
+        return func
+
+    elif pairing_db.startswith("uniref100"):
+
+        def func(description: str) -> Identifiers:
+            if (
+                description.startswith("UniRef100")
+                and "/" in description
+                and (first_comp := description.split("/")[0]).count("_") == 2
+            ):
+                identifier = Identifiers(species_id=first_comp.split("_")[-1])
+            else:
+                identifier = Identifiers()
+            return identifier
+
+        return func
+    else:
+        raise NotImplementedError(
+            f"Identifier func for {pairing_db} is not implemented"
+        )
+
+
+def run_msa_tool(
+    msa_runner,
+    fasta_path: str,
+    msa_out_path: str,
+    msa_format: str,
+    max_sto_sequences: Optional[int] = None,
+) -> Mapping[str, Any]:
+    """Runs an MSA tool, checking if output already exists first."""
+    if msa_format == "sto" and max_sto_sequences is not None:
+        result = msa_runner.query(fasta_path, max_sto_sequences)[0]
+    else:
+        result = msa_runner.query(fasta_path)[0]
+
+    assert msa_out_path.split(".")[-1] == msa_format
+    with open(msa_out_path, "w") as f:
+        f.write(result[msa_format])
+
+    return result
+
+
+def search_msa(sequence: str, db_fpath: str, res_fpath: str = ""):
+    assert opexists(
+        db_fpath
+    ), f"Database path for MSA searching does not exists:\n{db_fpath}"
+    seq_name = uuid.uuid4().hex
+    db_name = os.path.basename(db_fpath)
+    jackhmmer_binary_path = shutil.which("jackhmmer")
+    msa_runner = jackhmmer.Jackhmmer(
+        binary_path=jackhmmer_binary_path,
+        database_path=db_fpath,
+        n_cpu=2,
+    )
+    if res_fpath == "":
+        tmp_dir = f"/tmp/{uuid.uuid4().hex}"
+        res_fpath = os.path.join(tmp_dir, f"{seq_name}.a3m")
+    else:
+        tmp_dir = os.path.dirname(res_fpath)
+        os.makedirs(tmp_dir, exist_ok=True)
+    output_sto_path = os.path.join(tmp_dir, f"{seq_name}.sto")
+    with open((tmp_fasta_path := f"{tmp_dir}/{seq_name}_{db_name}.fasta"), "w") as f:
+        f.write(f">query\n")
+        f.write(sequence)
+
+    logger.info(f"Searching MSA for {seq_name}\n. Will be saved to {output_sto_path}")
+    _ = run_msa_tool(msa_runner, tmp_fasta_path, output_sto_path, "sto")
+    if not opexists(output_sto_path):
+        logger.info(f"Failed to search MSA for {sequence} from the database {db_fpath}")
+        return
+
+    logger.info(f"Reformatting the MSA file. Will be saved to {res_fpath}")
+
+    cmd = f"/opt/hhsuite/scripts/reformat.pl {output_sto_path} {res_fpath}"
+    try:
+        subprocess.check_call(cmd, shell=True, executable="/bin/bash")
+    except Exception as e:
+        logger.info(f"Reformatting failed:\n {e}\nRetry {cmd}...")
+        time.sleep(1)
+        subprocess.check_call(cmd, shell=True, executable="/bin/bash")
+    if not os.path.exists(res_fpath):
+        logger.info(
+            f"Failed to reformat the MSA file. Please check the validity of the .sto file{output_sto_path}"
+        )
+        return
+
+
+def search_msa_paired(
+    sequence: str, pairing_db_fpath: str, non_pairing_db_fpath: str, idx: int = -1
+) -> tuple[Union[str, None], int]:
+    tmp_dir = f"/tmp/{uuid.uuid4().hex}_{str(time.time()).replace('.', '_')}_{DIST_WRAPPER.rank}_{idx}"
+    os.makedirs(tmp_dir, exist_ok=True)
+    pairing_file = os.path.join(tmp_dir, "pairing.a3m")
+    search_msa(sequence, pairing_db_fpath, pairing_file)
+    if not os.path.exists(pairing_file):
+        return None, idx
+    non_pairing_file = os.path.join(tmp_dir, "non_pairing.a3m")
+    search_msa(sequence, non_pairing_db_fpath, non_pairing_file)
+    if not os.path.exists(non_pairing_file):
+        return None, idx
+    else:
+        return tmp_dir, idx
+
+
+def msa_parallel(sequences: dict[int, tuple[str, str, str]]) -> dict[int, str]:
+    from concurrent.futures import ThreadPoolExecutor
+
+    num_threads = 4
+    results = []
+    with ThreadPoolExecutor(max_workers=num_threads) as executor:
+        futures = [
+            executor.submit(search_msa_paired, seq[0], seq[1], seq[2], idx)
+            for idx, seq in sequences.items()
+        ]
+        # Wait for all threads to complete
+        for future in futures:
+            results.append(future.result())
+    msa_res = {}
+    for x in results:
+        msa_res[x[1]] = x[0]
+    return msa_res

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/data/parser.py

@@ -0,0 +1,1173 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import copy
+import functools
+import gzip
+import logging
+from collections import Counter
+from pathlib import Path
+from typing import Optional, Union
+
+import biotite.structure as struc
+import biotite.structure.io.pdbx as pdbx
+import numpy as np
+import pandas as pd
+from biotite.structure import AtomArray, get_chain_starts, get_residue_starts
+from biotite.structure.io.pdbx import convert as pdbx_convert
+from biotite.structure.molecules import get_molecule_indices
+
+from protenix.data import ccd
+from protenix.data.ccd import get_ccd_ref_info
+from protenix.data.constants import (
+    DNA_STD_RESIDUES,
+    PROT_STD_RESIDUES_ONE_TO_THREE,
+    RES_ATOMS_DICT,
+    RNA_STD_RESIDUES,
+    STD_RESIDUES,
+)
+from protenix.data.utils import get_starts_by
+
+logger = logging.getLogger(__name__)
+
+# Ignore inter residue metal coordinate bonds in mmcif _struct_conn
+if "metalc" in pdbx_convert.PDBX_COVALENT_TYPES:  # for reload
+    pdbx_convert.PDBX_COVALENT_TYPES.remove("metalc")
+
+
+class MMCIFParser:
+    def __init__(self, mmcif_file: Union[str, Path]) -> None:
+        self.cif = self._parse(mmcif_file=mmcif_file)
+
+    def _parse(self, mmcif_file: Union[str, Path]) -> pdbx.CIFFile:
+        mmcif_file = Path(mmcif_file)
+        if mmcif_file.suffix == ".gz":
+            with gzip.open(mmcif_file, "rt") as f:
+                cif_file = pdbx.CIFFile.read(f)
+        else:
+            with open(mmcif_file, "rt") as f:
+                cif_file = pdbx.CIFFile.read(f)
+        return cif_file
+
+    def get_category_table(self, name: str) -> Union[pd.DataFrame, None]:
+        if name not in self.cif.block:
+            return None
+        category = self.cif.block[name]
+        category_dict = {k: column.as_array() for k, column in category.items()}
+        return pd.DataFrame(category_dict, dtype=str)
+
+    @staticmethod
+    def mse_to_met(atom_array: AtomArray) -> AtomArray:
+        """
+        Ref: AlphaFold3 SI chapter 2.1
+        MSE residues are converted to MET residues.
+
+        Args:
+            atom_array (AtomArray): Biotite AtomArray object.
+
+        Returns:
+            AtomArray: Biotite AtomArray object after converted MSE to MET.
+        """
+        mse = atom_array.res_name == "MSE"
+        se = mse & (atom_array.atom_name == "SE")
+        atom_array.atom_name[se] = "SD"
+        atom_array.element[se] = "S"
+        atom_array.res_name[mse] = "MET"
+        atom_array.hetero[mse] = False
+        return atom_array
+
+    @functools.cached_property
+    def methods(self) -> list[str]:
+        """the methods to get the structure
+
+        most of the time, methods only has one method, such as 'X-RAY DIFFRACTION',
+        but about 233 entries have multi methods, such as ['X-RAY DIFFRACTION', 'NEUTRON DIFFRACTION'].
+
+        Allowed Values:
+        https://mmcif.wwpdb.org/dictionaries/mmcif_pdbx_v50.dic/Items/_exptl.method.html
+
+        Returns:
+            list[str]: such as ['X-RAY DIFFRACTION'], ['ELECTRON MICROSCOPY'], ['SOLUTION NMR', 'THEORETICAL MODEL'],
+                ['X-RAY DIFFRACTION', 'NEUTRON DIFFRACTION'], ['ELECTRON MICROSCOPY', 'SOLUTION NMR'], etc.
+        """
+        if "exptl" not in self.cif.block:
+            return []
+        else:
+            methods = self.cif.block["exptl"]["method"]
+            return methods.as_array()
+
+    def get_poly_res_names(
+        self, atom_array: Optional[AtomArray] = None
+    ) -> dict[str, list[str]]:
+        """get 3-letter residue names by combining mmcif._entity_poly_seq and atom_array
+
+        if ref_atom_array is None: keep first altloc residue of the same res_id based in mmcif._entity_poly_seq
+        if ref_atom_array is provided: keep same residue of ref_atom_array.
+
+        Returns
+            dict[str, list[str]]: label_entity_id --> [res_ids, res_names]
+        """
+        entity_res_names = {}
+        if atom_array is not None:
+            # build entity_id -> res_id -> res_name for input atom array
+            res_starts = struc.get_residue_starts(atom_array, add_exclusive_stop=False)
+            for start in res_starts:
+                entity_id = atom_array.label_entity_id[start]
+                res_id = atom_array.res_id[start]
+                res_name = atom_array.res_name[start]
+                if entity_id in entity_res_names:
+                    entity_res_names[entity_id][res_id] = res_name
+                else:
+                    entity_res_names[entity_id] = {res_id: res_name}
+
+        # build reference entity atom array, including missing residues
+        entity_poly_seq = self.get_category_table("entity_poly_seq")
+        if entity_poly_seq is None:
+            return {}
+
+        poly_res_names = {}
+        for entity_id, poly_type in self.entity_poly_type.items():
+            chain_mask = entity_poly_seq.entity_id == entity_id
+            seq_mon_ids = entity_poly_seq.mon_id[chain_mask].to_numpy(dtype=str)
+
+            # replace all MSE to MET in _entity_poly_seq.mon_id
+            seq_mon_ids[seq_mon_ids == "MSE"] = "MET"
+
+            seq_nums = entity_poly_seq.num[chain_mask].to_numpy(dtype=int)
+
+            if np.unique(seq_nums).size == seq_nums.size:
+                # no altloc residues
+                poly_res_names[entity_id] = seq_mon_ids
+                continue
+
+            # filter altloc residues, eg: 181 ALA (altloc A); 181 GLY (altloc B)
+            select_mask = np.zeros(len(seq_nums), dtype=bool)
+            matching_res_id = seq_nums[0]
+            for i, res_id in enumerate(seq_nums):
+                if res_id != matching_res_id:
+                    continue
+
+                res_name_in_atom_array = entity_res_names.get(entity_id, {}).get(res_id)
+                if res_name_in_atom_array is None:
+                    # res_name is mssing in atom_array,
+                    # keep first altloc residue of the same res_id
+                    select_mask[i] = True
+                else:
+                    # keep match residue to atom_array
+                    if res_name_in_atom_array == seq_mon_ids[i]:
+                        select_mask[i] = True
+
+                if select_mask[i]:
+                    matching_res_id += 1
+
+            seq_mon_ids = seq_mon_ids[select_mask]
+            seq_nums = seq_nums[select_mask]
+            assert len(seq_nums) == max(seq_nums)
+            poly_res_names[entity_id] = seq_mon_ids
+        return poly_res_names
+
+    def get_sequences(self, atom_array=None) -> dict:
+        """get sequence by combining mmcif._entity_poly_seq and atom_array
+
+        if ref_atom_array is None: keep first altloc residue of the same res_id based in mmcif._entity_poly_seq
+        if ref_atom_array is provided: keep same residue of atom_array.
+
+        Return
+            Dict{str:str}: label_entity_id --> canonical_sequence
+        """
+        sequences = {}
+        for entity_id, res_names in self.get_poly_res_names(atom_array).items():
+            seq = ccd.res_names_to_sequence(res_names)
+            sequences[entity_id] = seq
+        return sequences
+
+    @functools.cached_property
+    def entity_poly_type(self) -> dict[str, str]:
+        """
+        Ref: https://mmcif.wwpdb.org/dictionaries/mmcif_pdbx_v50.dic/Items/_entity_poly.type.html
+        Map entity_id to entity_poly_type.
+
+        Allowed Value:
+        · cyclic-pseudo-peptide
+        · other
+        · peptide nucleic acid
+        · polydeoxyribonucleotide
+        · polydeoxyribonucleotide/polyribonucleotide hybrid
+        · polypeptide(D)
+        · polypeptide(L)
+        · polyribonucleotide
+
+        Returns:
+            Dict: a dict of label_entity_id --> entity_poly_type.
+        """
+        entity_poly = self.get_category_table("entity_poly")
+        if entity_poly is None:
+            return {}
+
+        return {i: t for i, t in zip(entity_poly.entity_id, entity_poly.type)}
+
+    def filter_altloc(self, atom_array: AtomArray, altloc: str = "first"):
+        """
+        altloc: "first", "A", "B", "global_largest", etc
+
+        Filter first alternate coformation (altloc) of a given AtomArray.
+        - normally first altloc_id is 'A'
+        - but in one case, first altloc_id is '1' in 6uwi.cif
+
+        biotite v0.41 can not handle diff res_name at same res_id.
+        For example, in 2pxs.cif, there are two res_name (XYG|DYG) at res_id 63,
+        need to keep the first XYG.
+        """
+        if altloc == "all":
+            return atom_array
+
+        altloc_id = altloc
+        if altloc == "first":
+            letter_altloc_ids = np.unique(atom_array.label_alt_id)
+            if len(letter_altloc_ids) == 1 and letter_altloc_ids[0] == ".":
+                return atom_array
+            letter_altloc_ids = letter_altloc_ids[letter_altloc_ids != "."]
+            altloc_id = np.sort(letter_altloc_ids)[0]
+
+        return atom_array[np.isin(atom_array.label_alt_id, [altloc_id, "."])]
+
+    @staticmethod
+    def replace_auth_with_label(atom_array: AtomArray) -> AtomArray:
+        # fix issue https://github.com/biotite-dev/biotite/issues/553
+        atom_array.chain_id = atom_array.label_asym_id
+
+        # reset ligand res_id
+        res_id = copy.deepcopy(atom_array.label_seq_id)
+        chain_starts = get_chain_starts(atom_array, add_exclusive_stop=True)
+        for chain_start, chain_stop in zip(chain_starts[:-1], chain_starts[1:]):
+            if atom_array.label_seq_id[chain_start] != ".":
+                continue
+            else:
+                res_starts = get_residue_starts(
+                    atom_array[chain_start:chain_stop], add_exclusive_stop=True
+                )
+                num = 1
+                for res_start, res_stop in zip(res_starts[:-1], res_starts[1:]):
+                    res_id[chain_start:chain_stop][res_start:res_stop] = num
+                    num += 1
+
+        atom_array.res_id = res_id.astype(int)
+        return atom_array
+
+    def get_structure(
+        self,
+        altloc: str = "first",
+        model: int = 1,
+        bond_lenth_threshold: Union[float, None] = 2.4,
+    ) -> AtomArray:
+        """
+        Get an AtomArray created by bioassembly of MMCIF.
+
+        altloc: "first", "all", "A", "B", etc
+        model: the model number of the structure.
+        bond_lenth_threshold: the threshold of bond length. If None, no filter will be applied.
+                              Default is 2.4 Angstroms.
+
+        Returns:
+            AtomArray: Biotite AtomArray object created by bioassembly of MMCIF.
+        """
+        use_author_fields = True
+        extra_fields = ["label_asym_id", "label_entity_id", "auth_asym_id"]  # chain
+        extra_fields += ["label_seq_id", "auth_seq_id"]  # residue
+        atom_site_fields = {
+            "occupancy": "occupancy",
+            "pdbx_formal_charge": "charge",
+            "B_iso_or_equiv": "b_factor",
+            "label_alt_id": "label_alt_id",
+        }  # atom
+        for atom_site_name, alt_name in atom_site_fields.items():
+            if atom_site_name in self.cif.block["atom_site"]:
+                extra_fields.append(alt_name)
+
+        block = self.cif.block
+
+        extra_fields = set(extra_fields)
+
+        atom_site = block.get("atom_site")
+
+        models = atom_site["pdbx_PDB_model_num"].as_array(np.int32)
+        model_starts = pdbx_convert._get_model_starts(models)
+        model_count = len(model_starts)
+
+        if model == 0:
+            raise ValueError("The model index must not be 0")
+        # Negative models mean model indexing starting from last model
+
+        model = model_count + model + 1 if model < 0 else model
+        if model > model_count:
+            raise ValueError(
+                f"The file has {model_count} models, "
+                f"the given model {model} does not exist"
+            )
+
+        model_atom_site = pdbx_convert._filter_model(atom_site, model_starts, model)
+        # Any field of the category would work here to get the length
+        model_length = model_atom_site.row_count
+        atoms = AtomArray(model_length)
+
+        atoms.coord[:, 0] = model_atom_site["Cartn_x"].as_array(np.float32)
+        atoms.coord[:, 1] = model_atom_site["Cartn_y"].as_array(np.float32)
+        atoms.coord[:, 2] = model_atom_site["Cartn_z"].as_array(np.float32)
+
+        atoms.box = pdbx_convert._get_box(block)
+
+        # The below part is the same for both, AtomArray and AtomArrayStack
+        pdbx_convert._fill_annotations(
+            atoms, model_atom_site, extra_fields, use_author_fields
+        )
+
+        bonds = struc.connect_via_residue_names(atoms, inter_residue=False)
+        if "struct_conn" in block:
+            conn_bonds = pdbx_convert._parse_inter_residue_bonds(
+                model_atom_site, block["struct_conn"]
+            )
+            coord1 = atoms.coord[conn_bonds._bonds[:, 0]]
+            coord2 = atoms.coord[conn_bonds._bonds[:, 1]]
+            dist = np.linalg.norm(coord1 - coord2, axis=1)
+            if bond_lenth_threshold is not None:
+                conn_bonds._bonds = conn_bonds._bonds[dist < bond_lenth_threshold]
+            bonds = bonds.merge(conn_bonds)
+        atoms.bonds = bonds
+
+        atom_array = self.filter_altloc(atoms, altloc=altloc)
+
+        # inference inter residue bonds based on res_id (auth_seq_id) and label_asym_id.
+        atom_array = ccd.add_inter_residue_bonds(
+            atom_array,
+            exclude_struct_conn_pairs=True,
+            remove_far_inter_chain_pairs=True,
+        )
+
+        # use label_seq_id to match seq and structure
+        atom_array = self.replace_auth_with_label(atom_array)
+
+        # inference inter residue bonds based on new res_id (label_seq_id).
+        # the auth_seq_id is not reliable, some are discontinuous (8bvh), some with insertion codes (6ydy).
+        atom_array = ccd.add_inter_residue_bonds(
+            atom_array, exclude_struct_conn_pairs=True
+        )
+        return atom_array
+
+    def expand_assembly(
+        self, structure: AtomArray, assembly_id: str = "1"
+    ) -> AtomArray:
+        """
+        Expand the given assembly to all chains
+        copy from biotite.structure.io.pdbx.get_assembly
+
+        Args:
+            structure (AtomArray): The AtomArray of the structure to expand.
+            assembly_id (str, optional): The assembly ID in mmCIF file. Defaults to "1".
+                                         If assembly_id is "all", all assemblies will be returned.
+
+        Returns:
+            AtomArray: The assembly AtomArray.
+        """
+        block = self.cif.block
+
+        try:
+            assembly_gen_category = block["pdbx_struct_assembly_gen"]
+        except KeyError:
+            logging.info(
+                "File has no 'pdbx_struct_assembly_gen' category, return original structure."
+            )
+            return structure
+
+        try:
+            struct_oper_category = block["pdbx_struct_oper_list"]
+        except KeyError:
+            logging.info(
+                "File has no 'pdbx_struct_oper_list' category, return original structure."
+            )
+            return structure
+
+        assembly_ids = assembly_gen_category["assembly_id"].as_array(str)
+
+        if assembly_id != "all":
+            if assembly_id is None:
+                assembly_id = assembly_ids[0]
+            elif assembly_id not in assembly_ids:
+                raise KeyError(f"File has no Assembly ID '{assembly_id}'")
+
+        ### Calculate all possible transformations
+        transformations = pdbx_convert._get_transformations(struct_oper_category)
+
+        ### Get transformations and apply them to the affected asym IDs
+        assembly = None
+        assembly_1_mask = []
+        for id, op_expr, asym_id_expr in zip(
+            assembly_gen_category["assembly_id"].as_array(str),
+            assembly_gen_category["oper_expression"].as_array(str),
+            assembly_gen_category["asym_id_list"].as_array(str),
+        ):
+            # Find the operation expressions for given assembly ID
+            # We already asserted that the ID is actually present
+            if assembly_id == "all" or id == assembly_id:
+                operations = pdbx_convert._parse_operation_expression(op_expr)
+                asym_ids = asym_id_expr.split(",")
+                # Filter affected asym IDs
+                sub_structure = copy.deepcopy(
+                    structure[..., np.isin(structure.label_asym_id, asym_ids)]
+                )
+                sub_assembly = pdbx_convert._apply_transformations(
+                    sub_structure, transformations, operations
+                )
+                # Merge the chains with asym IDs for this operation
+                # with chains from other operations
+                if assembly is None:
+                    assembly = sub_assembly
+                else:
+                    assembly += sub_assembly
+
+                if id == "1":
+                    assembly_1_mask.extend([True] * len(sub_assembly))
+                else:
+                    assembly_1_mask.extend([False] * len(sub_assembly))
+
+        if assembly_id == "1" or assembly_id == "all":
+            assembly.set_annotation("assembly_1", np.array(assembly_1_mask))
+        return assembly
+
+
+class AddAtomArrayAnnot(object):
+    """
+    The methods in this class are all designed to add annotations to an AtomArray
+    without altering the information in the original AtomArray.
+    """
+
+    @staticmethod
+    def add_token_mol_type(
+        atom_array: AtomArray, sequences: dict[str, str]
+    ) -> AtomArray:
+        """
+        Add molecule types in atom_arry.mol_type based on ccd pdbx_type.
+
+        Args:
+            atom_array (AtomArray): Biotite AtomArray object.
+            sequences (dict[str, str]): A dict of label_entity_id --> canonical_sequence
+
+        Return
+            AtomArray: add atom_arry.mol_type = "protein" | "rna" | "dna" | "ligand"
+        """
+        mol_types = np.zeros(len(atom_array), dtype="U7")
+        starts = struc.get_residue_starts(atom_array, add_exclusive_stop=True)
+        for start, stop in zip(starts[:-1], starts[1:]):
+            entity_id = atom_array.label_entity_id[start]
+            if entity_id not in sequences:
+                # non-poly is ligand
+                mol_types[start:stop] = "ligand"
+                continue
+            res_name = atom_array.res_name[start]
+
+            mol_types[start:stop] = ccd.get_mol_type(res_name)
+
+        atom_array.set_annotation("mol_type", mol_types)
+        return atom_array
+
+    @staticmethod
+    def add_atom_mol_type_mask(atom_array: AtomArray) -> AtomArray:
+        """
+        Mask indicates is_protein / rna / dna / ligand.
+        It is atom-level which is different with paper (token-level).
+        The type of each atom is determined based on the most frequently
+        occurring type in the chain to which it belongs.
+
+        Args:
+            atom_array (AtomArray): Biotite AtomArray object
+
+        Returns:
+            AtomArray: Biotite AtomArray object with
+                       "is_ligand", "is_dna", "is_rna", "is_protein" annotation added.
+        """
+        # it should be called after mmcif_parser.add_token_mol_type
+        chain_starts = struc.get_chain_starts(atom_array, add_exclusive_stop=True)
+        chain_mol_type = []
+        for start, end in zip(chain_starts[:-1], chain_starts[1:]):
+            mol_types = atom_array.mol_type[start:end]
+            mol_type_count = Counter(mol_types)
+            most_freq_mol_type = max(mol_type_count, key=mol_type_count.get)
+            chain_mol_type.extend([most_freq_mol_type] * (end - start))
+        atom_array.set_annotation("chain_mol_type", chain_mol_type)
+
+        for type_str in ["ligand", "dna", "rna", "protein"]:
+            mask = (atom_array.chain_mol_type == type_str).astype(int)
+            atom_array.set_annotation(f"is_{type_str}", mask)
+        return atom_array
+
+    @staticmethod
+    def add_modified_res_mask(atom_array: AtomArray) -> AtomArray:
+        """
+        Ref: AlphaFold3 SI Chapter 5.9.3
+
+        Determine if an atom belongs to a modified residue,
+        which is used to calculate the Modified Residue Scores in sample ranking:
+        Modified residue scores are ranked according to the average pLDDT of the modified residue.
+
+        Args:
+            atom_array (AtomArray): Biotite AtomArray object
+
+        Returns:
+            AtomArray: Biotite AtomArray object with
+                       "modified_res_mask" annotation added.
+        """
+        modified_res_mask = []
+        starts = struc.get_residue_starts(atom_array, add_exclusive_stop=True)
+        for start, stop in zip(starts[:-1], starts[1:]):
+            res_name = atom_array.res_name[start]
+            mol_type = atom_array.mol_type[start]
+            res_atom_nums = stop - start
+            if res_name not in STD_RESIDUES and mol_type != "ligand":
+                modified_res_mask.extend([1] * res_atom_nums)
+            else:
+                modified_res_mask.extend([0] * res_atom_nums)
+        atom_array.set_annotation("modified_res_mask", modified_res_mask)
+        return atom_array
+
+    @staticmethod
+    def add_centre_atom_mask(atom_array: AtomArray) -> AtomArray:
+        """
+        Ref: AlphaFold3 SI Chapter 2.6
+            • A standard amino acid residue (Table 13) is represented as a single token.
+            • A standard nucleotide residue (Table 13) is represented as a single token.
+            • A modified amino acid or nucleotide residue is tokenized per-atom (i.e. N tokens for an N-atom residue)
+            • All ligands are tokenized per-atom
+        For each token we also designate a token centre atom, used in various places below:
+            • Cα for standard amino acids
+            • C1′ for standard nucleotides
+            • For other cases take the first and only atom as they are tokenized per-atom.
+
+        Args:
+            atom_array (AtomArray): Biotite AtomArray object
+
+        Returns:
+            AtomArray: Biotite AtomArray object with "centre_atom_mask" annotation added.
+        """
+        res_name = list(STD_RESIDUES.keys())
+        std_res = np.isin(atom_array.res_name, res_name) & (
+            atom_array.mol_type != "ligand"
+        )
+        prot_res = np.char.str_len(atom_array.res_name) == 3
+        prot_centre_atom = prot_res & (atom_array.atom_name == "CA")
+        nuc_centre_atom = (~prot_res) & (atom_array.atom_name == r"C1'")
+        not_std_res = ~std_res
+        centre_atom_mask = (
+            std_res & (prot_centre_atom | nuc_centre_atom)
+        ) | not_std_res
+        centre_atom_mask = centre_atom_mask.astype(int)
+        atom_array.set_annotation("centre_atom_mask", centre_atom_mask)
+        return atom_array
+
+    @staticmethod
+    def add_distogram_rep_atom_mask(atom_array: AtomArray) -> AtomArray:
+        """
+        Ref: AlphaFold3 SI Chapter 4.4
+        the representative atom mask for each token for distogram head
+        • Cβ for protein residues (Cα for glycine),
+        • C4 for purines and C2 for pyrimidines.
+        • All ligands already have a single atom per token.
+
+        Due to the lack of explanation regarding the handling of "N" and "DN" in the article,
+        it is impossible to determine the representative atom based on whether it is a purine or pyrimidine.
+        Therefore, C1' is chosen as the representative atom for both "N" and "DN".
+
+        Args:
+            atom_array (AtomArray): Biotite AtomArray object
+
+        Returns:
+            AtomArray: Biotite AtomArray object with "distogram_rep_atom_mask" annotation added.
+        """
+        std_res = np.isin(atom_array.res_name, list(STD_RESIDUES.keys())) & (
+            atom_array.mol_type != "ligand"
+        )
+
+        # for protein std res
+        std_prot_res = std_res & (np.char.str_len(atom_array.res_name) == 3)
+        gly = atom_array.res_name == "GLY"
+        prot_cb = std_prot_res & (~gly) & (atom_array.atom_name == "CB")
+        prot_gly_ca = gly & (atom_array.atom_name == "CA")
+
+        # for nucleotide std res
+        purines_c4 = np.isin(atom_array.res_name, ["DA", "DG", "A", "G"]) & (
+            atom_array.atom_name == "C4"
+        )
+        pyrimidines_c2 = np.isin(atom_array.res_name, ["DC", "DT", "C", "U"]) & (
+            atom_array.atom_name == "C2"
+        )
+
+        # for nucleotide unk res
+        unk_nuc = np.isin(atom_array.res_name, ["DN", "N"]) & (
+            atom_array.atom_name == r"C1'"
+        )
+
+        distogram_rep_atom_mask = (
+            prot_cb | prot_gly_ca | purines_c4 | pyrimidines_c2 | unk_nuc
+        ) | (~std_res)
+        distogram_rep_atom_mask = distogram_rep_atom_mask.astype(int)
+
+        atom_array.set_annotation("distogram_rep_atom_mask", distogram_rep_atom_mask)
+
+        assert np.sum(atom_array.distogram_rep_atom_mask) == np.sum(
+            atom_array.centre_atom_mask
+        )
+
+        return atom_array
+
+    @staticmethod
+    def add_plddt_m_rep_atom_mask(atom_array: AtomArray) -> AtomArray:
+        """
+        Ref: AlphaFold3 SI Chapter 4.3.1
+        the representative atom for plddt loss
+        • Atoms such that the distance in the ground truth between atom l and atom m is less than 15 Å
+            if m is a protein atom or less than 30 Å if m is a nucleic acid atom.
+        • Only atoms in polymer chains.
+        • One atom per token - Cα for standard protein residues
+            and C1′ for standard nucleic acid residues.
+
+        Args:
+            atom_array (AtomArray): Biotite AtomArray object
+
+        Returns:
+            AtomArray: Biotite AtomArray object with "plddt_m_rep_atom_mask" annotation added.
+        """
+        std_res = np.isin(atom_array.res_name, list(STD_RESIDUES.keys())) & (
+            atom_array.mol_type != "ligand"
+        )
+        ca_or_c1 = (atom_array.atom_name == "CA") | (atom_array.atom_name == r"C1'")
+        plddt_m_rep_atom_mask = (std_res & ca_or_c1).astype(int)
+        atom_array.set_annotation("plddt_m_rep_atom_mask", plddt_m_rep_atom_mask)
+        return atom_array
+
+    @staticmethod
+    def add_ref_space_uid(atom_array: AtomArray) -> AtomArray:
+        """
+        Ref: AlphaFold3 SI Chapter 2.8 Table 5
+        Numerical encoding of the chain id and residue index associated with this reference conformer.
+        Each (chain id, residue index) tuple is assigned an integer on first appearance.
+
+        Args:
+            atom_array (AtomArray): Biotite AtomArray object
+
+        Returns:
+            AtomArray: Biotite AtomArray object with "ref_space_uid" annotation added.
+        """
+        # [N_atom, 2]
+        chain_res_id = np.vstack((atom_array.asym_id_int, atom_array.res_id)).T
+        unique_id = np.unique(chain_res_id, axis=0)
+
+        mapping_dict = {}
+        for idx, chain_res_id_pair in enumerate(unique_id):
+            asym_id_int, res_id = chain_res_id_pair
+            mapping_dict[(asym_id_int, res_id)] = idx
+
+        ref_space_uid = [
+            mapping_dict[(asym_id_int, res_id)] for asym_id_int, res_id in chain_res_id
+        ]
+        atom_array.set_annotation("ref_space_uid", ref_space_uid)
+        return atom_array
+
+    @staticmethod
+    def add_cano_seq_resname(atom_array: AtomArray) -> AtomArray:
+        """
+        Assign to each atom the three-letter residue name (resname)
+        corresponding to its place in the canonical sequences.
+        Non-standard residues are mapped to standard ones.
+        Residues that cannot be mapped to standard residues and ligands are all labeled as "UNK".
+
+        Note: Some CCD Codes in the canonical sequence are mapped to three letters. It is labeled as one "UNK".
+
+        Args:
+            atom_array (AtomArray): Biotite AtomArray object
+
+        Returns:
+            AtomArray: Biotite AtomArray object with "cano_seq_resname" annotation added.
+        """
+        cano_seq_resname = []
+        starts = struc.get_residue_starts(atom_array, add_exclusive_stop=True)
+        for start, stop in zip(starts[:-1], starts[1:]):
+            res_atom_nums = stop - start
+            mol_type = atom_array.mol_type[start]
+            resname = atom_array.res_name[start]
+
+            one_letter_code = ccd.get_one_letter_code(resname)
+            if one_letter_code is None or len(one_letter_code) != 1:
+                # Some non-standard residues cannot be mapped back to one standard residue.
+                one_letter_code = "X" if mol_type == "protein" else "N"
+
+            if mol_type == "protein":
+                res_name_in_cano_seq = PROT_STD_RESIDUES_ONE_TO_THREE.get(
+                    one_letter_code, "UNK"
+                )
+            elif mol_type == "dna":
+                res_name_in_cano_seq = "D" + one_letter_code
+                if res_name_in_cano_seq not in DNA_STD_RESIDUES:
+                    res_name_in_cano_seq = "DN"
+            elif mol_type == "rna":
+                res_name_in_cano_seq = one_letter_code
+                if res_name_in_cano_seq not in RNA_STD_RESIDUES:
+                    res_name_in_cano_seq = "N"
+            else:
+                # some molecules attached to a polymer like ATP-RNA. e.g.
+                res_name_in_cano_seq = "UNK"
+
+            cano_seq_resname.extend([res_name_in_cano_seq] * res_atom_nums)
+
+        atom_array.set_annotation("cano_seq_resname", cano_seq_resname)
+        return atom_array
+
+    @staticmethod
+    def remove_bonds_between_polymer_chains(
+        atom_array: AtomArray, entity_poly_type: dict[str, str]
+    ) -> struc.BondList:
+        """
+        Remove bonds between polymer chains based on entity_poly_type
+
+        Args:
+            atom_array (AtomArray): Biotite AtomArray object
+            entity_poly_type (dict[str, str]): entity_id to poly_type
+
+        Returns:
+            BondList: Biotite BondList object (copy) with bonds between polymer chains removed
+        """
+        copy = atom_array.bonds.copy()
+        polymer_mask = np.isin(
+            atom_array.label_entity_id, list(entity_poly_type.keys())
+        )
+        i = copy._bonds[:, 0]
+        j = copy._bonds[:, 1]
+        pp_bond_mask = polymer_mask[i] & polymer_mask[j]
+        diff_chain_mask = atom_array.chain_id[i] != atom_array.chain_id[j]
+        pp_bond_mask = pp_bond_mask & diff_chain_mask
+        copy._bonds = copy._bonds[~pp_bond_mask]
+
+        # post-process after modified bonds manually
+        # due to the extraction of bonds using a mask, the lower one of the two atom indices is still in the first
+        copy._remove_redundant_bonds()
+        copy._max_bonds_per_atom = copy._get_max_bonds_per_atom()
+        return copy
+
+    @staticmethod
+    def find_equiv_mol_and_assign_ids(
+        atom_array: AtomArray,
+        entity_poly_type: Optional[dict[str, str]] = None,
+        check_final_equiv: bool = True,
+    ) -> AtomArray:
+        """
+        Assign a unique integer to each molecule in the structure.
+        All atoms connected by covalent bonds are considered as a molecule, with unique mol_id (int).
+        different copies of same molecule will assign same entity_mol_id (int).
+        for each mol, assign mol_atom_index starting from 0.
+
+        Args:
+            atom_array (AtomArray): Biotite AtomArray object
+            entity_poly_type (Optional[dict[str, str]]): label_entity_id to entity.poly_type.
+                              Defaults to None.
+            check_final_equiv (bool, optional): check if the final mol_ids of same entity_mol_id are all equivalent.
+
+        Returns:
+            AtomArray: Biotite AtomArray object with new annotations
+            - mol_id: atoms with covalent bonds connected, 0-based int
+            - entity_mol_id: equivalent molecules will assign same entity_mol_id, 0-based int
+            - mol_residue_index: mol_atom_index for each mol, 0-based int
+        """
+        # Re-assign mol_id to AtomArray after break asym bonds
+        if entity_poly_type is None:
+            mol_indices: list[np.ndarray] = get_molecule_indices(atom_array)
+        else:
+            bonds_filtered = AddAtomArrayAnnot.remove_bonds_between_polymer_chains(
+                atom_array, entity_poly_type
+            )
+            mol_indices: list[np.ndarray] = get_molecule_indices(bonds_filtered)
+
+        # assign mol_id
+        mol_ids = np.array([-1] * len(atom_array), dtype=np.int32)
+        for mol_id, atom_indices in enumerate(mol_indices):
+            mol_ids[atom_indices] = mol_id
+        atom_array.set_annotation("mol_id", mol_ids)
+
+        assert ~np.isin(-1, atom_array.mol_id), "Some mol_id is not assigned."
+        assert len(np.unique(atom_array.mol_id)) == len(
+            mol_indices
+        ), "Some mol_id is duplicated."
+
+        # assign entity_mol_id
+        # --------------------
+        # first atom of mol with infos in attrubites, eg: info.num_atoms, info.bonds, ...
+        ref_mol_infos = []
+        # perm for keep multiple chains in one mol are together and in same chain order
+        new_atom_perm = []
+        chain_starts = struc.get_chain_starts(atom_array, add_exclusive_stop=False)
+        entity_mol_ids = np.zeros_like(mol_ids)
+        for mol_id, atom_indices in enumerate(mol_indices):
+            atom_indices = np.sort(atom_indices)
+            # keep multiple chains-mol has same chain order in different copies
+            chain_perm = np.argsort(
+                atom_array.label_entity_id[atom_indices], kind="stable"
+            )
+            atom_indices = atom_indices[chain_perm]
+            # save indices for finally re-ordering atom_array
+            new_atom_perm.extend(atom_indices)
+
+            # check mol equal, keep chain order consistent with atom_indices
+            mol_chain_mask = np.isin(atom_indices, chain_starts)
+            entity_ids = atom_array.label_entity_id[atom_indices][
+                mol_chain_mask
+            ].tolist()
+
+            match_entity_mol_id = None
+            for entity_mol_id, mol_info in enumerate(ref_mol_infos):
+                # check mol equal
+                # same entity_ids and same atom name will assign same entity_mol_id
+                if entity_ids != mol_info.entity_ids:
+                    continue
+
+                if len(atom_indices) != len(mol_info.atom_name):
+                    continue
+
+                atom_name_not_equal = (
+                    atom_array.atom_name[atom_indices] != mol_info.atom_name
+                )
+                if np.any(atom_name_not_equal):
+                    diff_indices = np.where(atom_name_not_equal)[0]
+                    query_atom = atom_array[atom_indices[diff_indices[0]]]
+                    ref_atom = atom_array[mol_info.atom_indices[diff_indices[0]]]
+                    logger.warning(
+                        f"Two mols have entity_ids and same number of atoms, but diff atom name:\n{query_atom=}\n{  ref_atom=}"
+                    )
+                    continue
+
+                # pass all checks, it is a match
+                match_entity_mol_id = entity_mol_id
+                break
+
+            if match_entity_mol_id is None:  # not found match mol
+                # use first atom as a placeholder for mol info.
+                mol_info = atom_array[atom_indices[0]]
+                mol_info.atom_indices = atom_indices
+                mol_info.entity_ids = entity_ids
+                mol_info.atom_name = atom_array.atom_name[atom_indices]
+                mol_info.entity_mol_id = len(ref_mol_infos)
+                ref_mol_infos.append(mol_info)
+                match_entity_mol_id = mol_info.entity_mol_id
+
+            entity_mol_ids[atom_indices] = match_entity_mol_id
+
+        atom_array.set_annotation("entity_mol_id", entity_mol_ids)
+
+        # re-order atom_array to make atoms with same mol_id together.
+        atom_array = atom_array[new_atom_perm]
+
+        # assign mol_atom_index
+        mol_starts = get_starts_by(
+            atom_array, by_annot="mol_id", add_exclusive_stop=True
+        )
+        mol_atom_index = np.zeros_like(atom_array.mol_id, dtype=np.int32)
+        for start, stop in zip(mol_starts[:-1], mol_starts[1:]):
+            mol_atom_index[start:stop] = np.arange(stop - start)
+        atom_array.set_annotation("mol_atom_index", mol_atom_index)
+
+        # check mol equivalence again
+        if check_final_equiv:
+            num_mols = len(mol_starts) - 1
+            for i in range(num_mols):
+                for j in range(i + 1, num_mols):
+                    start_i, stop_i = mol_starts[i], mol_starts[i + 1]
+                    start_j, stop_j = mol_starts[j], mol_starts[j + 1]
+                    if (
+                        atom_array.entity_mol_id[start_i]
+                        != atom_array.entity_mol_id[start_j]
+                    ):
+                        continue
+                    for key in ["res_name", "atom_name", "mol_atom_index"]:
+                        # not check res_id for ligand may have different res_id
+                        annot = getattr(atom_array, key)
+                        assert np.all(
+                            annot[start_i:stop_i] == annot[start_j:stop_j]
+                        ), f"not equal {key} when find_equiv_mol_and_assign_ids()"
+
+        return atom_array
+
+    @staticmethod
+    def add_tokatom_idx(atom_array: AtomArray) -> AtomArray:
+        """
+        Add a tokatom_idx corresponding to the residue and atom name for each atom.
+        For non-standard residues or ligands, the tokatom_idx should be set to 0.
+
+        Parameters:
+        atom_array (AtomArray): The AtomArray object to which the annotation will be added.
+
+        Returns:
+        AtomArray: The AtomArray object with the 'tokatom_idx' annotation added.
+        """
+        # pre-defined atom name order for tokatom_idx
+        tokatom_idx_list = []
+        for atom in atom_array:
+            atom_name_position = RES_ATOMS_DICT.get(atom.res_name, None)
+            if atom.mol_type == "ligand" or atom_name_position is None:
+                tokatom_idx = 0
+            else:
+                tokatom_idx = atom_name_position[atom.atom_name]
+            tokatom_idx_list.append(tokatom_idx)
+        atom_array.set_annotation("tokatom_idx", tokatom_idx_list)
+        return atom_array
+
+    @staticmethod
+    def add_mol_id(atom_array: AtomArray) -> AtomArray:
+        """
+        Assign a unique integer to each molecule in the structure.
+
+        Args:
+            atom_array (AtomArray): Biotite AtomArray object
+        Returns:
+            AtomArray: Biotite AtomArray object with new annotations
+            - mol_id: atoms with covalent bonds connected, 0-based int
+        """
+        mol_indices = get_molecule_indices(atom_array)
+
+        # assign mol_id
+        mol_ids = np.array([-1] * len(atom_array), dtype=np.int32)
+        for mol_id, atom_indices in enumerate(mol_indices):
+            mol_ids[atom_indices] = mol_id
+        atom_array.set_annotation("mol_id", mol_ids)
+        return atom_array
+
+    @staticmethod
+    def unique_chain_and_add_ids(atom_array: AtomArray) -> AtomArray:
+        """
+        Unique chain ID and add asym_id, entity_id, sym_id.
+        Adds a number to the chain ID to make chain IDs in the assembly unique.
+        Example: [A, B, A, B, C] ==> [A0, B0, A1, B1, C0]
+
+        Args:
+            atom_array (AtomArray): Biotite AtomArray object.
+
+        Returns:
+            AtomArray: Biotite AtomArray object with new annotations:
+                - asym_id_int: np.array(int)
+                - entity_id_int: np.array(int)
+                - sym_id_int: np.array(int)
+        """
+        entity_id_uniq = np.sort(np.unique(atom_array.label_entity_id))
+        entity_id_dict = {e: i for i, e in enumerate(entity_id_uniq)}
+        asym_ids = np.zeros(len(atom_array), dtype=int)
+        entity_ids = np.zeros(len(atom_array), dtype=int)
+        sym_ids = np.zeros(len(atom_array), dtype=int)
+        chain_ids = np.zeros(len(atom_array), dtype="U4")
+        counter = Counter()
+        start_indices = struc.get_chain_starts(atom_array, add_exclusive_stop=True)
+        for i in range(len(start_indices) - 1):
+            start_i = start_indices[i]
+            stop_i = start_indices[i + 1]
+            asym_ids[start_i:stop_i] = i
+
+            entity_id = atom_array.label_entity_id[start_i]
+            entity_ids[start_i:stop_i] = entity_id_dict[entity_id]
+
+            sym_ids[start_i:stop_i] = counter[entity_id]
+            counter[entity_id] += 1
+            new_chain_id = f"{atom_array.chain_id[start_i]}{sym_ids[start_i]}"
+            chain_ids[start_i:stop_i] = new_chain_id
+
+        atom_array.set_annotation("asym_id_int", asym_ids)
+        atom_array.set_annotation("entity_id_int", entity_ids)
+        atom_array.set_annotation("sym_id_int", sym_ids)
+        atom_array.chain_id = chain_ids
+        return atom_array
+
+    @staticmethod
+    def add_int_id(atom_array):
+        """
+        Unique chain ID and add asym_id, entity_id, sym_id.
+        Adds a number to the chain ID to make chain IDs in the assembly unique.
+        Example: [A, B, A, B, C] ==> [A0, B0, A1, B1, C0]
+
+        Args:
+            atom_array (AtomArray): Biotite AtomArray object.
+
+        Returns:
+            AtomArray: Biotite AtomArray object with new annotations:
+                - asym_id_int: np.array(int)
+                - entity_id_int: np.array(int)
+                - sym_id_int: np.array(int)
+        """
+        entity_id_uniq = np.sort(np.unique(atom_array.label_entity_id))
+        entity_id_dict = {e: i for i, e in enumerate(entity_id_uniq)}
+        asym_ids = np.zeros(len(atom_array), dtype=int)
+        entity_ids = np.zeros(len(atom_array), dtype=int)
+        sym_ids = np.zeros(len(atom_array), dtype=int)
+        counter = Counter()
+        start_indices = struc.get_chain_starts(atom_array, add_exclusive_stop=True)
+        for i in range(len(start_indices) - 1):
+            start_i = start_indices[i]
+            stop_i = start_indices[i + 1]
+            asym_ids[start_i:stop_i] = i
+
+            entity_id = atom_array.label_entity_id[start_i]
+            entity_ids[start_i:stop_i] = entity_id_dict[entity_id]
+
+            sym_ids[start_i:stop_i] = counter[entity_id]
+            counter[entity_id] += 1
+
+        atom_array.set_annotation("asym_id_int", asym_ids)
+        atom_array.set_annotation("entity_id_int", entity_ids)
+        atom_array.set_annotation("sym_id_int", sym_ids)
+        return atom_array
+
+    @staticmethod
+    def add_ref_feat_info(
+        atom_array: AtomArray,
+    ) -> tuple[np.ndarray, np.ndarray, list[int]]:
+        """
+        Get info of reference structure of atoms based on the atom array.
+
+        Args:
+            atom_array (AtomArray): The atom array.
+
+        Returns:
+            tuple:
+                ref_pos (numpy.ndarray): Atom positions in the reference conformer,
+                                         with a random rotation and translation applied.
+                                         Atom positions are given in Å. Shape=(num_atom, 3).
+                ref_charge (numpy.ndarray): Charge for each atom in the reference conformer. Shape=(num_atom）
+                ref_mask ((numpy.ndarray): Mask indicating which atom slots are used in the reference conformer. Shape=(num_atom）
+        """
+        info_dict = {}
+        for ccd_id in np.unique(atom_array.res_name):
+            # create ref conformer for each CCD ID
+            ref_result = get_ccd_ref_info(ccd_id)
+            if ref_result:
+                for space_uid in np.unique(
+                    atom_array[atom_array.res_name == ccd_id].ref_space_uid
+                ):
+                    if ref_result:
+                        info_dict[space_uid] = [
+                            ref_result["atom_map"],
+                            ref_result["coord"],
+                            ref_result["charge"],
+                            ref_result["mask"],
+                        ]
+            else:
+                # get conformer failed will result in an empty dictionary
+                continue
+
+        ref_mask = []  # [N_atom]
+        ref_pos = []  # [N_atom, 3]
+        ref_charge = []  # [N_atom]
+        for atom in atom_array:
+            ref_result = info_dict.get(atom.ref_space_uid)
+            if ref_result is None:
+                # get conformer failed
+                ref_mask.append(0)
+                ref_pos.append([0.0, 0.0, 0.0])
+                ref_charge.append(0)
+
+            else:
+                atom_map, coord, charge, mask = ref_result
+                atom_sub_idx = atom_map[atom.atom_name]
+                ref_mask.append(mask[atom_sub_idx])
+                ref_pos.append(coord[atom_sub_idx])
+                ref_charge.append(charge[atom_sub_idx])
+
+        ref_pos = np.array(ref_pos)
+        ref_charge = np.array(ref_charge).astype(int)
+        ref_mask = np.array(ref_mask).astype(int)
+        return ref_pos, ref_charge, ref_mask
+
+    @staticmethod
+    def add_res_perm(
+        atom_array: AtomArray,
+    ) -> tuple[np.ndarray, np.ndarray, list[int]]:
+        """
+        Get permutations of each atom within the residue.
+
+        Args:
+            atom_array (AtomArray): biotite AtomArray object.
+
+        Returns:
+            list[list[int]]: 2D list of (N_atom, N_perm)
+        """
+        starts = get_residue_starts(atom_array, add_exclusive_stop=True)
+        res_perm = []
+        for start, stop in zip(starts[:-1], starts[1:]):
+            res_atom = atom_array[start:stop]
+            curr_res_atom_idx = list(range(len(res_atom)))
+
+            res_dict = get_ccd_ref_info(ccd_code=res_atom.res_name[0])
+            if not res_dict:
+                res_perm.extend([[i] for i in curr_res_atom_idx])
+                continue
+
+            perm_array = res_dict["perm"]  # [N_atoms, N_perm]
+            perm_atom_idx_in_res_order = [
+                res_dict["atom_map"][i] for i in res_atom.atom_name
+            ]
+            perm_idx_to_present_atom_idx = dict(
+                zip(perm_atom_idx_in_res_order, curr_res_atom_idx)
+            )
+
+            precent_row_mask = np.isin(perm_array[:, 0], perm_atom_idx_in_res_order)
+            perm_array_row_filtered = perm_array[precent_row_mask]
+
+            precent_col_mask = np.isin(
+                perm_array_row_filtered, perm_atom_idx_in_res_order
+            ).all(axis=0)
+            perm_array_filtered = perm_array_row_filtered[:, precent_col_mask]
+
+            # replace the elem in new_perm_array according to the perm_idx_to_present_atom_idx dict
+            new_perm_array = np.vectorize(perm_idx_to_present_atom_idx.get)(
+                perm_array_filtered
+            )
+
+            assert (
+                new_perm_array.shape[1] <= 1000
+                and new_perm_array.shape[1] <= perm_array.shape[1]
+            )
+            res_perm.extend(new_perm_array.tolist())
+        return res_perm
+
+    @staticmethod
+    def add_ref_info_and_res_perm(atom_array: AtomArray) -> AtomArray:
+        """
+        Add info of reference structure of atoms to the atom array.
+
+        Args:
+            atom_array (AtomArray): The atom array.
+
+        Returns:
+            AtomArray: The atom array with the 'ref_pos', 'ref_charge', 'ref_mask', 'res_perm' annotations added.
+        """
+        ref_pos, ref_charge, ref_mask = AddAtomArrayAnnot.add_ref_feat_info(atom_array)
+        res_perm = AddAtomArrayAnnot.add_res_perm(atom_array)
+
+        str_res_perm = []  # encode [N_atom, N_perm] -> list[str]
+        for i in res_perm:
+            str_res_perm.append("_".join([str(j) for j in i]))
+
+        assert (
+            len(atom_array)
+            == len(ref_pos)
+            == len(ref_charge)
+            == len(ref_mask)
+            == len(res_perm)
+        ), f"{len(atom_array)=}, {len(ref_pos)=}, {len(ref_charge)=}, {len(ref_mask)=}, {len(str_res_perm)=}"
+
+        atom_array.set_annotation("ref_pos", ref_pos)
+        atom_array.set_annotation("ref_charge", ref_charge)
+        atom_array.set_annotation("ref_mask", ref_mask)
+        atom_array.set_annotation("res_perm", str_res_perm)
+        return atom_array

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/data/substructure_perms.py

@@ -0,0 +1,257 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import itertools
+from collections import defaultdict
+
+import numpy as np
+from rdkit import Chem
+
+
+def neutralize_atoms(mol: Chem.Mol):
+    pattern = Chem.MolFromSmarts(
+        "[+1!h0!$([*]~[-1,-2,-3,-4]),-1!#4!#5!$([*]~[+1,+2,+3,+4])]"
+    )
+    at_matches = mol.GetSubstructMatches(pattern)
+    at_matches_list = [y[0] for y in at_matches]
+    if len(at_matches_list) > 0:
+        for at_idx in at_matches_list:
+            atom = mol.GetAtomWithIdx(at_idx)
+            chg = atom.GetFormalCharge()
+            hcount = atom.GetTotalNumHs()
+            atom.SetFormalCharge(0)
+            atom.SetNumExplicitHs(hcount - chg)
+            atom.UpdatePropertyCache()
+    return mol
+
+
+def recursive_permutation(atom_inds, permutation_list, res):
+    def _permute_atom_ind(atom_inds, permutation):
+        # atom_inds: list of atom (positional) indices
+        # permutation: values to be permutated in the given order
+        permute_inds = [i for i, a in enumerate(atom_inds) if a in permutation]
+        for i, perm_ind in enumerate(permute_inds):
+            atom_inds[perm_ind] = permutation[i]
+        return atom_inds
+
+    if len(permutation_list) == 0:
+        res.append(atom_inds)
+    else:
+        current_permutation_list = permutation_list.copy()
+        for permutation in current_permutation_list.pop(0):
+            atom_inds_permed = _permute_atom_ind(atom_inds.copy(), permutation)
+            recursive_permutation(atom_inds_permed, current_permutation_list, res)
+
+
+def augment_atom_maps_with_conjugate_terminal_groups(
+    original_maps, atomic_number_mapping, terminal_group_tuples, MaxMatches=1e6
+):
+    """
+    Augment atom maps from GetSubstructMatches with extra symmetry from confjugated terminal groups.
+    Parameters
+    --------------
+    original_maps:  Tuple(Tuples), all possible atom index mappings, note we require that the mappings should range from 0 to n_heavy_atom-1 (a.k.a. no gap in indexing)
+    atomic_number_mapping: dict, mapping from atom (positional) indices to its atomic numbers, for splitting/removing different types of atoms in each terminal group
+    terminal_group_tuples: Tuple(Tuples), a group of pair of atoms whose bonds match the SMARTS string. Ex: ((0, 1), (2, 1), (10, 9), (11, 9), (12, 9), (14, 13), (15, 13))
+    MaxMatches: int, cutoff for total number of matches (n_original_perm * n_conjugate perm)
+
+    Returns
+    --------------
+    augmented_maps: Tuple(Tuples) , original_maps augmented by muliplying the permutations induced by terminal_group_tuples.
+    """
+
+    def _terminal_atom_cluster_from_pairs(edges):
+        graph = defaultdict(set)
+        for u, v in edges:
+            graph[u].add(v)
+            graph[v].add(u)
+        return graph
+
+    def _split_sets_by_mapped_values(list_of_sets, mapping):
+        result = []
+        for s in list_of_sets:
+            mapped_sets = {}
+            for elem in s:
+                mapped_value = mapping.get(elem)
+                if mapped_value not in mapped_sets:
+                    mapped_sets[mapped_value] = set()
+                mapped_sets[mapped_value].add(elem)
+            result.extend(mapped_sets.values())
+        return result
+
+    # group terminal group tuples with common atom_indices: [{0, 2}, {10, 11, 12}, {14, 15}]
+    terminal_atom_clusters = _terminal_atom_cluster_from_pairs(terminal_group_tuples)
+    MaxTerminalGroups = max(
+        1, int(np.ceil(np.emath.logn(3, MaxMatches / len(original_maps))))
+    )
+    # if MaxTerminalGroups is less than the total number terminal groups, sample the first {MaxTerminalGroups} groups (to remove randomness)
+
+    perm_groups = sorted(
+        [
+            atom_inds
+            for common_id, atom_inds in terminal_atom_clusters.items()
+            if len(atom_inds) > 1
+        ]
+    )[: min(MaxTerminalGroups, len(terminal_atom_clusters))]
+
+    # within each terminal group, if there are different atom types, split by atom type (if only one left, discard)
+    perm_groups = _split_sets_by_mapped_values(perm_groups, atomic_number_mapping)
+    perm_groups = [p for p in perm_groups if len(p) > 1]
+
+    # all permutations according to symmetric conjugate terminal atoms: [[(0, 2), (2, 0)], [(10, 11, 12), (10, 12, 11), (11, 10, 12), (11, 12, 10), (12, 10, 11), (12, 11, 10)], [(14, 15), (15, 14)]]
+    perm_groups = [sorted(list(itertools.permutations(g))) for g in perm_groups]
+
+    # recursively permute the original mappings
+    augmented_maps = []
+    for initial_mapping in original_maps:
+        recursive_permutation(list(initial_mapping), perm_groups, augmented_maps)
+
+    # Convert to the same data type as in original_maps
+    augmented_maps = tuple(tuple(a) for a in augmented_maps)
+    # Remove duplicates: original_maps might have already permutated some of the conjugate_terminal group indices
+    return tuple(set(augmented_maps))
+
+
+def _get_substructure_perms(
+    mol: Chem.Mol,
+    Neutralize: bool = False,
+    CheckStereochem: bool = True,
+    SymmetrizeConjugatedTerminal: bool = True,
+    MaxMatches: int = 512,
+) -> np.ndarray:
+    """
+    Args:
+        CheckStereochem: whether to assure stereochem does not change after permutation
+        Neutralize: if true, neutralize the mol before computing the permutations
+        SymmetrizeConjugatedTerminal: if true, consider symmetrization of conjugated terminal groups
+        MaxMatches: int, cutoff for total number of matches
+
+    return shape=[num_perms, num_atoms]
+    """
+    ori_idx_w_h = []
+    for atom in mol.GetAtoms():
+        atom.SetProp("ori_idx_w_h", str(atom.GetIdx()))
+        ori_idx_w_h.append(atom.GetIdx())
+
+    # Attention !!!
+    # Remove Hs; Otherwise, there will be too many matches.
+    mol = Chem.RemoveHs(mol)
+    if Neutralize:
+        mol = neutralize_atoms(mol)
+
+    # Get substructure matches
+    base_perms = np.array(
+        mol.GetSubstructMatches(mol, uniquify=False, maxMatches=MaxMatches)
+    )
+    assert len(base_perms) > 0, "no matches found, error"
+    # Check stereochem
+    if CheckStereochem:
+        chem_order = np.array(
+            list(Chem.rdmolfiles.CanonicalRankAtoms(mol, breakTies=False))
+        )
+        perms_mask = (chem_order[base_perms] == chem_order[None]).sum(
+            -1
+        ) == mol.GetNumAtoms()
+        base_perms = base_perms[perms_mask]
+
+    # Add terminal conjugate groups
+    sma = "[O,N;D1;$([O,N;D1]-[*]=[O,N;D1]),$([O,N;D1]=[*]-[O,N;D1])]~[*]"
+    patt = Chem.MolFromSmarts(sma)
+    terminal_group_tuples = mol.GetSubstructMatches(patt)
+    if (
+        len(terminal_group_tuples) > 0 and SymmetrizeConjugatedTerminal
+    ):  # Only augment if there exist conjugate pairs or if user sets to
+        atomic_number_mapping = {
+            i: atom.GetAtomicNum() for i, atom in enumerate(mol.GetAtoms())
+        }
+        base_perms = augment_atom_maps_with_conjugate_terminal_groups(
+            tuple(tuple(a) for a in base_perms),
+            atomic_number_mapping,
+            terminal_group_tuples,
+            MaxMatches,
+        )
+        base_perms = np.array(base_perms)
+
+    if len(base_perms) > MaxMatches:
+        base_perms = base_perms[:MaxMatches]
+
+    new_to_ori_idx_map = {}
+    ori_to_new_idx_map = {}
+    for atom in mol.GetAtoms():
+        ori_idx = int(atom.GetProp("ori_idx_w_h"))
+        new_idx = atom.GetIdx()
+        new_to_ori_idx_map[new_idx] = ori_idx
+        ori_to_new_idx_map[ori_idx] = new_idx
+
+    base_perms = np.vectorize(new_to_ori_idx_map.get)(base_perms)
+    perms = np.zeros(shape=(base_perms.shape[0], len(ori_idx_w_h)))
+    for i in range(len(ori_idx_w_h)):
+        if i in ori_to_new_idx_map:
+            perms[:, i] = base_perms[:, ori_to_new_idx_map[i]]
+        else:
+            # The position of the H atom will not be exchanged.
+            perms[:, i] = i
+    return perms
+
+
+def get_substructure_perms(
+    mol: Chem.Mol,
+    CheckStereochem: bool = True,
+    SymmetrizeConjugatedTerminal: bool = True,
+    MaxMatches: int = 512,
+    KeepProtonation: bool = False,
+) -> np.ndarray:
+    kwargs = {
+        "CheckStereochem": CheckStereochem,
+        "SymmetrizeConjugatedTerminal": SymmetrizeConjugatedTerminal,
+        "MaxMatches": MaxMatches,
+    }
+
+    if KeepProtonation:
+        perms = _get_substructure_perms(mol, Neutralize=False, **kwargs)
+    else:
+        # Have to deuplicate permutations across the two protonation states
+        perms = np.unique(
+            np.row_stack(
+                (
+                    _get_substructure_perms(mol, Neutralize=False, **kwargs),
+                    _get_substructure_perms(mol, Neutralize=True, **kwargs),
+                )
+            ),
+            axis=0,
+        )
+
+    nperm = len(perms)
+    if nperm > MaxMatches:
+        perms = perms[np.random.choice(range(nperm), MaxMatches, replace=False)]
+    return perms
+
+
+def test():
+    testcases = [
+        "C1=CC=CC=C1",
+        "CC(=O)OC1=CC=CC=C1C(=O)O",
+        "C[C@H](CCC(=O)O)[C@H]1CC[C@@H]2[C@@]1(CC[C@H]3[C@H]2CC=C4[C@@]3(CC[C@@H](C4)O)C)C",
+        "CN1C=NC2=C1C(=O)N(C(=O)N2C)C",
+    ]
+    for smiles in testcases:
+        print(smiles)
+        molecule = Chem.MolFromSmiles(smiles)
+        perms = get_substructure_perms(molecule)
+        print(perms.shape)
+        print(perms.T)
+
+
+if __name__ == "__main__":
+    test()

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/data/tokenizer.py

@@ -0,0 +1,196 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import biotite.structure as struc
+import numpy as np
+from biotite.structure import AtomArray
+
+from protenix.data.constants import ELEMS, STD_RESIDUES
+
+
+class Token(object):
+    """
+    Used to store information related to Tokens.
+
+    Example:
+    >>> token = Token(1)
+    >>> token.value
+    1
+    >>> token.atom_indices = [1, 2, 3]
+    """
+
+    def __init__(self, value, **kwargs):
+        self.value = value
+        self._annot = {}
+        for name, annotation in kwargs.items():
+            self._annot[name] = annotation
+
+    def __getattr__(self, attr):
+        if attr in super().__getattribute__("_annot"):
+            return self._annot[attr]
+        else:
+            raise AttributeError(
+                f"'{type(self).__name__}' object has no attribute '{attr}'"
+            )
+
+    def __repr__(self):
+        annot_lst = []
+        for k, v in self._annot.items():
+            annot_lst.append(f"{k}={v}")
+        return f'Token({self.value}, {",".join(annot_lst)})'
+
+    def __setattr__(self, attr, value):
+        if attr == "_annot":
+            super().__setattr__(attr, value)
+        elif attr == "value":
+            super().__setattr__(attr, value)
+        else:
+            self._annot[attr] = value
+
+
+class TokenArray(object):
+    """
+    A group of Token objects used for batch operations.
+    """
+
+    def __init__(self, tokens: list[Token]):
+        self.tokens = tokens
+
+    def __repr__(self):
+        repr_str = "TokenArray(\n"
+        for token in self.tokens:
+            repr_str += f"\t{token}\n"
+        repr_str += ")"
+        return repr_str
+
+    def __len__(self):
+        return len(self.tokens)
+
+    def __iter__(self):
+        for token in self.tokens:
+            yield token
+
+    def __getitem__(self, index):
+        if isinstance(index, int):
+            return self.tokens[index]
+        else:
+            return TokenArray([self.tokens[i] for i in index])
+
+    def get_annotation(self, category):
+        return [token._annot[category] for token in self.tokens]
+
+    def set_annotation(self, category, values):
+        assert len(values) == len(
+            self.tokens
+        ), "Length of values must match the number of tokens"
+        for token, value in zip(self.tokens, values):
+            token._annot[category] = value
+
+    def get_values(self):
+        return [token.value for token in self.tokens]
+
+
+class AtomArrayTokenizer(object):
+    """
+    Tokenize an AtomArray object into a list of Token object.
+    """
+
+    def __init__(self, atom_array: AtomArray):
+        self.atom_array = atom_array
+
+    def tokenize(self) -> list[Token]:
+        """
+        Ref: AlphaFold3 SI Chapter 2.6
+        Tokenize an AtomArray object into a list of Token object.
+
+        Returns:
+           list : a list of Token object.
+        """
+        tokens = []
+        total_atom_num = 0
+        for res in struc.residue_iter(self.atom_array):
+            atom_num = len(res)
+            first_atom = res[0]
+            res_name = first_atom.res_name
+            mol_type = first_atom.mol_type
+            res_token = STD_RESIDUES.get(res_name, None)
+            if res_token is not None and mol_type != "ligand":
+                # for std residues
+                token = Token(res_token)
+                atom_indices = [
+                    i for i in range(total_atom_num, total_atom_num + atom_num)
+                ]
+                atom_names = [self.atom_array[i].atom_name for i in atom_indices]
+                token.atom_indices = atom_indices
+                token.atom_names = atom_names
+                tokens.append(token)
+                total_atom_num += atom_num
+            else:
+                # for ligand and non-std residues
+                for atom in res:
+                    atom_elem = atom.element
+                    atom_token = ELEMS.get(atom_elem, None)
+                    if atom_token is None:
+                        raise ValueError(f"Unknown atom element: {atom_elem}")
+                    token = Token(atom_token)
+                    token.atom_indices = [total_atom_num]
+                    token.atom_names = [
+                        self.atom_array[token.atom_indices[0]].atom_name
+                    ]
+                    tokens.append(token)
+                    total_atom_num += 1
+
+        assert total_atom_num == len(self.atom_array)
+        return tokens
+
+    def _set_token_annotations(self, token_array: TokenArray) -> TokenArray:
+        """
+        Set annotations for the token_array.
+
+        The annotations include:
+            - centre_atom_index: the atom indices of the token in the atom array
+
+        Args:
+            token_array (TokenArray): TokenArray object created by tokenize bioassembly AtomArray.
+
+        Returns:
+            TokenArray: TokenArray object with annotations.
+        """
+        centre_atom_indices = np.where(self.atom_array.centre_atom_mask == 1)[0]
+        token_array.set_annotation("centre_atom_index", centre_atom_indices)
+        assert len(token_array) == len(centre_atom_indices)
+        return token_array
+
+    def get_token_array(self) -> TokenArray:
+        """
+        Get TokenArray object with annotations (atom_indices, centre_atom_index).
+
+        Returns:
+            TokenArray: The TokenArray object with annotations.
+                TokenArray(
+                Token(1, atom_indices=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10],centre_atom_index=2,
+                    atom_names=['N', 'CA', 'C', 'O', 'CB', 'CG', 'CD', 'NE', 'CZ', 'NH1', 'NH2'])
+                Token(15, atom_indices=[11, 12, 13, 14, 15, 16],centre_atom_index=13,
+                    atom_names=['N', 'CA', 'C', 'O', 'CB', 'OG'])
+                Token(15, atom_indices=[17, 18, 19, 20, 21, 22],centre_atom_index=19,
+                    atom_names=['N', 'CA', 'C', 'O', 'CB', 'OG'])
+                    )
+                it satisfy the following format
+                Token($token_index,  atom_indices=[global_atom_indexs],
+                    centre_atom_index=global_atom_indexs,atom_names=[names])
+        """
+        tokens = self.tokenize()
+        token_array = TokenArray(tokens=tokens)
+        token_array = self._set_token_annotations(token_array=token_array)
+        return token_array

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/data/utils.py

@@ -0,0 +1,675 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import copy
+import os
+import re
+from collections import defaultdict
+from typing import Mapping, Sequence
+
+import biotite.structure as struc
+import numpy as np
+import torch
+from biotite.structure import AtomArray
+from biotite.structure.io import pdbx
+from biotite.structure.io.pdb import PDBFile
+
+from protenix.data.constants import DNA_STD_RESIDUES, PRO_STD_RESIDUES, RNA_STD_RESIDUES
+
+
+def remove_numbers(s: str) -> str:
+    """
+    Remove numbers from a string.
+
+    Args:
+        s (str): input string
+
+    Returns:
+        str: a string with numbers removed.
+    """
+    return re.sub(r"\d+", "", s)
+
+
+def int_to_letters(n: int) -> str:
+    """
+    Convert int to letters.
+    Useful for converting chain index to label_asym_id.
+
+    Args:
+        n (int): int number
+    Returns:
+        str: letters. e.g. 1 -> A, 2 -> B, 27 -> AA, 28 -> AB
+    """
+    result = ""
+    while n > 0:
+        n, remainder = divmod(n - 1, 26)
+        result = chr(65 + remainder) + result
+    return result
+
+
+def get_starts_by(
+    atom_array: AtomArray, by_annot: str, add_exclusive_stop=False
+) -> np.ndarray:
+    """get start indices by given annotation in an AtomArray
+
+    Args:
+        atom_array (AtomArray): Biotite AtomArray
+        by_annot (str): annotation to group by, eg: 'chain_id', 'res_id', 'res_name'
+        add_exclusive_stop (bool, optional): add exclusive stop (len(atom_array)). Defaults to False.
+
+    Returns:
+        np.ndarray: start indices of each group, shape = (n,), eg: [0, 10, 20, 30, 40]
+    """
+    annot = getattr(atom_array, by_annot)
+    # If annotation change, a new start
+    annot_change_mask = annot[1:] != annot[:-1]
+
+    # Convert mask to indices
+    # Add 1, to shift the indices from the end of a residue
+    # to the start of a new residue
+    starts = np.where(annot_change_mask)[0] + 1
+
+    # The first start is not included yet -> Insert '[0]'
+    if add_exclusive_stop:
+        return np.concatenate(([0], starts, [atom_array.array_length()]))
+    else:
+        return np.concatenate(([0], starts))
+
+
+def get_ligand_polymer_bond_mask(
+    atom_array: AtomArray, lig_include_ions=False
+) -> np.ndarray:
+    """
+    Ref AlphaFold3 SI Chapter 3.7.1.
+    Get bonds between the bonded ligand and its parent chain.
+
+    Args:
+        atom_array (AtomArray): biotite atom array object.
+        lig_include_ions (bool): whether to include ions in the ligand.
+
+    Returns:
+        np.ndarray: bond records between the bonded ligand and its parent chain.
+                    e.g. np.array([[atom1, atom2, bond_order]...])
+    """
+    if not lig_include_ions:
+        # bonded ligand exclude ions
+        unique_chain_id, counts = np.unique(
+            atom_array.label_asym_id, return_counts=True
+        )
+        chain_id_to_count_map = dict(zip(unique_chain_id, counts))
+        ions_mask = np.array(
+            [
+                chain_id_to_count_map[label_asym_id] == 1
+                for label_asym_id in atom_array.label_asym_id
+            ]
+        )
+
+        lig_mask = (atom_array.mol_type == "ligand") & ~ions_mask
+    else:
+        lig_mask = atom_array.mol_type == "ligand"
+
+    # identify polymer by mol_type (protein, rna, dna, ligand)
+    polymer_mask = np.isin(atom_array.mol_type, ["protein", "rna", "dna"])
+
+    idx_i = atom_array.bonds._bonds[:, 0]
+    idx_j = atom_array.bonds._bonds[:, 1]
+
+    lig_polymer_bond_indices = np.where(
+        (lig_mask[idx_i] & polymer_mask[idx_j])
+        | (lig_mask[idx_j] & polymer_mask[idx_i])
+    )[0]
+    if lig_polymer_bond_indices.size == 0:
+        # no ligand-polymer bonds
+        lig_polymer_bonds = np.empty((0, 3)).astype(int)
+    else:
+        lig_polymer_bonds = atom_array.bonds._bonds[
+            lig_polymer_bond_indices
+        ]  # np.array([[atom1, atom2, bond_order]...])
+    return lig_polymer_bonds
+
+
+def get_clean_data(atom_array: AtomArray) -> AtomArray:
+    """
+    Removes unresolved atoms from the AtomArray.
+
+    Args:
+        atom_array (AtomArray): The input AtomArray containing atoms.
+
+    Returns:
+        AtomArray: A new AtomArray with unresolved atoms removed.
+    """
+    atom_array_wo_unresol = atom_array.copy()
+    atom_array_wo_unresol = atom_array[atom_array.is_resolved]
+    return atom_array_wo_unresol
+
+
+def save_atoms_to_cif(
+    output_cif_file: str,
+    atom_array: AtomArray,
+    entity_poly_type: dict[str, str],
+    pdb_id: str,
+) -> None:
+    """
+    Save atom array data to a CIF file.
+
+    Args:
+        output_cif_file (str): The output path for saving the atom array in CIF format.
+        atom_array (AtomArray): The atom array to be saved.
+        entity_poly_type: The entity poly type information.
+        pdb_id: The PDB ID for the entry.
+    """
+    cifwriter = CIFWriter(atom_array, entity_poly_type)
+    cifwriter.save_to_cif(
+        output_path=output_cif_file,
+        entry_id=pdb_id,
+        include_bonds=False,
+    )
+
+
+def save_structure_cif(
+    atom_array: AtomArray,
+    pred_coordinate: torch.Tensor,
+    output_fpath: str,
+    entity_poly_type: dict[str, str],
+    pdb_id: str,
+):
+    """
+    Save the predicted structure to a CIF file.
+
+    Args:
+        atom_array (AtomArray): The original AtomArray containing the structure.
+        pred_coordinate (torch.Tensor): The predicted coordinates for the structure.
+        output_fpath (str): The output file path for saving the CIF file.
+        entity_poly_type (dict[str, str]): The entity poly type information.
+        pdb_id (str): The PDB ID for the entry.
+    """
+    pred_atom_array = copy.deepcopy(atom_array)
+    pred_pose = pred_coordinate.cpu().numpy()
+    pred_atom_array.coord = pred_pose
+    save_atoms_to_cif(
+        output_fpath,
+        pred_atom_array,
+        entity_poly_type,
+        pdb_id,
+    )
+    # save pred coordinates wo unresolved atoms
+    if hasattr(atom_array, "is_resolved"):
+        pred_atom_array_wo_unresol = get_clean_data(pred_atom_array)
+        save_atoms_to_cif(
+            output_fpath.replace(".cif", "_wounresol.cif"),
+            pred_atom_array_wo_unresol,
+            entity_poly_type,
+            pdb_id,
+        )
+
+
+class CIFWriter:
+    """
+    Write AtomArray to cif.
+    """
+
+    def __init__(self, atom_array: AtomArray, entity_poly_type: dict[str, str] = None):
+        """
+        Args:
+            atom_array (AtomArray): Biotite AtomArray object.
+            entity_poly_type (dict[str, str], optional): A dict of label_entity_id to entity_poly_type. Defaults to None.
+                                                         If None, "the entity_poly" and "entity_poly_seq" will not be written to the cif.
+        """
+        self.atom_array = atom_array
+        self.entity_poly_type = entity_poly_type
+
+    def _get_entity_poly_and_entity_poly_seq_block(self):
+        entity_poly = defaultdict(list)
+        for entity_id, entity_type in self.entity_poly_type.items():
+            label_asym_ids = np.unique(
+                self.atom_array.label_asym_id[
+                    self.atom_array.label_entity_id == entity_id
+                ]
+            )
+            label_asym_ids_str = ",".join(label_asym_ids)
+
+            if label_asym_ids_str == "":
+                # The entity not in current atom_array
+                continue
+
+            entity_poly["entity_id"].append(entity_id)
+            entity_poly["pdbx_strand_id"].append(label_asym_ids_str)
+            entity_poly["type"].append(entity_type)
+
+        entity_poly_seq = defaultdict(list)
+        for entity_id, label_asym_ids_str in zip(
+            entity_poly["entity_id"], entity_poly["pdbx_strand_id"]
+        ):
+            first_label_asym_id = label_asym_ids_str.split(",")[0]
+            first_asym_chain = self.atom_array[
+                self.atom_array.label_asym_id == first_label_asym_id
+            ]
+            chain_starts = struc.get_chain_starts(
+                first_asym_chain, add_exclusive_stop=True
+            )
+            asym_chain = first_asym_chain[
+                chain_starts[0] : chain_starts[1]
+            ]  # ensure the asym chain is a single chain
+
+            res_starts = struc.get_residue_starts(asym_chain, add_exclusive_stop=False)
+            asym_chain_entity_id = asym_chain[res_starts].label_entity_id.tolist()
+            asym_chain_hetero = [
+                "n" if not i else "y" for i in asym_chain[res_starts].hetero
+            ]
+            asym_chain_res_name = asym_chain[res_starts].res_name.tolist()
+            asym_chain_res_id = asym_chain[res_starts].res_id.tolist()
+
+            entity_poly_seq["entity_id"].extend(asym_chain_entity_id)
+            entity_poly_seq["hetero"].extend(asym_chain_hetero)
+            entity_poly_seq["mon_id"].extend(asym_chain_res_name)
+            entity_poly_seq["num"].extend(asym_chain_res_id)
+
+        block_dict = {
+            "entity_poly": pdbx.CIFCategory(entity_poly),
+            "entity_poly_seq": pdbx.CIFCategory(entity_poly_seq),
+        }
+        return block_dict
+
+    def save_to_cif(
+        self, output_path: str, entry_id: str = None, include_bonds: bool = False
+    ):
+        """
+        Save AtomArray to cif.
+
+        Args:
+            output_path (str): Output path of cif file.
+            entry_id (str, optional): The value of "_entry.id" in cif. Defaults to None.
+                                      If None, the entry_id will be the basename of output_path (without ".cif" extension).
+            include_bonds (bool, optional): Whether to include  bonds in the cif. Defaults to False.
+                                            If set to True and `array` has associated ``bonds`` , the
+                                            intra-residue bonds will be written into the ``chem_comp_bond``
+                                            category.
+                                            Inter-residue bonds will be written into the ``struct_conn``
+                                            independent of this parameter.
+
+        """
+        if entry_id is None:
+            entry_id = os.path.basename(output_path).replace(".cif", "")
+
+        block_dict = {"entry": pdbx.CIFCategory({"id": entry_id})}
+        if self.entity_poly_type:
+            block_dict.update(self._get_entity_poly_and_entity_poly_seq_block())
+
+        block = pdbx.CIFBlock(block_dict)
+        cif = pdbx.CIFFile(
+            {
+                os.path.basename(output_path).replace(".cif", "")
+                + "_predicted_by_protenix": block
+            }
+        )
+        pdbx.set_structure(cif, self.atom_array, include_bonds=include_bonds)
+        block = cif.block
+        atom_site = block.get("atom_site")
+        atom_site["label_entity_id"] = self.atom_array.label_entity_id
+        cif.write(output_path)
+
+
+def make_dummy_feature(
+    features_dict: Mapping[str, torch.Tensor],
+    dummy_feats: Sequence = ["msa"],
+) -> dict[str, torch.Tensor]:
+    num_token = features_dict["token_index"].shape[0]
+    num_atom = features_dict["atom_to_token_idx"].shape[0]
+    num_msa = 1
+    num_templ = 4
+    num_pockets = 30
+    feat_shape, _ = get_data_shape_dict(
+        num_token=num_token,
+        num_atom=num_atom,
+        num_msa=num_msa,
+        num_templ=num_templ,
+        num_pocket=num_pockets,
+    )
+    for feat_name in dummy_feats:
+        if feat_name not in ["msa", "template"]:
+            cur_feat_shape = feat_shape[feat_name]
+            features_dict[feat_name] = torch.zeros(cur_feat_shape)
+    if "msa" in dummy_feats:
+        # features_dict["msa"] = features_dict["restype"].unsqueeze(0)
+        features_dict["msa"] = torch.nonzero(features_dict["restype"])[:, 1].unsqueeze(
+            0
+        )
+        assert features_dict["msa"].shape == feat_shape["msa"]
+        features_dict["has_deletion"] = torch.zeros(feat_shape["has_deletion"])
+        features_dict["deletion_value"] = torch.zeros(feat_shape["deletion_value"])
+        features_dict["profile"] = features_dict["restype"]
+        assert features_dict["profile"].shape == feat_shape["profile"]
+        features_dict["deletion_mean"] = torch.zeros(feat_shape["deletion_mean"])
+        for key in [
+            "prot_pair_num_alignments",
+            "prot_unpair_num_alignments",
+            "rna_pair_num_alignments",
+            "rna_unpair_num_alignments",
+        ]:
+            features_dict[key] = torch.tensor(0, dtype=torch.int32)
+
+    if "template" in dummy_feats:
+        features_dict["template_restype"] = (
+            torch.ones(feat_shape["template_restype"]) * 31
+        )  # gap
+        features_dict["template_all_atom_mask"] = torch.zeros(
+            feat_shape["template_all_atom_mask"]
+        )
+        features_dict["template_all_atom_positions"] = torch.zeros(
+            feat_shape["template_all_atom_positions"]
+        )
+    return features_dict
+
+
+def data_type_transform(
+    feat_or_label_dict: Mapping[str, torch.Tensor]
+) -> tuple[dict[str, torch.Tensor], dict[str, torch.Tensor], AtomArray]:
+    for key, value in feat_or_label_dict.items():
+        if key in IntDataList:
+            feat_or_label_dict[key] = value.to(torch.long)
+
+    return feat_or_label_dict
+
+
+# List of "index" or "type" data
+# Their data type should be int
+IntDataList = [
+    "residue_index",
+    "token_index",
+    "asym_id",
+    "entity_id",
+    "sym_id",
+    "ref_space_uid",
+    "template_restype",
+    "atom_to_token_idx",
+    "atom_to_tokatom_idx",
+    "frame_atom_index",
+    "msa",
+    "entity_mol_id",
+    "mol_id",
+    "mol_atom_index",
+]
+
+
+# shape of the data
+def get_data_shape_dict(num_token, num_atom, num_msa, num_templ, num_pocket):
+    """
+    Generate a dictionary containing the shapes of all data.
+
+    Args:
+        num_token (int): Number of tokens.
+        num_atom (int): Number of atoms.
+        num_msa (int): Number of MSA sequences.
+        num_templ (int): Number of templates.
+        num_pocket (int): Number of pockets to the same interested ligand.
+
+    Returns:
+        dict: A dictionary containing the shapes of all data.
+    """
+    # Features in AlphaFold3 SI Table5
+    feat = {
+        # Token features
+        "residue_index": (num_token,),
+        "token_index": (num_token,),
+        "asym_id": (num_token,),
+        "entity_id": (num_token,),
+        "sym_id": (num_token,),
+        "restype": (num_token, 32),
+        # chain permutation features
+        "entity_mol_id": (num_atom,),
+        "mol_id": (num_atom,),
+        "mol_atom_index": (num_atom,),
+        # Reference features
+        "ref_pos": (num_atom, 3),
+        "ref_mask": (num_atom,),
+        "ref_element": (num_atom, 128),  # note: 128 elem in the paper
+        "ref_charge": (num_atom,),
+        "ref_atom_name_chars": (num_atom, 4, 64),
+        "ref_space_uid": (num_atom,),
+        # Msa features
+        # "msa": (num_msa, num_token, 32),
+        "msa": (num_msa, num_token),
+        "has_deletion": (num_msa, num_token),
+        "deletion_value": (num_msa, num_token),
+        "profile": (num_token, 32),
+        "deletion_mean": (num_token,),
+        # Template features
+        "template_restype": (num_templ, num_token),
+        "template_all_atom_mask": (num_templ, num_token, 37),
+        "template_all_atom_positions": (num_templ, num_token, 37, 3),
+        "template_pseudo_beta_mask": (num_templ, num_token),
+        "template_backbone_frame_mask": (num_templ, num_token),
+        "template_distogram": (num_templ, num_token, num_token, 39),
+        "template_unit_vector": (num_templ, num_token, num_token, 3),
+        # Bond features
+        "token_bonds": (num_token, num_token),
+    }
+
+    # Extra features needed
+    extra_feat = {
+        # Input features
+        "atom_to_token_idx": (num_atom,),  # after crop
+        "atom_to_tokatom_idx": (num_atom,),  # after crop
+        "pae_rep_atom_mask": (num_atom,),  # same as "pae_rep_atom_mask" in label_dict
+        "is_distillation": (1,),
+    }
+
+    # Label
+    label = {
+        "coordinate": (num_atom, 3),
+        "coordinate_mask": (num_atom,),
+        # "centre_atom_mask": (num_atom,),
+        # "centre_centre_distance": (num_token, num_token),
+        # "centre_centre_distance_mask": (num_token, num_token),
+        "distogram_rep_atom_mask": (num_atom,),
+        "pae_rep_atom_mask": (num_atom,),
+        "plddt_m_rep_atom_mask": (num_atom,),
+        "modified_res_mask": (num_atom,),
+        "bond_mask": (num_atom, num_atom),
+        "is_protein": (num_atom,),  # Atom level, not token level
+        "is_rna": (num_atom,),
+        "is_dna": (num_atom,),
+        "is_ligand": (num_atom,),
+        "has_frame": (num_token,),  # move to input_feature_dict?
+        "frame_atom_index": (num_token, 3),  # atom index after crop
+        "resolution": (1,),
+        # Metrics
+        "interested_ligand_mask": (
+            num_pocket,
+            num_atom,
+        ),
+        "pocket_mask": (
+            num_pocket,
+            num_atom,
+        ),
+    }
+
+    # Merged
+    all_feat = {**feat, **extra_feat}
+    return all_feat, label
+
+
+def get_lig_lig_bonds(
+    atom_array: AtomArray, lig_include_ions: bool = False
+) -> np.ndarray:
+    """
+    Get all inter-ligand bonds in order to create "token_bonds".
+
+    Args:
+        atom_array (AtomArray): biotite AtomArray object with "mol_type" attribute.
+        lig_include_ions (bool, optional): . Defaults to False.
+
+    Returns:
+        np.ndarray: inter-ligand bonds, e.g. np.array([[atom1, atom2, bond_order]...])
+    """
+    if not lig_include_ions:
+        # bonded ligand exclude ions
+        unique_chain_id, counts = np.unique(
+            atom_array.label_asym_id, return_counts=True
+        )
+        chain_id_to_count_map = dict(zip(unique_chain_id, counts))
+        ions_mask = np.array(
+            [
+                chain_id_to_count_map[label_asym_id] == 1
+                for label_asym_id in atom_array.label_asym_id
+            ]
+        )
+
+        lig_mask = (atom_array.mol_type == "ligand") & ~ions_mask
+    else:
+        lig_mask = atom_array.mol_type == "ligand"
+
+    chain_res_id = np.vstack((atom_array.label_asym_id, atom_array.res_id)).T
+    idx_i = atom_array.bonds._bonds[:, 0]
+    idx_j = atom_array.bonds._bonds[:, 1]
+
+    ligand_ligand_bond_indices = np.where(
+        (lig_mask[idx_i] & lig_mask[idx_j])
+        & np.any(chain_res_id[idx_i] != chain_res_id[idx_j], axis=1)
+    )[0]
+
+    if ligand_ligand_bond_indices.size == 0:
+        # no ligand-polymer bonds
+        lig_polymer_bonds = np.empty((0, 3)).astype(int)
+    else:
+        lig_polymer_bonds = atom_array.bonds._bonds[ligand_ligand_bond_indices]
+    return lig_polymer_bonds
+
+
+def pdb_to_cif(input_fname: str, output_fname: str, entry_id: str = None):
+    """
+    Convert PDB to CIF.
+
+    Args:
+        input_fname (str): input PDB file name
+        output_fname (str): output CIF file name
+        entry_id (str, optional): entry id. Defaults to None.
+    """
+    pdbfile = PDBFile.read(input_fname)
+    atom_array = pdbfile.get_structure(model=1, include_bonds=True, altloc="first")
+
+    seq_to_entity_id = {}
+    cnt = 0
+    chain_starts = struc.get_chain_starts(atom_array, add_exclusive_stop=True)
+
+    # split chains by hetero
+    new_chain_starts = []
+    for c_start, c_stop in zip(chain_starts[:-1], chain_starts[1:]):
+        new_chain_starts.append(c_start)
+        chain_start_hetero = atom_array.hetero[c_start]
+        hetero_diff = np.where(atom_array.hetero[c_start:c_stop] != chain_start_hetero)
+        if hetero_diff[0].shape[0] > 0:
+            new_chain_start = c_start + hetero_diff[0][0]
+            new_chain_starts.append(new_chain_start)
+
+    new_chain_starts += [chain_starts[-1]]
+
+    # # split HETATM chains by res id
+    new_chain_starts2 = []
+    for c_start, c_stop in zip(new_chain_starts[:-1], new_chain_starts[1:]):
+        new_chain_starts2.append(c_start)
+        res_id_diff = np.diff(atom_array.res_id[c_start:c_stop])
+        uncont_res_starts = np.where(res_id_diff >= 1)
+
+        if uncont_res_starts[0].shape[0] > 0:
+            for res_start_atom_idx in uncont_res_starts[0]:
+                new_chain_start = c_start + res_start_atom_idx + 1
+                # atom_array.hetero is True if "HETATM"
+                if (
+                    atom_array.hetero[new_chain_start]
+                    and atom_array.hetero[new_chain_start - 1]
+                ):
+                    new_chain_starts2.append(new_chain_start)
+
+    chain_starts = new_chain_starts2 + [chain_starts[-1]]
+
+    label_entity_id = np.zeros(len(atom_array), dtype=np.int32)
+    atom_index = np.arange(len(atom_array), dtype=np.int32)
+    res_id = copy.deepcopy(atom_array.res_id)
+
+    chain_id = copy.deepcopy(atom_array.chain_id)
+    chain_count = 0
+    for c_start, c_stop in zip(chain_starts[:-1], chain_starts[1:]):
+        chain_count += 1
+        new_chain_id = int_to_letters(chain_count)
+        chain_id[c_start:c_stop] = new_chain_id
+
+        chain_array = atom_array[c_start:c_stop]
+        residue_starts = struc.get_residue_starts(chain_array, add_exclusive_stop=True)
+        resname_seq = [name for name in chain_array[residue_starts[:-1]].res_name]
+        resname_str = "_".join(resname_seq)
+        if (
+            all([name in DNA_STD_RESIDUES for name in resname_seq])
+            and resname_str in seq_to_entity_id
+        ):
+            resname_seq = resname_seq[::-1]
+            resname_str = "_".join(resname_seq)
+            atom_index[c_start:c_stop] = atom_index[c_start:c_stop][::-1]
+
+        if resname_str not in seq_to_entity_id:
+            cnt += 1
+            seq_to_entity_id[resname_str] = cnt
+        label_entity_id[c_start:c_stop] = seq_to_entity_id[resname_str]
+
+        res_cnt = 1
+        for res_start, res_stop in zip(residue_starts[:-1], residue_starts[1:]):
+            res_id[c_start:c_stop][res_start:res_stop] = res_cnt
+            res_cnt += 1
+
+    atom_array = atom_array[atom_index]
+
+    # add label entity id
+    atom_array.set_annotation("label_entity_id", label_entity_id)
+    entity_poly_type = {}
+    for seq, entity_id in seq_to_entity_id.items():
+        resname_seq = seq.split("_")
+
+        count = defaultdict(int)
+        for name in resname_seq:
+            if name in PRO_STD_RESIDUES:
+                count["prot"] += 1
+            elif name in DNA_STD_RESIDUES:
+                count["dna"] += 1
+            elif name in RNA_STD_RESIDUES:
+                count["rna"] += 1
+            else:
+                count["other"] += 1
+
+        if count["prot"] >= 2 and count["dna"] == 0 and count["rna"] == 0:
+            entity_poly_type[entity_id] = "polypeptide(L)"
+        elif count["dna"] >= 2 and count["rna"] == 0 and count["prot"] == 0:
+            entity_poly_type[entity_id] = "polydeoxyribonucleotide"
+        elif count["rna"] >= 2 and count["dna"] == 0 and count["prot"] == 0:
+            entity_poly_type[entity_id] = "polyribonucleotide"
+        else:
+            # other entity type: ignoring
+            continue
+
+    # add label atom id
+    atom_array.set_annotation("label_atom_id", atom_array.atom_name)
+
+    # add label asym id
+    atom_array.chain_id = chain_id  # reset chain_id
+    atom_array.set_annotation("label_asym_id", atom_array.chain_id)
+
+    # add label seq id
+    atom_array.res_id = res_id  # reset res_id
+    atom_array.set_annotation("label_seq_id", atom_array.res_id)
+
+    w = CIFWriter(atom_array=atom_array, entity_poly_type=entity_poly_type)
+    w.save_to_cif(
+        output_fname,
+        entry_id=entry_id or os.path.basename(output_fname),
+        include_bonds=True,
+    )

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/metrics/clash.py

@@ -0,0 +1,272 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+from typing import Optional
+
+import torch
+import torch.nn as nn
+
+from protenix.data.constants import rdkit_vdws
+
+RDKIT_VDWS = torch.tensor(rdkit_vdws)
+ID2TYPE = {0: "UNK", 1: "lig", 2: "prot", 3: "dna", 4: "rna"}
+
+
+def get_vdw_radii(elements_one_hot):
+    """get vdw radius for each atom according to their elements"""
+    element_order = elements_one_hot.argmax(dim=1)
+    return RDKIT_VDWS.to(element_order.device)[element_order]
+
+
+class Clash(nn.Module):
+    def __init__(
+        self,
+        af3_clash_threshold=1.1,
+        vdw_clash_threshold=0.75,
+        compute_af3_clash=True,
+        compute_vdw_clash=True,
+    ):
+        super().__init__()
+        self.af3_clash_threshold = af3_clash_threshold
+        self.vdw_clash_threshold = vdw_clash_threshold
+        self.compute_af3_clash = compute_af3_clash
+        self.compute_vdw_clash = compute_vdw_clash
+
+    def forward(
+        self,
+        pred_coordinate,
+        asym_id,
+        atom_to_token_idx,
+        is_ligand,
+        is_protein,
+        is_dna,
+        is_rna,
+        mol_id: Optional[torch.Tensor] = None,
+        elements_one_hot: Optional[torch.Tensor] = None,
+    ):
+        chain_info = self.get_chain_info(
+            asym_id=asym_id,
+            atom_to_token_idx=atom_to_token_idx,
+            is_ligand=is_ligand,
+            is_protein=is_protein,
+            is_dna=is_dna,
+            is_rna=is_rna,
+            mol_id=mol_id,
+            elements_one_hot=elements_one_hot,
+        )
+        return self._check_clash_per_chain_pairs(
+            pred_coordinate=pred_coordinate, **chain_info
+        )
+
+    def get_chain_info(
+        self,
+        asym_id,
+        atom_to_token_idx,
+        is_ligand,
+        is_protein,
+        is_dna,
+        is_rna,
+        mol_id: Optional[torch.Tensor] = None,
+        elements_one_hot: Optional[torch.Tensor] = None,
+    ):
+        # Get chain info
+        asym_id = asym_id.long()
+        asym_id_to_asym_mask = {
+            aid.item(): asym_id == aid for aid in torch.unique(asym_id)
+        }
+        N_chains = len(asym_id_to_asym_mask)
+        # Make sure it is from 0 to N_chain-1
+        assert N_chains == asym_id.max() + 1
+
+        # Check and compute chain_types
+        chain_types = []
+        mol_id_to_asym_ids, asym_id_to_mol_id = {}, {}
+        atom_type = (1 * is_ligand + 2 * is_protein + 3 * is_dna + 4 * is_rna).long()
+        if self.compute_vdw_clash:
+            assert mol_id is not None
+            assert elements_one_hot is not None
+
+        for aid in range(N_chains):
+            atom_chain_mask = asym_id_to_asym_mask[aid][atom_to_token_idx]
+            atom_type_i = atom_type[atom_chain_mask]
+            assert len(atom_type_i.unique()) == 1
+            if atom_type_i[0].item() == 0:
+                logging.warning(
+                    "Unknown asym_id type: not in ligand / protein / dna / rna"
+                )
+            chain_types.append(ID2TYPE[atom_type_i[0].item()])
+            if self.compute_vdw_clash:
+                # Check if all atoms in a chain are from the same molecule
+                mol_id_i = mol_id[atom_chain_mask].unique().item()
+                mol_id_to_asym_ids.setdefault(mol_id_i, []).append(aid)
+                asym_id_to_mol_id[aid] = mol_id_i
+
+        chain_info = {
+            "N_chains": N_chains,
+            "atom_to_token_idx": atom_to_token_idx,
+            "asym_id_to_asym_mask": asym_id_to_asym_mask,
+            "atom_type": atom_type,
+            "mol_id": mol_id,
+            "elements_one_hot": elements_one_hot,
+            "chain_types": chain_types,
+        }
+
+        if self.compute_vdw_clash:
+            chain_info.update({"asym_id_to_mol_id": asym_id_to_mol_id})
+
+        return chain_info
+
+    def get_chain_pair_violations(
+        self,
+        pred_coordinate,
+        violation_type,
+        chain_1_mask,
+        chain_2_mask,
+        elements_one_hot: Optional[torch.Tensor] = None,
+    ):
+        chain_1_coords = pred_coordinate[chain_1_mask, :]
+        chain_2_coords = pred_coordinate[chain_2_mask, :]
+        pred_dist = torch.cdist(chain_1_coords, chain_2_coords)
+        if violation_type == "af3":
+            clash_per_atom_pair = (
+                pred_dist < self.af3_clash_threshold
+            )  # [ N_atom_chain_1, N_atom_chain_2]
+            clashed_col, clashed_row = torch.where(clash_per_atom_pair)
+            clash_atom_pairs = torch.stack((clashed_col, clashed_row), dim=-1)
+        else:
+            assert elements_one_hot is not None
+            vdw_radii_i, vdw_radii_j = get_vdw_radii(
+                elements_one_hot[chain_1_mask, :]
+            ), get_vdw_radii(elements_one_hot[chain_2_mask, :])
+            vdw_sum_pair = (
+                vdw_radii_i[:, None] + vdw_radii_j[None, :]
+            )  # [N_atom_chain_1, N_atom_chain_2]
+            relative_vdw_distance = pred_dist / vdw_sum_pair
+            clash_per_atom_pair = (
+                relative_vdw_distance < self.vdw_clash_threshold
+            )  # [N_atom_chain_1, N_atom_chain_2]
+            clashed_col, clashed_row = torch.where(clash_per_atom_pair)
+            clash_rel_dist = relative_vdw_distance[clashed_col, clashed_row]
+            clashed_global_col = torch.where(chain_1_mask)[0][clashed_col]
+            clashed_global_row = torch.where(chain_2_mask)[0][clashed_row]
+            clash_atom_pairs = torch.stack(
+                (clashed_global_col, clashed_global_row, clash_rel_dist), dim=-1
+            )
+        return clash_atom_pairs
+
+    def _check_clash_per_chain_pairs(
+        self,
+        pred_coordinate,
+        atom_to_token_idx,
+        N_chains,
+        atom_type,
+        chain_types,
+        elements_one_hot,
+        asym_id_to_asym_mask,
+        mol_id: Optional[torch.Tensor] = None,
+        asym_id_to_mol_id: Optional[torch.Tensor] = None,
+    ):
+        device = pred_coordinate.device
+        N_sample = pred_coordinate.shape[0]
+
+        # initialize results
+        if self.compute_af3_clash:
+            has_af3_clash_flag = torch.zeros(
+                N_sample, N_chains, N_chains, device=device, dtype=torch.bool
+            )
+            af3_clash_details = torch.zeros(
+                N_sample, N_chains, N_chains, 2, device=device, dtype=torch.bool
+            )
+        if self.compute_vdw_clash:
+            has_vdw_clash_flag = torch.zeros(
+                N_sample, N_chains, N_chains, device=device, dtype=torch.bool
+            )
+            vdw_clash_details = {}
+
+        skipped_pairs = []
+        for sample_id in range(N_sample):
+            for i in range(N_chains):
+                if chain_types[i] == "UNK":
+                    continue
+                atom_chain_mask_i = asym_id_to_asym_mask[i][atom_to_token_idx]
+                N_chain_i = torch.sum(atom_chain_mask_i).item()
+                for j in range(i + 1, N_chains):
+                    if chain_types[j] == "UNK":
+                        continue
+                    chain_pair_type = set([chain_types[i], chain_types[j]])
+                    # Skip potential bonded ligand to polymers
+                    skip_bonded_ligand = False
+                    if (
+                        self.compute_vdw_clash
+                        and "lig" in chain_pair_type
+                        and len(chain_pair_type) > 1
+                        and asym_id_to_mol_id[i] == asym_id_to_mol_id[j]
+                    ):
+                        common_mol_id = asym_id_to_mol_id[i]
+                        logging.warning(
+                            f"mol_id {common_mol_id} may contain bonded ligand to polymers"
+                        )
+                        skip_bonded_ligand = True
+                        skipped_pairs.append((i, j))
+                    atom_chain_mask_j = asym_id_to_asym_mask[j][atom_to_token_idx]
+                    N_chain_j = torch.sum(atom_chain_mask_j).item()
+                    if self.compute_vdw_clash and not skip_bonded_ligand:
+                        vdw_clash_pairs = self.get_chain_pair_violations(
+                            pred_coordinate=pred_coordinate[sample_id, :, :],
+                            violation_type="vdw",
+                            chain_1_mask=atom_chain_mask_i,
+                            chain_2_mask=atom_chain_mask_j,
+                            elements_one_hot=elements_one_hot,
+                        )
+                        if vdw_clash_pairs.shape[0] > 0:
+                            vdw_clash_details[(sample_id, i, j)] = vdw_clash_pairs
+                            has_vdw_clash_flag[sample_id, i, j] = True
+                            has_vdw_clash_flag[sample_id, j, i] = True
+                    if (
+                        chain_types[i] == "lig" or chain_types[j] == "lig"
+                    ):  # AF3 clash only consider polymer chains
+                        continue
+                    if self.compute_af3_clash:
+                        af3_clash_pairs = self.get_chain_pair_violations(
+                            pred_coordinate=pred_coordinate[sample_id, :, :],
+                            violation_type="af3",
+                            chain_1_mask=atom_chain_mask_i,
+                            chain_2_mask=atom_chain_mask_j,
+                        )
+                        total_clash = af3_clash_pairs.shape[0]
+                        relative_clash = total_clash / min(N_chain_i, N_chain_j)
+                        af3_clash_details[sample_id, i, j, 0] = total_clash
+                        af3_clash_details[sample_id, i, j, 1] = relative_clash
+                        has_af3_clash_flag[sample_id, i, j] = (
+                            total_clash > 100 or relative_clash > 0.5
+                        )
+                        af3_clash_details[sample_id, j, i, :] = af3_clash_details[
+                            sample_id, i, j, :
+                        ]
+                        has_af3_clash_flag[sample_id, j, i] = has_af3_clash_flag[
+                            sample_id, i, j
+                        ]
+        return {
+            "summary": {
+                "af3_clash": has_af3_clash_flag if self.compute_af3_clash else None,
+                "vdw_clash": has_vdw_clash_flag if self.compute_vdw_clash else None,
+                "chain_types": chain_types,
+                "skipped_pairs": skipped_pairs,
+            },
+            "details": {
+                "af3_clash": af3_clash_details if self.compute_af3_clash else None,
+                "vdw_clash": vdw_clash_details if self.compute_vdw_clash else None,
+            },
+        }

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/metrics/lddt_metrics.py

@@ -0,0 +1,277 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional
+
+import torch
+import torch.nn as nn
+
+from protenix.model import sample_confidence
+
+
+def get_complex_level_rankers(scores, keys):
+    assert all([k in ["plddt", "gpde", "ranking_score"] for k in keys])
+    rankers = {}
+    for key in keys:
+        if key == "gpde":
+            descending = False
+        else:
+            descending = True
+        ranking = scores[key].argsort(dim=0, descending=descending)
+        rankers[f"{key}.rank1"] = lambda x, rank1_idx=ranking[0].item(): x[
+            ..., rank1_idx
+        ]
+    return rankers
+
+
+def add_diff_metrics(scores, ranker_keys):
+    diff_metrics = {
+        "diff/best_worst": scores["best"] - scores["worst"],
+        "diff/best_random": scores["best"] - scores["random"],
+        "diff/best_median": scores["best"] - scores["median"],
+    }
+
+    for key in ranker_keys:
+        diff_metrics.update(
+            {
+                f"diff/best_{key}": scores["best"] - scores[f"{key}.rank1"],
+                f"diff/{key}_median": scores[f"{key}.rank1"] - scores["median"],
+            }
+        )
+    scores.update(diff_metrics)
+    return scores
+
+
+class LDDTMetrics(nn.Module):
+    """LDDT: evaluated on chains and interfaces"""
+
+    def __init__(self, configs):
+        super(LDDTMetrics, self).__init__()
+        self.eps = configs.metrics.lddt.eps
+        self.configs = configs
+        self.chunk_size = self.configs.infer_setting.lddt_metrics_chunk_size
+        self.lddt_base = LDDT(eps=self.eps)
+
+        self.complex_ranker_keys = configs.metrics.get(
+            "complex_ranker_keys", ["plddt", "gpde", "ranking_score"]
+        )
+
+    def compute_lddt(self, pred_dict: dict, label_dict: dict):
+        """compute complex-level and chain/interface-level lddt
+
+        Args:
+            pred_dict (Dict): a dictionary containing
+                coordinate: [N_sample, N_atom, 3]
+            label_dict (Dict): a dictionary containing
+                coordinate: [N_sample, N_atom, 3]
+                lddt_mask: [N_atom, N_atom]
+        """
+
+        out = {}
+
+        # Complex-level
+        lddt = self.lddt_base.forward(
+            pred_coordinate=pred_dict["coordinate"],
+            true_coordinate=label_dict["coordinate"],
+            lddt_mask=label_dict["lddt_mask"],
+            chunk_size=self.chunk_size,
+        )  # [N_sample]
+        out["complex"] = lddt
+
+        return out
+
+    def aggregate(
+        self,
+        vals,
+        dim: int = -1,
+        aggregators: dict = {},
+    ):
+        N_sample = vals.size(dim)
+        median_index = N_sample // 2
+        basic_sample_aggregators = {
+            "best": lambda x: x.max(dim=dim)[0],
+            "worst": lambda x: x.min(dim=dim)[0],
+            "random": lambda x: x.select(dim=dim, index=0),
+            "mean": lambda x: x.mean(dim=dim),
+            "median": lambda x: x.sort(dim=dim, descending=True)[0].select(
+                dim=dim, index=median_index
+            ),
+        }
+        sample_aggregators = {**basic_sample_aggregators, **aggregators}
+
+        return {
+            agg_name: agg_func(vals)
+            for agg_name, agg_func in sample_aggregators.items()
+        }
+
+    def aggregate_lddt(self, lddt_dict, per_sample_summary_confidence):
+
+        # Merge summary_confidence results
+        confidence_scores = sample_confidence.merge_per_sample_confidence_scores(
+            per_sample_summary_confidence
+        )
+
+        # Complex-level LDDT
+        complex_level_ranker = get_complex_level_rankers(
+            confidence_scores, self.complex_ranker_keys
+        )
+
+        complex_lddt = self.aggregate(
+            lddt_dict["complex"], aggregators=complex_level_ranker
+        )
+        complex_lddt = add_diff_metrics(complex_lddt, self.complex_ranker_keys)
+        # Log metrics
+        complex_lddt = {
+            f"lddt/complex/{name}": value for name, value in complex_lddt.items()
+        }
+        return complex_lddt, {}
+
+
+class LDDT(nn.Module):
+    """LDDT base metrics"""
+
+    def __init__(self, eps: float = 1e-10):
+        super(LDDT, self).__init__()
+        self.eps = eps
+
+    def _chunk_base_forward(self, pred_distance, true_distance) -> torch.Tensor:
+        distance_error_l1 = torch.abs(
+            pred_distance - true_distance
+        )  # [N_sample, N_pair_sparse]
+        thresholds = [0.5, 1, 2, 4]
+        sparse_pair_lddt = (
+            torch.stack([distance_error_l1 < t for t in thresholds], dim=-1)
+            .to(dtype=distance_error_l1.dtype)
+            .mean(dim=-1)
+        )  # [N_sample, N_pair_sparse]
+        del distance_error_l1
+        # Compute mean
+        if sparse_pair_lddt.numel() == 0:  # corespand to all zero in dense mask
+            sparse_pair_lddt = torch.zeros_like(sparse_pair_lddt)
+        lddt = torch.mean(sparse_pair_lddt, dim=-1)
+        return lddt
+
+    def _chunk_forward(
+        self, pred_distance, true_distance, chunk_size: Optional[int] = None
+    ) -> torch.Tensor:
+        if chunk_size is None:
+            return self._chunk_base_forward(pred_distance, true_distance)
+        else:
+            lddt = []
+            N_sample = pred_distance.shape[-2]
+            no_chunks = N_sample // chunk_size + (N_sample % chunk_size != 0)
+            for i in range(no_chunks):
+                lddt_i = self._chunk_base_forward(
+                    pred_distance[
+                        ...,
+                        i * chunk_size : (i + 1) * chunk_size,
+                        :,
+                    ],
+                    true_distance,
+                )
+                lddt.append(lddt_i)
+            lddt = torch.cat(lddt, dim=-1)  # [N_sample]
+            return lddt
+
+    def _calc_sparse_dist(self, pred_coordinate, true_coordinate, l_index, m_index):
+        pred_coords_l = pred_coordinate.index_select(
+            -2, l_index
+        )  # [N_sample, N_atom_sparse_l, 3]
+        pred_coords_m = pred_coordinate.index_select(
+            -2, m_index
+        )  # [N_sample, N_atom_sparse_m, 3]
+        true_coords_l = true_coordinate.index_select(
+            -2, l_index
+        )  # [N_atom_sparse_l, 3]
+        true_coords_m = true_coordinate.index_select(
+            -2, m_index
+        )  # [N_atom_sparse_m, 3]
+
+        pred_distance_sparse_lm = torch.norm(
+            pred_coords_l - pred_coords_m, p=2, dim=-1
+        )  # [N_sample, N_pair_sparse]
+        true_distance_sparse_lm = torch.norm(
+            true_coords_l - true_coords_m, p=2, dim=-1
+        )  # [N_sample, N_pair_sparse]
+        return pred_distance_sparse_lm, true_distance_sparse_lm
+
+    def forward(
+        self,
+        pred_coordinate: torch.Tensor,
+        true_coordinate: torch.Tensor,
+        lddt_mask: torch.Tensor,
+        chunk_size: Optional[int] = None,
+    ) -> dict[str, torch.Tensor]:
+        """LDDT: evaluated on complex, chains and interfaces
+        sparse implementation, which largely reduce cuda memory when atom num reaches 10^4 +
+
+        Args:
+            pred_coordinate (torch.Tensor): the pred coordinates
+                [N_sample, N_atom, 3]
+            true_coordinate (torch.Tensor): the ground truth atom coordinates
+                [N_atom, 3]
+            lddt_mask (torch.Tensor):
+                sparse version of [N_atom, N_atom] atompair mask based on bespoke radius of true distance
+                [N_nonzero_mask, 2]
+
+        Returns:
+            Dict[str, torch.Tensor]:
+                "best": [N_eval]
+                "worst": [N_eval]
+        """
+        lddt_indices = torch.nonzero(lddt_mask, as_tuple=True)
+        l_index = lddt_indices[0]
+        m_index = lddt_indices[1]
+        pred_distance_sparse_lm, true_distance_sparse_lm = self._calc_sparse_dist(
+            pred_coordinate, true_coordinate, l_index, m_index
+        )
+        group_lddt = self._chunk_forward(
+            pred_distance_sparse_lm, true_distance_sparse_lm, chunk_size=chunk_size
+        )  # [N_sample]
+        return group_lddt
+
+    @staticmethod
+    def compute_lddt_mask(
+        true_coordinate: torch.Tensor,
+        true_coordinate_mask: torch.Tensor,
+        is_nucleotide: torch.Tensor = None,
+        is_nucleotide_threshold: float = 30.0,
+        threshold: float = 15.0,
+    ):
+        # Distance mask
+        distance_mask = (
+            true_coordinate_mask[..., None] * true_coordinate_mask[..., None, :]
+        )
+        # Distances for all atom pairs
+        # Note: we convert to bf16 for saving cuda memory, if performance drops, do not convert it
+        distance = (torch.cdist(true_coordinate, true_coordinate) * distance_mask).to(
+            true_coordinate.dtype
+        )  # [..., N_atom, N_atom]
+
+        # Local mask
+        c_lm = distance < threshold  # [..., N_atom, N_atom]
+        if is_nucleotide is not None:
+            # Use a different radius for nucleotide
+            is_nucleotide_mask = is_nucleotide.bool()[..., None]
+            c_lm = (distance < is_nucleotide_threshold) * is_nucleotide_mask + c_lm * (
+                ~is_nucleotide_mask
+            )
+
+        # Zero-out diagonals of c_lm and cast to float
+        c_lm = c_lm * (
+            1 - torch.eye(n=c_lm.size(-1), device=c_lm.device, dtype=distance.dtype)
+        )
+        # Zero-out atom pairs without true coordinates
+        c_lm = c_lm * distance_mask  # [..., N_atom, N_atom]
+        return c_lm

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/metrics/rmsd.py

@@ -0,0 +1,260 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional
+
+import torch
+
+
+def rmsd(
+    pred_pose: torch.Tensor,
+    true_pose: torch.Tensor,
+    mask: torch.Tensor = None,
+    eps: float = 0.0,
+    reduce: bool = True,
+):
+    """
+    compute rmsd between two poses, with the same shape
+    Arguments:
+        pred_pose/true_pose: [...,N,3], two poses with the same shape
+        mask: [..., N], mask to indicate which atoms/pseudo_betas/etc to compute
+        eps: add a tolerance to avoid floating number issue
+        reduce: decide the return shape of rmsd;
+    Return:
+        rmsd: if reduce = true, return the mean of rmsd over batches;
+            else return a tensor containing each rmsd separately
+    """
+
+    # mask [..., N]
+    assert pred_pose.shape == true_pose.shape  # [..., N, 3]
+
+    if mask is None:
+        mask = torch.ones(true_pose.shape[:-1], device=true_pose.device)
+
+    # [...]
+    err2 = (torch.square(pred_pose - true_pose).sum(dim=-1) * mask).sum(
+        dim=-1
+    ) / mask.sum(dim=-1)
+    rmsd = err2.add(eps).sqrt()
+    if reduce:
+        rmsd = rmsd.mean()
+    return rmsd
+
+
+def align_pred_to_true(
+    pred_pose: torch.Tensor,
+    true_pose: torch.Tensor,
+    atom_mask: Optional[torch.Tensor] = None,
+    weight: Optional[torch.Tensor] = None,
+    allowing_reflection: bool = False,
+):
+    """Find optimal transformation, rotation (and reflection) of two poses.
+    Arguments:
+        pred_pose: [...,N,3] the pose to perform transformation on
+        true_pose: [...,N,3] the target pose to align pred_pose to
+        atom_mask: [..., N] a mask for atoms
+        weight: [..., N] a weight vector to be applied.
+        allow_reflection: whether to allow reflection when finding optimal alignment
+    return:
+        aligned_pose: [...,N,3] the transformed pose
+        rot: optimal rotation
+        translate: optimal translation
+    """
+    if atom_mask is not None:
+        pred_pose = pred_pose * atom_mask.unsqueeze(-1)
+        true_pose = true_pose * atom_mask.unsqueeze(-1)
+    else:
+        atom_mask = torch.ones(*pred_pose.shape[:-1]).to(pred_pose.device)
+
+    if weight is None:
+        weight = atom_mask
+    else:
+        weight = weight * atom_mask
+
+    weighted_n_atoms = torch.sum(weight, dim=-1, keepdim=True).unsqueeze(-1)
+    pred_pose_centroid = (
+        torch.sum(pred_pose * weight.unsqueeze(-1), dim=-2, keepdim=True)
+        / weighted_n_atoms
+    )
+    pred_pose_centered = pred_pose - pred_pose_centroid
+    true_pose_centroid = (
+        torch.sum(true_pose * weight.unsqueeze(-1), dim=-2, keepdim=True)
+        / weighted_n_atoms
+    )
+    true_pose_centered = true_pose - true_pose_centroid
+    H_mat = torch.matmul(
+        (pred_pose_centered * weight.unsqueeze(-1)).transpose(-2, -1),
+        true_pose_centered * atom_mask.unsqueeze(-1),
+    )
+    u, s, v = torch.svd(H_mat)
+    u = u.transpose(-1, -2)
+
+    if not allowing_reflection:
+
+        det = torch.linalg.det(torch.matmul(v, u))
+
+        diagonal = torch.stack(
+            [torch.ones_like(det), torch.ones_like(det), det], dim=-1
+        )
+        rot = torch.matmul(
+            torch.diag_embed(diagonal).to(u.device),
+            u,
+        )
+        rot = torch.matmul(v, rot)
+    else:
+        rot = torch.matmul(v, u)
+    translate = true_pose_centroid - torch.matmul(
+        pred_pose_centroid, rot.transpose(-1, -2)
+    )
+
+    pred_pose_translated = (
+        torch.matmul(pred_pose_centered, rot.transpose(-1, -2)) + true_pose_centroid
+    )
+
+    return pred_pose_translated, rot, translate
+
+
+def partially_aligned_rmsd(
+    pred_pose: torch.Tensor,
+    true_pose: torch.Tensor,
+    align_mask: torch.Tensor,
+    atom_mask: torch.Tensor,
+    weight: Optional[torch.Tensor] = None,
+    eps: float = 0.0,
+    reduce: bool = True,
+    allowing_reflection: bool = False,
+):
+    """RMSD when aligning parts of the complex coordinate, does NOT take permutation symmetricity into consideration
+    Arguments:
+        pred_pose: native predicted pose, [..., N,3]
+        true_pose: ground truth pose, [..., N, 3]
+        align_mask: a mask representing which coordinates to align [..., N]
+        atom_mask: a mask representing which coordinates to compute loss [..., N]
+        weight: a weight tensor assining weights in alignment for each atom [..., N]
+        eps: add a tolerance to avoid floating number issue in sqrt
+        reduce: decide the return shape of rmsd;
+        allowing_reflection: whether to allow reflection when finding optimal alignment
+    return:
+        aligned_part_rmsd: the rmsd of part being align_masked
+        unaligned_part_rmsd: the rmsd of unaligned part
+        transformed_pred_pose:
+        rot: optimal rotation
+        trans: optimal translation
+    """
+    _, rot, translate = align_pred_to_true(
+        pred_pose,
+        true_pose,
+        atom_mask=atom_mask * align_mask,
+        weight=weight,
+        allowing_reflection=allowing_reflection,
+    )
+    transformed_pose = torch.matmul(pred_pose, rot.transpose(-1, -2)) + translate
+    err_atom = torch.square(transformed_pose - true_pose).sum(dim=-1) * atom_mask
+    aligned_mask, unaligned_mask = atom_mask * align_mask.float(), atom_mask * (
+        1 - align_mask.float()
+    )
+    aligned_part_err_square = (err_atom * aligned_mask).sum(dim=-1) / aligned_mask.sum(
+        dim=-1
+    )
+    unaligned_part_err_square = (err_atom * unaligned_mask).sum(
+        dim=-1
+    ) / unaligned_mask.sum(dim=-1)
+    aligned_part_rmsd = aligned_part_err_square.add(eps).sqrt()
+    unaligned_part_rmsd = unaligned_part_err_square.add(eps).sqrt()
+    if reduce:
+        aligned_part_rmsd = aligned_part_rmsd.mean()
+        unaligned_part_rmsd = unaligned_part_rmsd.mean()
+    return aligned_part_rmsd, unaligned_part_rmsd, transformed_pose, rot, translate
+
+
+def self_aligned_rmsd(
+    pred_pose: torch.Tensor,
+    true_pose: torch.Tensor,
+    atom_mask: torch.Tensor,
+    eps: float = 0.0,
+    reduce: bool = True,
+    allowing_reflection: bool = False,
+):
+    """RMSD when aligning one molecule with ground truth and compute rmsd.
+    Arguments:
+        pred_pose: native predicted pose, [..., N,3]
+        true_pose: ground truth pose, [..., N, 3]
+        atom_mask: a mask representing which coordinates to compute loss [..., N]
+        eps: add a tolerance to avoid floating number issue in sqrt
+        reduce: decide the return shape of rmsd;
+        allowing_reflection: whether to allow reflection when finding optimal alignment
+    return:
+        aligned_rmsd: the rmsd of part being align_masked
+        transformed_pred_pose: the aligned pose
+        rot: optimal rotation matrix
+        trans: optimal translation
+    """
+    aligned_rmsd, _, transformed_pred_pose, rot, trans = partially_aligned_rmsd(
+        pred_pose=pred_pose,
+        true_pose=true_pose,
+        align_mask=atom_mask,
+        atom_mask=atom_mask,
+        eps=eps,
+        reduce=reduce,
+        allowing_reflection=allowing_reflection,
+    )
+    return aligned_rmsd, transformed_pred_pose, rot, trans
+
+
+def weighted_rigid_align(
+    x: torch.Tensor,
+    x_target: torch.Tensor,
+    atom_weight: torch.Tensor,
+    stop_gradient: bool = True,
+) -> tuple[torch.Tensor]:
+    """Implements Algorithm 28 in AF3. Wrap `align_pred_to_true`.
+
+    Args:
+        x (torch.Tensor): input coordinates, it will be moved to match x_target.
+            [..., N_atom, 3]
+        x_target (torch.Tensor): target coordinates for the input to match.
+            [..., N_atom, 3]
+        atom_weight (torch.Tensor): weights for each atom.
+            [..., N_atom] or [N_atom]
+        stop_gradient (bool): whether to detach the output. If true, will run it with no_grad() ctx.
+
+    Returns:
+        x_aligned (torch.Tensor): rotated, translated x which should be closer to x_target.
+            [..., N_atom, 3]
+    """
+
+    if len(atom_weight.shape) == len(x.shape) - 1:
+        assert atom_weight.shape[:-1] == x.shape[:-2]
+    else:
+        assert len(atom_weight.shape) == 1 and atom_weight.shape[-1] == x.shape[-2]
+
+    if stop_gradient:
+        with torch.no_grad():
+            x_aligned, rot, trans = align_pred_to_true(
+                pred_pose=x,
+                true_pose=x_target,
+                atom_mask=None,
+                weight=atom_weight,
+                allowing_reflection=False,
+            )
+            return x_aligned.detach()
+    else:
+        x_aligned, rot, trans = align_pred_to_true(
+            pred_pose=x,
+            true_pose=x_target,
+            atom_mask=None,
+            weight=atom_weight,
+            allowing_reflection=False,
+        )
+        return x_aligned

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/model/generator.py

@@ -0,0 +1,332 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any, Callable, Optional
+
+import torch
+
+from protenix.model.utils import centre_random_augmentation
+
+
+class TrainingNoiseSampler:
+    """
+    Sample the noise-level of of training samples
+    """
+
+    def __init__(
+        self,
+        p_mean: float = -1.2,
+        p_std: float = 1.5,
+        sigma_data: float = 16.0,  # NOTE: in EDM, this is 1.0
+    ) -> None:
+        """Sampler for training noise-level
+
+        Args:
+            p_mean (float, optional): gaussian mean. Defaults to -1.2.
+            p_std (float, optional): gaussian std. Defaults to 1.5.
+            sigma_data (float, optional): scale. Defaults to 16.0, but this is 1.0 in EDM.
+        """
+        self.sigma_data = sigma_data
+        self.p_mean = p_mean
+        self.p_std = p_std
+        print(f"train scheduler {self.sigma_data}")
+
+    def __call__(
+        self, size: torch.Size, device: torch.device = torch.device("cpu")
+    ) -> torch.Tensor:
+        """Sampling
+
+        Args:
+            size (torch.Size): the target size
+            device (torch.device, optional): target device. Defaults to torch.device("cpu").
+
+        Returns:
+            torch.Tensor: sampled noise-level
+        """
+        rnd_normal = torch.randn(size=size, device=device)
+        noise_level = (rnd_normal * self.p_std + self.p_mean).exp() * self.sigma_data
+        return noise_level
+
+
+class InferenceNoiseScheduler:
+    """
+    Scheduler for noise-level (time steps)
+    """
+
+    def __init__(
+        self,
+        s_max: float = 160.0,
+        s_min: float = 4e-4,
+        rho: float = 7,
+        sigma_data: float = 16.0,  # NOTE: in EDM, this is 1.0
+    ) -> None:
+        """Scheduler parameters
+
+        Args:
+            s_max (float, optional): maximal noise level. Defaults to 160.0.
+            s_min (float, optional): minimal noise level. Defaults to 4e-4.
+            rho (float, optional): the exponent numerical part. Defaults to 7.
+            sigma_data (float, optional): scale. Defaults to 16.0, but this is 1.0 in EDM.
+        """
+        self.sigma_data = sigma_data
+        self.s_max = s_max
+        self.s_min = s_min
+        self.rho = rho
+        print(f"inference scheduler {self.sigma_data}")
+
+    def __call__(
+        self,
+        N_step: int = 200,
+        device: torch.device = torch.device("cpu"),
+        dtype: torch.dtype = torch.float32,
+    ) -> torch.Tensor:
+        """Schedule the noise-level (time steps). No sampling is performed.
+
+        Args:
+            N_step (int, optional): number of time steps. Defaults to 200.
+            device (torch.device, optional): target device. Defaults to torch.device("cpu").
+            dtype (torch.dtype, optional): target dtype. Defaults to torch.float32.
+
+        Returns:
+            torch.Tensor: noise-level (time_steps)
+                [N_step+1]
+        """
+        step_size = 1 / N_step
+        step_indices = torch.arange(N_step + 1, device=device, dtype=dtype)
+        t_step_list = (
+            self.sigma_data
+            * (
+                self.s_max ** (1 / self.rho)
+                + step_indices
+                * step_size
+                * (self.s_min ** (1 / self.rho) - self.s_max ** (1 / self.rho))
+            )
+            ** self.rho
+        )
+        # replace the last time step by 0
+        t_step_list[..., -1] = 0  # t_N = 0
+
+        return t_step_list
+
+
+def sample_diffusion(
+    denoise_net: Callable,
+    input_feature_dict: dict[str, Any],
+    s_inputs: torch.Tensor,
+    s_trunk: torch.Tensor,
+    z_trunk: torch.Tensor,
+    noise_schedule: torch.Tensor,
+    N_sample: int = 1,
+    gamma0: float = 0.8,
+    gamma_min: float = 1.0,
+    noise_scale_lambda: float = 1.003,
+    step_scale_eta: float = 1.5,
+    diffusion_chunk_size: Optional[int] = None,
+    inplace_safe: bool = False,
+    attn_chunk_size: Optional[int] = None,
+) -> torch.Tensor:
+    """Implements Algorithm 18 in AF3.
+    It performances denoising steps from time 0 to time T.
+    The time steps (=noise levels) are given by noise_schedule.
+
+    Args:
+        denoise_net (Callable): the network that performs the denoising step.
+        input_feature_dict (dict[str, Any]): input meta feature dict
+        s_inputs (torch.Tensor): single embedding from InputFeatureEmbedder
+            [..., N_tokens, c_s_inputs]
+        s_trunk (torch.Tensor): single feature embedding from PairFormer (Alg17)
+            [..., N_tokens, c_s]
+        z_trunk (torch.Tensor): pair feature embedding from PairFormer (Alg17)
+            [..., N_tokens, N_tokens, c_z]
+        noise_schedule (torch.Tensor): noise-level schedule (which is also the time steps) since sigma=t.
+            [N_iterations]
+        N_sample (int): number of generated samples
+        gamma0 (float): params in Alg.18.
+        gamma_min (float): params in Alg.18.
+        noise_scale_lambda (float): params in Alg.18.
+        step_scale_eta (float): params in Alg.18.
+        diffusion_chunk_size (Optional[int]): Chunk size for diffusion operation. Defaults to None.
+        inplace_safe (bool): Whether to use inplace operations safely. Defaults to False.
+        attn_chunk_size (Optional[int]): Chunk size for attention operation. Defaults to None.
+
+    Returns:
+        torch.Tensor: the denoised coordinates of x in inference stage
+            [..., N_sample, N_atom, 3]
+    """
+    N_atom = input_feature_dict["atom_to_token_idx"].size(-1)
+    batch_shape = s_inputs.shape[:-2]
+    device = s_inputs.device
+    dtype = s_inputs.dtype
+
+    def _chunk_sample_diffusion(chunk_n_sample, inplace_safe):
+        # init noise
+        # [..., N_sample, N_atom, 3]
+        x_l = noise_schedule[0] * torch.randn(
+            size=(*batch_shape, chunk_n_sample, N_atom, 3), device=device, dtype=dtype
+        )  # NOTE: set seed in distributed training
+
+        for _, (c_tau_last, c_tau) in enumerate(
+            zip(noise_schedule[:-1], noise_schedule[1:])
+        ):
+            # [..., N_sample, N_atom, 3]
+            x_l = (
+                centre_random_augmentation(x_input_coords=x_l, N_sample=1)
+                .squeeze(dim=-3)
+                .to(dtype)
+            )
+
+            # Denoise with a predictor-corrector sampler
+            # 1. Add noise to move x_{c_tau_last} to x_{t_hat}
+            gamma = float(gamma0) if c_tau > gamma_min else 0
+            t_hat = c_tau_last * (gamma + 1)
+
+            delta_noise_level = torch.sqrt(t_hat**2 - c_tau_last**2)
+            x_noisy = x_l + noise_scale_lambda * delta_noise_level * torch.randn(
+                size=x_l.shape, device=device, dtype=dtype
+            )
+
+            # 2. Denoise from x_{t_hat} to x_{c_tau}
+            # Euler step only
+            t_hat = (
+                t_hat.reshape((1,) * (len(batch_shape) + 1))
+                .expand(*batch_shape, chunk_n_sample)
+                .to(dtype)
+            )
+
+            x_denoised = denoise_net(
+                x_noisy=x_noisy,
+                t_hat_noise_level=t_hat,
+                input_feature_dict=input_feature_dict,
+                s_inputs=s_inputs,
+                s_trunk=s_trunk,
+                z_trunk=z_trunk,
+                chunk_size=attn_chunk_size,
+                inplace_safe=inplace_safe,
+            )
+
+            delta = (x_noisy - x_denoised) / t_hat[
+                ..., None, None
+            ]  # Line 9 of AF3 uses 'x_l_hat' instead, which we believe  is a typo.
+            dt = c_tau - t_hat
+            x_l = x_noisy + step_scale_eta * dt[..., None, None] * delta
+
+        return x_l
+
+    if diffusion_chunk_size is None:
+        x_l = _chunk_sample_diffusion(N_sample, inplace_safe=inplace_safe)
+    else:
+        x_l = []
+        no_chunks = N_sample // diffusion_chunk_size + (
+            N_sample % diffusion_chunk_size != 0
+        )
+        for i in range(no_chunks):
+            chunk_n_sample = (
+                diffusion_chunk_size
+                if i < no_chunks - 1
+                else N_sample - i * diffusion_chunk_size
+            )
+            chunk_x_l = _chunk_sample_diffusion(
+                chunk_n_sample, inplace_safe=inplace_safe
+            )
+            x_l.append(chunk_x_l)
+        x_l = torch.cat(x_l, -3)  # [..., N_sample, N_atom, 3]
+    return x_l
+
+
+def sample_diffusion_training(
+    noise_sampler: TrainingNoiseSampler,
+    denoise_net: Callable,
+    label_dict: dict[str, Any],
+    input_feature_dict: dict[str, Any],
+    s_inputs: torch.Tensor,
+    s_trunk: torch.Tensor,
+    z_trunk: torch.Tensor,
+    N_sample: int = 1,
+    diffusion_chunk_size: Optional[int] = None,
+) -> tuple[torch.Tensor, ...]:
+    """Implements diffusion training as described in AF3 Appendix at page 23.
+    It performances denoising steps from time 0 to time T.
+    The time steps (=noise levels) are given by noise_schedule.
+
+    Args:
+        denoise_net (Callable): the network that performs the denoising step.
+        label_dict (dict, optional) : a dictionary containing the followings.
+            "coordinate": the ground-truth coordinates
+                [..., N_atom, 3]
+            "coordinate_mask": whether true coordinates exist.
+                [..., N_atom]
+        input_feature_dict (dict[str, Any]): input meta feature dict
+        s_inputs (torch.Tensor): single embedding from InputFeatureEmbedder
+            [..., N_tokens, c_s_inputs]
+        s_trunk (torch.Tensor): single feature embedding from PairFormer (Alg17)
+            [..., N_tokens, c_s]
+        z_trunk (torch.Tensor): pair feature embedding from PairFormer (Alg17)
+            [..., N_tokens, N_tokens, c_z]
+        N_sample (int): number of training samples
+    Returns:
+        torch.Tensor: the denoised coordinates of x in inference stage
+            [..., N_sample, N_atom, 3]
+    """
+    batch_size_shape = label_dict["coordinate"].shape[:-2]
+    device = label_dict["coordinate"].device
+    dtype = label_dict["coordinate"].dtype
+    # Areate N_sample versions of the input structure by randomly rotating and translating
+    x_gt_augment = centre_random_augmentation(
+        x_input_coords=label_dict["coordinate"],
+        N_sample=N_sample,
+        mask=label_dict["coordinate_mask"],
+    ).to(
+        dtype
+    )  # [..., N_sample, N_atom, 3]
+
+    # Add independent noise to each structure
+    # sigma: independent noise-level [..., N_sample]
+    sigma = noise_sampler(size=(*batch_size_shape, N_sample), device=device).to(dtype)
+    # noise: [..., N_sample, N_atom, 3]
+    noise = torch.randn_like(x_gt_augment, dtype=dtype) * sigma[..., None, None]
+
+    # Get denoising outputs [..., N_sample, N_atom, 3]
+    if diffusion_chunk_size is None:
+        x_denoised = denoise_net(
+            x_noisy=x_gt_augment + noise,
+            t_hat_noise_level=sigma,
+            input_feature_dict=input_feature_dict,
+            s_inputs=s_inputs,
+            s_trunk=s_trunk,
+            z_trunk=z_trunk,
+        )
+    else:
+        x_denoised = []
+        no_chunks = N_sample // diffusion_chunk_size + (
+            N_sample % diffusion_chunk_size != 0
+        )
+        for i in range(no_chunks):
+            x_noisy_i = (x_gt_augment + noise)[
+                ..., i * diffusion_chunk_size : (i + 1) * diffusion_chunk_size, :, :
+            ]
+            t_hat_noise_level_i = sigma[
+                ..., i * diffusion_chunk_size : (i + 1) * diffusion_chunk_size
+            ]
+            x_denoised_i = denoise_net(
+                x_noisy=x_noisy_i,
+                t_hat_noise_level=t_hat_noise_level_i,
+                input_feature_dict=input_feature_dict,
+                s_inputs=s_inputs,
+                s_trunk=s_trunk,
+                z_trunk=z_trunk,
+            )
+            x_denoised.append(x_denoised_i)
+        x_denoised = torch.cat(x_denoised, dim=-3)
+
+    return x_gt_augment, x_denoised, sigma

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/model/layer_norm/__init__.py

@@ -0,0 +1,16 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Copyright 2021- HPC-AI Technology Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http:#www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from .layer_norm import FusedLayerNorm

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/model/layer_norm/kernel/compat.h

@@ -0,0 +1,24 @@
+// modified from https://github.com/NVIDIA/apex/blob/master/csrc/compat.h
+// Copyright 2021- HPC-AI Technology Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef TORCH_CHECK
+#define TORCH_CHECK AT_CHECK
+#endif
+
+#ifdef VERSION_GE_1_3
+#define DATA_PTR data_ptr
+#else
+#define DATA_PTR data
+#endif

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/model/layer_norm/kernel/layer_norm_cuda.cpp

@@ -0,0 +1,138 @@
+// Copyright 2021- HPC-AI Technology Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+
+#include <torch/extension.h>
+#include <c10/cuda/CUDAGuard.h>
+
+#include <cassert>
+#include <vector>
+
+#include "compat.h"
+
+void compute_n1_n2(at::Tensor input, at::IntArrayRef normalized_shape, int& n1, int& n2) {
+    int idiff = input.ndimension() - normalized_shape.size();
+    n2 = 1;
+    for (int i = 0; i < (int)normalized_shape.size(); ++i) {
+        assert(input.sizes()[i + idiff] == normalized_shape[i]);
+        n2 *= normalized_shape[i];
+    }
+    n1 = 1;
+    for (int i = 0; i < idiff; ++i) {
+        n1 *= input.sizes()[i];
+    }
+}
+
+void check_args(at::IntArrayRef normalized_shape, at::Tensor gamma, at::Tensor beta) {
+    TORCH_CHECK(!gamma.defined() || gamma.sizes().equals(normalized_shape));
+    TORCH_CHECK(!beta.defined() || beta.sizes().equals(normalized_shape));
+}
+
+void check_args(at::Tensor input, at::IntArrayRef normalized_shape, int& n1, int& n2) {
+    int64_t normalized_ndim = normalized_shape.size();
+
+    if (normalized_ndim < 1) {
+        std::stringstream ss;
+        ss << "Expected normalized_shape to be at least 1-dimensional, i.e., "
+           << "containing at least one element, but got normalized_shape=" << normalized_shape;
+        throw std::runtime_error(ss.str());
+    }
+
+    auto input_shape = input.sizes();
+    auto input_ndim = input.dim();
+
+    if (input_ndim < normalized_ndim ||
+        !input_shape.slice(input_ndim - normalized_ndim).equals(normalized_shape)) {
+        std::stringstream ss;
+        ss << "Given normalized_shape=" << normalized_shape << ", expected input with shape [*";
+        for (auto size : normalized_shape) {
+            ss << ", " << size;
+        }
+        ss << "], but got input of size" << input_shape;
+        throw std::runtime_error(ss.str());
+    }
+
+    compute_n1_n2(input, normalized_shape, n1, n2);
+}
+
+void check_args(at::Tensor input, at::IntArrayRef normalized_shape, at::Tensor gamma,
+                at::Tensor beta, int& n1, int& n2) {
+    check_args(input, normalized_shape, n1, n2);
+    check_args(normalized_shape, gamma, beta);
+}
+
+void cuda_layer_norm(at::Tensor* output, at::Tensor* mean, at::Tensor* invvar, at::Tensor* input,
+                     int n1, int n2, at::IntArrayRef normalized_shape, at::Tensor* gamma,
+                     at::Tensor* beta, double epsilon);
+
+#define CHECK_CUDA(x) TORCH_CHECK(x.is_cuda(), #x " must be a CUDA tensor")
+#define CHECK_CONTIGUOUS(x) TORCH_CHECK(x.is_contiguous(), #x " must be contiguous")
+#define CHECK_INPUT(x) \
+    CHECK_CUDA(x);     \
+    CHECK_CONTIGUOUS(x)
+
+std::vector<at::Tensor> layer_norm_affine(at::Tensor input, at::IntArrayRef normalized_shape,
+                                          at::Tensor gamma, at::Tensor beta, double epsilon) {
+    CHECK_INPUT(input);
+    CHECK_INPUT(gamma);
+    CHECK_INPUT(beta);
+    int n1, n2;
+    check_args(input, normalized_shape, gamma, beta, n1, n2);
+
+    const at::cuda::OptionalCUDAGuard device_guard(device_of(input));
+
+    at::Tensor output = at::empty_like(input, gamma.options().dtype(gamma.scalar_type()));
+    at::Tensor mean = at::empty({n1}, input.options().dtype(at::ScalarType::Float));
+    at::Tensor invvar = at::empty_like(mean);
+
+    cuda_layer_norm(&output, &mean, &invvar, &input, n1, n2, normalized_shape, &gamma, &beta,
+                    epsilon);
+
+    return {output, mean, invvar};
+}
+
+void cuda_layer_norm_gradient(at::Tensor* dout, at::Tensor* mean, at::Tensor* invvar,
+                              at::Tensor* input, int n1, int n2, at::IntArrayRef normalized_shape,
+                              at::Tensor* gamma, at::Tensor* beta, double epsilon,
+                              at::Tensor* grad_input, at::Tensor* grad_gamma,
+                              at::Tensor* grad_beta);
+
+std::vector<at::Tensor> layer_norm_gradient_affine(at::Tensor dout, at::Tensor mean,
+                                                   at::Tensor invvar, at::Tensor input,
+                                                   at::IntArrayRef normalized_shape,
+                                                   at::Tensor gamma, at::Tensor beta,
+                                                   double epsilon) {
+    CHECK_INPUT(dout);
+    CHECK_INPUT(mean);
+    CHECK_INPUT(invvar);
+    CHECK_INPUT(input);
+    CHECK_INPUT(gamma);
+    CHECK_INPUT(beta);
+    int n1, n2;
+    check_args(input, normalized_shape, gamma, beta, n1, n2);
+
+    const at::cuda::OptionalCUDAGuard device_guard(device_of(input));
+
+    at::Tensor grad_input = at::empty_like(input);
+    at::Tensor grad_gamma = at::empty_like(gamma);
+    at::Tensor grad_beta = at::empty_like(beta);
+
+    cuda_layer_norm_gradient(&dout, &mean, &invvar, &input, n1, n2, normalized_shape, &gamma, &beta,
+                             epsilon, &grad_input, &grad_gamma, &grad_beta);
+
+    return {grad_input, grad_gamma, grad_beta};
+}
+
+PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
+    m.def("forward_affine", &layer_norm_affine, "LayerNorm forward (CUDA)");
+    m.def("backward_affine", &layer_norm_gradient_affine, "LayerNorm backward (CUDA)");
+}

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/model/layer_norm/kernel/layer_norm_cuda_kernel.cu

@@ -0,0 +1,409 @@
+// Copyright 2024 ByteDance and/or its affiliates.
+// Copyright 2020 The OneFlow Authors.
+// Copyright 2021- HPC-AI Technology Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include <cooperative_groups.h>
+#include <cuda.h>
+#include <cuda_runtime.h>
+#include <torch/extension.h>
+#include <iostream>
+
+#include <THC/THCDeviceUtils.cuh>
+
+#include "ATen/ATen.h"
+#include "ATen/AccumulateType.h"
+#include "ATen/cuda/CUDAContext.h"
+#include "compat.h"
+#include "type_shim.h"
+
+#define CHECK_CUDA(x) TORCH_CHECK(x.is_cuda(), #x " must be a CUDA tensor")
+#define CHECK_CONTIGUOUS(x) TORCH_CHECK(x.is_contiguous(), #x " must be contiguous")
+#define CHECK_INPUT(x) \
+    CHECK_CUDA(x);     \
+    CHECK_CONTIGUOUS(x)
+
+#define WarpNum 8
+#define WarpSize 32
+#define BlockSzie WarpNum*WarpSize
+
+inline __device__ void WelfordOnline(float val, float* mean, float* m2, float* count) {
+    *count += 1;
+    float delta1 = val - *mean;
+    *mean += delta1 / (*count);
+    float delta2 = val - *mean;
+    *m2 += delta1 * delta2;
+}
+
+inline __device__ void WelfordOnline(float b_mean, float b_m2, float b_count, float* mean,
+                                     float* m2, float* count) {
+    if (b_count == 0) {
+        return;
+    }
+    float new_count = *count + b_count;
+    float nb_n = b_count / new_count;
+    float delta = b_mean - *mean;
+    *mean += delta * nb_n;
+    *m2 += b_m2 + delta * delta * (*count) * nb_n;
+    *count = new_count;
+}
+
+__inline__ __device__ void WelfordWarpAllReduce(float thread_mean, float thread_m2,
+                                                float thread_count, float* mean, float* m2,
+                                                float* count) {
+    *mean = thread_mean;
+    *m2 = thread_m2;
+    *count = thread_count;
+    for (int mask = 1; mask < 32; mask *= 2) {
+        float b_mean = __shfl_down_sync(0xffffffff, *mean, mask);
+        float b_m2 = __shfl_down_sync(0xffffffff, *m2, mask);
+        float b_count = __shfl_down_sync(0xffffffff, *count, mask);
+        WelfordOnline(b_mean, b_m2, b_count, mean, m2, count);
+    }
+
+    *mean = __shfl_sync(0xffffffff, *mean, 0, 32);
+    *m2 = __shfl_sync(0xffffffff, *m2, 0, 32);
+    *count = __shfl_sync(0xffffffff, *count, 0, 32);
+}
+
+extern __shared__ float shared_data[];
+template <typename T>
+__global__ void LayerNormForward(T* input, T* output, T* gamma, T* beta, float* mean,
+                                 float* invvar, int rows, int cols, double epsilon) {
+    int warp_id = threadIdx.x / WarpSize;
+    int lane_id = threadIdx.x % WarpSize;
+    int row_offset = blockIdx.x * WarpNum + warp_id;
+
+    float* shared_data_warp = shared_data + warp_id*cols;
+
+    if (row_offset < rows) {
+        T* row_input = input + (long long)(row_offset) * (long long)(cols); // Starting point for input data
+        T* row_output = output + (long long)(row_offset) * (long long)(cols); // Starting point for output data
+
+        float thread_mean = 0.f;
+        float thread_m2 = 0.f;
+        float thread_count = 0.f;
+
+        float warp_mean;
+        float warp_m2;
+        float warp_count;
+        // load data to shared memory
+#pragma unroll
+        for(int idx = lane_id; idx < cols; idx += WarpSize) {
+            shared_data_warp[idx] = static_cast<float>(row_input[idx]);
+            WelfordOnline(shared_data_warp[idx], &thread_mean, &thread_m2, &thread_count);
+        }
+
+        WelfordWarpAllReduce(thread_mean, thread_m2, thread_count, &warp_mean, &warp_m2,
+                             &warp_count);
+
+        float row_mean = warp_mean;
+        float row_variance = max(warp_m2 / warp_count, 0.f);
+        float row_inv_var = rsqrt(row_variance + epsilon);
+        if (lane_id == 0) {
+            mean[row_offset] = row_mean;
+            invvar[row_offset] = row_inv_var;
+        }
+
+#pragma unroll
+        for(int idx = lane_id; idx < cols; idx += WarpSize) {
+            row_output[idx] = static_cast<T>((shared_data_warp[idx] - row_mean) * row_inv_var) * gamma[idx] + beta[idx];
+        }
+    }
+}
+
+void cuda_layer_norm(at::Tensor* output, at::Tensor* mean, at::Tensor* invvar, at::Tensor* input,
+                     int rows, int cols, at::IntArrayRef normalized_shape, at::Tensor* gamma,
+                     at::Tensor* beta, double epsilon) {
+    int grid = (rows + WarpNum - 1) / WarpNum; // each warp process one line
+    dim3 block(BlockSzie);
+    // add shared memory size
+    int shared_meory_size = WarpNum*sizeof(float)*cols;
+    if (output->dtype() == torch::kFloat32) {
+        LayerNormForward<float><<<grid, block, shared_meory_size>>>(
+            (float*)input->data_ptr(), (float*)output->data_ptr(), (float*)gamma->data_ptr(),
+            (float*)beta->data_ptr(), (float*)mean->data_ptr(), (float*)invvar->data_ptr(), rows,
+            cols, epsilon);
+    } else if (output->dtype() == torch::kFloat16) {
+        LayerNormForward<at::Half><<<grid, block, shared_meory_size>>>(
+            (at::Half*)input->data_ptr(), (at::Half*)output->data_ptr(),
+            (at::Half*)gamma->data_ptr(), (at::Half*)beta->data_ptr(), (float*)mean->data_ptr(),
+            (float*)invvar->data_ptr(), rows, cols, epsilon);
+    } else if (output->dtype() == torch::kBFloat16) {
+        LayerNormForward<at::BFloat16><<<grid, block, shared_meory_size>>>(
+            (at::BFloat16*)input->data_ptr(), (at::BFloat16*)output->data_ptr(),
+            (at::BFloat16*)gamma->data_ptr(), (at::BFloat16*)beta->data_ptr(),
+            (float*)mean->data_ptr(), (float*)invvar->data_ptr(), rows, cols, epsilon);
+    }
+}
+
+template <typename T>
+struct SharedMemory;
+
+template <>
+struct SharedMemory<float> {
+    __device__ float* getPointer() {
+        extern __shared__ float s_float[];
+        return s_float;
+    }
+};
+
+template<typename T>
+__inline__ __device__ T WarpReduce(T val) {
+  for (int mask = 16; mask > 0; mask /= 2) { val += __shfl_xor_sync(0xffffffff, val, mask); }
+  return val;
+}
+
+constexpr int tile_size = 32;
+constexpr int num_per_block = 4;
+constexpr int block_dim_x = 32;
+constexpr int block_dim_y = 32 / num_per_block;
+
+template <typename T, typename U, typename V>
+__global__ void LayerNormParamGradStep1(int rows, int cols, const V* __restrict__ dy,
+                                        const T* __restrict__ x, const U* __restrict__ mean,
+                                        const U* __restrict__ inv_var,
+                                        U* __restrict__ tmp_gamma_diff, U* __restrict__ tmp_beta_diff) {
+  __shared__ U dgamma[32][33];
+  __shared__ U dbeta[32][33];
+  U dgamma_sum[num_per_block];
+  U dbeta_sum[num_per_block];
+#pragma unroll
+  for (int index = 0; index < num_per_block; ++index) {
+    dgamma_sum[index] = 0;
+    dbeta_sum[index] = 0;
+  }
+  const int col_id = blockIdx.x * blockDim.x + threadIdx.x;
+  if (col_id < cols) {
+    for (int i = blockIdx.y * tile_size + threadIdx.y; i < rows; i += tile_size * gridDim.y) {
+#pragma unroll
+      for (int index = 0; index < num_per_block; ++index) {
+        int row_id = i + index * blockDim.y;
+        if (row_id < rows) {
+          int offset = row_id * cols + col_id;
+          const U dy_val = static_cast<U>(dy[offset]);
+          const U x_val = static_cast<U>(x[offset]);
+          const U mean_val = mean[row_id];
+          const U inv_var_val = inv_var[row_id];
+          dgamma_sum[index] += dy_val * (x_val - mean_val) * inv_var_val;
+          dbeta_sum[index] += dy_val;
+        }
+      }
+    }
+  }
+#pragma unroll
+  for (int index = 0; index < num_per_block; ++index) {
+    dgamma[index * blockDim.y + threadIdx.y][threadIdx.x] = dgamma_sum[index];
+    dbeta[index * blockDim.y + threadIdx.y][threadIdx.x] = dbeta_sum[index];
+  }
+  __syncthreads();
+#pragma unroll
+  for (int index = 0; index < num_per_block; ++index) {
+    const int col_id = blockIdx.x * blockDim.x + threadIdx.y + index * blockDim.y;
+    if (col_id < cols) {
+      U gamma_sum = dgamma[threadIdx.x][threadIdx.y + index * blockDim.y];
+      U beta_sum = dbeta[threadIdx.x][threadIdx.y + index * blockDim.y];
+      U global_dgamma = WarpReduce<U>(gamma_sum);
+      U global_dbeta = WarpReduce<U>(beta_sum);
+      if (threadIdx.x == 0) {
+        const int offset = blockIdx.y * cols + col_id;
+        tmp_gamma_diff[offset] = global_dgamma;
+        tmp_beta_diff[offset] = global_dbeta;
+      }
+    }
+  }
+}
+
+template <typename U, typename V>
+__global__ void LayerNormParamGradStep2(const U* part_grad_gamma, const U* part_grad_beta,
+                                        const int part_size, const int n1, const int n2,
+                                        V* grad_gamma, V* grad_beta) {
+    // sum partial gradients for gamma and beta
+    SharedMemory<U> shared;
+    U* buf = shared.getPointer();
+    int i2 = blockIdx.x * blockDim.x + threadIdx.x;
+    if (i2 < n2) {
+        // each warp does sequential reductions until reduced part_size is num_warps
+        // int num_warp_reductions = part_size / blockDim.y;
+        U sum_gamma = U(0);
+        U sum_beta = U(0);
+        const U* part_grad_gamma_ptr = part_grad_gamma + i2;
+        const U* part_grad_beta_ptr = part_grad_beta + i2;
+        for (int row_idx = threadIdx.y; row_idx < part_size; row_idx += blockDim.y) {
+            sum_gamma += part_grad_gamma_ptr[row_idx * n2];
+            sum_beta += part_grad_beta_ptr[row_idx * n2];
+        }
+        // inter-warp reductions
+        const int nbsize3 = blockDim.x * blockDim.y / 2;
+        for (int offset = blockDim.y / 2; offset >= 1; offset /= 2) {
+            // top half write to shared memory
+            if (threadIdx.y >= offset && threadIdx.y < 2 * offset) {
+                const int write_idx = (threadIdx.y - offset) * blockDim.x + threadIdx.x;
+                buf[write_idx] = sum_gamma;
+                buf[write_idx + nbsize3] = sum_beta;
+            }
+            __syncthreads();
+            // bottom half sums
+            if (threadIdx.y < offset) {
+                const int read_idx = threadIdx.y * blockDim.x + threadIdx.x;
+                sum_gamma += buf[read_idx];
+                sum_beta += buf[read_idx + nbsize3];
+            }
+            __syncthreads();
+        }
+        // write out fully summed gradients
+        if (threadIdx.y == 0) {
+            grad_gamma[i2] = sum_gamma;
+            grad_beta[i2] = sum_beta;
+        }
+    }
+}
+
+template <typename T, typename U, typename V>
+__global__ void LayerNormInputGrad(const V* __restrict__ dout, const T* __restrict__ input,
+                                   const int rows, const int cols, const U* __restrict__ mean,
+                                   const U* __restrict__ invvar, U epsilon, const V* gamma,
+                                   T* grad_input) {
+    int WarpPerBlock = blockDim.x / WarpSize;
+    int thread_idx = threadIdx.x;
+    int warp_idx = thread_idx / WarpSize;
+    int lane_idx = thread_idx % WarpSize;
+
+    float* shared_dout = shared_data + warp_idx*cols;
+    float* shared_input = shared_data + WarpPerBlock*cols + warp_idx*cols;
+    float* shared_gamma = shared_data + 2*WarpPerBlock*cols;
+    int row_stride = gridDim.x*WarpPerBlock;
+    for(int row = blockIdx.x*WarpPerBlock+warp_idx; row < rows; row += row_stride) {
+        U mean_r = mean[row];
+        U invvar_r = invvar[row];
+        // load dout, input and gamma
+        long long data_offset = (long long)(row) * cols;
+        const V* dout_r = dout + data_offset;
+        const T* input_r = input + data_offset;
+        T* grad_input_r = grad_input + data_offset;
+#pragma unroll
+        for(int col = lane_idx; col < cols; col += WarpSize) {
+            shared_dout[col] = float(dout_r[col]);
+            shared_input[col] = float(input_r[col]);
+        }
+        if(warp_idx == 0) {
+#pragma unroll
+            for(int col = lane_idx; col < cols; col += WarpSize) {
+                shared_gamma[col] = float(gamma[col]);
+            }
+        }
+        __syncthreads();
+
+        float gamma_dout = 0.0;
+        float gamma_dout_input_mean = 0.0;
+        // reduction, gamma*dout and gamma*dout*(input-mean)
+#pragma unroll
+        for(int col = lane_idx; col < cols; col += WarpSize) {
+            float temp = shared_gamma[col] * shared_dout[col];
+            gamma_dout += temp;
+            gamma_dout_input_mean += temp * (shared_input[col] - mean_r);
+        }
+        float global_gamma_dout = WarpReduce<float>(gamma_dout);
+        float global_gamma_dout_input_mean = WarpReduce<float>(gamma_dout_input_mean);
+
+        float part3_temp_value = global_gamma_dout_input_mean * invvar_r * invvar_r * invvar_r / cols;
+        float part2 = global_gamma_dout * invvar_r / cols;
+#pragma unroll
+        for(int col = lane_idx; col < cols; col += WarpSize) {
+            float part1 = shared_gamma[col] * shared_dout[col] * invvar_r;
+            float part3 = (shared_input[col] - mean_r) * part3_temp_value;
+            grad_input_r[col] = part1 - part2 - part3;
+        }
+    }
+}
+
+template <typename T, typename U, typename V>
+int GetGirdDimY(const int64_t num_instances, const int64_t norm_size) {
+    const int grid_dim_x = (norm_size + tile_size - 1) / tile_size;
+    const int max_grid_dim_y = (num_instances + tile_size - 1) / tile_size;
+    const int block_size = block_dim_x * block_dim_y;
+    int max_active_blocks = 0;
+    cudaOccupancyMaxActiveBlocksPerMultiprocessor(
+        &max_active_blocks, LayerNormParamGradStep1<T, U, V>, block_size, 0);
+    int waves = 1;
+    int dev;
+    cudaGetDevice(&dev);
+    int sm_count;
+    cudaDeviceGetAttribute(&sm_count, cudaDevAttrMultiProcessorCount, dev);
+    int num_blocks = max_active_blocks * sm_count * waves;
+    int grid_dim_y = std::min(max_grid_dim_y, static_cast<int>(num_blocks / grid_dim_x));
+    return std::max(grid_dim_y, 1);
+}
+
+template <typename T, typename U, typename V>
+void HostLayerNormGradient(const V* dout, const U* mean, const U* invvar, at::Tensor* input, int n1,
+                           int n2, const V* gamma, const V* beta, double epsilon, T* grad_input,
+                           V* grad_gamma, V* grad_beta) {
+    auto stream = at::cuda::getCurrentCUDAStream().stream();
+
+    if (gamma != NULL && beta != NULL) {
+        // compute grad_gamma(j) and grad_beta(j)
+        const int part_size = GetGirdDimY<T, U, V>(n1, n2);
+        const int grid_dim_x = (n2 + tile_size - 1) / tile_size;
+        const int grid_dim_y = part_size;
+
+        at::Tensor part_grad_gamma = at::empty({part_size, n2}, input->options().dtype(at::ScalarType::Float));
+        at::Tensor part_grad_beta = at::empty_like(part_grad_gamma);
+        LayerNormParamGradStep1<T, U, V><<<dim3(grid_dim_x, grid_dim_y), dim3(32, 32 / num_per_block)>>>(
+            n1, n2, dout, input->DATA_PTR<T>(), mean, invvar, part_grad_gamma.DATA_PTR<U>(), part_grad_beta.DATA_PTR<U>()
+        );
+
+        const dim3 threads3(32, 8, 1);
+        const dim3 blocks3((n2 + 32 - 1) / 32, 1, 1);
+        const int nshared3 = threads3.x * threads3.y * sizeof(U);
+        LayerNormParamGradStep2<<<blocks3, threads3, nshared3, stream>>>(
+            part_grad_gamma.DATA_PTR<U>(), part_grad_beta.DATA_PTR<U>(), part_size, n1, n2,
+            grad_gamma, grad_beta);
+    }
+
+    const uint64_t maxGridY = at::cuda::getCurrentDeviceProperties()->maxGridSize[1];
+    #define BlockDim 128
+    int WarpNumPerBlock = BlockDim / WarpSize;
+    const dim3 threads1(BlockDim);
+    int nshared = sizeof(float)*n2*(WarpNumPerBlock*2 + 1);
+
+    int max_active_blocks = 0;
+    cudaOccupancyMaxActiveBlocksPerMultiprocessor(
+        &max_active_blocks, LayerNormInputGrad<T, U, V>, BlockDim, nshared);
+    int dev;
+    cudaGetDevice(&dev);
+    int sm_count;
+    cudaDeviceGetAttribute(&sm_count, cudaDevAttrMultiProcessorCount, dev);
+
+    const dim3 blocks1(std::min((uint64_t)((n1 + WarpNumPerBlock - 1)/WarpNumPerBlock), (uint64_t)(max_active_blocks * sm_count)));
+    LayerNormInputGrad<<<blocks1, threads1, nshared>>>(dout, input->DATA_PTR<T>(), n1, n2, mean, invvar, U(epsilon), gamma, grad_input);
+}
+
+void cuda_layer_norm_gradient(at::Tensor* dout, at::Tensor* mean, at::Tensor* invvar,
+                              at::Tensor* input, int n1, int n2, at::IntArrayRef normalized_shape,
+                              at::Tensor* gamma, at::Tensor* beta, double epsilon,
+                              at::Tensor* grad_input, at::Tensor* grad_gamma,
+                              at::Tensor* grad_beta) {
+    using namespace at;
+    DISPATCH_FLOAT_HALF_AND_BFLOAT_INOUT_TYPES(
+        input->scalar_type(), gamma->scalar_type(), "cuda_layer_norm_gradient_kernel",
+        HostLayerNormGradient(dout->DATA_PTR<scalar_t_out>(), mean->DATA_PTR<float>(),
+                              invvar->DATA_PTR<float>(), input, n1, n2,
+                              // TMJ pass NULL argument for gamma, beta, grad_gamma and grad_beta
+                              // if gamma Tensor is NULL on input.
+                              gamma != NULL ? gamma->DATA_PTR<scalar_t_out>() : NULL,
+                              gamma != NULL ? beta->DATA_PTR<scalar_t_out>() : NULL, epsilon,
+                              grad_input->DATA_PTR<scalar_t_in>(),
+                              gamma != NULL ? grad_gamma->DATA_PTR<scalar_t_out>() : NULL,
+                              gamma != NULL ? grad_beta->DATA_PTR<scalar_t_out>() : NULL);)
+}

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/model/layer_norm/kernel/type_shim.h

@@ -0,0 +1,246 @@
+// modified from https://github.com/NVIDIA/apex
+// Copyright 2021- HPC-AI Technology Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <ATen/ATen.h>
+
+#include "compat.h"
+
+#define DISPATCH_HALF_AND_BFLOAT(TYPE, NAME, ...)                           \
+    switch (TYPE) {                                                         \
+        case at::ScalarType::Half: {                                        \
+            using scalar_t = at::Half;                                      \
+            __VA_ARGS__;                                                    \
+            break;                                                          \
+        }                                                                   \
+        case at::ScalarType::BFloat16: {                                    \
+            using scalar_t = at::BFloat16;                                  \
+            __VA_ARGS__;                                                    \
+            break;                                                          \
+        }                                                                   \
+        default:                                                            \
+            AT_ERROR(#NAME, " not implemented for '", toString(TYPE), "'"); \
+    }
+
+#define DISPATCH_FLOAT_HALF_AND_BFLOAT_INOUT_TYPES(TYPEIN, TYPEOUT, NAME, ...)         \
+    switch (TYPEIN) {                                                                  \
+        case at::ScalarType::Float: {                                                  \
+            using scalar_t_in = float;                                                 \
+            switch (TYPEOUT) {                                                         \
+                case at::ScalarType::Float: {                                          \
+                    using scalar_t_out = float;                                        \
+                    __VA_ARGS__;                                                       \
+                    break;                                                             \
+                }                                                                      \
+                case at::ScalarType::Half: {                                           \
+                    using scalar_t_out = at::Half;                                     \
+                    __VA_ARGS__;                                                       \
+                    break;                                                             \
+                }                                                                      \
+                case at::ScalarType::BFloat16: {                                       \
+                    using scalar_t_out = at::BFloat16;                                 \
+                    __VA_ARGS__;                                                       \
+                    break;                                                             \
+                }                                                                      \
+                default:                                                               \
+                    AT_ERROR(#NAME, " not implemented for '", toString(TYPEOUT), "'"); \
+            }                                                                          \
+            break;                                                                     \
+        }                                                                              \
+        case at::ScalarType::Half: {                                                   \
+            using scalar_t_in = at::Half;                                              \
+            using scalar_t_out = at::Half;                                             \
+            __VA_ARGS__;                                                               \
+            break;                                                                     \
+        }                                                                              \
+        case at::ScalarType::BFloat16: {                                               \
+            using scalar_t_in = at::BFloat16;                                          \
+            using scalar_t_out = at::BFloat16;                                         \
+            __VA_ARGS__;                                                               \
+            break;                                                                     \
+        }                                                                              \
+        default:                                                                       \
+            AT_ERROR(#NAME, " not implemented for '", toString(TYPEIN), "'");          \
+    }
+
+// Forward/backward compatiblity hack around
+// https://github.com/pytorch/pytorch/commit/3aeb78079bcd68282fe9117088e138b77318e288
+// pending more future-proof guidance from upstream.
+// struct TypeShim
+// {
+//   const at::Type& payload;
+//   TypeShim(const at::Type& type) : payload(type) {}
+//   // Enable trivial conversion to a const at::Type& for pre-3aeb78
+//   operator const at::Type&(){ return payload; };
+//   // Enable dispatch switch statements to take *this directly for  post-3aeb78
+//   //operator at::ScalarType(){ return payload.; };
+// };
+
+#define DISPATCH_FLOAT_AND_HALF(TYPE, LEVEL, NAME, ...)                     \
+    switch (TYPE) {                                                         \
+        case at::ScalarType::Float: {                                       \
+            using scalar_t_##LEVEL = float;                                 \
+            __VA_ARGS__;                                                    \
+            break;                                                          \
+        }                                                                   \
+        case at::ScalarType::Half: {                                        \
+            using scalar_t_##LEVEL = at::Half;                              \
+            __VA_ARGS__;                                                    \
+            break;                                                          \
+        }                                                                   \
+        default:                                                            \
+            AT_ERROR(#NAME, " not implemented for '", toString(TYPE), "'"); \
+    }
+
+#define DISPATCH_FLOAT_HALF_AND_BYTE(TYPE, LEVEL, NAME, ...)                \
+    switch (TYPE) {                                                         \
+        case at::ScalarType::Float: {                                       \
+            using scalar_t_##LEVEL = float;                                 \
+            __VA_ARGS__;                                                    \
+            break;                                                          \
+        }                                                                   \
+        case at::ScalarType::Half: {                                        \
+            using scalar_t_##LEVEL = at::Half;                              \
+            __VA_ARGS__;                                                    \
+            break;                                                          \
+        }                                                                   \
+        case at::ScalarType::Byte: {                                        \
+            using scalar_t_##LEVEL = uint8_t;                               \
+            __VA_ARGS__;                                                    \
+            break;                                                          \
+        }                                                                   \
+        default:                                                            \
+            AT_ERROR(#NAME, " not implemented for '", toString(TYPE), "'"); \
+    }
+
+#define DISPATCH_DOUBLE_FLOAT_AND_HALF(TYPE, LEVEL, NAME, ...)              \
+    switch (TYPE) {                                                         \
+        case at::ScalarType::Double: {                                      \
+            using scalar_t_##LEVEL = double;                                \
+            __VA_ARGS__;                                                    \
+            break;                                                          \
+        }                                                                   \
+        case at::ScalarType::Float: {                                       \
+            using scalar_t_##LEVEL = float;                                 \
+            __VA_ARGS__;                                                    \
+            break;                                                          \
+        }                                                                   \
+        case at::ScalarType::Half: {                                        \
+            using scalar_t_##LEVEL = at::Half;                              \
+            __VA_ARGS__;                                                    \
+            break;                                                          \
+        }                                                                   \
+        default:                                                            \
+            AT_ERROR(#NAME, " not implemented for '", toString(TYPE), "'"); \
+    }
+
+#define DISPATCH_DOUBLE_AND_FLOAT(TYPE, LEVEL, NAME, ...)                   \
+    switch (TYPE) {                                                         \
+        case at::ScalarType::Double: {                                      \
+            using scalar_t_##LEVEL = double;                                \
+            __VA_ARGS__;                                                    \
+            break;                                                          \
+        }                                                                   \
+        case at::ScalarType::Float: {                                       \
+            using scalar_t_##LEVEL = float;                                 \
+            __VA_ARGS__;                                                    \
+            break;                                                          \
+        }                                                                   \
+        default:                                                            \
+            AT_ERROR(#NAME, " not implemented for '", toString(TYPE), "'"); \
+    }
+
+template <typename T>
+__device__ __forceinline__ T
+reduce_block_into_lanes(T *x, T val, int lanes = 1,
+                        bool share_result = false)  // lanes is intended to be <= 32.
+{
+    int tid = threadIdx.x + threadIdx.y * blockDim.x;
+    int blockSize = blockDim.x * blockDim.y;  // blockSize is intended to be a multiple of 32.
+
+    if (blockSize >= 64) {
+        x[tid] = val;
+        __syncthreads();
+    }
+
+#pragma unroll
+    for (int i = (blockSize >> 1); i >= 64; i >>= 1) {
+        if (tid < i) x[tid] = x[tid] + x[tid + i];
+        __syncthreads();
+    }
+
+    T final;
+
+    if (tid < 32) {
+        if (blockSize >= 64)
+            final = x[tid] + x[tid + 32];
+        else
+            final = val;
+            // __SYNCWARP();
+
+#pragma unroll
+        for (int i = 16; i >= lanes; i >>= 1)
+            final = final + __shfl_down_sync(0xffffffff, final, i);
+    }
+
+    if (share_result) {
+        if (tid < lanes) x[tid] = final;  // EpilogueOp
+        // Make sure the smem result is visible to all warps.
+        __syncthreads();
+    }
+
+    return final;
+}
+
+template <typename T>
+__device__ __forceinline__ T
+reduce_block_into_lanes_max_op(T *x, T val, int lanes = 1,
+                               bool share_result = false)  // lanes is intended to be <= 32.
+{
+    int tid = threadIdx.x + threadIdx.y * blockDim.x;
+    int blockSize = blockDim.x * blockDim.y;  // blockSize is intended to be a multiple of 32.
+
+    if (blockSize >= 64) {
+        x[tid] = val;
+        __syncthreads();
+    }
+
+#pragma unroll
+    for (int i = (blockSize >> 1); i >= 64; i >>= 1) {
+        if (tid < i) x[tid] = fmaxf(fabsf(x[tid]), fabsf(x[tid + i]));
+        __syncthreads();
+    }
+
+    T final;
+
+    if (tid < 32) {
+        if (blockSize >= 64)
+            final = fmaxf(fabsf(x[tid]), fabsf(x[tid + 32]));
+        else
+            final = val;
+            // __SYNCWARP();
+
+#pragma unroll
+        for (int i = 16; i >= lanes; i >>= 1)
+            final = fmaxf(fabsf(final), fabsf(__shfl_down_sync(0xffffffff, final, i)));
+    }
+
+    if (share_result) {
+        if (tid < lanes) x[tid] = final;  // EpilogueOp
+        // Make sure the smem result is visible to all warps.
+        __syncthreads();
+    }
+
+    return final;
+}

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/model/layer_norm/layer_norm.py

@@ -0,0 +1,134 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Copyright 2021- HPC-AI Technology Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http:#www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import importlib
+import numbers
+import os
+import sys
+import time
+
+import torch
+from torch.nn.parameter import Parameter
+
+sys.path.append(os.path.dirname(__file__))
+
+try:
+    fastfold_layer_norm_cuda = importlib.import_module("fastfold_layer_norm_cuda")
+except ImportError:
+    from protenix.model.layer_norm.torch_ext_compile import compile
+
+    current_dir = os.path.dirname(__file__)
+    fastfold_layer_norm_cuda = compile(
+        name="fastfold_layer_norm_cuda",
+        sources=[
+            os.path.join(f"{current_dir}/kernel", file)
+            for file in ["layer_norm_cuda.cpp", "layer_norm_cuda_kernel.cu"]
+        ],
+        extra_include_paths=[f"{current_dir}/kernel"],
+        build_directory=current_dir,
+    )
+
+
+class FusedLayerNormAffineFunction(torch.autograd.Function):
+
+    @staticmethod
+    def forward(ctx, input, weight, bias, normalized_shape, eps):
+        d = input.dtype
+        if d is torch.bfloat16:
+            with torch.cuda.amp.autocast(enabled=False):
+                ctx.normalized_shape = normalized_shape
+                ctx.eps = eps
+                input_ = input.contiguous()
+                weight_ = weight.contiguous().to(dtype=d)
+                bias_ = bias.contiguous().to(dtype=d)
+                output, mean, invvar = fastfold_layer_norm_cuda.forward_affine(
+                    input_, ctx.normalized_shape, weight_, bias_, ctx.eps
+                )
+                ctx.save_for_backward(input_, weight_, bias_, mean, invvar)
+        else:
+            ctx.normalized_shape = normalized_shape
+            ctx.eps = eps
+            input_ = input.contiguous()
+            weight_ = weight.contiguous()
+            bias_ = bias.contiguous()
+            output, mean, invvar = fastfold_layer_norm_cuda.forward_affine(
+                input_, ctx.normalized_shape, weight_, bias_, ctx.eps
+            )
+            ctx.save_for_backward(input_, weight_, bias_, mean, invvar)
+
+        return output
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        d = grad_output.dtype
+        if d is torch.bfloat16:
+            with torch.cuda.amp.autocast(enabled=False):
+                input_, weight_, bias_, mean, invvar = ctx.saved_tensors
+                grad_input = grad_weight = grad_bias = None
+                grad_input, grad_weight, grad_bias = (
+                    fastfold_layer_norm_cuda.backward_affine(
+                        grad_output.contiguous(),
+                        mean,
+                        invvar,
+                        input_,
+                        ctx.normalized_shape,
+                        weight_.to(dtype=d),
+                        bias_.to(dtype=d),
+                        ctx.eps,
+                    )
+                )
+        else:
+            input_, weight_, bias_, mean, invvar = ctx.saved_tensors
+            grad_input = grad_weight = grad_bias = None
+            grad_input, grad_weight, grad_bias = (
+                fastfold_layer_norm_cuda.backward_affine(
+                    grad_output.contiguous(),
+                    mean,
+                    invvar,
+                    input_,
+                    ctx.normalized_shape,
+                    weight_,
+                    bias_,
+                    ctx.eps,
+                )
+            )
+
+        return grad_input, grad_weight, grad_bias, None, None
+
+
+class FusedLayerNorm(torch.nn.Module):
+
+    def __init__(self, normalized_shape, eps=1e-5):
+        super(FusedLayerNorm, self).__init__()
+
+        if isinstance(normalized_shape, numbers.Integral):
+            normalized_shape = (normalized_shape,)
+        self.normalized_shape = torch.Size(normalized_shape)
+        self.eps = eps
+        self.weight = Parameter(torch.ones(*normalized_shape))
+        self.bias = Parameter(torch.ones(*normalized_shape))
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        torch.nn.init.ones_(self.weight)
+        torch.nn.init.zeros_(self.bias)
+
+    def forward(self, input):
+        return self.kernel_forward(input)
+
+    def kernel_forward(self, input):
+        return FusedLayerNormAffineFunction.apply(
+            input, self.weight, self.bias, self.normalized_shape, self.eps
+        )

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/model/layer_norm/torch_ext_compile.py

@@ -0,0 +1,55 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+
+from torch.utils.cpp_extension import load
+
+
+def compile(name, sources, extra_include_paths, build_directory):
+    os.environ["TORCH_CUDA_ARCH_LIST"] = "7.0;8.0"
+    return load(
+        name=name,
+        sources=sources,
+        extra_include_paths=extra_include_paths,
+        extra_cflags=[
+            "-O3",
+            "-DVERSION_GE_1_1",
+            "-DVERSION_GE_1_3",
+            "-DVERSION_GE_1_5",
+        ],
+        extra_cuda_cflags=[
+            "-O3",
+            "--use_fast_math",
+            "-DVERSION_GE_1_1",
+            "-DVERSION_GE_1_3",
+            "-DVERSION_GE_1_5",
+            "-std=c++17",
+            "-maxrregcount=50",
+            "-U__CUDA_NO_HALF_OPERATORS__",
+            "-U__CUDA_NO_HALF_CONVERSIONS__",
+            "--expt-relaxed-constexpr",
+            "--expt-extended-lambda",
+            "-gencode",
+            "arch=compute_70,code=sm_70",
+            "-gencode",
+            "arch=compute_80,code=sm_80",
+            "-gencode",
+            "arch=compute_86,code=sm_86",
+            "-gencode",
+            "arch=compute_90,code=sm_90",
+        ],
+        verbose=True,
+        build_directory=build_directory,
+    )

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/model/loss.py

@@ -0,0 +1,1812 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+from typing import Any, Optional, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from protenix.metrics.rmsd import weighted_rigid_align
+from protenix.model.modules.frames import (
+    expressCoordinatesInFrame,
+    gather_frame_atom_by_indices,
+)
+from protenix.model.utils import expand_at_dim
+from protenix.openfold_local.utils.checkpointing import get_checkpoint_fn
+from protenix.utils.torch_utils import cdist
+
+
+def loss_reduction(loss: torch.Tensor, method: str = "mean") -> torch.Tensor:
+    """reduction wrapper
+
+    Args:
+        loss (torch.Tensor): loss
+            [...]
+        method (str, optional): reduction method. Defaults to "mean".
+
+    Returns:
+        torch.Tensor: reduced loss
+            [] or [...]
+    """
+
+    if method is None:
+        return loss
+    assert method in ["mean", "sum", "add", "max", "min"]
+    if method == "add":
+        method = "sum"
+    return getattr(torch, method)(loss)
+
+
+class SmoothLDDTLoss(nn.Module):
+    """
+    Implements Algorithm 27 [SmoothLDDTLoss] in AF3
+    """
+
+    def __init__(
+        self,
+        eps: float = 1e-10,
+        reduction: str = "mean",
+    ) -> None:
+        """SmoothLDDTLoss
+
+        Args:
+            eps (float, optional): avoid nan. Defaults to 1e-10.
+            reduction (str, optional): reduction method for the batch dims. Defaults to mean.
+        """
+        super(SmoothLDDTLoss, self).__init__()
+        self.eps = eps
+        self.reduction = reduction
+
+    def _chunk_forward(self, pred_distance, true_distance, c_lm=None):
+        dist_diff = torch.abs(pred_distance - true_distance)
+        # For save cuda memory we use inplace op
+        dist_diff_epsilon = 0
+        for threshold in [0.5, 1, 2, 4]:
+            dist_diff_epsilon += 0.25 * torch.sigmoid(threshold - dist_diff)
+
+        # Compute mean
+        if c_lm is not None:
+            lddt = torch.sum(c_lm * dist_diff_epsilon, dim=(-1, -2)) / (
+                torch.sum(c_lm, dim=(-1, -2)) + self.eps
+            )  # [..., N_sample]
+        else:
+            # It's for sparse forward mode
+            lddt = torch.mean(dist_diff_epsilon, dim=-1)
+        return lddt
+
+    def forward(
+        self,
+        pred_distance: torch.Tensor,
+        true_distance: torch.Tensor,
+        distance_mask: torch.Tensor,
+        lddt_mask: torch.Tensor,
+        diffusion_chunk_size: Optional[int] = None,
+    ) -> torch.Tensor:
+        """SmoothLDDTLoss
+
+        Args:
+            pred_distance (torch.Tensor): the diffusion denoised atom-atom distance
+                [..., N_sample, N_atom, N_atom]
+            true_distance (torch.Tensor): the ground truth coordinates
+                [..., N_atom, N_atom]
+            distance_mask (torch.Tensor): whether true coordinates exist.
+                [N_atom, N_atom]
+            lddt_mask (torch.Tensor, optional): whether true distance is within radius (30A for nuc and 15A for others)
+                [N_atom, N_atom]
+            diffusion_chunk_size (Optional[int]): Chunk size over the N_sample dimension. Defaults to None.
+
+        Returns:
+            torch.Tensor: the smooth lddt loss
+                [...] if reduction is None else []
+        """
+        c_lm = lddt_mask.bool().unsqueeze(dim=-3).detach()  # [..., 1, N_atom, N_atom]
+        # Compute distance error
+        # [...,  N_sample , N_atom, N_atom]
+        if diffusion_chunk_size is None:
+            lddt = self._chunk_forward(
+                pred_distance=pred_distance, true_distance=true_distance, c_lm=c_lm
+            )
+        else:
+            # Default use checkpoint for saving memory
+            checkpoint_fn = get_checkpoint_fn()
+            lddt = []
+            N_sample = pred_distance.shape[-3]
+            no_chunks = N_sample // diffusion_chunk_size + (
+                N_sample % diffusion_chunk_size != 0
+            )
+            for i in range(no_chunks):
+                lddt_i = checkpoint_fn(
+                    self._chunk_forward,
+                    pred_distance[
+                        ...,
+                        i * diffusion_chunk_size : (i + 1) * diffusion_chunk_size,
+                        :,
+                        :,
+                    ],
+                    true_distance,
+                    c_lm,
+                )
+                lddt.append(lddt_i)
+            lddt = torch.cat(lddt, dim=-1)
+
+        lddt = lddt.mean(dim=-1)  # [...]
+        return 1 - loss_reduction(lddt, method=self.reduction)
+
+    def sparse_forward(
+        self,
+        pred_coordinate: torch.Tensor,
+        true_coordinate: torch.Tensor,
+        lddt_mask: torch.Tensor,
+        diffusion_chunk_size: Optional[int] = None,
+    ) -> torch.Tensor:
+        """SmoothLDDTLoss sparse implementation
+
+        Args:
+            pred_coordinate (torch.Tensor): the diffusion denoised atom coordinates
+                [..., N_sample, N_atom, 3]
+            true_coordinate (torch.Tensor): the ground truth atom coordinates
+                [..., N_atom, 3]
+            lddt_mask (torch.Tensor, optional): whether true distance is within radius (30A for nuc and 15A for others)
+                [N_atom, N_atom]
+            diffusion_chunk_size (Optional[int]): Chunk size over the N_sample dimension. Defaults to None.
+
+        Returns:
+            torch.Tensor: the smooth lddt loss
+                [...] if reduction is None else []
+        """
+        lddt_indices = torch.nonzero(lddt_mask, as_tuple=True)
+        true_coords_l = true_coordinate.index_select(-2, lddt_indices[0])
+        true_coords_m = true_coordinate.index_select(-2, lddt_indices[1])
+        true_distance_sparse_lm = torch.norm(true_coords_l - true_coords_m, p=2, dim=-1)
+        if diffusion_chunk_size is None:
+            pred_coords_l = pred_coordinate.index_select(-2, lddt_indices[0])
+            pred_coords_m = pred_coordinate.index_select(-2, lddt_indices[1])
+            # \delta x_{lm} and \delta x_{lm}^{GT} in the Algorithm 27
+            pred_distance_sparse_lm = torch.norm(
+                pred_coords_l - pred_coords_m, p=2, dim=-1
+            )
+            lddt = self._chunk_forward(
+                pred_distance_sparse_lm, true_distance_sparse_lm, c_lm=None
+            )
+        else:
+            checkpoint_fn = get_checkpoint_fn()
+            lddt = []
+            N_sample = pred_coordinate.shape[-3]
+            no_chunks = N_sample // diffusion_chunk_size + (
+                N_sample % diffusion_chunk_size != 0
+            )
+            for i in range(no_chunks):
+                pred_coords_i_l = pred_coordinate[
+                    i * diffusion_chunk_size : (i + 1) * diffusion_chunk_size, :, :
+                ].index_select(-2, lddt_indices[0])
+                pred_coords_i_m = pred_coordinate[
+                    i * diffusion_chunk_size : (i + 1) * diffusion_chunk_size, :, :
+                ].index_select(-2, lddt_indices[1])
+
+                # \delta x_{lm} and \delta x_{lm}^{GT} in the Algorithm 27
+                pred_distance_sparse_i_lm = torch.norm(
+                    pred_coords_i_l - pred_coords_i_m, p=2, dim=-1
+                )
+                lddt_i = checkpoint_fn(
+                    self._chunk_forward,
+                    pred_distance_sparse_i_lm,
+                    true_distance_sparse_lm,
+                )
+                lddt.append(lddt_i)
+            lddt = torch.cat(lddt, dim=-1)
+
+        lddt = lddt.mean(dim=-1)  # [...]
+        return 1 - loss_reduction(lddt, method=self.reduction)
+
+    def dense_forward(
+        self,
+        pred_coordinate: torch.Tensor,
+        true_coordinate: torch.Tensor,
+        lddt_mask: torch.Tensor,
+        diffusion_chunk_size: Optional[int] = None,
+    ) -> torch.Tensor:
+        """SmoothLDDTLoss sparse implementation
+
+        Args:
+            pred_coordinate (torch.Tensor): the diffusion denoised atom coordinates
+                [..., N_sample, N_atom, 3]
+            true_coordinate (torch.Tensor): the ground truth atom coordinates
+                [..., N_atom, 3]
+            lddt_mask (torch.Tensor, optional): whether true distance is within radius (30A for nuc and 15A for others)
+                [N_atom, N_atom]
+            diffusion_chunk_size (Optional[int]): Chunk size over the N_sample dimension. Defaults to None.
+
+        Returns:
+            torch.Tensor: the smooth lddt loss
+                [...] if reduction is None else []
+        """
+        c_lm = lddt_mask.bool().unsqueeze(dim=-3).detach()  # [..., 1, N_atom, N_atom]
+        # Compute distance error
+        # [...,  N_sample , N_atom, N_atom]
+        true_distance = torch.cdist(true_coordinate, true_coordinate)
+        if diffusion_chunk_size is None:
+            pred_distance = torch.cdist(pred_coordinate, pred_coordinate)
+            lddt = self._chunk_forward(
+                pred_distance=pred_distance, true_distance=true_distance, c_lm=c_lm
+            )
+        else:
+            checkpoint_fn = get_checkpoint_fn()
+            lddt = []
+            N_sample = pred_coordinate.shape[-3]
+            no_chunks = N_sample // diffusion_chunk_size + (
+                N_sample % diffusion_chunk_size != 0
+            )
+            for i in range(no_chunks):
+                pred_distance_i = torch.cdist(
+                    pred_coordinate[
+                        i * diffusion_chunk_size : (i + 1) * diffusion_chunk_size,
+                        :,
+                        :,
+                    ],
+                    pred_coordinate[
+                        i * diffusion_chunk_size : (i + 1) * diffusion_chunk_size,
+                        :,
+                        :,
+                    ],
+                )
+                lddt_i = checkpoint_fn(
+                    self._chunk_forward,
+                    pred_distance_i,
+                    true_distance,
+                    c_lm,
+                )
+                lddt.append(lddt_i)
+            lddt = torch.cat(lddt, dim=-1)
+
+        lddt = lddt.mean(dim=-1)  # [...]
+        return 1 - loss_reduction(lddt, method=self.reduction)
+
+
+class BondLoss(nn.Module):
+    """
+    Implements Formula 5 [BondLoss] in AF3
+    """
+
+    def __init__(self, eps: float = 1e-6, reduction: str = "mean") -> None:
+        """BondLoss
+
+        Args:
+            eps (float, optional): avoid nan. Defaults to 1e-6.
+            reduction (str, optional): reduction method for the batch dims. Defaults to mean.
+        """
+        super(BondLoss, self).__init__()
+        self.eps = eps
+        self.reduction = reduction
+
+    def _chunk_forward(self, pred_distance, true_distance, bond_mask):
+        # Distance squared error
+        # [...,  N_sample , N_atom, N_atom]
+        dist_squared_err = (pred_distance - true_distance.unsqueeze(dim=-3)) ** 2
+        bond_loss = torch.sum(dist_squared_err * bond_mask, dim=(-1, -2)) / torch.sum(
+            bond_mask + self.eps, dim=(-1, -2)
+        )  # [..., N_sample]
+        return bond_loss
+
+    def forward(
+        self,
+        pred_distance: torch.Tensor,
+        true_distance: torch.Tensor,
+        distance_mask: torch.Tensor,
+        bond_mask: torch.Tensor,
+        per_sample_scale: torch.Tensor = None,
+        diffusion_chunk_size: Optional[int] = None,
+    ) -> torch.Tensor:
+        """BondLoss
+
+        Args:
+            pred_distance (torch.Tensor): the diffusion denoised atom-atom distance
+                [..., N_sample, N_atom, N_atom]
+            true_distance (torch.Tensor): the ground truth coordinates
+                [..., N_atom, N_atom]
+            distance_mask (torch.Tensor): whether true coordinates exist.
+                [N_atom, N_atom] or [..., N_atom, N_atom]
+            bond_mask (torch.Tensor): bonds considered in this loss
+                [N_atom, N_atom] or [..., N_atom, N_atom]
+            per_sample_scale (torch.Tensor, optional): whether to scale the loss by the per-sample noise-level.
+                [..., N_sample]
+            diffusion_chunk_size (Optional[int]): Chunk size over the N_sample dimension. Defaults to None.
+
+        Returns:
+            torch.Tensor: the bond loss
+                [...] if reduction is None else []
+        """
+
+        bond_mask = (bond_mask * distance_mask).unsqueeze(
+            dim=-3
+        )  # [1, N_atom, N_atom] or [..., 1, N_atom, N_atom]
+        # Bond Loss
+        if diffusion_chunk_size is None:
+            bond_loss = self._chunk_forward(
+                pred_distance=pred_distance,
+                true_distance=true_distance,
+                bond_mask=bond_mask,
+            )
+        else:
+            checkpoint_fn = get_checkpoint_fn()
+            bond_loss = []
+            N_sample = pred_distance.shape[-3]
+            no_chunks = N_sample // diffusion_chunk_size + (
+                N_sample % diffusion_chunk_size != 0
+            )
+            for i in range(no_chunks):
+                bond_loss_i = checkpoint_fn(
+                    self._chunk_forward,
+                    pred_distance[
+                        ...,
+                        i * diffusion_chunk_size : (i + 1) * diffusion_chunk_size,
+                        :,
+                        :,
+                    ],
+                    true_distance,
+                    bond_mask,
+                )
+                bond_loss.append(bond_loss_i)
+            bond_loss = torch.cat(bond_loss, dim=-1)
+        if per_sample_scale is not None:
+            bond_loss = bond_loss * per_sample_scale
+
+        bond_loss = bond_loss.mean(dim=-1)  # [...]
+        return loss_reduction(bond_loss, method=self.reduction)
+
+    def sparse_forward(
+        self,
+        pred_coordinate: torch.Tensor,
+        true_coordinate: torch.Tensor,
+        distance_mask: torch.Tensor,
+        bond_mask: torch.Tensor,
+        per_sample_scale: torch.Tensor = None,
+    ) -> torch.Tensor:
+        """BondLoss sparse implementation
+
+        Args:
+            pred_coordinate (torch.Tensor): the diffusion denoised atom coordinates
+                [..., N_sample, N_atom, 3]
+            true_coordinate (torch.Tensor): the ground truth atom coordinates
+                [..., N_atom, 3]
+            distance_mask (torch.Tensor): whether true coordinates exist.
+                [N_atom, N_atom] or [..., N_atom, N_atom]
+            bond_mask (torch.Tensor): bonds considered in this loss
+                [N_atom, N_atom] or [..., N_atom, N_atom]
+            per_sample_scale (torch.Tensor, optional): whether to scale the loss by the per-sample noise-level.
+                [..., N_sample]
+        Returns:
+            torch.Tensor: the bond loss
+                [...] if reduction is None else []
+        """
+
+        bond_mask = bond_mask * distance_mask
+        bond_indices = torch.nonzero(bond_mask, as_tuple=True)
+        pred_coords_i = pred_coordinate.index_select(-2, bond_indices[0])
+        pred_coords_j = pred_coordinate.index_select(-2, bond_indices[1])
+        true_coords_i = true_coordinate.index_select(-2, bond_indices[0])
+        true_coords_j = true_coordinate.index_select(-2, bond_indices[1])
+
+        pred_distance_sparse = torch.norm(pred_coords_i - pred_coords_j, p=2, dim=-1)
+        true_distance_sparse = torch.norm(true_coords_i - true_coords_j, p=2, dim=-1)
+        dist_squared_err_sparse = (pred_distance_sparse - true_distance_sparse) ** 2
+        # Protecting special data that has size: tensor([], size=(x, 0), grad_fn=<PowBackward0>)
+        if dist_squared_err_sparse.numel() == 0:
+            return torch.tensor(
+                0.0, device=dist_squared_err_sparse.device, requires_grad=True
+            )
+        bond_loss = torch.mean(dist_squared_err_sparse, dim=-1)  # [..., N_sample]
+        if per_sample_scale is not None:
+            bond_loss = bond_loss * per_sample_scale
+
+        bond_loss = bond_loss.mean(dim=-1)  # [...]
+        return bond_loss
+
+
+def compute_lddt_mask(
+    true_distance: torch.Tensor,
+    distance_mask: torch.Tensor,
+    is_nucleotide: torch.Tensor,
+    is_nucleotide_threshold: float = 30.0,
+    is_not_nucleotide_threshold: float = 15.0,
+) -> torch.Tensor:
+    """calculate the atom pair mask with the bespoke radius
+
+    Args:
+        true_distance (torch.Tensor): the ground truth coordinates
+            [..., N_atom, N_atom]
+        distance_mask (torch.Tensor): whether true coordinates exist.
+            [..., N_atom, N_atom] or [N_atom, N_atom]
+        is_nucleotide (torch.Tensor): Indicator for nucleotide atoms.
+            [..., N_atom] or [N_atom]
+        is_nucleotide_threshold (float): Threshold distance for nucleotide atoms. Defaults to 30.0.
+        is_not_nucleotide_threshold (float): Threshold distance for non-nucleotide atoms. Defaults to 15.0.
+
+    Returns:
+        c_lm (torch.Tenson): the atom pair mask c_lm, not symmetric
+            [..., N_atom, N_atom]
+    """
+    # Restrict to bespoke inclusion radius
+    is_nucleotide_mask = is_nucleotide.bool()
+    c_lm = (true_distance < is_nucleotide_threshold) * is_nucleotide_mask[..., None] + (
+        true_distance < is_not_nucleotide_threshold
+    ) * (
+        ~is_nucleotide_mask[..., None]
+    )  # [..., N_atom, N_atom]
+
+    # Zero-out diagonals of c_lm and cast to float
+    c_lm = c_lm * (
+        1 - torch.eye(n=c_lm.size(-1), device=c_lm.device, dtype=true_distance.dtype)
+    )
+    # Zero-out atom pairs without true coordinates
+    # Note: the sparsity of c_lm is ~10% in 5000 atom-pairs,
+    # and becomes more sparse as the number of atoms increases,
+    # change to sparse implementation can reduce cuda memory
+    c_lm = c_lm * distance_mask  # [..., N_atom, N_atom]
+    return c_lm
+
+
+def softmax_cross_entropy(logits: torch.Tensor, labels: torch.Tensor) -> torch.Tensor:
+    """Softmax cross entropy
+
+    Args:
+        logits (torch.Tensor): classification logits
+            [..., num_class]
+        labels (torch.Tensor): classification labels (value = probability)
+            [..., num_class]
+
+    Returns:
+        torch.Tensor: softmax cross entropy
+            [...]
+    """
+    loss = -1 * torch.sum(
+        labels * F.log_softmax(logits, dim=-1),
+        dim=-1,
+    )
+    return loss
+
+
+class DistogramLoss(nn.Module):
+    """
+    Implements DistogramLoss in AF3
+    """
+
+    def __init__(
+        self,
+        min_bin: float = 2.3125,
+        max_bin: float = 21.6875,
+        no_bins: int = 64,
+        eps: float = 1e-6,
+        reduction: str = "mean",
+    ) -> None:
+        """Distogram loss
+        This head and loss are identical to AlphaFold 2, where the pairwise token distances use the representative atom for each token:
+            Cβ for protein residues (Cα for glycine),
+            C4 for purines and C2 for pyrimidines.
+            All ligands already have a single atom per token.
+
+        Args:
+            min_bin (float, optional): min boundary of bins. Defaults to 2.3125.
+            max_bin (float, optional): max boundary of bins. Defaults to 21.6875.
+            no_bins (int, optional): number of bins. Defaults to 64.
+            eps (float, optional): small number added to denominator. Defaults to 1e-6.
+            reduce (bool, optional): reduce dim. Defaults to True.
+        """
+        super(DistogramLoss, self).__init__()
+        self.min_bin = min_bin
+        self.max_bin = max_bin
+        self.no_bins = no_bins
+        self.eps = eps
+        self.reduction = reduction
+
+    def calculate_label(
+        self,
+        true_coordinate: torch.Tensor,
+        coordinate_mask: torch.Tensor,
+        rep_atom_mask: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """calculate the label as bins
+
+        Args:
+            true_coordinate (torch.Tensor): true coordinates.
+                [..., N_atom, 3]
+            coordinate_mask (torch.Tensor): whether true coordinates exist.
+                [N_atom] or [..., N_atom]
+            rep_atom_mask (torch.Tensor): representative atom mask
+                [N_atom]
+
+        Returns:
+            true_bins (torch.Tensor): distance error assigned into bins (one-hot).
+                [..., N_token, N_token, no_bins]
+            pair_coordinate_mask (torch.Tensor): whether the coordinates of representative atom pairs exist.
+                [N_token, N_token] or [..., N_token, N_token]
+        """
+
+        boundaries = torch.linspace(
+            start=self.min_bin,
+            end=self.max_bin,
+            steps=self.no_bins - 1,
+            device=true_coordinate.device,
+        )
+
+        # Compute label: the true bins
+        # True distance
+        rep_atom_mask = rep_atom_mask.bool()
+        true_coordinate = true_coordinate[..., rep_atom_mask, :]  # [..., N_token, 3]
+        gt_dist = cdist(true_coordinate, true_coordinate)  # [..., N_token, N_token]
+        # Assign distance to bins
+        true_bins = torch.sum(
+            gt_dist.unsqueeze(dim=-1) > boundaries, dim=-1
+        )  # range in [0, no_bins-1], shape = [..., N_token, N_token]
+
+        # Mask
+        token_mask = coordinate_mask[..., rep_atom_mask]
+        pair_mask = token_mask[..., None] * token_mask[..., None, :]
+
+        return F.one_hot(true_bins, self.no_bins), pair_mask
+
+    def forward(
+        self,
+        logits: torch.Tensor,
+        true_coordinate: torch.Tensor,
+        coordinate_mask: torch.Tensor,
+        rep_atom_mask: torch.Tensor,
+    ) -> torch.Tensor:
+        """Distogram loss
+
+        Args:
+            logits (torch.Tensor): logits.
+                [..., N_token, N_token, no_bins]
+            true_coordinate (torch.Tensor): true coordinates.
+                [..., N_atom, 3]
+            coordinate_mask (torch.Tensor): whether true coordinates exist.
+                [N_atom] or [..., N_atom]
+            rep_atom_mask (torch.Tensor): representative atom mask.
+                [N_atom]
+
+        Returns:
+            torch.Tensor: the return loss.
+                [...] if self.reduction is not None else []
+        """
+
+        with torch.no_grad():
+            true_bins, pair_mask = self.calculate_label(
+                true_coordinate=true_coordinate,
+                coordinate_mask=coordinate_mask,
+                rep_atom_mask=rep_atom_mask,
+            )
+
+        errors = softmax_cross_entropy(
+            logits=logits,
+            labels=true_bins,
+        )  # [..., N_token, N_token]
+
+        denom = self.eps + torch.sum(pair_mask, dim=(-1, -2))
+        loss = torch.sum(errors * pair_mask, dim=(-1, -2))
+        loss = loss / denom
+
+        return loss_reduction(loss, method=self.reduction)
+
+
+class PDELoss(nn.Module):
+    """
+    Implements Predicted distance loss in AF3
+    """
+
+    def __init__(
+        self,
+        min_bin: float = 0,
+        max_bin: float = 32,
+        no_bins: int = 64,
+        eps: float = 1e-6,
+        reduction: str = "mean",
+    ) -> None:
+        """PDELoss
+        This loss are between representative token atoms i and j in the mini-rollout prediction
+
+        Args:
+            min_bin (float, optional): min boundary of bins. Defaults to 0.
+            max_bin (float, optional): max boundary of bins. Defaults to 32.
+            no_bins (int, optional): number of bins. Defaults to 64.
+            eps (float, optional): small number added to denominator. Defaults to 1e-6.
+            reduction (str, optional): reduction method for the batch dims. Defaults to mean.
+        """
+        super(PDELoss, self).__init__()
+        self.min_bin = min_bin
+        self.max_bin = max_bin
+        self.no_bins = no_bins
+        self.eps = eps
+        self.reduction = reduction
+
+    def calculate_label(
+        self,
+        pred_coordinate: torch.Tensor,
+        true_coordinate: torch.Tensor,
+        coordinate_mask: torch.Tensor,
+        rep_atom_mask: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """calculate the label as bins
+
+        Args:
+            pred_coordinate (torch.Tensor): predicted coordinates.
+                [..., N_sample, N_atom, 3]
+            true_coordinate (torch.Tensor): true coordinates.
+                [..., N_atom, 3]
+            coordinate_mask (torch.Tensor): whether true coordinates exist.
+                [N_atom] or [..., N_atom]
+            rep_atom_mask (torch.Tensor):
+                [N_atom]
+
+        Returns:
+            true_bins (torch.Tensor): distance error assigned into bins (one-hot).
+                [..., N_sample, N_token, N_token, no_bins]
+            pair_coordinate_mask (torch.Tensor): whether the coordinates of representative atom pairs exist.
+                [N_token, N_token] or [..., N_token, N_token]
+        """
+
+        boundaries = torch.linspace(
+            start=self.min_bin,
+            end=self.max_bin,
+            steps=self.no_bins + 1,
+            device=pred_coordinate.device,
+        )
+
+        # Compute label: the true bins
+        # True distance
+        rep_atom_mask = rep_atom_mask.bool()
+        true_coordinate = true_coordinate[..., rep_atom_mask, :]  # [..., N_token, 3]
+        gt_dist = cdist(true_coordinate, true_coordinate)  # [..., N_token, N_token]
+        # Predicted distance
+        pred_coordinate = pred_coordinate[..., rep_atom_mask, :]
+        pred_dist = cdist(
+            pred_coordinate, pred_coordinate
+        )  # [..., N_sample, N_token, N_token]
+        # Distance error
+        dist_error = torch.abs(pred_dist - gt_dist.unsqueeze(dim=-3))
+
+        # Assign distance error to bins
+        true_bins = torch.sum(
+            dist_error.unsqueeze(dim=-1) > boundaries, dim=-1
+        )  # range in [1, no_bins + 1], shape = [..., N_sample, N_token, N_token]
+        true_bins = torch.clamp(
+            true_bins, min=1, max=self.no_bins
+        )  # just in case bin=0 occurs
+
+        # Mask
+        token_mask = coordinate_mask[..., rep_atom_mask]
+        pair_mask = token_mask[..., None] * token_mask[..., None, :]
+
+        return F.one_hot(true_bins - 1, self.no_bins).detach(), pair_mask.detach()
+
+    def forward(
+        self,
+        logits: torch.Tensor,
+        pred_coordinate: torch.Tensor,
+        true_coordinate: torch.Tensor,
+        coordinate_mask: torch.Tensor,
+        rep_atom_mask: torch.Tensor,
+    ) -> torch.Tensor:
+        """PDELoss
+
+        Args:
+            logits (torch.Tensor): logits
+                [..., N_sample, N_token, N_token, no_bins]
+            pred_coordinate: (torch.Tensor): predict coordinates
+                [..., N_sample, N_atom, 3]
+            true_coordinate (torch.Tensor): true coordinates
+                [..., N_atom, 3]
+            coordinate_mask (torch.Tensor): whether true coordinates exist
+                [N_atom] or [..., N_atom]
+            rep_atom_mask (torch.Tensor): representative atom mask for this loss
+                [N_atom]
+
+        Returns:
+            torch.Tensor: the return loss
+                [...] if reduction is None else []
+        """
+
+        with torch.no_grad():
+            true_bins, pair_mask = self.calculate_label(
+                pred_coordinate=pred_coordinate,
+                true_coordinate=true_coordinate,
+                coordinate_mask=coordinate_mask,
+                rep_atom_mask=rep_atom_mask,
+            )
+
+        errors = softmax_cross_entropy(
+            logits=logits,
+            labels=true_bins,
+        )  # [..., N_sample, N_token, N_token]
+
+        denom = self.eps + torch.sum(pair_mask, dim=(-1, -2))  # [...]
+        loss = errors * pair_mask.unsqueeze(dim=-3)  # [..., N_sample, N_token, N_token]
+        loss = torch.sum(loss, dim=(-1, -2))  # [..., N_sample]
+        loss = loss / denom.unsqueeze(dim=-1)  # [..., N_sample]
+        loss = loss.mean(dim=-1)  # [...]
+
+        return loss_reduction(loss, method=self.reduction)
+
+
+# Algorithm 30 Compute alignment error
+def compute_alignment_error_squared(
+    pred_coordinate: torch.Tensor,
+    true_coordinate: torch.Tensor,
+    pred_frames: torch.Tensor,
+    true_frames: torch.Tensor,
+) -> torch.Tensor:
+    """Implements Algorithm 30 Compute alignment error, but do not take the square root
+
+    Args:
+        pred_coordinate (torch.Tensor): the predict coords [frame center]
+            [..., N_sample, N_token, 3]
+        true_coordinate (torch.Tensor): the ground truth coords [frame center]
+            [..., N_token, 3]
+        pred_frames (torch.Tensor): the predict frame
+            [..., N_sample, N_frame, 3, 3]
+        true_frames (torch.Tensor): the ground truth frame
+            [..., N_frame, 3, 3]
+
+    Returns:
+        torch.Tensor: the computed alignment error
+            [..., N_sample, N_frame, N_token]
+    """
+    x_transformed_pred = expressCoordinatesInFrame(
+        coordinate=pred_coordinate, frames=pred_frames
+    )  # [..., N_sample, N_frame, N_token, 3]
+    x_transformed_true = expressCoordinatesInFrame(
+        coordinate=true_coordinate, frames=true_frames
+    )  # [..., N_frame, N_token, 3]
+    squared_pae = torch.sum(
+        (x_transformed_pred - x_transformed_true.unsqueeze(dim=-4)) ** 2, dim=-1
+    )  # [..., N_sample, N_frame, N_token]
+    return squared_pae
+
+
+class PAELoss(nn.Module):
+    """
+    Implements Predicted Aligned distance loss in AF3
+    """
+
+    def __init__(
+        self,
+        min_bin: float = 0,
+        max_bin: float = 32,
+        no_bins: int = 64,
+        eps: float = 1e-6,
+        reduction: str = "mean",
+    ) -> None:
+        """PAELoss
+        This loss are between representative token atoms i and j in the mini-rollout prediction
+
+        Args:
+            min_bin (float, optional): min boundary of bins. Defaults to 0.
+            max_bin (float, optional): max boundary of bins. Defaults to 32.
+            no_bins (int, optional): number of bins. Defaults to 64.
+            eps (float, optional): small number added to denominator. Defaults to 1e-6.
+            reduce (bool, optional): reduce dim. Defaults to True.
+        """
+        super(PAELoss, self).__init__()
+        self.min_bin = min_bin
+        self.max_bin = max_bin
+        self.no_bins = no_bins
+        self.eps = eps
+        self.reduction = reduction
+
+    def calculate_label(
+        self,
+        pred_coordinate: torch.Tensor,
+        true_coordinate: torch.Tensor,
+        coordinate_mask: torch.Tensor,
+        rep_atom_mask: torch.Tensor,
+        frame_atom_index: torch.Tensor,
+        has_frame: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """calculate true PAE (squared) and true bins
+
+        Args:
+            pred_coordinate: (torch.Tensor): predict coordinates.
+                [..., N_sample, N_atom, 3]
+            true_coordinate (torch.Tensor): true coordinates.
+                [..., N_atom, 3]
+            coordinate_mask (torch.Tensor): whether true coordinates exist
+                [N_atom]
+            rep_atom_mask (torch.Tensor): masks of the representative atom for each token.
+                [N_atom]
+            frame_atom_index (torch.Tensor): indices of frame atoms (three atoms per token(=per frame)).
+                [N_token, 3[three atom]]
+            has_frame (torch.Tensor): indicates whether token_i has a valid frame.
+                [N_token]
+        Returns:
+            squared_pae (torch.Tensor): pairwise alignment error squared
+                [..., N_sample, N_frame, N_token] where N_token = rep_atom_mask.sum()
+            true_bins (torch.Tensor): the true bins
+                [..., N_sample, N_frame, N_token, no_bins]
+            frame_token_pair_mask (torch.Tensor): whether frame_i token_j both have true coordinates.
+                [N_frame, N_token]
+        """
+
+        coordinate_mask = coordinate_mask.bool()
+        rep_atom_mask = rep_atom_mask.bool()
+        has_frame = has_frame.bool()
+
+        # NOTE: to support frame_atom_index with batch_dims, need to expand its dims before constructing frames.
+        assert len(frame_atom_index.shape) == 2
+
+        # Take valid frames: N_token -> N_frame
+        frame_atom_index = frame_atom_index[has_frame, :]  # [N_frame, 3[three atom]]
+
+        # Get predicted frames and true frames
+        pred_frames = gather_frame_atom_by_indices(
+            coordinate=pred_coordinate, frame_atom_index=frame_atom_index, dim=-2
+        )  # [..., N_sample, N_frame, 3[three atom], 3[coordinates]]
+        true_frames = gather_frame_atom_by_indices(
+            coordinate=true_coordinate, frame_atom_index=frame_atom_index, dim=-2
+        )  # [..., N_frame, 3[three atom], 3[coordinates]]
+
+        # Get pair_mask for computing the loss
+        true_frame_coord_mask = gather_frame_atom_by_indices(
+            coordinate=coordinate_mask, frame_atom_index=frame_atom_index, dim=-1
+        )  # [N_frame, 3[three atom]]
+        true_frame_coord_mask = (
+            true_frame_coord_mask.sum(dim=-1) >= 3
+        )  # [N_frame] whether all atoms in the frame has coordinates
+        token_mask = coordinate_mask[rep_atom_mask]  # [N_token]
+        frame_token_pair_mask = (
+            true_frame_coord_mask[..., None] * token_mask[..., None, :]
+        )  # [N_frame, N_token]
+
+        squared_pae = (
+            compute_alignment_error_squared(
+                pred_coordinate=pred_coordinate[..., rep_atom_mask, :],
+                true_coordinate=true_coordinate[..., rep_atom_mask, :],
+                pred_frames=pred_frames,
+                true_frames=true_frames,
+            )
+            * frame_token_pair_mask
+        )  # [..., N_sample, N_frame, N_token]
+
+        # Compute true bins
+        boundaries = torch.linspace(
+            start=self.min_bin,
+            end=self.max_bin,
+            steps=self.no_bins + 1,
+            device=pred_coordinate.device,
+        )
+        boundaries = boundaries**2
+
+        true_bins = torch.sum(
+            squared_pae.unsqueeze(dim=-1) > boundaries, dim=-1
+        )  # range [1, no_bins + 1]
+        true_bins = torch.where(
+            frame_token_pair_mask,
+            true_bins,
+            torch.ones_like(true_bins) * self.no_bins,
+        )
+        true_bins = torch.clamp(
+            true_bins, min=1, max=self.no_bins
+        )  # just in case bin=0 occurs
+
+        return (
+            squared_pae.detach(),
+            F.one_hot(true_bins - 1, self.no_bins).detach(),
+            frame_token_pair_mask.detach(),
+        )
+
+    def forward(
+        self,
+        logits: torch.Tensor,
+        pred_coordinate: torch.Tensor,
+        true_coordinate: torch.Tensor,
+        coordinate_mask: torch.Tensor,
+        frame_atom_index: torch.Tensor,
+        rep_atom_mask: torch.Tensor,
+        has_frame: torch.Tensor,
+    ) -> torch.Tensor:
+        """PAELoss
+
+        Args:
+            logits (torch.Tensor): logits
+                [..., N_sample, N_token, N_token, no_bins]
+            pred_coordinate: (torch.Tensor): predict coordinates
+                [..., N_sample, N_atom, 3]
+            true_coordinate (torch.Tensor): true coordinates
+                [..., N_atom, 3]
+            coordinate_mask (torch.Tensor): whether true coordinates exist
+                [N_atom]
+            rep_atom_mask (torch.Tensor): masks of the representative atom for each token.
+                [N_atom]
+            frame_atom_index (torch.Tensor): indices of frame atoms (three atoms per token(=per frame)).
+                [N_token, 3[three atom]]
+            has_frame (torch.Tensor): indicates whether token_i has a valid frame.
+                [N_token]
+        Returns:
+            torch.Tensor: the return loss
+                [] if reduce
+                [..., n] else
+        """
+
+        has_frame = has_frame.bool()
+        rep_atom_mask = rep_atom_mask.bool()
+        assert len(has_frame.shape) == 1
+        assert len(frame_atom_index.shape) == 2
+
+        with torch.no_grad():
+            # true_bins: [..., N_sample, N_frame, N_token, no_bins]
+            # pair_mask: [N_frame, N_token]
+            _, true_bins, pair_mask = self.calculate_label(
+                pred_coordinate=pred_coordinate,
+                true_coordinate=true_coordinate,
+                frame_atom_index=frame_atom_index,
+                rep_atom_mask=rep_atom_mask,
+                coordinate_mask=coordinate_mask,
+                has_frame=has_frame,
+            )
+
+        loss = softmax_cross_entropy(
+            logits=logits[
+                ..., has_frame, :, :
+            ],  # [..., N_sample, N_frame, N_token, no_bins]
+            labels=true_bins,
+        )  # [..., N_sample, N_frame, N_token]
+
+        denom = self.eps + torch.sum(pair_mask, dim=(-1, -2))  # []
+        loss = loss * pair_mask.unsqueeze(dim=-3)  # [..., N_sample, N_token, N_token]
+        loss = torch.sum(loss, dim=(-1, -2))  # [..., N_sample]
+        loss = loss / denom.unsqueeze(dim=-1)  # [..., N_sample]
+        loss = loss.mean(dim=-1)  # [...]
+
+        return loss_reduction(loss, self.reduction)
+
+
+class ExperimentallyResolvedLoss(nn.Module):
+    def __init__(
+        self,
+        eps: float = 1e-6,
+        reduction: str = "mean",
+    ) -> None:
+        """
+        Args:
+            eps (float, optional): avoid nan. Defaults to 1e-6.
+        """
+        super(ExperimentallyResolvedLoss, self).__init__()
+        self.eps = eps
+        self.reduction = reduction
+
+    def forward(
+        self,
+        logits: torch.Tensor,
+        coordinate_mask: torch.Tensor,
+        atom_mask: torch.Tensor = None,
+    ) -> torch.Tensor:
+        """
+        Args:
+            logits (torch.Tensor): logits
+                [..., N_sample, N_atom, no_bins:=2]
+            coordinate_mask (torch.Tensor): whether true coordinates exist
+                [..., N_atom] | [N_atom]
+            atom_mask (torch.Tensor, optional): whether to conside the atom in the loss
+                [..., N_atom]
+        Returns:
+            torch.Tensor: the experimentally resolved loss
+        """
+        is_resolved = F.one_hot(
+            coordinate_mask.long(), 2
+        )  # [..., N_atom, 2] or [N_atom, 2]
+        errors = softmax_cross_entropy(
+            logits=logits, labels=is_resolved.unsqueeze(dim=-3)
+        )  # [..., N_sample, N_atom]
+        if atom_mask is None:
+            loss = errors.mean(dim=-1)  # [..., N_sample]
+        else:
+            loss = torch.sum(
+                errors * atom_mask[..., None, :], dim=-1
+            )  # [..., N_sample]
+            loss = loss / (
+                self.eps + torch.sum(atom_mask[..., None, :], dim=-1)
+            )  # [..., N_sample]
+
+        loss = loss.mean(dim=-1)  # [...]
+        return loss_reduction(loss, method=self.reduction)
+
+
+class MSELoss(nn.Module):
+    """
+    Implements Formula 2-4 [MSELoss] in AF3
+    """
+
+    def __init__(
+        self,
+        weight_mse: float = 1 / 3,
+        weight_dna: float = 5.0,
+        weight_rna=5.0,
+        weight_ligand=10.0,
+        eps=1e-6,
+        reduction: str = "mean",
+    ) -> None:
+        super(MSELoss, self).__init__()
+        self.weight_mse = weight_mse
+        self.weight_dna = weight_dna
+        self.weight_rna = weight_rna
+        self.weight_ligand = weight_ligand
+        self.eps = eps
+        self.reduction = reduction
+
+    def weighted_rigid_align(
+        self,
+        pred_coordinate: torch.Tensor,
+        true_coordinate: torch.Tensor,
+        coordinate_mask: torch.Tensor,
+        is_dna: torch.Tensor,
+        is_rna: torch.Tensor,
+        is_ligand: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """compute weighted rigid alignment results
+
+        Args:
+            pred_coordinate (torch.Tensor): the denoised coordinates from diffusion module
+                [..., N_sample, N_atom, 3]
+            true_coordinate (torch.Tensor): the ground truth coordinates
+                [..., N_atom, 3]
+            coordinate_mask (torch.Tensor): whether true coordinates exist
+                [N_atom] or [..., N_atom]
+            is_dna / is_rna / is_ligand (torch.Tensor): mol type mask
+                [N_atom] or [..., N_atom]
+
+        Returns:
+            true_coordinate_aligned (torch.Tensor): aligned coordinates for each sample
+                [..., N_sample, N_atom, 3]
+            weight (torch.Tensor): weights for each atom
+                [N_atom] or [..., N_sample, N_atom]
+        """
+        N_sample = pred_coordinate.size(-3)
+        weight = (
+            1
+            + self.weight_dna * is_dna
+            + self.weight_rna * is_rna
+            + self.weight_ligand * is_ligand
+        )  # [N_atom] or [..., N_atom]
+
+        # Apply coordinate_mask
+        weight = weight * coordinate_mask  # [N_atom] or [..., N_atom]
+        true_coordinate = true_coordinate * coordinate_mask.unsqueeze(dim=-1)
+        pred_coordinate = pred_coordinate * coordinate_mask[..., None, :, None]
+
+        # Reshape to add "N_sample" dimension
+        true_coordinate = expand_at_dim(
+            true_coordinate, dim=-3, n=N_sample
+        )  # [..., N_sample, N_atom, 3]
+        if len(weight.shape) > 1:
+            weight = expand_at_dim(
+                weight, dim=-2, n=N_sample
+            )  # [..., N_sample, N_atom]
+
+        # Align GT coords to predicted coords
+        d = pred_coordinate.dtype
+        # Some ops in weighted_rigid_align do not support BFloat16 training
+        with torch.cuda.amp.autocast(enabled=False):
+            true_coordinate_aligned = weighted_rigid_align(
+                x=true_coordinate.to(torch.float32),  # [..., N_sample, N_atom, 3]
+                x_target=pred_coordinate.to(
+                    torch.float32
+                ),  # [..., N_sample, N_atom, 3]
+                atom_weight=weight.to(
+                    torch.float32
+                ),  # [N_atom] or [..., N_sample, N_atom]
+                stop_gradient=True,
+            )  # [..., N_sample, N_atom, 3]
+            true_coordinate_aligned = true_coordinate_aligned.to(d)
+
+        return (true_coordinate_aligned.detach(), weight.detach())
+
+    def forward(
+        self,
+        pred_coordinate: torch.Tensor,
+        true_coordinate: torch.Tensor,
+        coordinate_mask: torch.Tensor,
+        is_dna: torch.Tensor,
+        is_rna: torch.Tensor,
+        is_ligand: torch.Tensor,
+        per_sample_scale: torch.Tensor = None,
+    ) -> torch.Tensor:
+        """MSELoss
+
+        Args:
+            pred_coordinate (torch.Tensor): the denoised coordinates from diffusion module.
+                [..., N_sample, N_atom, 3]
+            true_coordinate (torch.Tensor): the ground truth coordinates.
+                [..., N_atom, 3]
+            coordinate_mask (torch.Tensor): whether true coordinates exist.
+                [N_atom] or [..., N_atom]
+            is_dna / is_rna / is_ligand (torch.Tensor): mol type mask.
+                [N_atom] or [..., N_atom]
+            per_sample_scale (torch.Tensor, optional): whether to scale the loss by the per-sample noise-level.
+                [..., N_sample]
+
+        Returns:
+            torch.Tensor: the weighted mse loss.
+                [...] is self.reduction is None else []
+        """
+        # True_coordinate_aligned: [..., N_sample, N_atom, 3]
+        # Weight: [N_atom] or [..., N_sample, N_atom]
+        with torch.no_grad():
+            true_coordinate_aligned, weight = self.weighted_rigid_align(
+                pred_coordinate=pred_coordinate,
+                true_coordinate=true_coordinate,
+                coordinate_mask=coordinate_mask,
+                is_dna=is_dna,
+                is_rna=is_rna,
+                is_ligand=is_ligand,
+            )
+
+        # Calculate MSE loss
+        per_atom_se = ((pred_coordinate - true_coordinate_aligned) ** 2).sum(
+            dim=-1
+        )  # [..., N_sample, N_atom]
+        per_sample_weighted_mse = (weight * per_atom_se).sum(dim=-1) / (
+            coordinate_mask.sum(dim=-1, keepdim=True) + self.eps
+        )  # [..., N_sample]
+
+        if per_sample_scale is not None:
+            per_sample_weighted_mse = per_sample_weighted_mse * per_sample_scale
+
+        weighted_align_mse_loss = self.weight_mse * (per_sample_weighted_mse).mean(
+            dim=-1
+        )  # [...]
+
+        loss = loss_reduction(weighted_align_mse_loss, method=self.reduction)
+
+        return loss
+
+
+class PLDDTLoss(nn.Module):
+    """
+    Implements PLDDT Loss in AF3, different from the paper description.
+    Main changes:
+    1. use difference of distance instead of predicted distance when calculating plddt
+    2. normalize each plddt score within 0-1
+    """
+
+    def __init__(
+        self,
+        min_bin: float = 0,
+        max_bin: float = 1,
+        no_bins: int = 50,
+        is_nucleotide_threshold: float = 30.0,
+        is_not_nucleotide_threshold: float = 15.0,
+        eps: float = 1e-6,
+        normalize: bool = True,
+        reduction: str = "mean",
+    ) -> None:
+        """PLDDT loss
+        This loss are between atoms l and m (has some filters) in the mini-rollout prediction
+
+        Args:
+            min_bin (float, optional): min boundary of bins. Defaults to 0.
+            max_bin (float, optional): max boundary of bins. Defaults to 1.
+            no_bins (int, optional): number of bins. Defaults to 50.
+            is_nucleotide_threshold (float, optional): threshold for nucleotide atoms. Defaults 30.0.
+            is_not_nucleotide_threshold (float, optional): threshold for non-nucleotide atoms. Defaults 15.0
+            eps (float, optional): small number added to denominator. Defaults to 1e-6.
+            reduction (str, optional): reduction method for the batch dims. Defaults to mean.
+        """
+        super(PLDDTLoss, self).__init__()
+        self.normalize = normalize
+        self.min_bin = min_bin
+        self.max_bin = max_bin
+        self.no_bins = no_bins
+        self.eps = eps
+        self.reduction = reduction
+        self.is_nucleotide_threshold = is_nucleotide_threshold
+        self.is_not_nucleotide_threshold = is_not_nucleotide_threshold
+
+    def calculate_label(
+        self,
+        pred_coordinate: torch.Tensor,
+        true_coordinate: torch.Tensor,
+        is_nucleotide: torch.Tensor,
+        is_polymer: torch.Tensor,
+        rep_atom_mask: torch.Tensor,
+    ) -> torch.Tensor:
+        """calculate the lddt as described in Sec 4.3.1.
+
+        Args:
+            pred_coordinate (torch.Tensor):
+                [..., N_sample, N_atom, 3]
+            true_coordinate (torch.Tensor):
+                [..., N_atom]
+            is_nucleotide (torch.Tensor):
+                [N_atom] or [..., N_atom]
+            is_polymer (torch.Tensor):
+                [N_atom]
+            rep_atom_mask (torch.Tensor):
+                [N_atom]
+
+        Returns:
+            torch.Tensor: per-atom lddt
+                [..., N_sample, N_atom]
+        """
+
+        N_atom = true_coordinate.size(-2)
+        atom_m_mask = (rep_atom_mask * is_polymer).bool()  # [N_atom]
+        # Distance: d_lm
+        pred_d_lm = torch.cdist(
+            pred_coordinate, pred_coordinate[..., atom_m_mask, :]
+        )  # [..., N_sample, N_atom, N_atom(m)]
+        true_d_lm = torch.cdist(
+            true_coordinate, true_coordinate[..., atom_m_mask, :]
+        )  # [..., N_atom, N_atom(m)]
+        delta_d_lm = torch.abs(
+            pred_d_lm - true_d_lm.unsqueeze(dim=-3)
+        )  # [..., N_sample, N_atom, N_atom(m)]
+
+        # Pair-wise lddt
+        thresholds = [0.5, 1, 2, 4]
+        lddt_lm = (
+            torch.stack([delta_d_lm < t for t in thresholds], dim=-1)
+            .to(dtype=delta_d_lm.dtype)
+            .mean(dim=-1)
+        )  # [..., N_sample, N_atom, N_atom(m)]
+
+        # Select atoms that are within certain threshold to l in ground truth
+        # Restrict to bespoke inclusion radius
+        is_nucleotide = is_nucleotide[
+            ..., atom_m_mask
+        ].bool()  # [N_atom(m)] or [..., N_atom(m)]
+        locality_mask = (
+            true_d_lm < self.is_nucleotide_threshold
+        ) * is_nucleotide.unsqueeze(dim=-2) + (
+            true_d_lm < self.is_not_nucleotide_threshold
+        ) * (
+            ~is_nucleotide.unsqueeze(dim=-2)
+        )  # [..., N_atom, N_atom(m)]
+
+        # Remove self-distance computation
+        diagonal_mask = ((1 - torch.eye(n=N_atom)).bool().to(true_d_lm.device))[
+            ..., atom_m_mask
+        ]  # [N_atom, N_atom(m)]
+
+        pair_mask = (locality_mask * diagonal_mask).unsqueeze(
+            dim=-3
+        )  # [..., 1, N_atom, N_atom(m)]
+
+        per_atom_lddt = torch.sum(
+            lddt_lm * pair_mask, dim=-1, keepdim=True
+        )  # [...,  N_sample, N_atom, 1]
+        if self.normalize:
+            per_atom_lddt = per_atom_lddt / (
+                torch.sum(pair_mask.to(dtype=per_atom_lddt.dtype), dim=-1, keepdim=True)
+                + self.eps
+            )
+        # Distribute into bins
+        boundaries = torch.linspace(
+            start=self.min_bin,
+            end=self.max_bin,
+            steps=self.no_bins + 1,
+            device=true_coordinate.device,
+        )  # [N_bins]
+
+        true_bins = torch.sum(
+            per_atom_lddt > boundaries, dim=-1
+        )  # [...,  N_sample, N_atom], range in [1, no_bins]
+        true_bins = torch.clamp(
+            true_bins, min=1, max=self.no_bins
+        )  # just in case bin=0/no_bins+1 occurs
+        true_bins = F.one_hot(
+            true_bins - 1, self.no_bins
+        )  # [...,  N_sample, N_atom, N_bins]
+
+        return true_bins
+
+    def forward(
+        self,
+        logits: torch.Tensor,
+        pred_coordinate: torch.Tensor,
+        true_coordinate: torch.Tensor,
+        coordinate_mask: torch.Tensor,
+        is_nucleotide: torch.Tensor,
+        is_polymer: torch.Tensor,
+        rep_atom_mask: torch.Tensor,
+    ) -> torch.Tensor:
+        """PLDDT loss
+
+        Args:
+            logits (torch.Tensor): logits
+                [..., N_sample, N_atom, no_bins:=50]
+            pred_coordinate (torch.Tensor): predicted coordinates
+                [..., N_sample, N_atom, 3]
+            true_coordinate (torch.Tensor): true coordinates
+                [..., N_atom, 3]
+            coordinate_mask (torch.Tensor): whether true coordinates exist
+                [N_atom]
+            is_nucleotide (torch.Tensor): "is_rna" or "is_dna"
+                [N_atom]
+            is_polymer (torch.Tensor): not "is_ligand"
+                [N_atom]
+            rep_atom_mask (torch.Tensor): representative atom of each token
+                [N_atom]
+
+        Returns:
+            torch.Tensor: the return loss
+                [...] if self.reduction is None else []
+        """
+        assert (
+            is_nucleotide.shape
+            == is_polymer.shape
+            == rep_atom_mask.shape
+            == coordinate_mask.shape
+            == coordinate_mask.view(-1).shape
+        )
+
+        coordinate_mask = coordinate_mask.bool()
+        rep_atom_mask = rep_atom_mask.bool()
+        is_nucleotide = is_nucleotide.bool()
+        is_polymer = is_polymer.bool()
+
+        with torch.no_grad():
+            true_bins = self.calculate_label(
+                pred_coordinate=pred_coordinate[..., coordinate_mask, :],
+                true_coordinate=true_coordinate[..., coordinate_mask, :],
+                is_nucleotide=is_nucleotide[coordinate_mask],
+                is_polymer=is_polymer[coordinate_mask],
+                rep_atom_mask=rep_atom_mask[coordinate_mask],
+            ).detach()  # [..., N_sample, N_atom_with_coords, N_bins]
+
+        plddt_loss = softmax_cross_entropy(
+            logits=logits[..., coordinate_mask, :],
+            labels=true_bins,
+        )  # [..., N_sample, N_atom_with_coords]
+
+        # Average over atoms
+        plddt_loss = plddt_loss.mean(dim=-1)  # [..., N_sample]
+
+        # Average over samples
+        plddt_loss = plddt_loss.mean(dim=-1)  # [...]
+
+        return loss_reduction(plddt_loss, method=self.reduction)
+
+
+class ProtenixLoss(nn.Module):
+    """Aggregation of the various losses"""
+
+    def __init__(self, configs) -> None:
+        super(ProtenixLoss, self).__init__()
+        self.configs = configs
+
+        self.alpha_confidence = self.configs.loss.weight.alpha_confidence
+        self.alpha_pae = self.configs.loss.weight.alpha_pae
+        self.alpha_except_pae = self.configs.loss.weight.alpha_except_pae
+        self.alpha_diffusion = self.configs.loss.weight.alpha_diffusion
+        self.alpha_distogram = self.configs.loss.weight.alpha_distogram
+        self.alpha_bond = self.configs.loss.weight.alpha_bond
+        self.weight_smooth_lddt = self.configs.loss.weight.smooth_lddt
+
+        self.lddt_radius = {
+            "is_nucleotide_threshold": 30.0,
+            "is_not_nucleotide_threshold": 15.0,
+        }
+
+        self.loss_weight = {
+            # confidence
+            "plddt_loss": self.alpha_confidence * self.alpha_except_pae,
+            "pde_loss": self.alpha_confidence * self.alpha_except_pae,
+            "resolved_loss": self.alpha_confidence * self.alpha_except_pae,
+            "pae_loss": self.alpha_confidence * self.alpha_pae,
+            # diffusion
+            "mse_loss": self.alpha_diffusion,
+            "bond_loss": self.alpha_diffusion * self.alpha_bond,
+            "smooth_lddt_loss": self.alpha_diffusion
+            * self.weight_smooth_lddt,  # Different from AF3 appendix eq(6), where smooth_lddt has no weight
+            # distogram
+            "distogram_loss": self.alpha_distogram,
+        }
+
+        # Loss
+        self.plddt_loss = PLDDTLoss(**configs.loss.plddt, **self.lddt_radius)
+        self.pde_loss = PDELoss(**configs.loss.pde)
+        self.resolved_loss = ExperimentallyResolvedLoss(**configs.loss.resolved)
+        self.pae_loss = PAELoss(**configs.loss.pae)
+        self.mse_loss = MSELoss(**configs.loss.diffusion.mse)
+        self.bond_loss = BondLoss(**configs.loss.diffusion.bond)
+        self.smooth_lddt_loss = SmoothLDDTLoss(**configs.loss.diffusion.smooth_lddt)
+        self.distogram_loss = DistogramLoss(**configs.loss.distogram)
+
+    def calculate_label(
+        self,
+        feat_dict: dict[str, Any],
+        label_dict: dict[str, Any],
+    ) -> dict[str, Any]:
+        """calculate true distance, and atom pair mask
+
+        Args:
+            feat_dict (dict): Feature dictionary containing additional features.
+            label_dict (dict): Label dictionary containing ground truth data.
+
+        Returns:
+            label_dict (dict): with the following updates:
+                distance (torch.Tensor): true atom-atom distance.
+                    [..., N_atom, N_atom]
+                distance_mask (torch.Tensor): atom-atom mask indicating whether true distance exists.
+                    [..., N_atom, N_atom]
+        """
+        # Distance mask
+        distance_mask = (
+            label_dict["coordinate_mask"][..., None]
+            * label_dict["coordinate_mask"][..., None, :]
+        )
+        # Distances for all atom pairs
+        # Note: we convert to bf16 for saving cuda memory, if performance drops, do not convert it
+        distance = (
+            cdist(label_dict["coordinate"], label_dict["coordinate"]) * distance_mask
+        ).to(
+            label_dict["coordinate"].dtype
+        )  # [..., N_atom, N_atom]
+
+        lddt_mask = compute_lddt_mask(
+            true_distance=distance,
+            distance_mask=distance_mask,
+            is_nucleotide=feat_dict["is_rna"].bool() + feat_dict["is_dna"].bool(),
+            **self.lddt_radius,
+        )
+
+        label_dict["lddt_mask"] = lddt_mask
+        label_dict["distance_mask"] = distance_mask
+        if not self.configs.loss_metrics_sparse_enable:
+            label_dict["distance"] = distance
+        del distance, distance_mask, lddt_mask
+        return label_dict
+
+    def calculate_prediction(
+        self,
+        pred_dict: dict[str, torch.Tensor],
+    ) -> dict[str, torch.Tensor]:
+        """get more predictions used for calculating difference losses
+
+        Args:
+            pred_dict (dict[str, torch.Tensor]): raw prediction dict given by the model
+
+        Returns:
+            dict[str, torch.Tensor]: updated predictions
+        """
+        if not self.configs.loss_metrics_sparse_enable:
+            pred_dict["distance"] = torch.cdist(
+                pred_dict["coordinate"], pred_dict["coordinate"]
+            ).to(
+                pred_dict["coordinate"].dtype
+            )  # [..., N_atom, N_atom]
+        return pred_dict
+
+    def aggregate_losses(
+        self, loss_fns: dict, has_valid_resolution: Optional[torch.Tensor] = None
+    ) -> tuple[torch.Tensor, dict]:
+        """
+        Aggregates multiple loss functions and their respective metrics.
+
+        Args:
+            loss_fns (dict): Dictionary of loss functions to be aggregated.
+            has_valid_resolution (Optional[torch.Tensor]): Tensor indicating valid resolutions. Defaults to None.
+
+        Returns:
+            tuple[torch.Tensor, dict]:
+                - cum_loss (torch.Tensor): Cumulative loss.
+                - all_metrics (dict): Dictionary containing all metrics.
+        """
+        cum_loss = 0.0
+        all_metrics = {}
+        for loss_name, loss_fn in loss_fns.items():
+            weight = self.loss_weight[loss_name]
+            loss_outputs = loss_fn()
+            if isinstance(loss_outputs, tuple):
+                loss, metrics = loss_outputs
+            else:
+                assert isinstance(loss_outputs, torch.Tensor)
+                loss, metrics = loss_outputs, {}
+
+            all_metrics.update(
+                {f"{loss_name}/{key}": val for key, val in metrics.items()}
+            )
+            if torch.isnan(loss) or torch.isinf(loss):
+                logging.warning(f"{loss_name} loss is NaN. Skipping...")
+            if (
+                (has_valid_resolution is not None)
+                and (has_valid_resolution.sum() == 0)
+                and (
+                    loss_name in ["plddt_loss", "pde_loss", "resolved_loss", "pae_loss"]
+                )
+            ):
+                loss = 0.0 * loss
+            else:
+                all_metrics[loss_name] = loss.detach().clone()
+                all_metrics[f"weighted_{loss_name}"] = weight * loss.detach().clone()
+
+            cum_loss = cum_loss + weight * loss
+        all_metrics["loss"] = cum_loss.detach().clone()
+
+        return cum_loss, all_metrics
+
+    def calculate_losses(
+        self,
+        feat_dict: dict[str, Any],
+        pred_dict: dict[str, torch.Tensor],
+        label_dict: dict[str, Any],
+        mode: str = "train",
+    ) -> tuple[torch.Tensor, dict[str, torch.Tensor]]:
+        """
+        Calculate the cumulative loss and aggregated metrics for the given predictions and labels.
+
+        Args:
+            feat_dict (dict[str, Any]): Feature dictionary containing additional features.
+            pred_dict (dict[str, torch.Tensor]): Prediction dictionary containing model outputs.
+            label_dict (dict[str, Any]): Label dictionary containing ground truth data.
+            mode (str): Mode of operation ('train', 'eval', 'inference'). Defaults to 'train'.
+
+        Returns:
+            tuple[torch.Tensor, dict[str, torch.Tensor]]:
+                - cum_loss (torch.Tensor): Cumulative loss.
+                - metrics (dict[str, torch.Tensor]): Dictionary containing aggregated metrics.
+        """
+        assert mode in ["train", "eval", "inference"]
+        if mode == "train":
+            # Confidence Loss: use mini-rollout coordinates
+            confidence_coordinate = "coordinate_mini"
+            if not self.configs.train_confidence_only:
+                # Scale diffusion loss with noise-level
+                diffusion_per_sample_scale = (
+                    pred_dict["noise_level"] ** 2 + self.configs.sigma_data**2
+                ) / (self.configs.sigma_data * pred_dict["noise_level"]) ** 2
+
+        else:
+            # Confidence Loss: use diffusion coordinates
+            confidence_coordinate = "coordinate"
+            # No scale is required
+            diffusion_per_sample_scale = None
+
+        if self.configs.train_confidence_only and mode == "train":
+            # Skip Diffusion Loss and distogram loss
+            loss_fns = {}
+        else:
+            # Diffusion Loss: SmoothLDDTLoss / BondLoss / MSELoss
+            loss_fns = {}
+            if self.configs.loss.diffusion_lddt_loss_dense:
+                loss_fns.update(
+                    {
+                        "smooth_lddt_loss": lambda: self.smooth_lddt_loss.dense_forward(
+                            pred_coordinate=pred_dict["coordinate"],
+                            true_coordinate=label_dict["coordinate"],
+                            lddt_mask=label_dict["lddt_mask"],
+                            diffusion_chunk_size=self.configs.loss.diffusion_lddt_chunk_size,
+                        )  # it's faster is not OOM
+                    }
+                )
+            elif self.configs.loss.diffusion_sparse_loss_enable:
+                loss_fns.update(
+                    {
+                        "smooth_lddt_loss": lambda: self.smooth_lddt_loss.sparse_forward(
+                            pred_coordinate=pred_dict["coordinate"],
+                            true_coordinate=label_dict["coordinate"],
+                            lddt_mask=label_dict["lddt_mask"],
+                            diffusion_chunk_size=self.configs.loss.diffusion_lddt_chunk_size,
+                        )
+                    }
+                )
+            else:
+                loss_fns.update(
+                    {
+                        "smooth_lddt_loss": lambda: self.smooth_lddt_loss(
+                            pred_distance=pred_dict["distance"],
+                            true_distance=label_dict["distance"],
+                            distance_mask=label_dict["distance_mask"],
+                            lddt_mask=label_dict["lddt_mask"],
+                            diffusion_chunk_size=self.configs.loss.diffusion_lddt_chunk_size,
+                        )
+                    }
+                )
+            loss_fns.update(
+                {
+                    "bond_loss": lambda: (
+                        self.bond_loss.sparse_forward(
+                            pred_coordinate=pred_dict["coordinate"],
+                            true_coordinate=label_dict["coordinate"],
+                            distance_mask=label_dict["distance_mask"],
+                            bond_mask=feat_dict["bond_mask"],
+                            per_sample_scale=diffusion_per_sample_scale,
+                        )
+                        if self.configs.loss.diffusion_sparse_loss_enable
+                        else self.bond_loss(
+                            pred_distance=pred_dict["distance"],
+                            true_distance=label_dict["distance"],
+                            distance_mask=label_dict["distance_mask"],
+                            bond_mask=feat_dict["bond_mask"],
+                            per_sample_scale=diffusion_per_sample_scale,
+                            diffusion_chunk_size=self.configs.loss.diffusion_bond_chunk_size,
+                        )
+                    ),
+                    "mse_loss": lambda: self.mse_loss(
+                        pred_coordinate=pred_dict["coordinate"],
+                        true_coordinate=label_dict["coordinate"],
+                        coordinate_mask=label_dict["coordinate_mask"],
+                        is_rna=feat_dict["is_rna"],
+                        is_dna=feat_dict["is_dna"],
+                        is_ligand=feat_dict["is_ligand"],
+                        per_sample_scale=diffusion_per_sample_scale,
+                    ),
+                }
+            )
+            # Distogram Loss
+            if "distogram" in pred_dict:
+                loss_fns.update(
+                    {
+                        "distogram_loss": lambda: self.distogram_loss(
+                            logits=pred_dict["distogram"],
+                            true_coordinate=label_dict["coordinate"],
+                            coordinate_mask=label_dict["coordinate_mask"],
+                            rep_atom_mask=feat_dict["distogram_rep_atom_mask"],
+                        )
+                    }
+                )
+
+        # Confidence Loss:
+        # Only when resoluton is in [min_resolution, max_resolution] the confidence loss is considered
+        # NOTE: here we assume batch_size == 1
+        resolution = feat_dict["resolution"].item()
+        has_valid_resolution = (resolution >= self.configs.loss.resolution.min) & (
+            resolution <= self.configs.loss.resolution.max
+        )
+
+        if has_valid_resolution:
+            has_valid_resolution = torch.tensor(
+                [1.0],
+                dtype=label_dict["coordinate"].dtype,
+                device=label_dict["coordinate"].device,
+            )
+        else:
+            has_valid_resolution = torch.tensor(
+                [0.0],
+                dtype=label_dict["coordinate"].dtype,
+                device=label_dict["coordinate"].device,
+            )
+
+        if all(x in pred_dict for x in ["plddt", "pde", "pae", "resolved"]):
+            loss_fns.update(
+                {
+                    "plddt_loss": lambda: self.plddt_loss(
+                        logits=pred_dict["plddt"],
+                        pred_coordinate=pred_dict[confidence_coordinate].detach(),
+                        true_coordinate=label_dict["coordinate"],
+                        coordinate_mask=label_dict["coordinate_mask"],
+                        rep_atom_mask=feat_dict["plddt_m_rep_atom_mask"],
+                        is_nucleotide=feat_dict["is_rna"] + feat_dict["is_dna"],
+                        is_polymer=1 - feat_dict["is_ligand"],
+                    ),
+                    "pde_loss": lambda: self.pde_loss(
+                        logits=pred_dict["pde"],
+                        pred_coordinate=pred_dict[confidence_coordinate].detach(),
+                        true_coordinate=label_dict["coordinate"],
+                        coordinate_mask=label_dict["coordinate_mask"],
+                        rep_atom_mask=feat_dict["distogram_rep_atom_mask"],
+                    ),
+                    "resolved_loss": lambda: self.resolved_loss(
+                        logits=pred_dict["resolved"],
+                        coordinate_mask=label_dict["coordinate_mask"],
+                    ),
+                    "pae_loss": lambda: self.pae_loss(
+                        logits=pred_dict["pae"],
+                        pred_coordinate=pred_dict[confidence_coordinate].detach(),
+                        true_coordinate=label_dict["coordinate"],
+                        coordinate_mask=label_dict["coordinate_mask"],
+                        frame_atom_index=feat_dict["frame_atom_index"],
+                        rep_atom_mask=feat_dict["pae_rep_atom_mask"],
+                        has_frame=feat_dict["has_frame"],
+                    ),
+                }
+            )
+
+        cum_loss, metrics = self.aggregate_losses(loss_fns, has_valid_resolution)
+        return cum_loss, metrics
+
+    def forward(
+        self,
+        feat_dict: dict[str, Any],
+        pred_dict: dict[str, torch.Tensor],
+        label_dict: dict[str, Any],
+        mode: str = "train",
+    ) -> tuple[torch.Tensor, dict[str, torch.Tensor]]:
+        """
+        Forward pass for calculating the cumulative loss and aggregated metrics.
+
+        Args:
+            feat_dict (dict[str, Any]): Feature dictionary containing additional features.
+            pred_dict (dict[str, torch.Tensor]): Prediction dictionary containing model outputs.
+            label_dict (dict[str, Any]): Label dictionary containing ground truth data.
+            mode (str): Mode of operation ('train', 'eval', 'inference'). Defaults to 'train'.
+
+        Returns:
+            tuple[torch.Tensor, dict[str, torch.Tensor]]:
+                - cum_loss (torch.Tensor): Cumulative loss.
+                - losses (dict[str, torch.Tensor]): Dictionary containing aggregated metrics.
+        """
+        diffusion_chunk_size = self.configs.loss.diffusion_chunk_size_outer
+        assert mode in ["train", "eval", "inference"]
+        # Pre-computations
+        with torch.no_grad():
+            label_dict = self.calculate_label(feat_dict, label_dict)
+
+        pred_dict = self.calculate_prediction(pred_dict)
+
+        if diffusion_chunk_size <= 0:
+            # Calculate losses
+            cum_loss, losses = self.calculate_losses(
+                feat_dict=feat_dict,
+                pred_dict=pred_dict,
+                label_dict=label_dict,
+                mode=mode,
+            )
+        else:
+            if "coordinate" in pred_dict:
+                N_sample = pred_dict["coordinate"].shape[-3]
+            elif self.configs.train_confidence_only:
+                N_sample = pred_dict["coordinate_mini"].shape[-3]
+            else:
+                raise KeyError("Missing key: coordinate (in pred_dict).")
+            no_chunks = N_sample // diffusion_chunk_size + (
+                N_sample % diffusion_chunk_size != 0
+            )
+            cum_loss = 0.0
+            losses = {}
+            for i in range(no_chunks):
+                cur_sample_num = min(
+                    diffusion_chunk_size, N_sample - i * diffusion_chunk_size
+                )
+                pred_dict_i = {}
+                for key, value in pred_dict.items():
+                    if key in ["coordinate"] and mode == "train":
+                        pred_dict_i[key] = value[
+                            i * diffusion_chunk_size : (i + 1) * diffusion_chunk_size,
+                            :,
+                            :,
+                        ]
+                    elif (
+                        key in ["coordinate", "plddt", "pae", "pde", "resolved"]
+                        and mode != "train"
+                    ):
+                        pred_dict_i[key] = value[
+                            i * diffusion_chunk_size : (i + 1) * diffusion_chunk_size,
+                            :,
+                            :,
+                        ]
+                    elif key == "noise_level":
+                        pred_dict_i[key] = value[
+                            i * diffusion_chunk_size : (i + 1) * diffusion_chunk_size
+                        ]
+                    else:
+                        pred_dict_i[key] = value
+                pred_dict_i = self.calculate_prediction(pred_dict_i)
+                cum_loss_i, losses_i = self.calculate_losses(
+                    feat_dict=feat_dict,
+                    pred_dict=pred_dict_i,
+                    label_dict=label_dict,
+                    mode=mode,
+                )
+                cum_loss += cum_loss_i * cur_sample_num
+                # Aggregate metrics
+                for key, value in losses_i.items():
+                    if key in losses:
+                        losses[key] += value * cur_sample_num
+                    else:
+                        losses[key] = value * cur_sample_num
+            cum_loss /= N_sample
+            for key in losses.keys():
+                losses[key] /= N_sample
+
+        return cum_loss, losses

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/model/modules/confidence.py

@@ -0,0 +1,321 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional, Union
+
+import torch
+import torch.nn as nn
+
+from protenix.model.modules.pairformer import PairformerStack
+from protenix.model.modules.primitives import LinearNoBias
+from protenix.model.utils import broadcast_token_to_atom, one_hot
+from protenix.openfold_local.model.primitives import LayerNorm
+from protenix.utils.torch_utils import cdist
+
+
+class ConfidenceHead(nn.Module):
+    """
+    Implements Algorithm 31 in AF3
+    """
+
+    def __init__(
+        self,
+        n_blocks: int = 4,
+        c_s: int = 384,
+        c_z: int = 128,
+        c_s_inputs: int = 449,
+        b_pae: int = 64,
+        b_pde: int = 64,
+        b_plddt: int = 50,
+        b_resolved: int = 2,
+        max_atoms_per_token: int = 20,
+        pairformer_dropout: float = 0.0,
+        blocks_per_ckpt: Optional[int] = None,
+        distance_bin_start: float = 3.25,
+        distance_bin_end: float = 52.0,
+        distance_bin_step: float = 1.25,
+        stop_gradient: bool = True,
+    ) -> None:
+        """
+        Args:
+            n_blocks (int, optional): number of blocks for ConfidenceHead. Defaults to 4.
+            c_s (int, optional):  hidden dim [for single embedding]. Defaults to 384.
+            c_z (int, optional): hidden dim [for pair embedding]. Defaults to 128.
+            c_s_inputs (int, optional): hidden dim [for single embedding from InputFeatureEmbedder]. Defaults to 449.
+            b_pae (int, optional): the bin number for pae. Defaults to 64.
+            b_pde (int, optional): the bin numer for pde. Defaults to 64.
+            b_plddt (int, optional): the bin number for plddt. Defaults to 50.
+            b_resolved (int, optional): the bin number for resolved. Defaults to 2.
+            max_atoms_per_token (int, optional): max atoms in a token. Defaults to 20.
+            pairformer_dropout (float, optional): dropout ratio for Pairformer. Defaults to 0.0.
+            blocks_per_ckpt: number of Pairformer blocks in each activation checkpoint
+            distance_bin_start (float, optional): Start of the distance bin range. Defaults to 3.375.
+            distance_bin_end (float, optional): End of the distance bin range. Defaults to 21.375.
+            distance_bin_step (float, optional): Step size for the distance bins. Defaults to 1.25.
+            stop_gradient (bool, optional): Whether to stop gradient propagation. Defaults to True.
+        """
+        super(ConfidenceHead, self).__init__()
+        self.n_blocks = n_blocks
+        self.c_s = c_s
+        self.c_z = c_z
+        self.c_s_inputs = c_s_inputs
+        self.b_pae = b_pae
+        self.b_pde = b_pde
+        self.b_plddt = b_plddt
+        self.b_resolved = b_resolved
+        self.max_atoms_per_token = max_atoms_per_token
+        self.stop_gradient = stop_gradient
+        self.linear_no_bias_s1 = LinearNoBias(
+            in_features=self.c_s_inputs, out_features=self.c_z
+        )
+        self.linear_no_bias_s2 = LinearNoBias(
+            in_features=self.c_s_inputs, out_features=self.c_z
+        )
+        lower_bins = torch.arange(
+            distance_bin_start, distance_bin_end, distance_bin_step
+        )
+        upper_bins = torch.cat([lower_bins[1:], torch.tensor([1e6])])
+
+        self.lower_bins = nn.Parameter(lower_bins, requires_grad=False)
+        self.upper_bins = nn.Parameter(upper_bins, requires_grad=False)
+        self.num_bins = len(lower_bins)  # + 1
+
+        self.linear_no_bias_d = LinearNoBias(
+            in_features=self.num_bins, out_features=self.c_z
+        )
+
+        self.pairformer_stack = PairformerStack(
+            c_z=self.c_z,
+            c_s=self.c_s,
+            n_blocks=n_blocks,
+            dropout=pairformer_dropout,
+            blocks_per_ckpt=blocks_per_ckpt,
+        )
+        self.linear_no_bias_pae = LinearNoBias(
+            in_features=self.c_z, out_features=self.b_pae
+        )
+        self.linear_no_bias_pde = LinearNoBias(
+            in_features=self.c_z, out_features=self.b_pde
+        )
+        self.plddt_weight = nn.Parameter(
+            data=torch.empty(size=(self.max_atoms_per_token, self.c_s, self.b_plddt))
+        )
+        self.resolved_weight = nn.Parameter(
+            data=torch.empty(size=(self.max_atoms_per_token, self.c_s, self.b_resolved))
+        )
+
+        self.linear_no_bias_s_inputs = LinearNoBias(self.c_s_inputs, self.c_s)
+        self.linear_no_bias_s_trunk = LinearNoBias(self.c_s, self.c_s)
+        self.layernorm_s_trunk = LayerNorm(self.c_s)
+        self.linear_no_bias_z_trunk = LinearNoBias(self.c_z, self.c_z)
+        self.layernorm_z_trunk = LayerNorm(self.c_z)
+
+        self.layernorm_no_bias_z_cat = nn.LayerNorm(self.c_z * 2, bias=False)
+        self.layernorm_no_bias_s_cat = nn.LayerNorm(self.c_s * 2, bias=False)
+        self.linear_no_bias_z_cat = LinearNoBias(self.c_z * 2, self.c_z)
+        self.linear_no_bias_s_cat = LinearNoBias(self.c_s * 2, self.c_s)
+
+        # Output layernorm
+        self.pae_ln = LayerNorm(self.c_z)
+        self.pde_ln = LayerNorm(self.c_z)
+        self.plddt_ln = LayerNorm(self.c_s)
+        self.resolved_ln = LayerNorm(self.c_s)
+
+        with torch.no_grad():
+            # Zero init for output layer (before softmax) to zero
+            nn.init.zeros_(self.linear_no_bias_pae.weight)
+            nn.init.zeros_(self.linear_no_bias_pde.weight)
+            nn.init.zeros_(self.plddt_weight)
+            nn.init.zeros_(self.resolved_weight)
+
+            # Zero init for trunk embedding input layer
+            # nn.init.zeros_(self.linear_no_bias_s_trunk.weight)
+            # nn.init.zeros_(self.linear_no_bias_z_trunk.weight)
+
+    def forward(
+        self,
+        input_feature_dict: dict[str, Union[torch.Tensor, int, float, dict]],
+        s_inputs: torch.Tensor,
+        s_trunk: torch.Tensor,
+        z_trunk: torch.Tensor,
+        pair_mask: torch.Tensor,
+        x_pred_coords: torch.Tensor,
+        use_memory_efficient_kernel: bool = False,
+        use_deepspeed_evo_attention: bool = False,
+        use_lma: bool = False,
+        inplace_safe: bool = False,
+        chunk_size: Optional[int] = None,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        """
+        Args:
+            input_feature_dict: Dictionary containing input features.
+            s_inputs (torch.Tensor): single embedding from InputFeatureEmbedder
+                [..., N_tokens, c_s_inputs]
+            s_trunk (torch.Tensor): single feature embedding from PairFormer (Alg17)
+                [..., N_tokens, c_s]
+            z_trunk (torch.Tensor): pair feature embedding from PairFormer (Alg17)
+                [..., N_tokens, N_tokens, c_z]
+            pair_mask (torch.Tensor): pair mask
+                [..., N_token, N_token]
+            x_pred_coords (torch.Tensor): predicted coordinates
+                [..., N_sample, N_atoms, 3]
+            use_memory_efficient_kernel (bool, optional): Whether to use memory-efficient kernel. Defaults to False.
+            use_deepspeed_evo_attention (bool, optional): Whether to use DeepSpeed evolutionary attention. Defaults to False.
+            use_lma (bool, optional): Whether to use low-memory attention. Defaults to False.
+            inplace_safe (bool, optional): Whether to use inplace operations. Defaults to False.
+            chunk_size (Optional[int], optional): Chunk size for memory-efficient operations. Defaults to None.
+
+        Returns:
+            tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+                - plddt_preds: Predicted pLDDT scores [..., N_sample, N_atom, plddt_bins].
+                - pae_preds: Predicted PAE scores [..., N_sample, N_token, N_token, pae_bins].
+                - pde_preds: Predicted PDE scores [..., N_sample, N_token, N_token, pde_bins].
+                - resolved_preds: Predicted resolved scores [..., N_sample, N_atom, 2].
+        """
+
+        if self.stop_gradient:
+            s_inputs = s_inputs.detach()
+            s_trunk = s_trunk.detach()
+            z_trunk = z_trunk.detach()
+
+        s_trunk = self.linear_no_bias_s_trunk(self.layernorm_s_trunk(s_trunk))
+        z_trunk = self.linear_no_bias_z_trunk(self.layernorm_z_trunk(z_trunk))
+
+        z_init = (
+            self.linear_no_bias_s1(s_inputs)[..., None, :, :]
+            + self.linear_no_bias_s2(s_inputs)[..., None, :]
+        )
+        s_init = self.linear_no_bias_s_inputs(s_inputs)
+        s_trunk = torch.cat([s_init, s_trunk], dim=-1)
+        z_trunk = torch.cat([z_init, z_trunk], dim=-1)
+
+        s_trunk = self.linear_no_bias_s_cat(self.layernorm_no_bias_s_cat(s_trunk))
+        z_trunk = self.linear_no_bias_z_cat(self.layernorm_no_bias_z_cat(z_trunk))
+
+        if not self.training:
+            del z_init
+            torch.cuda.empty_cache()
+
+        x_rep_atom_mask = input_feature_dict[
+            "distogram_rep_atom_mask"
+        ].bool()  # [N_atom]
+        x_pred_rep_coords = x_pred_coords[..., x_rep_atom_mask, :]
+        N_sample = x_pred_rep_coords.size(-3)
+
+        plddt_preds, pae_preds, pde_preds, resolved_preds = [], [], [], []
+        for i in range(N_sample):
+            plddt_pred, pae_pred, pde_pred, resolved_pred = (
+                self.memory_efficient_forward(
+                    input_feature_dict=input_feature_dict,
+                    s_trunk=s_trunk,
+                    z_pair=z_trunk,
+                    pair_mask=pair_mask,
+                    x_pred_rep_coords=x_pred_rep_coords[..., i, :, :],
+                    use_memory_efficient_kernel=use_memory_efficient_kernel,
+                    use_deepspeed_evo_attention=use_deepspeed_evo_attention,
+                    use_lma=use_lma,
+                    inplace_safe=inplace_safe,
+                    chunk_size=chunk_size,
+                )
+            )
+            if z_trunk.shape[-2] > 2000 and (not self.training):
+                # cpu offload pae_preds/pde_preds
+                pae_pred = pae_pred.cpu()
+                pde_pred = pde_pred.cpu()
+                torch.cuda.empty_cache()
+            plddt_preds.append(plddt_pred)
+            pae_preds.append(pae_pred)
+            pde_preds.append(pde_pred)
+            resolved_preds.append(resolved_pred)
+        plddt_preds = torch.stack(
+            plddt_preds, dim=-3
+        )  # [..., N_sample, N_atom, plddt_bins]
+        # Pae_preds/pde_preds single tensor will occupy 11.6G[BF16]/23.2G[FP32]
+        pae_preds = torch.stack(
+            pae_preds, dim=-4
+        )  # [..., N_sample, N_token, N_token, pae_bins]
+        pde_preds = torch.stack(
+            pde_preds, dim=-4
+        )  # [..., N_sample, N_token, N_token, pde_bins]
+        resolved_preds = torch.stack(
+            resolved_preds, dim=-3
+        )  # [..., N_sample, N_atom, 2]
+        return plddt_preds, pae_preds, pde_preds, resolved_preds
+
+    def memory_efficient_forward(
+        self,
+        input_feature_dict: dict[str, Union[torch.Tensor, int, float, dict]],
+        s_trunk: torch.Tensor,
+        z_pair: torch.Tensor,
+        pair_mask: torch.Tensor,
+        x_pred_rep_coords: torch.Tensor,
+        use_memory_efficient_kernel: bool = False,
+        use_deepspeed_evo_attention: bool = False,
+        use_lma: bool = False,
+        inplace_safe: bool = False,
+        chunk_size: Optional[int] = None,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        """
+        Args:
+            ...
+            x_pred_coords (torch.Tensor): predicted coordinates
+                [..., N_atoms, 3] # Note: N_sample = 1 for avoiding CUDA OOM
+        """
+        # Embed pair distances of representative atoms:
+        distance_pred = cdist(
+            x_pred_rep_coords, x_pred_rep_coords
+        )  # [..., N_tokens, N_tokens]
+        z_pair = z_pair + self.linear_no_bias_d(
+            one_hot(
+                x=distance_pred, lower_bins=self.lower_bins, upper_bins=self.upper_bins
+            )
+        )  # [..., N_tokens, N_tokens, c_z]
+        # Line 4
+        s_single, z_pair = self.pairformer_stack(
+            s_trunk,
+            z_pair,
+            pair_mask,
+            use_memory_efficient_kernel=use_memory_efficient_kernel,
+            use_deepspeed_evo_attention=use_deepspeed_evo_attention,
+            use_lma=use_lma,
+            inplace_safe=inplace_safe,
+            chunk_size=chunk_size,
+        )
+
+        pae_pred = self.linear_no_bias_pae(self.pae_ln(z_pair))
+        pde_pred = self.linear_no_bias_pde(
+            self.pde_ln(z_pair + z_pair.transpose(-2, -3))
+        )
+
+        atom_to_token_idx = input_feature_dict[
+            "atom_to_token_idx"
+        ]  # in range [0, N_token-1] shape: [N_atom]
+        atom_to_tokatom_idx = input_feature_dict[
+            "atom_to_tokatom_idx"
+        ]  # in range [0, max_atoms_per_token-1] shape: [N_atom] # influenced by crop
+        # Broadcast s_single: [N_tokens, c_s] -> [N_atoms, c_s]
+        a = broadcast_token_to_atom(
+            x_token=s_single, atom_to_token_idx=atom_to_token_idx
+        )
+        plddt_pred = torch.einsum(
+            "...nc,ncb->...nb", self.plddt_ln(a), self.plddt_weight[atom_to_tokatom_idx]
+        )
+        resolved_pred = torch.einsum(
+            "...nc,ncb->...nb",
+            self.resolved_ln(a),
+            self.resolved_weight[atom_to_tokatom_idx],
+        )
+        if not self.training and z_pair.shape[-2] > 2000:
+            torch.cuda.empty_cache()
+        return plddt_pred, pae_pred, pde_pred, resolved_pred

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/model/modules/diffusion.py

@@ -0,0 +1,541 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional, Union
+
+import torch
+import torch.nn as nn
+
+from protenix.model.modules.embedders import FourierEmbedding, RelativePositionEncoding
+from protenix.model.modules.primitives import LinearNoBias, Transition
+from protenix.model.modules.transformer import (
+    AtomAttentionDecoder,
+    AtomAttentionEncoder,
+    DiffusionTransformer,
+)
+from protenix.model.utils import expand_at_dim
+from protenix.openfold_local.model.primitives import LayerNorm
+from protenix.openfold_local.utils.checkpointing import get_checkpoint_fn
+
+
+class DiffusionConditioning(nn.Module):
+    """
+    Implements Algorithm 21 in AF3
+    """
+
+    def __init__(
+        self,
+        sigma_data: float = 16.0,
+        c_z: int = 128,
+        c_s: int = 384,
+        c_s_inputs: int = 449,
+        c_noise_embedding: int = 256,
+    ) -> None:
+        """
+        Args:
+            sigma_data (torch.float, optional): the standard deviation of the data. Defaults to 16.0.
+            c_z (int, optional): hidden dim [for pair embedding]. Defaults to 128.
+            c_s (int, optional):  hidden dim [for single embedding]. Defaults to 384.
+            c_s_inputs (int, optional): input embedding dim from InputEmbedder. Defaults to 449.
+            c_noise_embedding (int, optional): noise embedding dim. Defaults to 256.
+        """
+        super(DiffusionConditioning, self).__init__()
+        self.sigma_data = sigma_data
+        self.c_z = c_z
+        self.c_s = c_s
+        self.c_s_inputs = c_s_inputs
+        # Line1-Line3:
+        self.relpe = RelativePositionEncoding(c_z=c_z)
+        self.layernorm_z = LayerNorm(2 * self.c_z)
+        self.linear_no_bias_z = LinearNoBias(
+            in_features=2 * self.c_z, out_features=self.c_z
+        )
+        # Line3-Line5:
+        self.transition_z1 = Transition(c_in=self.c_z, n=2)
+        self.transition_z2 = Transition(c_in=self.c_z, n=2)
+
+        # Line6-Line7
+        self.layernorm_s = LayerNorm(self.c_s + self.c_s_inputs)
+        self.linear_no_bias_s = LinearNoBias(
+            in_features=self.c_s + self.c_s_inputs, out_features=self.c_s
+        )
+        # Line8-Line9
+        self.fourier_embedding = FourierEmbedding(c=c_noise_embedding)
+        self.layernorm_n = LayerNorm(c_noise_embedding)
+        self.linear_no_bias_n = LinearNoBias(
+            in_features=c_noise_embedding, out_features=self.c_s
+        )
+        # Line10-Line12
+        self.transition_s1 = Transition(c_in=self.c_s, n=2)
+        self.transition_s2 = Transition(c_in=self.c_s, n=2)
+        print(f"Diffusion Module has {self.sigma_data}")
+
+    def forward(
+        self,
+        t_hat_noise_level: torch.Tensor,
+        input_feature_dict: dict[str, Union[torch.Tensor, int, float, dict]],
+        s_inputs: torch.Tensor,
+        s_trunk: torch.Tensor,
+        z_trunk: torch.Tensor,
+        inplace_safe: bool = False,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Args:
+            t_hat_noise_level (torch.Tensor): the noise level
+                [..., N_sample]
+            input_feature_dict (dict[str, Union[torch.Tensor, int, float, dict]]): input meta feature dict
+            s_inputs (torch.Tensor): single embedding from InputFeatureEmbedder
+                [..., N_tokens, c_s_inputs]
+            s_trunk (torch.Tensor): single feature embedding from PairFormer (Alg17)
+                [..., N_tokens, c_s]
+            z_trunk (torch.Tensor): pair feature embedding from PairFormer (Alg17)
+                [..., N_tokens, N_tokens, c_z]
+            inplace_safe (bool): Whether it is safe to use inplace operations.
+        Returns:
+            tuple[torch.Tensor, torch.Tensor]: embeddings s and z
+                - s (torch.Tensor): [..., N_sample, N_tokens, c_s]
+                - z (torch.Tensor): [..., N_tokens, N_tokens, c_z]
+        """
+        # Pair conditioning
+        pair_z = torch.cat(
+            tensors=[z_trunk, self.relpe(input_feature_dict)], dim=-1
+        )  # [..., N_tokens, N_tokens, 2*c_z]
+        pair_z = self.linear_no_bias_z(self.layernorm_z(pair_z))
+        if inplace_safe:
+            pair_z += self.transition_z1(pair_z)
+            pair_z += self.transition_z2(pair_z)
+        else:
+            pair_z = pair_z + self.transition_z1(pair_z)
+            pair_z = pair_z + self.transition_z2(pair_z)
+        # Single conditioning
+        single_s = torch.cat(
+            tensors=[s_trunk, s_inputs], dim=-1
+        )  # [..., N_tokens, c_s + c_s_inputs]
+        single_s = self.linear_no_bias_s(self.layernorm_s(single_s))
+        noise_n = self.fourier_embedding(
+            t_hat_noise_level=torch.log(input=t_hat_noise_level / self.sigma_data) / 4
+        ).to(
+            single_s.dtype
+        )  # [..., N_sample, c_in]
+        single_s = single_s.unsqueeze(dim=-3) + self.linear_no_bias_n(
+            self.layernorm_n(noise_n)
+        ).unsqueeze(
+            dim=-2
+        )  # [..., N_sample, N_tokens, c_s]
+        if inplace_safe:
+            single_s += self.transition_s1(single_s)
+            single_s += self.transition_s2(single_s)
+        else:
+            single_s = single_s + self.transition_s1(single_s)
+            single_s = single_s + self.transition_s2(single_s)
+        if not self.training and pair_z.shape[-2] > 2000:
+            torch.cuda.empty_cache()
+        return single_s, pair_z
+
+
+class DiffusionSchedule:
+    def __init__(
+        self,
+        sigma_data: float = 16.0,
+        s_max: float = 160.0,
+        s_min: float = 4e-4,
+        p: float = 7.0,
+        dt: float = 1 / 200,
+        p_mean: float = -1.2,
+        p_std: float = 1.5,
+    ) -> None:
+        """
+        Args:
+            sigma_data (float, optional): The standard deviation of the data. Defaults to 16.0.
+            s_max (float, optional): The maximum noise level. Defaults to 160.0.
+            s_min (float, optional): The minimum noise level. Defaults to 4e-4.
+            p (float, optional): The exponent for the noise schedule. Defaults to 7.0.
+            dt (float, optional): The time step size. Defaults to 1/200.
+            p_mean (float, optional): The mean of the log-normal distribution for noise level sampling. Defaults to -1.2.
+            p_std (float, optional): The standard deviation of the log-normal distribution for noise level sampling. Defaults to 1.5.
+        """
+        self.sigma_data = sigma_data
+        self.s_max = s_max
+        self.s_min = s_min
+        self.p = p
+        self.dt = dt
+        self.p_mean = p_mean
+        self.p_std = p_std
+        # self.T
+        self.T = int(1 / dt) + 1  # 201
+
+    def get_train_noise_schedule(self) -> torch.Tensor:
+        return self.sigma_data * torch.exp(self.p_mean + self.p_std * torch.randn(1))
+
+    def get_inference_noise_schedule(self) -> torch.Tensor:
+        time_step_lists = torch.arange(start=0, end=1 + 1e-10, step=self.dt)
+        inference_noise_schedule = (
+            self.sigma_data
+            * (
+                self.s_max ** (1 / self.p)
+                + time_step_lists
+                * (self.s_min ** (1 / self.p) - self.s_max ** (1 / self.p))
+            )
+            ** self.p
+        )
+        return inference_noise_schedule
+
+
+class DiffusionModule(nn.Module):
+    """
+    Implements Algorithm 20 in AF3
+    """
+
+    def __init__(
+        self,
+        sigma_data: float = 16.0,
+        c_atom: int = 128,
+        c_atompair: int = 16,
+        c_token: int = 768,
+        c_s: int = 384,
+        c_z: int = 128,
+        c_s_inputs: int = 449,
+        atom_encoder: dict[str, int] = {"n_blocks": 3, "n_heads": 4},
+        transformer: dict[str, int] = {"n_blocks": 24, "n_heads": 16},
+        atom_decoder: dict[str, int] = {"n_blocks": 3, "n_heads": 4},
+        blocks_per_ckpt: Optional[int] = None,
+        use_fine_grained_checkpoint: bool = False,
+        initialization: Optional[dict[str, Union[str, float, bool]]] = None,
+    ) -> None:
+        """
+        Args:
+            sigma_data (torch.float, optional): the standard deviation of the data. Defaults to 16.0.
+            c_atom (int, optional): embedding dim for atom feature. Defaults to 128.
+            c_atompair (int, optional): embedding dim for atompair feature. Defaults to 16.
+            c_token (int, optional): feature channel of token (single a). Defaults to 768.
+            c_s (int, optional):  hidden dim [for single embedding]. Defaults to 384.
+            c_z (int, optional): hidden dim [for pair embedding]. Defaults to 128.
+            c_s_inputs (int, optional): hidden dim [for single input embedding]. Defaults to 449.
+            atom_encoder (dict[str, int], optional): configs in AtomAttentionEncoder. Defaults to {"n_blocks": 3, "n_heads": 4}.
+            transformer (dict[str, int], optional): configs in DiffusionTransformer. Defaults to {"n_blocks": 24, "n_heads": 16}.
+            atom_decoder (dict[str, int], optional): configs in AtomAttentionDecoder. Defaults to {"n_blocks": 3, "n_heads": 4}.
+            blocks_per_ckpt: number of atom_encoder/transformer/atom_decoder blocks in each activation checkpoint
+                Size of each chunk. A higher value corresponds to fewer
+                checkpoints, and trades memory for speed. If None, no checkpointing is performed.
+            use_fine_grained_checkpoint: whether use fine-gained checkpoint for finetuning stage 2
+                only effective if blocks_per_ckpt is not None.
+            initialization: initialize the diffusion module according to initialization config.
+        """
+
+        super(DiffusionModule, self).__init__()
+        self.sigma_data = sigma_data
+        self.c_atom = c_atom
+        self.c_atompair = c_atompair
+        self.c_token = c_token
+        self.c_s_inputs = c_s_inputs
+        self.c_s = c_s
+        self.c_z = c_z
+
+        # Grad checkpoint setting
+        self.blocks_per_ckpt = blocks_per_ckpt
+        self.use_fine_grained_checkpoint = use_fine_grained_checkpoint
+
+        self.diffusion_conditioning = DiffusionConditioning(
+            sigma_data=self.sigma_data, c_z=c_z, c_s=c_s, c_s_inputs=c_s_inputs
+        )
+        self.atom_attention_encoder = AtomAttentionEncoder(
+            **atom_encoder,
+            c_atom=c_atom,
+            c_atompair=c_atompair,
+            c_token=c_token,
+            has_coords=True,
+            c_s=c_s,
+            c_z=c_z,
+            blocks_per_ckpt=blocks_per_ckpt,
+        )
+        # Alg20: line4
+        self.layernorm_s = LayerNorm(c_s)
+        self.linear_no_bias_s = LinearNoBias(in_features=c_s, out_features=c_token)
+        self.diffusion_transformer = DiffusionTransformer(
+            **transformer,
+            c_a=c_token,
+            c_s=c_s,
+            c_z=c_z,
+            blocks_per_ckpt=blocks_per_ckpt,
+        )
+        self.layernorm_a = LayerNorm(c_token)
+        self.atom_attention_decoder = AtomAttentionDecoder(
+            **atom_decoder,
+            c_token=c_token,
+            c_atom=c_atom,
+            c_atompair=c_atompair,
+            blocks_per_ckpt=blocks_per_ckpt,
+        )
+        self.init_parameters(initialization)
+
+    def init_parameters(self, initialization: dict):
+        """
+        Initializes the parameters of the diffusion module according to the provided initialization configuration.
+
+        Args:
+            initialization (dict): A dictionary containing initialization settings.
+        """
+        if initialization.get("zero_init_condition_transition", False):
+            self.diffusion_conditioning.transition_z1.zero_init()
+            self.diffusion_conditioning.transition_z2.zero_init()
+            self.diffusion_conditioning.transition_s1.zero_init()
+            self.diffusion_conditioning.transition_s2.zero_init()
+
+        self.atom_attention_encoder.linear_init(
+            zero_init_atom_encoder_residual_linear=initialization.get(
+                "zero_init_atom_encoder_residual_linear", False
+            ),
+            he_normal_init_atom_encoder_small_mlp=initialization.get(
+                "he_normal_init_atom_encoder_small_mlp", False
+            ),
+            he_normal_init_atom_encoder_output=initialization.get(
+                "he_normal_init_atom_encoder_output", False
+            ),
+        )
+
+        if initialization.get("glorot_init_self_attention", False):
+            for (
+                block
+            ) in (
+                self.atom_attention_encoder.atom_transformer.diffusion_transformer.blocks
+            ):
+                block.attention_pair_bias.glorot_init()
+
+        for block in self.diffusion_transformer.blocks:
+            if initialization.get("zero_init_adaln", False):
+                block.attention_pair_bias.layernorm_a.zero_init()
+                block.conditioned_transition_block.adaln.zero_init()
+            if initialization.get("zero_init_residual_condition_transition", False):
+                nn.init.zeros_(
+                    block.conditioned_transition_block.linear_nobias_b.weight
+                )
+
+        if initialization.get("zero_init_atom_decoder_linear", False):
+            nn.init.zeros_(self.atom_attention_decoder.linear_no_bias_a.weight)
+
+        if initialization.get("zero_init_dit_output", False):
+            nn.init.zeros_(self.atom_attention_decoder.linear_no_bias_out.weight)
+
+    def f_forward(
+        self,
+        r_noisy: torch.Tensor,
+        t_hat_noise_level: torch.Tensor,
+        input_feature_dict: dict[str, Union[torch.Tensor, int, float, dict]],
+        s_inputs: torch.Tensor,
+        s_trunk: torch.Tensor,
+        z_trunk: torch.Tensor,
+        inplace_safe: bool = False,
+        chunk_size: Optional[int] = None,
+    ) -> torch.Tensor:
+        """The raw network to be trained.
+        As in EDM equation (7), this is F_theta(c_in * x, c_noise(sigma)).
+        Here, c_noise(sigma) is computed in Conditioning module.
+
+        Args:
+            r_noisy (torch.Tensor): scaled x_noisy (i.e., c_in * x)
+                [..., N_sample, N_atom, 3]
+            t_hat_noise_level (torch.Tensor): the noise level, as well as the time step t
+                [..., N_sample]
+            input_feature_dict (dict[str, Union[torch.Tensor, int, float, dict]]): input feature
+            s_inputs (torch.Tensor): single embedding from InputFeatureEmbedder
+                [..., N_tokens, c_s_inputs]
+            s_trunk (torch.Tensor): single feature embedding from PairFormer (Alg17)
+                [..., N_tokens, c_s]
+            z_trunk (torch.Tensor): pair feature embedding from PairFormer (Alg17)
+                [..., N_tokens, N_tokens, c_z]
+            inplace_safe (bool): Whether it is safe to use inplace operations. Defaults to False.
+            chunk_size (Optional[int]): Chunk size for memory-efficient operations. Defaults to None.
+
+        Returns:
+            torch.Tensor: coordinates update
+                [..., N_sample, N_atom, 3]
+        """
+        N_sample = r_noisy.size(-3)
+        assert t_hat_noise_level.size(-1) == N_sample
+
+        blocks_per_ckpt = self.blocks_per_ckpt
+        if not torch.is_grad_enabled():
+            blocks_per_ckpt = None
+        # Conditioning, shared across difference samples
+        # Diffusion_conditioning consumes 7-8G when token num is 768,
+        # use checkpoint here if blocks_per_ckpt is not None.
+        if blocks_per_ckpt:
+            checkpoint_fn = get_checkpoint_fn()
+            s_single, z_pair = checkpoint_fn(
+                self.diffusion_conditioning,
+                t_hat_noise_level,
+                input_feature_dict,
+                s_inputs,
+                s_trunk,
+                z_trunk,
+                inplace_safe,
+            )
+        else:
+            s_single, z_pair = self.diffusion_conditioning(
+                t_hat_noise_level=t_hat_noise_level,
+                input_feature_dict=input_feature_dict,
+                s_inputs=s_inputs,
+                s_trunk=s_trunk,
+                z_trunk=z_trunk,
+                inplace_safe=inplace_safe,
+            )  # [..., N_sample, N_token, c_s], [..., N_token, N_token, c_z]
+
+        # Expand embeddings to match N_sample
+        s_trunk = expand_at_dim(
+            s_trunk, dim=-3, n=N_sample
+        )  # [..., N_sample, N_token, c_s]
+        z_pair = expand_at_dim(
+            z_pair, dim=-4, n=N_sample
+        )  # [..., N_sample, N_token, N_token, c_z]
+        # Fine-grained checkpoint for finetuning stage 2 (token num: 768) for avoiding OOM
+        if blocks_per_ckpt and self.use_fine_grained_checkpoint:
+            checkpoint_fn = get_checkpoint_fn()
+            a_token, q_skip, c_skip, p_skip = checkpoint_fn(
+                self.atom_attention_encoder,
+                input_feature_dict,
+                r_noisy,
+                s_trunk,
+                z_pair,
+                inplace_safe,
+                chunk_size,
+            )
+        else:
+            # Sequence-local Atom Attention and aggregation to coarse-grained tokens
+            a_token, q_skip, c_skip, p_skip = self.atom_attention_encoder(
+                input_feature_dict=input_feature_dict,
+                r_l=r_noisy,
+                s=s_trunk,
+                z=z_pair,
+                inplace_safe=inplace_safe,
+                chunk_size=chunk_size,
+            )
+        # Full self-attention on token level.
+        if inplace_safe:
+            a_token += self.linear_no_bias_s(
+                self.layernorm_s(s_single)
+            )  # [..., N_sample, N_token, c_token]
+        else:
+            a_token = a_token + self.linear_no_bias_s(
+                self.layernorm_s(s_single)
+            )  # [..., N_sample, N_token, c_token]
+        a_token = self.diffusion_transformer(
+            a=a_token,
+            s=s_single,
+            z=z_pair,
+            inplace_safe=inplace_safe,
+            chunk_size=chunk_size,
+        )
+
+        a_token = self.layernorm_a(a_token)
+
+        # Fine-grained checkpoint for finetuning stage 2 (token num: 768) for avoiding OOM
+        if blocks_per_ckpt and self.use_fine_grained_checkpoint:
+            checkpoint_fn = get_checkpoint_fn()
+            r_update = checkpoint_fn(
+                self.atom_attention_decoder,
+                input_feature_dict,
+                a_token,
+                q_skip,
+                c_skip,
+                p_skip,
+                inplace_safe,
+                chunk_size,
+            )
+        else:
+            # Broadcast token activations to atoms and run Sequence-local Atom Attention
+            r_update = self.atom_attention_decoder(
+                input_feature_dict=input_feature_dict,
+                a=a_token,
+                q_skip=q_skip,
+                c_skip=c_skip,
+                p_skip=p_skip,
+                inplace_safe=inplace_safe,
+                chunk_size=chunk_size,
+            )
+
+        return r_update
+
+    def forward(
+        self,
+        x_noisy: torch.Tensor,
+        t_hat_noise_level: torch.Tensor,
+        input_feature_dict: dict[str, Union[torch.Tensor, int, float, dict]],
+        s_inputs: torch.Tensor,
+        s_trunk: torch.Tensor,
+        z_trunk: torch.Tensor,
+        inplace_safe: bool = False,
+        chunk_size: Optional[int] = None,
+    ) -> torch.Tensor:
+        """One step denoise: x_noisy, noise_level -> x_denoised
+
+        Args:
+            x_noisy (torch.Tensor): the noisy version of the input atom coords
+                [..., N_sample, N_atom,3]
+            t_hat_noise_level (torch.Tensor): the noise level, as well as the time step t
+                [..., N_sample]
+            input_feature_dict (dict[str, Union[torch.Tensor, int, float, dict]]): input meta feature dict
+            s_inputs (torch.Tensor): single embedding from InputFeatureEmbedder
+                [..., N_tokens, c_s_inputs]
+            s_trunk (torch.Tensor): single feature embedding from PairFormer (Alg17)
+                [..., N_tokens, c_s]
+            z_trunk (torch.Tensor): pair feature embedding from PairFormer (Alg17)
+                [..., N_tokens, N_tokens, c_z]
+            inplace_safe (bool): Whether it is safe to use inplace operations. Defaults to False.
+            chunk_size (Optional[int]): Chunk size for memory-efficient operations. Defaults to None.
+
+        Returns:
+            torch.Tensor: the denoised coordinates of x
+                [..., N_sample, N_atom,3]
+        """
+        # Scale positions to dimensionless vectors with approximately unit variance
+        # As in EDM:
+        #     r_noisy = (c_in * x_noisy)
+        #     where c_in = 1 / sqrt(sigma_data^2 + sigma^2)
+        r_noisy = (
+            x_noisy
+            / torch.sqrt(self.sigma_data**2 + t_hat_noise_level**2)[..., None, None]
+        )
+
+        # Compute the update given r_noisy (the scaled x_noisy)
+        # As in EDM:
+        #     r_update = F(r_noisy, c_noise(sigma))
+        r_update = self.f_forward(
+            r_noisy=r_noisy,
+            t_hat_noise_level=t_hat_noise_level,
+            input_feature_dict=input_feature_dict,
+            s_inputs=s_inputs,
+            s_trunk=s_trunk,
+            z_trunk=z_trunk,
+            inplace_safe=inplace_safe,
+            chunk_size=chunk_size,
+        )
+
+        # Rescale updates to positions and combine with input positions
+        # As in EDM:
+        #     D = c_skip * x_noisy + c_out * r_update
+        #     c_skip = sigma_data^2 / (sigma_data^2 + sigma^2)
+        #     c_out = (sigma_data * sigma) / sqrt(sigma_data^2 + sigma^2)
+        #     s_ratio = sigma / sigma_data
+        #     c_skip = 1 / (1 + s_ratio^2)
+        #     c_out = sigma / sqrt(1 + s_ratio^2)
+
+        s_ratio = (t_hat_noise_level / self.sigma_data)[..., None, None].to(
+            r_update.dtype
+        )
+        x_denoised = (
+            1 / (1 + s_ratio**2) * x_noisy
+            + t_hat_noise_level[..., None, None] / torch.sqrt(1 + s_ratio**2) * r_update
+        ).to(r_update.dtype)
+
+        return x_denoised

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/model/modules/embedders.py

@@ -0,0 +1,256 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any, Optional, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from protenix.model.modules.primitives import LinearNoBias
+from protenix.model.modules.transformer import AtomAttentionEncoder
+
+
+class InputFeatureEmbedder(nn.Module):
+    """
+    Implements Algorithm 2 in AF3
+    """
+
+    def __init__(
+        self,
+        c_atom: int = 128,
+        c_atompair: int = 16,
+        c_token: int = 384,
+    ) -> None:
+        """
+        Args:
+            c_atom (int, optional): atom embedding dim. Defaults to 128.
+            c_atompair (int, optional): atom pair embedding dim. Defaults to 16.
+            c_token (int, optional): token embedding dim. Defaults to 384.
+        """
+        super(InputFeatureEmbedder, self).__init__()
+        self.c_atom = c_atom
+        self.c_atompair = c_atompair
+        self.c_token = c_token
+        self.atom_attention_encoder = AtomAttentionEncoder(
+            c_atom=c_atom,
+            c_atompair=c_atompair,
+            c_token=c_token,
+            has_coords=False,
+        )
+        # Line2
+        self.input_feature = {"restype": 32, "profile": 32, "deletion_mean": 1}
+
+    def forward(
+        self,
+        input_feature_dict: dict[str, Any],
+        inplace_safe: bool = False,
+        chunk_size: Optional[int] = None,
+    ) -> torch.Tensor:
+        """
+        Args:
+            input_feature_dict (Dict[str, Any]): dict of input features
+            inplace_safe (bool): Whether it is safe to use inplace operations. Defaults to False.
+            chunk_size (Optional[int]): Chunk size for memory-efficient operations. Defaults to None.
+
+        Returns:
+            torch.Tensor: token embedding
+                [..., N_token, 384 (c_token) + 32 + 32 + 1 :=449]
+        """
+        # Embed per-atom features.
+        a, _, _, _ = self.atom_attention_encoder(
+            input_feature_dict=input_feature_dict,
+            inplace_safe=inplace_safe,
+            chunk_size=chunk_size,
+        )  # [..., N_token, c_token]
+        # Concatenate the per-token features.
+        batch_shape = input_feature_dict["restype"].shape[:-1]
+        s_inputs = torch.cat(
+            [a]
+            + [
+                input_feature_dict[name].reshape(*batch_shape, d)
+                for name, d in self.input_feature.items()
+            ],
+            dim=-1,
+        )
+        return s_inputs
+
+
+class RelativePositionEncoding(nn.Module):
+    """
+    Implements Algorithm 3 in AF3
+    """
+
+    def __init__(self, r_max: int = 32, s_max: int = 2, c_z: int = 128) -> None:
+        """
+        Args:
+            r_max (int, optional): Relative position indices clip value. Defaults to 32.
+            s_max (int, optional): Relative chain indices clip value. Defaults to 2.
+            c_z (int, optional): hidden dim [for pair embedding]. Defaults to 128.
+        """
+        super(RelativePositionEncoding, self).__init__()
+        self.r_max = r_max
+        self.s_max = s_max
+        self.c_z = c_z
+        self.linear_no_bias = LinearNoBias(
+            in_features=(4 * self.r_max + 2 * self.s_max + 7), out_features=self.c_z
+        )
+        self.input_feature = {
+            "asym_id": 1,
+            "residue_index": 1,
+            "entity_id": 1,
+            "sym_id": 1,
+            "token_index": 1,
+        }
+
+    def forward(self, input_feature_dict: dict[str, Any]) -> torch.Tensor:
+        """
+        Args:
+            input_feature_dict (Dict[str, Any]): input meta feature dict.
+            asym_id / residue_index / entity_id / sym_id / token_index
+                [..., N_tokens]
+        Returns:
+            torch.Tensor: relative position encoding
+                [..., N_token, N_token, c_z]
+        """
+        b_same_chain = (
+            input_feature_dict["asym_id"][..., :, None]
+            == input_feature_dict["asym_id"][..., None, :]
+        ).long()  # [..., N_token, N_token]
+        b_same_residue = (
+            input_feature_dict["residue_index"][..., :, None]
+            == input_feature_dict["residue_index"][..., None, :]
+        ).long()  # [..., N_token, N_token]
+        b_same_entity = (
+            input_feature_dict["entity_id"][..., :, None]
+            == input_feature_dict["entity_id"][..., None, :]
+        ).long()  # [..., N_token, N_token]
+        d_residue = torch.clip(
+            input=input_feature_dict["residue_index"][..., :, None]
+            - input_feature_dict["residue_index"][..., None, :]
+            + self.r_max,
+            min=0,
+            max=2 * self.r_max,
+        ) * b_same_chain + (1 - b_same_chain) * (
+            2 * self.r_max + 1
+        )  # [..., N_token, N_token]
+        a_rel_pos = F.one_hot(d_residue, 2 * (self.r_max + 1))
+        d_token = torch.clip(
+            input=input_feature_dict["token_index"][..., :, None]
+            - input_feature_dict["token_index"][..., None, :]
+            + self.r_max,
+            min=0,
+            max=2 * self.r_max,
+        ) * b_same_chain * b_same_residue + (1 - b_same_chain * b_same_residue) * (
+            2 * self.r_max + 1
+        )  # [..., N_token, N_token]
+        a_rel_token = F.one_hot(d_token, 2 * (self.r_max + 1))
+        d_chain = torch.clip(
+            input=input_feature_dict["sym_id"][..., :, None]
+            - input_feature_dict["sym_id"][..., None, :]
+            + self.s_max,
+            min=0,
+            max=2 * self.s_max,
+        ) * b_same_entity + (1 - b_same_entity) * (
+            2 * self.s_max + 1
+        )  # [..., N_token, N_token]
+        a_rel_chain = F.one_hot(d_chain, 2 * (self.s_max + 1))
+
+        if self.training:
+            p = self.linear_no_bias(
+                torch.cat(
+                    [a_rel_pos, a_rel_token, b_same_entity[..., None], a_rel_chain],
+                    dim=-1,
+                ).float()
+            )  # [..., N_token, N_token, 2 * (self.r_max + 1)+ 2 * (self.r_max + 1)+ 1 + 2 * (self.s_max + 1)] -> [..., N_token, N_token, c_z]
+            return p
+        else:
+            del d_chain, d_token, d_residue, b_same_chain, b_same_residue
+            origin_shape = a_rel_pos.shape[:-1]
+            Ntoken = a_rel_pos.shape[-2]
+            a_rel_pos = a_rel_pos.reshape(-1, a_rel_pos.shape[-1])
+            chunk_num = 1 if Ntoken < 3200 else 8
+            a_rel_pos_chunks = torch.chunk(
+                a_rel_pos.reshape(-1, a_rel_pos.shape[-1]), chunk_num, dim=-2
+            )
+            a_rel_token_chunks = torch.chunk(
+                a_rel_token.reshape(-1, a_rel_token.shape[-1]), chunk_num, dim=-2
+            )
+            b_same_entity_chunks = torch.chunk(
+                b_same_entity.reshape(-1, 1), chunk_num, dim=-2
+            )
+            a_rel_chain_chunks = torch.chunk(
+                a_rel_chain.reshape(-1, a_rel_chain.shape[-1]), chunk_num, dim=-2
+            )
+            start = 0
+            p = None
+            for i in range(len(a_rel_pos_chunks)):
+                data = torch.cat(
+                    [
+                        a_rel_pos_chunks[i],
+                        a_rel_token_chunks[i],
+                        b_same_entity_chunks[i],
+                        a_rel_chain_chunks[i],
+                    ],
+                    dim=-1,
+                ).float()
+                result = self.linear_no_bias(data)
+                del data
+                if p is None:
+                    p = torch.empty(
+                        (a_rel_pos.shape[-2], self.c_z),
+                        device=a_rel_pos.device,
+                        dtype=result.dtype,
+                    )
+                p[start : start + result.shape[0]] = result
+                start += result.shape[0]
+                del result
+            del a_rel_pos, a_rel_token, b_same_entity, a_rel_chain
+            p = p.reshape(*origin_shape, -1)
+            return p
+
+
+class FourierEmbedding(nn.Module):
+    """
+    Implements Algorithm 22 in AF3
+    """
+
+    def __init__(self, c: int, seed: int = 42) -> None:
+        """
+        Args:
+            c (int): embedding dim.
+        """
+        super(FourierEmbedding, self).__init__()
+        self.c = c
+        self.seed = seed
+        generator = torch.Generator()
+        generator.manual_seed(seed)
+        w_value = torch.randn(size=(c,), generator=generator)
+        self.w = nn.Parameter(w_value, requires_grad=False)
+        b_value = torch.randn(size=(c,), generator=generator)
+        self.b = nn.Parameter(b_value, requires_grad=False)
+
+    def forward(self, t_hat_noise_level: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            t_hat_noise_level (torch.Tensor): the noise level
+                [..., N_sample]
+
+        Returns:
+            torch.Tensor: the output fourier embedding
+                [..., N_sample, c]
+        """
+        return torch.cos(
+            input=2 * torch.pi * (t_hat_noise_level.unsqueeze(dim=-1) * self.w + self.b)
+        )

benchmarks/FoldBench/algorithms/Protenix/Protenix/protenix/model/modules/frames.py

@@ -0,0 +1,108 @@
+# Copyright 2024 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+import torch.nn.functional as F
+
+from protenix.model.utils import batched_gather
+
+
+def expressCoordinatesInFrame(
+    coordinate: torch.Tensor, frames: torch.Tensor, eps: float = 1e-8
+) -> torch.Tensor:
+    """Algorithm 29 Express coordinate in frame
+
+    Args:
+        coordinate (torch.Tensor): the input coordinate
+            [..., N_atom, 3]
+        frames (torch.Tensor): the input frames
+            [..., N_frame, 3, 3]
+        eps (float): Small epsilon value
+
+    Returns:
+        torch.Tensor: the transformed coordinate projected onto frame basis
+            [..., N_frame, N_atom, 3]
+    """
+    # Extract frame atoms
+    a, b, c = torch.unbind(frames, dim=-2)  # a, b, c shape: [..., N_frame, 3]
+    w1 = F.normalize(a - b, dim=-1, eps=eps)
+    w2 = F.normalize(c - b, dim=-1, eps=eps)
+    # Build orthonormal basis
+    e1 = F.normalize(w1 + w2, dim=-1, eps=eps)
+    e2 = F.normalize(w2 - w1, dim=-1, eps=eps)
+    e3 = torch.cross(e1, e2, dim=-1)  # [..., N_frame, 3]
+    # Project onto frame basis
+    d = coordinate[..., None, :, :] - b[..., None, :]  #  [..., N_frame, N_atom, 3]
+    x_transformed = torch.cat(
+        [
+            torch.sum(d * e1[..., None, :], dim=-1, keepdim=True),
+            torch.sum(d * e2[..., None, :], dim=-1, keepdim=True),
+            torch.sum(d * e3[..., None, :], dim=-1, keepdim=True),
+        ],
+        dim=-1,
+    )  # [..., N_frame, N_atom, 3]
+    return x_transformed
+
+
+def gather_frame_atom_by_indices(
+    coordinate: torch.Tensor, frame_atom_index: torch.Tensor, dim: int = -2
+) -> torch.Tensor:
+    """construct frames from coordinate
+
+    Args:
+        coordinate (torch.Tensor):  the input coordinate
+            [..., N_atom, 3]
+        frame_atom_index (torch.Tensor): indices of three atoms in each frame
+            [..., N_frame, 3] or [N_frame, 3]
+        dim (torch.Tensor): along which dimension to select the frame atoms
+    Returns:
+        torch.Tensor: the constructed frames
+            [..., N_frame, 3[three atom], 3[three coordinate]]
+    """
+    if len(frame_atom_index.shape) == 2:
+        # the navie case
+        x1 = torch.index_select(
+            coordinate, dim=dim, index=frame_atom_index[:, 0]
+        )  # [..., N_frame, 3]
+        x2 = torch.index_select(
+            coordinate, dim=dim, index=frame_atom_index[:, 1]
+        )  # [..., N_frame, 3]
+        x3 = torch.index_select(
+            coordinate, dim=dim, index=frame_atom_index[:, 2]
+        )  # [..., N_frame, 3]
+        return torch.stack([x1, x2, x3], dim=dim)
+    else:
+        assert (
+            frame_atom_index.shape[:dim] == coordinate.shape[:dim]
+        ), "batch size dims should match"
+
+    x1 = batched_gather(
+        data=coordinate,
+        inds=frame_atom_index[..., 0],
+        dim=dim,
+        no_batch_dims=len(coordinate.shape[:dim]),
+    )  # [..., N_frame, 3]
+    x2 = batched_gather(
+        data=coordinate,
+        inds=frame_atom_index[..., 1],
+        dim=dim,
+        no_batch_dims=len(coordinate.shape[:dim]),
+    )  # [..., N_frame, 3]
+    x3 = batched_gather(
+        data=coordinate,
+        inds=frame_atom_index[..., 2],
+        dim=dim,
+        no_batch_dims=len(coordinate.shape[:dim]),
+    )  # [..., N_frame, 3]
+    return torch.stack([x1, x2, x3], dim=dim)