Upload folder using huggingface_hub

.flake8

@@ -0,0 +1,59 @@
+# originally from: https://github.com/pytorch/pytorch/blob/main/.flake8
+[flake8]
+# NOTE: **Mirror any changes** to this file the [tool.ruff] config in pyproject.toml
+# before we can fully move to use ruff
+enable-extensions = G
+select = B,C,E,F,G,P,SIM1,SIM911,T4,W,B9,TOR0,TOR1,TOR2,TOR9
+max-line-length = 120
+# C408 ignored because we like the dict keyword argument syntax
+# E501 is not flexible enough, we're using B950 instead
+ignore =
+    E203,E305,E402,E501,E704,E721,E741,F405,F824,F841,F999,W503,W504,C408,E302,W291,E303,
+    # shebang has extra meaning in fbcode lints, so I think it's not worth trying
+    # to line this up with executable bit
+    EXE001,
+    # these ignores are from flake8-bugbear; please fix!
+    B007,B008,B017,B019,B023,B028,B903,B904,B905,B906,B907
+    # these ignores are from flake8-comprehensions; please fix!
+    C407,
+    # these ignores are from flake8-logging-format; please fix!
+    G100,G101,G200
+    # these ignores are from flake8-simplify. please fix or ignore with commented reason
+    SIM105,SIM108,SIM110,SIM111,SIM113,SIM114,SIM115,SIM116,SIM117,SIM118,SIM119,SIM12,
+    # flake8-simplify code styles
+    SIM102,SIM103,SIM106,SIM112,
+
+per-file-ignores =
+    __init__.py: F401
+    test/**: F821
+    test/**/__init__.py: F401,F821
+    torch/utils/cpp_extension.py: B950
+    torchgen/api/types/__init__.py: F401,F403
+    torchgen/executorch/api/types/__init__.py: F401,F403
+    test/dynamo/test_higher_order_ops.py: B950
+    test/dynamo/test_graph_break_messages.py: B950
+    torch/testing/_internal/dynamo_test_failures.py: B950
+    # TOR901 is only for test, we want to ignore it for everything else.
+    # It's not easy to configure this without affecting other per-file-ignores,
+    # so we explicitly list every file where it's violated outside of test.
+    torch/__init__.py: F401,TOR901
+    torch/_custom_op/impl.py: TOR901
+    torch/_export/serde/upgrade.py: TOR901
+    torch/_functorch/vmap.py: TOR901
+    torch/_inductor/test_operators.py: TOR901
+    torch/_library/abstract_impl.py: TOR901
+    torch/_meta_registrations.py: TOR901
+    torch/_prims/__init__.py: F401,TOR901
+    torch/_prims/rng_prims.py: TOR901
+    torch/ao/quantization/fx/_decomposed.py: TOR901
+    torch/distributed/_functional_collectives.py: TOR901
+    torch/distributed/_spmd/data_parallel.py: TOR901
+    torch/distributed/_tensor/_collective_utils.py: TOR901
+    # This is a full package that happen to live within the test
+    # folder, so ok to skip
+    test/cpp_extensions/open_registration_extension/pytorch_openreg/_aten_impl.py: TOR901
+optional-ascii-coding = True
+exclude =
+    ./.git,
+    ./venv,
+    *.pyi

.gitattributes

@@ -57,3 +57,5 @@ 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
+Protenix_Technical_Report.pdf filter=lfs diff=lfs merge=lfs -text
+af3-dev/release/clusters-by-entity-40.txt filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,146 @@
+# Byte-compiled / optimized / DLL files
+*__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+*.o
+*.obj
+*.d
+# ninjia relate
+*ninja*
+lock
+# Distribution / packaging
+.Python
+.vscode
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# data cache and checkpoints
+data_cache/
+checkpoints/
+
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+wandb/
+output/
+release_data/
+
+coord/
+ModelGenerator/
+protenix_1d_embeddings/
+protenix_3d_embeddings/
+second_stage/
+training_json/
+examples/

.pre-commit-config.yaml

@@ -0,0 +1,51 @@
+# originally from: https://github.com/pytorch/torchtune/blob/main/.pre-commit-config.yaml
+exclude: 'build'
+
+default_language_version:
+    python: python3
+
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: check-ast
+    -   id: check-merge-conflict
+    -   id: no-commit-to-branch
+        args: ['--branch=main']
+    -   id: check-added-large-files
+        args: ['--maxkb=1000']
+    -   id: end-of-file-fixer
+        exclude: '^(.*\.svg)$'
+
+-   repo: https://github.com/Lucas-C/pre-commit-hooks
+    rev: v1.5.5
+    hooks:
+    -   id: insert-license
+        files: \.py$|\.sh$
+        args:
+        - --license-filepath
+        - assets/license_header.txt
+
+-   repo: https://github.com/pycqa/flake8
+    rev: 7.1.1
+    hooks:
+    -   id: flake8
+        additional_dependencies:
+          - flake8-bugbear == 22.4.25
+          - pep8-naming == 0.12.1
+          - torchfix
+        args: ['--config=.flake8']
+
+-   repo: https://github.com/omnilib/ufmt
+    rev: v2.3.0
+    hooks:
+    -   id: ufmt
+        additional_dependencies:
+          - black == 22.12.0
+          - usort == 1.0.5
+
+- repo: https://github.com/jsh9/pydoclint
+  rev: d88180a8632bb1602a4d81344085cf320f288c5a
+  hooks:
+    - id: pydoclint

CODE_OF_CONDUCT.md

@@ -0,0 +1,127 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

CONTRIBUTING.md

@@ -0,0 +1,61 @@
+# Contributing
+
+Thank you for investing your time in contributing to protenix project! 
+
+Read our [Code of Conduct](./CODE_OF_CONDUCT.md) to keep our community approachable and respectable.
+
+This guide details how to use issues and pull requests to improve protenix project.
+
+## General Guidelines
+
+### Pull Requests
+
+Make sure to keep Pull Requests small and functional to make them easier to review, understand, and look up in commit history. This repository uses "Squash and Commit" to keep our history clean and make it easier to revert changes based on PR.
+
+Adding the appropriate documentation, unit tests and e2e tests as part of a feature is the responsibility of the feature owner, whether it is done in the same Pull Request or not.
+
+Pull Requests should follow the "subject: message" format, where the subject describes what part of the code is being modified.
+
+Refer to the template for more information on what goes into a PR description.
+
+### Design Docs
+
+A contributor proposes a design with a PR on the repository to allow for revisions and discussions. If a design needs to be discussed before formulating a document for it, make use of Google doc and GitHub issue to involve the community on the discussion. 
+
+### GitHub Issues
+
+GitHub Issues are used to file bugs, work items, and feature requests with actionable items/issues (Please refer to the "Reporting Bugs/Feature Requests" section below for more information).
+
+### Reporting Bugs/Feature Requests
+
+We welcome you to use the GitHub issue tracker to report bugs or suggest features that have actionable items/issues (as opposed to introducing a feature request on GitHub Discussions).
+
+When filing an issue, please check existing open, or recently closed, issues to make sure somebody else hasn't already reported the issue. Please try to include as much information as you can. Details like these are incredibly useful:
+
+- A reproducible test case or series of steps
+- The version of the code being used
+- Any modifications you've made relevant to the bug
+- Anything unusual about your environment or deployment
+
+## Contributing via Pull Requests
+
+### Find interesting issue
+
+If you spot a problem with the problem, [search if an issue already exists](https://github.com/bytedance/protenix/issues). If a related issue doesn't exist, you can open a new issue using [issue template](https://github.com/bytedance/protenix/issues/new/choose). 
+
+### Solve an issue
+
+Please check `DEVELOPMENT.md` in sub folder to get familiar with running and testing codes.
+
+### Open a Pull request.
+
+When you're done making the changes, open a pull request and fill PR template so we can better review your PR. The template helps reviewers understand your changes and the purpose of your pull request. 
+
+Don't forget to link PR to the issue if you are solving one.
+
+If you run into any merge issues, checkout this [git tutorial](https://lab.github.com/githubtraining/managing-merge-conflicts) to help you resolve merge conflicts and other issues.
+
+
+## Finding contributions to work on
+
+Looking at the existing issues is a great way to find something to contribute on. As our projects, by default, use the default GitHub issue labels (enhancement/bug/duplicate/help wanted/invalid/question/wontfix), looking at any 'help wanted' and 'good first issue' issues are a great place to start.

Dockerfile

@@ -0,0 +1,56 @@
+FROM ai4s-cn-beijing.cr.volces.com/pytorch-mirror/pytorch:2.3.1-cuda12.1-cudnn8-devel
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV TZ=Asia/Shanghai
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    wget \
+    g++ \
+    gcc \
+    libc6-dev \
+    make zlib1g zlib1g-dev \
+    git git-lfs expect zsh vim wget curl unzip zip cmake cmake-curses-gui libgdbm-dev libnss3-dev libssl-dev libreadline-dev libffi-dev \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/* 
+
+RUN apt update && apt -y install postgresql
+
+RUN DEBIAN_FRONTEND=noninteractive apt-get install --no-install-recommends -y \
+        hmmer cmake cmake-curses-gui   \
+    && git clone --branch v3.3.0 https://github.com/soedinglab/hh-suite.git /tmp/hh-suite \
+    && mkdir /tmp/hh-suite/build \
+    && cd /tmp/hh-suite/build \
+    && cmake -DCMAKE_INSTALL_PREFIX=/opt/hhsuite .. \
+    && make -j 32 && make install \
+    && ln -s /opt/hhsuite/bin/* /usr/bin \
+    && cd - \
+    && rm -rf /tmp/hh-suite
+
+RUN apt-get install -yq --no-install-recommends iproute2 curl
+# Add PIP Package
+RUN pip3 --no-cache-dir install \
+    scipy \
+    ml_collections \
+    tqdm \
+    pandas \
+    optree \
+    rdkit
+
+# Add openfold dependency
+RUN pip3 --no-cache-dir install \
+    biopython==1.83 \
+    modelcif==0.7 
+  
+# Add datapipeline dependency
+RUN pip3 --no-cache-dir install \
+    biotite==1.0.1 \
+    scikit-learn \
+    scikit-learn-extra \
+    fair-esm \
+    deepspeed \
+    protobuf==3.20.2 tos icecream ipdb wandb numpy==1.26.3 matplotlib==3.9.2 ipywidgets py3Dmol
+
+# For H20 compatibility
+RUN pip3 install --no-cache-dir nvidia-cublas-cu12==12.4.5.8 --no-deps
+RUN git clone  -b v3.5.1 https://github.com/NVIDIA/cutlass.git  /opt/cutlass
+ENV CUTLASS_PATH=/opt/cutlass

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.

Protenix_Technical_Report.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b4150ea75c2772c27e8fb64153434b568850bd724ac22d47cc73158737e3ee44
+size 3586577

README.md

@@ -1,3 +1,309 @@
----
-license: apache-2.0
----
+# Protenix: Protein + X
+
+
+> 📣📣📣 **We're hiring!** \
+> Positions in **_Beijing, China_** and **_Seattle, US_** ! \
+> Interested in machine learning, computational chemistry/biology, structural biology, or drug discovery?  \
+> 👉 [**Join us »**](#join-us)
+
+
+
+<div align="center" style="margin: 20px 0;">
+  <span style="margin: 0 10px;">⚡ <a href="https://protenix-server.com">Protenix Web Server</a></span>
+  &bull; <span style="margin: 0 10px;">📄 <a href="https://www.biorxiv.org/content/10.1101/2025.01.08.631967v1">Technical Report</a></span>
+</div>
+
+<div align="center">
+
+[![Twitter](https://img.shields.io/badge/Twitter-Follow-blue?logo=x)](https://x.com/ai4s_protenix)
+[![Slack](https://img.shields.io/badge/Slack-Join-yellow?logo=slack)](https://join.slack.com/t/protenixworkspace/shared_invite/zt-36j4kx1cy-GyQMWLDrMO4Wd0fjGxtxug)
+[![Wechat](https://img.shields.io/badge/Wechat-Join-brightgreen?logo=wechat)](https://github.com/bytedance/Protenix/issues/52)
+[![Email](https://img.shields.io/badge/Email-Contact-lightgrey?logo=gmail)](#contact-us)
+</div>
+
+We’re excited to introduce **Protenix** — a trainable, open-source PyTorch reproduction of [AlphaFold 3](https://www.nature.com/articles/s41586-024-07487-w).
+
+Protenix is built for high-accuracy structure prediction. It serves as an initial step in our journey toward advancing accessible and extensible research tools for the computational biology community.
+
+
+
+![Protenix predictions](assets/protenix_predictions.gif)
+
+## 🌟 Related Projects
+- **[PXMeter](https://github.com/bytedance/PXMeter/)** is an open-source toolkit designed for reproducible evaluation of structure prediction models, released with high-quality benchmark dataset that has been manually reviewed to remove experimental artifacts and non-biological interactions. The associated study presents an in-depth comparative analysis of state-of-the-art models, drawing insights from extensive metric data and detailed case studies. The evaluation of Protenix is based on PXMeter.
+- **[Protenix-Dock](https://github.com/bytedance/Protenix-Dock)**: Our implementation of a classical protein-ligand docking framework that leverages empirical scoring functions. Without using deep neural networks, Protenix-Dock delivers competitive performance in rigid docking tasks.
+
+## 🎉 Updates
+- 2025-07-17: **Protenix-Mini released!**: Lightweight model variants with significantly reduced inference cost are now available. Users can choose from multiple configurations to balance speed and accuracy based on deployment needs. See our [paper](https://arxiv.org/abs/2507.11839) and [model configs](./configs/configs_model_type.py) for more information. 
+- 2025-07-17: [***New constraint feature***](docs/infer_json_format.md#constraint) is released! Now supports **atom-level contact** and **pocket** constraints, significantly improving performance in our evaluations.
+- 2025-05-30: **Protenix-v0.5.0** is now available! You may try Protenix-v0.5.0 by accessing the [server](https://protenix-server.com), or upgrade to the latest version using pip.
+- 2025-01-16: The preview version of **constraint feature** is released to branch [`constraint_esm`](https://github.com/bytedance/Protenix/tree/constraint_esm).
+- 2025-01-16: The [training data pipeline](./docs/prepare_training_data.md) is released.
+- 2025-01-16: The [MSA pipeline](./docs/msa_pipeline.md) is released.
+- 2025-01-16: Use [local colabfold_search](./docs/colabfold_compatible_msa.md) to generate protenix-compatible MSA.
+
+### 📊 Benchmark
+We benchmarked the performance of Protenix-v0.5.0 against [Boltz-1](https://github.com/jwohlwend/boltz/releases/tag/v0.4.1) and [Chai-1](https://github.com/chaidiscovery/chai-lab/releases/tag/v0.6.1) across multiple datasets, including [PoseBusters v2](https://arxiv.org/abs/2308.05777), [AF3 Nucleic Acid Complexes](https://www.nature.com/articles/s41586-024-07487-w), [AF3 Antibody Set](https://github.com/google-deepmind/alphafold3/blob/20ad0a21eb49febcaad4a6f5d71aa6b701512e5b/docs/metadata_antibody_antigen.csv), and our curated Recent PDB set.
+<!-- 1️⃣ [PoseBusters v2](https://arxiv.org/abs/2308.05777)\
+2️⃣ [AF3 Nucleic Acid Complexes](https://www.nature.com/articles/s41586-024-07487-w)\
+3️⃣ [AF3 Antibody Set](https://github.com/google-deepmind/alphafold3/blob/20ad0a21eb49febcaad4a6f5d71aa6b701512e5b/docs/metadata_antibody_antigen.csv)\
+4️⃣ Our curated Recent PDB set -->
+
+Protenix-v0.5.0 was trained using a PDB cut-off date of September 30, 2021. For the comparative analysis, we adhered to AF3’s inference protocol, generating 25 predictions by employing 5 model seeds, with each seed yielding 5 diffusion samples. The predictions were subsequently ranked based on their respective ranking scores.
+
+
+![V0.5.0 model Metrics](assets/v0.5.0_metrics.png)
+
+We will soon release the benchmarking toolkit, including the evaluation datasets, data curation pipeline, and metric calculators, to support transparent and reproducible benchmarking.
+
+
+## 🛠 Installation
+
+### PyPI
+
+```bash
+pip3 install protenix
+```
+
+For development on a CPU-only machine, it is convenient to install with the `--cpu` flag in editable mode:
+```
+python3 setup.py develop --cpu
+```
+
+### Docker (Recommended for Training)
+
+Check the detailed guide: [<u> Docker Installation</u>](docs/docker_installation.md).
+
+
+## 🚀 Inference
+
+### Expected Input & Output Format
+For details on the input JSON format and expected outputs, please refer to the [Input/Output Documentation](docs/infer_json_format.md).
+
+
+### Prepare Inputs
+
+#### Convert PDB/CIF File to Input JSON
+
+If your input is a `.pdb` or `.cif` file, you can convert it into a JSON file for inference.
+
+
+```bash
+# ensure `release_data/ccd_cache/components.cif` or run:
+python scripts/gen_ccd_cache.py -c release_data/ccd_cache/ -n [num_cpu]
+
+# for PDB
+# download pdb file
+wget https://files.rcsb.org/download/7pzb.pdb
+# run with pdb/cif file, and convert it to json file for inference.
+protenix tojson --input examples/7pzb.pdb --out_dir ./output
+
+# for CIF (same process)
+# download cif file
+wget https://files.rcsb.org/download/7pzb.cif
+# run with pdb/cif file, and convert it to json file for inference.
+protenix tojson --input examples/7pzb.cif --out_dir ./output
+```
+
+
+#### (Optional) Prepare MSA Files
+
+We provide an independent MSA search utility. You can run it using either a JSON file or a protein FASTA file.
+```bash
+# run msa search with json file, it will write precomputed msa dir info to a new json file.
+protenix msa --input examples/example_without_msa.json --out_dir ./output
+
+# run msa search with fasta file which only contains protein.
+protenix msa --input examples/prot.fasta --out_dir ./output
+```
+
+### Inference via Command Line
+
+If you installed `Protenix` via `pip`, you can run the following command to perform model inference:
+
+
+```bash
+# 1. The default model_name is protenix_base_default_v0.5.0, you can modify it by passing --model_name xxxx
+# 2. We provide recommended default configuration parameters for each model. To customize cycle/step/use_msa settings, you must set --use_default_params false
+# 3. You can modify cycle/step/use_msa by passing --cycle x1 --step x2 --use_msa false
+
+# run with example.json, which contains precomputed msa dir.
+protenix predict --input examples/example.json --out_dir  ./output --seeds 101 --model_name "protenix_base_default_v0.5.0"
+
+# run with example.json, we use only esm feature.
+protenix predict --input examples/example.json --out_dir  ./output --seeds 101 --model_name "protenix_mini_esm_v0.5.0" --use_msa false
+
+# run with multiple json files, the default seed is 101.
+protenix predict --input ./jsons_dir/ --out_dir  ./output
+
+# if the json do not contain precomputed msa dir,
+# add --use_msa (default: true) to search msa and then predict.
+# if mutiple seeds are provided, split them by comma.
+protenix predict --input examples/example_without_msa.json --out_dir ./output --seeds 101,102 --use_msa true
+```
+
+### Inference via Bash Script
+Alternatively you can run inference by:
+Alternatively, run inference via script:
+
+```bash
+bash inference_demo.sh
+```
+
+The script accepts the following arguments:
+* `model_name`: Name of the model to use for inference.
+* `input_json_path`: Path to a JSON file that fully specifies the input structure.
+* `dump_dir`: Directory where inference results will be saved.
+* `dtype`: Data type used during inference. Supported options: `bf16` and `fp32`.
+* `use_msa`: Whether to enable MSA features (default: true).
+
+
+> **Note**: By default, layernorm and EvoformerAttention kernels are disabled for simplicity.
+> To enable them and speed up inference, see the [**Kernels Setup Guide**](docs/kernels.md).
+
+
+## 🧬 Training
+
+Refer to the [Training Documentation](docs/training.md) for setup and details.
+
+## Model Features
+###  📌 Constraint
+
+Protenix supports specifying ***contacts*** (at both residue and atom levels) and ***pocket constraints*** as extra guidance. Our benchmark results demonstrate that constraint-guided predictions are significantly more accurate.See our [doc](docs/infer_json_format.md#constraint) for input format details.
+
+![Constraint Metrics](assets/constraint_metrics.png)
+
+###  📌 Mini-Models
+We introduce Protenix-Mini, a lightweight variant of Protenix that uses reduced network blocks and few ODE steps (even as few as one or two steps) to enable efficient prediction of biomolecular complex structures. Experimental results show that Protenix-Mini achieves a favorable balance between efficiency and accuracy, with only a marginal 1–5% drop in evaluation metrics such as interface LDDT, complex LDDT, and ligand RMSD success rate. Protenix-Mini enables accurate structure prediction in high-throughput and resource-limited scenarios, making it well-suited for practical applications at scale. The following comparisons were performed on a subset of the RecentPDB dataset comprising sequences with fewer than 768 tokens.
+
+![Mini/Tiny Metrics](assets/mini_performance.png)
+
+
+## Training and Inference Cost
+
+For details on memory usage and runtime during training and inference, refer to the [Training & Inference Cost Documentation](docs/model_train_inference_cost.md).
+
+
+## Citing Protenix
+
+If you use Protenix in your research, please cite the following:
+
+```
+@article{bytedance2025protenix,
+  title={Protenix - Advancing Structure Prediction Through a Comprehensive AlphaFold3 Reproduction},
+  author={ByteDance AML AI4Science Team and Chen, Xinshi and Zhang, Yuxuan and Lu, Chan and Ma, Wenzhi and Guan, Jiaqi and Gong, Chengyue and Yang, Jincai and Zhang, Hanyu and Zhang, Ke and Wu, Shenghao and Zhou, Kuangqi and Yang, Yanping and Liu, Zhenyu and Wang, Lan and Shi, Bo and Shi, Shaochen and Xiao, Wenzhi},
+  year={2025},
+  journal={bioRxiv},
+  publisher={Cold Spring Harbor Laboratory},
+  doi={10.1101/2025.01.08.631967},
+  URL={https://www.biorxiv.org/content/early/2025/01/11/2025.01.08.631967},
+  elocation-id={2025.01.08.631967},
+  eprint={https://www.biorxiv.org/content/early/2025/01/11/2025.01.08.631967.full.pdf},
+}
+```
+
+### 📚 Citing Related Work
+Protenix is built upon and inspired by several influential projects. If you use Protenix in your research, we also encourage citing the following foundational works where appropriate:
+```
+@article{abramson2024accurate,
+  title={Accurate structure prediction of biomolecular interactions with AlphaFold 3},
+  author={Abramson, Josh and Adler, Jonas and Dunger, Jack and Evans, Richard and Green, Tim and Pritzel, Alexander and Ronneberger, Olaf and Willmore, Lindsay and Ballard, Andrew J and Bambrick, Joshua and others},
+  journal={Nature},
+  volume={630},
+  number={8016},
+  pages={493--500},
+  year={2024},
+  publisher={Nature Publishing Group UK London}
+}
+@article{ahdritz2024openfold,
+  title={OpenFold: Retraining AlphaFold2 yields new insights into its learning mechanisms and capacity for generalization},
+  author={Ahdritz, Gustaf and Bouatta, Nazim and Floristean, Christina and Kadyan, Sachin and Xia, Qinghui and Gerecke, William and O’Donnell, Timothy J and Berenberg, Daniel and Fisk, Ian and Zanichelli, Niccol{\`o} and others},
+  journal={Nature Methods},
+  volume={21},
+  number={8},
+  pages={1514--1524},
+  year={2024},
+  publisher={Nature Publishing Group US New York}
+}
+@article{mirdita2022colabfold,
+  title={ColabFold: making protein folding accessible to all},
+  author={Mirdita, Milot and Sch{\"u}tze, Konstantin and Moriwaki, Yoshitaka and Heo, Lim and Ovchinnikov, Sergey and Steinegger, Martin},
+  journal={Nature methods},
+  volume={19},
+  number={6},
+  pages={679--682},
+  year={2022},
+  publisher={Nature Publishing Group US New York}
+}
+```
+
+## Contributing to Protenix
+
+We welcome contributions from the community to help improve Protenix!
+
+📄 Check out the [Contributing Guide](CONTRIBUTING.md) to get started.
+
+✅ Code Quality: 
+We use `pre-commit` hooks to ensure consistency and code quality. Please install them before making commits:
+
+```bash
+pip install pre-commit
+pre-commit install
+```
+
+🐞 Found a bug or have a feature request? [Open an issue](https://github.com/bytedance/Protenix/issues).
+
+
+
+## Acknowledgements
+
+
+The implementation of LayerNorm operators refers to both [OneFlow](https://github.com/Oneflow-Inc/oneflow) and [FastFold](https://github.com/hpcaitech/FastFold).
+We also adopted several [module](protenix/openfold_local/) implementations from [OpenFold](https://github.com/aqlaboratory/openfold), except for [`LayerNorm`](protenix/model/layer_norm/), which is implemented independently.
+
+
+## Code of Conduct
+
+We are committed to fostering a welcoming and inclusive environment.
+Please review our [Code of Conduct](CODE_OF_CONDUCT.md) for guidelines on how to participate respectfully.
+
+
+## Security
+
+If you discover a potential security issue in this project, or think you may
+have discovered a security issue, we ask that you notify Bytedance Security via our [security center](https://security.bytedance.com/src) or [vulnerability reporting email]([email protected]).
+
+Please do **not** create a public GitHub issue.
+
+## License
+
+The Protenix project including both code and model parameters is released under the [Apache 2.0 License](./LICENSE). It is free for both academic research and commercial use.
+
+## Contact Us
+
+We welcome inquiries and collaboration opportunities for advanced applications of our model, such as developing new features, fine-tuning for specific use cases, and more. Please feel free to contact us at [email protected].
+
+## Join Us
+
+We're expanding the **Protenix team** at ByteDance Seed-AI for Science! \
+We’re looking for talented individuals in **machine learning** and **computational biology/chemistry**. Opportunities are available in both **Beijing** and **Seattle**, across internships, new grad roles, and experienced full-time positions. \
+*“Computational Biology/Chemistry” covers structural biology, computational biology, computational chemistry, drug discovery, and more.*
+
+
+### 📍 Beijing, China
+| Type       | Expertise                          | Apply Link |
+|------------|------------------------------------|------------|
+| Full-Time  | Computational Biology / Chemistry       | [Experienced & New Grad](https://jobs.bytedance.com/society/position/detail/7505998274429421842) |
+| Full-Time  | Machine Learning                   | [Experienced & New Grad](https://jobs.bytedance.com/society/position/detail/7505999453133015314) |
+| Internship | Computational Biology / Chemistry       | [Internship](https://jobs.bytedance.com/campus/position/7509005072577546504/detail) |
+| Internship | Machine Learning                   | [Internship](https://jobs.bytedance.com/campus/position/7509005074018961672/detail) |
+
+
+### 📍 Seattle, US
+
+| Type       | Expertise                          | Apply Link |
+|------------|------------------------------------|------------|
+| Full-Time  | Computational Biology / Chemistry       | [Experienced](https://jobs.bytedance.com/en/position/7270666468370614585/detail), [New Grad](https://jobs.bytedance.com/en/position/7515465250054211847/detail) |
+| Full-Time  | Machine Learning                   | [Experienced](https://jobs.bytedance.com/en/position/7270665658072926521/detail), [New Grad](https://jobs.bytedance.com/en/position/7515908698011601159/detail) |
+| Internship | Computational Biology / Chemistry       | Internship (opening ~August) |
+| Internship | Machine Learning                   | Internship (opening ~August) |

af3-dev/release/clusters-by-entity-40.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1ab4af905e75b382eda8dec59917dc3608bee0729e36b9e71baf860bbe86850c
+size 21699572

assets/license_header.txt

@@ -0,0 +1,13 @@
+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.

configs/configs_base.py

@@ -0,0 +1,395 @@
+# 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,
+    "finetune_params_with_substring": [
+        ""
+    ],  # params with substring will be finetuned with different learning rate: finetune_optim_configs["lr"]
+    "eval_only": False,
+    "load_checkpoint_path": "",
+    "load_ema_checkpoint_path": "",
+    "load_strict": True,
+    "load_params_only": True,
+    "skip_load_step": False,
+    "skip_load_optimizer": False,
+    "skip_load_scheduler": False,
+    "load_step_for_scheduler": False,
+    "train_confidence_only": False,
+    "use_wandb": True,
+    "wandb_id": "",
+    "seed": 42,
+    "deterministic": False,
+    "deterministic_seed": False,
+    "ema_decay": -1.0,
+    "eval_ema_only": False,  # whether wandb only tracking ema checkpoint metrics
+    "ema_mutable_param_keywords": [""],
+    "model_name": "protenix_base_default_v0.5.0",  # train model name
+}
+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,
+    "esm": {
+        "enable": False,
+        "model_name": "esm2-3b",
+        "embedding_dim": 2560,
+    },
+}
+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"),
+    },
+}
+# Fine-tuned optimizer settings.
+# For models supporting structural constraints and ESM embeddings.
+finetune_optim_configs = {
+    # Optim
+    "lr": 0.0018,
+    "lr_scheduler": "cosine_annealing",
+    "warmup_steps": 1000,
+    "max_steps": 20000,
+    "min_lr_ratio": 0.1,
+    "decay_every_n_steps": 50000,
+}
+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,
+        "condition_embedding_drop_rate": 0.0,
+        "confidence_embedding_drop_rate": 0.0,
+        "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"),
+            "msa_chunk_size": ValueMaybeNone(2048),
+        },
+        # Optional constraint embedder, only used when constraint is enabled.
+        "constraint_embedder": {
+            "pocket_embedder": {
+                "enable": False,
+                "c_s_input": 3,
+                "c_z_input": 1,
+            },
+            "contact_embedder": {
+                "enable": False,
+                "c_z_input": 2,
+            },
+            "substructure_embedder": {
+                "enable": False,
+                "n_classes": 4,
+                "architecture": "transformer",
+                "hidden_dim": 128,
+                "n_layers": 1,
+            },
+            "contact_atom_embedder": {
+                "enable": False,
+                "c_z_input": 2,
+            },
+            "c_constraint_z": GlobalConfigValue("c_z"),
+            "c_constraint_s": GlobalConfigValue("c_s_inputs"),
+            "c_constraint_atom_pair": GlobalConfigValue("c_atompair"),
+            "initialize_method": "zero",  # zero, kaiming
+        },
+        "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"),
+            "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,
+}
+configs["finetune"] = finetune_optim_configs

configs/configs_data.py

@@ -0,0 +1,279 @@
+# 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"),
+    "constraint": {
+        "enable": False,
+        "fix_seed": False,  # True means use use the same contact in each evaluation.
+    },
+}
+
+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"),
+    # If enabled, the training settings for different constraint types,
+    # providing the model a certain proportion of constraints
+    # that meet specific conditions.
+    "constraint": {
+        "enable": False,
+        "fix_seed": False,
+        "pocket": {
+            "prob": 0.0,
+            "size": 1 / 3,
+            "spec_binder_chain": False,
+            "max_distance_range": {"PP": ListValue([6, 20]), "LP": ListValue([6, 20])},
+            "group": "complex",
+            "distance_type": "center_atom",
+        },
+        "contact": {
+            "prob": 0.0,
+            "size": 1 / 3,
+            "max_distance_range": {
+                "PP": ListValue([6, 30]),
+                "PL": ListValue([4, 10]),
+            },
+            "group": "complex",
+            "distance_type": "center_atom",
+        },
+        "substructure": {
+            "prob": 0.0,
+            "size": 0.8,
+            "mol_type_pairs": {
+                "PP": 15,
+                "PL": 10,
+                "LP": 10,
+            },
+            "feature_type": "one_hot",
+            "ratios": {
+                "full": [
+                    0.0,
+                    0.5,
+                    1.0,
+                ],  # ratio options of full chain substructure constraint
+                "partial": 0.3,  # ratio of partial chain substructure constraint
+            },
+            "coord_noise_scale": 0.05,
+            "spec_asym_id": False,
+        },
+        "contact_atom": {
+            "prob": 0.0,
+            "size": 1 / 3,
+            "max_distance_range": {
+                "PP": ListValue([2, 12]),
+                "PL": ListValue([2, 8]),
+            },
+            "min_distance": -1,
+            "group": "complex",
+            "distance_type": "atom",
+            "feature_type": "continuous",
+        },
+    },
+}
+
+DATA_ROOT_DIR = os.environ.get("PROTENIX_DATA_ROOT_DIR", "/af3-dev/release_data/")
+
+# Use CCD cache created by scripts/gen_ccd_cache.py priority. (without date in filename)
+# See: docs/prepare_data.md
+CCD_COMPONENTS_FILE_PATH = os.path.join(DATA_ROOT_DIR, "components.cif")
+CCD_COMPONENTS_RDKIT_MOL_FILE_PATH = os.path.join(
+    DATA_ROOT_DIR, "components.cif.rdkit_mol.pkl"
+)
+
+if (not os.path.exists(CCD_COMPONENTS_FILE_PATH)) or (
+    not os.path.exists(CCD_COMPONENTS_RDKIT_MOL_FILE_PATH)
+):
+    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"
+    )
+PDB_CLUSTER_FILE_PATH = os.path.join(DATA_ROOT_DIR, "clusters-by-entity-40.txt")
+
+
+# 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.cif")
+    CCD_COMPONENTS_RDKIT_MOL_FILE_PATH = os.path.join(
+        data_cache_dir, "components.cif.rdkit_mol.pkl"
+    )
+    if (not os.path.exists(CCD_COMPONENTS_FILE_PATH)) or (
+        not os.path.exists(CCD_COMPONENTS_RDKIT_MOL_FILE_PATH)
+    ):
+
+        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": 1,
+        },
+        "max_size": {
+            "train": 16384,
+            "test": 16384,
+        },
+        "sample_cutoff": {
+            "train": 16384,
+            "test": 16384,
+        },
+    },
+    "template": {
+        "enable": False,
+    },
+    "ccd_components_file": CCD_COMPONENTS_FILE_PATH,
+    "ccd_components_rdkit_mol_file": CCD_COMPONENTS_RDKIT_MOL_FILE_PATH,
+    "pdb_cluster_file": PDB_CLUSTER_FILE_PATH,
+}

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.5.0.pt"
+inference_configs = {
+    "model_name": "protenix_base_default_v0.5.0",  # inference model selection
+    "seeds": ListValue([101]),
+    "dump_dir": "./output",
+    "need_atom_confidence": False,
+    "sorted_by_ranking_score": True,
+    "input_json_path": RequiredValue(str),
+    "load_checkpoint_dir": os.path.join(code_directory, "./release_data/checkpoint/"),
+    "num_workers": 16,
+    "use_msa": True,
+}

configs/configs_model_type.py

@@ -0,0 +1,236 @@
+# 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.
+
+# model configs for inference and training,
+# such as: protenix-base, protenix-mini, protenix-tiny, protenix-constraint.
+# protenix_{model_size}_{features}_{version}
+# model_size: base, mini, tiny
+# features: default, constraint, esm, etc, if multiple split by "-"
+# version: v{x}.{y}.{z}
+
+"""
+Currently, the model_name support the following models.
+
+|           Model Name                |    ESM/MSA/Constraint    | Model Parameters(M ) |
+|-------------------------------------|--------------------------|----------------------|
+| `protenix_base_default_v0.5.0`      |      ❌ / ✅ / ❌         |         368.09       |
+| `protenix_base_constraint_v0.5.0`   |      ❌ / ✅ / ✅         |         368.30       |
+| `protenix_mini_esm_v0.5.0`          |      ✅ / ✅ / ❌         |         135.22       |
+| `protenix_mini_ism_v0.5.0`          |      ✅ / ✅ / ❌         |         135.22       |
+| `protenix_mini_default_v0.5.0`      |      ❌ / ✅ / ❌         |         134.06       |
+| `protenix_tiny_detault_v0.5.0`      |      ❌ / ✅ / ❌         |         109.50       |
+"""
+model_configs = {
+    "protenix_base_default_v0.5.0": {
+        "model": {"N_cycle": 10},
+        "sample_diffusion": {
+            "N_step": 200,
+        },  # the default setting for base model
+    },
+    "protenix_base_constraint_v0.5.0": {
+        "model": {
+            "sample_diffusion": {
+                "N_step": 200,
+            },  # the default setting for constraint model
+            "N_cycle": 10,
+            "constraint_embedder": {
+                "pocket_embedder": {
+                    "enable": True,
+                },
+                "contact_embedder": {
+                    "enable": True,
+                },
+                "substructure_embedder": {
+                    "enable": True,
+                },
+                "contact_atom_embedder": {
+                    "enable": True,
+                },
+            },
+        },
+        "data": {
+            "weightedPDB_before2109_wopb_nometalc_0925": {
+                "constraint": {
+                    "enable": True,
+                    "pocket": {
+                        "prob": 0.2,
+                        "max_distance_range": {
+                            "PP": [4, 15],
+                            "LP": [3, 10],
+                        },
+                    },
+                    "contact": {
+                        "prob": 0.1,
+                    },
+                    "substructure": {
+                        "prob": 0.5,
+                        "size": 1,
+                        "coord_noise_scale": 1,
+                    },
+                    "contact_atom": {
+                        "prob": 0.1,
+                        "max_distance_range": {
+                            "PP": [2, 12],
+                            "PL": [2, 15],
+                        },
+                        "min_distance": -1,
+                        "group": "complex",
+                        "distance_type": "atom",
+                        "feature_type": "continuous",
+                    },
+                },
+            },
+            "recentPDB_1536_sample384_0925": {
+                "constraint": {
+                    "enable": True,
+                },
+            },
+            "posebusters_0925": {
+                "constraint": {
+                    "enable": True,
+                },
+            },
+        },
+        "load_strict": False,  # If finetuning from base model, model arch has been changed,
+        # it should be False, for inference, it should be True.
+        "finetune_params_with_substring": [
+            "constraint_embedder.substructure_z_embedder",
+            "constraint_embedder.pocket_z_embedder",
+            "constraint_embedder.contact_z_embedder",
+            "constraint_embedder.contact_atom_z_embedder",
+        ],
+    },
+    "protenix_mini_default_v0.5.0": {
+        "sample_diffusion": {
+            "gamma0": 0,
+            "step_scale_eta": 1.0,
+            "N_step": 5,
+        },  # the default setting for mini model
+        "model": {
+            "N_cycle": 4,
+            "msa_module": {
+                "n_blocks": 1,
+            },
+            "pairformer": {
+                "n_blocks": 16,
+            },
+            "diffusion_module": {
+                "atom_encoder": {
+                    "n_blocks": 1,
+                },
+                "transformer": {
+                    "n_blocks": 8,
+                },
+                "atom_decoder": {
+                    "n_blocks": 1,
+                },
+            },
+        },
+        "load_strict": False,  # For inference, it should be True.
+    },
+    "protenix_tiny_default_v0.5.0": {
+        "sample_diffusion": {
+            "gamma0": 0,
+            "step_scale_eta": 1.0,
+            "N_step": 5,
+        },  # the default setting for tiny model
+        "model": {
+            "N_cycle": 4,
+            "msa_module": {
+                "n_blocks": 1,
+            },
+            "pairformer": {
+                "n_blocks": 8,
+            },
+            "diffusion_module": {
+                "atom_encoder": {
+                    "n_blocks": 1,
+                },
+                "transformer": {
+                    "n_blocks": 8,
+                },
+                "atom_decoder": {
+                    "n_blocks": 1,
+                },
+            },
+        },
+        "load_strict": False,  # For inference, it should be True.
+    },
+    "protenix_mini_esm_v0.5.0": {
+        "sample_diffusion": {
+            "gamma0": 0,
+            "step_scale_eta": 1.0,
+            "N_step": 5,
+        },  # the default setting for mini model
+        "model": {
+            "N_cycle": 4,
+            "msa_module": {
+                "n_blocks": 1,
+            },
+            "pairformer": {
+                "n_blocks": 16,
+            },
+            "diffusion_module": {
+                "atom_encoder": {
+                    "n_blocks": 1,
+                },
+                "transformer": {
+                    "n_blocks": 8,
+                },
+                "atom_decoder": {
+                    "n_blocks": 1,
+                },
+            },
+        },
+        "esm": {
+            "enable": True,
+            "model_name": "esm2-3b",
+        },
+        "load_strict": False,  # For inference, it should be True.
+        "use_msa": False,  # For efficiency, this model does not use MSA by default.
+    },
+    "protenix_mini_ism_v0.5.0": {
+        "sample_diffusion": {
+            "gamma0": 0,
+            "step_scale_eta": 1.0,
+            "N_step": 5,
+        },  # the default setting for mini model
+        "model": {
+            "N_cycle": 4,
+            "msa_module": {
+                "n_blocks": 1,
+            },
+            "pairformer": {
+                "n_blocks": 16,
+            },
+            "diffusion_module": {
+                "atom_encoder": {
+                    "n_blocks": 1,
+                },
+                "transformer": {
+                    "n_blocks": 8,
+                },
+                "atom_decoder": {
+                    "n_blocks": 1,
+                },
+            },
+        },
+        "esm": {
+            "enable": True,
+            "model_name": "esm2-3b-ism",
+        },
+        "load_strict": False,  # For inference, it should be True.
+        "use_msa": False,  # For efficiency, this model does not use MSA by default.
+    },
+}

debug.py

@@ -0,0 +1,4 @@
+import torch
+
+data = torch.load('/home/hui007/Protenix/protenix_1d_embeddings/1EG0-0-M.pt')
+print(data)

docs/colabfold_compatible_msa.md

@@ -0,0 +1,33 @@
+### Using Local Colabfold_search to Generate Protenix-Compatible MSA
+
+Colabfold provides an easy-to-use and efficient MSA search pipeline that's ideal for generating MSAs during inference. Unfortunately, this pipeline cannot fully match Protenix's MSA search process designed for training, as the current `colabfold_search` omits species information in the MSA, preventing correct pairing by Protenix's data pipeline. To address this issue, we provide the `scripts/colabfold_msa.py` script, which post-processes `colabfold_search` results by adding pseudo taxonomy IDs to paired MSAs to match Protenix's data pipeline.
+
+Here's an example:
+```bash
+python3 scripts/colabfold_msa.py examples/dimer.fasta <path/to/colabfold_db> dimer_colabfold_msa --db1 uniref30_2103_db --db3 colabfold_envdb_202108_db --mmseqs_path <path/to/mmseqs> 
+```
+
+#### Configuring Colabfold_search
+Installation of colabfold and mmseqs2 is required.
+
+colabfold can be installed with: `pip install colabfold[alphafold]`. 
+
+Build MMseqs2 from source:
+
+```bash
+wget https://github.com/soedinglab/MMseqs2/archive/refs/tags/16-747c6.tar.gz
+tar xzf 16-747c6.tar.gz 
+cd MMseqs2-16-747c6/
+mkdir build && cd build
+cmake -DCMAKE_BUILD_TYPE=RELEASE -DCMAKE_INSTALL_PREFIX=. ..
+make -j8
+make install
+```
+
+Download ColabFold database:
+```bash
+git clone https://github.com/sokrypton/ColabFold.git
+cd ColabFold
+# Configure database:
+MMSEQS_NO_INDEX=1 ./setup_databases.sh <path/to/colabfold_db>
+```

docs/docker_installation.md

@@ -0,0 +1,30 @@
+### Run with Docker
+
+1. Install Docker (with GPU Support)
+
+    Ensure that Docker is installed and configured with GPU support. Follow these steps:
+    *  Install [Docker](https://www.docker.com/) if not already installed.
+    *  Install the [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html) to enable GPU support.
+    *  Verify the setup with:
+        ```bash
+        docker run --rm --gpus all nvidia/cuda:12.1.0-base-ubuntu22.04 nvidia-smi
+        ```
+        
+2. Pull the Docker image, which was built based on this [Dockerfile](../Dockerfile)
+    ```bash
+    docker pull ai4s-cn-beijing.cr.volces.com/infra/protenix:v0.0.3
+    ```
+
+3. Clone this repository and `cd` into it
+    ```bash
+    git clone https://github.com/bytedance/protenix.git 
+    cd ./protenix
+    pip install -e .
+    ```
+
+4. Run Docker with an interactive shell
+    ```bash
+    docker run --gpus all -it -v $(pwd):/workspace -v /dev/shm:/dev/shm ai4s-cn-beijing.cr.volces.com/infra/protenix:v0.0.3 /bin/bash
+    ```
+  
+  After running above commands, you’ll be inside the container’s environment and can execute commands as you would on a normal Linux terminal.

docs/infer_json_format.md

@@ -0,0 +1,329 @@
+### Format of the input JSON file
+The JSON file format closely resembles that used by the AlphaFold Server, with a few key differences:
+
+1. There are no restrictions on the types of ligands, ions, and modifications, whereas the AlphaFold Server currently supports only a limited set of specific CCD codes.
+2. Users can specify bonds between entities, such as covalent bonds between ligands and polymers.
+3. It supports inputting ligands in the form of SMILES strings or molecular structure files.
+4. Ligands composed of multiple CCD codes can be treated as a single entity. This feature is useful for representing glycans, for example, "NAG-NAG".
+5. The "glycans" field is no longer supported. Glycans can be fully represented by inputting multiple ligands with defined bonding or by providing their SMILES strings.
+
+Here is an overview of the JSON file format:
+```json
+[ 
+  {
+    "name": "Test Fold Job Number One",
+    "sequences": [...],
+    "covalent_bonds": [...]
+  }
+]
+```
+The JSON file consists of a list of dictionaries, where each dictionary represents a set of sequences you want to model. 
+Even if you are modeling only one set of sequences, the top-level structure should still be a list.
+
+Each dictionary contains the following three keys:
+* `name`: A string representing the name of the inference job.
+* `sequences`: A list of dictionaries that describe the entities (e.g., proteins, DNA, RNA, small molecules, and ions) involved in the inference.
+* `covalent_bonds`: An optional list of dictionaries that define the covalent bonds between atoms from different entities.
+
+Details of `sequences` and `covalent_bonds` are provided below.
+
+#### sequences
+There are 5 kinds of supported sequences:
+*   `proteinChain` – used for proteins
+*   `dnaSequence` – used for DNA (single strand)
+*   `rnaSequence` – used for RNA (single strand)
+*   `ligand` – used for ligands
+*   `ion` – used for ions
+
+##### proteinChain
+```json
+{
+  "proteinChain": {
+    "sequence": "PREACHINGS", 
+    "count": 1,
+    "modifications": [
+      {
+        "ptmType": "CCD_HY3", 
+        "ptmPosition": 1,
+      },
+      {
+        "ptmType": "CCD_P1L",
+        "ptmPosition": 5
+      }
+    ],
+    "msa":{
+      "precomputed_msa_dir": "./precomputed_msa",
+      "pairing_db": "uniref100",
+    },
+  },
+}
+```
+* `sequence`: A string representating a protein sequence, which can only contain the 20 standard amino acid type and X (UNK) for unknown residues.
+* `count`: The number of copies of this protein chain (integer).
+* `modifications`: An optional list of dictionaries that describe post-translational modifications.
+
+  * `ptmType`: A string containing CCD code of the modification. 
+  * `ptmPosition`: The position of the modified amino acid (integer).
+* `msa`: A dictionary containing options for Multiple Sequence Alignment (MSA). **If you want to search MSAs using our inference pipeline, you should not set this field or set it to an empty dictionary**:
+  * `precomputed_msa_dir`: The path to a directory containing precomputed MSAs. This directory should contain two specific files: "pairing.a3m" for MSAs used for pairing, and "non_pairing.a3m" for non-pairing MSAs.
+  * `pairing_db`: The name of the genomic database used for pairing MSAs. The default is "uniref100" and you should not change it. In fact, The MSA search against the UniRef30, a clustered version of the UniRef100.
+
+##### dnaSequence
+```json
+{
+  "dnaSequence": {
+      "sequence": "GATTACA",
+      "modifications": [
+          {
+              "modificationType": "CCD_6OG",
+              "basePosition": 1
+          },
+          {
+              "modificationType": "CCD_6MA",
+              "basePosition": 2
+          }
+      ],
+      "count": 1
+  }
+},
+{
+    "dnaSequence": {
+        "sequence": "TGTAATC",
+        "count": 1
+    }
+}
+```
+Please note that the `dnaSequence` type refers to a single stranded DNA sequence. If you
+wish to model double-stranded DNA, please add a second `dnaSequence` entry representing
+the sequence of the reverse complement strand.
+
+* `sequence`: A string containing a DNA sequence; only letters A, T, G, C and N (unknown ribonucleotide) are allowed.
+* `count`: The number of copies of this DNA chain (integer).
+* `modifications`: An optional list of dictionaries describing of
+the DNA chemical modifications:
+  * `modificationType`: A string containing CCD code of modification.
+  * `basePosition`: A position of the modified nucleotide (integer).
+
+##### rnaSequence
+```json
+{
+  "rnaSequence": {
+      "sequence": "GUAC",
+      "modifications": [
+          {
+              "modificationType": "CCD_2MG",
+              "basePosition": 1
+          },
+          {
+              "modificationType": "CCD_5MC",
+              "basePosition": 4
+          }
+      ],
+      "count": 1
+  }
+}
+```
+* `sequence`: A string representing the RNA sequence (single-stranded); only letters A, U, G, C and N (unknown nucleotides) are allowed.
+* `count`: The number of copies of this RNA chain (integer).
+* `modifications`: An optional list of dictionaries describing RNA chemical modifications:
+  * `modificationType`: A string containing
+    CCD code  of modification.
+  * `basePosition`: The position of the modified nucleotide (integer).
+
+##### ligand
+```json
+{
+    "ligand": {
+        "ligand": "CCD_ATP",
+        "count": 1
+    }
+},
+{
+    "ligand": {
+        "ligand": "FILE_your_file_path/atp.sdf",
+        "count": 1
+    }
+},
+{
+    "ligand": {
+        "ligand": "Nc1ncnc2c1ncn2[C@@H]1O[C@H](CO[P@@](=O)(O)O[P@](=O)(O)OP(=O)(O)O)[C@@H](O)[C@H]1O",
+        "count": 1
+    }
+}
+```
+* `ligand`: A string representing the ligand. `ligand` can be one of the following three:
+  * A string containing the CCD code of the ligand, prefixed with "CCD_". For glycans or similar structures, this can be a concatenation of multiple CCD codes, for example, "CCD_NAG_BMA_BGC".
+  * A molecular SMILES string representing the ligand.
+  * A path to a molecular structure file, prefixed with "FILE_", where the supported file formats are PDB, SDF, MOL, and MOL2. The file must include the 3D conformation of the molecule.
+
+* `count` is the number of copies of this ligand (integer).
+
+##### ion
+```json
+{
+    "ion": {
+        "ion": "MG",
+        "count": 2
+    }
+},
+{
+    "ion": {
+        "ion": "NA",
+        "count": 3
+    }
+}
+```
+* `ion`: A string containing the CCD code for the ion. Note that, unlike ligands, the ion code **does not** start with "CCD_".
+* `count`: The number of copies of this ion (integer).
+
+#### covalent_bonds
+```json
+"covalent_bonds": [
+            {
+                "entity1": "2",
+                "copy1": 1,
+                "position1": "2",
+                "atom1": "N6",
+                "entity2": "3",
+                "copy2": 1,
+                "position2": "1",
+                "atom2": "C1"
+            }
+]
+```
+
+The `covalent_bonds` section specifies covalent bonds between a polymer and a ligand, or between two ligands.
+To define a covalent bond, two atoms involved in the bond must be identified. The following fields are used:
+
+* `entity1`, `entity2`: The entity numbers for the two atoms involved in the bond. 
+The entity number corresponds to the order in which the entity appears in the `sequences` list, starting from 1.
+* `copy1`, `copy2`: The copy index (starting from 1) of the `left_entity` and `right_entity`, respectively. These fields are optional, but if specified, both `left_copy` and `right_copy` must be filled simultaneously or left empty at the same time. If neither field is provided, a bond will be created between all pairs of copies of the two entities. For example, if both entity1 and entity2 have two copies, a bond will be formed between entity1.copy1 and entity2.copy1, as well as between entity1.copy2 and entity2.copy2. In this case, the number of copies for both entities must be equal.
+* `position1`, `position2` - The position of the residue (or ligand part) within the entity. 
+The position value starts at 1 and can vary based on the type of entity:
+  * For **polymers** (e.g., proteins, DNA, RNA), the position corresponds to the location of the residue in the sequence.
+  * For **ligands** composed of multiple CCD codes, the position refers to the serial number of the CCD code.
+  * For **single CCD code ligands**, or ligands defined by **SMILES** or **FILE**, the position is always set to 1.
+    
+* `atom1`, `atom2` - The atom names (or atom indices) of the atoms to be bonded.
+  * If the entity is a polymer or described by a CCD code, the atom names are consistent with those defined in the CCD.
+  * If the entity is a ligand defined by SMILES or a FILE, atoms can be specified by their atom index. The atom index corresponds to the position of the atom in the file or in the SMILES string, starting from 0.
+
+Deprecation Notice: The previous fields such as old `left_entity`, `right_entity`, and other fields starting with `left`/`right` have been updated to use `1` and `2` to denote the two atoms forming a bond. The current code still supports the old field names, but they may be deprecated in the future, leaving only the new field names. An alternative approach is to write the element name of the specified atom in the SMILES/file, along with its sequential number for that element, e.g., "C2" indicates it is the second carbon.
+
+Here is a revised user guide compatible with **Version 2** of the `constraint` format for the Complex Structure Predictor:
+
+---
+
+### constraint
+The `constraint` section specifies additional structural information to enable inter-chain guidance for Protenix. Currently, Protenix support two kind of constraint: `contact` and `pocket` constraint. 
+The `contact` constraint allows you to specify residue/atom-residue/atom level priors. The `pocket` constraint is used to guide the binding interface between a chain of interest (e.g. a ligand or an antibody) and specific residues in another chain (e.g. epitopes).
+
+> 💡 *This is a **soft constraint**: the model is encouraged, but not strictly required, to satisfy it.*
+
+#### contact constraint
+
+The `contact` field consists of a list of dictionaries, each describing one contact. The residues and atoms involved in the contact are now represented as compact lists, making the format more concise and flexible.
+
+##### Example:
+
+```json
+"contact": [
+    {
+        "residue1": ["1", 1, 169],
+        "atom2": ["2", 1, 1, "C5"],
+        "max_distance": 6,
+        "min_distance": 0
+    }, // token-contact
+    {
+        "atom1": ["1", 1, 169, "CA"],
+        "residue2": ["2", 1, 1],
+        "max_distance": 6,
+        "min_distance": 0
+    }, // token-contact
+    {
+        "residue1": ["1", 1, 169],
+        "residue2": ["2", 1, 1 ],
+        "max_distance": 6,
+        "min_distance": 0
+    }, // token-contact
+    {
+        "atom1": ["1", 1, 169, "CA"],
+        "atom2": ["2", 1, 1, "C5"],
+        "max_distance": 6,
+        "min_distance": 3
+    }, // atom-contact
+    ...
+]
+```
+
+Each contact dictionary includes the following keys:
+* `residue1` or `residue2` (list):
+  Specifies a **residue** in the format:`[entity_number, copy_index, position]`
+
+* `atom1` or `atom2` (list):
+  Specifies an **atom** (commonly from a ligand or another residue) in the format:`[entity_number, copy_index, position, atom_name]`
+
+* `max_distance` (float):
+  The **expected maximum distance** (in Ångströms) between the specified residues or atoms.
+* `min_distance` (float):
+  The **expected minimum distance** (in Ångströms) between the specified residues or atoms. For token-contact, you do not need to specify this field. It is 0 by default.
+
+#### pocket constraint
+
+The `pocket` constraint is defined as a dictionary with three keys: `"binder_chain"`, `"contact_residues"`, and `"max_distance"` to allow chain-residue binding specification.
+
+##### Example
+
+```json
+"pocket": {
+  "binder_chain": ["2", 1], 
+  "contact_residues": [
+    ["1", 1, 126],
+    ...
+  ], 
+  "max_distance": 6
+}
+```
+
+* `binder_chain` (list):
+  Specifies the **binder chain** in the format:  `[entity_number, copy_index]`
+
+* `contact_residues` (list of lists):
+  A list of residue  that are expected to be in spatial proximity (i.e., in or near the binding pocket). Each residue is specified as:
+  `[entity_number, copy_index, position]`
+
+* `max_distance` (float):
+  The **maximum allowed distance** (in Ångströms) between the binder and the specified contact residues.
+
+
+### Format of the model output
+The outputs will be saved in the directory provided via the `--dump_dir` flag in the inference script. The outputs include the predicted structures in CIF format and the confidence in JSON files. The `--dump_dir` will have the following structure:
+
+```bash
+├── <name>/  # specified in the input JSON file
+│   ├── <seed>/  # specified via the `--seeds` flag in the inference script
+│   │   ├── <name>_<seed>_sample_0.cif
+│   │   ├── <name>_<seed>_summary_confidence_sample_0.json
+│   │   └──... # the number of samples in each seed is specified via `--sample_diffusion.N_sample ` flag in the inference script
+│   └──...
+└── ...
+```
+
+The contents of each output file are as follows:
+- `<name>_<seed>_sample_*.cif` - A CIF format text file containing the predicted structure
+- `<name>_<seed>_summary_confidence_sample_*.json` - A JSON format text file containing various confidence scores for assessing the reliability of predictions. Here’s a description of each score:
+
+    - `plddt` - Predicted Local Distance Difference Test (pLDDT) score. Higher values indicate greater confidence.
+    - `gpde` - Globl Predicted Distance Error (PDE) score. Lower values indicate greater confidence.
+    - `ptm` - Predicted TM-score (pTM). Values closer to 1 indicate greater confidence.
+    - `iptm` - Interface Predicted TM-score, used to estimate the accuracy of interfaces between chains. Values closer to 1 indicate greater confidence.
+    - `chain_ptm` - pTM score calculated for individual chains with the shape of [N_chains], indicating the reliability of specific chain structure.
+    - `chain_pair_iptm`: Pairwise interface pTM scores between chain pairs with the shape of [N_chains, N_chains], indicating the reliability of specific chain-chain interactions.
+    - `chain_iptm` - Average ipTM scores for each chain with the shape of [N_chains].
+    - `chain_pair_iptm_global` - Averge `chain_iptm` between chain pairs with the shape of [N_chains, N_chains]. For interface containing a small molecule, ion, or bonded ligand chain (named `C*`), this value is equal to the `chain_iptm` value of `C*`. 
+    - `chain_plddt` - pLDDT scores calculated for individual chains with the shape of [N_chains].
+    - `chain_pair_plddt` - Pairwise pLDDT scores for chain pairs with the shape of [N_chains, N_chains].
+    - `has_clash` - Boolean flag indicating if there are steric clashes in the predicted structure.
+    - `disorder` - Predicted regions of intrinsic disorder within the protein, highlighting residues that may be flexible or unstructured.
+    - `ranking_score` - Predicted confidence score for ranking complexes. Higher values indicate greater confidence.
+    - `num_recycles`: Number of recycling steps used during inference.

docs/kernels.md

@@ -0,0 +1,24 @@
+### Setting up kernels
+
+- **Custom CUDA layernorm kernels** modified from [FastFold](https://github.com/hpcaitech/FastFold) and [Oneflow](https://github.com/Oneflow-Inc/oneflow) accelerate about 30%-50% during different training stages. To use this feature, run the following command:
+  ```bash
+  export LAYERNORM_TYPE=fast_layernorm
+  ```
+  If the environment variable `LAYERNORM_TYPE` is set to `fast_layernorm`, the model will employ the layernorm we have developed; otherwise, the naive PyTorch layernorm will be adopted. The kernels will be compiled when `fast_layernorm` is called for the first time.
+- **[DeepSpeed DS4Sci_EvoformerAttention kernel](https://www.deepspeed.ai/tutorials/ds4sci_evoformerattention/)** is a memory-efficient attention kernel developed as part of a collaboration between OpenFold and the DeepSpeed4Science initiative. To use this feature, run the following command:
+  ```bash
+  export USE_DEEPSPEED_EVO_ATTENTION=true
+  ```
+  DS4Sci_EvoformerAttention is implemented based on [CUTLASS](https://github.com/NVIDIA/cutlass). If you use this feature, You need to clone the CUTLASS repository and specify the path to it in the environment variable CUTLASS_PATH. The [Dockerfile](Dockerfile) has already include this setting:
+  ```bash
+  RUN git clone -b v3.5.1 https://github.com/NVIDIA/cutlass.git  /opt/cutlass
+  ENV CUTLASS_PATH=/opt/cutlass
+  ```
+  If you set up `Protenix` by `pip`, you can set environment variable `CUTLASS_PATH` as follows:
+
+  ```bash
+  git clone -b v3.5.1 https://github.com/NVIDIA/cutlass.git  /path/to/cutlass
+  export CUTLASS_PATH=/path/to/cutlass
+  ```
+
+  The kernels will be compiled when DS4Sci_EvoformerAttention is called for the first time.

docs/model_train_inference_cost.md

@@ -0,0 +1,51 @@
+### Training 
+Some settings follow those in the [AlphaFold 3](https://www.nature.com/articles/s41586-024-07487-w) paper, The table below shows the training settings for different fine-tuning stages:
+
+  | Arguments  | Initial training | Fine tuning 1   |  Fine tuning 2  | Fine tuning 3 |
+  |-----------------------------------------|--------|---------|-------|-----|
+  | `train_crop_size`                       | 384    | 640    | 768    | 768 |
+  | `diffusion_batch_size`                  | 48     | 32     | 32     | 32  |
+  | `loss.weight.alpha_pae`                 | 0      | 0      | 0      | 1.0 |
+  | `loss.weight.alpha_bond`                | 0      | 1.0    | 1.0    | 0   | 
+  | `loss.weight.smooth_lddt`               | 1.0    | 0      | 0      | 0   | 
+  | `loss.weight.alpha_confidence`          | 1e-4   | 1e-4   | 1e-4   | 1e-4|
+  | `loss.weight.alpha_diffusion`           | 4.0    | 4.0    | 4.0    | 0   |
+  | `loss.weight.alpha_distogram`           | 0.03   | 0.03   | 0.03   | 0   |
+  | `train_confidence_only`                 | False  | False  | False  | True|
+  | full BF16-mixed speed(A100, s/step)     | ~12    | ~30    | ~44    | ~13 |
+  | full BF16-mixed peak memory (G)         | ~34    | ~35    | ~48    | ~24 |
+  
+  We recommend carrying out the training on A100-80G or H20/H100 GPUs. If utilizing full BF16-Mixed precision training, the initial training stage can also be performed on A800-40G GPUs. GPUs with smaller memory, such as A30, you'll need to reduce the model size, such as decreasing `model.pairformer.nblocks` and `diffusion_batch_size`.
+
+### Inference
+
+The model will be infered in BF16 Mixed precision, by **default**, the `SampleDiffusion`,`ConfidenceHead` part will still be infered in FP32 precision.
+
+Below are reference examples of cuda memory usage (G).
+
+| Ntoken | Natom | Memory(G) | Inference time(s) |
+|--------|-------|-------|------------------|
+| 500    | 5000  | 5.2   | 72   |
+| 1000   | 10000 | 11.5  | 229  |
+| 2000   | 20000 | 42.8  | 933  |
+| 3000   | 30000 | 73.9  | 2295 |
+| 3500   | 35000 | 69.5  | 3329 |
+| 4000   | 40000 | 67.5  | 4483 |
+
+The script in [runner/inference.py](../runner/inference.py) will automatically change the default precision to compute `SampleDiffusion`,`ConfidenceHead` to avoid OOM as follows:
+```python
+def update_inference_configs(configs: Any, N_token: int):
+    # Setting the default inference configs for different N_token and N_atom
+    # when N_token is larger than 3000, the default config might OOM even on a
+    # A100 80G GPUS,
+    if N_token > 3840:
+        configs.skip_amp.confidence_head = False
+        configs.skip_amp.sample_diffusion = False
+    elif N_token > 2560:
+        configs.skip_amp.confidence_head = False
+        configs.skip_amp.sample_diffusion = True
+    else:
+        configs.skip_amp.confidence_head = True
+        configs.skip_amp.sample_diffusion = True
+    return configs
+```

docs/msa_pipeline.md

@@ -0,0 +1,101 @@
+## MSA data pipeline
+If you download our released wwPDB dataset as in [training.md](./training.md), the mmcif_msa [450G] dir has the following directory structure.
+  ```bash
+  ├── seq_to_pdb_index.json [45M] # sequence to integers mapping file
+  ├── mmcif_msa [450G] # msa files
+    ├── 0
+      ├── uniref100_hits.a3m
+      ├── mmseqs_other_hits.a3m
+    ├── 1
+      ├── uniref100_hits.a3m
+      ├── mmseqs_other_hits.a3m
+    ├── 2
+      ├── uniref100_hits.a3m
+      ├── mmseqs_other_hits.a3m
+    ...
+    ├── 157201
+      ├── uniref100_hits.a3m
+      ├── mmseqs_other_hits.a3m
+
+  ```
+
+Each integer in the first-level directory under mmcif_msa (for example, 0, 1, 2, and 157201) represents a unique protein sequence. The key of `seq_to_pdb_index.json` is the unique protein sequence, and the value is the integer corresponding to the first-level subdirectory of mmcif_msa mentioned above.
+
+This document is used to provide the steps to convert the MSA obtained from colabfold into the Protenix training format.
+
+### Steps to get your own MSA data for training
+
+#### Step1: get input protein sequence 
+Run the following command:
+
+```python
+python3 scripts/msa/step1-get_prot_seq.py
+```
+you will get outputs in `scripts/msa/data/pdb_seqs` dir. The result dir is as follows,
+
+```bash
+  ├── pdb_index_to_seq.json # mapping integers to sequences
+  ├── seq_to_pdb_index.json # mapping sequences to integers identifiers when saving MSA, This file is required in training for finding local MSA path from sequence
+  ├── pdb_seq.fasta # Input of MSA
+  ├── pdb_seq.csv # Intermediate Files
+  ├── seq_to_pdb_id_entity_id.json # Intermediate Files
+```
+
+#### Step2: run msa search
+We give detailed environment configuration and search commands in 
+
+```python
+scripts/msa/step2-get_msa.ipynb
+```
+
+The searched MSA is in `scripts/msa/data/mmcif_msa_initial`, The result dir is as follows,
+```bash
+  ├── 0.a3m
+  ├── 1.a3m
+  ├── 2.a3m
+  ├── 3.a3m
+  ├── pdb70_220313_db.m8
+  ├── uniref_tax.m8 # record Taxonomy ID which is used by MSA Pairing
+```
+#### Steps3: MSA Post-Processing
+
+The overall solution is to search the MSA containing taxonomy information only once for the unique sequence, and pair it according to the species information of each MSA. 
+
+For MSA Post-Processing, Taxonomy ID from UniRef30 DB is added to MSAs and MSAs is split into `uniref100_hits.a3m` and `mmseqs_other_hits.a3m`, which correspond to `pairing.a3m` and `non_pairing.a3m` in inference stage respectively.
+
+You can run:
+```python
+python3 scripts/msa/step3-uniref_add_taxid.py
+
+python3 scripts/msa/step4-split_msa_to_uniref_and_others.py
+```
+
+The final pairing and non_pairing MSAs in `scripts/msa/data/mmcif_msa` is as follows:
+
+
+```
+>query
+GPTHRFVQKVEEMVQNHMTYSLQDVGGDANWQLVVEEGEMKVYRREVEENGIVLDPLKATHAVKGVTGHEVCNYFWNVDVRNDWETTIENFHVVETLADNAIIIYQTHKRVWPASQRDVLYLSVIRKIPALTENDPETWIVCNFSVDHDSAPLNNRCVRAKINVAMICQTLVSPPEGNQEISRDNILCKITYVANVNPGGWAPASVLRAVAKREYPKFLKRFTSYVQEKTAGKPILF
+>UniRef100_A0A0S7JZT1_188132/	246	0.897	6.614E-70	2	236	237	97	331	332
+--THRFADKVEEMVQNHMTYSLQDVGGDANWQLVIEEGEMKVYRREVEENGIVLDPLKATHAVKGVTGHEVCHYFWDTDVRNDWETTIDNFNVVETLSDNAIIVYQTHKRVWPASQRDILFLSAIRKILAKNENDPDTWLVCNFSVDHDKAPPTNRCVRAKINVAMICQTLVSPPEGDKEISRDNILCKITYVANVNPGGWAPASVLRAVAKREYPKFLKRFTSYVQEKTAGNPILF
+>UniRef100_A0A4W6GBN4_8187/	246	0.893	9.059E-70	2	236	237	373	607	608
+--THRFANKVEEMVQNHMTYSLQDVGGDANWQLVIEEGEMKVYRREVEENGIVLDPLKATHSVKGVTGHEVCHYFWDTDVRMDWETTIENFNVVEKLSENAIIVYQTHKRVWPASQRDVLYLSAIRKIMATNENDPDTWLVCNFSVDHNNAPPTNRCVRAKINVAMICQTLVSPPEGDKEISRDNILCKITYVANVNPGGWAPASVLRAVAKREYPKFLKRFTSYVQEKTAGKPILF
+```
+
+```
+>query
+MAEVIRSSAFWRSFPIFEEFDSETLCELSGIASYRKWSAGTVIFQRGDQGDYMIVVVSGRIKLSLFTPQGRELMLRQHEAGALFGEMALLDGQPRSADATAVTAAEGYVIGKKDFLALITQRPKTAEAVIRFLCAQLRDTTDRLETIALYDLNARVARFFLATLRQIHGSEMPQSANLRLTLSQTDIASILGASRPKVNRAILSLEESGAIKRADGIICCNVGRLLSIADPEEDLEHHHHHHHH
+>MGYP001165762451	218	0.325	1.019E-59	5	230	244	3	228	230
+-----DKVEFLKGVPLFSELPEAHLQSLGELLIERSYRRGATIFFEGDPGDALYIVRSGIVKISRVAEDGREKTLAFLGKGEPFGEMALIDGGPRSAIAQALEATSLYALHRADFLAALTENPALSLGVIKVLSARLQQANAQLMDLVFRDVRGRVAQALLDLARR-HGVPLTNGRMISVKLTHQEIANLVGTARETVSRTFAELQDSGIIRIeGRNIVLLDAAQLEGYAAG-------------
+>A0A160T8V6	218	0.285	1.019E-59	0	227	244	0	229	237
+MPTTRDsnAVQALQVVPFFANLPEDHVAALAKALVPRRFSPGQVIFHLGDPGGLLYLISRGKIKISHTTSDGQEVVLAILGPGDFFGEMALIDDAPRSATAITLEPSETWTLHREEFIQYLTDNPEFALHVLKTLARHIRRLNTQLADIFFLDLPGRLARTLLNLADQ-YGRRAADGTIIDLSLTQTDLAEMTGATRVSINKALGRFRRAGWIQvTGRQVTVLDRAALEAL----------------
+>AP58_3_1055460.scaffolds.fasta_scaffold1119545_2	216	0.304	3.581E-59	10	225	244	5	221	226
+----------LSRVPLFAELPPERIHELAQSVRRRTYHRGETIFHKGDPGNGLYIIAAGQVKIVLPSEMGEEAMLAVLEGGEFFGELALFDGLPRSATVVAVQNAEVLVLHRDDFMSFVGRNPEVVSALFAALSRRLRDADEMIEDAIFLDVPGRLAKRLLDLAEKHGRAEEKGGVAIDLKLTQQDLAAMVGATRESVNKHLGWMRDHGLIQLDRqRIVILKPDDLR------------------
+```
+### Format of MSA 
+In `uniref100_hits.a3m`(training stage) or `pairing.a3m`(inference stage), the header must starts with the following format, which we use for pairing:
+```
+>UniRef100_{hitname}_{taxonomyid}/
+```
+
+we also provide a pipeline of local Colabfold_search to Generate Protenix-Compatible MSAs in [colabfold_compatible_msa.md](./colabfold_compatible_msa.md).

docs/prepare_training_data.md

@@ -0,0 +1,119 @@
+# Start with CIF files and prepare your own training data.
+
+## Data Preparation
+
+1. **Prepare CIF Files**: Place the CIF files you want to convert into training data in a folder. Alternatively, you can use a `txt` file to record the paths to these CIF files, with each line corresponding to the path of a specific CIF file.
+
+2. **Prepare Protein Clustering File (Optional)**: The protein clustering file contains category information for each `[PDB ID]_[Entity ID]`. In the Protenix training data, we cluster protein sequences using a 40% sequence identity threshold.
+
+   You can download the official clustering results file provided by RCSB PDB using the following command, and use it directly:
+   ```bash
+   wget https://cdn.rcsb.org/resources/sequence/clusters/clusters-by-entity-40.txt
+   ```
+
+    If you prefer to perform your own clustering of protein sequences, ensure the final results are formatted as a text file like this:
+    Each line represents a cluster, containing `[PDB ID]_[Entity ID]` entries separated by spaces.
+
+3. **Update the CCD (Chemical Component Dictionary) Cache File (If needed)**: We provide a pre-processed file, with a cutoff date of 2024-06-08, that records the reference conformers for each CCD Code. If the training data you're preparing is more recent than this date, there may be issues with some CCD Codes might be missing. For example, the CCD Code "WTB," appearing in the PDB ID: 8P3K released on 2024-11-20, is not defined in the previously provided CCD file. In such cases, you need to run the following script to download and update the CCD CIF files:
+
+    ```bash
+    python3 scripts/gen_ccd_cache.py -c [ccd_cache_dir] -n [num_cpu]
+    ```
+
+    After running the script, three files will be generated in the specified "ccd_cache_dir":
+    
+    - `components.cif` (CCD CIF file downloaded from RCSB)
+    - `components.cif.rdkit_mol.pkl` (pre-processed dictionary, where the key is the CCD Code and the value is an RDKit Mol object with 3D structure)
+    - `components.txt` (a list containing all the CCD Codes)
+
+    When running Protenix, it first uses 
+    ```bash
+    `release_data/ccd_cache/components.cif`
+    `release_data/ccd_cache/components.cif.rdkit_mol.pkl`
+    ```
+    if unavailable, it switches to 
+    ```bash
+    `release_data/ccd_cache/components.v20240608.cif`
+    `release_data/ccd_cache/components.v20240608.cif.rdkit_mol.pkl`
+    ```
+    Notes:
+    - The `-c` parameter is optional. If not specified, files will be saved in the "release_data/ccd_cache" folder within the Protenix code directory by default.
+    - You can add the `-d` parameter when running the script to skip the CIF file download step, in which case the script will directly process the "components.cif" file located in the "ccd_cache_dir".
+
+## Data Preprocessing
+Execute the script to preprocess the data:
+```bash
+python3 scripts/prepare_training_data.py -i [input_path] -o [output_csv] -b [output_dir] -c [cluster_txt] -n [num_cpu]
+```
+
+The preprocessed structures will be saved as `.pkl.gz` files. Additionally, a `CSV` file will be generated to catalog the chains and interfaces within these structures, which will facilitate sampling during the training process.
+
+You can view the explanation of the parameters by using the `--help` command.
+```
+python3 scripts/prepare_training_data.py --help
+```
+
+Note that there is an optional parameter `-d` in the script. When this parameter is not used, the script processes CIF files downloaded from RCSB PDB by applying the full set of WeightedPDB training data filters. These filters include:
+
+- Removing water molecules
+- Removing hydrogen atoms
+- Deleting polymer chains composed entirely of unknown residues
+- Eliminating chains where the Cα distance between adjacent numbered residues exceeds 10 angstroms
+- Removing elements labeled as "X"
+- Deleting chains where no residues have been resolved
+- When the number of chains exceeds 20, selecting one central atom from those capable of forming interfaces and retaining the 20 nearest chains to it. If a ligand is covalently bonded to a polymer, it is considered as one chain together. Additionally, if the number of chains is greater than 20 but the total number of tokens in these chains is less than 5120, more chains will be retained until the 5120 token limit is reached.
+- Removing chains with one-third of their heavy atoms colliding
+
+For CIF files generated through model inference where these filtering steps aren't desired, you can run the script with the `-d` parameter, which disables all these filters. The CIF structure will not be expanded to Assembly 1 in this case.
+
+
+## Output Format
+### Bioassembly Dict
+In the folder specified by the `-b` parameter of the data preprocessing script, a corresponding `[pdb_id].pkl.gz` file is generated for each successfully processed CIF file. This file contains a dictionary saved with `pickle.dump`, with the following contents:
+```
+| Key                        | Value Type    | Description                                                                   |
+|----------------------------|---------------|-------------------------------------------------------------------------------|
+| pdb_id                     | str           | PDB Code                                                                      |
+| assembly_id                | str           | Assembly ID                                                                   |
+| sequences                  | dict[str, str]| Key is polymer's label_entity_id, value is canonical_sequence                 |
+| release_date               | str           | PDB's Release Date                                                            |
+| num_assembly_polymer_chains| int           | Number of assembly polymer chains (pdbx_struct_assembly.oligomeric_count)     |
+| num_prot_chains            | int           | Number of protein chains in AtomArray                                         |
+| entity_poly_type           | dict[str, str]| Key is polymer's label_entity_id, value is corresponding to entity_poly.type  |
+| resolution                 | float         | Resolution; if no resolution, value is -1                                     |
+| num_tokens                 | int           | Number of tokens                                                              |
+| atom_array                 | AtomArray     | AtomArray from structure processing                                           |
+| token_array                | TokenArray    | TokenArray generated based on AtomArray                                       |
+| msa_features               | None          | (Placeholder)                                                                 |
+| template_features          | None          | (Placeholder)                                                                 |
+```
+
+### Indices CSV
+After the script successfully completes, a CSV file will be generated in the directory specified by `-o`. 
+Each row contains information about a pre-processed chain or interface, and the content of each column is described as follows: 
+```
+| Column Name    | Value Type | Meaning                                                                | Required |
+|----------------|------------|------------------------------------------------------------------------|----------|
+| type           | str        | "chain" or "interface"                                                 | Y        |
+| pdb_id         | str        | PDB Code (entry.id)                                                    | Y        |
+| cluster_id     | str        | Cluster_id of the chain/interface                                      | Y        |
+| assembly_id    | str        | Assembly id                                                            | N        |
+| release_date   | str        | Release date                                                           | N        |
+| resolution     | float      | Resolution; if no resolution, value is -1                              | N        |
+| num_tokens     | int        | Number of tokens in AtomArray of Bioassembly Dict                      | N        |
+| num_prot_chains| int        | Number of protein chains in AtomArray of Bioassembly Dict              | N        |
+| eval_type      | str        | Classification used for evaluation                                     | N        |
+| entity_1_id    | str        | Chain 1's label_entity_id                                              | Y        |
+| chain_1_id     | str        | Chain 1's chain ID                                                     | Y        |
+| mol_1_type     | str        | Chain 1's corresponding mol_type ("protein", "nuc", "ligand", "ions")  | Y        |
+| sub_mol_1_type | str        | Sub-classification of Chain 1's entity corresponding to mol_type       | N        |
+| cluster_1_id   | str        | Chain 1's cluster ID                                                   | Y        |
+| entity_2_id    | str        | Chain 2's label_entity_id                                              | Y        |
+| chain_2_id     | str        | Chain 2's chain ID                                                     | Y        |
+| mol_2_type     | str        | Chain 2's corresponding mol_type ("protein", "nuc", "ligand", "ions")  | Y        |
+| sub_mol_2_type | str        | Sub-classification of Chain 2's entity corresponding to mol_type       | N        |
+| cluster_2_id   | str        | Chain 2's cluster_id                                                   | Y        |
+```
+Notes: 
+- In the table, columns marked with 'Y' under 'Required' indicate that these columns are essential for training. If you are creating your own CSV for training purposes, these columns must be included. Columns marked with 'N' are optional and can be excluded. 
+- For rows where the "type" is "chain", the values in columns related to Chain 2 should all be filled with empty strings.

docs/training.md

@@ -0,0 +1,88 @@
+### Preparing the datasets
+To download the [wwPDB dataset](https://www.wwpdb.org/) and preprocessed training data, you need at least 1T disk space.
+
+Use the following command to download the preprocessed wwpdb training databases:
+
+```bash
+wget -P /af3-dev/release_data/ https://af3-dev.tos-cn-beijing.volces.com/release_data.tar.gz
+tar -xzvf /af3-dev/release_data/release_data.tar.gz -C /af3-dev/release_data/
+rm /af3-dev/release_data/release_data.tar.gz
+```
+
+
+The data should be placed in the `/af3-dev/release_data/` directory. You can also download it to a different directory, but remember to modify the `DATA_ROOT_DIR` in [configs/configs_data.py](../configs/configs_data.py) correspondingly. Alternatively, you can set an environment variable "PROTENIX_DATA_ROOT_DIR" to specify the path. Data hierarchy after extraction is as follows:
+
+  ```bash
+  ├── components.v20240608.cif [408M] # ccd source file
+  ├── components.v20240608.cif.rdkit_mol.pkl [121M] # rdkit Mol object generated by ccd source file
+  ├── indices [33M] # chain or interface entries
+  ├── mmcif [283G]  # raw mmcif data
+  ├── mmcif_bioassembly [36G] # preprocessed wwPDB structural data
+  ├── mmcif_msa [450G] # msa files
+  ├── posebusters_bioassembly [42M] # preprocessed posebusters structural data
+  ├── posebusters_mmcif [361M] # raw mmcif data
+  ├── recentPDB_bioassembly [1.5G] # preprocessed recentPDB structural data
+  └── seq_to_pdb_index.json [45M] # sequence to pdb id mapping file
+  ```
+
+Data processing scripts have also been released. you can refer to [prepare_training_data.md](./prepare_training_data.md) for generating `{dataset}_bioassembly` and `indices`. And you can refer to [msa_pipeline.md](./msa_pipeline.md) for pipelines to get `mmcif_msa` and `seq_to_pdb_index.json`.
+
+### Training demo
+After the installation and data preparations, you can run the following command to train the model from scratch:
+
+  ```bash
+  bash train_demo.sh 
+  ```
+Key arguments in this scripts are explained as follows:
+* `dtype`: data type used in training. Valid options include `"bf16"` and `"fp32"`. 
+  * `--dtype fp32`: the model will be trained in full FP32 precision.
+  * `--dtype bf16`: the model will be trained in BF16 Mixed precision, by default, the `SampleDiffusion`,`ConfidenceHead`, `Mini-rollout` and `Loss` part will still be training in FP32 precision. if you want to train and infer the model in full BF16 Mixed precision, pass the following arguments to the [train_demo.sh](../train_demo.sh):
+    ```bash
+    --skip_amp.sample_diffusion_training false \
+    --skip_amp.confidence_head false \
+    --skip_amp.sample_diffusion false \
+    --skip_amp.loss false \
+    ```
+* `ema_decay`: the decay rate of the EMA, default is 0.999.
+* `sample_diffusion.N_step`: during evalutaion, the number of steps for the diffusion process is reduced to 20 to improve efficiency.
+
+* `data.train_sets/data.test_sets`: the datasets used for training and evaluation. If there are multiple datasets, separate them with commas.
+* Some settings follow those in the [AlphaFold 3](https://www.nature.com/articles/s41586-024-07487-w) paper, The table in [model_performance.md](../docs/model_performance.md) shows the training settings and memory usages for different training stages.
+* In this version, we do not use the template and RNA MSA feature for training. As the default settings in [configs/configs_base.py](../configs/configs_base.py) and [configs/configs_data.py](../configs/configs_data.py):
+  ```bash
+  --model.template_embedder.n_blocks 0 \
+  --data.msa.enable_rna_msa false \
+  ```
+  This will be considered in our future work.
+
+* The model also supports distributed training with PyTorch’s [`torchrun`](https://pytorch.org/docs/stable/elastic/run.html). For example, if you’re running distributed training on a single node with 4 GPUs, you can use:
+  ```bash
+  torchrun --nproc_per_node=4 runner/train.py
+  ```
+  You can also pass other arguments with `--<ARGS_KEY> <ARGS_VALUE>` as you want.
+
+
+If you want to speed up training, see [<u> setting up kernels documentation </u>](./kernels.md).
+
+### Finetune demo
+
+If you want to fine-tune the model on a specific subset, such as an antibody dataset, you only need to provide a PDB list file and load the pretrained weights as [finetune_demo.sh](../finetune_demo.sh) shows:
+    
+```bash
+# wget -P /af3-dev/release_model/ https://af3-dev.tos-cn-beijing.volces.com/release_model/model_v0.5.0.pt
+checkpoint_path="/af3-dev/release_model/model_v0.5.0.pt"
+...
+
+--load_checkpoint_path ${checkpoint_path} \
+--load_checkpoint_ema_path ${checkpoint_path} \
+--data.weightedPDB_before2109_wopb_nometalc_0925.base_info.pdb_list examples/subset.txt \
+```
+
+, where the `subset.txt` is a file containing the PDB IDs like:
+```bash
+6hvq
+5mqc
+5zin
+3ew0
+5akv
+```

extract_tianrui.py

@@ -0,0 +1,84 @@
+import numpy as np
+import pickle
+import torch
+import json
+
+# np_data = np.load('/home/hui007/rna/rna_repr/zhiyuan/train_data_final.npz') 
+# data_list = pickle.loads(np_data['data_list'])
+
+# training_json = []
+
+# for item in data_list:
+#     full_id = item['full_id']
+#     sequence = ''.join([i[1] for i in item['data']])
+#     # entry = {
+#     #     "sequences": [
+#     #         {
+#     #             "rnaSequence": {
+#     #                 "sequence": sequence,
+#     #                 "count": 1
+#     #             }
+#     #         }
+#     #     ],
+#     #     "name": full_id
+#     # }
+#     # training_json.append(entry)
+#     data = item['data']
+
+#     extracted = [[j[1], j[2]] for j in data]
+
+#     torch.save(extracted, f"/home/hui007/Protenix/coord/{full_id}.pt")
+        
+
+#     # coords = [coord for i in item['data'] for coord in i[2]['coord_list']]
+#     # tensor = torch.tensor(coords, dtype=torch.float32)
+#     # centroid = tensor.mean(dim=0, keepdim=True)
+#     # normalized_pos = (tensor - centroid) / 20.3689
+    
+#     # torch.save(normalized_pos, f"/home/hui007/Protenix/coord/{full_id}.pt")
+
+# # with open("/home/hui007/Protenix/training.json", "w") as f:
+# #     json.dump(training_json, f, indent=2)
+
+# import os
+# import json
+# from pathlib import Path
+
+# # === 路径设置 ===
+# embedding_dir = Path("/home/hui007/Protenix/protenix_1d_embeddings")
+# input_json_path = "/home/hui007/Protenix/training_json/training.json"
+# output_prefix = "training"
+
+# # === 加载 JSON 数据 ===
+# with open(input_json_path, "r") as f:
+#     data = json.load(f)
+
+# # === 只保留那些其 name.pt 不存在的条目 ===
+# filtered_data = []
+# for item in data:
+#     name = item["name"]
+#     pt_path = embedding_dir / f"{name}.pt"
+#     if not pt_path.exists():
+#         filtered_data.append(item)
+
+# print(f"共有 {len(filtered_data)} 条数据将被保留并拆分")
+
+# # === 平均分成 4 份 ===
+# chunk_size = (len(filtered_data) + 5) // 6  # 向上取整
+# chunks = [filtered_data[i:i+chunk_size] for i in range(0, len(filtered_data), chunk_size)]
+
+# # === 保存为 training1.json ~ training4.json ===
+# for i, chunk in enumerate(chunks):
+#     out_path = f"/home/hui007/Protenix/training_json/{output_prefix}{i+1}.json"
+#     with open(out_path, "w") as f:
+#         json.dump(chunk, f, indent=2)
+#     print(f"保存 {out_path}，包含 {len(chunk)} 条")
+
+from huggingface_hub import upload_folder
+
+upload_folder(
+    repo_id="Yimingbear/protenix",
+    repo_type="dataset",
+    folder_path=".",
+    ignore_patterns=["coord/*", "ModelGenerator/*", "protenix_1d_embeddings/*", "protenix_3d_embeddings/*", "second_stage/*", "training_json/*", "examples/*"]  # 忽略 scale 文件夹
+)

finetune_demo.sh

@@ -0,0 +1,42 @@
+# 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.
+
+export LAYERNORM_TYPE=fast_layernorm
+export USE_DEEPSPEED_EVO_ATTENTION=true
+# wget -P /af3-dev/release_model/ https://af3-dev.tos-cn-beijing.volces.com/release_model/protenix_base_default_v0.5.0.pt
+checkpoint_path="/af3-dev/release_model/protenix_base_default_v0.5.0.pt"
+
+python3 ./runner/train.py \
+--model_name "protenix_base_constraint_v0.5.0" \
+--run_name protenix_finetune \
+--seed 42 \
+--base_dir ./output \
+--dtype bf16 \
+--project protenix \
+--use_wandb false \
+--diffusion_batch_size 48 \
+--eval_interval 400 \
+--log_interval 50 \
+--checkpoint_interval 400 \
+--ema_decay 0.999 \
+--train_crop_size 384 \
+--max_steps 100000 \
+--warmup_steps 2000 \
+--lr 0.001 \
+--sample_diffusion.N_step 20 \
+--load_checkpoint_path ${checkpoint_path} \
+--load_ema_checkpoint_path ${checkpoint_path} \
+--data.train_sets weightedPDB_before2109_wopb_nometalc_0925 \
+--data.weightedPDB_before2109_wopb_nometalc_0925.base_info.pdb_list examples/finetune_subset.txt \
+--data.test_sets recentPDB_1536_sample384_0925,posebusters_0925

inference_demo.sh

@@ -0,0 +1,50 @@
+# 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.
+
+export LAYERNORM_TYPE=fast_layernorm
+export USE_DEEPSPEED_EVO_ATTENTION=true
+
+N_sample=5
+N_step=200
+N_cycle=10
+seed=101
+
+input_json_path="./examples/example.json"
+dump_dir="./output"
+# model_name="protenix_base_default_v0.5.0"
+model_name = 'protenix_tiny_detault_v0.5.0'
+
+python3 runner/inference.py \
+--model_name ${model_name} \
+--seeds ${seed} \
+--dump_dir ${dump_dir} \
+--input_json_path ${input_json_path} \
+--model.N_cycle ${N_cycle} \
+--sample_diffusion.N_sample ${N_sample} \
+--sample_diffusion.N_step ${N_step}
+
+# The following is a demo to use DDP for inference
+# torchrun \
+#     --nproc_per_node $NPROC \
+#     --master_addr $WORKER_0_HOST \
+#     --master_port $WORKER_0_PORT \
+#     --node_rank=$ID \
+#     --nnodes=$WORKER_NUM \
+#     runner/inference.py \
+#     --seeds ${seed} \
+#     --dump_dir ${dump_dir} \
+#     --input_json_path ${input_json_path} \
+#     --model.N_cycle ${N_cycle} \
+#     --sample_diffusion.N_sample ${N_sample} \
+#     --sample_diffusion.N_step ${N_step}

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

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)

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")

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

protenix/data/compute_esm.py

@@ -0,0 +1,230 @@
+# 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 os
+
+import pandas as pd
+import torch
+from esm import FastaBatchedDataset, pretrained
+from tqdm.auto import tqdm
+
+ESM_CONFIG = {
+    "esm2-3b": {
+        "type": "esm2",
+        "model_path": "esm2_t36_3B_UR50D.pt",
+        "emb_dim": 2560,
+        "n_layers": 36,
+    },
+    "esm2-3b-ism": {
+        "type": "esm2",
+        "model_path": "esm2_t36_3B_UR50D_ism.pt",
+        "emb_dim": 2560,
+        "n_layers": 36,
+    },  # https://www.biorxiv.org/content/10.1101/2024.11.08.622579v2
+}
+
+
+def _load_esm2_model(model_path):
+    if os.path.exists(model_path):
+        model, alphabet = pretrained.load_model_and_alphabet_local(model_path)
+    else:
+        model, alphabet = pretrained.load_model_and_alphabet(
+            os.path.splitext(os.path.basename(model_path))[0]
+        )
+    return model, alphabet
+
+
+def load_esm_model(model_name, local_esm_dir="release_data/checkpoint"):
+    local_model_path = os.path.join(local_esm_dir, ESM_CONFIG[model_name]["model_path"])
+    if os.path.exists(local_model_path):
+        print("Try to load ESM language model from ", local_model_path)
+
+    if "ism" in model_name and not os.path.exists(local_model_path):
+        raise RuntimeError(
+            f"esm2-3b-ism model: {local_model_path} does not exist \n"
+            + "this model can not be download from fair-esm, \n"
+            + "download it from https://af3-dev.tos-cn-beijing.volces.com/release_model/esm2_t36_3B_UR50D_ism.pt"
+        )
+    if model_name.startswith("esm2"):
+        model, alphabet = _load_esm2_model(local_model_path)
+    model.eval()
+    if torch.cuda.is_available():
+        model = model.cuda()
+
+    return model, alphabet
+
+
+def _check_files_exist(save_dir, labels):
+    return all(
+        [os.path.exists(os.path.join(save_dir, label + ".pt")) for label in labels]
+    )
+
+
+def compute_ESM_embeddings(
+    model_name,
+    model,
+    alphabet,
+    labels,
+    sequences,
+    save_dir,
+    toks_per_batch=4096,
+    truncation_seq_length=1022,
+):
+    if model_name.startswith("esm2"):
+        embeddings = compute_esm2_embeddings(
+            model,
+            alphabet,
+            labels,
+            sequences,
+            save_dir,
+            toks_per_batch,
+            truncation_seq_length,
+        )
+    return embeddings
+
+
+# Adapt from Corso, Gabriele, et al. "Diffdock: Diffusion steps, twists, and turns for molecular docking."
+# URL: https://github.com/gcorso/DiffDock/blob/main/utils/inference_utils.py
+def compute_esm2_embeddings(
+    model,
+    alphabet,
+    labels,
+    sequences,
+    save_dir,
+    toks_per_batch=4096,
+    truncation_seq_length=1022,
+):
+    dataset = FastaBatchedDataset(labels, sequences)
+    batches = dataset.get_batch_indices(toks_per_batch, extra_toks_per_seq=1)
+    data_loader = torch.utils.data.DataLoader(
+        dataset,
+        collate_fn=alphabet.get_batch_converter(truncation_seq_length),
+        batch_sampler=batches,
+    )
+    repr_layer = model.num_layers
+    embeddings = {}
+    with torch.no_grad():
+        for batch_idx, (labels, strs, toks) in enumerate(tqdm(data_loader)):
+            print(
+                f"Processing {batch_idx + 1} of {len(batches)} batches ({toks.size(0)} sequences)"
+            )
+            if _check_files_exist(save_dir, labels):
+                continue
+            if torch.cuda.is_available():
+                toks = toks.to(device="cuda", non_blocking=True)
+            out = model(toks, repr_layers=[repr_layer], return_contacts=False)
+            representation = out["representations"][repr_layer].to(device="cpu")
+            for i, label in enumerate(labels):
+                truncate_len = min(truncation_seq_length, len(strs[i]))
+                embeddings[label] = representation[i, 1 : truncate_len + 1].clone()
+                save_path = os.path.join(save_dir, label + ".pt")
+                torch.save(embeddings[label], save_path)
+    return embeddings
+
+
+def pdb_sequences_iterator(
+    input_path="./scripts/msa/data/pdb_seqs/pdb_seq.csv",
+    save_path="./scripts/msa/data/pdb_seqs/pdb_labels_seqs.csv",
+    start_id=0,
+    end_id=-1,
+):
+    if os.path.exists(save_path):
+        df_seq = pd.read_csv(save_path)
+    else:
+        df = pd.read_csv(input_path)
+        # Protein only
+        df = df[df["mol_type"] == "protein"]
+        # Sequence name
+        df["pdb_entity_id"] = df["pdb_id"] + "_" + df["entity_id"].astype(str)
+        # Group by 'seq'
+        df_seq = (
+            df.groupby("seq")["pdb_entity_id"]
+            .apply(lambda x: ",".join(x))
+            .reset_index()
+        )
+        # Use the first pdb_entity_id as the label
+        df_seq["seq_label"] = df_seq["pdb_entity_id"].apply(lambda x: x.split(",")[0])
+        assert df_seq["seq_label"].nunique() == len(df_seq)
+        # Get a part id
+        df_seq["part_id"] = df_seq["pdb_entity_id"].apply(lambda x: x[1:3])
+        df_seq.to_csv(save_path)
+
+    if end_id == -1:
+        end_id = len(df_seq)
+    df_seq = df_seq[start_id:end_id]
+
+    part_counts = dict(df_seq["part_id"].value_counts())
+    for part_id, count in part_counts.items():
+        df_part = df_seq[df_seq["part_id"] == part_id]
+        print(f"Part {part_id}: {len(df_part)} sequences.")
+        yield part_id, df_part["seq_label"].tolist(), df_part["seq"].tolist()
+
+
+def process_pdb_dataset(
+    model_name, root_save_dir, pdb_seq_path, pdb_seq_label_path, start_id=0, end_id=-1
+):
+
+    model, alphabet = load_esm_model(model_name)
+    seq_iterator = pdb_sequences_iterator(
+        pdb_seq_path, pdb_seq_label_path, start_id, end_id
+    )
+    error_parts = []
+    for part_id, labels, sequences in seq_iterator:
+        save_dir = os.path.join(root_save_dir, f"{part_id}")
+
+        if not os.path.exists(save_dir):
+            os.makedirs(save_dir)
+        print(f"[{part_id}] Generating ESM language model embeddings")
+        lm_embeddings = compute_ESM_embeddings(
+            model_name,
+            model,
+            alphabet,
+            labels,
+            sequences,
+            save_dir,
+            truncation_seq_length=4094,
+            toks_per_batch=16384,
+        )
+        print(f"[{part_id}] Processed {len(lm_embeddings)} sequences in total. Done!")
+
+    print("Error parts: ", error_parts)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model_name", type=str, choices=list(ESM_CONFIG.keys()))
+    parser.add_argument("--start_id", type=int, default=0)
+    parser.add_argument("--end_id", type=int, default=-1)
+    args = parser.parse_args()
+
+    save_dir = f"./esm_embeddings/{args.model_name}"
+    pdb_seq_path = "./scripts/msa/data/pdb_seqs/pdb_seq.csv"
+    pdb_seq_label_path = "./scripts/msa/data/pdb_seqs/pdb_labels_seqs.csv"
+
+    if not os.path.exists(save_dir):
+        print("Make dir: ", save_dir)
+        os.makedirs(save_dir)
+    process_pdb_dataset(
+        args.model_name,
+        save_dir,
+        pdb_seq_path,
+        pdb_seq_label_path,
+        args.start_id,
+        args.end_id,
+    )
+
+
+if __name__ == "__main__":
+    main()

protenix/data/constants.py

@@ -0,0 +1,977 @@
+# 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 rdkit.Chem import GetPeriodicTable
+
+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"],
+}
+
+CRYSTALLIZATION_METHODS = {
+    "X-RAY DIFFRACTION",
+    "NEUTRON DIFFRACTION",
+    "ELECTRON CRYSTALLOGRAPHY",
+    "POWDER CRYSTALLOGRAPHY",
+    "FIBER DIFFRACTION",
+}
+
+### Protein Constants ###
+# https://mmcif.wwpdb.org/dictionaries/mmcif_pdbx_v40.dic/Items/_entity_poly.pdbx_seq_one_letter_code_can.html
+
+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": 25,
+}
+
+DNA_STD_RESIDUES = {
+    "DA": 26,
+    "DG": 27,
+    "DC": 28,
+    "DT": 29,
+    "DN": 30,
+}
+
+GAP = {"-": 31}
+STD_RESIDUES = PRO_STD_RESIDUES | RNA_STD_RESIDUES | DNA_STD_RESIDUES
+STD_RESIDUES_WITH_GAP = STD_RESIDUES | GAP
+STD_RESIDUES_WITH_GAP_ID_TO_NAME = {
+    idx: res_type for res_type, idx in STD_RESIDUES_WITH_GAP.items()
+}
+
+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

protenix/data/constraint_featurizer.py

@@ -0,0 +1,2414 @@
+# 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 hashlib
+from typing import Any
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn.functional as F
+from biotite.structure import AtomArray
+from scipy.spatial.distance import cdist
+
+from protenix.data.constants import ELEMS, STD_RESIDUES
+from protenix.data.tokenizer import Token, TokenArray
+from protenix.data.utils import get_atom_mask_by_name
+from protenix.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class ConstraintFeatureGenerator:
+    """Generates constraint features by coordinating different featurizers"""
+
+    def __init__(
+        self, constraint_config: dict[str, Any], ab_top2_clusters: set[str] = None
+    ):
+        """
+        Args:
+            constraint_config: Configuration dict for constraints
+            ab_top2_clusters: Optional antibody cluster info
+        """
+        self.constraint = constraint_config
+        self.ab_top2_clusters = ab_top2_clusters
+
+    # function set for inference
+    @staticmethod
+    def _canonicalize_contact_format(
+        sequences: list[dict[str, Any]], pair: dict[str, Any]
+    ) -> dict[str, Any]:
+        pair = copy.deepcopy(pair)
+        _pair = {}
+
+        for id_num in ["1", "2"]:
+            res_id = f"residue{id_num}"
+            if (res_info := pair.get(res_id, None)) is not None:
+                assert len(res_info) == 3, "residue contact should have 3 identifiers"
+                res_info.append(None)  # Add None for atom_name
+                _pair[f"id{id_num}"] = res_info
+
+            atom_id = f"atom{id_num}"
+            if (atom_info := pair.get(atom_id, None)) is not None:
+                assert len(atom_info) == 4, "atom contact must have 4 identifiers"
+
+                entity_id, atom_name = atom_info[0], atom_info[3]
+                if isinstance(atom_name, int):
+                    entity_dict = list(sequences[int(entity_id - 1)].values())[0]
+                    assert "atom_map_to_atom_name" in entity_dict
+                    atom_info[3] = entity_dict["atom_map_to_atom_name"][atom_name]
+
+                _pair[f"id{id_num}"] = atom_info
+
+        if hash(tuple(_pair["id1"][:2])) == hash(tuple(_pair["id2"][:2])):
+            raise ValueError("A contact pair can not be specified on the same chain")
+
+        _pair["min_distance"] = float(pair.get("min_distance", 0))
+        _pair["max_distance"] = float(pair["max_distance"])
+        if _pair["max_distance"] < _pair["min_distance"]:
+            raise ValueError("max_distance must be greater than min_distance")
+        if "atom1" in pair and "atom2" in pair:
+            _pair["contact_type"] = "atom_contact"
+        else:
+            _pair["contact_type"] = "token_contact"
+        return _pair
+
+    @staticmethod
+    def _canonicalize_pocket_res_format(binder: list, pocket_pos: list) -> list:
+        assert len(pocket_pos) == 3
+        if hash(tuple(binder[:2])) == hash(tuple(pocket_pos[:2])):
+            raise ValueError("Pockets can not be the same chain with the binder")
+        return pocket_pos
+
+    @staticmethod
+    def _log_constraint_feature(
+        atom_array: AtomArray, token_array: TokenArray, constraint_feature: dict
+    ):
+
+        atom_feature = constraint_feature["contact_atom"]
+        if atom_feature.sum() > 0:
+            # logging contact feature
+            token_idx_1, token_idx_2 = torch.nonzero(
+                torch.triu(atom_feature[..., 1]), as_tuple=True
+            )
+
+            atom1_index = token_array[token_idx_1].get_annotation("centre_atom_index")
+            atom2_index = token_array[token_idx_2].get_annotation("centre_atom_index")
+
+            res_name_1 = atom_array.res_name[atom1_index]
+            res_name_2 = atom_array.res_name[atom2_index]
+
+            atom_name_1 = atom_array.atom_name[atom1_index]
+            atom_name_2 = atom_array.atom_name[atom2_index]
+
+            chain_id_1 = atom_array.chain_id[atom1_index]
+            chain_id_2 = atom_array.chain_id[atom2_index]
+
+            max_distance = atom_feature[token_idx_1, token_idx_2, 1]
+            min_distance = atom_feature[token_idx_1, token_idx_2, 0]
+
+            contact_info = {
+                "chain_id": np.stack([chain_id_1, chain_id_2]).T.tolist(),
+                "res_name": np.stack([res_name_1, res_name_2]).T.tolist(),
+                "atom_name": np.stack([atom_name_1, atom_name_2]).T.tolist(),
+                "max_distance": max_distance.tolist(),
+                "min_distance": min_distance.tolist(),
+            }
+            logger.info(f"loaded atom contact info:{contact_info}")
+
+        token_feature = constraint_feature["contact"]
+        if token_feature.sum() > 0:
+            # logging contact feature
+            token_idx_1, token_idx_2 = torch.nonzero(
+                torch.triu(token_feature[..., 1]), as_tuple=True
+            )
+
+            atom1_index = token_array[token_idx_1].get_annotation("centre_atom_index")
+            atom2_index = token_array[token_idx_2].get_annotation("centre_atom_index")
+
+            res_name_1 = atom_array.res_name[atom1_index]
+            res_name_2 = atom_array.res_name[atom2_index]
+
+            atom_name_1 = atom_array.atom_name[atom1_index]
+            atom_name_2 = atom_array.atom_name[atom2_index]
+
+            chain_id_1 = atom_array.chain_id[atom1_index]
+            chain_id_2 = atom_array.chain_id[atom2_index]
+
+            max_distance = token_feature[token_idx_1, token_idx_2, 1]
+            min_distance = token_feature[token_idx_1, token_idx_2, 0]
+
+            contact_info = {
+                "chain_id": np.stack([chain_id_1, chain_id_2]).T.tolist(),
+                "res_name": np.stack([res_name_1, res_name_2]).T.tolist(),
+                "atom_name": np.stack([atom_name_1, atom_name_2]).T.tolist(),
+                "max_distance": max_distance.tolist(),
+                "min_distance": min_distance.tolist(),
+            }
+            logger.info(f"loaded contact info:{contact_info}")
+
+        pocket_feature = constraint_feature["pocket"]
+        if pocket_feature.sum() > 0:
+            # logging contact feature
+            binder_idx, pocket_idx = torch.nonzero(
+                pocket_feature[..., 0], as_tuple=True
+            )
+            atom1_index = token_array[binder_idx].get_annotation("centre_atom_index")
+            atom2_index = token_array[pocket_idx].get_annotation("centre_atom_index")
+
+            res_name_1 = atom_array.res_name[atom1_index]
+            res_name_2 = atom_array.res_name[atom2_index]
+
+            atom_name_1 = atom_array.atom_name[atom1_index]
+            atom_name_2 = atom_array.atom_name[atom2_index]
+
+            chain_id_1 = atom_array.chain_id[atom1_index]
+            chain_id_2 = atom_array.chain_id[atom2_index]
+
+            distance = pocket_feature[binder_idx, pocket_idx, 0]
+
+            pocket_info = {
+                "binder_chain_id": np.unique(chain_id_1).tolist(),
+                "binder_res_name": np.unique(res_name_1).tolist(),
+                "binder_atom_name": np.unique(atom_name_1).tolist(),
+                "pocket_chain_id": np.unique(chain_id_2).tolist(),
+                "pocket_res_name": np.unique(res_name_2).tolist(),
+                "pocket_atom_name": np.unique(atom_name_2).tolist(),
+                "distance": distance.unique().item(),
+            }
+            logger.info(f"loaded pocket info:{pocket_info}")
+
+    @staticmethod
+    def generate_from_json(
+        token_array: TokenArray,
+        atom_array: AtomArray,
+        sequences: list[dict[str, Any]],
+        constraint_param: dict,
+    ) -> tuple[dict[str, Any], TokenArray, AtomArray]:
+        feature_dict = {}
+
+        # build atom-level contact features
+        contact_inputs = [
+            ConstraintFeatureGenerator._canonicalize_contact_format(sequences, pair)
+            for pair in constraint_param.get("contact", [])
+        ]
+        atom_contact_inputs = list(
+            filter(lambda d: d["contact_type"] == "atom_contact", contact_inputs)
+        )
+        token_contact_inputs = list(
+            filter(lambda d: d["contact_type"] == "token_contact", contact_inputs)
+        )
+
+        atom_to_token_idx_dict = {}
+        for idx, token in enumerate(token_array.tokens):
+            for atom_idx in token.atom_indices:
+                atom_to_token_idx_dict[atom_idx] = idx
+
+        atom_contact_specifics = []
+        for i, pair in enumerate(atom_contact_inputs):
+            atom_mask1 = get_atom_mask_by_name(
+                atom_array=atom_array,
+                entity_id=pair["id1"][0],
+                copy_id=pair["id1"][1],
+                position=pair["id1"][2],
+                atom_name=pair["id1"][3],
+            )
+            atom_mask2 = get_atom_mask_by_name(
+                atom_array=atom_array,
+                entity_id=pair["id2"][0],
+                copy_id=pair["id2"][1],
+                position=pair["id2"][2],
+                atom_name=pair["id2"][3],
+            )
+            atom_list_1 = np.nonzero(atom_mask1)[0]
+            atom_list_2 = np.nonzero(atom_mask2)[0]
+            if np.size(atom_list_1) != 1 or np.size(atom_list_2) != 1:
+                logger.info(f"Atom contact {i} not found for the input")
+                continue
+            atom_contact_specifics.append(
+                (
+                    atom_list_1.item(),
+                    atom_list_2.item(),
+                    pair["max_distance"],
+                    pair["min_distance"],
+                )
+            )
+
+        token_array, atom_array, atom_contact_specifics, _, _ = (
+            ConstraintFeatureGenerator.expand_tokens(
+                token_array,
+                atom_array,
+                atom_contact_specifics,
+                atom_to_token_idx_dict,
+                None,
+            )
+        )
+        atom_contact_featurizer = ContactAtomFeaturizer(
+            token_array=token_array, atom_array=atom_array
+        )
+        feature_dict["contact_atom"], _ = (
+            atom_contact_featurizer.generate_spec_constraint(
+                atom_contact_specifics,
+                feature_type="continuous",
+                shape=(len(token_array), len(token_array), 2),
+            )
+        )
+
+        # build token-level contact
+        atom_to_token_idx_dict = {}
+        for idx, token in enumerate(token_array.tokens):
+            for atom_idx in token.atom_indices:
+                atom_to_token_idx_dict[atom_idx] = idx
+        atom_to_token_idx = np.array(
+            [atom_to_token_idx_dict[atom_idx] for atom_idx in range(len(atom_array))]
+        )
+        token_contact_specifics = []
+        for i, pair in enumerate(token_contact_inputs):
+            atom_mask1 = get_atom_mask_by_name(
+                atom_array=atom_array,
+                entity_id=pair["id1"][0],
+                copy_id=pair["id1"][1],
+                position=pair["id1"][2],
+                atom_name=pair["id1"][3],
+            )
+            atom_mask2 = get_atom_mask_by_name(
+                atom_array=atom_array,
+                entity_id=pair["id2"][0],
+                copy_id=pair["id2"][1],
+                position=pair["id2"][2],
+                atom_name=pair["id2"][3],
+            )
+            token_list_1 = atom_to_token_idx[atom_mask1]
+            token_list_2 = atom_to_token_idx[atom_mask2]
+            if np.size(token_list_1) == 0 or np.size(token_list_2) == 0:
+                logger.info(f"Contact {i} not found for the input")
+                continue
+            token_contact_specifics.append(
+                (token_list_1, token_list_2, pair["max_distance"], 0)
+            )  # default min_distance=0
+
+        contact_featurizer = ContactFeaturizer(
+            token_array=token_array, atom_array=atom_array
+        )
+        feature_dict["contact"], _ = contact_featurizer.generate_spec_constraint(
+            token_contact_specifics, feature_type="continuous"
+        )
+
+        # build pocket features
+        pocket_specifics = []
+        if pocket := constraint_param.get("pocket", {}):
+            distance = pocket["max_distance"]
+            binder = pocket["binder_chain"]
+
+            assert len(binder) == 2
+
+            atom_mask_binder = get_atom_mask_by_name(
+                atom_array=atom_array,
+                entity_id=binder[0],
+                copy_id=binder[1],
+            )
+
+            binder_asym_id = torch.tensor(
+                atom_array.asym_id_int[atom_mask_binder], dtype=torch.long
+            )
+            num_binder = binder_asym_id.unique().numel()
+            if num_binder == 0:
+                logger.info(f"Binder does not exist. {i},{num_binder}")
+            elif num_binder > 1:
+                logger.info(f"#Binders is more than 1. {i},{num_binder}")
+            else:
+                binder_token_list = atom_to_token_idx[atom_mask_binder]
+
+                for j, pocket_res in enumerate(pocket["contact_residues"]):
+                    pocket_res = (
+                        ConstraintFeatureGenerator._canonicalize_pocket_res_format(
+                            binder, pocket_res
+                        )
+                    )
+
+                    atom_mask_pocket = get_atom_mask_by_name(
+                        atom_array=atom_array,
+                        entity_id=pocket_res[0],
+                        copy_id=pocket_res[1],
+                        position=pocket_res[2],
+                    )
+                    pocket_token_list = atom_to_token_idx[atom_mask_pocket]
+
+                    if np.size(pocket_token_list) == 0:
+                        logger.info(f"Pocket not found: {i}:{j}")
+                        continue
+
+                    pocket_specifics.append(
+                        (binder_token_list, pocket_token_list, distance)
+                    )
+                logger.info(f"#pocket:{len(pocket_specifics)}")
+
+        pocket_featurizer = PocketFeaturizer(
+            token_array=token_array, atom_array=atom_array
+        )
+        feature_dict["pocket"], _ = pocket_featurizer.generate_spec_constraint(
+            pocket_specifics,
+            feature_type="continuous",
+        )
+
+        # build substructure features
+        substructure_specifics = {
+            "token_indices": [],
+            "token_coords": [],
+        }
+        if substructure := constraint_param.get("structure", {}):
+            # TODO parse substructure specifics
+            pass
+        substructure_featurizer = SubStructureFeaturizer(
+            token_array=token_array, atom_array=atom_array
+        )
+        feature_dict["substructure"] = substructure_featurizer.generate_spec_constraint(
+            substructure_specifics, feature_type="one_hot"
+        )
+
+        logger.info(
+            f"Loaded constraint feature: #atom contact:{len(atom_contact_specifics)} #contact:{len(token_contact_specifics)} #pocket:{len(pocket_specifics)}"
+        )
+        ConstraintFeatureGenerator._log_constraint_feature(
+            atom_array, token_array, feature_dict
+        )
+
+        return feature_dict, token_array, atom_array
+
+    # function set for training
+    def generate(
+        self,
+        atom_array: AtomArray,
+        token_array: TokenArray,
+        sample_indice: pd.core.series.Series,
+        pdb_indice: pd.core.series.Series,
+        msa_features: dict[str, np.ndarray],
+        max_entity_mol_id: int,
+        full_atom_array: AtomArray,
+    ) -> tuple[
+        TokenArray,
+        AtomArray,
+        dict[str, np.ndarray],
+        dict[str, torch.Tensor],
+        dict[str, Any],
+        torch.Tensor,
+        AtomArray,
+    ]:
+        """Generate all constraint features
+
+        Args:
+            idx: Data index
+            atom_array: Atom array data
+            token_array: Token array data
+            sample_indice: Sample index information
+            pdb_indice: PDB index information
+            msa_features: MSA features
+            max_entity_mol_id: Maximum entity mol id
+            full_atom_array: Full atom array data
+        Returns:
+            Dictionary of constraint features
+        """
+        # Setup constraint generator
+        constraint_generator = self._setup_constraint_generator(sample_indice)
+
+        # Get base features for constraint featurizer
+        features_dict = self._get_base_features(token_array, atom_array)
+
+        # Generate contact atom features
+        (_, contact_atom_featurizer, contact_pairs, tokens_w_atom_contact) = (
+            self._generate_contact_atom_features(
+                atom_array,
+                token_array,
+                constraint_generator,
+                features_dict,
+                pdb_indice,
+            )
+        )
+
+        # Expand token according to atom-contact pairs
+        if len(contact_pairs) > 0:
+            logger.info("Expanding tokens for contact atom constraint feature")
+            token_array, atom_array, contact_pairs, token_map, full_atom_array = (
+                ConstraintFeatureGenerator.expand_tokens(
+                    token_array,
+                    atom_array,
+                    contact_pairs,
+                    features_dict["atom_to_token_dict"],
+                    full_atom_array,
+                )
+            )
+            features_dict = self._get_base_features(token_array, atom_array)
+        else:
+            token_map = {}
+        # make atom contact feature
+        contact_atom_constraint_feature, tokens_w_atom_contact = (
+            contact_atom_featurizer.generate_spec_constraint(
+                contact_pairs,
+                feature_type=self.constraint.get("contact_atom", {}).get(
+                    "feature_type", "continuous"
+                ),
+                shape=(len(token_array), len(token_array), 2),
+            )
+        )
+
+        # Expand MSA features
+        if len(msa_features) > 0 and len(contact_pairs) > 0:
+            msa_features = self.expand_msa_features(msa_features, token_map)
+
+        # Generate pocket features
+        pocket_constraint_feature, _, tokens_w_pocket = self._generate_pocket_features(
+            atom_array,
+            token_array,
+            constraint_generator,
+            sample_indice,
+        )
+
+        # Generate contact features
+        contact_constraint_feature, _, _, tokens_w_contact = (
+            self._generate_contact_features(
+                atom_array,
+                token_array,
+                constraint_generator,
+                features_dict,
+                pdb_indice,
+            )
+        )
+
+        # Generate substructure features
+        (
+            substructure_constraint_feature,
+            substructure_featurizer,
+            tokens_w_substructure,
+        ) = self._generate_substructure_features(
+            atom_array,
+            token_array,
+            constraint_generator,
+            sample_indice,
+        )
+
+        # Combine features
+        constraint_feature = {
+            "contact": contact_constraint_feature,
+            "pocket": pocket_constraint_feature,
+            "contact_atom": contact_atom_constraint_feature,
+            "substructure": substructure_constraint_feature,
+        }
+
+        # change entity_mol_id in case of permutation of constraint pairs
+        featured_tokens = (
+            tokens_w_contact
+            | tokens_w_atom_contact
+            | tokens_w_pocket
+            | tokens_w_substructure
+        )
+
+        if max_entity_mol_id is not None:
+            atom_array, full_atom_array = self.change_entity_mol_id(
+                token_array,
+                atom_array,
+                max_entity_mol_id,
+                full_atom_array,
+                featured_tokens,
+            )
+
+        # Log feature statistics
+        feature_info = self._get_feature_statistics(
+            constraint_feature,
+            atom_array,
+            token_array,
+            features_dict,
+            contact_atom_featurizer,
+            substructure_featurizer,
+        )
+        log_constraint = self._log_feature_statistics(feature_info)
+        return (
+            token_array,
+            atom_array,
+            msa_features,
+            constraint_feature,
+            feature_info,
+            log_constraint,
+            full_atom_array,
+        )
+
+    @staticmethod
+    def expand_tokens(
+        token_array: TokenArray,
+        atom_array: AtomArray,
+        contact_pairs: list[tuple[int, int, float, float]],
+        atom_to_token: dict[int, int],
+        full_atom_array: AtomArray,
+    ) -> tuple[TokenArray, AtomArray, list[tuple[int, int, float, float]]]:
+        """
+        Expand selected tokens into atom-level tokens and update related arrays.
+
+        Args:
+            token_array: Original token array
+            atom_array: Original atom array
+            contact_pairs: Original contact pairs
+            atom_to_token: Atom to token mapping
+            full_atom_array: Full atom array
+        Returns:
+            Updated token array, atom array and transformed constraint pairs
+        """
+        # Update token array
+        tokens_to_expand = set()
+        for atom_i, atom_j, _, _ in contact_pairs:
+            tokens_to_expand.add(atom_to_token[atom_i])
+            tokens_to_expand.add(atom_to_token[atom_j])
+
+        if len(tokens_to_expand) == 0:
+            return token_array, atom_array, contact_pairs, {}, full_atom_array
+
+        new_tokens = []
+        # Maps old token idx to list of new token indices
+        token_map = {}
+        curr_token_idx = 0
+
+        for old_token_idx, token in enumerate(token_array):
+            if old_token_idx in tokens_to_expand:
+                # Check if token represents standard residue
+                centre_atom = atom_array[token.centre_atom_index]
+                if (
+                    centre_atom.res_name in STD_RESIDUES
+                    and centre_atom.mol_type != "ligand"
+                ):
+                    # Expand token into atom-level tokens
+                    atom_tokens = []
+                    for atom_idx, atom_name in zip(
+                        token.atom_indices, token.atom_names
+                    ):
+                        atom = atom_array[atom_idx]
+                        atom_token = Token(ELEMS[atom.element])
+                        atom_token.atom_indices = [atom_idx]
+                        atom_token.atom_names = [atom_name]
+                        atom_token.centre_atom_index = atom_idx
+                        atom_tokens.append(atom_token)
+                    new_tokens.extend(atom_tokens)
+                    token_map[old_token_idx] = list(
+                        range(curr_token_idx, curr_token_idx + len(atom_tokens))
+                    )
+                    curr_token_idx += len(atom_tokens)
+                else:
+                    new_tokens.append(token)
+                    token_map[old_token_idx] = [curr_token_idx]
+                    curr_token_idx += 1
+            else:
+                new_tokens.append(token)
+                token_map[old_token_idx] = [curr_token_idx]
+                curr_token_idx += 1
+
+        updated_token_array = TokenArray(new_tokens)
+
+        # Create atom_idx to new_token_idx mapping for expanded tokens
+        atom_to_new_token = {}
+        for new_token_idx, token in enumerate(updated_token_array):
+            for atom_idx in token.atom_indices:
+                atom_to_new_token[atom_idx] = new_token_idx
+
+        # Update atom array annotations
+        atom_array.centre_atom_mask = np.zeros(len(atom_array), dtype=bool)
+        for token in updated_token_array:
+            atom_array.centre_atom_mask[token.centre_atom_index] = True
+
+        # Update tokatom_idx and distogram_rep_atom_mask
+        expanded_atoms = set()
+
+        for tokens in token_map.values():
+            if len(tokens) > 1:  # Expanded tokens
+                for token_idx in tokens:
+                    token = updated_token_array[token_idx]
+                    expanded_atoms.update(token.atom_indices)
+
+        atom_array.tokatom_idx = np.array(
+            [
+                0 if i in expanded_atoms else idx
+                for i, idx in enumerate(atom_array.tokatom_idx)
+            ]
+        )
+
+        atom_array.distogram_rep_atom_mask = np.array(
+            [
+                1 if i in expanded_atoms else mask
+                for i, mask in enumerate(atom_array.distogram_rep_atom_mask)
+            ]
+        )
+        if len(expanded_atoms) > 0:
+            logger.info(f"Expanded atoms: {expanded_atoms}")
+
+        # Create mapping between atom_array and full_atom_array atoms
+        if full_atom_array is not None:
+            expanded_atom_keys = set()
+            for atom_idx in expanded_atoms:
+                atom = atom_array[atom_idx]
+                # Create unique key using chain_id, res_id and atom_name
+                atom_key = (atom.chain_id, atom.res_id, atom.atom_name)
+                expanded_atom_keys.add(atom_key)
+
+            # Update full_atom_array centre_atom_mask using the mapping
+            full_atom_array.centre_atom_mask = np.array(
+                [
+                    (
+                        1
+                        if (atom.chain_id, atom.res_id, atom.atom_name)
+                        in expanded_atom_keys
+                        else mask
+                    )
+                    for atom, mask in zip(
+                        full_atom_array, full_atom_array.centre_atom_mask
+                    )
+                ]
+            )
+        # Transform constraint pairs using atom_to_new_token mapping
+        transformed_pairs = []
+        for atom_i, atom_j, min_dist, max_dist in contact_pairs:
+            new_token_i = atom_to_new_token[atom_i]
+            new_token_j = atom_to_new_token[atom_j]
+            transformed_pairs.append((new_token_i, new_token_j, min_dist, max_dist))
+
+        return (
+            updated_token_array,
+            atom_array,
+            transformed_pairs,
+            token_map,
+            full_atom_array,
+        )
+
+    def expand_msa_features(
+        self,
+        msa_features: dict[str, np.ndarray],
+        token_map: dict[
+            int, list[int]
+        ],  # Maps old token idx to list of new token indices
+    ) -> dict[str, np.ndarray]:
+        """
+        Expand MSA features for expanded tokens.
+
+        Args:
+            msa_features: Original MSA features
+            token_map: Mapping from old token indices to new token indices
+
+        Returns:
+            Updated MSA features with expanded tokens
+        """
+        # Calculate new number of tokens
+        num_new_tokens = max(max(new_idxs) for new_idxs in token_map.values()) + 1
+
+        old_indices = []
+        new_indices = []
+        for old_idx, new_idxs in token_map.items():
+            old_indices.extend([old_idx] * len(new_idxs))
+            new_indices.extend(new_idxs)
+        old_indices = np.array(old_indices, dtype=int)
+        new_indices = np.array(new_indices, dtype=int)
+
+        # For sequence-based features (msa, has_deletion, deletion_value)
+        for feat_name in ["msa", "has_deletion", "deletion_value"]:
+            if feat_name not in msa_features:
+                continue
+
+            feat = msa_features[feat_name]
+            num_seqs = feat.shape[0]  # Number of sequences in MSA
+
+            # Create new feature array
+            new_feat = np.zeros((num_seqs, num_new_tokens), dtype=feat.dtype)
+
+            # Copy features according to token mapping
+            new_feat = np.zeros((num_seqs, num_new_tokens), dtype=feat.dtype)
+            new_feat[:, new_indices] = feat[:, old_indices]
+            msa_features[feat_name] = new_feat
+
+        # Handle deletion_mean (1D array)
+        if "deletion_mean" in msa_features:
+            feat = msa_features["deletion_mean"]
+            new_feat = np.zeros(num_new_tokens, dtype=feat.dtype)
+            new_feat[new_indices] = feat[old_indices]
+            msa_features["deletion_mean"] = new_feat
+
+        # Handle profile (2D array: tokens x channels)
+        if "profile" in msa_features:
+            feat = msa_features["profile"]
+            num_channels = feat.shape[1]
+            new_feat = np.zeros((num_new_tokens, num_channels), dtype=feat.dtype)
+            new_feat[new_indices, :] = feat[old_indices, :]
+            msa_features["profile"] = new_feat
+
+        return msa_features
+
+    def change_entity_mol_id(
+        self,
+        token_array: TokenArray,
+        atom_array: AtomArray,
+        max_entity_mol_id: int,
+        full_atom_array: AtomArray,
+        featured_tokens: set[int],
+    ) -> tuple[AtomArray, AtomArray]:
+        """Update entity_mol_id for atoms involved in constraints"""
+        if max_entity_mol_id is None or len(featured_tokens) == 0:
+            return atom_array, full_atom_array
+
+        # Get atom indices for all constrained tokens
+        constrained_atom_indices = set()
+        centre_atom_indices = token_array.get_annotation("centre_atom_index")
+
+        for token_idx in featured_tokens:
+            constrained_atom_indices.add(centre_atom_indices[token_idx])
+
+        # Get mol_ids for constrained atoms
+        constrained_mol_ids = set(atom_array.mol_id[list(constrained_atom_indices)])
+
+        # Create mapping for new entity_mol_ids
+        new_id = max_entity_mol_id + 1
+        id_mapping = {}
+        for old_id in constrained_mol_ids:
+            id_mapping[old_id] = new_id
+            new_id += 1
+
+        # Update entity_mol_ids in atom_array
+        for old_id, new_id in id_mapping.items():
+            mask = atom_array.mol_id == old_id
+            atom_array.entity_mol_id[mask] = new_id
+            mask = full_atom_array.mol_id == old_id
+            full_atom_array.entity_mol_id[mask] = new_id
+
+        return atom_array, full_atom_array
+
+    def _get_chain_interface_mask(
+        self,
+        pdb_indice: pd.core.series.Series,
+        atom_array_chain_id: np.array,
+    ) -> tuple[list[torch.Tensor], list[torch.Tensor]]:
+        df = pdb_indice.copy()
+
+        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
+
+        chain_1_mask = df["chain_1_mask"].tolist()  # [N_eval, N_atom]
+        chain_2_mask = df["chain_2_mask"].tolist()  # [N_eval, N_atom]
+
+        return chain_1_mask, chain_2_mask
+
+    def _setup_constraint_generator(self, sample_indice: pd.core.series.Series) -> Any:
+        """Setup random generator with optional fixed seed"""
+        if not self.constraint.get("fix_seed", False):
+            return None
+
+        constraint_seed = int(
+            hashlib.sha256(sample_indice.pdb_id.encode("utf-8")).hexdigest(), 16
+        ) % (2**32)
+        logger.info(
+            f"[constraint_seed seed]: {constraint_seed} for pdb {sample_indice.pdb_id}"
+        )
+        return torch.Generator().manual_seed(constraint_seed)
+
+    def _get_base_features(
+        self, token_array: TokenArray, atom_array: AtomArray
+    ) -> dict[str, Any]:
+        """Get base features for constraint featurizer"""
+        features_dict = {}
+        centre_atoms_indices = token_array.get_annotation("centre_atom_index")
+        centre_atoms = atom_array[centre_atoms_indices]
+        features_dict["asym_id"] = torch.Tensor(centre_atoms.asym_id_int).long()
+
+        atom_to_token_idx_dict = {}
+        for idx, token in enumerate(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(atom_array))
+        ]
+        features_dict["atom_to_token_idx"] = torch.Tensor(atom_to_token_idx).long()
+
+        features_dict["is_dna"] = torch.Tensor(atom_array.is_dna).bool()
+        features_dict["is_rna"] = torch.Tensor(atom_array.is_rna).bool()
+        features_dict["is_ligand"] = torch.Tensor(atom_array.is_ligand).bool()
+        features_dict["atom_to_token_dict"] = atom_to_token_idx_dict
+        return features_dict
+
+    def _generate_pocket_features(
+        self,
+        atom_array: AtomArray,
+        token_array: TokenArray,
+        generator: torch.Generator,
+        sample_indice: pd.core.series.Series,
+    ) -> tuple[torch.Tensor, Any, set[int]]:
+        """Generate pocket constraint features"""
+        # pocket feature
+        pocket_featurizer = PocketFeaturizer(
+            token_array=token_array,
+            atom_array=atom_array,
+            generator=generator,
+        )
+        use_random_pocket = np.random.rand() < self.constraint.get("pocket", {}).get(
+            "prob", 0
+        )
+        if use_random_pocket:
+            binder_asym_id = None
+            if self.constraint["pocket"].get("spec_binder_chain", False):
+                # find ligand binder
+                if sample_indice.mol_1_type == "ligand":
+                    binder_chain_id = str(sample_indice.chain_1_id)
+                elif sample_indice.mol_2_type == "ligand":
+                    binder_chain_id = str(sample_indice.chain_2_id)
+                # find antibody binder
+                elif (
+                    f"{sample_indice.pdb_id.lower()}_{sample_indice.entity_1_id}"
+                    in self.ab_top2_clusters
+                ):
+                    binder_chain_id = str(sample_indice.chain_1_id)
+                elif (
+                    f"{sample_indice.pdb_id.lower()}_{sample_indice.entity_2_id}"
+                    in self.ab_top2_clusters
+                ):
+                    binder_chain_id = str(sample_indice.chain_2_id)
+                else:
+                    binder_chain_id = -1
+                    logger.info(f"No binder found!")
+                binder_asym_id = atom_array.asym_id_int[
+                    atom_array.chain_id == binder_chain_id
+                ]
+                num_unique = len(np.unique(binder_asym_id))
+                assert num_unique <= 1
+                logger.info(f"found binder chains: {num_unique}")
+                binder_asym_id = binder_asym_id[0] if num_unique == 1 else -1
+            pocket_constraint_feature, constrained_tokens = pocket_featurizer.generate(
+                size=self.constraint["pocket"].get("size", 0.0),
+                feature_type=self.constraint["pocket"].get(
+                    "feature_type", "continuous"
+                ),
+                max_distance_range=self.constraint["pocket"].get(
+                    "max_distance_range", {}
+                ),
+                sample_group=self.constraint["pocket"].get("group", "complex"),
+                distance_type=self.constraint["pocket"].get(
+                    "distance_type", "center_atom"
+                ),
+                spec_binder_asym_id=binder_asym_id,
+            )
+        else:
+            pocket_constraint_feature, constrained_tokens = pocket_featurizer.generate(
+                {}, "continuous", size=0, distance_type=None
+            )
+        return pocket_constraint_feature, pocket_featurizer, constrained_tokens
+
+    def _generate_contact_features(
+        self,
+        atom_array: AtomArray,
+        token_array: TokenArray,
+        generator: torch.Generator,
+        features_dict: dict[str, Any],
+        pdb_indice: pd.core.series.Series,
+    ) -> tuple[torch.Tensor, Any, list[tuple[int, int]], set[int]]:
+        """Generate contact constraint features"""
+        contact_featurizer = ContactFeaturizer(
+            token_array=token_array,
+            atom_array=atom_array,
+            generator=generator,
+        )
+        # contact_feature_prob =
+        use_random_contact = np.random.rand() < self.constraint.get("contact", {}).get(
+            "prob", 0
+        )
+        selected_pairs = []
+        if use_random_contact:
+            # collecte all interfaces in cropped_tokens
+            interface_asym_pairs = []
+            if self.constraint["contact"].get("group", "complex") == "interface":
+
+                def _get_asym_id(atom_mask):
+                    token_idx = features_dict["atom_to_token_idx"][
+                        atom_mask.bool()
+                    ].long()
+                    asym_ids = features_dict["asym_id"][token_idx]
+                    assert len(torch.unique(asym_ids)) == 1
+                    return asym_ids[0].item()
+
+                chain_1_mask, chain_2_mask = self._get_chain_interface_mask(
+                    pdb_indice=pdb_indice, atom_array_chain_id=atom_array.chain_id
+                )
+
+                interface_asym_pairs = [
+                    (_get_asym_id(c1), _get_asym_id(c2))
+                    for c1, c2 in zip(chain_1_mask, chain_2_mask)
+                    if not torch.equal(c1, c2)
+                ]
+
+                if len(interface_asym_pairs) == 0:
+                    logger.info("Interface for constraint feature is not found")
+
+            contact_constraint_feature, selected_pairs, constrained_tokens = (
+                contact_featurizer.generate(
+                    size=self.constraint["contact"].get("size", 0.0),
+                    chain_pairs=interface_asym_pairs,
+                    feature_type=self.constraint["contact"].get(
+                        "feature_type", "continuous"
+                    ),
+                    max_distance_range=self.constraint["contact"].get(
+                        "max_distance_range", {}
+                    ),
+                    min_distance_threshold=self.constraint["contact"].get(
+                        "min_distance", 0.0
+                    ),
+                    sample_group=self.constraint["contact"].get("group", "complex"),
+                    distance_type=self.constraint["contact"].get(
+                        "distance_type", "center_atom"
+                    ),
+                )
+            )
+        else:
+            contact_constraint_feature, selected_pairs, constrained_tokens = (
+                contact_featurizer.generate(
+                    {}, None, "continuous", size=0, distance_type=None
+                )
+            )
+        return (
+            contact_constraint_feature,
+            contact_featurizer,
+            selected_pairs,
+            constrained_tokens,
+        )
+
+    def _generate_contact_atom_features(
+        self,
+        atom_array: AtomArray,
+        token_array: TokenArray,
+        generator: torch.Generator,
+        features_dict: dict[str, Any],
+        pdb_indice: pd.core.series.Series,
+    ) -> tuple[torch.Tensor, Any, list[tuple[int, int]], set[int]]:
+        """Generate contact atom constraint features"""
+        contact_atom_featurizer = ContactAtomFeaturizer(
+            token_array=token_array, atom_array=atom_array, generator=generator
+        )
+        use_random_contact_atom = np.random.rand() < self.constraint.get(
+            "contact_atom", {}
+        ).get("prob", 0)
+        selected_pairs = []
+        if use_random_contact_atom:
+            # collecte all interfaces in cropped_tokens
+            interface_asym_pairs = []
+            if self.constraint["contact_atom"].get("group", "complex") == "interface":
+
+                def _get_asym_id(atom_mask):
+                    token_idx = features_dict["atom_to_token_idx"][
+                        atom_mask.bool()
+                    ].long()
+                    asym_ids = features_dict["asym_id"][token_idx]
+                    assert len(torch.unique(asym_ids)) == 1
+                    return asym_ids[0].item()
+
+                chain_1_mask, chain_2_mask = self._get_chain_interface_mask(
+                    pdb_indice=pdb_indice, atom_array_chain_id=atom_array.chain_id
+                )
+
+                interface_asym_pairs = [
+                    (_get_asym_id(c1), _get_asym_id(c2))
+                    for c1, c2 in zip(chain_1_mask, chain_2_mask)
+                    if not torch.equal(c1, c2)
+                ]
+
+                if len(interface_asym_pairs) == 0:
+                    logger.info("Interface for constraint feature is not found")
+
+            contact_atom_constraint_feature, selected_pairs, constrained_tokens = (
+                contact_atom_featurizer.generate(
+                    size=self.constraint["contact_atom"].get("size", 0.0),
+                    chain_pairs=interface_asym_pairs,
+                    feature_type=self.constraint["contact_atom"].get(
+                        "feature_type", "continuous"
+                    ),
+                    max_distance_range=self.constraint["contact_atom"].get(
+                        "max_distance_range", {}
+                    ),
+                    min_distance_threshold=self.constraint["contact_atom"].get(
+                        "min_distance", 0.0
+                    ),
+                    sample_group=self.constraint["contact_atom"].get(
+                        "group", "complex"
+                    ),
+                    distance_type=self.constraint["contact_atom"].get(
+                        "distance_type", "atom"
+                    ),
+                )
+            )
+        else:
+            contact_atom_constraint_feature, selected_pairs, constrained_tokens = (
+                contact_atom_featurizer.generate(
+                    {}, None, "continuous", size=0, distance_type=None
+                )
+            )
+        return (
+            contact_atom_constraint_feature,
+            contact_atom_featurizer,
+            selected_pairs,
+            constrained_tokens,
+        )
+
+    def _generate_substructure_features(
+        self,
+        atom_array: AtomArray,
+        token_array: TokenArray,
+        generator: torch.Generator,
+        sample_indice: pd.core.series.Series,
+    ) -> tuple[torch.Tensor, Any, set[int]]:
+        """Generate substructure constraint features"""
+        substructure_featurizer = SubStructureFeaturizer(
+            token_array=token_array,
+            atom_array=atom_array,
+            generator=generator,
+        )
+        use_random_substructure = np.random.rand() < self.constraint.get(
+            "substructure", {}
+        ).get("prob", 0)
+        if use_random_substructure:
+            spec_asym_id = None
+            if self.constraint["substructure"].get("spec_asym_id", False):
+                # find ligand chain
+                if sample_indice.mol_1_type == "ligand":
+                    binder_chain_id = str(sample_indice.chain_1_id)
+                    target_chain_id = str(sample_indice.chain_2_id)
+                elif sample_indice.mol_2_type == "ligand":
+                    binder_chain_id = str(sample_indice.chain_2_id)
+                    target_chain_id = str(sample_indice.chain_1_id)
+                # find antibody chain
+                elif (
+                    f"{sample_indice.pdb_id.lower()}_{sample_indice.entity_1_id}"
+                    in self.ab_top2_clusters
+                ):
+                    binder_chain_id = str(sample_indice.chain_1_id)
+                    target_chain_id = str(sample_indice.chain_2_id)
+                elif (
+                    f"{sample_indice.pdb_id.lower()}_{sample_indice.entity_2_id}"
+                    in self.ab_top2_clusters
+                ):
+                    binder_chain_id = str(sample_indice.chain_2_id)
+                    target_chain_id = str(sample_indice.chain_1_id)
+                else:
+                    target_chain_id = binder_chain_id = -1
+                    logger.info(f"No specific chain found!")
+
+                chain_choice = self.constraint["substructure"].get(
+                    "spec_chain_type", "binder"
+                )
+                if chain_choice == "binder":
+                    spec_chain_id = binder_chain_id
+                elif chain_choice == "target":
+                    spec_chain_id = target_chain_id
+                else:
+                    raise ValueError(
+                        f"Invalid spec_chain_type: {self.constraint['substructure'].get('spec_chain_type', 'binder')}"
+                    )
+
+                if spec_chain_id != -1:
+                    spec_asym_id = atom_array.asym_id_int[
+                        atom_array.chain_id == spec_chain_id
+                    ]
+                    num_unique = len(np.unique(spec_asym_id))
+                    assert num_unique <= 1
+                    logger.info(f"found {chain_choice} chain: {num_unique}")
+                    spec_asym_id = spec_asym_id[0] if num_unique == 1 else -1
+
+            substructure_constraint_feature, constrained_tokens = (
+                substructure_featurizer.generate(
+                    mol_type_pairs=self.constraint["substructure"].get(
+                        "mol_type_pairs", {}
+                    ),
+                    feature_type=self.constraint["substructure"].get(
+                        "feature_type", "one_hot"
+                    ),
+                    size=self.constraint["substructure"].get("size", 0),
+                    ratios=self.constraint["substructure"].get(
+                        "ratios", {"full": [0.0, 0.5, 1.0], "partial": 0.3}
+                    ),
+                    coord_noise_scale=self.constraint["substructure"].get(
+                        "coord_noise_scale", 0.05
+                    ),
+                    spec_asym_id=spec_asym_id,
+                )
+            )
+        else:
+            substructure_constraint_feature, constrained_tokens = (
+                substructure_featurizer.generate(
+                    mol_type_pairs={},
+                    feature_type="one_hot",
+                    size=0,
+                    ratios={"full": [0.0, 0.5, 1.0], "partial": 0.3},
+                    coord_noise_scale=0.05,
+                    spec_asym_id=None,
+                )
+            )
+        return (
+            substructure_constraint_feature,
+            substructure_featurizer,
+            constrained_tokens,
+        )
+
+    def _get_feature_statistics(
+        self,
+        constraint_feature: dict[str, torch.Tensor],
+        atom_array: AtomArray,
+        token_array: TokenArray,
+        features_dict: dict[str, Any],
+        contact_atom_featurizer: Any,
+        substructure_featurizer: Any,
+    ) -> dict[str, Any]:
+        """Log statistics about generated features"""
+        token_idx_1, token_idx_2 = torch.nonzero(
+            torch.triu(constraint_feature["contact"][..., 1]), as_tuple=True
+        )
+        asym_id_1 = features_dict["asym_id"][token_idx_1]
+        asym_id_2 = features_dict["asym_id"][token_idx_2]
+
+        res_id_1 = atom_array.res_id[
+            token_array[token_idx_1].get_annotation("centre_atom_index")
+        ]
+        res_id_2 = atom_array.res_id[
+            token_array[token_idx_2].get_annotation("centre_atom_index")
+        ]
+        contact_distance = constraint_feature["contact"][token_idx_1, token_idx_2, 1]
+
+        # logging contact atom feature
+        atom_idx_1, atom_idx_2 = torch.nonzero(
+            torch.triu(constraint_feature["contact_atom"][..., 1]), as_tuple=True
+        )
+        contact_atom_real_distance = (
+            contact_atom_featurizer.get_real_distance(atom_idx_1, atom_idx_2)
+            if len(atom_idx_1) > 0
+            else None
+        )
+        contact_atom_max_distance = constraint_feature["contact_atom"][
+            atom_idx_1, atom_idx_2, 1
+        ]
+        contact_atom_min_distance = constraint_feature["contact_atom"][
+            atom_idx_1, atom_idx_2, 0
+        ]
+        num_contact_atom = contact_atom_max_distance.shape[0]
+
+        # logging pocket feature
+        binder_idx, pocket_idx = torch.nonzero(
+            constraint_feature["pocket"].squeeze(-1), as_tuple=True
+        )
+        binder_idx = binder_idx.unique()
+        pocket_idx = pocket_idx.unique()
+        if binder_idx.numel() > 1:
+            pocket_distance = constraint_feature["pocket"][binder_idx[0], pocket_idx, 0]
+        else:
+            pocket_distance = -1
+
+        # logging substructure feature
+        sub_structure_info = substructure_featurizer.analyze_features(
+            constraint_feature["substructure"]
+        )
+
+        feature_info = {
+            "contact_info": {
+                "asym_id": torch.stack([asym_id_1, asym_id_2]),
+                "token_id": torch.stack([token_idx_1, token_idx_2]),
+                "res_id": torch.tensor(np.stack([res_id_1, res_id_2])),
+                "distance": contact_distance,
+            },
+            "contact_atom_info": {
+                "distance": contact_atom_real_distance,
+                "max_distance": contact_atom_max_distance,
+                "min_distance": contact_atom_min_distance,
+                "num_contact_atom": num_contact_atom,
+            },
+            "pocket_info": {
+                "binder_tokenid": binder_idx,
+                "pocket_tokenid": pocket_idx,
+                "distance": pocket_distance,
+            },
+            "substructure_info": sub_structure_info,
+        }
+
+        return feature_info
+
+    def _log_feature_statistics(self, feature_info: dict[str, Any]) -> dict[str, Any]:
+        log_constraint = {}
+        if feature_info.get("pocket_info", None) is not None:
+            binder_tokens, pocket_tokens, distance = feature_info[
+                "pocket_info"
+            ].values()
+            pocket_msg = ";".join(
+                [
+                    ",".join(map(str, binder_tokens.flatten().tolist())),
+                    ",".join(map(str, pocket_tokens.flatten().tolist())),
+                ]
+            )
+            log_constraint["pocket_msg"] = pocket_msg
+            log_constraint["pocket_N_binder"] = torch.tensor(
+                feature_info["pocket_info"]["binder_tokenid"].shape[0]
+            )
+            log_constraint["pocket_N_pocket"] = torch.tensor(
+                feature_info["pocket_info"]["pocket_tokenid"].shape[0]
+            )
+        if feature_info.get("contact_info", None) is not None:
+            asym_id, token_id, res_id, distance = feature_info["contact_info"].values()
+            N_contact = asym_id.shape[-1]
+            contact_msg = ";".join(
+                [
+                    ",".join(map(str, asym_id.flatten().tolist())),
+                    ",".join(map(str, token_id.flatten().tolist())),
+                    ",".join(map(str, distance.flatten().tolist())),
+                ]
+            )
+            log_constraint["contact_N_pair"] = torch.tensor(N_contact)
+            log_constraint["contact_msg"] = contact_msg
+        if feature_info.get("contact_atom_info", None) is not None:
+            distance, max_distance, min_distance, num_contact_atom = feature_info[
+                "contact_atom_info"
+            ].values()
+            N_contact = num_contact_atom
+            log_constraint["contact_atom_N_pair"] = torch.tensor(N_contact)
+            log_constraint["contact_atom_distance"] = distance
+            log_constraint["contact_atom_max_distance"] = max_distance
+            log_constraint["contact_atom_min_distance"] = min_distance
+
+        if feature_info.get("substructure_info", None) is not None:
+            log_constraint["substructure_active_tokens"] = torch.tensor(
+                feature_info["substructure_info"]["num_active_tokens"]
+            )
+            log_constraint["substructure_active_token_ratio"] = torch.tensor(
+                feature_info["substructure_info"]["active_token_ratio"]
+            )
+            log_constraint["substructure_bin0_cnt"] = torch.tensor(
+                feature_info["substructure_info"]["distance_distribution"][
+                    "bin_0_count"
+                ]
+            )
+            log_constraint["substructure_bin1_cnt"] = torch.tensor(
+                feature_info["substructure_info"]["distance_distribution"][
+                    "bin_1_count"
+                ]
+            )
+            log_constraint["substructure_bin2_cnt"] = torch.tensor(
+                feature_info["substructure_info"]["distance_distribution"][
+                    "bin_2_count"
+                ]
+            )
+            log_constraint["substructure_bin3_cnt"] = torch.tensor(
+                feature_info["substructure_info"]["distance_distribution"][
+                    "bin_3_count"
+                ]
+            )
+
+        return log_constraint
+
+
+class ConstraintFeaturizer(object):
+    def __init__(
+        self,
+        token_array: TokenArray,
+        atom_array: AtomArray,
+        pad_value: float = 0,
+        generator=None,
+    ):
+        self.token_array = token_array
+        self.atom_array = atom_array
+        self.pad_value = pad_value
+        self.generator = generator
+        self._get_base_info()
+
+    @staticmethod
+    def one_hot_encoder(feature: torch.Tensor, num_classes: int):
+        # Create mask for padding values (-1)
+        pad_mask = feature == -1
+
+        # Replace -1 with 0 temporarily for F.one_hot
+        feature = torch.where(pad_mask, torch.zeros_like(feature), feature)
+
+        # Convert to one-hot
+        one_hot = F.one_hot(feature, num_classes=num_classes).float()
+
+        # Zero out the one-hot vectors for padding positions
+        one_hot[pad_mask] = 0.0
+
+        return one_hot
+
+    def encode(self, feature: torch.Tensor, feature_type: str, **kwargs):
+        if feature_type == "one_hot":
+            return ConstraintFeaturizer.one_hot_encoder(
+                feature, num_classes=kwargs.get("num_classes", -1)
+            )
+        elif feature_type == "continuous":
+            return feature
+        else:
+            raise RuntimeError(f"Invalid feature_type: {feature_type}")
+
+    def _get_base_info(self):
+        token_centre_atom_indices = self.token_array.get_annotation("centre_atom_index")
+        centre_atoms = self.atom_array[token_centre_atom_indices]
+        self.asymid = torch.tensor(centre_atoms.asym_id_int, dtype=torch.long)
+        self.is_ligand = torch.tensor(centre_atoms.is_ligand, dtype=torch.bool)
+        self.is_protein = torch.tensor(centre_atoms.is_protein, dtype=torch.bool)
+        self.entity_type_dict = {"P": self.is_protein, "L": self.is_ligand}
+
+    def _get_generation_basics(self, distance_type: str = "center_atom"):
+        token_centre_atom_indices = self.token_array.get_annotation("centre_atom_index")
+        centre_atoms = self.atom_array[token_centre_atom_indices]
+
+        # is_resolved mask
+        self.token_resolved_mask = torch.tensor(
+            centre_atoms.is_resolved, dtype=torch.bool
+        )
+        self.token_resolved_maskmat = (
+            self.token_resolved_mask[:, None] * self.token_resolved_mask[None, :]
+        )
+
+        # distance matrix
+        if distance_type == "center_atom":
+            # center atom distance
+            self.token_distance = torch.tensor(
+                cdist(centre_atoms.coord, centre_atoms.coord), dtype=torch.float64
+            )
+        elif distance_type == "any_atom":
+            # any atom distance
+            all_atom_resolved_mask = (
+                self.atom_array.is_resolved[:, None]
+                * self.atom_array.is_resolved[None, :]
+            )
+            all_atom_distance = cdist(self.atom_array.coord, self.atom_array.coord)
+            all_atom_distance[~all_atom_resolved_mask] = np.inf
+
+            token_atoms_num = [
+                len(_atoms)
+                for _atoms in self.token_array.get_annotation("atom_indices")
+            ]
+            atom_token_num = np.repeat(
+                np.arange(len(self.token_array)), token_atoms_num
+            )
+
+            self.token_distance = torch.zeros(
+                (len(centre_atoms), len(centre_atoms)), dtype=torch.float64
+            )
+            for i, j in np.ndindex(self.token_distance.shape):
+                atom_pairs_mask = np.ix_(atom_token_num == i, atom_token_num == j)
+                self.token_distance[i, j] = np.min(all_atom_distance[atom_pairs_mask])
+        elif distance_type == "atom":
+            raise ValueError(
+                "Not implement in this class, please use ContactAtomFeaturizer"
+            )
+        else:
+            raise ValueError(f"Not recognized distance_type: {distance_type}")
+
+    def generate(self):
+        pass
+
+    def generate_spec_constraint(self):
+        pass
+
+
+class ContactFeaturizer(ConstraintFeaturizer):
+    def __init__(self, **kargs):
+        super().__init__(**kargs)
+
+    def get_valid_contact_feature(
+        self,
+        valid_contact_type: str,
+        max_distance_threshold: float,
+        min_distance_threshold: float,
+    ) -> torch.Tensor:
+        """
+        Find all valid pairs of entities that satisfy the given contact distance requirements.
+
+        Parameters:
+         - valid_contact_type: A two-charactor type to represent entity pairs under consideration.
+            e.g. PP, PL, P_
+         - max_distance_threshold: The maximum allowable distance for a contact to be considered valid.
+         - min_distance_threshold: The minimum allowable distance for a contact to be considered valid.
+        Returns:
+         - shape=(N_token, N_token), A matrix generate contact within the specified distance range.
+        """
+        # get valid contact type
+        query_type, key_type = valid_contact_type
+
+        if key_type == "_":
+            # intra chain contact
+            assert query_type == "P", "only support intra-protein contact for now"
+
+            valid_chain_mask = self.asymid[:, None] == self.asymid[None, :]
+
+            # skip closest squence pairs
+            n_neighbor = 20  # TODO: tune this parameter
+            valid_chain_mask_right = torch.triu(valid_chain_mask, diagonal=n_neighbor)
+            valid_chain_mask_left = torch.tril(valid_chain_mask, diagonal=-n_neighbor)
+            valid_chain_mask = valid_chain_mask_right | valid_chain_mask_left
+
+        else:
+            # inter chain contact
+            assert (
+                query_type in "PL" and key_type in "PL"
+            ), f"[Error]contact type not support: {valid_contact_type}"
+
+            valid_type_mask = (
+                self.entity_type_dict[query_type][None, :]
+                & self.entity_type_dict[key_type][:, None]
+            )
+            valid_type_mask |= (
+                self.entity_type_dict[key_type][None, :]
+                & self.entity_type_dict[query_type][:, None]
+            )
+            # get different chain mask
+            valid_chain_mask = self.asymid[:, None] != self.asymid[None, :]
+            valid_chain_mask &= valid_type_mask
+
+        # get min & max distance threshold
+        if min_distance_threshold == -1:  # default false, hard to determine
+            # random select a min threshold in [0, max_distance_threshold), but may lead to zero contact pairs
+            min_distance_threshold = (
+                torch.zeros(1).uniform_(to=max_distance_threshold).item()
+            )
+        valid_dist_mask = (self.token_distance <= max_distance_threshold) & (
+            self.token_distance >= min_distance_threshold
+        )
+
+        # make feature
+        contact_valid_mask = (
+            valid_chain_mask & self.token_resolved_maskmat & valid_dist_mask
+        )
+        return contact_valid_mask
+
+    def _get_constraint_size(self, group: str, size: Any) -> list[int]:
+        """
+        If size is not fixed, then we generate it randomly for each group
+
+        Args:
+            - group: groups types
+        """
+        if group == "complex":
+            k = 1
+        elif group == "interface":
+            N_asym = torch.unique(self.asymid).shape[0]
+            k = (N_asym * N_asym - N_asym) // 2
+        if size < 1 and size > 0:
+            samples = torch.zeros(k).geometric_(size).int().tolist()
+            return samples
+        elif size >= 1 and isinstance(size, int):
+            return [size] * k
+        else:
+            raise NotImplementedError
+
+    def _sample_contacts(
+        self,
+        contact_valid_mask: torch.Tensor,
+        contact_distance_mat: torch.Tensor,
+        size: list[int],
+        sample_group: str,
+        chain_pairs: list[tuple[int, int]],
+    ) -> tuple[torch.Tensor, list[tuple[int, int, float, float]]]:
+        """
+        Randomly select contact from all valid contact pairs
+
+        Args:
+            - contact_valid_mask: shape=(N_token, N_token), all valid contact pairs, bool
+            - size: how many contacts to sample
+            - sample_group: support sample group by 1. whole complex 2. interface
+        """
+        result_mat = torch.full(
+            (contact_valid_mask.shape[0], contact_valid_mask.shape[1], 2),
+            fill_value=self.pad_value,
+            dtype=torch.float32,
+        )
+        selected_pairs = []
+
+        if not contact_valid_mask.any().item():
+            return result_mat, selected_pairs
+
+        def _sample(valid_mask, cur_size):
+            nonlocal selected_pairs
+
+            valid_indices = torch.nonzero(torch.triu(valid_mask))
+            selected_indices = valid_indices[
+                torch.randperm(valid_indices.shape[0], generator=self.generator)[
+                    :cur_size
+                ]
+            ]
+
+            selected_indices = tuple(zip(*selected_indices))
+            if len(selected_indices) == 0:
+                return
+
+            # Convert to pairs format
+            for i, j in zip(*selected_indices):
+                min_dist, max_dist = contact_distance_mat[i, j]
+                selected_pairs.append(
+                    (i.item(), j.item(), min_dist.item(), max_dist.item())
+                )
+                selected_pairs.append(
+                    (j.item(), i.item(), min_dist.item(), max_dist.item())
+                )  # Add symmetric pair
+
+            # add symmetry indices
+            selected_indices = (
+                selected_indices[0] + selected_indices[1],
+                selected_indices[1] + selected_indices[0],
+            )
+            result_mat[selected_indices] = contact_distance_mat[selected_indices]
+            return
+
+        # sample contacts by complex
+        if sample_group == "complex":
+            _sample(contact_valid_mask, size[0])
+        # if group by interface, get all unique interfaces, and sample contact from each interface
+        elif sample_group == "interface":
+            # sample contacts from each interface iteratively
+
+            idx = 0
+            for asym1, asym2 in chain_pairs:
+                asym1_mask, asym2_mask = self.asymid == asym1, self.asymid == asym2
+
+                cur_interface_mask = asym1_mask[..., None, :] & asym2_mask[..., :, None]
+                cur_interface_mask |= (
+                    asym1_mask[..., :, None] & asym2_mask[..., None, :]
+                )
+                valid_contacts_interface = contact_valid_mask & cur_interface_mask
+                _sample(valid_contacts_interface, size[idx])
+                idx += 1
+        else:
+            raise NotImplementedError
+        return result_mat, selected_pairs
+
+    def generate(
+        self,
+        max_distance_range: dict[str, tuple[float, float]],
+        sample_group: str,
+        feature_type: str,
+        size: Any,
+        distance_type: str,
+        min_distance_threshold: float = 0.0,
+        chain_pairs: list[tuple[int, int]] = [],
+        **kwargs,
+    ) -> tuple[torch.Tensor, list[tuple[int, int, float, float]], set[int]]:
+        """
+        training & evaluation
+        """
+        constrained_tokens = set()
+        if size == 0:
+            return (
+                self.encode(
+                    torch.full(
+                        (self.asymid.shape[0], self.asymid.shape[0], 2),
+                        fill_value=self.pad_value,
+                        dtype=torch.float32,
+                    ),
+                    feature_type=feature_type,
+                ),
+                [],
+                constrained_tokens,
+            )
+        self._get_generation_basics(distance_type=distance_type)
+
+        # contact mask
+        n_token = len(self.asymid)
+        contact_valid_mask = torch.zeros((n_token, n_token), dtype=torch.bool)
+        contact_distance_mat = torch.zeros((n_token, n_token, 2), dtype=torch.float32)
+
+        for contact_type, max_d_range in max_distance_range.items():
+            # generate max_distance_mask for different contact type
+            max_distance_threshold = torch.zeros(1).uniform_(*max_d_range).item()
+
+            # get all valid contact pairs
+            contact_mask = self.get_valid_contact_feature(
+                contact_type,
+                max_distance_threshold=max_distance_threshold,
+                min_distance_threshold=min_distance_threshold,
+            )
+            contact_valid_mask |= contact_mask
+            contact_distance_mat[contact_mask] = torch.tensor(
+                [0, max_distance_threshold], dtype=torch.float32
+            )
+
+        # random select contact
+        size = self._get_constraint_size(sample_group, size)
+        sampled_contact_feature, selected_pairs = self._sample_contacts(
+            contact_valid_mask,
+            contact_distance_mat,
+            size,
+            sample_group,
+            chain_pairs,
+        )
+
+        # encode the feature
+        contact_feature = self.encode(
+            feature=sampled_contact_feature, feature_type=feature_type
+        )
+        # Track constrained tokens
+        constrained_tokens = set()
+        for token_i, token_j, _, _ in selected_pairs:
+            constrained_tokens.add(token_i)
+            constrained_tokens.add(token_j)
+
+        return contact_feature, selected_pairs, constrained_tokens
+
+    def generate_spec_constraint(
+        self,
+        contact_specifics: list[tuple[int, int, float, float]],
+        feature_type: str,
+    ) -> tuple[torch.Tensor, set[int]]:
+        """
+        parse constraint from user specification
+        """
+
+        contact_feature = torch.full(
+            (self.asymid.shape[0], self.asymid.shape[0], 2),
+            fill_value=self.pad_value,
+            dtype=torch.float32,
+        )
+        constrained_tokens = set()
+
+        for token_list_1, token_list_2, max_distance, min_distance in contact_specifics:
+            token_id_1 = token_list_1[
+                torch.randint(
+                    high=token_list_1.shape[0], size=(1,), generator=self.generator
+                ).item()
+            ]
+            token_id_2 = token_list_2[
+                torch.randint(
+                    high=token_list_2.shape[0], size=(1,), generator=self.generator
+                ).item()
+            ]
+
+            contact_feature[token_id_1, token_id_2, 1] = max_distance
+            contact_feature[token_id_2, token_id_1, 1] = max_distance
+            contact_feature[token_id_1, token_id_2, 0] = min_distance
+            contact_feature[token_id_2, token_id_1, 0] = min_distance
+
+            constrained_tokens.add(token_id_1)
+            constrained_tokens.add(token_id_2)
+
+        contact_feature = self.encode(
+            feature=contact_feature, feature_type=feature_type
+        )
+        return contact_feature, constrained_tokens
+
+
+class PocketFeaturizer(ConstraintFeaturizer):
+    def __init__(self, **kargs):
+        super().__init__(**kargs)
+
+    def get_valid_pocket_feature(
+        self,
+        binder_pocket_type: str,
+        max_distance_threshold: float,
+        asym_list: list[int],
+    ) -> torch.Tensor:
+        """
+        Parameters:
+            - binder_pocket_type: PP, LP
+            - max_distance_threshold
+            - asym list
+        Returns:
+            - binder_pocket_valid_masks, shape=(N_asym, N_token), A matrix of all pocket tokens within the specified distance range.
+            - max_distance_value, shape=(N_asym, N_token), A matrix of the max_distance_threshold to determine the pocket token for each binder chain
+        """
+        # get valid binder-pocket type, not symmetry
+        query_type, key_type = binder_pocket_type
+        valid_type_mask = (
+            self.entity_type_dict[query_type][:, None]
+            & self.entity_type_dict[key_type][None, :]
+        )
+
+        # get different chain mask
+        diff_chain_mask = self.asymid[:, None] != self.asymid[None, :]
+
+        # get distance mask
+        # Note: To simplify the implementation, we only consider token-token distance, instead of any heavy atom distance for each residue for now.
+        dist_mask = (
+            (self.token_distance <= max_distance_threshold)
+            & self.token_resolved_maskmat
+            & diff_chain_mask
+            & valid_type_mask
+        )
+
+        # pocket mask
+        n_token = len(self.asymid)
+        n_asym = len(asym_list)
+        binder_pocket_valid_masks = torch.zeros((n_asym, n_token), dtype=torch.bool)
+
+        for idx, asym_id in enumerate(asym_list):
+            cur_chain_dist_mask = (
+                self.asymid[:, None].expand(-1, self.asymid.shape[0]) == asym_id
+            )
+            if cur_chain_dist_mask[:, 0].sum() > 1:  # ensure num of binder tokens > 1
+                cur_chain_dist_mask = cur_chain_dist_mask & dist_mask
+                cur_valid_mask = cur_chain_dist_mask.any(dim=0)
+                binder_pocket_valid_masks[idx] = cur_valid_mask
+        return binder_pocket_valid_masks
+
+    def _sample_pocket(
+        self,
+        binder_pocket_valid_masks: torch.Tensor,
+        size: Any,
+        asym_list: list[int],
+        max_distance_value: torch.Tensor,
+        spec_binder_asym_id: Any = None,
+        **_,  # do not use
+    ) -> torch.Tensor:
+        pocket_dist_feature = torch.full(
+            (self.asymid.shape[0], self.asymid.shape[0]),
+            fill_value=self.pad_value,
+            dtype=torch.float32,
+        )
+        if spec_binder_asym_id is None:
+            # random select 1 binder with valid pocket
+            binders_with_valid_pocket = torch.nonzero(
+                binder_pocket_valid_masks.any(-1), as_tuple=True
+            )[0]
+            if len(binders_with_valid_pocket) == 0:
+                return pocket_dist_feature
+            selected_binder = binders_with_valid_pocket[
+                torch.randperm(
+                    binders_with_valid_pocket.shape[0], generator=self.generator
+                )[0]
+            ]
+        else:
+            selected_binder = torch.nonzero(
+                asym_list == spec_binder_asym_id, as_tuple=True
+            )[0].squeeze()
+        selected_all_pocket_res = binder_pocket_valid_masks[selected_binder]
+        binder_asym_id = (
+            asym_list[selected_binder]
+            if spec_binder_asym_id is None
+            else spec_binder_asym_id
+        )
+
+        # random select k residues within the selected pocket
+        selected_pocket_res_mask = torch.zeros(self.asymid.shape[0], dtype=torch.bool)
+        valid_pockets = torch.nonzero(selected_all_pocket_res, as_tuple=True)[0]
+        selected_pocket_res_indices = torch.randperm(
+            valid_pockets.shape[0], generator=self.generator
+        )[:size]
+        selected_pocket_res_mask[valid_pockets[selected_pocket_res_indices]] = True
+
+        binder_pocket_mask_mat = (self.asymid == binder_asym_id)[
+            :, None
+        ] * selected_pocket_res_mask[None, :]
+
+        # set distance threshold to selected pocket
+        # [binder_mask, pocket_mask]
+        binder_dist_mat = max_distance_value[selected_binder][selected_pocket_res_mask][
+            None, :
+        ].expand((self.asymid == binder_asym_id).sum(), -1)
+
+        pocket_dist_feature[binder_pocket_mask_mat] = binder_dist_mat.reshape(-1)
+
+        return pocket_dist_feature
+
+    def generate(
+        self,
+        max_distance_range: dict[str, tuple[float, float]],
+        feature_type: str,
+        size: Any,
+        distance_type: Any,
+        spec_binder_asym_id: int = None,
+        **_,  # do not use
+    ) -> tuple[torch.Tensor, set[int]]:
+        """
+        trainint & evaluation
+        """
+        constrained_tokens = set()
+        if size == 0 or spec_binder_asym_id == -1:
+            pocket_dist_feature = self.encode(
+                torch.full(
+                    (self.asymid.shape[0], self.asymid.shape[0], 1),
+                    fill_value=self.pad_value,
+                    dtype=torch.float32,
+                ),
+                feature_type=feature_type,
+            )  # [..., N_token, 1]
+
+            return pocket_dist_feature, constrained_tokens
+        self._get_generation_basics(distance_type=distance_type)
+
+        # get all binder-pocket pairs & masks
+        n_token = len(self.asymid)
+        asym_list = torch.unique(self.asymid, sorted=True)
+        n_asym = len(asym_list)
+        binder_pocket_valid_masks = torch.zeros((n_asym, n_token), dtype=torch.bool)
+        max_distance_value = torch.zeros((n_asym, n_token), dtype=torch.float32)
+        for binder_pocket_type, max_d_range in max_distance_range.items():
+            # generate max_distance_mask for different binder_pocket type
+            max_distance_threshold = torch.zeros(1).uniform_(*max_d_range).item()
+
+            # get all valid binder-pocket pairs
+            valid_pocket_token_mask = self.get_valid_pocket_feature(
+                binder_pocket_type,
+                max_distance_threshold=max_distance_threshold,
+                asym_list=asym_list,
+            )
+            binder_pocket_valid_masks |= valid_pocket_token_mask
+            max_distance_value[valid_pocket_token_mask] = max_distance_threshold
+
+        # random select k residues from pocket, only consider one binder
+        size = self._get_constraint_size(size)
+        sampled_pocket_feature = self._sample_pocket(
+            binder_pocket_valid_masks,
+            size,
+            asym_list,
+            max_distance_value,
+            spec_binder_asym_id,
+        ).unsqueeze(-1)
+
+        # encode the feature
+        pocket_dist_feature = self.encode(
+            feature=sampled_pocket_feature, feature_type=feature_type
+        )
+        # Track constrained tokens
+        nonzero_indices = torch.nonzero(pocket_dist_feature)
+        for i, j, _ in nonzero_indices:
+            constrained_tokens.add(i.item())
+            constrained_tokens.add(j.item())
+
+        return pocket_dist_feature, constrained_tokens
+
+    def generate_spec_constraint(
+        self, pocket_specifics, feature_type: str
+    ) -> tuple[torch.Tensor, set[int]]:
+        """
+        parse constraint from user specification
+        """
+        pocket_dist_mat = torch.full(
+            (self.asymid.shape[0], self.asymid.shape[0], 1),
+            fill_value=self.pad_value,
+            dtype=torch.float32,
+        )
+
+        for binder_token_list, pocket_token_list, max_distance in pocket_specifics:
+            pocket_token_id = pocket_token_list[
+                torch.randint(
+                    high=pocket_token_list.shape[0], size=(1,), generator=self.generator
+                ).item()
+            ]
+
+            binder_token_idx = torch.tensor(binder_token_list)[:, None]
+            pocket_dist_mat[binder_token_idx, pocket_token_id, 0] = max_distance
+
+        pocket_dist_feature = self.encode(
+            feature=pocket_dist_mat, feature_type=feature_type
+        )
+
+        constrained_tokens = set()
+        nonzero_indices = torch.nonzero(pocket_dist_feature)
+        for binder_token_id, pocket_token_id, _ in nonzero_indices:
+            constrained_tokens.add(binder_token_id)
+            constrained_tokens.add(pocket_token_id)
+        return pocket_dist_feature, constrained_tokens
+
+    def _get_constraint_size(self, size) -> list[int]:
+        """
+        If size is not fixed, then we generate it randomly for each group
+        """
+        if size < 1 and size > 0:
+            # TODO: to be determined!
+            samples = torch.zeros(1).geometric_(size).int().tolist()[0]
+            return samples
+        elif size >= 1 and isinstance(size, int):
+            return size
+        else:
+            raise NotImplementedError
+
+
+class ContactAtomFeaturizer(ContactFeaturizer):
+    def __init__(
+        self,
+        token_array: TokenArray,
+        atom_array: AtomArray,
+        pad_value: float = 0,
+        generator=None,
+    ):
+        self.token_array = token_array
+        self.atom_array = atom_array
+        self.pad_value = pad_value
+        self.generator = generator
+        self._get_base_info()
+
+    def _get_base_info(self):
+        self.asymid = torch.tensor(self.atom_array.asym_id_int, dtype=torch.long)
+        self.is_ligand = torch.tensor(self.atom_array.is_ligand, dtype=torch.bool)
+        self.is_protein = torch.tensor(self.atom_array.is_protein, dtype=torch.bool)
+        self.entity_type_dict = {"P": self.is_protein, "L": self.is_ligand}
+
+    def _get_generation_basics(self, distance_type="atom"):
+        # is_resolved mask
+        self.token_resolved_mask = torch.tensor(
+            self.atom_array.is_resolved, dtype=torch.bool
+        )
+        self.token_resolved_maskmat = (
+            self.token_resolved_mask[:, None] * self.token_resolved_mask[None, :]
+        )
+
+        # distance matrix
+        self.token_distance = torch.tensor(
+            cdist(self.atom_array.coord, self.atom_array.coord), dtype=torch.float64
+        )
+
+    def generate_spec_constraint(
+        self,
+        contact_specifics: list[tuple[int, int, float, float]],
+        feature_type: str,
+        shape: tuple[int, int, int],
+    ) -> tuple[torch.Tensor, set[int]]:
+        """
+        parse constraint from user specification
+        """
+
+        contact_feature = torch.full(
+            shape, fill_value=self.pad_value, dtype=torch.float32
+        )
+        for token_id_1, token_id_2, max_distance, min_distance in contact_specifics:
+            contact_feature[token_id_1, token_id_2, 1] = max_distance
+            contact_feature[token_id_2, token_id_1, 1] = max_distance
+            contact_feature[token_id_1, token_id_2, 0] = min_distance
+            contact_feature[token_id_2, token_id_1, 0] = min_distance
+
+        contact_feature = self.encode(
+            feature=contact_feature, feature_type=feature_type
+        )
+        constrained_tokens = set()
+        for token_id_1, token_id_2, _, _ in contact_specifics:
+            constrained_tokens.add(token_id_1)
+            constrained_tokens.add(token_id_2)
+        return contact_feature, constrained_tokens
+
+    def get_real_distance(self, atom_idx_1: int, atom_idx_2: int) -> float:
+        return self.token_distance[atom_idx_1, atom_idx_2]
+
+
+class SubStructureFeaturizer(ConstraintFeaturizer):
+    def __init__(self, **kargs):
+        super().__init__(**kargs)
+        # Default distance bins
+        self.distance_bins = torch.tensor([0, 4, 8, 16, torch.inf])
+
+    def _add_coordinate_noise(self, coord_noise_scale: float = 0.05) -> torch.Tensor:
+        """Add Gaussian noise to coordinates"""
+        # Convert coordinates to tensor first
+        coords = torch.tensor(self.atom_array.coord)
+        if coord_noise_scale <= 0:
+            return coords
+        noisy_coords = (
+            coords
+            + torch.randn(
+                coords.shape,
+                generator=self.generator,
+            )
+            * coord_noise_scale
+        )
+
+        return noisy_coords
+
+    def _get_distance_feature(
+        self,
+        selected_token_mask: torch.Tensor,
+        coord_noise_scale: float = 0.05,
+        feature_type: str = "one_hot",
+    ) -> torch.Tensor:
+        """
+        Encode pairwise distances between selected tokens into binned one-hot features
+
+        Parameters:
+            - selected_token_mask: Boolean mask of selected tokens
+            - coord_noise_scale: Scale of Gaussian noise to add to coordinates
+            - feature_type: "one_hot" or "continuous"
+
+        Returns:
+            - distance_feature: For one_hot: [..., N_token, N_token] tensor with bin indices
+                              For continuous: [..., N_token, N_token] tensor with distance values
+        """
+        n_tokens = len(self.asymid)
+
+        # Initialize output tensor
+        distance_feature = torch.full(
+            (n_tokens, n_tokens),
+            fill_value=-1 if feature_type == "one_hot" else self.pad_value,
+            dtype=torch.long if feature_type == "one_hot" else torch.float32,
+        )
+
+        # Get selected token indices
+        selected_tokens = torch.nonzero(selected_token_mask).squeeze(-1)
+        if len(selected_tokens) <= 1:
+            return distance_feature
+
+        # Add noise to coordinates and calculate distances
+        noisy_coords = self._add_coordinate_noise(coord_noise_scale)
+
+        # Get token center atom indices
+        token_centre_atom_indices = torch.tensor(
+            self.token_array.get_annotation("centre_atom_index"), dtype=torch.long
+        )
+        selected_indices = token_centre_atom_indices[selected_tokens.long()]
+        selected_coords = noisy_coords[selected_indices]
+
+        # Calculate pairwise distances between selected tokens
+        pairwise_distances = torch.cdist(selected_coords, selected_coords)
+
+        if feature_type == "one_hot":
+            # Digitize distances into bins
+            binned_distances = (
+                torch.bucketize(pairwise_distances, self.distance_bins, right=True) - 1
+            )
+
+            # Create mask for valid bins
+            valid_bins = binned_distances > 0
+
+            # Create indices for the full matrix
+            rows = selected_tokens.repeat_interleave(len(selected_tokens))
+            cols = selected_tokens.repeat(len(selected_tokens))
+
+            # Get valid indices and their corresponding bin values
+            valid_mask = valid_bins.flatten()
+            valid_rows = rows[valid_mask]
+            valid_cols = cols[valid_mask]
+            valid_bins = binned_distances.flatten()[valid_mask]
+
+            # Fill the distance feature matrix
+            distance_feature[valid_rows, valid_cols] = valid_bins
+            distance_feature[valid_cols, valid_rows] = valid_bins  # symmetric
+
+        else:  # continuous
+            # Create indices for the full matrix
+            rows = selected_tokens.repeat_interleave(len(selected_tokens))
+            cols = selected_tokens.repeat(len(selected_tokens))
+
+            # Fill the distance feature matrix
+            distance_feature[rows, cols] = pairwise_distances.flatten()
+            distance_feature[cols, rows] = pairwise_distances.flatten()  # symmetric
+
+        return distance_feature
+
+    def get_valid_substructure_feature(
+        self, mol_type_pairs: dict[str, float]
+    ) -> torch.Tensor:
+        """
+        Find valid chains that form interfaces based on mol_type_pairs
+
+        Parameters:
+            - mol_type_pairs: Dict of type pairs (e.g. {'PP': threshold, 'LP': threshold})
+                First type in pair is the one to be selected as substructure, threshold is the distance threshold to determine the interface
+        Returns:
+            - valid_asym_ids: List of valid asym_ids that can form interfaces
+        """
+        valid_asym_ids = []
+
+        for type_pair, threshold in mol_type_pairs.items():
+            # Parse type pair (e.g. 'PP' -> ('P','P'))
+            query_type, key_type = type_pair
+
+            # Get type masks
+            valid_type_mask = (
+                self.entity_type_dict[query_type][:, None]
+                & self.entity_type_dict[key_type][None, :]
+            )
+
+            # Get different chain mask
+            diff_chain_mask = self.asymid[:, None] != self.asymid[None, :]
+
+            # Get distance mask
+            dist_mask = (
+                (self.token_distance <= threshold)
+                & self.token_resolved_maskmat
+                & diff_chain_mask
+                & valid_type_mask
+            )
+
+            # Find chains that form interfaces
+            for asym_id in torch.unique(self.asymid):
+                # Only consider chains of query_type
+                if not self.entity_type_dict[query_type][self.asymid == asym_id].any():
+                    continue
+
+                # Check if this chain forms interface with any chain of key_type
+                cur_chain_mask = self.asymid == asym_id
+                other_chains_mask = ~cur_chain_mask
+
+                has_interface = (dist_mask[cur_chain_mask][:, other_chains_mask]).any()
+
+                if has_interface:
+                    valid_asym_ids.append(asym_id)
+
+        return torch.tensor(valid_asym_ids)
+
+    def _get_constraint_size(self, size: Any) -> int:
+        """
+        If size is not fixed, then we generate it randomly
+
+        Args:
+            - size: If >=1, randomly select chains; if <1, select size chains
+        Returns:
+            - size: Number of chains/proportion of tokens to select
+        """
+        if size < 1 and size > 0:
+            # For size < 1, use as proportion directly
+            return torch.rand(1).geometric_(size, generator=self.generator).int().item()
+        elif size >= 1 and isinstance(size, (int, float)):
+            # For size >= 1, return the size directly
+            return int(size)
+        else:
+            raise NotImplementedError(f"Invalid size: {size}")
+
+    def _sample_substructure(
+        self,
+        valid_asym_ids: torch.Tensor,
+        size: Any,
+        ratios: dict[str, list[float]],
+        spec_asym_id: Any = None,
+    ) -> torch.Tensor:
+        """
+        Sample substructure based on size and ratios
+
+        Parameters:
+            - valid_asym_ids: List of valid asym_ids
+            - size: Total number of chains to select
+            - ratios: Dict containing:
+                - full: List of possible proportions for full chain selection
+                - partial: Proportion of tokens to select for partial chains [0,1]
+            - spec_asym_id: If provided, select from this specific chain
+        """
+        selected_token_mask = torch.zeros(len(self.asymid), dtype=torch.bool)
+
+        if len(valid_asym_ids) == 0:
+            return selected_token_mask
+
+        # Handle spec_asym_id case
+        if spec_asym_id is not None:
+            if spec_asym_id not in valid_asym_ids:
+                return selected_token_mask
+            # Use partial_ratio for spec_asym_id
+            chain_mask = (self.asymid == spec_asym_id) & self.token_resolved_mask
+            chain_tokens = torch.nonzero(chain_mask).squeeze()
+            if len(chain_tokens) == 0:  # Skip if no resolved tokens
+                return selected_token_mask
+            num_tokens = max(1, int(len(chain_tokens) * ratios["partial"]))
+            selected_tokens = chain_tokens[
+                torch.randperm(len(chain_tokens), generator=self.generator)[:num_tokens]
+            ]
+            selected_token_mask[selected_tokens] = True
+            return selected_token_mask
+
+        # Regular case: sample based on size and ratios
+        if size == 0:
+            return selected_token_mask
+
+        # Randomly select full chain ratio from the list
+        full_ratio_idx = torch.randint(
+            len(ratios["full"]), (1,), generator=self.generator
+        ).item()
+        full_ratio = ratios["full"][full_ratio_idx]
+
+        # Calculate number of chains for full and partial selection
+        num_full_chains = min(int(size * full_ratio), len(valid_asym_ids))
+        num_partial_chains = min(
+            size - num_full_chains, len(valid_asym_ids) - num_full_chains
+        )
+
+        # Randomly shuffle and split valid_asym_ids
+        shuffled_indices = torch.randperm(len(valid_asym_ids), generator=self.generator)
+        full_chain_ids = valid_asym_ids[shuffled_indices[:num_full_chains]]
+        partial_chain_ids = valid_asym_ids[
+            shuffled_indices[num_full_chains : num_full_chains + num_partial_chains]
+        ]
+
+        # Select full chains
+        for asym_id in full_chain_ids:
+            chain_mask = (self.asymid == asym_id) & self.token_resolved_mask
+            selected_token_mask |= chain_mask
+        # Select partial chains
+        for asym_id in partial_chain_ids:
+            chain_mask = (self.asymid == asym_id) & self.token_resolved_mask
+            chain_tokens = torch.nonzero(chain_mask).squeeze(-1)
+            if len(chain_tokens) == 0:  # Skip if no resolved tokens
+                continue
+            num_tokens = max(
+                1,
+                int(len(chain_tokens) * torch.rand(1, generator=self.generator).item()),
+            )
+            selected_tokens = chain_tokens[
+                torch.randperm(len(chain_tokens), generator=self.generator)[:num_tokens]
+            ]
+            selected_token_mask[selected_tokens] = True
+
+        return selected_token_mask
+
+    def generate(
+        self,
+        mol_type_pairs: dict[str, float],
+        feature_type: str,
+        size: Any,
+        ratios: dict[str, list[float]],
+        coord_noise_scale: float,
+        spec_asym_id: int = None,
+    ) -> tuple[torch.Tensor, set[int]]:
+        """
+        Generate substructure features
+
+        Parameters:
+            - mol_type_pairs: Dict of type pairs and their distance thresholds
+            - feature_type: Type of feature encoding
+            - size: Number of chains to select
+            - ratios: Dict containing:
+                - full: List of possible proportions for full chain selection
+                - partial: Proportion of tokens to select for partial chains [0,1]
+            - coord_noise_scale: Scale of Gaussian noise to add to coordinates
+            - spec_asym_id: Specific chain to select from
+        """
+        constrained_tokens = set()
+        if size == 0 or spec_asym_id == -1:
+            distance_feature = torch.full(
+                (self.asymid.shape[0], self.asymid.shape[0]),
+                fill_value=-1 if feature_type == "one_hot" else self.pad_value,
+                dtype=torch.long if feature_type == "one_hot" else torch.float32,
+            )
+            return (
+                self.encode(
+                    feature=distance_feature,
+                    feature_type=feature_type,
+                    num_classes=len(self.distance_bins) - 1,
+                ),
+                constrained_tokens,
+            )
+
+        self._get_generation_basics()
+
+        # Get valid asym_ids that form interfaces
+        valid_asym_ids = self.get_valid_substructure_feature(mol_type_pairs)
+
+        if len(valid_asym_ids) == 0:
+            distance_feature = torch.full(
+                (self.asymid.shape[0], self.asymid.shape[0]),
+                fill_value=-1 if feature_type == "one_hot" else self.pad_value,
+                dtype=torch.long if feature_type == "one_hot" else torch.float32,
+            )
+            return (
+                self.encode(
+                    feature=distance_feature,
+                    feature_type=feature_type,
+                    num_classes=len(self.distance_bins) - 1,
+                ),
+                constrained_tokens,
+            )
+
+        size = self._get_constraint_size(size)
+
+        # Sample tokens based on ratio and spec_asym_id
+        selected_token_mask = self._sample_substructure(
+            valid_asym_ids, size, ratios, spec_asym_id
+        )
+
+        # Get distance features (bin indices)
+        distance_feature = self._get_distance_feature(
+            selected_token_mask, coord_noise_scale, feature_type
+        )
+
+        # Track constrained tokens
+        constrained_tokens = set(torch.nonzero(selected_token_mask).flatten().tolist())
+
+        # Encode using base class method
+        return (
+            self.encode(
+                feature=distance_feature,
+                feature_type=feature_type,
+                num_classes=len(self.distance_bins) - 1,
+            ),
+            constrained_tokens,
+        )
+
+    def analyze_features(self, feature_tensor: torch.Tensor) -> dict[str, Any]:
+        """
+        Analyze the features generated by the generate method
+        """
+        is_one_hot = len(feature_tensor.shape) == 3
+        n_tokens = feature_tensor.shape[0]
+        if is_one_hot:
+            # For one-hot features
+            # A token is active if it has any non-zero one-hot vector
+            has_valid_distance = torch.any(feature_tensor, dim=-1)
+            active_tokens = torch.any(has_valid_distance, dim=1)
+
+            # Get distribution of distance bins (excluding zero vectors)
+            valid_distances = feature_tensor[has_valid_distance]
+            bin_counts = torch.sum(valid_distances, dim=0)  # Sum over all valid pairs
+            distance_stats = {
+                f"bin_{i}_count": count.item() for i, count in enumerate(bin_counts)
+            }
+
+        else:
+            # For continuous features
+            # A token is active if it has any non-zero distance to other tokens
+            has_valid_distance = feature_tensor != 0
+            active_tokens = torch.any(has_valid_distance, dim=1)
+
+            # Get distribution of actual distances (excluding zeros)
+            valid_distances = feature_tensor[has_valid_distance]
+            if len(valid_distances) > 0:
+                distance_stats = {
+                    "mean": valid_distances.mean().item(),
+                    "std": valid_distances.std().item(),
+                    "min": valid_distances.min().item(),
+                    "max": valid_distances.max().item(),
+                }
+            else:
+                distance_stats = {"mean": 0.0, "std": 0.0, "min": 0.0, "max": 0.0}
+
+        stats = {
+            "num_active_tokens": active_tokens.sum().item(),
+            "active_token_ratio": (active_tokens.sum().item() / n_tokens),
+            "distance_distribution": distance_stats,
+        }
+
+        return stats
+
+    def generate_spec_constraint(self, substructure_specifics, feature_type):
+        """parse constraint from user specification
+
+        Args:
+            substructure_specifics (Dict): dictionary speicifing fixed tokens
+                token_indices: List[int]
+                token_coords: List[List[float]]
+            feature_type: 'ont hot' by default
+        """
+        distance_feature_mat = torch.full(
+            (self.asymid.shape[0], self.asymid.shape[0]),
+            fill_value=-1 if feature_type == "one_hot" else self.pad_value,
+            dtype=torch.long if feature_type == "one_hot" else torch.float32,
+        )
+
+        if len(substructure_specifics["token_indices"]) > 0:
+            token_indices = torch.tensor(substructure_specifics["token_indices"])
+            coords = torch.tensor(substructure_specifics["token_coords"])
+
+            distance_mat = torch.cdist(coords, coords)
+            distance_feature_mat[token_indices[:, None], token_indices[None, :]] = (
+                distance_mat
+            )
+
+        distance_feature_mat = self.encode(
+            distance_feature_mat, feature_type, num_classes=len(self.distance_bins) - 1
+        )
+
+        return distance_feature_mat

protenix/data/data_pipeline.py

@@ -0,0 +1,373 @@
+# 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
+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.parser import DistillationMMCIFParser, MMCIFParser
+from protenix.data.tokenizer import AtomArrayTokenizer, 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):
+    """
+    DataPipeline class provides static methods to handle various data processing tasks related to bioassembly structures.
+    """
+
+    @staticmethod
+    def get_data_from_mmcif(
+        mmcif: Union[str, Path],
+        pdb_cluster_file: Union[str, Path, None] = None,
+        dataset: str = "WeightedPDB",
+        interface_radius: float = 5,
+    ) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+        """
+        Get raw data from mmcif with tokenizer and a list of chains and interfaces for sampling.
+
+        Args:
+            mmcif (Union[str, Path]): The raw mmcif file.
+            pdb_cluster_file (Union[str, Path, None], optional): Cluster info txt file. Defaults to None.
+            dataset (str, optional): The dataset type, either "WeightedPDB" or "Distillation". Defaults to "WeightedPDB".
+            interface_radius (float, optional): The radius of the interface. Defaults to 5.
+        Returns:
+            tuple[list[dict[str, Any]], dict[str, Any]]:
+                sample_indices_list (list[dict[str, Any]]): The sample indices list (each one is a chain or an interface).
+                bioassembly_dict (dict[str, Any]): The bioassembly dict with sequence, atom_array, and token_array.
+        """
+        try:
+            if dataset == "WeightedPDB":
+                parser = MMCIFParser(mmcif_file=mmcif)
+                bioassembly_dict = parser.get_bioassembly()
+            elif dataset == "Distillation":
+                parser = DistillationMMCIFParser(mmcif_file=mmcif)
+                bioassembly_dict = parser.get_structure_dict()
+            else:
+                raise NotImplementedError(
+                    'Unsupported "dataset", please input either "WeightedPDB" or "Distillation".'
+                )
+
+            sample_indices_list = parser.make_indices(
+                bioassembly_dict=bioassembly_dict,
+                pdb_cluster_file=pdb_cluster_file,
+                interface_radius=interface_radius,
+            )
+            if len(sample_indices_list) == 0:
+                # empty indices and AtomArray
+                return [], bioassembly_dict
+
+            atom_array = bioassembly_dict["atom_array"]
+            atom_array.set_annotation(
+                "resolution", [parser.resolution] * len(atom_array)
+            )
+
+            tokenizer = AtomArrayTokenizer(atom_array)
+            token_array = tokenizer.get_token_array()
+            bioassembly_dict["msa_features"] = None
+            bioassembly_dict["template_features"] = None
+
+            bioassembly_dict["token_array"] = token_array
+            return sample_indices_list, bioassembly_dict
+
+        except Exception as e:
+            logging.warning("Gen data failed for %s due to %s", mmcif, e)
+            return [], {}
+
+    @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,
+        )

protenix/data/dataloader.py

@@ -0,0 +1,373 @@
+# 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
+from protenix.utils.torch_utils import collate_fn_first
+
+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=collate_fn_first,
+            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=collate_fn_first,
+            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=collate_fn_first,
+        )
+    logger.info(
+        f"train data size: {len(train_dataset)}, test size: {test_dataset_sizes}"
+    )
+    return train_dl, test_dls

protenix/data/dataset.py

@@ -0,0 +1,1182 @@
+# 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.constraint_featurizer import ConstraintFeatureGenerator
+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,
+    get_antibody_clusters,
+    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
+        # Configs for constraint
+        self.constraint = kwargs.get("constraint", {})
+        if self.constraint.get("enable", False):
+            logger.info(f"[{self.name}] constraint config: {self.constraint}")
+            # Do not rely on new files for users who do not use constraint feature
+            self.ab_top2_clusters = get_antibody_clusters()
+            self.constraint_generator = ConstraintFeatureGenerator(
+                self.constraint, self.ab_top2_clusters
+            )
+
+        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"]
+            )
+
+        max_entity_mol_id = bioassembly_dict["atom_array"].entity_mol_id.max()
+
+        # 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(),
+            max_entity_mol_id=max_entity_mol_id,
+        )
+
+        # 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_pdb_indice(self, idx: int) -> pd.core.series.Series:
+        if self.group_by_pdb_id:
+            pdb_indice = self.indices_list[idx].copy()
+        else:
+            pdb_indice = self.indices_list.iloc[idx : idx + 1].copy()
+        return pdb_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_constraint_feature(
+        self,
+        idx,
+        atom_array,
+        token_array,
+        msa_features,
+        max_entity_mol_id,
+        full_atom_array,
+    ):
+        sample_indice = self._get_sample_indice(idx=idx)
+        pdb_indice = self._get_pdb_indice(idx=idx)
+        features_dict = {}
+        (
+            token_array,
+            atom_array,
+            msa_features,
+            constraint_feature_dict,
+            feature_info,
+            log_dict,
+            full_atom_array,
+        ) = self.constraint_generator.generate(
+            atom_array,
+            token_array,
+            sample_indice,
+            pdb_indice,
+            msa_features,
+            max_entity_mol_id,
+            full_atom_array,
+        )
+        features_dict["constraint_feature"] = constraint_feature_dict
+        features_dict.update(feature_info)
+        features_dict["constraint_log_info"] = log_dict
+        return token_array, atom_array, features_dict, msa_features, full_atom_array
+
+    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,
+        max_entity_mol_id: int = None,
+    ) -> 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.
+            max_entity_mol_id: Maximum entity mol ID in the full atom array.
+        Returns:
+            A tuple containing the feature dictionary and the label dictionary.
+
+        Raises:
+            ValueError: If the ligand cannot be found in the data point.
+        """
+        features_dict = {}
+        if self.constraint.get("enable", False):
+            token_array, atom_array, features_dict, msa_features, full_atom_array = (
+                self.get_constraint_feature(
+                    idx,
+                    atom_array,
+                    token_array,
+                    msa_features,
+                    max_entity_mol_id,
+                    full_atom_array,
+                )
+            )
+
+        # 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.update(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: Optional[dict] = None,
+    alpha_dict: Optional[dict] = None,
+) -> float:
+    """
+    Get sample weight for each example in a weighted PDB dataset.
+
+        data_type (str): Type of data, either 'chain' or 'interface'.
+        cluster_size (int): Cluster size of this chain/interface.
+        chain_count (dict): Count of each kind of chains, e.g., {"prot": int, "nuc": int, "ligand": int}.
+        eps (float, optional): A small epsilon value to avoid division by zero. Default is 1e-9.
+        beta_dict (Optional[dict], optional): Dictionary containing beta values for 'chain' and 'interface'.
+        alpha_dict (Optional[dict], optional): Dictionary containing alpha values for different chain types.
+
+    Returns:
+         float: Calculated weight for the given chain/interface.
+    """
+    if not beta_dict:
+        beta_dict = {
+            "chain": 0.5,
+            "interface": 1,
+        }
+    if not alpha_dict:
+        alpha_dict = {
+            "prot": 3,
+            "nuc": 3,
+            "ligand": 1,
+        }
+
+    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),
+            "constraint": config_dict.get("constraint", {}),
+        }
+
+    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

protenix/data/esm_featurizer.py

@@ -0,0 +1,184 @@
+# 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
+import traceback
+
+import pandas as pd
+import torch
+
+from protenix.data.compute_esm import compute_ESM_embeddings, load_esm_model
+from protenix.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class ESMFeaturizer:
+
+    def __init__(
+        self,
+        embedding_dir: str,
+        sequence_fpath: str,
+        embedding_dim: int = 1028,
+        error_dir: str = None,
+    ):
+        self.embedding_dir = embedding_dir
+        self.sequence_fpath = sequence_fpath
+        self.seq_to_filename = self.get_seq_to_filename(sequence_fpath)
+        self.embedding_dim = embedding_dim
+        self.error_dir = error_dir
+        if self.error_dir is not None:
+            self.error_dir = os.path.join(self.error_dir, "esm_error")
+            os.makedirs(self.error_dir, exist_ok=True)
+
+    def get_seq_to_filename(self, sequence_fpath: str) -> dict[str, str]:
+        df = pd.read_csv(sequence_fpath)
+        df["filename"] = (
+            df["part_id"].astype(str) + "/" + df["seq_label"].astype(str) + ".pt"
+        )
+        return df.set_index("seq")["filename"].to_dict()
+
+    def load_esm_embedding(self, sequence: str):
+        x = torch.load(os.path.join(self.embedding_dir, self.seq_to_filename[sequence]))
+        assert x.size(0) == len(sequence)
+        return x
+
+    def save_error(self, error_sequences, pdb_id):
+        if (self.error_dir is None) or (len(error_sequences) == 0):
+            return
+        for error_data in error_sequences:
+            fpath = os.path.join(
+                self.error_dir, f"{pdb_id}_{error_data['entity_id']}.txt"
+            )
+            if os.path.exists(fpath):
+                continue
+            with open(fpath, "w") as f:
+                f.write(error_data["error"])
+
+    def __call__(self, token_array, atom_array, bioassembly_dict, inference_mode=False):
+
+        # init as zeros
+        N_token = len(token_array)
+        x = torch.zeros([N_token, self.embedding_dim])
+
+        # get one atom per token
+        centre_atoms_indices = token_array.get_annotation("centre_atom_index")
+        centre_atom_array = atom_array[centre_atoms_indices]
+
+        # protein entities
+        is_protein = centre_atom_array.chain_mol_type == "protein"
+        protein_entity_ids = set(centre_atom_array.label_entity_id[is_protein])
+
+        if inference_mode:
+            entity_id_to_sequence = (
+                {}
+            )  # Only contains protein entity, many-to-one mapping
+            for i, entity_info_wrapper in enumerate(bioassembly_dict["sequences"]):
+                entity_id = str(i + 1)
+                entity_type = list(entity_info_wrapper.keys())[0]
+                entity_info = entity_info_wrapper[entity_type]
+                if entity_type == "proteinChain":
+                    entity_id_to_sequence[entity_id] = entity_info["sequence"]
+
+        # enumerate over the entities
+        error_sequences = []
+        for entity_id in protein_entity_ids:
+            try:
+                # Get sequence
+                if inference_mode:
+                    sequence = entity_id_to_sequence[entity_id]
+                else:
+                    sequence = bioassembly_dict["sequences"][str(entity_id)]
+                x_esm = self.load_esm_embedding(sequence)
+                # Get residue indices of the cropped tokens
+                entity_mask = centre_atom_array.label_entity_id == entity_id
+                res_index = (
+                    centre_atom_array.res_id[entity_mask] - 1
+                )  # res_id starts with 1
+                # Get esm embeddding according to residue indices
+                x[entity_mask] = x_esm[res_index]
+            except Exception as e:
+                error_message = f"{e}:\n{traceback.format_exc()}"
+                error_sequences.append(
+                    {
+                        "entity_id": entity_id,
+                        "error": error_message,
+                    }
+                )
+                logger.warning(
+                    f"[{bioassembly_dict['pdb_id']}] ESM error: {error_message}"
+                )
+
+        id_key = "name" if inference_mode else "pdb_id"
+        self.save_error(error_sequences, pdb_id=bioassembly_dict[id_key])
+
+        return x
+
+    @staticmethod
+    def precompute_esm_embedding(
+        inputs: list, model_name, embedding_dir, sequence_fpath, checkpoint_dir
+    ):
+        print("Precompute ESM embeddings")
+        # prepare seq_label
+        all_seq_dict = []
+        for sample_dict in inputs:
+            sample_name = sample_dict["name"]
+            for i, entity_info_wrapper in enumerate(sample_dict["sequences"]):
+                pdb_entity_id = sample_name + "_" + str(i + 1)
+                entity_type = list(entity_info_wrapper.keys())[0]
+                entity_info = entity_info_wrapper[entity_type]
+                if entity_type == "proteinChain":
+                    all_seq_dict.append(
+                        {
+                            "seq": entity_info["sequence"],
+                            "pdb_entity_id": pdb_entity_id,
+                            "seq_label": pdb_entity_id,
+                            "part_id": pdb_entity_id,
+                        }
+                    )
+        df_seq = pd.DataFrame(
+            all_seq_dict, columns=["seq", "pdb_entity_id", "seq_label", "part_id"]
+        )
+        df_seq.to_csv(sequence_fpath)
+        print(f"Save sequence file to {sequence_fpath}")
+
+        model, alphabet = load_esm_model(model_name, local_esm_dir=checkpoint_dir)
+        error_parts = []
+        part_counts = dict(df_seq["part_id"].value_counts())
+        for part_id, count in part_counts.items():
+            df_part = df_seq[df_seq["part_id"] == part_id]
+            print(f"Part {part_id}: {len(df_part)} sequences.")
+            labels = df_part["seq_label"].tolist()
+            sequences = df_part["seq"].tolist()
+            try:
+                save_dir = os.path.join(embedding_dir, part_id)
+                if not os.path.exists(save_dir):
+                    os.makedirs(save_dir)
+                lm_embeddings = compute_ESM_embeddings(
+                    model_name,
+                    model,
+                    alphabet,
+                    labels,
+                    sequences,
+                    save_dir,
+                    truncation_seq_length=4094,
+                    toks_per_batch=16384,
+                )
+                print(
+                    f"[{part_id}] Processed {len(lm_embeddings)} sequences in total. Done!"
+                )
+            except Exception as e:
+                print(f"[{part_id}] {e}")
+                error_parts.append(part_id)
+        print("Error parts: ", error_parts)

protenix/data/featurizer.py

@@ -0,0 +1,828 @@
+# 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 Optional, 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, STD_RESIDUES_WITH_GAP, get_all_elems
+from protenix.data.tokenizer import Token, TokenArray
+from protenix.data.utils import get_atom_level_token_mask, 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_dict_or_list: Optional[Union[dict, 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_dict_or_list (list or dict): A list or dict 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.
+        """
+        num_keys = len(encode_def_dict_or_list)
+        if isinstance(encode_def_dict_or_list, dict):
+            items = encode_def_dict_or_list.items()
+            assert (
+                num_keys == max(encode_def_dict_or_list.values()) + 1
+            ), "Do not use discontinuous number, which might causing potential bugs in the code"
+        elif isinstance(encode_def_dict_or_list, list):
+            items = ((key, idx) for idx, key in enumerate(encode_def_dict_or_list))
+        else:
+            raise TypeError(
+                "encode_def_dict_or_list must be a list or dict, "
+                f"but got {type(encode_def_dict_or_list)}"
+            )
+        onehot_dict = {
+            key: [int(i == idx) for i in range(num_keys)] for key, idx in items
+        }
+        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(STD_RESIDUES_WITH_GAP, 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:
+                vec1 = ref_pos[frame_atom_index[1]] - ref_pos[frame_atom_index[0]]
+                vec2 = ref_pos[frame_atom_index[2]] - ref_pos[frame_atom_index[1]]
+                # ref_pos can be all zeros, in which case has_frame=0
+                is_zero_norm = np.isclose(
+                    np.linalg.norm(vec1, axis=-1), 0
+                ) or np.isclose(np.linalg.norm(vec2, axis=-1), 0)
+                if is_zero_norm:
+                    has_frame = 0
+                else:
+                    theta_degrees = angle_3p(
+                        *[ref_pos[idx] for idx in frame_atom_index]
+                    )
+                    is_colinear = theta_degrees <= 25 or theta_degrees >= 155
+                    if is_colinear:
+                        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 = token_array
+        atom_level_token_mask = get_atom_level_token_mask(token_array, atom_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())))
+            | atom_level_token_mask
+        ]
+        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
+                and len(token.atom_indices) > 1
+            ):
+                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_array = self.cropped_atom_array.bonds.as_array()
+        bond_atom_i = bond_array[:, 0]
+        bond_atom_j = bond_array[:, 1]
+        ref_space_uid = self.cropped_atom_array.ref_space_uid
+        polymer_mask = np.isin(
+            self.cropped_atom_array.mol_type, ["protein", "dna", "rna"]
+        )
+        std_res_mask = (
+            np.isin(self.cropped_atom_array.res_name, list(STD_RESIDUES.keys()))
+            & polymer_mask
+        )
+        unstd_res_mask = ~std_res_mask & polymer_mask
+        # the polymer-polymer (std-std, std-unstd, and inter-unstd) bond will not be included in token_bonds.
+        std_std_bond_mask = std_res_mask[bond_atom_i] & std_res_mask[bond_atom_j]
+        std_unstd_bond_mask = (
+            std_res_mask[bond_atom_i] & unstd_res_mask[bond_atom_j]
+        ) | (std_res_mask[bond_atom_j] & unstd_res_mask[bond_atom_i])
+        inter_unstd_bond_mask = (
+            unstd_res_mask[bond_atom_i] & unstd_res_mask[bond_atom_j]
+        ) & (ref_space_uid[bond_atom_i] != ref_space_uid[bond_atom_j])
+        kept_bonds = bond_array[
+            ~(std_std_bond_mask | std_unstd_bond_mask | inter_unstd_bond_mask)
+        ]
+        # -1 means the atom is not in any token
+        atom_idx_to_token_idx = np.zeros(len(self.cropped_atom_array), dtype=int) - 1
+        for idx, token in enumerate(self.cropped_token_array.tokens):
+            for atom_idx in token.atom_indices:
+                atom_idx_to_token_idx[atom_idx] = idx
+        assert np.all(atom_idx_to_token_idx >= 0), "Some atoms are not in any token"
+        num_tokens = len(self.cropped_token_array)
+        token_adj_matrix = np.zeros((num_tokens, num_tokens), dtype=int)
+        bond_token_i, bond_atom_j = (
+            atom_idx_to_token_idx[kept_bonds[:, 0]],
+            atom_idx_to_token_idx[kept_bonds[:, 1]],
+        )
+        for i, j in zip(bond_token_i, bond_atom_j):
+            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 & atom_array.is_resolved]
+
+            # 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) and atom_array.is_resolved[i])
+                    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

protenix/data/filter.py

@@ -0,0 +1,637 @@
+# 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, get_molecule_indices
+from scipy.spatial.distance import cdist
+
+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]
+
+    @staticmethod
+    def _get_clashing_chains(
+        atom_array: AtomArray, chain_ids: list[str]
+    ) -> tuple[np.ndarray, list[int]]:
+        """
+        Calculate the number of atoms clashing with other chains for each chain
+        and return a matrix that records the count of clashing atoms.
+
+        Note: if two chains are covalent, they are not considered as clashing.
+
+        Args:
+            atom_array (AtomArray): All atoms, including those not resolved.
+            chain_ids (list[str]): Unique chain indices of resolved atoms.
+
+        Returns:
+            tuple:
+                clash_records (numpy.ndarray): Matrix of clashing atom num.
+                                               (i, j) means the ratio of i's atom clashed with j's atoms.
+                                               Note: (i, j) != (j, i).
+                chain_resolved_atom_nums (list[int]): The number of resolved atoms corresponding to each chain ID.
+        """
+        is_resolved_centre_atom = (
+            atom_array.centre_atom_mask == 1
+        ) & atom_array.is_resolved
+        cell_list = struc.CellList(
+            atom_array, cell_size=1.7, selection=is_resolved_centre_atom
+        )
+
+        # (i, j) means the ratio of i's atom clashed with j's atoms
+        clash_records = np.zeros((len(chain_ids), len(chain_ids)))
+
+        # record the number of resolved atoms for each chain
+        chain_resolved_atom_nums = []
+
+        # record covalent relationship between chains
+        chains_covalent_dict = {}
+        for idx, chain_id_i in enumerate(chain_ids):
+            for chain_id_j in chain_ids[idx + 1 :]:
+                mol_indices = get_molecule_indices(
+                    atom_array[np.isin(atom_array.chain_id, [chain_id_i, chain_id_j])]
+                )
+                if len(mol_indices) == 1:
+                    covalent = 1
+                else:
+                    covalent = 0
+                chains_covalent_dict[(chain_id_i, chain_id_j)] = covalent
+                chains_covalent_dict[(chain_id_j, chain_id_i)] = covalent
+
+        for i, chain_id in enumerate(chain_ids):
+            coords = atom_array.coord[
+                (atom_array.chain_id == chain_id) & is_resolved_centre_atom
+            ]
+            chain_resolved_atom_nums.append(len(coords))
+            chain_atom_ids = np.where(atom_array.chain_id == chain_id)[0]
+            chain_atom_ids_set = set(chain_atom_ids) | {-1}
+
+            # Get atom indices from the current cell and the eight surrounding cells.
+            neighbors_ids_2d = cell_list.get_atoms_in_cells(coords, cell_radius=1)
+            neighbors_ids = np.unique(neighbors_ids_2d)
+
+            # Remove the atom indices of the current chain.
+            other_chain_atom_ids = list(set(neighbors_ids) - chain_atom_ids_set)
+
+            if not other_chain_atom_ids:
+                continue
+            else:
+                # Calculate the distance matrix with neighboring atoms.
+                other_chain_atom_coords = atom_array.coord[other_chain_atom_ids]
+                dist_mat = cdist(coords, other_chain_atom_coords, metric="euclidean")
+                clash_mat = dist_mat < 1.6  # change 1.7 to 1.6 for more compatibility
+                if np.any(clash_mat):
+                    clashed_other_chain_ids = atom_array.chain_id[other_chain_atom_ids]
+
+                    for other_chain_id in set(clashed_other_chain_ids):
+
+                        # two chains covalent with each other
+                        if chains_covalent_dict[(chain_id, other_chain_id)]:
+                            continue
+
+                        cols = np.where(clashed_other_chain_ids == other_chain_id)[0]
+
+                        # how many i's atoms clashed with j
+                        any_atom_clashed = np.any(
+                            clash_mat[:, cols].astype(int), axis=1
+                        )
+                        clashed_atom_num = np.sum(any_atom_clashed.astype(int))
+
+                        if clashed_atom_num > 0:
+                            j = chain_ids.index(other_chain_id)
+                            clash_records[i][j] += clashed_atom_num
+        return clash_records, chain_resolved_atom_nums
+
+    @staticmethod
+    def _get_removed_clash_chain_ids(
+        clash_records: np.ndarray,
+        chain_ids: list[str],
+        chain_resolved_atom_nums: list[int],
+        core_chain_id: np.ndarray = [],
+    ) -> list[str]:
+        """
+        Perform pairwise comparisons on the chains, and select the chain IDs
+        to be deleted according to the clahsing chain rules.
+
+        Args:
+            clash_records (numpy.ndarray): Matrix of clashing atom num.
+                                           (i, j) means the ratio of i's atom clashed with j's atoms.
+                                           Note: (i, j) != (j, i).
+            chain_ids (list[str]): Unique chain indices of resolved atoms.
+            chain_resolved_atom_nums (list[int]): The number of resolved atoms corresponding to each chain ID.
+            core_chain_id (np.ndarray): The chain ID of the core chain.
+
+        Returns:
+            list[str]: A list of chain IDs that have been determined for deletion.
+        """
+        removed_chain_ids = []
+        for i in range(len(chain_ids)):
+            atom_num_i = chain_resolved_atom_nums[i]
+            chain_idx_i = chain_ids[i]
+
+            if chain_idx_i in removed_chain_ids:
+                continue
+
+            for j in range(i + 1, len(chain_ids)):
+                atom_num_j = chain_resolved_atom_nums[j]
+                chain_idx_j = chain_ids[j]
+
+                if chain_idx_j in removed_chain_ids:
+                    continue
+
+                clash_num_ij, clash_num_ji = (
+                    clash_records[i][j],
+                    clash_records[j][i],
+                )
+
+                clash_ratio_ij = clash_num_ij / atom_num_i
+                clash_ratio_ji = clash_num_ji / atom_num_j
+
+                if clash_ratio_ij <= 0.3 and clash_ratio_ji <= 0.3:
+                    # not reaches the threshold
+                    continue
+                else:
+                    # clashing chains
+                    if (
+                        chain_idx_i in core_chain_id
+                        and chain_idx_j not in core_chain_id
+                    ):
+                        removed_chain_idx = chain_idx_j
+                    elif (
+                        chain_idx_i not in core_chain_id
+                        and chain_idx_j in core_chain_id
+                    ):
+                        removed_chain_idx = chain_idx_i
+
+                    elif clash_ratio_ij > clash_ratio_ji:
+                        removed_chain_idx = chain_idx_i
+                    elif clash_ratio_ij < clash_ratio_ji:
+                        removed_chain_idx = chain_idx_j
+                    else:
+                        if atom_num_i < atom_num_j:
+                            removed_chain_idx = chain_idx_i
+                        elif atom_num_i > atom_num_j:
+                            removed_chain_idx = chain_idx_j
+                        else:
+                            removed_chain_idx = sorted([chain_idx_i, chain_idx_j])[1]
+
+                    removed_chain_ids.append(removed_chain_idx)
+
+                    if removed_chain_idx == chain_idx_i:
+                        # chain i already removed
+                        break
+        return removed_chain_ids
+
+    @staticmethod
+    def remove_polymer_chains_all_residues_unknown(
+        atom_array: AtomArray,
+        entity_poly_type: dict,
+    ) -> AtomArray:
+        """remove chains with all residues unknown"""
+        chain_starts = struc.get_chain_starts(atom_array, add_exclusive_stop=True)
+        invalid_chains = []  # list of [start, end)
+        for index in range(len(chain_starts) - 1):
+            start, end = chain_starts[index], chain_starts[index + 1]
+            entity_id = atom_array[start].label_entity_id
+            if (
+                entity_poly_type.get(entity_id, "non-poly") == "polypeptide(L)"
+                and np.all(atom_array.res_name[start:end] == "UNK")
+            ) or (
+                entity_poly_type.get(entity_id, "non-poly")
+                in (
+                    "polyribonucleotide",
+                    "polydeoxyribonucleotide",
+                )
+                and np.all(atom_array.res_name[start:end] == "N")
+            ):
+                invalid_chains.append((start, end))
+        mask = np.ones(len(atom_array), dtype=bool)
+        for start, end in invalid_chains:
+            mask[start:end] = False
+        atom_array = atom_array[mask]
+        return atom_array
+
+    @staticmethod
+    def remove_polymer_chains_too_short(
+        atom_array: AtomArray, entity_poly_type: dict
+    ) -> AtomArray:
+        chain_starts = struc.get_chain_starts(atom_array, add_exclusive_stop=True)
+        invalid_chains = []  # list of [start, end)
+        for index in range(len(chain_starts) - 1):
+            start, end = chain_starts[index], chain_starts[index + 1]
+            entity_id = atom_array[start].label_entity_id
+            num_residue_ids = len(set(atom_array.label_seq_id[start:end]))
+            if (
+                entity_poly_type.get(entity_id, "non-poly")
+                in (
+                    "polypeptide(L)",  # TODO: how to handle polypeptide(D)?
+                    "polyribonucleotide",
+                    "polydeoxyribonucleotide",
+                )
+                and num_residue_ids < 4
+            ):
+                invalid_chains.append((start, end))
+        mask = np.ones(len(atom_array), dtype=bool)
+        for start, end in invalid_chains:
+            mask[start:end] = False
+        atom_array = atom_array[mask]
+        return atom_array
+
+    @staticmethod
+    def remove_polymer_chains_with_consecutive_c_alpha_too_far_away(
+        atom_array: AtomArray, entity_poly_type: dict, max_distance: float = 10.0
+    ) -> AtomArray:
+        chain_starts = struc.get_chain_starts(atom_array, add_exclusive_stop=True)
+        invalid_chains = []  # list of [start, end)
+        for index in range(len(chain_starts) - 1):
+            start, end = chain_starts[index], chain_starts[index + 1]
+            entity_id = atom_array.label_entity_id[start]
+            if entity_poly_type.get(entity_id, "non-poly") == "polypeptide(L)":
+                peptide_atoms = atom_array[start:end]
+                ca_atoms = peptide_atoms[peptide_atoms.atom_name == "CA"]
+                seq_ids = ca_atoms.label_seq_id
+                seq_ids[seq_ids == "."] = "-100"
+                seq_ids = seq_ids.astype(np.int64)
+                dist_square = np.sum(
+                    (ca_atoms[:-1].coord - ca_atoms[1:].coord) ** 2, axis=-1
+                )
+                invalid_neighbor_mask = (dist_square > max_distance**2) & (
+                    seq_ids[:-1] + 1 == seq_ids[1:]
+                )
+                if np.any(invalid_neighbor_mask):
+                    invalid_chains.append((start, end))
+        mask = np.ones(len(atom_array), dtype=bool)
+        for start, end in invalid_chains:
+            mask[start:end] = False
+        atom_array = atom_array[mask]
+        return atom_array
+
+    @staticmethod
+    def too_many_chains_filter(
+        atom_array: AtomArray,
+        interface_radius: int = 15,
+        max_chains_num: int = 20,
+        core_indices: list[int] = None,
+        max_tokens_num: int = None,
+    ) -> tuple[AtomArray, int]:
+        """
+        Ref: AlphaFold3 SI Chapter 2.5.4
+
+        For bioassemblies with greater than 20 chains, we select a random interface token
+        (with a centre atom <15 Å to the centre atom of a token in another chain)
+        and select the closest 20 chains to this token based on
+        minimum distance between any tokens centre atom.
+
+        Note: due to the presence of covalent small molecules,
+        treat the covalent small molecule and the polymer it is attached to
+        as a single chain to avoid inadvertently removing the covalent small molecules.
+        Use the mol_id added to the AtomArray to differentiate between the various
+        parts of the structure composed of covalent bonds.
+
+        Args:
+            atom_array (AtomArray): Biotite AtomArray Object of a Bioassembly.
+            interface_radius (int, optional): Atoms within this distance of the central atom are considered interface atoms.
+                                            Defaults to 15.
+            max_chains_num (int, optional): The maximum number of chains permitted in a bioassembly.
+                                            Filtration will be applied if exceeds this value. Defaults to 20.
+            core_indices (list[int], optional): A list of indices to be used as chose the central atom.
+                                                     And corresponding chains in the list will be selected proriority.
+                                                     If None, a random index from whole AtomArray will be selected. Defaults to None.
+            max_tokens_num (int, optional): The maximum number of tokens permitted in a bioassembly.
+                                            If not None,  after more than max_chains_num, if the max_tokens_num is not reached,
+                                            it will continue to append the chains.
+
+        Returns:
+            tuple:
+                - atom_array (AtomArray): An AtomArray that has been processed through this filter.
+                - input_chains_num (int): The number of chain in the input AtomArray.
+                                          This is to log whether the filter has been utilized.
+        """
+        # each mol is a so called "chain" in the context of this filter.
+        input_chains_num = len(np.unique(atom_array.mol_id))
+        if input_chains_num <= max_chains_num:
+            # no change
+            return atom_array, input_chains_num
+
+        is_resolved_centre_atom = (
+            atom_array.centre_atom_mask == 1
+        ) & atom_array.is_resolved
+
+        cell_list = struc.CellList(
+            atom_array, cell_size=interface_radius, selection=is_resolved_centre_atom
+        )
+        resolved_centre_atom = atom_array[is_resolved_centre_atom]
+
+        assert resolved_centre_atom, "There is no resolved central atom."
+
+        # random pick centre atom
+        if core_indices is None:
+            index_shuf = np.random.default_rng(seed=42).permutation(
+                len(resolved_centre_atom)
+            )
+        else:
+            index_shuf = np.array(core_indices)
+            resolved_centre_atom_indices = np.nonzero(is_resolved_centre_atom)[0]
+
+            # get indices of resolved_centre_atom
+            index_shuf = np.array(
+                [
+                    np.where(resolved_centre_atom_indices == idx)[0][0]
+                    for idx in index_shuf
+                    if idx in resolved_centre_atom_indices
+                ]
+            )
+            np.random.default_rng(seed=42).shuffle(index_shuf)
+
+        chosen_centre_atom = None
+        for idx in index_shuf:
+            centre_atom = resolved_centre_atom[idx]
+            neighbors_indices = cell_list.get_atoms(
+                centre_atom.coord, radius=interface_radius
+            )
+            neighbors_indices = neighbors_indices[neighbors_indices != -1]
+
+            neighbors_chain_ids = np.unique(atom_array.mol_id[neighbors_indices])
+            # neighbors include centre atom itself
+            if len(neighbors_chain_ids) > 1:
+                chosen_centre_atom = centre_atom
+                break
+
+        # The distance between the central atoms in any two chains is greater than 15 angstroms.
+        if chosen_centre_atom is None:
+            return None, input_chains_num
+
+        dist_mat = cdist(centre_atom.coord.reshape((1, -1)), resolved_centre_atom.coord)
+        sorted_chain_id = np.array(
+            [
+                chain_id
+                for chain_id, _dist in sorted(
+                    zip(resolved_centre_atom.mol_id, dist_mat[0]),
+                    key=lambda pair: pair[1],
+                )
+            ]
+        )
+
+        if core_indices is not None:
+            # select core proriority
+            core_mol_id = np.unique(atom_array.mol_id[core_indices])
+            in_core_mask = np.isin(sorted_chain_id, core_mol_id)
+            sorted_chain_id = np.concatenate(
+                (sorted_chain_id[in_core_mask], sorted_chain_id[~in_core_mask])
+            )
+
+        closest_chain_id = set()
+        chain_ids_to_token_num = {}
+        if max_tokens_num is None:
+            max_tokens_num = 0
+
+        tokens = 0
+        for chain_id in sorted_chain_id:
+            # get token num
+            if chain_id not in chain_ids_to_token_num:
+                chain_ids_to_token_num[chain_id] = atom_array.centre_atom_mask[
+                    atom_array.mol_id == chain_id
+                ].sum()
+            chain_token_num = chain_ids_to_token_num[chain_id]
+
+            if len(closest_chain_id) >= max_chains_num:
+                if tokens + chain_token_num > max_tokens_num:
+                    break
+
+            closest_chain_id.add(chain_id)
+            tokens += chain_token_num
+
+        atom_array = atom_array[np.isin(atom_array.mol_id, list(closest_chain_id))]
+        output_chains_num = len(np.unique(atom_array.mol_id))
+        assert (
+            output_chains_num == max_chains_num
+            or atom_array.centre_atom_mask.sum() <= max_tokens_num
+        )
+        return atom_array, input_chains_num
+
+    @staticmethod
+    def remove_clashing_chains(
+        atom_array: AtomArray,
+        core_indices: list[int] = None,
+    ) -> AtomArray:
+        """
+        Ref: AlphaFold3 SI Chapter 2.5.4
+
+        Clashing chains are removed.
+        Clashing chains are defined as those with >30% of atoms within 1.7 Å of an atom in another chain.
+        If two chains are clashing with each other, the chain with the greater percentage of clashing atoms will be removed.
+        If the same fraction of atoms are clashing, the chain with fewer total atoms is removed.
+        If the chains have the same number of atoms, then the chain with the larger chain id is removed.
+
+        Note: if two chains are covalent, they are not considered as clashing.
+
+        Args:
+            atom_array (AtomArray): Biotite AtomArray Object of a Bioassembly.
+            core_indices (list[int]): A list of indices for core structures,
+                                      where these indices correspond to structures that will be preferentially
+                                      retained when pairwise clash chain assessments are performed.
+
+        Returns:
+            atom_array (AtomArray): An AtomArray that has been processed through this filter.
+            removed_chain_ids (list[str]): A list of chain IDs that have been determined for deletion.
+                                           This is to log whether the filter has been utilized.
+        """
+        chain_ids = np.unique(atom_array.chain_id[atom_array.is_resolved]).tolist()
+
+        if core_indices is not None:
+            core_chain_id = np.unique(atom_array.chain_id[core_indices])
+        else:
+            core_chain_id = np.array([])
+
+        clash_records, chain_resolved_atom_nums = Filter._get_clashing_chains(
+            atom_array, chain_ids
+        )
+        removed_chain_ids = Filter._get_removed_clash_chain_ids(
+            clash_records,
+            chain_ids,
+            chain_resolved_atom_nums,
+            core_chain_id=core_chain_id,
+        )
+
+        atom_array = atom_array[~np.isin(atom_array.chain_id, removed_chain_ids)]
+        return atom_array, removed_chain_ids
+
+    @staticmethod
+    def remove_unresolved_mols(atom_array: AtomArray) -> AtomArray:
+        """
+        Remove molecules from a bioassembly object which all atoms are not resolved.
+
+        Args:
+            atom_array (AtomArray): Biotite AtomArray Object of a bioassembly.
+
+        Returns:
+            AtomArray: An AtomArray object with unresolved molecules removed.
+        """
+        valid_mol_id = []
+        for mol_id in np.unique(atom_array.mol_id):
+            resolved = atom_array.is_resolved[atom_array.mol_id == mol_id]
+            if np.any(resolved):
+                valid_mol_id.append(mol_id)
+
+        atom_array = atom_array[np.isin(atom_array.mol_id, valid_mol_id)]
+        return atom_array
+
+    @staticmethod
+    def remove_asymmetric_polymer_ligand_bonds(
+        atom_array: AtomArray, entity_poly_type: dict
+    ) -> AtomArray:
+        """remove asymmetric polymer ligand bonds (including protein-protein bond, like disulfide bond).
+
+        AF3 SI 5.1 Structure filters
+        Bonds for structures with homomeric subcomplexes lacking the corresponding homomeric symmetry are also removed
+        - e.g. if a certain bonded ligand only exists for some of the symmetric copies, but not for all,
+        we remove the corresponding bond information from the input.
+        In consequence the model has to learn to infer these bonds by itself.
+
+        Args:
+            atom_array (AtomArray): input atom array
+
+        Returns:
+            AtomArray: output atom array with asymmetric polymer ligand bonds removed.
+        """
+        # get inter chain bonds
+        inter_chain_bonds = set()
+        for i, j, b in atom_array.bonds.as_array():
+            if atom_array.chain_id[i] != atom_array.chain_id[j]:
+                inter_chain_bonds.add((i, j))
+
+        # get asymmetric polymer ligand bonds
+        asymmetric_bonds = set()
+        chain_starts = struc.get_chain_starts(atom_array, add_exclusive_stop=False)
+        for bond in inter_chain_bonds:
+
+            if bond in asymmetric_bonds:
+                continue
+
+            i, j = bond
+            atom_i = atom_array[i]
+            atom_j = atom_array[j]
+            i_is_polymer = atom_i.label_entity_id in entity_poly_type
+            j_is_polymer = atom_j.label_entity_id in entity_poly_type
+            if i_is_polymer:
+                pass
+            elif j_is_polymer:
+                i, j = j, i
+                atom_i, atom_j = atom_j, atom_i
+                i_is_polymer, j_is_polymer = j_is_polymer, i_is_polymer
+            else:
+                # both entity is not polymer
+                continue
+
+            # get atom i mask from all entity i copies
+            entity_mask_i = atom_array.label_entity_id == atom_i.label_entity_id
+            num_copies = np.isin(chain_starts, np.flatnonzero(entity_mask_i)).sum()
+            mask_i = (
+                entity_mask_i
+                & (atom_array.res_id == atom_i.res_id)
+                & (atom_array.atom_name == atom_i.atom_name)
+            )
+            indices_i = np.flatnonzero(mask_i)
+
+            if len(indices_i) != num_copies:
+                # not every copy of entity i has atom i.
+                asymmetric_bonds.add(bond)
+                continue
+
+            # check all atom i in entity i bond to an atom j in entity j.
+            target_bonds = []
+            for ii in indices_i:
+                ii_bonds = [b for b in inter_chain_bonds if ii in b]
+                for bond in ii_bonds:
+                    jj = bond[1] if ii == bond[0] else bond[0]
+                    atom_jj = atom_array[jj]
+                    if atom_jj.label_entity_id != atom_j.label_entity_id:
+                        continue
+                    if atom_jj.res_name != atom_j.res_name:
+                        continue
+                    if atom_jj.atom_name != atom_j.atom_name:
+                        continue
+                    if j_is_polymer and atom_jj.res_id != atom_j.res_id:
+                        # only for polymer, check res_id
+                        continue
+                    # found bond (ii, jj) with same enity_id, res_name, atom_name to bond (i,j)
+                    target_bonds.append((min(ii, jj), max(ii, jj)))
+                    break
+            if len(target_bonds) != num_copies:
+                asymmetric_bonds |= set(target_bonds)
+
+        for bond in asymmetric_bonds:
+            atom_array.bonds.remove_bond(bond[0], bond[1])
+        return atom_array

protenix/data/infer_data_pipeline.py

@@ -0,0 +1,284 @@
+# 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 os
+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.esm_featurizer import ESMFeaturizer
+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 collate_fn_identity, 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,
+        configs=configs,
+        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=collate_fn_identity,
+        # num_workers=configs.num_workers,
+        num_workers=0
+    )
+    return dataloader
+
+
+class InferenceDataset(Dataset):
+    def __init__(
+        self,
+        input_json_path: str,
+        dump_dir: str,
+        use_msa: bool = True,
+        configs=None,
+    ) -> 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)
+        json_task_name = os.path.basename(self.input_json_path).split(".")[0]
+        esm_info = configs.get("esm", {})
+        configs.esm.embedding_dir = f"./esm_embeddings/{configs.esm.model_name}"
+        configs.esm.sequence_fpath = (
+            f"./esm_embeddings/{json_task_name}_prot_sequences.csv"
+        )
+        self.esm_enable = esm_info.get("enable", False)
+        if self.esm_enable:
+            os.makedirs(configs.esm.embedding_dir, exist_ok=True)
+            os.makedirs(os.path.dirname(configs.esm.sequence_fpath), exist_ok=True)
+            ESMFeaturizer.precompute_esm_embedding(
+                self.inputs,
+                configs.esm.model_name,
+                configs.esm.embedding_dir,
+                configs.esm.sequence_fpath,
+                configs.load_checkpoint_dir,
+            )
+            self.esm_featurizer = ESMFeaturizer(
+                embedding_dir=esm_info.embedding_dir,
+                sequence_fpath=esm_info.sequence_fpath,
+                embedding_dim=esm_info.embedding_dim,
+                error_dir="./esm_embeddings/",
+            )
+
+    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 {}
+        )
+
+        # Esm features
+        if self.esm_enable:
+            x_esm = self.esm_featurizer(
+                token_array=token_array,
+                atom_array=atom_array,
+                bioassembly_dict=single_sample_dict,
+                inference_mode=True,
+            )
+            features_dict["esm_token_embedding"] = x_esm
+
+        # 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, token_array
+
+    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, token_array = self.process_one(
+                single_sample_dict=single_sample_dict
+            )
+            error_message = ""
+
+            coords = torch.load(f"/home/hui007/Protenix/coord/{sample_name}.pt")
+            assert len(coords) == len(token_array)
+
+            coord_label = {'coordinate': [], 'coordinate_mask': []}
+            tmp_coord = []
+            tmp_mask = []
+            for coord_entry, token in zip(coords, token_array):
+                atom_list = coord_entry[1]['atom_list']
+                coord_list = coord_entry[1]['coord_list']
+                token_atom_names = token.atom_names
+
+                atom_to_coord = {atom: coord_list[i] for i, atom in enumerate(atom_list)}
+
+                for atom_name in token_atom_names:
+                    if atom_name in atom_to_coord:
+                        tmp_coord.append(atom_to_coord[atom_name].tolist())
+                        tmp_mask.append(1)
+                    else:
+                        tmp_coord.append([0.0, 0.0, 0.0])
+                        tmp_mask.append(0)
+
+            coord_label['coordinate'] = torch.tensor(tmp_coord, dtype=torch.float32)
+            coord_label['coordinate_mask'] = torch.tensor(tmp_mask)
+            coord_label['sample_name'] = sample_name
+
+        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, coord_label, error_message

protenix/data/json_maker.py

@@ -0,0 +1,317 @@
+# 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 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["entity1"])],
+            all_entity_counts[str(bond_dict["entity2"])],
+        )
+        for i in range(2):
+            for j in ["entity", "position", "atom"]:
+                k = f"{j}{i+1}"
+                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():
+        counts1 = bonds_entity_counts[k][0]
+        counts2 = bonds_entity_counts[k][1]
+        if counts1 == counts2 == len(v):
+            bond_dict_copy = copy.deepcopy(v[0])
+            del bond_dict_copy["copy1"]
+            del bond_dict_copy["copy2"]
+            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: str = None,
+    save_entity_and_asym_id: bool = 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 (str, 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)
+    chain_id_to_copy_id_dict = {}
+    for label_entity_id in unique_label_entity_id:
+        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 = {}
+    label_entity_id_to_entity_id_in_json = {}
+    entity_idx = 0
+    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.
+                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)
+        entity_idx += 1
+        entity_id_in_json = str(entity_idx)
+        label_entity_id_to_entity_id_in_json[label_entity_id] = entity_id_in_json
+        all_entity_counts[entity_id_in_json] = 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,
+            list(label_entity_id_to_entity_id_in_json.keys()),
+        )
+    ]
+
+    # 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 i in range(2):
+                positon = atom_array.res_id[atoms[i]]
+                bond_dict[f"entity{i+1}"] = int(
+                    label_entity_id_to_entity_id_in_json[
+                        atom_array.label_entity_id[atoms[i]]
+                    ]
+                )
+                bond_dict[f"position{i+1}"] = int(positon)
+                bond_dict[f"atom{i+1}"] = atom_array.atom_name[atoms[i]]
+                bond_dict[f"copy{i+1}"] = int(atom_array.copy_id[atoms[i]])
+
+            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: str = None,
+    save_entity_and_asym_id: bool = 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 (str, 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
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--cif_file", type=str, required=True, help="The cif file to parse"
+    )
+    parser.add_argument(
+        "--json_file",
+        type=str,
+        required=False,
+        default=None,
+        help="The json file path to generate",
+    )
+    args = parser.parse_args()
+    print(cif_to_input_json(args.cif_file, output_json=args.json_file))