diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 0000000..fc36cc3 --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,80 @@ +# EvolutionaryScale Community License Agreement + +Please read this EvolutionaryScale Community License Agreement (the “**Agreement**”) carefully before using the AI Model (as defined below), which is offered by EvolutionaryScale, PBC (“**ES**”). + +By downloading the AI Model, or otherwise using the AI Model in any manner, You agree that You have read and agree to be bound by the terms of this Agreement. If You are accessing the AI Model on behalf of an organization or entity, You represent and warrant that You are authorized to enter into this Agreement on that organization’s or entity’s behalf and bind them to the terms of this Agreement (in which case, the references to “**You**” and “**Your**” in this Agreement, except for in this sentence, refer to that organization or entity) and that such entity is a non-commercial organization (such as a university, non-profit organization, research institute or educational or governmental body). Use of the AI Model is expressly conditioned upon Your assent to all terms of this Agreement, to the exclusion of all other terms. + +## Definitions. + +In addition to other terms defined elsewhere in this Agreement, the terms below have the following meanings. + +1. “**AI Model**” means the EvolutionaryScale ESM-3 Open Model code and model weights made available at the following link [https://github.com/evolutionaryscale/esm] (the “**GitHub Page**”), as may be updated and amended from time to time, whether in Source or Object form, made available to You pursuant to this Agreement. +2. “**Commercial Entity**” means any entity engaged in any activity intended for or directed toward commercial advantage or monetary compensation, including, without limitation, the development of any product or service intended to be sold or made available for a fee. For the purpose of this Agreement, references to a Commercial Entity expressly exclude any universities, non-profit organizations, not-for-profit entities, research institutes and educational and government bodies. +3. “**Contribution**” means any work of authorship, including the original version of the AI Model and any modifications or additions to that AI Model or Derivative Works thereof, that is intentionally submitted to ES for inclusion in the AI Model 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 ES 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, ES for the purpose of discussing and improving the AI Model, but excluding Outputs and all communications that are conspicuously marked or otherwise designated in writing by the copyright owner as "**Not a Contribution**." +4. “**Contributor**” means ES and any individual or Legal Entity on behalf of whom a Contribution has been received by ES and subsequently incorporated within the AI Model. +5. “**Derivative Work**” means any work, whether in Source or Object form, that is based on (or derived from) the AI Model 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 Agreement, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the AI Model and Derivative Works thereof. +6. “**Legal Entity**” means 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. +7. “**Non-Commercial Purposes**” means uses not intended for or directed toward commercial advantage or monetary compensation, or the facilitation of development of any product or service to be sold or made available for a fee. For the avoidance of doubt, the provision of Outputs as a service is not a Non-Commercial Purpose. +8. “**Object**” means 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. +9. “**Output**” means any output, including any protein sequence, structure prediction, functional annotation, molecule, descriptions of a molecule, model, sequence, text, and/or image that is elicited directly or indirectly by, or otherwise made available to, You in connection with Your use of the AI Model, including, but not limited to, the use of AI-Powered Technology. +10. “**Output Derivatives**” means any enhancements, modifications and derivative works of Outputs (including, but not limited to, any derivative sequences or molecules). +11. “**Source**” means the preferred form for making modifications, including but not limited to AI Model source code, documentation source, and configuration files. +12. “**Third Party Model**” means any non-human tool, platform and/or other technology powered or made available in connection with the use of generative artificial intelligence or machine learning models that is operated by any third party. +13. “**You**” or “**Your**” means the individual entering into this Agreement or the organization or entity on whose behalf such individual is entering into this Agreement. + +## Intellectual Property Rights and Licenses. + +1. **Copyright License. Subject to the terms and conditions of this Agreement, each Contributor hereby grants to You a non-exclusive, non-transferable, limited copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the AI Model and such Derivative Works in Source or Object form for Your Non-Commercial Purposes.** +2. **Patent License**. Subject to the terms and conditions of this Agreement, each Contributor hereby grants to You a non-exclusive, non-transferable, limited patent license to make, have made, use, import, and otherwise transfer the AI Model for Your Non-Commercial Purposes, 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 AI Model 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 AI Model or a Contribution incorporated within the AI Model constitutes direct or contributory patent infringement, then any patent licenses granted to You under this Agreement for that AI Model shall terminate as of the date such litigation is filed. + +## Licensing Process. + +In connection with Your licensing of the AI Model, ES may collect, from You or automatically through Your use of the AI Model, certain registration information about You, any Legal Entity You may represent, and Your use of the AI Model. The collection of this information and ES’s policies and procedures regarding the collection, use, disclosure and security of information received are described further in ES’s Privacy Policy available at [[](https://redpanda.com/legal/privacy-policy/)https://evolutionaryscale.ai/privacy], as may be updated from time to time. + +## Redistribution. + +Subject to Section 5 (Use Restrictions) below, You may reproduce and distribute copies of the AI Model or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form for Your Non-Commercial Purposes, provided that You meet the following conditions: + +1. You must not distribute copies of the AI Model or Derivative Works thereof to, or allow the use of any reproductions or copies thereof by, on behalf of or for, any Commercial Entity; and +2. You must restrict the usage of any copies of the AI Model or Derivative Works to usage for Non-Commercial Purposes; and +3. You must give any other recipients of the AI Model or Derivative Works a copy of this Agreement; and +4. You must cause any modified files to carry prominent notices stating that You changed the files; and +5. 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 AI Model, excluding those notices that do not pertain to any part of the Derivative Works; and +6. If the AI Model 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 this Agreement. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the AI Model, provided that such additional attribution notices cannot be construed as modifying this Agreement. + +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 AI Model otherwise complies with the conditions stated in this Agreement. + +## Use Restrictions. + +**No Commercial Use**.  You may only use the AI Model, Contributions, Derivative Works, Outputs and Output Derivatives (as defined below) for Non-Commercial Purposes. For the avoidance of doubt, structure tokens are also considered Outputs and may only be used for Non-Commercial Purposes. Any commercial use of any of the foregoing, including, without limitation, any use by, on behalf of or for any Commercial Entity or to facilitate the development of any product or service to be sold or made available for a fee, is strictly prohibited under this Agreement. + +**No Use in Drug Development or Discovery**. Without limiting the foregoing, You may not use the AI Model or any Contributions, Derivative Works, Outputs or Output Derivatives in or in connection with: (i) the development (at any stage) or discovery of any drug, medication or pharmaceutical of any kind; (ii) any molecular or biological target, hit or lead identification; (iii) drug candidate selection; or (iv) lead optimization. + +**Use of Outputs**.  Notwithstanding anything to the contrary in this Agreement, You may not use or provide access to any Outputs or Output Derivatives to train, optimize, improve or otherwise influence the functionality or performance of any: (i) other large language model; (ii) technology for protein structure prediction; ****or (iii) other Third Party Model ****that is similar to the AI Model. You may, however, use the Outputs and Outputs Derivatives to train, optimize, improve or otherwise influence the functionality or performance of the AI Model itself and downstream Derivative Works thereof. + +**Additional Restrictions**.  Your use of the AI Model may also be subject to additional use restrictions communicated to You through the AI Model or otherwise, including those set forth in the ES Acceptable Use Policy available at [https://evolutionaryscale.ai/acceptable-use-policy], as may be updated and amended from time to time (the “**AUP**”), the terms of which are incorporated herein by reference. In the event of any conflict between the terms of this Agreement and the terms of the AUP, the terms that are more restrictive of Your use of the AI Model, Derivative Works, Outputs and Output Derivatives, as applicable, shall govern and control. + +## Submission of Contributions. + +Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the AI Model by You to ES shall be under the terms and conditions of this Agreement, 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 ES regarding such Contributions. + +## Trademarks. + +This Agreement does not grant permission to use the trade names, trademarks, service marks, or product names of ES, except as required for reasonable and customary use in describing the origin of the AI Model and reproducing the content of the NOTICE file. + +## Disclaimer of Warranty. + +UNLESS REQUIRED BY APPLICABLE LAW OR OTHERWISE EXPRESSLY AGREED MUTUALLY AGREED UPON BY YOU AND ES IN WRITING, ES PROVIDES THE AI MODEL (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, CORRECTNESS, RELIABILITY OR FITNESS FOR A PARTICULAR PURPOSE, ALL OF WHICH ARE HEREBY DISCLAIMED. YOU ARE SOLELY RESPONSIBLE FOR DETERMINING THE APPROPRIATENESS OF USING OR REDISTRIBUTING THE AI MODEL AND ASSUME ANY RISKS ASSOCIATED WITH YOUR EXERCISE OF PERMISSIONS UNDER THIS AGREEMENT. + +## 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 Agreement or out of the use or inability to use the AI Model (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. + +## General. + +1. **Entire Agreement**. This Agreement constitutes the entire agreement between You and ES relating to the subject matter hereof and supersedes all proposals, understandings, or discussions, whether written or oral, relating to the subject matter of this Agreement and all past dealing or industry custom. The failure of either party to enforce its rights under this Agreement at any time for any period shall not be construed as a waiver of such rights. ES may amend or modify this Agreement from time to time and will use reasonable efforts to provide You with notice of any material changes that may negatively impact Your use of the AI Model through the GitHub Page or through another means made available to You. No other changes, modifications or waivers to this Agreement will be effective unless in writing and signed by both parties. +2. **Relationship of Parties**. You and ES are independent contractors, and nothing herein shall be deemed to constitute either party as the agent or representative of the other or both parties as joint venturers or partners for any purpose. +3. **Export Control**. You shall comply with the U.S. Foreign Corrupt Practices Act and all applicable export laws, restrictions and regulations of the U.S. Department of Commerce, and any other applicable U.S. and foreign authority. +4. **Assignment**. This Agreement and the rights and obligations herein may not be assigned or transferred, in whole or in part, by You without the prior written consent of ES. Any assignment in violation of this provision is void. ES may freely assign or transfer this Agreement, in whole or in part. This Agreement shall be binding upon, and inure to the benefit of, the successors and permitted assigns of the parties. +5. **Governing Law**. This Agreement shall be governed by and construed under the laws of the State of New York and the United States without regard to conflicts of laws provisions thereof, and without regard to the Uniform Computer Information Transactions Act. +6. **Severability**.  If any provision of this Agreement is held to be invalid, illegal or unenforceable in any respect, that provision shall be limited or eliminated to the minimum extent necessary so that this Agreement otherwise remains in full force and effect and enforceable. diff --git a/README.md b/README.md new file mode 100644 index 0000000..a6d33c1 --- /dev/null +++ b/README.md @@ -0,0 +1,106 @@ +# ESM3 +[ESM3](https://www.evolutionaryscale.ai/papers/esm3-simulating-500-million-years-of-evolution-with-a-language-model) is a frontier generative model for biology, able to jointly reason across three fundamental biological properties of proteins: sequence, structure, and function. These three data modalities are represented as tracks of discrete tokens at the input and output of ESM3. You can present the model with a combination of partial inputs across the tracks, and ESM3 will provide output predictions for all the tracks. + +ESM3 is a *generative* masked language model. You can prompt it with partial sequence, structure, and function keywords, and iteratively sample masked positions until all positions are unmasked. This iterative sampling is what the `.generate()` function does. + + +ESM3 Diagram + +The ESM3 architecture is highly scalable due to its transformer backbone and all-to-all reasoning over discrete token sequences. At its largest scale, ESM3 was trained with 1.07e24 FLOPs on 2.78 billion proteins and 771 billion unique tokens, and has 98 billion parameters. + +Here we present `esm3-open-small`. With 1.4B parameters it is the smallest and fastest model in the family. +ESM3-open is available under a [non-commercial license](LICENSE.md). +Visit our [Discussions page](https://github.com/evolutionaryscale/esm/discussions) to get in touch, provide feedback, ask questions or share your experience with ESM3! + + +## Quickstart for ESM3-open + +``` +pip install esm +``` + +In order to download the weights, we require users to accept our non-commercial license. +The weights are stored on HuggingFace Hub under [HuggingFace/EvolutionaryScale/esm3](https://huggingface.co/EvolutionaryScale/esm3). +Please create an account and accept the license. + +```py +from huggingface_hub import login +from esm.models.esm3 import ESM3 +from esm.sdk.api import ESM3InferenceClient, ESMProtein, GenerationConfig + +# This will prompt you to get an API key from huggingface hub, make one with +# "Read" or "Write" permission and copy it back here. +login() + +# This will download the model weights and instantiate the model on your machine. +model: ESM3InferenceClient = ESM3.from_pretrained("esm3_sm_open_v1").to("cuda") # or "cpu" + +# Generate a completion for a partial Carbonic Anhydrase (2vvb) +prompt = "___________________________________________________DQATSLRILNNGHAFNVEFDDSQDKAVLKGGPLDGTYRLIQFHFHWGSLDGQGSEHTVDKKKYAAELHLVHWNTKYGDFGKAVQQPDGLAVLGIFLKVGSAKPGLQKVVDVLDSIKTKGKSADFTNFDPRGLLPESLDYWTYPGSLTTPP___________________________________________________________" +protein = ESMProtein(sequence=prompt) +# Generate the sequence, then the structure. This will iteratively unmask the sequence track. +protein = model.generate(protein, GenerationConfig(track="sequence", num_steps=8, temperature=0.7)) +# We can show the predicted structure for the generated sequence. +protein = model.generate(protein, GenerationConfig(track="structure", num_steps=8)) +protein.to_pdb("./generation.pdb") +# Then we can do a round trip design by inverse folding the sequence and recomputing the structure +protein.sequence = None +protein = model.generate(protein, GenerationConfig(track="sequence", num_steps=8)) +protein.structure = None +protein = model.generate(protein, GenerationConfig(track="structure", num_steps=8)) +protein.to_pdb("./round_tripped.pdb") +``` + +Congratulations, you just ran a chain of thought with ESM3! +Let's explore some more advanced prompting examples: + +[Open examples/generate.ipynb in Colab](https://colab.research.google.com/github/evolutionaryscale/esm/blob/main/examples/generate.ipynb) + +## Forge: Access to larger ESM3 models +You can apply for beta access to the full family of ESM3 models at [EvolutionaryScale Forge](https://forge.evolutionaryscale.ai). + +We encourage users to interact with the Forge API through the python `esm` library instead of the command line. +The python interface enables you to interactively load proteins, build prompts, and inspect generated proteins. +Additionally, users can seamlessly swap between `esm.models.esm3.ESM3` running locally, and +`esm.sdk.forge.ESM3ForgeInferenceClient` connecting to the Forge API. + +Once the forge client is released, we'll be able to do something like: +```py +model: ESM3InferenceClient = ESMForgeInferenceClient("esm3_sm_open_v1").to("cuda") +... +``` +and the exact same code will work. +This will enable seamless access to our large 98B protein language models for protein design work. + +## Responsible Development + +EvolutionaryScale is a public benefit company. Our mission is to develop artificial intelligence to understand biology for the benefit of human health and society, through partnership with the scientific community, and open, safe, and responsible research. Inspired by the history of our field as well as [new principles and recommendations](https://responsiblebiodesign.ai/), we have created a Responsible Development Framework to guide our work towards our mission with transparency and clarity. + +The core tenants of our framework are + +- We will communicate the benefits and risks of our research +- We will proactively and rigorously evaluate the risk of our models before public deployment +- We will adopt risk mitigation strategies and precautionary guardrails +- We will work with stakeholders in government, policy, and civil society to keep them informed + +With this in mind, we have performed a variety of mitigations for `esm3-sm-open-v1`, detailed in our [paper](https://www.evolutionaryscale.ai/papers/esm3-simulating-500-million-years-of-evolution-with-a-language-model) + + +## License + +**The Big Picture:** + +1. The EvolutionaryScale AI Model is **only** available under this Community License Agreement for **non-commercial use** by **individuals** or **non-commercial organizations** (including universities, non-profit organizations and research institutes, educational and government bodies). + +2. You **may not** use the EvolutionaryScale AI Model or any derivative works of the EvolutionaryScale AI Model or its outputs: + + 1. in connection with **any commercial activities**, for example, any activities **by, on behalf of or for a commercial entity** or to develop **any product or service** such as hosting the AI Model behind an API; or + + 2. without attribution to EvolutionaryScale and this Community License Agreement; or + + 3. to **train** any other **large language model**, any technology for protein representation learning or protein generation or any other AI-powered third party model **similar to EvolutionaryScale’s AI Model**, even for non-commercial usage. + +3. You **can publish, share and adapt** the EvolutionaryScale AI Model and its outputs for **non-commercial purposes** in accordance with the Community License Agreement, including the requirement to **restrict** the usage of any reproductions and copies **by, on behalf of or for a commercial entity** or **for any commercial purpose**. + + +Please refer to our [non-commercial license](LICENSE.md) for details. diff --git a/_assets/esm3_diagram.png b/_assets/esm3_diagram.png new file mode 100644 index 0000000..4e6e2d5 Binary files /dev/null and b/_assets/esm3_diagram.png differ diff --git a/esm/__init__.py b/esm/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/esm/layers/attention.py b/esm/layers/attention.py new file mode 100644 index 0000000..823aa2c --- /dev/null +++ b/esm/layers/attention.py @@ -0,0 +1,70 @@ +import functools + +import einops +import torch +import torch.nn.functional as F +from torch import nn + +from esm.layers.rotary import RotaryEmbedding + + +class MultiHeadAttention(nn.Module): + def __init__( + self, + d_model: int, + n_heads: int, + bias: bool = False, + qk_layernorm: bool = True, + ): + super().__init__() + + self.d_model = d_model + self.n_heads = n_heads + + self.d_head = self.d_model // self.n_heads + self.layernorm_qkv = nn.Sequential( + nn.LayerNorm(d_model), nn.Linear(d_model, d_model * 3, bias=bias) + ) + self.out_proj = nn.Linear(d_model, d_model, bias=bias) + + if qk_layernorm: + self.q_ln = nn.LayerNorm(d_model, bias=bias) + self.k_ln = nn.LayerNorm(d_model, bias=bias) + else: + self.q_ln = nn.Identity() + self.k_ln = nn.Identity() + + self.rotary = RotaryEmbedding(d_model // n_heads) + + def _apply_rotary(self, q: torch.Tensor, k: torch.Tensor): + q = q.unflatten(-1, (self.n_heads, self.d_head)) + k = k.unflatten(-1, (self.n_heads, self.d_head)) + q, k = self.rotary(q, k) + q = q.flatten(-2, -1) + k = k.flatten(-2, -1) + return q, k + + def forward(self, x, seq_id): + qkv_BLD3 = self.layernorm_qkv(x) + query_BLD, key_BLD, value_BLD = torch.chunk(qkv_BLD3, 3, dim=-1) + query_BLD, key_BLD = self.q_ln(query_BLD), self.k_ln(key_BLD) + query_BLD, key_BLD = self._apply_rotary(query_BLD, key_BLD) + + n_heads = self.n_heads + reshaper = functools.partial( + einops.rearrange, pattern="b s (h d) -> b h s d", h=n_heads + ) + + query_BHLD, key_BHLD, value_BHLD = map( + reshaper, (query_BLD, key_BLD, value_BLD) + ) + + # Where True, enable participation in attention. + mask_BLL = seq_id.unsqueeze(-1) == seq_id.unsqueeze(-2) + mask_BHLL = mask_BLL.unsqueeze(1) + + context_BHLD = F.scaled_dot_product_attention( + query_BHLD, key_BHLD, value_BHLD, mask_BHLL + ) + context_BLD = einops.rearrange(context_BHLD, "b h s d -> b s (h d)") + return self.out_proj(context_BLD) diff --git a/esm/layers/blocks.py b/esm/layers/blocks.py new file mode 100644 index 0000000..7d0203f --- /dev/null +++ b/esm/layers/blocks.py @@ -0,0 +1,153 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +from esm.layers.attention import MultiHeadAttention +from esm.layers.geom_attention import ( + GeometricReasoningOriginalImpl, +) +from esm.utils.structure.affine3d import Affine3D + + +def swiglu_correction_fn(expansion_ratio: float, d_model: int) -> int: + # set hidden dimesion to nearest multiple of 256 after expansion ratio + return int(((expansion_ratio * d_model) + 255) // 256 * 256) + + +class SwiGLU(nn.Module): + """ + SwiGLU activation function as an nn.Module, allowing it to be used within nn.Sequential. + This module splits the input tensor along the last dimension and applies the SiLU (Swish) + activation function to the first half, then multiplies it by the second half. + """ + + def __init__(self): + super(SwiGLU, self).__init__() + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x1, x2 = x.chunk(2, dim=-1) + return F.silu(x1) * x2 + + +def swiglu_ln_ffn(d_model: int, expansion_ratio: float, bias: bool): + return nn.Sequential( + nn.LayerNorm(d_model), + nn.Linear( + d_model, swiglu_correction_fn(expansion_ratio, d_model) * 2, bias=bias + ), + SwiGLU(), + nn.Linear(swiglu_correction_fn(expansion_ratio, d_model), d_model, bias=bias), + ) + + +def gelu_ln_ffn(d_model: int, expansion_ratio: float, bias: bool): + hidden_dim = int(expansion_ratio * d_model) + return nn.Sequential( + nn.LayerNorm(d_model), + nn.Linear(d_model, hidden_dim, bias=bias), + nn.GELU(), + nn.Linear(hidden_dim, d_model, bias=bias), + ) + + +class UnifiedTransformerBlock(nn.Module): + """ + A unified transformer block that can optionally incorporate geometric attention. + + This class defines a transformer block that can be configured to use geometric attention + alongside the standard multi-head attention mechanism. It is designed to be a flexible + component of transformer-based models, allowing for the integration of geometric reasoning. + + Parameters + ---------- + d_model : int + The dimensionality of the input and output features of the transformer block. + n_heads : int + The number of attention heads in the multi-head attention mechanism. + n_layers : int + The number of layers in the transformer block. + use_geom_attn : bool, optional + Whether to use geometric attention in addition to the standard multi-head attention. Defaults to False. + v_heads : int, optional + The number of heads to use for the geometric attention mechanism, if enabled. Must be specified if `use_geom_attn` is True. + """ + + def __init__( + self, + d_model: int, + n_heads: int, + use_geom_attn: bool = False, + use_plain_attn: bool = True, + v_heads: int | None = None, + bias: bool = False, + expansion_ratio: float = 4.0, + residue_scaling_factor: float = 1, + mask_and_zero_frameless: bool = False, + qk_layernorm: bool = True, + ffn_type: str = "swiglu", # swiglu | gelu + ): + super().__init__() + self.use_plain_attn = use_plain_attn + if self.use_plain_attn: + self.attn = MultiHeadAttention( + d_model, n_heads, bias, qk_layernorm=qk_layernorm + ) + self.use_geom_attn = use_geom_attn + if self.use_geom_attn: + if v_heads is None: + raise ValueError("v_heads must be specified when use_geom_attn is True") + self.geom_attn = GeometricReasoningOriginalImpl( + c_s=d_model, + v_heads=v_heads, + bias=bias, + mask_and_zero_frameless=mask_and_zero_frameless, + ) + if ffn_type == "swiglu": + self.ffn = swiglu_ln_ffn(d_model, expansion_ratio, bias) + elif ffn_type == "gelu": + self.ffn = gelu_ln_ffn(d_model, expansion_ratio, bias) + else: + raise ValueError(f"Unknown ffn_type: {ffn_type}") + self.scaling_factor = residue_scaling_factor + + def forward( + self, + x: torch.Tensor, + sequence_id: torch.Tensor, + frames: Affine3D, + frames_mask: torch.Tensor, + chain_id: torch.Tensor, + ) -> torch.Tensor: + """ + Forward pass for the UnifiedTransformerBlock. + + Parameters + ---------- + x : torch.Tensor[float] + Input tensor to the transformer block, typically the output from the previous layer. + sequence_id : torch.Tensor[int] + Tensor containing sequence IDs for each element in the batch, used for attention masking. + frames : Affine3D + Affine3D containing geometric frame information for geometric attention. + frames_mask : torch.Tensor[bool] + Boolean mask tensor indicating valid frames for geometric attention. + chain_id : torch.Tensor[int] + Tensor containing chain IDs for each element, used for attention masking in geometric attention. + + Returns + ------- + torch.Tensor[float] + The output tensor after applying the transformer block operations. + """ + if self.use_plain_attn: + r1 = self.attn(x, sequence_id) + x = x + r1 / self.scaling_factor + + if self.use_geom_attn: + r2 = self.geom_attn(x, frames, frames_mask, sequence_id, chain_id) + x = x + r2 / self.scaling_factor + + r3 = self.ffn(x) / self.scaling_factor + x = x + r3 + + return x diff --git a/esm/layers/codebook.py b/esm/layers/codebook.py new file mode 100644 index 0000000..886d17c --- /dev/null +++ b/esm/layers/codebook.py @@ -0,0 +1,88 @@ +import numpy as np +import torch +import torch.distributed as dist +import torch.nn as nn +import torch.nn.functional as F + + +class EMACodebook(nn.Module): + def __init__( + self, + n_codes, + embedding_dim, + no_random_restart=True, + restart_thres=1.0, + ema_decay=0.99, + ): + super().__init__() + self.register_buffer("embeddings", torch.randn(n_codes, embedding_dim)) + self.register_buffer("N", torch.zeros(n_codes)) + self.register_buffer("z_avg", self.embeddings.data.clone()) + + self.n_codes = n_codes + self.embedding_dim = embedding_dim + self._need_init = True + self.no_random_restart = no_random_restart + self.restart_thres = restart_thres + self.freeze_codebook = False + self.ema_decay = ema_decay + + def reset_parameters(self): + # For meta init + pass + + def _tile(self, x): + d, ew = x.shape + if d < self.n_codes: + n_repeats = (self.n_codes + d - 1) // d + std = 0.01 / np.sqrt(ew) + x = x.repeat(n_repeats, 1) + x = x + torch.randn_like(x) * std + return x + + def _init_embeddings(self, z): + # z: [b, t, c] + self._need_init = False + flat_inputs = z.view(-1, self.embedding_dim) + y = self._tile(flat_inputs) + + y.shape[0] + _k_rand = y[torch.randperm(y.shape[0])][: self.n_codes] + if dist.is_initialized(): + dist.broadcast(_k_rand, 0) + self.embeddings.data.copy_(_k_rand) + self.z_avg.data.copy_(_k_rand) + self.N.data.copy_(torch.ones(self.n_codes)) + + def forward(self, z): + # z: [b, t, c] + if self._need_init and self.training and not self.freeze_codebook: + self._init_embeddings(z) + # z is of shape [batch_size, sequence length, channels] + flat_inputs = z.view(-1, self.embedding_dim) + distances = ( + (flat_inputs**2).sum(dim=1, keepdim=True) + - 2 * flat_inputs @ self.embeddings.t() + + (self.embeddings.t() ** 2).sum(dim=0, keepdim=True) + ) # [bt, c] + + encoding_indices = torch.argmin(distances, dim=1) + encoding_indices = encoding_indices.view(*z.shape[:2]) # [b, t, ncode] + + embeddings = F.embedding(encoding_indices, self.embeddings) # [b, t, c] + + commitment_loss = 0.25 * F.mse_loss(z, embeddings.detach()) + + # EMA codebook update + if self.training and not self.freeze_codebook: + assert False, "Not implemented" + embeddings_st = (embeddings - z).detach() + z + + return embeddings_st, encoding_indices, commitment_loss + + def dictionary_lookup(self, encodings): + embeddings = F.embedding(encodings, self.embeddings) + return embeddings + + def soft_codebook_lookup(self, weights: torch.Tensor) -> torch.Tensor: + return weights @ self.embeddings diff --git a/esm/layers/ffn.py b/esm/layers/ffn.py new file mode 100644 index 0000000..3e97389 --- /dev/null +++ b/esm/layers/ffn.py @@ -0,0 +1,29 @@ +import torch.nn as nn +import torch.nn.functional as F +from torch import Tensor + +# NOT CURRENTLY USED + + +class SwiGLU(nn.Module): + def __init__(self) -> None: + super().__init__() + + def forward(self, x: Tensor) -> Tensor: + x1, x2 = x.chunk(2, dim=-1) + hidden = F.silu(x1) * x2 + return hidden + + +class FFN(nn.Module): + def __init__(self, in_proj, activation, out_proj) -> None: + super().__init__() + self.in_proj = in_proj + self.activation = activation + self.out_proj = out_proj + + def forward(self, x: Tensor) -> Tensor: + x = self.in_proj(x) + x = self.activation(x) + x = self.out_proj(x) + return x diff --git a/esm/layers/geom_attention.py b/esm/layers/geom_attention.py new file mode 100644 index 0000000..ec577cd --- /dev/null +++ b/esm/layers/geom_attention.py @@ -0,0 +1,151 @@ +from math import sqrt + +import torch +from einops import rearrange +from torch import nn +from torch.nn import functional as F + + +class GeometricReasoningOriginalImpl(nn.Module): + def __init__( + self, + c_s: int, + v_heads: int, + num_vector_messages: int = 1, + mask_and_zero_frameless: bool = True, + divide_residual_by_depth: bool = False, + bias: bool = False, + ): + """Approximate implementation: + + ATTN(A, v) := (softmax_j A_ij) v_j + make_rot_vectors(x) := R(i->g) Linear(x).reshape(..., 3) + make_vectors(x) := T(i->g) Linear(x).reshape(..., 3) + + v <- make_rot_vectors(x) + q_dir, k_dir <- make_rot_vectors(x) + q_dist, k_dist <- make_vectors(x) + + A_ij <- dot(q_dir_i, k_dir_j) -||q_dist_i - k_dist_j||^2 + x <- x + Linear(T(g->i) ATTN(A, v)) + """ + super().__init__() + self.c_s = c_s + self.v_heads = v_heads + self.num_vector_messages = num_vector_messages + self.mask_and_zero_frameless = mask_and_zero_frameless + + self.s_norm = nn.LayerNorm(c_s, bias=bias) + dim_proj = ( + 4 * self.v_heads * 3 + self.v_heads * 3 * self.num_vector_messages + ) # 2 x (q, k) * number of heads * (x, y, z) + number of heads * number of vector messages * (x, y, z) + self.proj = nn.Linear(c_s, dim_proj, bias=bias) + channels_out = self.v_heads * 3 * self.num_vector_messages + self.out_proj = nn.Linear(channels_out, c_s, bias=bias) + + # The basic idea is for some attention heads to pay more or less attention to rotation versus distance, + # as well as to control the sharpness of the softmax (i.e., should this head only attend to those residues + # very nearby or should there be shallower dropoff in attention weight?) + self.distance_scale_per_head = nn.Parameter(torch.zeros((self.v_heads))) + self.rotation_scale_per_head = nn.Parameter(torch.zeros((self.v_heads))) + + def forward(self, s, affine, affine_mask, sequence_id, chain_id): + attn_bias = sequence_id.unsqueeze(-1) == sequence_id.unsqueeze(-2) + attn_bias = attn_bias.unsqueeze(1).float() + attn_bias = attn_bias.masked_fill( + ~affine_mask[:, None, None, :], torch.finfo(attn_bias.dtype).min + ) + chain_id_mask = chain_id.unsqueeze(1) != chain_id.unsqueeze(2) + attn_bias = attn_bias.masked_fill( + chain_id_mask.unsqueeze(1), torch.finfo(s.dtype).min + ) + + ns = self.s_norm(s) + vec_rot, vec_dist = self.proj(ns).split( + [ + self.v_heads * 2 * 3 + self.v_heads * 3 * self.num_vector_messages, + self.v_heads * 2 * 3, + ], + dim=-1, + ) + + # Rotate the queries and keys for the rotation term. We also rotate the values. + # NOTE(zeming, thayes): Values are only rotated, not translated. We may wish to change + # this in the future. + query_rot, key_rot, value = ( + affine.rot[..., None] + .apply(rearrange(vec_rot, "... (h c) -> ... h c", c=3)) + .split( + [ + self.v_heads, + self.v_heads, + self.v_heads * self.num_vector_messages, + ], + dim=-2, + ) + ) + + # Rotate and translate the queries and keys for the distance term + # NOTE(thayes): a simple speedup would be to apply all rotations together, then + # separately apply the translations. + query_dist, key_dist = ( + affine[..., None] + .apply(rearrange(vec_dist, "... (h c) -> ... h c", c=3)) + .chunk(2, dim=-2) + ) + + query_dist = rearrange(query_dist, "b s h d -> b h s 1 d") + key_dist = rearrange(key_dist, "b s h d -> b h 1 s d") + query_rot = rearrange(query_rot, "b s h d -> b h s d") + key_rot = rearrange(key_rot, "b s h d -> b h d s") + value = rearrange( + value, "b s (h m) d -> b h s (m d)", m=self.num_vector_messages + ) + + distance_term = (query_dist - key_dist).norm(dim=-1) / sqrt(3) + rotation_term = query_rot.matmul(key_rot) / sqrt(3) + distance_term_weight = rearrange( + F.softplus(self.distance_scale_per_head), "h -> h 1 1" + ) + rotation_term_weight = rearrange( + F.softplus(self.rotation_scale_per_head), "h -> h 1 1" + ) + + attn_weight = ( + rotation_term * rotation_term_weight - distance_term * distance_term_weight + ) + + if attn_bias is not None: + # we can re-use the attention bias from the transformer layers + # NOTE(thayes): This attention bias is expected to handle two things: + # 1. Masking attention on padding tokens + # 2. Masking cross sequence attention in the case of bin packing + s_q = attn_weight.size(2) + s_k = attn_weight.size(3) + _s_q = max(0, attn_bias.size(2) - s_q) + _s_k = max(0, attn_bias.size(3) - s_k) + attn_bias = attn_bias[:, :, _s_q:, _s_k:] + attn_weight = attn_weight + attn_bias + + attn_weight = torch.softmax(attn_weight, dim=-1) + + attn_out = attn_weight.matmul(value) + + attn_out = ( + affine.rot[..., None] + .invert() + .apply( + rearrange( + attn_out, "b h s (m d) -> b s (h m) d", m=self.num_vector_messages + ) + ) + ) + + attn_out = rearrange( + attn_out, "b s (h m) d -> b s (h m d)", m=self.num_vector_messages + ) + if self.mask_and_zero_frameless: + attn_out = attn_out.masked_fill(~affine_mask[..., None], 0.0) + s = self.out_proj(attn_out) + + return s diff --git a/esm/layers/regression_head.py b/esm/layers/regression_head.py new file mode 100644 index 0000000..a237872 --- /dev/null +++ b/esm/layers/regression_head.py @@ -0,0 +1,24 @@ +import torch.nn as nn + + +def RegressionHead( + d_model: int, + output_dim: int, + hidden_dim: int | None = None, +) -> nn.Module: + """Single-hidden layer MLP for supervised output. + + Args: + d_model: input dimension + output_dim: dimensionality of the output. + hidden_dim: optional dimension of hidden layer, defaults to d_model. + Returns: + output MLP module. + """ + hidden_dim = hidden_dim if hidden_dim is not None else d_model + return nn.Sequential( + nn.Linear(d_model, hidden_dim), + nn.GELU(), + nn.LayerNorm(hidden_dim), + nn.Linear(hidden_dim, output_dim), + ) diff --git a/esm/layers/rotary.py b/esm/layers/rotary.py new file mode 100644 index 0000000..b820969 --- /dev/null +++ b/esm/layers/rotary.py @@ -0,0 +1,221 @@ +# Copyright 2022 EleutherAI and the HuggingFace Inc. team. All rights reserved. +# +# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX +# and OPT implementations in this library. It has been modified from its +# original forms to accommodate minor architectural differences compared +# to GPT-NeoX and OPT used by the Meta AI team that trained the model. +# +# 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. +# NOTE: this implementation is from LLaMA 2: +# https://huggingface.co/togethercomputer/LLaMA-2-7B-32K/blob/08639a72e17836184096ae6a7e2766f2a34c3e36/modeling_flash_llama.py#L114 +# Flash attention rotary implementation can be installed like so: `pip install git+https://github.com/HazyResearch/flash-attention.git#subdirectory=csrc/rotary` + +from typing import Tuple + +import torch +from einops import rearrange, repeat + + +def rotate_half(x, interleaved=False): + if not interleaved: + x1, x2 = x.chunk(2, dim=-1) + return torch.cat((-x2, x1), dim=-1) + else: + x1, x2 = x[..., ::2], x[..., 1::2] + return rearrange( + torch.stack((-x2, x1), dim=-1), "... d two -> ... (d two)", two=2 + ) + + +def apply_rotary_emb_torch(x, cos, sin, interleaved=False, _inplace=False): + """ + x: (batch_size, seqlen, nheads, headdim) + cos, sin: (seqlen, rotary_dim / 2) + """ + ro_dim = cos.shape[-1] * 2 + assert ro_dim <= x.shape[-1] + seqlen = x.size(1) + cos = cos[:seqlen] + sin = sin[:seqlen] + cos = repeat(cos, "s d -> s 1 (2 d)") + sin = repeat(sin, "s d -> s 1 (2 d)") + return torch.cat( + [ + x[..., :ro_dim] * cos + rotate_half(x[..., :ro_dim], interleaved) * sin, + x[..., ro_dim:], + ], + dim=-1, + ) + + +class RotaryEmbedding(torch.nn.Module): + """ + The rotary position embeddings from RoFormer_ (Su et. al). + A crucial insight from the method is that the query and keys are + transformed by rotation matrices which depend on the relative positions. + Other implementations are available in the Rotary Transformer repo_ and in + GPT-NeoX_, GPT-NeoX was an inspiration + .. _RoFormer: https://arxiv.org/abs/2104.09864 + .. _repo: https://github.com/ZhuiyiTechnology/roformer + .. _GPT-NeoX: https://github.com/EleutherAI/gpt-neox + If scale_base is not None, this implements XPos (Sun et al., https://arxiv.org/abs/2212.10554). + A recommended value for scale_base is 512: https://github.com/HazyResearch/flash-attention/issues/96 + Reference: https://github.com/sunyt32/torchscale/blob/main/torchscale/component/xpos_relative_position.py + """ + + def __init__( + self, + dim: int, + base=10000.0, + interleaved=False, + scale_base=None, + scaling_factor=1.0, + pos_idx_in_fp32=True, + device=None, + ): + """ + interleaved: if True, rotate pairs of even and odd dimensions (GPT-J style) instead + of 1st half and 2nd half (GPT-NeoX style). + pos_idx_in_fp32: if True, the position indices [0.0, ..., seqlen - 1] are in fp32, + otherwise they might be in lower precision. + This option was added because previously (before 2023-07-02), when we construct + the position indices, we use the dtype of self.inv_freq. In most cases this would + be fp32, but if the model is trained in pure bf16 (not mixed precision), then + self.inv_freq would be bf16, and the position indices are also in bf16. + Because of the limited precision of bf16 (e.g. 1995.0 is rounded to 2000.0), the + embeddings for some positions will coincide. + To maintain compatibility with models previously trained in pure bf16, + we add this option. + scaling_factor: RotaryEmbedding extended with linear scaling. + """ + super().__init__() + self.dim = dim + self.base = float(base) + self.pos_idx_in_fp32 = pos_idx_in_fp32 + # Generate and save the inverse frequency buffer (non trainable) + self.interleaved = interleaved + self.scale_base = scale_base + self.scaling_factor = scaling_factor + self.device = device + + self._seq_len_cached = 0 + self._cos_cached = None + self._sin_cached = None + self._cos_k_cached = None + self._sin_k_cached = None + self.reset_parameters() + + def reset_parameters(self): + inv_freq = self._compute_inv_freq(self.device) + self.register_buffer("inv_freq", inv_freq, persistent=False) + arange = torch.arange(0, self.dim, 2, device=self.device, dtype=torch.float32) + scale = ( + (arange + 0.4 * self.dim) / (1.4 * self.dim) + if self.scale_base is not None + else None + ) + self.register_buffer("scale", scale) + + def _compute_inv_freq(self, device=None): + return 1 / ( + self.base + ** ( + torch.arange(0, self.dim, 2, device=device, dtype=torch.float32) + / self.dim + ) + ) + + def _update_cos_sin_cache(self, seqlen, device=None, dtype=None): + # Reset the tables if the sequence length has changed, + # if we're on a new device (possibly due to tracing for instance), + # or if we're switching from inference mode to training + if ( + seqlen > self._seq_len_cached + or self._cos_cached is None + or self._cos_cached.device != device + or self._cos_cached.dtype != dtype + or (self.training and self._cos_cached.is_inference()) + ): + self._seq_len_cached = seqlen + # We want fp32 here, not self.inv_freq.dtype, since the model could be loaded in bf16 + # And the output of arange can be quite large, so bf16 would lose a lot of precision. + # However, for compatibility reason, we add an option to use the dtype of self.inv_freq. + if self.pos_idx_in_fp32: + t = torch.arange(seqlen, device=device, dtype=torch.float32) + t /= self.scaling_factor + # We want fp32 here as well since inv_freq will be multiplied with t, and the output + # will be large. Having it in bf16 will lose a lot of precision and cause the + # cos & sin output to change significantly. + # We want to recompute self.inv_freq if it was not loaded in fp32 + if self.inv_freq.dtype != torch.float32: + inv_freq = self.inv_freq.to(torch.float32) + else: + inv_freq = self.inv_freq + else: + t = torch.arange(seqlen, device=device, dtype=self.inv_freq.dtype) + t /= self.scaling_factor + inv_freq = self.inv_freq + # Don't do einsum, it converts fp32 to fp16 under AMP + # freqs = torch.einsum("i,j->ij", t, self.inv_freq) + freqs = torch.outer(t, inv_freq) + + if self.scale is None: + self._cos_cached = torch.cos(freqs).to(dtype) + self._sin_cached = torch.sin(freqs).to(dtype) + else: + power = ( + torch.arange( + seqlen, dtype=self.scale.dtype, device=self.scale.device + ) + - seqlen // 2 + ) / self.scale_base + scale = self.scale.to(device=power.device) ** power.unsqueeze(-1) + # We want the multiplication by scale to happen in fp32 + self._cos_cached = (torch.cos(freqs) * scale).to(dtype) + self._sin_cached = (torch.sin(freqs) * scale).to(dtype) + self._cos_k_cached = (torch.cos(freqs) / scale).to(dtype) + self._sin_k_cached = (torch.sin(freqs) / scale).to(dtype) + + def forward( + self, q: torch.Tensor, k: torch.Tensor, seqlen_offset: int = 0 + ) -> Tuple[torch.Tensor, torch.Tensor]: + """ + q: (batch, seqlen, nheads, headdim) + k: (batch, seqlen, nheads, headdim) + seqlen_offset: can be used in generation where the qkv being passed in is only the last + token in the batch. + """ + self._update_cos_sin_cache( + q.shape[1] + seqlen_offset, device=q.device, dtype=q.dtype + ) + assert self._cos_cached is not None + assert self._sin_cached is not None + if self.scale is None: + return ( + apply_rotary_emb_torch( + q, + self._cos_cached[seqlen_offset:], + self._sin_cached[seqlen_offset:], + self.interleaved, + True, # inplace=True + ), + apply_rotary_emb_torch( + k, + self._cos_cached[seqlen_offset:], + self._sin_cached[seqlen_offset:], + self.interleaved, + True, # inplace=True + ), + ) # type: ignore + else: + assert False diff --git a/esm/layers/structure_proj.py b/esm/layers/structure_proj.py new file mode 100644 index 0000000..a650176 --- /dev/null +++ b/esm/layers/structure_proj.py @@ -0,0 +1,68 @@ +import torch +import torch.nn as nn + +from esm.utils.constants.physics import ( + BB_COORDINATES, +) +from esm.utils.structure.affine3d import ( + Affine3D, + RotationMatrix, +) + + +class Dim6RotStructureHead(nn.Module): + # Normally, AF2 uses quaternions to specify rotations. There's some evidence that + # other representations are more well behaved - the best one according to + # https://openaccess.thecvf.com/content_CVPR_2019/papers/Zhou_On_the_Continuity_of_Rotation_Representations_in_Neural_Networks_CVPR_2019_paper.pdf + # is using graham schmidt on 2 vectors, which is implemented here. + def __init__( + self, + input_dim: int, + trans_scale_factor: float = 10, + norm_type: str = "layernorm", + activation_fn: str = "esm_gelu", + predict_torsion_angles: bool = True, + ): + super().__init__() + self.ffn1 = nn.Linear(input_dim, input_dim) + self.activation_fn = nn.GELU() + self.norm = nn.LayerNorm(input_dim) + self.proj = nn.Linear(input_dim, 9 + 7 * 2) + self.trans_scale_factor = trans_scale_factor + self.predict_torsion_angles = predict_torsion_angles + self.bb_local_coords = torch.tensor(BB_COORDINATES).float() + + def forward(self, x, affine, affine_mask, **kwargs): + if affine is None: + rigids = Affine3D.identity( + x.shape[:-1], + dtype=x.dtype, + device=x.device, + requires_grad=self.training, + rotation_type=RotationMatrix, + ) + else: + rigids = affine + + # [*, N] + x = self.ffn1(x) + x = self.activation_fn(x) + x = self.norm(x) + trans, x, y, angles = self.proj(x).split([3, 3, 3, 7 * 2], dim=-1) + trans = trans * self.trans_scale_factor + x = x / (x.norm(dim=-1, keepdim=True) + 1e-5) + y = y / (y.norm(dim=-1, keepdim=True) + 1e-5) + update = Affine3D.from_graham_schmidt(x + trans, trans, y + trans) + rigids = rigids.compose(update.mask(affine_mask)) + affine = rigids.tensor + + # We approximate the positions of the backbone atoms in the global frame by applying the rigid + # transformation to the mean of the backbone atoms in the local frame. + all_bb_coords_local = ( + self.bb_local_coords[None, None, :, :] + .expand(*x.shape[:-1], 3, 3) + .to(x.device) + ) + pred_xyz = rigids[..., None].apply(all_bb_coords_local) + + return affine, pred_xyz diff --git a/esm/layers/transformer_stack.py b/esm/layers/transformer_stack.py new file mode 100644 index 0000000..22d65ae --- /dev/null +++ b/esm/layers/transformer_stack.py @@ -0,0 +1,94 @@ +import math + +import torch +import torch.nn as nn + +from esm.layers.blocks import UnifiedTransformerBlock +from esm.utils.structure.affine3d import Affine3D + + +class TransformerStack(nn.Module): + """ + A stack of transformer blocks used in the ESM-3 model. Each block is a UnifiedTransformerBlock, + which can either be geometric attention or standard multi-head attention. + + Args: + d_model (int): The dimensionality of the input and output feature vectors. + n_heads (int): The number of attention heads. + v_heads (int): The number of voting heads. + n_layers (int): The number of transformer blocks in the stack. + n_layers_geom (int, optional): The number of transformer blocks that use geometric attention. + scale_residue (bool, optional): Whether to scale the residue connections in each transformer block. + mask_and_zero_frameless (bool, optional): Whether to mask and zero frameless positions in the input. + Only applies in the geometric attention blocks, which is conditioned on the structure + """ + + def __init__( + self, + d_model: int, + n_heads: int, + v_heads: int | None, + n_layers: int, + n_layers_geom: int = 1, + scale_residue: bool = True, + mask_and_zero_frameless: bool = False, + bias: bool = False, + qk_layernorm: bool = True, + ffn_type: str = "swiglu", # swiglu | gelu + expansion_ratio: float = 8 / 3, + ): + super().__init__() + self.blocks = nn.ModuleList( + [ + UnifiedTransformerBlock( + d_model, + n_heads, + v_heads=v_heads, + use_geom_attn=i < n_layers_geom, + residue_scaling_factor=( + math.sqrt(n_layers / 36) if scale_residue else 1.0 + ), + expansion_ratio=expansion_ratio, + mask_and_zero_frameless=mask_and_zero_frameless, + bias=bias, + qk_layernorm=qk_layernorm, + ffn_type=ffn_type, + ) + for i in range(n_layers) + ] + ) + self.norm = nn.LayerNorm(d_model, bias=False) + + def forward( + self, + x: torch.Tensor, + sequence_id: torch.Tensor | None = None, + affine: Affine3D | None = None, + affine_mask: torch.Tensor | None = None, + chain_id: torch.Tensor | None = None, + ) -> tuple[torch.Tensor, torch.Tensor]: + """ + Forward pass of the TransformerStack. + + Args: + x (torch.Tensor): The input tensor of shape (batch_size, sequence_length, d_model). + sequence_id (torch.Tensor): The sequence ID tensor of shape (batch_size, sequence_length). + affine (Affine3D | None): The affine transformation tensor or None. + affine_mask (torch.Tensor | None): The affine mask tensor or None. + chain_id (torch.Tensor): The protein chain tensor of shape (batch_size, sequence_length). + Only used in geometric attention. + + Returns: + post_norm: The output tensor of shape (batch_size, sequence_length, d_model). + pre_norm: The embedding of shape (batch_size, sequence_length, d_model). + """ + *batch_dims, _ = x.shape + if sequence_id is None: + sequence_id = torch.ones( + size=batch_dims, dtype=torch.int64, device=x.device + ) + if chain_id is None: + chain_id = torch.ones(size=batch_dims, dtype=torch.int64, device=x.device) + for block in self.blocks: + x = block(x, sequence_id, affine, affine_mask, chain_id) + return self.norm(x), x diff --git a/esm/models/esm3.py b/esm/models/esm3.py new file mode 100644 index 0000000..76e26cd --- /dev/null +++ b/esm/models/esm3.py @@ -0,0 +1,799 @@ +from __future__ import annotations + +import contextlib +from functools import partial + +import attr +import einops +import torch +import torch.nn as nn +from attr import dataclass + +from esm.layers.regression_head import RegressionHead +from esm.layers.transformer_stack import TransformerStack +from esm.models.function_decoder import FunctionTokenDecoder +from esm.models.vqvae import ( + StructureTokenDecoder, + StructureTokenEncoder, +) +from esm.sdk.api import ( + ESM3InferenceClient, + ESMProtein, + ESMProteinTensor, + ForwardAndSampleOutput, + ForwardConfig, + ForwardOutput, + ForwardTrackData, + GenerationConfig, + ProteinType, + ReturnLogitsConfig, + SamplingConfig, + SamplingTrackConfig, +) +from esm.tokenization import get_model_tokenizers +from esm.utils import encoding +from esm.utils.constants import esm3 as C +from esm.utils.constants.models import ESM3_OPEN_SMALL +from esm.utils.decoding import decode_protein_tensor +from esm.utils.generation import ( + iterative_sampling_raw, + iterative_sampling_tokens, +) +from esm.utils.misc import rbf +from esm.utils.sampling import ( + get_default_sampling_config, + sample_function_logits, + sample_logits, + sample_residue_annotation_logits, +) +from esm.utils.structure.affine3d import ( + build_affine3d_from_coordinates, +) + + +@dataclass +class ESMOutput: + sequence_logits: torch.Tensor + structure_logits: torch.Tensor + secondary_structure_logits: torch.Tensor + sasa_logits: torch.Tensor + function_logits: torch.Tensor + residue_logits: torch.Tensor + embeddings: torch.Tensor + + +class EncodeInputs(nn.Module): + """ + Module for encoding input features in the ESM-3 model. + + Args: + d_model (int): The dimensionality of the model's hidden states. + """ + + def __init__(self, d_model: int): + super().__init__() + + # Sequence + self.sequence_embed = nn.Embedding(64, d_model) + # Mandatory information + self.plddt_projection = nn.Linear(16, d_model) + self.structure_per_res_plddt_projection = nn.Linear(16, d_model) + + # Structure + self.structure_tokens_embed = nn.Embedding(4096 + 5, d_model) + + # "Structural" features + self.ss8_embed = nn.Embedding(8 + 3, d_model) + self.sasa_embed = nn.Embedding(16 + 3, d_model) + + # "Functional" features + self.function_embed = nn.ModuleList( + [nn.Embedding(260, d_model // 8, padding_idx=0) for _ in range(8)] + ) + + self.residue_embed = nn.EmbeddingBag(1478, d_model, mode="sum", padding_idx=0) + + def forward( + self, + sequence_tokens: torch.Tensor, + structure_tokens: torch.Tensor, + average_plddt: torch.Tensor, + per_res_plddt: torch.Tensor, + ss8_tokens: torch.Tensor, + sasa_tokens: torch.Tensor, + function_tokens: torch.Tensor, + residue_annotation_tokens: torch.Tensor, + ) -> torch.Tensor: + sequence_embed = self.sequence_embed(sequence_tokens) + + rbf_16_fn = partial(rbf, v_min=0.0, v_max=1.0, n_bins=16) + # the `masked_fill(padding_mask.unsqueeze(2), 0)` for the two below is unnecessary + # as pad tokens never even interact with the "real" tokens (due to sequence_id) + plddt_embed = self.plddt_projection(rbf_16_fn(average_plddt)) + structure_per_res_plddt = self.structure_per_res_plddt_projection( + rbf_16_fn(per_res_plddt) + ) + + # Structure + "structural features" embeds + structure_embed = self.structure_tokens_embed(structure_tokens) + ss8_embed = self.ss8_embed(ss8_tokens) + sasa_embed = self.sasa_embed(sasa_tokens) + + # "Functional" features embeds + function_embed = torch.cat( + [ + embed_fn(funcs) + for embed_fn, funcs in zip( + self.function_embed, function_tokens.unbind(-1) + ) + ], + -1, + ) + + # Residue embeds + B, L, N = residue_annotation_tokens.shape + residue_embed = self.residue_embed( + einops.rearrange( + residue_annotation_tokens, "B L N -> (B L) N", B=B, L=L, N=N + ) + ) + residue_embed = einops.rearrange(residue_embed, "(B L) D -> B L D", B=B, L=L) + + return ( + sequence_embed + + plddt_embed + + structure_per_res_plddt + + structure_embed + + ss8_embed + + sasa_embed + + function_embed + + residue_embed + ) + + +class OutputHeads(nn.Module): + def __init__(self, d_model: int): + super().__init__() + self.sequence_head = RegressionHead(d_model, 64) + self.structure_head = RegressionHead(d_model, 4096) + self.ss8_head = RegressionHead(d_model, 8 + 3) + self.sasa_head = RegressionHead(d_model, 16 + 3) + self.function_head = RegressionHead(d_model, 260 * 8) + self.residue_head = RegressionHead(d_model, 1478) + + def forward(self, x: torch.Tensor, embed: torch.Tensor) -> ESMOutput: + sequence_logits = self.sequence_head(x) + structure_logits = self.structure_head(x) + secondary_structure_logits = self.ss8_head(x) + sasa_logits = self.sasa_head(x) + function_logits = self.function_head(x) + function_logits = einops.rearrange( + function_logits, + "... (k v) -> ... k v", + k=8, + ) + + residue_logits = self.residue_head(x) + + return ESMOutput( + sequence_logits=sequence_logits, + structure_logits=structure_logits, + secondary_structure_logits=secondary_structure_logits, + sasa_logits=sasa_logits, + function_logits=function_logits, + residue_logits=residue_logits, + embeddings=embed, + ) + + +class ESM3(nn.Module, ESM3InferenceClient): + """ + ESM3 model implementation. + + Args: + d_model (int): The dimensionality of the input and output feature vectors. + n_heads (int): The number of attention heads in the transformer layers. + v_heads (int): The number of attention heads in the variational transformer layers. + n_layers (int): The number of transformer layers. + """ + + def __init__( + self, + d_model: int, + n_heads: int, + v_heads: int, + n_layers: int, + structure_encoder_name: str, + structure_decoder_name: str, + function_decoder_name: str, + ): + super().__init__() + self.encoder = EncodeInputs(d_model) + self.transformer = TransformerStack( + d_model, + n_heads, + v_heads, + n_layers, + mask_and_zero_frameless=True, + ) + self.output_heads = OutputHeads(d_model) + + self.structure_encoder_name = structure_encoder_name + self.structure_decoder_name = structure_decoder_name + self.function_decoder_name = function_decoder_name + + self.structure_encoder: StructureTokenEncoder | None = None # type: ignore + self.structure_decoder: StructureTokenDecoder | None = None # type: ignore + self.function_decoder: FunctionTokenDecoder | None = None # type: ignore + + self.tokenizers = get_model_tokenizers(ESM3_OPEN_SMALL) + + @classmethod + def from_pretrained( + cls, + model_name: str = ESM3_OPEN_SMALL, + device: torch.device | str = "cpu", + ) -> ESM3: + from esm.pretrained import load_local_model + + if model_name not in [ESM3_OPEN_SMALL]: + raise ValueError(f"Model name {model_name} is not a valid ESM3 model name.") + model: ESM3 = load_local_model(model_name, device=device) # type: ignore + return model + + def get_structure_token_encoder(self) -> StructureTokenEncoder: + if self.structure_encoder is None: + self.structure_encoder = self.load_model(self.structure_encoder_name) # type: ignore + return self.structure_encoder # type: ignore + + def get_structure_token_decoder(self) -> StructureTokenDecoder: + if self.structure_decoder is None: + self.structure_decoder = self.load_model(self.structure_decoder_name) # type: ignore + return self.structure_decoder # type: ignore + + def get_function_token_decoder(self) -> FunctionTokenDecoder: + if self.function_decoder is None: + self.function_decoder = self.load_model(self.function_decoder_name) # type: ignore + return self.function_decoder # type: ignore + + def load_model(self, model_name: str): + # Lazy import from pretrained + from esm.pretrained import load_local_model + + return load_local_model(model_name, device=next(self.parameters()).device) + + def forward( + self, + *, + sequence_tokens: torch.Tensor | None = None, + structure_tokens: torch.Tensor | None = None, + ss8_tokens: torch.Tensor | None = None, + sasa_tokens: torch.Tensor | None = None, + function_tokens: torch.Tensor | None = None, + residue_annotation_tokens: torch.Tensor | None = None, + average_plddt: torch.Tensor | None = None, + per_res_plddt: torch.Tensor | None = None, + structure_coords: torch.Tensor | None = None, + chain_id: torch.Tensor | None = None, + sequence_id: torch.Tensor | None = None, + ) -> ESMOutput: + """ + Performs forward pass through the ESM3 model. Check utils to see how to tokenize inputs from raw data. + + Args: + sequence_tokens (torch.Tensor, optional): The amino acid tokens. + structure_tokens (torch.Tensor, optional): The structure tokens. + ss8_tokens (torch.Tensor, optional): The secondary structure tokens. + sasa_tokens (torch.Tensor, optional): The solvent accessible surface area tokens. + function_tokens (torch.Tensor, optional): The function tokens. + residue_annotation_tokens (torch.Tensor, optional): The residue annotation tokens. + average_plddt (torch.Tensor, optional): The average plddt across the entire sequence. + per_res_plddt (torch.Tensor, optional): The per residue plddt, if you want to specify exact plddts, use this, + otherwise, use average_plddt. + structure_coords (torch.Tensor, optional): The structure coordinates, in the form of (B, L, 3, 3). + chain_id (torch.Tensor, optional): The chain ID + sequence_id (torch.Tensor, optional): The sequence ID. + + Returns: + ESMOutput: The output of the ESM3 model. + + Raises: + ValueError: If at least one of the inputs is None. + + """ + # Reasonable defaults: + try: + L, device = next( + (x.shape[1], x.device) + for x in [ + sequence_tokens, + structure_tokens, + ss8_tokens, + sasa_tokens, + structure_coords, + function_tokens, + residue_annotation_tokens, + ] + if x is not None + ) + except StopIteration: + raise ValueError("At least one of the inputs must be non-None") + + t = self.tokenizers + defaults = lambda x, tok: ( + torch.full((1, L), tok, dtype=torch.long, device=device) if x is None else x + ) + sequence_tokens = defaults(sequence_tokens, t.sequence.mask_token_id) + ss8_tokens = defaults(ss8_tokens, C.SS8_UNK_TOKEN) + sasa_tokens = defaults(sasa_tokens, C.SASA_UNK_TOKEN) + average_plddt = defaults(average_plddt, 1).float() + per_res_plddt = defaults(per_res_plddt, 0).float() + chain_id = defaults(chain_id, 0) + sequence_id = defaults(sequence_id, 0) + + if residue_annotation_tokens is None: + residue_annotation_tokens = torch.full( + (1, L, 16), C.RESIDUE_PAD_TOKEN, dtype=torch.long, device=device + ) + + if function_tokens is None: + function_tokens = torch.full( + (1, L, 8), C.INTERPRO_PAD_TOKEN, dtype=torch.long, device=device + ) + + if structure_coords is None: + structure_coords = torch.full( + (1, L, 3, 3), float("nan"), dtype=torch.float, device=device + ) + + structure_coords = structure_coords[ + ..., :3, : + ] # In case we pass in an atom14 or atom37 repr + affine, affine_mask = build_affine3d_from_coordinates(structure_coords) + + if structure_tokens is None: + _, structure_tokens = self.get_structure_token_encoder().encode( + structure_coords + ) + assert structure_tokens is not None + structure_tokens = ( + structure_tokens.masked_fill( + (structure_tokens == -1) | ~affine_mask, C.STRUCTURE_MASK_TOKEN + ) + .masked_fill(sequence_tokens == C.SEQUENCE_BOS_TOKEN, C.STRUCTURE_BOS_TOKEN) + .masked_fill(sequence_tokens == C.SEQUENCE_PAD_TOKEN, C.STRUCTURE_PAD_TOKEN) + .masked_fill(sequence_tokens == C.SEQUENCE_EOS_TOKEN, C.STRUCTURE_EOS_TOKEN) + .masked_fill( + sequence_tokens == C.SEQUENCE_CHAINBREAK_TOKEN, + C.STRUCTURE_CHAINBREAK_TOKEN, + ) + ) + + x = self.encoder( + sequence_tokens, + structure_tokens, + average_plddt, + per_res_plddt, + ss8_tokens, + sasa_tokens, + function_tokens, + residue_annotation_tokens, + ) + x, embedding = self.transformer(x, sequence_id, affine, affine_mask, chain_id) + return self.output_heads(x, embedding) + + # The following methods are for the ESM3InferenceClient interface + def generate(self, input: ProteinType, config: GenerationConfig) -> ProteinType: + if isinstance(input, ESMProtein): + return iterative_sampling_raw(self, input, config) + elif isinstance(input, ESMProteinTensor): + return iterative_sampling_tokens(self, input, config, self.tokenizers) + else: + raise ValueError("Input must be an ESMProtein or ESMProteinTensor") + + def encode(self, input: ESMProtein) -> ESMProteinTensor: + input = attr.evolve(input) # Make a copy + + sequence_tokens = None + structure_tokens = None + secondary_structure_tokens = None + sasa_tokens = None + function_tokens = None + residue_annotation_tokens = None + + coordinates = None + + if input.sequence is not None: + sequence_tokens = encoding.tokenize_sequence( + input.sequence, self.tokenizers.sequence, add_special_tokens=True + ) + if input.secondary_structure is not None: + secondary_structure_tokens = encoding.tokenize_secondary_structure( + input.secondary_structure, + self.tokenizers.secondary_structure, + add_special_tokens=True, + ) + if input.sasa is not None: + sasa_tokens = encoding.tokenize_sasa( + input.sasa, self.tokenizers.sasa, add_special_tokens=True + ) + + # Infer input length + sequence_length = -1 + if sequence_tokens is not None: + sequence_length = len(sequence_tokens) + elif secondary_structure_tokens is not None: + sequence_length = len(secondary_structure_tokens) + elif sasa_tokens is not None: + sequence_length = len(sasa_tokens) + + # Try to infer input length from structure data + if input.coordinates is not None: + coordinates, _, structure_tokens = encoding.tokenize_structure( + input.coordinates, + self.get_structure_token_encoder(), + structure_tokenizer=self.tokenizers.structure, + reference_sequence=input.sequence or "", + add_special_tokens=True, + ) + if sequence_length == -1: + sequence_length = len(structure_tokens) + + if sequence_length == -1: + raise ValueError( + "Cannot infer input length from input data. Please provide one of: sequence, structure, secondary_structure, sasa.\n" + "To condition on sequence length only, use ESM3LocalInferenceClient.get_default_sequence(sequence_length) to generate a default sequence input." + ) + + # Function and Residue annotations + if input.function_annotations is not None: + if input.sequence is None: + reference_sequence = encoding.get_default_sequence(sequence_length - 2) + else: + reference_sequence = input.sequence + ( + function_tokens, + residue_annotation_tokens, + ) = encoding.tokenize_function_annotations( + input.function_annotations, + reference_sequence=reference_sequence, + function_tokenizer=self.tokenizers.function, + residue_annotation_tokenizer=self.tokenizers.residue_annotations, + add_special_tokens=True, + ) + + return ESMProteinTensor( + sequence=sequence_tokens, + structure=structure_tokens, + secondary_structure=secondary_structure_tokens, + sasa=sasa_tokens, + function=function_tokens, + residue_annotations=residue_annotation_tokens, + coordinates=coordinates, + ).to(next(self.parameters()).device) + + def decode( + self, + input: ESMProteinTensor, + ) -> ESMProtein: + return decode_protein_tensor( + input=input, + tokenizers=self.tokenizers, + structure_token_decoder=self.get_structure_token_decoder(), + function_token_decoder=self.get_function_token_decoder(), + ) + + def _forward( + self, input: ESMProteinTensor, config: ForwardConfig = ForwardConfig() + ) -> ForwardOutput: + # Default plddt conditioning for inference. 1s where coordinates are provided. + if input.coordinates is None: + per_res_plddt = None + else: + # 1.0 if all coordinates at specific indices have valid non-nan values. + per_res_plddt = input.coordinates.isfinite().all(dim=-1).any(dim=-1).float() + + with torch.no_grad() if self.eval else contextlib.nullcontext(): + output = self.forward( + sequence_tokens=input.sequence, + structure_tokens=input.structure, + ss8_tokens=input.secondary_structure, + sasa_tokens=input.sasa, + function_tokens=input.function, + residue_annotation_tokens=input.residue_annotations, + average_plddt=torch.tensor(1.0, device=input.device), + per_res_plddt=per_res_plddt, + structure_coords=input.coordinates, + chain_id=None, + sequence_id=None, + ) + + if config.return_logits: + logits = ForwardTrackData( + sequence=output.sequence_logits, + structure=output.structure_logits, + secondary_structure=output.secondary_structure_logits, + sasa=output.sasa_logits, + function=output.function_logits, + ) + else: + logits = None + + return ForwardOutput( + logits=logits, + residue_annotation_logits=output.residue_logits, + embeddings=output.embeddings if config.return_embeddings else None, + ) + + def forward_and_sample( + self, input: ESMProteinTensor, sampling_configuration: SamplingConfig + ) -> ForwardAndSampleOutput: + protein_tensor = attr.evolve(input) # Make a copy + + def maybe_clone(x: torch.Tensor | None) -> torch.Tensor | None: + return x.clone() if x is not None else None + + device = next(self.parameters()).device + + sampling_config = sampling_configuration + if sampling_config is None: + sampling_config = get_default_sampling_config(self.tokenizers) + + # Initialize default values for missing tracks + default_protein_tensor = ESMProteinTensor.empty( + len(input) - 2, tokenizers=self.tokenizers, device=input.device + ) + for track in attr.fields(ESMProteinTensor): + if getattr(protein_tensor, track.name, None) is None: + setattr( + protein_tensor, + track.name, + getattr(default_protein_tensor, track.name, None), + ) + + # Preprocessing + sequence_length: int = -1 + for track in [ + "sequence", + "structure", + "secondary_structure", + "sasa", + "function", + "residue_annotations", + ]: + input_tensor: torch.Tensor | None = getattr(protein_tensor, track, None) + if input_tensor is not None: + # Add batch dimension if necessary + if track in ["sequence", "structure", "secondary_structure", "sasa"]: + if len(input_tensor.size()) == 1: + input_tensor = input_tensor.unsqueeze(0) # (L,) -> (1, L) + elif track in ["function", "residue_annotations"]: + if len(input_tensor.size()) == 2: + input_tensor = input_tensor.unsqueeze(0) # (L, O) -> (1, L, O) + + # Check length consistency + if sequence_length == -1: + sequence_length = input_tensor.size(1) + else: + if input_tensor.size(1) != sequence_length: + raise ValueError( + f"Length mismatch for track {track}. Expected {sequence_length}, got {input_tensor.size(1)}" + ) + + # Move input tensor to model device + input_tensor = input_tensor.to(device) + setattr(protein_tensor, track, input_tensor) + + if protein_tensor.coordinates is not None: + coordinates = protein_tensor.coordinates + if len(coordinates.size()) == 3: + coordinates = coordinates.unsqueeze(0) + protein_tensor.coordinates = coordinates.to(device) + sequence_length = coordinates.size(1) + + if sequence_length == -1: + raise ValueError("No input data provided") + + # Forward pass + forward_output = self._forward( + protein_tensor, + ForwardConfig( + ReturnLogitsConfig( + sequence=True, + structure=True, + secondary_structure=True, + sasa=True, + function=True, + residue_annotations=True, + ), + return_embeddings=True, + ), + ) + + # Sampling + tokens_dir = {} + track_sampling_metadata_dir: dict[str, dict | None] = {} + for track in ["sequence", "structure", "secondary_structure", "sasa"]: + config = getattr(sampling_config, track) + if config is None: + tokens_dir[track] = maybe_clone(getattr(input, track)) + continue + sampling_metadata = self._sample_track( + logits=getattr(forward_output.logits, track)[0, ...], + tokens=getattr(protein_tensor, track)[0, ...], + sampling_track_config=config, + mask_idx=getattr(self.tokenizers, track).mask_token_id, + ) + tokens_dir[track] = sampling_metadata.pop("sampled_tokens") # (L,) + track_sampling_metadata_dir[track] = sampling_metadata + + # Sample function and residue annotations separately + config = getattr(sampling_config, "function") + if config is None: + tokens_dir["function"] = maybe_clone(getattr(input, "function")) + tokens_dir["residue_annotations"] = maybe_clone( + getattr(input, "residue_annotations") + ) + else: + sampling_metadata = self._sample_function_track( + tokens=getattr(protein_tensor, "function")[0, ...], + logits=getattr(forward_output.logits, "function")[0, ...], + sampling_track_config=config, + ) + tokens_dir["function"] = sampling_metadata.pop("sampled_tokens") # (L, D) + track_sampling_metadata_dir["function"] = sampling_metadata + + sampled_tokens, _ = sample_residue_annotation_logits( + logits=forward_output.residue_annotation_logits[0, ...] # type: ignore + ) + tokens_dir["residue_annotations"] = sampled_tokens # (L, MAX_R) + + # Format output + forward_and_sample_output_dir = {} + forward_and_sample_output_dir["protein_tensor"] = ESMProteinTensor(**tokens_dir) + for property in [ + "entropy", + "prob", + "logprob", + "top_prob", + "topk_logprob", + "topk_tokens", + ]: + is_all_none = True + forward_track_data_dir = {} + for track in track_sampling_metadata_dir.keys(): + values = track_sampling_metadata_dir[track] + if values is not None and values.get(property, None) is not None: + forward_track_data_dir[track] = values.get(property, None) + is_all_none = False + if not is_all_none: + forward_and_sample_output_dir[property] = ForwardTrackData( + **forward_track_data_dir + ) + else: + forward_and_sample_output_dir[property] = None + + perres_embed = ( + forward_output.embeddings[0] # type: ignore + if sampling_configuration.return_per_residue_embeddings + else None + ) + mean_embedding = ( + forward_output.embeddings[0].mean(1) # type: ignore + if sampling_configuration.return_per_residue_embeddings + else None + ) + + return ForwardAndSampleOutput( + per_residue_embedding=perres_embed, + mean_embedding=mean_embedding, + **forward_and_sample_output_dir, + ) + + def _sample_track( + self, + logits: torch.Tensor, + tokens: torch.Tensor, + sampling_track_config: SamplingTrackConfig, + mask_idx: int, + ) -> dict[str, torch.Tensor]: + # Sample in all positions + temperature = sampling_track_config.temperature + sampled_tokens = sample_logits( + logits, temperature=temperature, top_p=sampling_track_config.top_p + ) + log_probs = logits.log_softmax(-1) + + # Do not sample at BOS and EOS tokens + sampling_mask = torch.ones_like(tokens, dtype=torch.bool) # (L, ) + sampling_mask[0] = False + sampling_mask[-1] = False + + # Do not sample at special token positions but allow sampling at mask token + special_minus_mask = list(set(sampling_track_config.invalid_ids) - {mask_idx}) + if len(special_minus_mask) > 0: + special_tokens = torch.tensor(special_minus_mask, device=tokens.device) + assert special_tokens.numel() > 0 + sampling_mask = sampling_mask & ( + tokens[..., None] != special_tokens[None, :] + ).all(-1) + + # Keep only samples from masked positions (if specified) + if sampling_track_config.only_sample_masked_tokens: + masked_tokens = tokens == mask_idx + sampling_mask = sampling_mask & masked_tokens + sampled_tokens = torch.where(sampling_mask, sampled_tokens, tokens) + + return self._compute_track_metadata( + sampled_tokens, + log_probs, + sampling_mask, + top_k=sampling_track_config.topk_logprobs, + ) + + def _sample_function_track( + self, + tokens: torch.Tensor, + logits: torch.Tensor, + sampling_track_config: SamplingTrackConfig, + ) -> dict[str, torch.Tensor]: + # Do not sample at BOS and EOS tokens + sampling_mask = torch.ones_like(tokens, dtype=torch.bool) + sampling_mask[0] = False + sampling_mask[-1] = False + + sampled_tokens, probs = sample_function_logits( + logits, + self.tokenizers.function, + top_p=sampling_track_config.top_p, + temperature=sampling_track_config.temperature, + ) + + if sampling_track_config.only_sample_masked_tokens: + raise ValueError( + "Sampling only masked tokens is undefined for function tokens." + ) + + sampled_tokens = torch.where(sampling_mask, sampled_tokens, tokens) # (L, D) + + return self._compute_track_metadata( + sampled_tokens, + probs, + sampling_mask, + top_k=sampling_track_config.topk_logprobs, + ) + + @staticmethod + def _compute_track_metadata( + sampled_tokens: torch.Tensor, + log_probs: torch.Tensor, + sampling_mask: torch.Tensor, + top_k: int, + ) -> dict: + probs = torch.exp(log_probs) # (B, L) + entropy = torch.distributions.Categorical(probs=probs).entropy() # (B, L) + + # Only compute probabilities for sampled tokens + sampled_logprob = torch.zeros_like( + sampled_tokens, dtype=torch.float32 + ) # (B, L) + sampled_tokens_valid = sampled_tokens[sampling_mask] + sampled_log_probs_valid = log_probs[sampling_mask, sampled_tokens_valid] + sampled_logprob[sampling_mask] = sampled_log_probs_valid + + # Calculate extra metadata + sampled_prob = torch.exp(sampled_logprob) + top_prob = torch.max(probs, dim=-1).values + topk_logprobs, topk_tokens = torch.topk(log_probs, top_k, dim=-1) + topk_logprobs = None if top_k == 0 else topk_logprobs + topk_tokens = None if top_k == 0 else topk_tokens + + return { + "entropy": entropy, + "sampled_tokens": sampled_tokens, + "prob": sampled_prob, + "logprob": sampled_logprob, + "top_prob": top_prob, + "topk_logprob": topk_logprobs, + "topk_tokens": topk_tokens, + } diff --git a/esm/models/function_decoder.py b/esm/models/function_decoder.py new file mode 100644 index 0000000..7e6d4f6 --- /dev/null +++ b/esm/models/function_decoder.py @@ -0,0 +1,339 @@ +"""Function Token Decoder.""" + +from collections import defaultdict +from dataclasses import dataclass, field + +import numpy as np +import pandas as pd +import torch +import torch.nn as nn +import torch.nn.functional as F + +from esm.layers.regression_head import RegressionHead +from esm.layers.transformer_stack import TransformerStack +from esm.tokenization.function_tokenizer import ( + InterProQuantizedTokenizer, +) +from esm.utils.constants import esm3 as C +from esm.utils.misc import merge_ranges +from esm.utils.types import FunctionAnnotation + + +@dataclass(frozen=True) +class FunctionTokenDecoderConfig: + """Configures function token decoder.""" + + # Embedding dimension of decoder. + d_model: int = 1024 + # Number of attention heads of decoder. + n_heads: int = 8 + # Number of layers of decoder. + n_layers: int = 3 + # Number of integer values that function tokens may assume. + function_token_vocab_size: int = 260 + # Number of function tokens at each position. + function_token_depth: int = 8 + # Number of InterPro labels that can be decoded. + num_interpro_classes: int = 29026 + # Number of function keywords that can be decoded. + keyword_vocabulary_size: int = 58641 + # List of supported InterPro ids. + interpro_entry_list: str = field( + default_factory=lambda: str(C.data_root() / C.INTERPRO_ENTRY) + ) + # Path to keywords vocabulary. + keyword_vocabulary_path: str = field( + default_factory=lambda: str(C.data_root() / C.KEYWORDS_VOCABULARY) + ) + # Whether to unpack LSH bits into single-bit tokens. + unpack_lsh_bits: bool = True + # The number of special tokens in the function tokenizer vocabulary which come + # before the LSH tokens. + num_special_tokens: int = 4 + # The number of bits per LSH token in the function tokenizer. + bits_per_token: int = 8 + + +class FunctionTokenDecoder(nn.Module): + def __init__(self, config: FunctionTokenDecoderConfig | None = None): + """Constructs function token decoder.""" + super().__init__() + if config is None: + config = FunctionTokenDecoderConfig() + self.config = config + + # Get the supported set of InterPro ids. + df = pd.read_csv(config.interpro_entry_list, sep="\t") + self.interpro_ids = sorted(df.ENTRY_AC) + self.interpro2index = { + interpro_id: i for i, interpro_id in enumerate(self.interpro_ids) + } + assert len(self.interpro_ids) == config.num_interpro_classes + + with open(config.keyword_vocabulary_path, "r") as f: + self.keywords_vocabulary: list[str] = list(f.read().strip().split("\n")) + assert len(self.keywords_vocabulary) == config.keyword_vocabulary_size + + if config.unpack_lsh_bits: + vocab_size = 2 * config.function_token_depth * config.bits_per_token + else: + # Function-token id's re-use the same token ids at each position along the depth + # dimension, despite distinct meanings. The decoder should take this into + # account so create distinct embeddings for tokens at each position. + vocab_size = ( + self.config.function_token_depth * self.config.function_token_vocab_size + ) + + self.embedding = nn.Embedding( + # Function-token id's re-use the same token ids at each position along the + # depth dimension, despite distinct meanings. The decoder should take this + # into account so create distinct embeddings for tokens at each position. + num_embeddings=(vocab_size), + embedding_dim=config.d_model, + ) + self.decoder = TransformerStack( + d_model=config.d_model, + n_heads=config.n_heads, + v_heads=None, + n_layers=config.n_layers, + n_layers_geom=0, + scale_residue=False, + bias=True, + qk_layernorm=False, + ffn_type="gelu", + expansion_ratio=4, + ) + self.heads = nn.ModuleDict( + { + # Binary classification head predicting which keywords are present. + "keyword_logits": RegressionHead( + d_model=config.d_model, + output_dim=config.keyword_vocabulary_size, + hidden_dim=4 * config.d_model, + ), + # Regresses the TF-IDF value of each present keyword. + "keyword_tfidf": RegressionHead( + d_model=config.d_model, + output_dim=config.keyword_vocabulary_size, + hidden_dim=4 * config.d_model, + ), + # Predicts which InterPro annotations are present. + "interpro_logits": RegressionHead( + d_model=config.d_model, + output_dim=config.num_interpro_classes, + hidden_dim=4 * config.d_model, + ), + } + ) + + def forward(self, token_ids: torch.Tensor) -> dict[str, torch.Tensor]: + """Forward pass through function token decoder. + + Args: + token_ids: [batch_size, function_token_depth] batch of function tokens + ids to decode. + Returns: + interpro_logits: binary classification logits tensor of shape + [batch_size, num_interpro_classes] + """ + assert token_ids.ndim == 2 + assert token_ids.shape[1] == self.config.function_token_depth + batch_size, depth = token_ids.shape + + if self.config.unpack_lsh_bits: + # Shift values into [0, 2^bits/token) + lsh_bits = token_ids - self.config.num_special_tokens + # extract each bit. (hob stands for highest-order bit) + bits = torch.concat( + [ + torch.bitwise_and(lsh_bits, 1 << hob).gt(0).to(torch.int32) + for hob in range(self.config.bits_per_token) + ], + dim=1, + ) + assert bits.shape == (batch_size, depth * self.config.bits_per_token) + + # Shift each bit into individual vocabulary ranges, so they get distinct + # embeddings. + vocab_offsets = 2 * torch.arange( + depth * self.config.bits_per_token, device=token_ids.device + ) + inputs = vocab_offsets[None, :] + bits + + # zero-out special tokens, i.e. non LSH tokens. + where_special = token_ids < self.config.num_special_tokens + inputs = torch.where(where_special.any(dim=1, keepdim=True), 0, inputs) + else: + # Apply depth-position offset to use distinct vocabs. See __init__ for + # explaination. + vocab_offsets = self.config.function_token_vocab_size * torch.arange( + self.config.function_token_depth, + device=token_ids.device, + ) + inputs = token_ids + vocab_offsets[None, :] + + embed = self.embedding(inputs) + encoding, _ = self.decoder(embed) + pooled = torch.mean(encoding, dim=1) + + return {name: head(pooled) for name, head in self.heads.items()} + + @property + def device(self) -> torch.device: + return next(self.parameters()).device + + def decode( + self, + function_token_ids: torch.Tensor, + tokenizer: InterProQuantizedTokenizer, + decode_annotations: bool = True, + annotation_threshold: float = 0.1, + decode_keywords=True, + keywords_threshold: float = 0.5, + annotation_min_length: int | None = 5, + annotation_gap_merge_max: int | None = 3, + ): + """Decodes function tokens into predicted annotations and keywords. + + Args: + function_token_ids: [length, depth] function token ids. NOTE: + without / prefix + tokenizer: function tokenizer. + decode_annotations: whether to decode InterPro annotations. + annotation_threshold: threshold for emitting a function annotation. + decode_keywords: whether to decode function keywords. + keywords_threshold: threshold for emitting a keyword. + annotation_min_length: optional minimum length of predicted annotations for + size filtering. + annotation_gap_merge_max: optional merge adjacent annotation of the same type + Returns: + Decoder outputs: + - "interpro_logits": [length, num_interpro] predicted interpro logits. + - "interpro_preds": [length, num_interpro] predicted intepro labels. + - "interpro_annotations": list[FunctionAnnotation] predicted InterPro + annotations + - "keyword_logits": [length, keyword_vocabulary] binary prediciton + logits for keywrods. + - "function_keywords": list[FunctionAnnotation] predicted function keyword + ranges. + """ + assert function_token_ids.ndim == 2 + assert function_token_ids.shape[1] == tokenizer.depth + assert self.config.function_token_depth == tokenizer.depth + + outputs = {} + + outputs = self(function_token_ids.to(self.device)) + + # Only decode in positions that have function tokens. + where_decode = torch.all( + (function_token_ids != tokenizer.vocab_to_index[""]) + & (function_token_ids != tokenizer.vocab_to_index[""]) + & (function_token_ids != tokenizer.vocab_to_index[""]), + dim=1, + ) + + # Decode InterPro annotations ranges. + interpro_preds = F.sigmoid(outputs["interpro_logits"]) + interpro_preds = interpro_preds >= annotation_threshold + interpro_preds[~where_decode, :] = False + outputs["interpro_preds"] = interpro_preds + if decode_annotations: + annotations: list[FunctionAnnotation] = [] + preds: np.ndarray = interpro_preds.detach().cpu().numpy() + for position_index, class_index in zip(*preds.nonzero()): + interpro_id = self.interpro_ids[class_index] + annotation = FunctionAnnotation( + label=interpro_id, + start=position_index + 1, # zero-index -> one-index inclusive + end=position_index + 1, # zero-index -> one-index inclusive + ) + annotations.append(annotation) + + annotations = _merge_annotations( + annotations, + merge_gap_max=annotation_gap_merge_max, + ) + + # Drop very small annotations. + if annotation_min_length is not None: + annotations = [ + annotation + for annotation in annotations + if annotation.end - annotation.start + 1 >= annotation_min_length + ] + + outputs["interpro_annotations"] = annotations + + # Decode function keyword ranges. + keyword_logits = outputs["keyword_logits"] + keyword_logits[~where_decode, :] = -torch.inf + if decode_keywords: + keyword_preds = F.sigmoid(keyword_logits) >= keywords_threshold + outputs["function_keywords"] = self._preds_to_keywords( + keyword_preds.detach().cpu().numpy() + ) + + return outputs + + def _preds_to_keywords(self, keyword_preds: np.ndarray) -> list[FunctionAnnotation]: + """Converts output log-TFDF to predicted keywords over the sequence. + + Args: + keyword_precs: [length, keyword_vocab] positional predictions of + function keywords from the keyword prediction head. + Returns: + Non-overlapping keyword annotated ranges along the sequence. Note that indices + will index into the *sequence*, not the function token array which has a + prefix. + """ + assert keyword_preds.ndim == 2 + assert keyword_preds.shape[1] == self.config.keyword_vocabulary_size + + keyword_positions: dict[str, list[range]] = defaultdict(list) + for position, keyword_id in zip(*np.nonzero(keyword_preds)): + keyword = self.keywords_vocabulary[keyword_id] + keyword_positions[keyword].append(range(position, position + 1)) + + annotations: list[FunctionAnnotation] = [] + for keyword, ranges in keyword_positions.items(): + for range_ in merge_ranges(ranges): + annotation = FunctionAnnotation( + label=keyword, + start=range_.start + 1, # zero-index -> one-index + end=range_.stop + 1 - 1, # zero-index excl -> one-index incl + ) + annotations.append(annotation) + + return annotations + + +def _merge_annotations( + annotations: list[FunctionAnnotation], + merge_gap_max: int | None = None, +) -> list[FunctionAnnotation]: + """Merges annotations into non-overlapping segments. + + Args: + annotations: annotations to merge. + merge_gap_max: optionally merge neighboring ranges that are separated by a gap + no larger than this size. + Returns: + non-overlapping annotations with gaps merged. + """ + grouped: dict[str, list[range]] = defaultdict(list) + for a in annotations: + # Convert one-indexed inclusive-inclusive, to range() + grouped[a.label].append(range(a.start, a.end + 1)) + + merged = [] + for label, ranges in grouped.items(): + merged_ranges = merge_ranges(ranges, merge_gap_max=merge_gap_max) + for range_ in merged_ranges: + annotation = FunctionAnnotation( + label=label, + start=range_.start + 1, # zero-index -> one-index + end=range_.stop - 1, # zero-index excl -> one-index incl + ) + merged.append(annotation) + return merged diff --git a/esm/models/vqvae.py b/esm/models/vqvae.py new file mode 100644 index 0000000..1e4afa9 --- /dev/null +++ b/esm/models/vqvae.py @@ -0,0 +1,450 @@ +import torch +import torch.nn as nn + +from esm.layers.blocks import UnifiedTransformerBlock +from esm.layers.codebook import EMACodebook +from esm.layers.structure_proj import Dim6RotStructureHead +from esm.layers.transformer_stack import TransformerStack +from esm.utils.constants import esm3 as C +from esm.utils.misc import knn_graph +from esm.utils.structure.affine3d import ( + Affine3D, + build_affine3d_from_coordinates, +) +from esm.utils.structure.predicted_aligned_error import ( + compute_predicted_aligned_error, + compute_tm, +) + + +class RelativePositionEmbedding(nn.Module): + """ + Embedding layer for relative position embeddings. `bins` is the number of positions relative + to the query position that are considered before clipping. For instance, if `bins=10`, then + the relative position embedding will have 21 positions, [-10, 10]. + """ + + def __init__(self, bins, embedding_dim, init_std=0.02): + super().__init__() + self.bins = bins + + self.embedding = torch.nn.Embedding(2 * bins + 2, embedding_dim) + self.embedding.weight.data.normal_(0, init_std) + + def forward(self, query_residue_index, key_residue_index): + """ + Input: + query_residue_index: (B, ) tensor of source indices (dytpe=torch.long) + key_residue_index: (B, L) tensor of target indices (dytpe=torch.long) + Output: + embeddings: B x L x embedding_dim tensor of embeddings + """ + + assert query_residue_index.dtype == torch.long + assert key_residue_index.dtype == torch.long + assert query_residue_index.ndim == 1 + assert key_residue_index.ndim == 2 + + diff = key_residue_index - query_residue_index.unsqueeze(1) + diff = diff.clamp(-self.bins, self.bins) + diff = diff + self.bins + 1 # add 1 to adjust for padding index + output = self.embedding(diff) + return output + + +class PairwisePredictionHead(nn.Module): + def __init__( + self, + input_dim: int, + downproject_dim: int, + hidden_dim: int, + n_bins: int, + bias: bool = True, + pairwise_state_dim: int = 0, + ): + super().__init__() + self.downproject = nn.Linear(input_dim, downproject_dim, bias=bias) + self.linear1 = nn.Linear( + downproject_dim + pairwise_state_dim, hidden_dim, bias=bias + ) + self.activation_fn = nn.GELU() + self.norm = nn.LayerNorm(hidden_dim) + self.linear2 = nn.Linear(hidden_dim, n_bins, bias=bias) + + def forward(self, x, pairwise: torch.Tensor | None = None): + """ + Args: + x: [B x L x D] + + Output: + [B x L x L x K] + """ + x = self.downproject(x) + # Let x_i be a vector of size (B, D). + # Input is {x_1, ..., x_L} of size (B, L, D) + # Output is 2D where x_ij = cat([x_i * x_j, x_i - x_j]) + q, k = x.chunk(2, dim=-1) + + prod = q[:, None, :, :] * k[:, :, None, :] + diff = q[:, None, :, :] - k[:, :, None, :] + x_2d = [ + prod, + diff, + ] + if pairwise is not None: + x_2d.append(pairwise) + x = torch.cat(x_2d, dim=-1) + x = self.linear1(x) + x = self.activation_fn(x) + x = self.norm(x) + x = self.linear2(x) + return x + + +class RegressionHead(nn.Module): + def __init__(self, embed_dim: int, output_dim: int): + super().__init__() + self.dense = nn.Linear(embed_dim, embed_dim) + self.activation_fn = nn.GELU() + self.norm = nn.LayerNorm(embed_dim) + self.output = nn.Linear(embed_dim, output_dim) + + def forward(self, features): + x = self.dense(features) + x = self.activation_fn(x) + x = self.norm(x) + x = self.output(x) + return x + + +class CategoricalMixture: + def __init__(self, param, bins=50, start=0, end=1): + # All tensors are of shape ..., bins. + self.logits = param + bins = torch.linspace( + start, end, bins + 1, device=self.logits.device, dtype=torch.float32 + ) + self.v_bins = (bins[:-1] + bins[1:]) / 2 + + def log_prob(self, true): + # Shapes are: + # self.probs: ... x bins + # true : ... (floating point # for target) + true_index = ( + (true.unsqueeze(-1) - self.v_bins[[None] * true.ndim]).abs().argmin(-1) + ) + nll = self.logits.log_softmax(-1) + return torch.take_along_dim(nll, true_index.unsqueeze(-1), dim=-1).squeeze(-1) + + def mean(self): + return ( + self.logits.to(self.v_bins.dtype).softmax(-1) @ self.v_bins.unsqueeze(1) + ).squeeze(-1) + + def median(self): + return self.v_bins[self.logits.max(-1).indices] + + +class GeometricEncoderStack(TransformerStack): + def __init__(self, d_model, n_heads, v_heads, n_layers): + super().__init__(d_model, n_heads, v_heads, 0) + self.blocks = nn.ModuleList( + [ + UnifiedTransformerBlock( + d_model, + n_heads, + v_heads=v_heads, + use_geom_attn=True, + use_plain_attn=False, + expansion_ratio=4, + bias=True, + ) + for i in range(n_layers) + ] + ) + self.norm = nn.Identity() + + +def batched_gather(data, inds, dim=0, no_batch_dims=0): + ranges = [] + for i, s in enumerate(data.shape[:no_batch_dims]): + r = torch.arange(s) + r = r.view(*(*((1,) * i), -1, *((1,) * (len(inds.shape) - i - 1)))) + ranges.append(r) + + remaining_dims = [slice(None) for _ in range(len(data.shape) - no_batch_dims)] + remaining_dims[dim - no_batch_dims if dim >= 0 else dim] = inds + ranges.extend(remaining_dims) + return data[ranges] + + +def node_gather(s: torch.Tensor, edges: torch.Tensor) -> torch.Tensor: + return batched_gather(s.unsqueeze(-3), edges, -2, no_batch_dims=len(s.shape) - 1) + + +class StructureTokenEncoder(nn.Module): + def __init__(self, d_model, n_heads, v_heads, n_layers, d_out, n_codes): + super().__init__() + # We only support fully-geometric structure token encoders for now... + # setting n_layers_geom to something that's not n_layers won't work because + # sequence ID isn't supported fully in this repo for plain-old transformers + self.transformer = GeometricEncoderStack(d_model, n_heads, v_heads, n_layers) + self.pre_vq_proj = nn.Linear(d_model, d_out) + self.codebook = EMACodebook(n_codes, d_out) + self.relative_positional_embedding = RelativePositionEmbedding( + 32, d_model, init_std=0.02 + ) + self.knn = 16 + + def encode_local_structure( + self, + coords: torch.Tensor, + affine: Affine3D, + attention_mask: torch.Tensor, + sequence_id: torch.Tensor | None, + affine_mask: torch.Tensor, + residue_index: torch.Tensor | None = None, + ): + """This function allows for a multi-layered encoder to encode tokens with a local receptive fields. The implementation is as follows: + + 1. Starting with (B, L) frames, we find the KNN in structure space. This now gives us (B, L, K) where the last dimension is the local + neighborhood of all (B, L) residues. + 2. We reshape these frames to (B*L, K) so now we have a large batch of a bunch of local neighborhoods. + 3. Pass the (B*L, K) local neighborhoods through a stack of geometric reasoning blocks, effectively getting all to all communication between + all frames in the local neighborhood. + 4. This gives (B*L, K, d_model) embeddings, from which we need to get a single embedding per local neighborhood. We do this by simply + taking the embedding corresponding to the query node. This gives us (B*L, d_model) embeddings. + 5. Reshape back to (B, L, d_model) embeddings + """ + assert coords.size(-1) == 3 and coords.size(-2) == 3, "need N, CA, C" + with torch.no_grad(): + knn_edges, _ = self.find_knn_edges( + coords, + ~attention_mask, + coord_mask=affine_mask, + sequence_id=sequence_id, + knn=self.knn, + ) + B, L, E = knn_edges.shape + + affine_tensor = affine.tensor # for easier manipulation + T_D = affine_tensor.size(-1) + knn_affine_tensor = node_gather(affine_tensor, knn_edges) + knn_affine_tensor = knn_affine_tensor.view(-1, E, T_D).contiguous() + affine = Affine3D.from_tensor(knn_affine_tensor) + knn_sequence_id = ( + node_gather(sequence_id.unsqueeze(-1), knn_edges).view(-1, E) + if sequence_id is not None + else torch.zeros(L, E, dtype=torch.int64, device=coords.device) + ) + knn_affine_mask = node_gather(affine_mask.unsqueeze(-1), knn_edges).view( + -1, E + ) + knn_chain_id = torch.zeros(L, E, dtype=torch.int64, device=coords.device) + + if residue_index is None: + res_idxs = knn_edges.view(-1, E) + else: + res_idxs = node_gather(residue_index.unsqueeze(-1), knn_edges).view( + -1, E + ) + + z = self.relative_positional_embedding(res_idxs[:, 0], res_idxs) + + z, _ = self.transformer.forward( + x=z, + sequence_id=knn_sequence_id, + affine=affine, + affine_mask=knn_affine_mask, + chain_id=knn_chain_id, + ) + + # Unflatten the output and take the query node embedding, which will always be the first one because + # a node has distance 0 with itself and the KNN are sorted. + z = z.view(B, L, E, -1) + z = z[:, :, 0, :] + + return z + + @staticmethod + def find_knn_edges( + coords, + padding_mask, + coord_mask, + sequence_id: torch.Tensor | None = None, + knn: int | None = None, + ) -> tuple: + assert knn is not None, "Must specify a non-null knn to find_knn_edges" + # Coords are N, CA, C + coords = coords.clone() + coords[~coord_mask] = 0 + + if sequence_id is None: + sequence_id = torch.zeros( + (coords.shape[0], coords.shape[1]), device=coords.device + ).long() + + with torch.no_grad(), torch.cuda.amp.autocast(enabled=False): # type: ignore + ca = coords[..., 1, :] + edges, edge_mask = knn_graph( + ca, + coord_mask, + padding_mask, + sequence_id, + no_knn=knn, + ) + + return edges, edge_mask + + def encode( + self, + coords: torch.Tensor, + attention_mask: torch.Tensor | None = None, + sequence_id: torch.Tensor | None = None, + residue_index: torch.Tensor | None = None, + ): + coords = coords[..., :3, :] + affine, affine_mask = build_affine3d_from_coordinates(coords=coords) + + if attention_mask is None: + attention_mask = torch.ones_like(affine_mask, dtype=torch.bool) + attention_mask = attention_mask.bool() + + if sequence_id is None: + sequence_id = torch.zeros_like(affine_mask, dtype=torch.int64) + + z = self.encode_local_structure( + coords=coords, + affine=affine, + attention_mask=attention_mask, + sequence_id=sequence_id, + affine_mask=affine_mask, + residue_index=residue_index, + ) + + z = z.masked_fill(~affine_mask.unsqueeze(2), 0) + z = self.pre_vq_proj(z) + + z_q, min_encoding_indices, _ = self.codebook(z) + + return z_q, min_encoding_indices + + +class StructureTokenDecoder(nn.Module): + def __init__( + self, + d_model, + n_heads, + n_layers, + ): + super().__init__() + self.decoder_channels = d_model + + self.vqvae_codebook_size = C.VQVAE_CODEBOOK_SIZE + self.special_tokens = C.VQVAE_SPECIAL_TOKENS + self.max_pae_bin = C.VQVAE_MAX_PAE_BIN + + self.embed = nn.Embedding( + self.vqvae_codebook_size + len(self.special_tokens), d_model + ) + self.decoder_stack = TransformerStack( + d_model, n_heads, 1, n_layers, scale_residue=False, n_layers_geom=0 + ) + + self.affine_output_projection = Dim6RotStructureHead( + self.decoder_channels, 10, predict_torsion_angles=False + ) + + direction_loss_bins = C.VQVAE_DIRECTION_LOSS_BINS + pae_bins = C.VQVAE_PAE_BINS + self.pairwise_bins = [ + 64, # distogram + direction_loss_bins * 6, # direction bins + pae_bins, # predicted aligned error + ] + self.pairwise_classification_head = PairwisePredictionHead( + self.decoder_channels, + downproject_dim=128, + hidden_dim=128, + n_bins=sum(self.pairwise_bins), + bias=False, + ) + + plddt_bins = C.VQVAE_PLDDT_BINS + self.plddt_head = RegressionHead( + embed_dim=self.decoder_channels, output_dim=plddt_bins + ) + + def decode( + self, + structure_tokens: torch.Tensor, + attention_mask: torch.Tensor | None = None, + sequence_id: torch.Tensor | None = None, + ): + if attention_mask is None: + attention_mask = torch.ones_like(structure_tokens, dtype=torch.bool) + + attention_mask = attention_mask.bool() + if sequence_id is None: + sequence_id = torch.zeros_like(structure_tokens, dtype=torch.int64) + # not supported for now + chain_id = torch.zeros_like(structure_tokens, dtype=torch.int64) + + # check that BOS and EOS are set correctly + assert ( + structure_tokens[:, 0].eq(self.special_tokens["BOS"]).all() + ), "First token in structure_tokens must be BOS token" + assert ( + structure_tokens[ + torch.arange(structure_tokens.shape[0]), attention_mask.sum(1) - 1 + ] + .eq(self.special_tokens["EOS"]) + .all() + ), "Last token in structure_tokens must be EOS token" + assert ( + (structure_tokens < 0).sum() == 0 + ), "All structure tokens set to -1 should be replaced with BOS, EOS, PAD, or MASK tokens by now, but that isn't the case!" + + x = self.embed(structure_tokens) + # !!! NOTE: Attention mask is actually unused here so watch out + x, _ = self.decoder_stack.forward( + x, affine=None, affine_mask=None, sequence_id=sequence_id, chain_id=chain_id + ) + + tensor7_affine, bb_pred = self.affine_output_projection( + x, affine=None, affine_mask=torch.zeros_like(attention_mask) + ) + + pae, ptm = None, None + pairwise_logits = self.pairwise_classification_head(x) + _, _, pae_logits = [ + (o if o.numel() > 0 else None) + for o in pairwise_logits.split(self.pairwise_bins, dim=-1) + ] + + special_tokens_mask = structure_tokens >= min(self.special_tokens.values()) + pae = compute_predicted_aligned_error( + pae_logits, # type: ignore + aa_mask=~special_tokens_mask, + sequence_id=sequence_id, + max_bin=self.max_pae_bin, + ) + # This might be broken for chainbreak tokens? We might align to the chainbreak + ptm = compute_tm( + pae_logits, # type: ignore + aa_mask=~special_tokens_mask, + max_bin=self.max_pae_bin, + ) + + plddt_logits = self.plddt_head(x) + plddt_value = CategoricalMixture( + plddt_logits, bins=plddt_logits.shape[-1] + ).mean() + + return dict( + tensor7_affine=tensor7_affine, + bb_pred=bb_pred, + plddt=plddt_value, + ptm=ptm, + predicted_aligned_error=pae, + ) diff --git a/esm/pretrained.py b/esm/pretrained.py new file mode 100644 index 0000000..141ba2f --- /dev/null +++ b/esm/pretrained.py @@ -0,0 +1,95 @@ +from typing import Callable + +import torch +import torch.nn as nn + +from esm.models.esm3 import ESM3 +from esm.models.function_decoder import FunctionTokenDecoder +from esm.models.vqvae import ( + StructureTokenDecoder, + StructureTokenEncoder, +) +from esm.utils.constants.esm3 import data_root +from esm.utils.constants.models import ( + ESM3_FUNCTION_DECODER_V0, + ESM3_OPEN_SMALL, + ESM3_STRUCTURE_DECODER_V0, + ESM3_STRUCTURE_ENCODER_V0, +) + +ModelBuilder = Callable[[torch.device | str], nn.Module] + + +def ESM3_sm_open_v0(device: torch.device | str = "cpu"): + model = ( + ESM3( + d_model=1536, + n_heads=24, + v_heads=256, + n_layers=48, + structure_encoder_name=ESM3_STRUCTURE_ENCODER_V0, + structure_decoder_name=ESM3_STRUCTURE_DECODER_V0, + function_decoder_name=ESM3_FUNCTION_DECODER_V0, + ) + .to(device) + .eval() + ) + state_dict = torch.load( + data_root() / "data/weights/esm3_sm_open_v1.pth", map_location=device + ) + model.load_state_dict(state_dict) + return model + + +def ESM3_structure_encoder_v0(device: torch.device | str = "cpu"): + model = ( + StructureTokenEncoder( + d_model=1024, n_heads=1, v_heads=128, n_layers=2, d_out=128, n_codes=4096 + ) + .to(device) + .eval() + ) + state_dict = torch.load( + data_root() / "data/weights/esm3_structure_encoder_v0.pth", map_location=device + ) + model.load_state_dict(state_dict) + return model + + +def ESM3_structure_decoder_v0(device: torch.device | str = "cpu"): + model = ( + StructureTokenDecoder(d_model=1280, n_heads=20, n_layers=30).to(device).eval() + ) + state_dict = torch.load( + data_root() / "data/weights/esm3_structure_decoder_v0.pth", map_location=device + ) + model.load_state_dict(state_dict) + return model + + +def ESM3_function_decoder_v0(device: torch.device | str = "cpu"): + model = FunctionTokenDecoder().to(device).eval() + state_dict = torch.load( + data_root() / "data/weights/esm3_function_decoder_v0.pth", map_location=device + ) + model.load_state_dict(state_dict) + return model + + +LOCAL_MODEL_REGISTRY: dict[str, ModelBuilder] = { + ESM3_OPEN_SMALL: ESM3_sm_open_v0, + ESM3_STRUCTURE_ENCODER_V0: ESM3_structure_encoder_v0, + ESM3_STRUCTURE_DECODER_V0: ESM3_structure_decoder_v0, + ESM3_FUNCTION_DECODER_V0: ESM3_function_decoder_v0, +} + + +def load_local_model(model_name: str, device: torch.device | str = "cpu") -> nn.Module: + if model_name not in LOCAL_MODEL_REGISTRY: + raise ValueError(f"Model {model_name} not found in local model registry.") + return LOCAL_MODEL_REGISTRY[model_name](device) + + +# Register custom versions of ESM3 for use with the local inference API +def register_local_model(model_name: str, model_builder: ModelBuilder) -> None: + LOCAL_MODEL_REGISTRY[model_name] = model_builder diff --git a/esm/sdk/api.py b/esm/sdk/api.py new file mode 100644 index 0000000..98ccea1 --- /dev/null +++ b/esm/sdk/api.py @@ -0,0 +1,327 @@ +from __future__ import annotations + +from abc import ABC +from typing import Sequence, TypeVar + +import attr +import torch +from attr import define + +from esm.tokenization import ( + TokenizerCollectionProtocol, + get_model_tokenizers, +) +from esm.utils import encoding +from esm.utils.constants.models import ESM3_OPEN_SMALL +from esm.utils.structure.protein_chain import ProteinChain +from esm.utils.types import ( + FunctionAnnotation, + PathLike, + PathOrBuffer, +) + + +## Basic Types +@define +class ESMProtein: + # Tracks + sequence: str | None = None + secondary_structure: str | None = None + sasa: list[float | str | None] | None = None + function_annotations: list[FunctionAnnotation] | None = None + coordinates: torch.Tensor | None = None + # Metrics + plddt: torch.Tensor | None = None + ptm: torch.Tensor | None = None + + def __len__(self): + if self.sequence is not None: + return len(self.sequence) + elif self.secondary_structure is not None: + return len(self.secondary_structure) + elif self.sasa is not None: + return len(self.sasa) + elif self.coordinates is not None: + return self.coordinates.size(0) + else: + raise ValueError("No track to determine length from.") + + @classmethod + def from_pdb( + cls, + path: PathOrBuffer, + chain_id: str = "detect", + id: str | None = None, + is_predicted: bool = False, + ) -> ESMProtein: + protein_chain = ProteinChain.from_pdb( + path=path, chain_id=chain_id, id=id, is_predicted=is_predicted + ) + return cls.from_protein_chain(protein_chain) + + @classmethod + def from_protein_chain( + cls, protein_chain: ProteinChain, with_annotations: bool = False + ) -> ESMProtein: + # By default, we don't annotate with DSSP / SASA, which are expensive. + # If mkdssp is installed, we can annotate with a flag. + if with_annotations: + return ESMProtein( + sequence=protein_chain.sequence, + secondary_structure=protein_chain.dssp().tolist(), + sasa=protein_chain.sasa().tolist(), + function_annotations=None, + coordinates=torch.tensor(protein_chain.atom37_positions), + ) + else: + return ESMProtein( + sequence=protein_chain.sequence, + secondary_structure=None, + sasa=None, + function_annotations=None, + coordinates=torch.tensor(protein_chain.atom37_positions), + ) + + def to_pdb(self, pdb_path: PathLike) -> None: + protein_chain = self.to_protein_chain() + protein_chain.to_pdb(pdb_path) + + def to_pdb_string(self) -> str: + protein_chain = self.to_protein_chain() + return protein_chain.to_pdb_string() + + def to_protein_chain(self) -> ProteinChain: + if self.coordinates is None: + raise ValueError("Coordinates are required to convert to a ProteinChain.") + protein_chain = ProteinChain.from_atom37( + atom37_positions=self.coordinates.to("cpu").numpy(), + id=None, + sequence=self.sequence, + chain_id=None, + entity_id=None, + residue_index=None, + insertion_code=None, + ) + return protein_chain + + +@define +class ESMProteinTensor: + sequence: torch.Tensor | None = None + structure: torch.Tensor | None = None + secondary_structure: torch.Tensor | None = None + sasa: torch.Tensor | None = None + function: torch.Tensor | None = None + residue_annotations: torch.Tensor | None = None + coordinates: torch.Tensor | None = None + + def __len__(self) -> int: + if self.sequence is not None: + return self.sequence.size(0) + elif self.structure is not None: + return self.structure.size(0) + elif self.secondary_structure is not None: + return self.secondary_structure.size(0) + elif self.sasa is not None: + return self.sasa.size(0) + elif self.coordinates is not None: + return self.coordinates.size(0) + else: + raise ValueError("No track to determine length from.") + + @property + def device(self) -> str | torch.device: + device_ = None + + tracks = [f.name for f in attr.fields(ESMProteinTensor)] + + for track in tracks: + current_track: torch.Tensor | None = getattr(self, track) + if current_track is not None: + if device_ is not None and device_ != current_track.device: + raise ValueError(f"Inconsistent devices for track {track}.") + device_ = getattr(self, track).device + + if device_ is None: + raise ValueError("No track to determine device from.") + + return device_ + + def to(self, device: str | torch.device | None) -> ESMProteinTensor: + if device is None: + return self + + device = torch.device(device) + + def _to(name): + v = getattr(self, name) + if v is not None: + setattr(self, name, v.to(device)) + + for n in [ + "sequence", + "structure", + "secondary_structure", + "sasa", + "function", + "residue_annotations", + "coordinates", + ]: + _to(n) + + return self + + @classmethod + def empty( + cls, + length: int, + tokenizers: TokenizerCollectionProtocol | None = None, + device: torch.device | str = "cpu", + ) -> ESMProteinTensor: + if tokenizers is None: + tokenizers = get_model_tokenizers(ESM3_OPEN_SMALL) + + return ESMProteinTensor( + sequence=encoding.get_default_sequence_tokens( + length, tokenizers.sequence + ).to(device), + structure=encoding.get_default_structure_tokens( + length, tokenizers.structure + ).to(device), + secondary_structure=encoding.get_default_secondary_structure_tokens( + length, tokenizers.secondary_structure + ).to(device), + sasa=encoding.get_default_sasa_tokens(length, tokenizers.sasa).to(device), + function=encoding.get_default_function_tokens( + length, tokenizers.function + ).to(device), + residue_annotations=encoding.get_default_residue_annotation_tokens( + length, tokenizers.residue_annotations + ).to(device), + ) + + +## High Level Endpoint Types +@define +class GenerationConfig: + track: str = "" + invalid_ids: Sequence[int] = [] + schedule: str = "cosine" + num_steps: int = 8 + temperature: float = 1.0 + top_p: float = 1.0 + condition_on_coordinates_only: bool = True + + +## Low Level Endpoint Types +@define +class SamplingTrackConfig: + temperature: float = 1.0 + top_p: float = 1.0 + only_sample_masked_tokens: bool = True + invalid_ids: Sequence[int] = [] + topk_logprobs: int = 0 + + +@define +class SamplingConfig: + sequence: SamplingTrackConfig | None = None + structure: SamplingTrackConfig | None = None + secondary_structure: SamplingTrackConfig | None = None + sasa: SamplingTrackConfig | None = None + function: SamplingTrackConfig | None = None + + return_per_residue_embeddings: bool = False + return_mean_embedding: bool = False + + +@define +class ReturnLogitsConfig: + sequence: bool = False + structure: bool = False + secondary_structure: bool = False + sasa: bool = False + function: bool = False + residue_annotations: bool = False + + +@define +class ForwardConfig: + return_logits: ReturnLogitsConfig = ReturnLogitsConfig() + return_embeddings: bool = False + + +@define +class ForwardTrackData: + sequence: torch.Tensor | None = None + structure: torch.Tensor | None = None + secondary_structure: torch.Tensor | None = None + sasa: torch.Tensor | None = None + function: torch.Tensor | None = None + + +@define +class ForwardOutput: + logits: ForwardTrackData | None = None + embeddings: torch.Tensor | None = None + + # Residue annotations is multi-hot, so deserves special treatment + # It's not a categorical distribution, but instead a bernoulli, so + # softmax across the last dimension is _wrong_ + residue_annotation_logits: torch.Tensor | None = None + + +@define +class ForwardAndSampleOutput(ForwardOutput): + protein_tensor: ESMProteinTensor = ESMProteinTensor() + + entropy: ForwardTrackData | None = None + # Probability of sampled token + prob: ForwardTrackData | None = None + logprob: ForwardTrackData | None = None + # Top probability at this position + top_prob: ForwardTrackData | None = None + topk_logprob: ForwardTrackData | None = None + # Which tokens correspond to top probability + topk_tokens: ForwardTrackData | None = None + + per_residue_embedding: torch.Tensor | None = None + mean_embedding: torch.Tensor | None = None + + +ProteinType = TypeVar("ProteinType", bound=ESMProteinTensor | ESMProtein) + + +class ESM3InferenceClient(ABC): + def generate(self, input: ProteinType, config: GenerationConfig) -> ProteinType: + # This is the easiest and most flexible way to run ESM3. Generate will + # iteratively sample tokens an provide an output with the track specified + # completely filled out, according to the GenerationConfig provided. + # It is a local function wrapping calls for encode -> iterative_sampling -> decode. + # if a ESMProteinTensor is provided, encode and decode are skipped + raise NotImplementedError + + def encode(self, input: ESMProtein) -> ESMProteinTensor: + # Encode allows for encoding RawRepresentation into TokenizedRepresentation. + # This runs the structure_token_encoder, as well as dealing with PDB => atom37 conversion + raise NotImplementedError + + def decode(self, input: ESMProteinTensor) -> ESMProtein: + # Decode is the inverse of encode, and runs a structure_token_decoder to output coordinates + raise NotImplementedError + + def _forward( + self, input: ESMProteinTensor, config: ForwardConfig = ForwardConfig() + ) -> ForwardOutput: + # Our API generally discourages using raw forwards. + # This is because sending logits can be prohibitively expensive. + # Please use forward_and_sample instead. + raise NotImplementedError + + def forward_and_sample( + self, input: ESMProteinTensor, sampling_configuration: SamplingConfig + ) -> ForwardAndSampleOutput: + # forward_and_sample runs a single model forward, sampling tokens according to `SamplingConfiguration`. + # This is the way for power users to run ESM3. We hope to design this in a way to enable high throughput + # inference, as well as arbitrary chain-of-though invocations of ESM3. + raise NotImplementedError diff --git a/esm/tokenization/__init__.py b/esm/tokenization/__init__.py new file mode 100644 index 0000000..9d2e5a9 --- /dev/null +++ b/esm/tokenization/__init__.py @@ -0,0 +1,63 @@ +from dataclasses import dataclass +from typing import Protocol + +from esm.utils.constants.esm3 import VQVAE_SPECIAL_TOKENS +from esm.utils.constants.models import ESM3_OPEN_SMALL + +from .function_tokenizer import InterProQuantizedTokenizer +from .residue_tokenizer import ResidueAnnotationsTokenizer +from .sasa_tokenizer import SASADiscretizingTokenizer +from .sequence_tokenizer import EsmSequenceTokenizer +from .ss_tokenizer import SecondaryStructureTokenizer +from .structure_tokenizer import StructureTokenizer +from .tokenizer_base import EsmTokenizerBase + + +class TokenizerCollectionProtocol(Protocol): + sequence: EsmSequenceTokenizer + structure: StructureTokenizer + secondary_structure: SecondaryStructureTokenizer + sasa: SASADiscretizingTokenizer + function: InterProQuantizedTokenizer + residue_annotations: ResidueAnnotationsTokenizer + + +@dataclass +class TokenizerCollection: + sequence: EsmSequenceTokenizer + structure: StructureTokenizer + secondary_structure: SecondaryStructureTokenizer + sasa: SASADiscretizingTokenizer + function: InterProQuantizedTokenizer + residue_annotations: ResidueAnnotationsTokenizer + + +def get_model_tokenizers(model: str = ESM3_OPEN_SMALL) -> TokenizerCollection: + if model == ESM3_OPEN_SMALL: + return TokenizerCollection( + sequence=EsmSequenceTokenizer(), + structure=StructureTokenizer(vq_vae_special_tokens=VQVAE_SPECIAL_TOKENS), + secondary_structure=SecondaryStructureTokenizer(kind="ss8"), + sasa=SASADiscretizingTokenizer(), + function=InterProQuantizedTokenizer(), + residue_annotations=ResidueAnnotationsTokenizer(), + ) + else: + raise ValueError(f"Unknown model: {model}") + + +def get_invalid_tokenizer_ids(tokenizer: EsmTokenizerBase) -> list[int]: + if isinstance(tokenizer, EsmSequenceTokenizer): + return [ + tokenizer.mask_token_id, # type: ignore + tokenizer.pad_token_id, # type: ignore + tokenizer.cls_token_id, # type: ignore + tokenizer.eos_token_id, # type: ignore + ] + else: + return [ + tokenizer.mask_token_id, + tokenizer.pad_token_id, + tokenizer.bos_token_id, + tokenizer.eos_token_id, + ] diff --git a/esm/tokenization/function_tokenizer.py b/esm/tokenization/function_tokenizer.py new file mode 100644 index 0000000..a56e728 --- /dev/null +++ b/esm/tokenization/function_tokenizer.py @@ -0,0 +1,404 @@ +"""Tokenizes annotations of protein function.""" + +import re +import string +from functools import cache, cached_property, partial +from typing import Collection + +import numpy as np +import pandas as pd +import scipy.sparse as sp +import torch +import torch.nn.functional as F + +from esm.tokenization.tokenizer_base import EsmTokenizerBase +from esm.utils.constants import esm3 as C +from esm.utils.function import interpro, lsh, tfidf +from esm.utils.misc import stack_variable_length_tensors +from esm.utils.types import FunctionAnnotation + + +class InterProQuantizedTokenizer(EsmTokenizerBase): + """Tokenizer for functional annotations. + + This tokenizer converts InterPro and/or function keywords into a multi-token + representation by hashing TF-IDF vector representations of the text associated with + the fuction and then applying a locality sensitive hash (LSH). + """ + + def __init__( + self, + depth: int = 8, + lsh_bits_per_token: int = 8, + lsh_path: str | None = None, + keyword_vocabulary_path: str | None = None, + keyword_idf_path: str | None = None, + interpro_entry_path: str | None = None, + interpro2keywords_path: str | None = None, + ): + """Constructs function tokenizer. + + Args: + depth: number of tokens emitted in each position. + lsh_bits_per_token: Number of LSH bits per token. Determines the vocabulary + size. + lsh_path: path to locality sensitive hash (LSH) hyperplanes. + keyword_vocabulary_path: path to csv containing function keyword vocabulary. + keyword_idf_path: path to IDF values for each keyword. + interpro_entry_csv_path: path to list of InterPro entries in CSV format. + interpro2keywords_path: path to CSV mapping InterPro IDs to function keywords. + """ + self.depth = depth + default = lambda x, d: x if x is not None else C.data_root() / d + + self.keyword_vocabulary_path = default( + keyword_vocabulary_path, C.KEYWORDS_VOCABULARY + ) + self.keyword_idf_path = default(keyword_idf_path, C.KEYWORDS_IDF) + + self._interpro2keywords_path = default( + interpro2keywords_path, C.INTERPRO2KEYWORDS + ) + self.interpro_ = interpro.InterPro( + entries_path=default(interpro_entry_path, C.INTERPRO_ENTRY) + ) + + self.lsh_vocab_size = 1 << lsh_bits_per_token + self._lsh = lsh.LSHTokenized( + lsh_bits_per_token, + len(self.keyword_vocabulary), + self.depth, + default(lsh_path, C.LSH_TABLE_PATHS["8bit"]), + ) + + # This is the offset into the vocabulary where LSH tokens start. + self._lsh_token_vocab_offset = len(self.special_tokens) + 1 # +1 for + + @cached_property + def interpro2keywords(self) -> dict[str, list[str]]: + """Mapping from InterPro ID to function keywords.""" + df = pd.read_csv(self._interpro2keywords_path) + assert "interpro_id" in df.columns and "keywords" in df.columns, df.columns + return dict(zip(df.interpro_id, df.keywords.str.split(","))) + + @cached_property + def interpro_labels(self) -> list[str]: + """The set of supported InterPro labels.""" + return sorted(self.interpro2keywords.keys()) + + @cached_property + def interpro_to_index(self) -> dict[str, int]: + """Mapping from InterPro id to index.""" + return {id: i for i, id in enumerate(self.interpro_labels)} + + @property + def keyword_vocabulary(self) -> list[str]: + """Set of supported keywords.""" + return self._tfidf.vocabulary + + @property + def keyword_to_index(self) -> dict[str, int]: + """Mapping from keywords to index.""" + return self._tfidf.vocab_to_index + + @cached_property + def _tfidf(self) -> tfidf.TFIDFModel: + """Creates TF-IDF model for encoding function keywords.""" + return tfidf.TFIDFModel( + vocabulary_path=self.keyword_vocabulary_path, + idf_path=self.keyword_idf_path, + ) + + @cached_property + def special_tokens(self) -> list[str]: + """List of special tokens which come before cluster tokens in vocab.""" + return ["", "", ""] + + @cached_property + def vocab(self) -> list[str]: + """Vocabulary of function tokens.""" + lsh_tokens = [f"" for i in range(self.lsh_vocab_size)] + return self.special_tokens + [""] + lsh_tokens + + @cached_property + def vocab_to_index(self) -> dict[str, int]: + return {token: token_id for token_id, token in enumerate(self.vocab)} + + def get_special_tokens_mask(self, encoded: torch.Tensor) -> torch.Tensor: + """Determines where in the sequence are special tokens.""" + where = encoded < len(self.special_tokens) + assert torch.all(torch.all(where, dim=1) | torch.all(~where, dim=1)) + return where[:, 0] + + def tokenize( + self, + annotations: list[FunctionAnnotation], + seqlen: int, + p_keyword_dropout: float = 0.0, + ) -> list[str]: + """Encodes range-annotations of protein function as tokens. + + Args: + features: Annotated function ranges, either as InterPro ids or keywords. + seqlen: length of sequence. + p_keyword_dropout: Optional probability of dropping out keywords from the + input annotations. + Returns: + Tokenized representation of function annotations as a list of string tokens + of size seqlen. + """ + assert seqlen >= 0 + + if not annotations: + return [""] * seqlen + + # Expand the range annotations into positional annotaiton sets. + positional_labels: list[set[str]] = [set() for _ in range(seqlen)] + for annotation in annotations: + assert 1 <= annotation.start <= annotation.end <= seqlen, ( + f"Invalid annotation range [{annotation.start}, {annotation.end}] for " + f"sequence length {seqlen}." + ) + for i in range(annotation.start - 1, annotation.end): + positional_labels[i].add(annotation.label) + + if p_keyword_dropout > 0: + keyword_mask = ( + np.random.random(len(self._tfidf.vocabulary)) < p_keyword_dropout + ) + else: + keyword_mask = None + + # Annotations tend to be repetitive over the length of the sequence - cache their + # hashes to speed up tokenization. + hash_fn = cache(partial(self._function_text_hash, keyword_mask=keyword_mask)) + + tokens: list[str] = [] + for labels in positional_labels: + if not labels: + token = "" + else: + lsh_hash = hash_fn(frozenset(labels)) + if lsh_hash is not None: + assert len(lsh_hash) == self.depth + token = "" + else: + token = "" + + tokens.append(token) + + return tokens + + def _function_text_hash( + self, + labels: Collection[str], + keyword_mask: np.ndarray | None = None, + ) -> np.ndarray | None: + """Applies a locality sensitive hash (LSH) to function text. + + Args: + labels: InterPro ids and/or keywords. + keyword_mask: optional boolean array shaped (keyword_vocab_size,) indicating + which keywords to drop before hashing. + Returns: + LSH shaped (depth,) or None if there is no text or keywords to hash. + """ + # Split labels into either InterPro ids or keywords. + interpro_ids = [] + keywords = [] + for label in labels: + match = re.match(r"IPR\d+", label) + if match and match.group() in self.interpro_to_index: + interpro_ids.append(match.group()) + elif label in self._tfidf.vocab_to_index: + keywords.append(label) + else: + raise ValueError(f"Unsupported: {label}") + + vec: sp.csr_matrix = self._tfidf.encode(keywords) + + # Perform an element-wise maximum over TF-IDF vectors from distinct tags to + # avoid tags getting "washed out" by eg. 4 very similar tags. Keywords are + # incorporated as another TF-IDF vector + vec: sp.csr_matrix = self._tfidf.encode(keywords) + for interpro_id in interpro_ids: + interpro_keywords = self.interpro2keywords.get(interpro_id, []) + vec_ = self._tfidf.encode(interpro_keywords) + vec = vec.maximum(vec_) + + if keyword_mask is not None: + vec.data *= 1 - np.take(keyword_mask, vec.indices) + + if vec.sum() == 0: + return None + + return self._lsh(vec)[0, :] + + def encode( + self, tokens: list[str], add_special_tokens: bool = True + ) -> torch.Tensor: + """Encodes string tokens as token-id tensor. + + Args: + tokens: list of individual tokens. e.g. ["", ""] + add_special_tokens: whether to add a single pad token at the start and end + of the sequence to act as and tokens. + Returns: + [length, depth] function tokens. Length will be +2 of input tokens + length when add_special_tokens is True. + """ + token_ids = torch.zeros(size=(len(tokens), self.depth), dtype=torch.int64) + for i, token in enumerate(tokens): + token_ids[i, :] = torch.tensor(self._token2ids(token)) + if add_special_tokens: + token_ids = F.pad( + token_ids, (0, 0, 1, 1), value=self.vocab_to_index[""] + ) + return token_ids + + def lookup_annotation_name(self, annotation: FunctionAnnotation) -> str | None: + return self.interpro_.lookup_name(annotation.label) + + def format_annotation(self, annotation: FunctionAnnotation) -> str: + annotation_name = self.lookup_annotation_name(annotation) + if annotation_name is not None: + return f"{annotation_name} ({annotation.label})" + else: + return annotation.label + + def _token2ids(self, token: str) -> list[int]: + """Converts token into token_id set of length depth.""" + if re.match(r"", token): + lsh_ids = [int(lsh_id) for lsh_id in re.findall(r"\d+", token)] + assert ( + len(lsh_ids) == self.depth + ), f"Expected token to have {self.depth} ids found {lsh_ids}" + return [self._lsh_token_vocab_offset + lsh_id for lsh_id in lsh_ids] + elif token == "" or token in self.special_tokens: + return [self.vocab_to_index[token]] * self.depth + else: + raise ValueError(f"Unknown token: {token}") + + def batch_encode( + self, + token_batch: list[list[str]], + add_special_tokens: bool = True, + ) -> torch.Tensor: + """Encodes batch of function tokens. + + Args: + token_batch: batch of function tokens. + add_special_tokens: whether to add special tokens. + Returns: + [batch_size, max_length, depth] batch of encoded tokens. + """ + encoded = [ + self.encode(tokens, add_special_tokens=add_special_tokens) + for tokens in token_batch + ] + return stack_variable_length_tensors( + encoded, + constant_value=self.vocab_to_index[""], + ) + + def decode(self, encoded: torch.Tensor): + raise NotImplementedError( + "Function token decoding should be handled with " + "util.decoding.decode_function_annotations" + ) + + @property + def mask_token(self) -> str: + return "" + + @property + def mask_token_id(self) -> int: + return self.vocab_to_index[self.mask_token] + + @property + def bos_token(self) -> str: + return "" + + @property + def bos_token_id(self) -> int: + return self.vocab_to_index[self.bos_token] + + @property + def eos_token(self) -> str: + return "" + + @property + def eos_token_id(self) -> int: + return self.vocab_to_index[self.eos_token] + + @property + def pad_token(self) -> str: + return "" + + @property + def pad_token_id(self) -> int: + return self.vocab_to_index[self.pad_token] + + +def _texts_to_keywords(texts: list[str]) -> list[str]: + """Breaks InterPro/GO free-text description set into bag-of-n-grams for n={1,2}. + + Args: + texts: collection of text descriptions, i.e. InterPro/GO names. + Returns: + Collection of terms/n-grams + """ + keywords = [] + for text in texts: + keywords.extend(_keywords_from_text(text)) + return keywords + + +def _keywords_from_text(text: str) -> list[str]: + """Splits text into unigrams and bigrams.""" + elements = text.split(", ") + + terms = [] + for element in elements: + element = _sanitize(element) + words = element.split() + + # Add 1-mers + terms.extend(words) + + # Add 2-mers + for i in range(len(words) - 1): + bigram = words[i] + " " + words[i + 1] + terms.append(bigram) + + return [term for term in terms if len(term) > 1 and term not in _EXCLUDED_TERMS] + + +def _sanitize(text: str) -> str: + text = text.replace("-", " ") + text = text.translate(str.maketrans("", "", string.punctuation)) + text = text.lower() + return text + + +# These terms are omitted from textual representations since they are pervasive and +# unspecific to particular protein function. +_EXCLUDED_TERMS = { + "binding domain", + "biological_process", + "biological process", + "biologicalprocess", + "c", + "cellular_component", + "cellular component", + "cellularcomponent", + "cellular_process", + "cellularprocess", + "cellular process", + "cellularprocess", + "like domain", + "molecular function", + "molecular_function", + "molecularfunction", + "n", +} diff --git a/esm/tokenization/residue_tokenizer.py b/esm/tokenization/residue_tokenizer.py new file mode 100644 index 0000000..a48d048 --- /dev/null +++ b/esm/tokenization/residue_tokenizer.py @@ -0,0 +1,224 @@ +from functools import cached_property +from pathlib import Path +from typing import Any + +import pandas as pd +import torch +import torch.nn.functional as F + +from esm.tokenization.tokenizer_base import EsmTokenizerBase +from esm.utils.constants import esm3 as C + +Sample = dict[str, Any] + + +class ResidueAnnotationsTokenizer(EsmTokenizerBase): + def __init__( + self, + csv_path: str | None = None, + max_annotations: int = 16, + ): + if csv_path is None: + csv_path = str(C.data_root() / C.RESID_CSV) + self.csv_path = csv_path + self.max_annotations = max_annotations + + @cached_property + def _description2label(self) -> dict[str, str]: + with Path(self.csv_path).open() as f: # type: ignore + df = pd.read_csv(f) + return dict(zip(df.label, df.label_clean)) + + @cached_property + def _labels(self) -> list[str]: + with Path(self.csv_path).open() as f: # type: ignore + df = pd.read_csv(f) + labels = ( + df.groupby("label_clean")["count"] + .sum() + .sort_values(ascending=False, kind="stable") # type: ignore + .index.tolist() + ) + assert isinstance(labels, list) + return labels # type: ignore + + def _description2id(self, description: str) -> int | None: + label = self._description2label.get(description) + return self._label2id.get(label) # type: ignore + + @cached_property + def _label2id(self) -> dict[str, int]: + offset = len(self.special_tokens) + 1 # +1 for "" + return {label: offset + i for i, label in enumerate(self._labels)} + + @cached_property + def special_tokens(self) -> list[str]: + """List of special tokens which come before cluster toknes in vocab.""" + return ["", "", ""] + + @cached_property + def vocab(self): + annotation_tokens = [f"" for _, id in self._label2id.items()] + return self.special_tokens + [""] + annotation_tokens + + @cached_property + def vocab_to_index(self) -> dict[str, int]: + return {token: token_id for token_id, token in enumerate(self.vocab)} + + @cached_property + def vocabulary(self) -> list[str]: + """Full vocabulary.""" + return [*self.special_tokens, "", *self._labels] + + def get_special_tokens_mask(self, encoded: torch.Tensor) -> torch.Tensor: + """Determines where in the sequence are special tokens.""" + return encoded[:, 0] < len(self.special_tokens) + + def tokenize( + self, sample: Sample | None, sequence: str, fail_on_mismatch: bool = False + ) -> list[str]: + """ + # interpro_site_starts + # interpro_site_ends # should always == interpro_site_starts. but I haven't checked overall. + # interpro_site_residues # the residue identity of the specfic residue that is annotated. good for a sanity check that parsing occurred correctly. + # interpro_site_descriptions + # ASSERT (i.e. drop if bad) + # interpro_site_residues matches the residue at that position + # all these lists ^ above are the same length + """ + seqlen = len(sequence) + assert seqlen >= 0 + # None mean sequence is *not annotated* - so use full + if sample is None: + return [""] * seqlen + + if any( + sample.get(field) is None + for field in [ + "interpro_site_descriptions", + "interpro_site_starts", + "interpro_site_ends", + "interpro_site_residues", + ] + ): + return [""] * seqlen + + num_annotations = len(sample["interpro_site_descriptions"]) + if any( + len(sample[field]) != num_annotations + for field in [ + "interpro_site_starts", + "interpro_site_ends", + "interpro_site_residues", + ] + ): + # mismatched length. + return [""] * seqlen + + positional_ids = [set() for _ in range(seqlen)] + for description, start, end, residues in zip( + sample["interpro_site_descriptions"], + sample["interpro_site_starts"], + sample["interpro_site_ends"], + sample["interpro_site_residues"], + ): + try: + start = int(start) + end = int(end) + except (TypeError, ValueError): + continue + + # Start / End are 1-indexed [inclusive, inclusive]. + if start <= 0 or end > seqlen or start > end: + print(f"invalid start/end: ({start}, {end}), len: {seqlen}") + continue + + if len(residues) != (end - start) + 1: + print(f"bad reference residue: {residues}") + continue + + token_id = self._description2id(description) + if token_id is None: + token_id = self.vocab_to_index[""] + + for i, residue in zip(range(start - 1, end), residues): + # If there are any mismatching residues, skip the entire sample. + if sequence[i] != residue: + if fail_on_mismatch: + raise ValueError( + f"Residue mismatch at position {i} (1-indexed): {sequence[i]} != {residue}" + ) + return [""] * seqlen + + positional_ids[i].add(token_id) + + tokens = [] + for token_ids in positional_ids: + if token_ids: + token = "" + else: + token = "" + tokens.append(token) + return tokens + + def _token2ids(self, token: str) -> list[int]: + if token.startswith(""): + return [int(token_id) for token_id in token[4:-1].split(",")] + else: + token_id = self.vocab_to_index[token] + return [token_id] + + def encode( + self, tokens: list[str], add_special_tokens: bool = True + ) -> torch.Tensor: + token_ids = torch.full( + size=(len(tokens), self.max_annotations), + dtype=torch.int64, + fill_value=self.vocab_to_index[""], + ) + for i, token in enumerate(tokens): + ids = self._token2ids(token)[: self.max_annotations] + token_ids[i, : len(ids)] = torch.tensor(ids) + + if add_special_tokens: + token_ids = F.pad( + token_ids, (0, 0, 1, 1), value=self.vocab_to_index[""] + ) + return token_ids + + def decode(self, encoded: torch.Tensor) -> list[str]: + raise NotImplementedError( + "Residue annotation decoding should be handled with util.decoding.decode_residue_annotations" + ) + + @property + def mask_token(self) -> str: + return "" + + @property + def mask_token_id(self) -> int: + return self.vocab_to_index[self.mask_token] + + @property + def bos_token(self) -> str: + return "" + + @property + def bos_token_id(self) -> int: + return self.vocab_to_index[self.bos_token] + + @property + def eos_token(self) -> str: + return "" + + @property + def eos_token_id(self) -> int: + return self.vocab_to_index[self.eos_token] + + @property + def pad_token(self) -> str: + return "" + + @property + def pad_token_id(self) -> int: + return self.vocab_to_index[self.pad_token] diff --git a/esm/tokenization/sasa_tokenizer.py b/esm/tokenization/sasa_tokenizer.py new file mode 100644 index 0000000..4d7221b --- /dev/null +++ b/esm/tokenization/sasa_tokenizer.py @@ -0,0 +1,129 @@ +from functools import cached_property + +import torch + +from esm.tokenization.tokenizer_base import EsmTokenizerBase +from esm.utils.constants import esm3 as C + + +class SASADiscretizingTokenizer(EsmTokenizerBase): + """Tokenizer for Solvent Accessible Surface Area (SASA).""" + + def __init__(self, boundaries: list[float] = C.SASA_DISCRETIZATION_BOUNDARIES): + self._boundaries = sorted(boundaries) + + @cached_property + def special_tokens(self) -> list[str]: + return ["", "", ""] + + @cached_property + def vocab(self) -> list[str]: + """Discrete token vocabulary. + + Returns: + token vocabulary with ranges represented as "". + """ + boundary_strs = ["0"] + [str(b) for b in self._boundaries] + ["inf"] + range_tokens = [ + f"<{low}-{high}>" + for low, high in zip(boundary_strs[:-1], boundary_strs[1:]) + ] + return self.special_tokens + range_tokens + + @cached_property + def midpoints(self) -> list[float]: + """Midpoints of the SASA token ranges.""" + boundaries = [0] + self._boundaries + [self._boundaries[-1] * 2] + midpoint_tokens = [ + (float(high) + float(low)) / 2 + for low, high in zip(boundaries[:-1], boundaries[1:]) + ] + midpoint_tokens = [float("nan"), float("nan"), float("nan")] + midpoint_tokens + return midpoint_tokens + + @cached_property + def vocab_to_index(self) -> dict[str, int]: + """Constructs token -> token id mapping.""" + return {word: i for i, word in enumerate(self.vocab)} + + def get_special_tokens_mask(self, tokens: torch.Tensor) -> torch.Tensor: + """Determines which positions are special tokens. + + Args: + tokens: [length] + Returns: + [length] tensor, true where special tokens are located in the input. + """ + return tokens < len(self.special_tokens) + + def encode( + self, values: list[float | str], add_special_tokens: bool = True + ) -> torch.Tensor: + """Encodes SASA values as discrete tokens. + + Args: + values: list of either SASA values or individual tokens. For example + [1.2, "", 10.3, , 0.] + Returns: + Token ids as tensor. Adds BOS and EOS special tokens. + """ + ids = [] + if add_special_tokens: + ids.append(self.vocab_to_index[""]) # BOS + for value in values: + if isinstance(value, (float, int)): + bucket = torch.bucketize(value, torch.tensor(self._boundaries)) + token_id = len(self.special_tokens) + bucket + elif isinstance(value, str): + token_id = self.vocab_to_index[value] + else: + raise TypeError(value) + ids.append(token_id) + if add_special_tokens: + ids.append(self.vocab_to_index[""]) # EOS + + return torch.tensor(ids, dtype=torch.int64) + + def decode_float(self, encoded: torch.Tensor) -> list[float]: + """Decodes SASA token ids into float values.""" + return [self.midpoints[token_id] for token_id in encoded] + + def decode(self, encoded: torch.Tensor) -> str: + """Decodes SASA token ids.""" + return ",".join(self.vocab[i] for i in encoded) + + def decode_list(self, encoded: torch.Tensor) -> list[str]: + """Decodes SASA token ids.""" + return [self.vocab[i] for i in encoded] + + @property + def mask_token(self) -> str: + return "" + + @property + def mask_token_id(self) -> int: + return self.vocab_to_index[self.mask_token] + + @property + def bos_token(self) -> str: + return "" + + @property + def bos_token_id(self) -> int: + return self.vocab_to_index[self.bos_token] + + @property + def eos_token(self) -> str: + return "" + + @property + def eos_token_id(self) -> int: + return self.vocab_to_index[self.eos_token] + + @property + def pad_token(self) -> str: + return "" + + @property + def pad_token_id(self) -> int: + return self.vocab_to_index[self.pad_token] diff --git a/esm/tokenization/sequence_tokenizer.py b/esm/tokenization/sequence_tokenizer.py new file mode 100644 index 0000000..0926aab --- /dev/null +++ b/esm/tokenization/sequence_tokenizer.py @@ -0,0 +1,68 @@ +from tokenizers import Tokenizer +from tokenizers.models import BPE +from tokenizers.processors import TemplateProcessing +from transformers import PreTrainedTokenizerFast + +from esm.tokenization.tokenizer_base import EsmTokenizerBase +from esm.utils.constants import esm3 as C + + +class EsmSequenceTokenizer(PreTrainedTokenizerFast, EsmTokenizerBase): + """ + Constructs an ESM tokenizer. + """ + + model_input_names = ["sequence_tokens", "attention_mask"] + + def __init__( + self, + unk_token="", + cls_token="", + pad_token="", + mask_token="", + eos_token="", + chainbreak_token="|", + **kwargs, + ): + all_tokens = C.SEQUENCE_VOCAB + token_to_id = {tok: ind for ind, tok in enumerate(all_tokens)} + + # a character-level tokenizer is the same as BPE with no token merges + bpe = BPE(token_to_id, merges=[], unk_token=unk_token) + tokenizer = Tokenizer(bpe) + special_tokens = [cls_token, pad_token, mask_token, eos_token, chainbreak_token] + additional_special_tokens = [chainbreak_token] + + tokenizer.add_special_tokens( + special_tokens, + ) + + # This is where we configure the automatic addition of special tokens when we call + # tokenizer(text, add_special_tokens=True). Note that you can also configure how two + # sequences are merged if you want. + tokenizer.post_processor = TemplateProcessing( # type: ignore + single=" $A ", + special_tokens=[ + ("", tokenizer.token_to_id("")), + ("", tokenizer.token_to_id("")), + ], + ) + super().__init__( + tokenizer_object=tokenizer, + unk_token=unk_token, + cls_token=cls_token, + pad_token=pad_token, + mask_token=mask_token, + eos_token=eos_token, + additional_special_tokens=additional_special_tokens, + **kwargs, + ) + + # These are a footgun, we never use the `bos` token anywhere so we're just overriding it here. + @property + def bos_token(self): + return self.cls_token + + @property + def bos_token_id(self): + return self.cls_token_id diff --git a/esm/tokenization/ss_tokenizer.py b/esm/tokenization/ss_tokenizer.py new file mode 100644 index 0000000..c540103 --- /dev/null +++ b/esm/tokenization/ss_tokenizer.py @@ -0,0 +1,109 @@ +from functools import cached_property +from typing import Sequence + +import torch + +from esm.tokenization.tokenizer_base import EsmTokenizerBase +from esm.utils.constants import esm3 as C + + +class SecondaryStructureTokenizer(EsmTokenizerBase): + """Tokenizer for secondary structure strings.""" + + def __init__(self, kind: str = "ss8"): + assert kind in ("ss8", "ss3") + self.kind = kind + + @property + def special_tokens(self) -> list[str]: + return ["", "", ""] + + @cached_property + def vocab(self): + """Tokenzier vocabulary list.""" + match self.kind: + case "ss8": + nonspecial_tokens = list(C.SSE_8CLASS_VOCAB) # "GHITEBSC" + case "ss3": + nonspecial_tokens = list(C.SSE_3CLASS_VOCAB) # HEC + case _: + raise ValueError(self.kind) + + # The non-special tokens ids match amino acid tokens ids when possible. + return [*self.special_tokens, *nonspecial_tokens] + + @cached_property + def vocab_to_index(self) -> dict[str, int]: + """Constructs token -> token id mapping.""" + return {word: i for i, word in enumerate(self.vocab)} + + def get_special_tokens_mask(self, tokens: torch.Tensor) -> torch.Tensor: + """Determines which positions are special tokens. + + Args: + tokens: [length] + Returns: + [length] tensor, true where special tokens are located in the input. + """ + return tokens < len(self.special_tokens) + + def encode( + self, sequence: str | Sequence[str], add_special_tokens: bool = True + ) -> torch.Tensor: + """Encode secondary structure string + + Args: + string: secondary structure string e.g. "GHHIT", or as token listk. + Returns: + [sequence_length] token ids representing. Will add /. + """ + ids = [] + if add_special_tokens: + ids.append(self.vocab_to_index[""]) # cls + for char in sequence: + ids.append(self.vocab_to_index[char]) + if add_special_tokens: + ids.append(self.vocab_to_index[""]) # eos + return torch.tensor(ids, dtype=torch.int64) + + def decode(self, encoded: torch.Tensor) -> str: + """Decodes token ids into secondary structure string. + + Args: + encoded: [length] token id array. + Returns + Decoded secondary structure string. + """ + return "".join(self.vocab[i] for i in encoded) + + @property + def mask_token(self) -> str: + return "" + + @property + def mask_token_id(self) -> int: + return self.vocab_to_index[self.mask_token] + + @property + def bos_token(self) -> str: + return "" + + @property + def bos_token_id(self) -> int: + return self.vocab_to_index[self.bos_token] + + @property + def eos_token(self) -> str: + return "" + + @property + def eos_token_id(self) -> int: + return self.vocab_to_index[self.eos_token] + + @property + def pad_token(self) -> str: + return "" + + @property + def pad_token_id(self) -> int: + return self.vocab_to_index[self.pad_token] diff --git a/esm/tokenization/structure_tokenizer.py b/esm/tokenization/structure_tokenizer.py new file mode 100644 index 0000000..76b91b2 --- /dev/null +++ b/esm/tokenization/structure_tokenizer.py @@ -0,0 +1,63 @@ +from esm.tokenization.tokenizer_base import EsmTokenizerBase + + +class StructureTokenizer(EsmTokenizerBase): + """A convenince class for accessing special token ids of + the StructureTokenEncoder and StructureTokenDecoder.""" + + def __init__(self, vq_vae_special_tokens: dict[str, int]): + self.vq_vae_special_tokens = vq_vae_special_tokens + + def mask_token(self) -> str: + raise NotImplementedError( + "Structure tokens are defined on 3D coordinates, not strings." + ) + + @property + def mask_token_id(self) -> int: + return self.vq_vae_special_tokens["MASK"] + + def bos_token(self) -> str: + raise NotImplementedError( + "Structure tokens are defined on 3D coordinates, not strings." + ) + + @property + def bos_token_id(self) -> int: + return self.vq_vae_special_tokens["BOS"] + + def eos_token(self) -> str: + raise NotImplementedError( + "Structure tokens are defined on 3D coordinates, not strings." + ) + + @property + def eos_token_id(self) -> int: + return self.vq_vae_special_tokens["EOS"] + + def pad_token(self) -> str: + raise NotImplementedError( + "Structure tokens are defined on 3D coordinates, not strings." + ) + + @property + def pad_token_id(self) -> int: + return self.vq_vae_special_tokens["PAD"] + + @property + def chainbreak_token_id(self) -> int: + return self.vq_vae_special_tokens["CHAINBREAK"] + + def encode(self, *args, **kwargs): + raise NotImplementedError( + "The StructureTokenizer class is provided as a convenience for " + "accessing special token ids of the StructureTokenEncoder and StructureTokenDecoder.\n" + "Please use them instead." + ) + + def decode(self, *args, **kwargs): + raise NotImplementedError( + "The StructureTokenizer class is provided as a convenience for " + "accessing special token ids of the StructureTokenEncoder and StructureTokenDecoder.\n" + "Please use them instead." + ) diff --git a/esm/tokenization/tokenizer_base.py b/esm/tokenization/tokenizer_base.py new file mode 100644 index 0000000..7cbce34 --- /dev/null +++ b/esm/tokenization/tokenizer_base.py @@ -0,0 +1,42 @@ +from typing import Protocol, runtime_checkable + + +@runtime_checkable +class EsmTokenizerBase(Protocol): + def encode(self, *args, **kwargs): + ... + + def decode(self, *args, **kwargs): + ... + + @property + def mask_token(self) -> str: + ... + + @property + def mask_token_id(self) -> int: + ... + + @property + def bos_token(self) -> str: + ... + + @property + def bos_token_id(self) -> int: + ... + + @property + def eos_token(self) -> str: + ... + + @property + def eos_token_id(self) -> int: + ... + + @property + def pad_token(self) -> str: + ... + + @property + def pad_token_id(self) -> int: + ... diff --git a/esm/utils/constants/esm3.py b/esm/utils/constants/esm3.py new file mode 100644 index 0000000..10411c0 --- /dev/null +++ b/esm/utils/constants/esm3.py @@ -0,0 +1,127 @@ +from functools import cache +from pathlib import Path + +from huggingface_hub import snapshot_download + +SEQUENCE_BOS_TOKEN = 0 +SEQUENCE_PAD_TOKEN = 1 +SEQUENCE_EOS_TOKEN = 2 +SEQUENCE_CHAINBREAK_TOKEN = 31 +SEQUENCE_MASK_TOKEN = 32 + +VQVAE_CODEBOOK_SIZE = 4096 +VQVAE_SPECIAL_TOKENS = { + "MASK": VQVAE_CODEBOOK_SIZE, + "EOS": VQVAE_CODEBOOK_SIZE + 1, + "BOS": VQVAE_CODEBOOK_SIZE + 2, + "PAD": VQVAE_CODEBOOK_SIZE + 3, + "CHAINBREAK": VQVAE_CODEBOOK_SIZE + 4, +} +VQVAE_DIRECTION_LOSS_BINS = 16 +VQVAE_PAE_BINS = 64 +VQVAE_MAX_PAE_BIN = 31.0 +VQVAE_PLDDT_BINS = 50 + +STRUCTURE_MASK_TOKEN = VQVAE_SPECIAL_TOKENS["MASK"] +STRUCTURE_BOS_TOKEN = VQVAE_SPECIAL_TOKENS["BOS"] +STRUCTURE_EOS_TOKEN = VQVAE_SPECIAL_TOKENS["EOS"] +STRUCTURE_PAD_TOKEN = VQVAE_SPECIAL_TOKENS["PAD"] +STRUCTURE_CHAINBREAK_TOKEN = VQVAE_SPECIAL_TOKENS["CHAINBREAK"] +STRUCTURE_UNDEFINED_TOKEN = 955 + +SASA_UNK_TOKEN = 2 +SASA_PAD_TOKEN = 0 + +SS8_UNK_TOKEN = 2 +SS8_PAD_TOKEN = 0 + +INTERPRO_PAD_TOKEN = 0 + +RESIDUE_PAD_TOKEN = 0 + +CHAIN_BREAK_STR = "|" + +SEQUENCE_BOS_STR = "" +SEQUENCE_EOS_STR = "" + +MASK_STR_SHORT = "_" +SEQUENCE_MASK_STR = "" +SASA_MASK_STR = "" +SS8_MASK_STR = "" + +# fmt: off +SEQUENCE_VOCAB = [ + "", "", "", "", + "L", "A", "G", "V", "S", "E", "R", "T", "I", "D", "P", "K", + "Q", "N", "F", "Y", "M", "H", "W", "C", "X", "B", "U", "Z", + "O", ".", "-", "|", + "", +] +# fmt: on + +SSE_8CLASS_VOCAB = "GHITEBSC" +SSE_3CLASS_VOCAB = "HEC" +SSE_8CLASS_TO_3CLASS_MAP = { + "G": "H", + "H": "H", + "I": "H", + "T": "C", + "E": "E", + "B": "E", + "S": "C", + "C": "C", +} + +SASA_DISCRETIZATION_BOUNDARIES = [ + 0.8, + 4.0, + 9.6, + 16.4, + 24.5, + 32.9, + 42.0, + 51.5, + 61.2, + 70.9, + 81.6, + 93.3, + 107.2, + 125.4, + 151.4, +] + +MAX_RESIDUE_ANNOTATIONS = 16 + + +TFIDF_VECTOR_SIZE = 58641 + + +@staticmethod +@cache +def data_root(): + # Try a few default directories + for path in [ + "esm/data", + "esm/data", + ]: + if (p := Path(path)).exists(): + return p.parent + # Try to download from hugginface if it doesn't exist + path = Path(snapshot_download(repo_id="EvolutionaryScale/esm3-sm-open-v1")) + return path + + +INTERPRO_ENTRY = "data/entry_list_safety_29026.list" +INTERPRO_HIERARCHY = "data/ParentChildTreeFile.txt" +INTERPRO2GO = "data/ParentChildTreeFile.txt" +INTERPRO_2ID = "data/tag_dict_4_safety_filtered.json" + +LSH_TABLE_PATHS = { + "8bit": "data/hyperplanes_8bit_58641.npz", +} + +KEYWORDS_VOCABULARY = "data/keyword_vocabulary_safety_filtered_58641.txt" +KEYWORDS_IDF = "data/keyword_idf_safety_filtered_58641.npy" + +RESID_CSV = "data/uniref90_and_mgnify90_residue_annotations_gt_1k_proteins.csv" +INTERPRO2KEYWORDS = "data/interpro_29026_to_keywords_58641.csv" diff --git a/esm/utils/constants/models.py b/esm/utils/constants/models.py new file mode 100644 index 0000000..c72b922 --- /dev/null +++ b/esm/utils/constants/models.py @@ -0,0 +1,5 @@ +# Model names +ESM3_OPEN_SMALL = "esm3_sm_open_v1" +ESM3_STRUCTURE_ENCODER_V0 = "esm3_structure_encoder_v0" +ESM3_STRUCTURE_DECODER_V0 = "esm3_structure_decoder_v0" +ESM3_FUNCTION_DECODER_V0 = "esm3_function_decoder_v0" diff --git a/esm/utils/constants/physics.py b/esm/utils/constants/physics.py new file mode 100644 index 0000000..4130016 --- /dev/null +++ b/esm/utils/constants/physics.py @@ -0,0 +1,5 @@ +BB_COORDINATES = [ + [0.5256, 1.3612, 0.0000], + [0.0000, 0.0000, 0.0000], + [-1.5251, 0.0000, 0.0000], +] diff --git a/esm/utils/decoding.py b/esm/utils/decoding.py new file mode 100644 index 0000000..c65f057 --- /dev/null +++ b/esm/utils/decoding.py @@ -0,0 +1,225 @@ +import warnings + +import attr +import torch + +from esm.models.function_decoder import FunctionTokenDecoder +from esm.models.vqvae import StructureTokenDecoder +from esm.sdk.api import ESMProtein, ESMProteinTensor +from esm.tokenization import TokenizerCollectionProtocol +from esm.tokenization.function_tokenizer import ( + InterProQuantizedTokenizer, +) +from esm.tokenization.residue_tokenizer import ( + ResidueAnnotationsTokenizer, +) +from esm.tokenization.sasa_tokenizer import ( + SASADiscretizingTokenizer, +) +from esm.tokenization.sequence_tokenizer import ( + EsmSequenceTokenizer, +) +from esm.tokenization.ss_tokenizer import ( + SecondaryStructureTokenizer, +) +from esm.tokenization.structure_tokenizer import ( + StructureTokenizer, +) +from esm.tokenization.tokenizer_base import EsmTokenizerBase +from esm.utils.constants import esm3 as C +from esm.utils.function.encode_decode import ( + decode_function_tokens, + decode_residue_annotation_tokens, +) +from esm.utils.structure.protein_chain import ProteinChain +from esm.utils.types import FunctionAnnotation + + +def decode_protein_tensor( + input: ESMProteinTensor, + tokenizers: TokenizerCollectionProtocol, + structure_token_decoder: StructureTokenDecoder, + function_token_decoder: FunctionTokenDecoder, +) -> ESMProtein: + input = attr.evolve(input) # Make a copy + + sequence = None + secondary_structure = None + sasa = None + function_annotations = [] + + coordinates = None + + # If all pad tokens, set to None + for track in attr.fields(ESMProteinTensor): + tokens: torch.Tensor | None = getattr(input, track.name) + if track.name == "coordinates": + continue + if tokens is not None: + tokens = tokens[1:-1] # Remove BOS and EOS tokens + tokens = tokens.flatten() # For multi-track tensors + track_tokenizer = getattr(tokenizers, track.name) + if torch.all(tokens == track_tokenizer.pad_token_id): + setattr(input, track.name, None) + + if input.sequence is not None: + sequence = decode_sequence(input.sequence, tokenizers.sequence) + + plddt, ptm = None, None + if input.structure is not None: + # Note: We give priority to the structure tokens over the coordinates when decoding + coordinates, plddt, ptm = decode_structure( + structure_tokens=input.structure, + structure_decoder=structure_token_decoder, + structure_tokenizer=tokenizers.structure, + sequence=sequence, + ) + elif input.coordinates is not None: + coordinates = input.coordinates[1:-1, ...] + + if input.secondary_structure is not None: + secondary_structure = decode_secondary_structure( + input.secondary_structure, tokenizers.secondary_structure + ) + if input.sasa is not None: + sasa = decode_sasa(input.sasa, tokenizers.sasa) + if input.function is not None: + function_track_annotations = decode_function_annotations( + input.function, + function_token_decoder=function_token_decoder, + function_tokenizer=tokenizers.function, + ) + function_annotations.extend(function_track_annotations) + if input.residue_annotations is not None: + residue_annotations = decode_residue_annotations( + input.residue_annotations, tokenizers.residue_annotations + ) + function_annotations.extend(residue_annotations) + + return ESMProtein( + sequence=sequence, + secondary_structure=secondary_structure, + sasa=sasa, # type: ignore + function_annotations=function_annotations if function_annotations else None, + coordinates=coordinates, + plddt=plddt, + ptm=ptm, + ) + + +def _bos_eos_warn(msg: str, tensor: torch.Tensor, tok: EsmTokenizerBase): + if tensor[0] != tok.bos_token_id: + warnings.warn( + f"{msg} does not start with BOS token, token is ignored. BOS={tok.bos_token_id} vs {tensor}" + ) + if tensor[-1] != tok.eos_token_id: + warnings.warn( + f"{msg} does not end with EOS token, token is ignored. EOS='{tok.eos_token_id}': {tensor}" + ) + + +def decode_sequence( + sequence_tokens: torch.Tensor, + sequence_tokenizer: EsmSequenceTokenizer, + **kwargs, +) -> str: + _bos_eos_warn("Sequence", sequence_tokens, sequence_tokenizer) + sequence = sequence_tokenizer.decode( + sequence_tokens, + **kwargs, + ) + sequence = sequence.replace(" ", "") + sequence = sequence.replace(sequence_tokenizer.mask_token, C.MASK_STR_SHORT) + sequence = sequence.replace(sequence_tokenizer.cls_token, "") + sequence = sequence.replace(sequence_tokenizer.eos_token, "") + + return sequence + + +def decode_structure( + structure_tokens: torch.Tensor, + structure_decoder: StructureTokenDecoder, + structure_tokenizer: StructureTokenizer, + sequence: str | None = None, +) -> tuple[torch.Tensor, torch.Tensor | None, torch.Tensor | None]: + is_singleton = len(structure_tokens.size()) == 1 + if is_singleton: + structure_tokens = structure_tokens.unsqueeze(0) + else: + raise ValueError( + f"Only one structure can be decoded at a time, got structure tokens of shape {structure_tokens.size()}" + ) + _bos_eos_warn("Structure", structure_tokens[0], structure_tokenizer) + + decoder_output = structure_decoder.decode(structure_tokens) + bb_coords: torch.Tensor = decoder_output["bb_pred"][ + 0, 1:-1, ... + ] # Remove BOS and EOS tokens + bb_coords = bb_coords.detach().cpu() + + if "plddt" in decoder_output: + plddt = decoder_output["plddt"][0, 1:-1] + plddt = plddt.detach().cpu() + else: + plddt = None + + if "ptm" in decoder_output: + ptm = decoder_output["ptm"] + else: + ptm = None + + chain = ProteinChain.from_backbone_atom_coordinates(bb_coords, sequence=sequence) + chain = chain.infer_oxygen() + return torch.tensor(chain.atom37_positions), plddt, ptm + + +def decode_secondary_structure( + secondary_structure_tokens: torch.Tensor, + ss_tokenizer: SecondaryStructureTokenizer, +) -> str: + _bos_eos_warn("Secondary structure", secondary_structure_tokens, ss_tokenizer) + secondary_structure_tokens = secondary_structure_tokens[1:-1] + secondary_structure = ss_tokenizer.decode( + secondary_structure_tokens, + ) + return secondary_structure + + +def decode_sasa( + sasa_tokens: torch.Tensor, + sasa_tokenizer: SASADiscretizingTokenizer, +) -> list[float]: + _bos_eos_warn("SASA", sasa_tokens, sasa_tokenizer) + sasa_tokens = sasa_tokens[1:-1] + + return sasa_tokenizer.decode_float(sasa_tokens) + + +def decode_function_annotations( + function_annotation_tokens: torch.Tensor, + function_token_decoder: FunctionTokenDecoder, + function_tokenizer: InterProQuantizedTokenizer, + **kwargs, +) -> list[FunctionAnnotation]: + # No need to check for BOS/EOS as function annotations are not affected + + function_annotations = decode_function_tokens( + function_annotation_tokens, + function_token_decoder=function_token_decoder, + function_tokens_tokenizer=function_tokenizer, + **kwargs, + ) + return function_annotations + + +def decode_residue_annotations( + residue_annotation_tokens: torch.Tensor, + residue_annotation_decoder: ResidueAnnotationsTokenizer, +) -> list[FunctionAnnotation]: + # No need to check for BOS/EOS as function annotations are not affected + + residue_annotations = decode_residue_annotation_tokens( + residue_annotations_token_ids=residue_annotation_tokens, + residue_annotations_tokenizer=residue_annotation_decoder, + ) + return residue_annotations diff --git a/esm/utils/encoding.py b/esm/utils/encoding.py new file mode 100644 index 0000000..97555e0 --- /dev/null +++ b/esm/utils/encoding.py @@ -0,0 +1,241 @@ +from typing import Sequence + +import torch +import torch.nn.functional as F + +from esm.models.vqvae import StructureTokenEncoder +from esm.tokenization.function_tokenizer import ( + InterProQuantizedTokenizer as EsmFunctionTokenizer, +) +from esm.tokenization.residue_tokenizer import ( + ResidueAnnotationsTokenizer, +) +from esm.tokenization.sasa_tokenizer import ( + SASADiscretizingTokenizer, +) +from esm.tokenization.sequence_tokenizer import ( + EsmSequenceTokenizer, +) +from esm.tokenization.ss_tokenizer import ( + SecondaryStructureTokenizer, +) +from esm.tokenization.structure_tokenizer import ( + StructureTokenizer, +) +from esm.utils.constants import esm3 as C +from esm.utils.function.encode_decode import ( + encode_function_annotations, +) +from esm.utils.structure.protein_chain import ProteinChain +from esm.utils.types import FunctionAnnotation + + +# Raw Defaults +def get_default_sequence(sequence_length: int) -> str: + return C.MASK_STR_SHORT * sequence_length + + +def get_default_secondary_structure(sequence_length: int) -> str: + return C.MASK_STR_SHORT * sequence_length + + +def get_default_sasa(sequence_length: int) -> Sequence[float | str | None]: + return [None] * sequence_length + + +# Tokenization +def tokenize_sequence( + sequence: str, + sequence_tokenizer: EsmSequenceTokenizer, + add_special_tokens: bool = True, +) -> torch.Tensor: + sequence = sequence.replace(C.MASK_STR_SHORT, sequence_tokenizer.mask_token) + sequence_tokens = sequence_tokenizer.encode( + sequence, add_special_tokens=add_special_tokens + ) + sequence_tokens = torch.tensor(sequence_tokens, dtype=torch.int64) + return sequence_tokens + + +def tokenize_structure( + coordinates: torch.Tensor, + structure_encoder: StructureTokenEncoder, + structure_tokenizer: StructureTokenizer, + reference_sequence: str = "", + add_special_tokens: bool = True, +) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + device = next(structure_encoder.parameters()).device + chain = ProteinChain.from_atom37( + coordinates, sequence=reference_sequence if reference_sequence else None + ) + + # Setup padding + if reference_sequence and len(reference_sequence) != coordinates.size(0): + raise ValueError( + f"Reference sequence length ({len(reference_sequence)}) does not match the number of residues in the coordinates ({coordinates.size(0)})" + ) + + left_pad = 0 + right_pad = 0 + + if add_special_tokens: + left_pad += 1 # Add space for BOS token + right_pad += 1 # Add space for EOS token + + coordinates, plddt, residue_index = chain.to_structure_encoder_inputs() + coordinates = coordinates.to(device) # (1, L, 37, 3) + plddt = plddt.to(device) # (1, L) + residue_index = residue_index.to(device) # (1, L) + _, structure_tokens = structure_encoder.encode( + coordinates, residue_index=residue_index + ) + coordinates = torch.squeeze(coordinates, dim=0) # (L, 37, 3) # type: ignore + plddt = torch.squeeze(plddt, dim=0) # (L,) # type: ignore + structure_tokens = torch.squeeze(structure_tokens, dim=0) # (L,) # type: ignore + + # Add space for BOS and EOS tokens + if add_special_tokens: + coordinates = F.pad( + coordinates, + (0, 0, 0, 0, left_pad, right_pad), + value=torch.inf, + ) + plddt = F.pad(plddt, (left_pad, right_pad), value=0) + structure_tokens = F.pad( + structure_tokens, + (left_pad, right_pad), + value=structure_tokenizer.pad_token_id, + ) + structure_tokens[0] = structure_tokenizer.bos_token_id + structure_tokens[-1] = structure_tokenizer.eos_token_id + return coordinates, plddt, structure_tokens + + +def tokenize_secondary_structure( + secondary_structure: str | Sequence[str], + secondary_structure_tokenizer: SecondaryStructureTokenizer, + add_special_tokens: bool = True, +) -> torch.Tensor: + if isinstance(secondary_structure, str): + # Ensure only one char per token + secondary_structure = secondary_structure.replace( + secondary_structure_tokenizer.mask_token, C.MASK_STR_SHORT + ) + + # Input as list of chars + secondary_structure = [char for char in secondary_structure] + + # Use tokenizer's mask token + secondary_structure = [ + secondary_structure_tokenizer.mask_token if char == C.MASK_STR_SHORT else char + for char in secondary_structure + ] + + secondary_structure_tokens = secondary_structure_tokenizer.encode( + secondary_structure, add_special_tokens=add_special_tokens + ) + return secondary_structure_tokens + + +def tokenize_sasa( + sasa: Sequence[float | str | None], + sasa_tokenizer: SASADiscretizingTokenizer, + add_special_tokens: bool = True, +): + sasa_tokens = sasa_tokenizer.encode( + [sasa_tokenizer.mask_token if value is None else value for value in sasa], + add_special_tokens=add_special_tokens, + ) + return sasa_tokens + + +def tokenize_function_annotations( + function_annotations: Sequence[FunctionAnnotation], + reference_sequence: str, + function_tokenizer: EsmFunctionTokenizer, + residue_annotation_tokenizer: ResidueAnnotationsTokenizer, + add_special_tokens: bool = True, +) -> tuple[torch.Tensor, torch.Tensor]: + function_tokens, residue_annotation_tokens = encode_function_annotations( + sequence=reference_sequence, + function_annotations=function_annotations, + function_tokens_tokenizer=function_tokenizer, + residue_annotations_tokenizer=residue_annotation_tokenizer, + add_special_tokens=add_special_tokens, + ) + return function_tokens, residue_annotation_tokens + + +# Tokenized Defaults +def get_default_sequence_tokens( + sequence_length: int, + sequence_tokenizer: EsmSequenceTokenizer, +) -> torch.Tensor: + return tokenize_sequence( + get_default_sequence(sequence_length), + sequence_tokenizer, + add_special_tokens=True, + ) + + +def get_default_structure_tokens( + sequence_length: int, structure_tokenizer: StructureTokenizer +) -> torch.Tensor: + structure_tokens = ( + torch.ones( + (sequence_length + 2,), + dtype=torch.int64, + ) + * structure_tokenizer.pad_token_id + ) + # Always include BOS and EOS tokens + structure_tokens[0] = structure_tokenizer.bos_token_id + structure_tokens[-1] = structure_tokenizer.eos_token_id + return structure_tokens + + +def get_default_secondary_structure_tokens( + sequence_length: int, secondary_structure_tokenizer: SecondaryStructureTokenizer +) -> torch.Tensor: + return tokenize_secondary_structure( + get_default_secondary_structure(sequence_length), + secondary_structure_tokenizer, + add_special_tokens=True, + ) + + +def get_default_sasa_tokens( + sequence_length: int, sasa_tokenizer: SASADiscretizingTokenizer +) -> torch.Tensor: + return tokenize_sasa( + get_default_sasa(sequence_length), sasa_tokenizer, add_special_tokens=True + ) + + +def get_default_function_tokens( + sequence_length: int, function_tokenizer: EsmFunctionTokenizer +) -> torch.Tensor: + function_tokens = ( + torch.ones((sequence_length + 2, function_tokenizer.depth), dtype=torch.int64) + * function_tokenizer.pad_token_id + ) + # Always include BOS and EOS tokens + function_tokens[0] = function_tokenizer.bos_token_id + function_tokens[-1] = function_tokenizer.eos_token_id + return function_tokens + + +def get_default_residue_annotation_tokens( + sequence_length: int, residue_annotation_tokenizer: ResidueAnnotationsTokenizer +) -> torch.Tensor: + residue_annotation_tokens = ( + torch.ones( + (sequence_length + 2, C.MAX_RESIDUE_ANNOTATIONS), + dtype=torch.int64, + ) + * residue_annotation_tokenizer.pad_token_id + ) + # Always include BOS and EOS tokens + residue_annotation_tokens[0] = residue_annotation_tokenizer.bos_token_id + residue_annotation_tokens[-1] = residue_annotation_tokenizer.eos_token_id + return residue_annotation_tokens diff --git a/esm/utils/function/encode_decode.py b/esm/utils/function/encode_decode.py new file mode 100644 index 0000000..f8d57c7 --- /dev/null +++ b/esm/utils/function/encode_decode.py @@ -0,0 +1,187 @@ +import re +from typing import Sequence + +import torch + +from esm.models.function_decoder import ( + FunctionTokenDecoder, + _merge_annotations, +) +from esm.tokenization.function_tokenizer import ( + InterProQuantizedTokenizer, +) +from esm.tokenization.residue_tokenizer import ( + ResidueAnnotationsTokenizer, +) +from esm.utils.constants import esm3 as C +from esm.utils.types import FunctionAnnotation + + +def encode_function_annotations( + sequence: str, + function_annotations: Sequence[FunctionAnnotation], + function_tokens_tokenizer: InterProQuantizedTokenizer, + residue_annotations_tokenizer: ResidueAnnotationsTokenizer, + add_special_tokens: bool = True, +) -> tuple[torch.Tensor, torch.Tensor]: + assert isinstance( + residue_annotations_tokenizer, ResidueAnnotationsTokenizer + ), "residue_annotations_tokenizer must be of type ResidueAnnotationsTokenizer" + + # Split the user's annotations by type + ft_annotations: list[FunctionAnnotation] = [] + ra_annotations: list[FunctionAnnotation] = [] + for fa in function_annotations: + assert ( + 1 <= fa.start <= fa.end <= len(sequence) + ), f"Invalid (start, end) in function annotation {fa}. Indices 1-indexed and [inclusive, inclusive]" + + supported_label = False + + # Is it an InterPro label? + if match := re.match(r"IPR\d+", fa.label): + if match.group() in function_tokens_tokenizer.interpro_to_index: + ft_annotations.append(fa) + supported_label = True + + # Is it a function keyword? + if fa.label in function_tokens_tokenizer._tfidf.vocab_to_index: + ft_annotations.append(fa) + supported_label = True + + # Is it a residue annotation? + if fa.label in residue_annotations_tokenizer._labels: + ra_annotations.append(fa) + supported_label = True + + if not supported_label: + raise ValueError(f"Unknown label in FunctionAnnotation: {fa.label}") + + # Convert function token FunctionAnnotations -> Tensor + function_tokens = function_tokens_tokenizer.tokenize( + annotations=ft_annotations, + seqlen=len(sequence), + ) + function_token_ids = function_tokens_tokenizer.encode( + function_tokens, add_special_tokens=add_special_tokens + ) + + # Convert residue annotation FunctionAnnotations -> Tensor + if ra_annotations: + descriptions, starts, ends = zip( + *[(anot.label, anot.start, anot.end) for anot in ra_annotations] + ) + else: + descriptions = starts = ends = None + ra_tokens = residue_annotations_tokenizer.tokenize( + { + "interpro_site_descriptions": descriptions, + "interpro_site_starts": starts, + "interpro_site_ends": ends, + }, + sequence=sequence, + fail_on_mismatch=True, + ) + residue_annotation_ids = residue_annotations_tokenizer.encode( + ra_tokens, add_special_tokens=add_special_tokens + ) + + return function_token_ids, residue_annotation_ids + + +def decode_function_tokens( + function_token_ids: torch.Tensor, + function_token_decoder: FunctionTokenDecoder, + function_tokens_tokenizer: InterProQuantizedTokenizer, + decoder_annotation_threshold: float = 0.1, + annotation_min_length: int | None = 5, + annotation_gap_merge_max: int | None = 3, +) -> list[FunctionAnnotation]: + """Decodes model prediction logits into function predictions. + + Merges function token and residue annotation predictions into a single + set of FunctionAnnotation predictions. + + Args: + function_token_ids: Tensor [length, depth] of + function token ids. + residue_annotation_logits: Tensor [length, RA-vocab] of residue + annotation binary classification logits. + function_tokens_tokenizer: InterPro annotation tokenizer. + residue_annotation_threshold: tokenizer of residue annotations. + residue_annotation_threshold: predicted probability threshold for emitting + a predicted residue annotation. + Returns: + Predicted function annotations merged from both predictions. + """ + assert ( + function_token_ids.ndim == 2 + ), "function_token_ids must be of shape (length, depth)" + + annotations: list[FunctionAnnotation] = [] + + # Function Annotations from predicted function tokens. + decoded = function_token_decoder.decode( + function_token_ids, + tokenizer=function_tokens_tokenizer, + annotation_threshold=decoder_annotation_threshold, + annotation_min_length=annotation_min_length, + annotation_gap_merge_max=annotation_gap_merge_max, + ) + + # Convert predicted InterPro annotation to FunctionAnnotation. + annotations.extend(decoded["function_keywords"]) + for annotation in decoded["interpro_annotations"]: + annotation: FunctionAnnotation + label = function_tokens_tokenizer.format_annotation(annotation) + annotations.append( + FunctionAnnotation(label=label, start=annotation.start, end=annotation.end) + ) + + return annotations + + +def decode_residue_annotation_tokens( + residue_annotations_token_ids: torch.Tensor, + residue_annotations_tokenizer: ResidueAnnotationsTokenizer, + annotation_min_length: int | None = 5, + annotation_gap_merge_max: int | None = 3, +) -> list[FunctionAnnotation]: + """Decodes residue annotation tokens into FunctionAnnotations. + + Args: + tokens: Tensor [length, MAX_RESIDUE_ANNOTATIONS] of residue annotation tokens. + residue_annotations_tokenizer: Tokenizer of residue annotations. + threshold: predicted probability threshold for emitting a predicted residue + annotation. + Returns: + Predicted residue annotations. + """ + assert ( + residue_annotations_token_ids.ndim == 2 + ), "logits must be of shape (length, MAX_RESIDUE_ANNOTATIONS)" + + annotations: list[FunctionAnnotation] = [] + + for depth in range(0, C.MAX_RESIDUE_ANNOTATIONS): + token_ids = residue_annotations_token_ids[:, depth] + for loc, vocab_index in torch.nonzero(token_ids).cpu().numpy(): + label = residue_annotations_tokenizer.vocabulary[vocab_index] + if label not in [*residue_annotations_tokenizer.special_tokens, ""]: + annotation = FunctionAnnotation(label=label, start=loc, end=loc) + annotations.append(annotation) + + annotations = _merge_annotations( + annotations, + merge_gap_max=annotation_gap_merge_max, + ) + + # Drop very small annotations. + if annotation_min_length is not None: + annotations = [ + annotation + for annotation in annotations + if annotation.end - annotation.start + 1 >= annotation_min_length + ] + + return annotations diff --git a/esm/utils/function/interpro.py b/esm/utils/function/interpro.py new file mode 100644 index 0000000..ccfb8e0 --- /dev/null +++ b/esm/utils/function/interpro.py @@ -0,0 +1,245 @@ +"""Utilities for interacting with InterPro.""" + +import itertools +import re +from dataclasses import dataclass +from enum import IntEnum, auto +from functools import cached_property +from pathlib import Path + +import networkx as nx +import numpy as np +import pandas as pd + +from esm.utils.constants import esm3 as C + + +def parse_go_terms(text: str) -> list[str]: + """Parses GO terms from a string. + + Args: + text: String containing GO terms. Example: "GO:0008309, GO:1902267" Note that GO + terms have exactly 7 digits. + Returns: + All GO terms found in the string. Example: ['GO:0008309', 'GO:1902267'] + """ + return re.findall(r"GO:(?:\d{7,})", text) + + +def _parse_interpro2go(path: str) -> dict[str, list[str]]: + """Parses InterPro2GO file into map. + + NOTE: this file has a very strange, non-standard format. + + Args: + path: path to InterPro2GO file from: https://www.ebi.ac.uk/GOA/InterPro2GO + Returns: + Mapping from InterPro to list of associated GO terms. + """ + with Path(path).open("r") as f: + text = f.read() + df = pd.Series(text.split("\n"), name="line").to_frame() + df = df[~df.line.str.startswith("!")] + df["interpro_id"] = df.line.apply(lambda line: re.findall(r"IPR\d+", line)) + df["go_ids"] = df.line.apply(parse_go_terms) + df = df[df.go_ids.apply(len).gt(0) & df.interpro_id.apply(len).eq(1)] + df["interpro_id"] = df["interpro_id"].apply(lambda xs: xs[0]) # type: ignore + + # Group all mappints together into a single map. + df = ( + df.groupby("interpro_id")["go_ids"] # type: ignore + .apply(lambda group: list(itertools.chain.from_iterable(group))) + .reset_index() + ) + return dict(zip(df.interpro_id, df.go_ids)) # type: ignore + + +class InterProEntryType(IntEnum): + """InterPro types and representation counts: + + Family 21,942 + Domain 14,053 + Homologous_superfamily 3,446 + Conserved_site 728 + Repeat 374 + Active_site 133 + Binding_site 75 + PTM 17 + """ + + ACTIVE_SITE = 0 + BINDING_SITE = auto() + CONSERVED_SITE = auto() + DOMAIN = auto() + FAMILY = auto() + HOMOLOGOUS_SUPERFAMILY = auto() + PTM = auto() + REPEAT = auto() + UNKNOWN = auto() + + +@dataclass +class InterProEntry: + """Represents an InterPro entry.""" + + id: str # Example: IPR000006 + type: InterProEntryType + name: str # Example: "Metallothionein, vertebrate" + description: str | None = None + + +@dataclass(frozen=True) +class InterProRangeAnnotation: + """Represents a InterPro annotation along a range of residues in a protein.""" + + interpro_accession: str + start_idx: int + end_idx: int + + +class InterPro: + """Convenience class interacting with InterPro ontology/data.""" + + def __init__( + self, + entries_path: str | None = None, + hierarchy_path: str | None = None, + interpro2go_path: str | None = None, + ): + """Constructs interface to query InterPro entries.""" + default = lambda x, d: x if x is not None else d + self.entries_path = default(entries_path, str(C.data_root() / C.INTERPRO_ENTRY)) + self.hierarchy_graph_path = default( + hierarchy_path, str(C.data_root() / C.INTERPRO_HIERARCHY) + ) + self.interpro2go_path = default( + interpro2go_path, str(C.data_root() / C.INTERPRO2GO) + ) + + @cached_property + def interpro2go(self) -> dict[str, list[str]]: + """Reads the InterPro to GO term mapping.""" + assert self.interpro2go_path is not None + return _parse_interpro2go(self.interpro2go_path) + + @cached_property + def entries_frame(self) -> pd.DataFrame: + """Loads full InterPro entry set as a DataFrame. + + Colums are + - "id": str interpro accession /id as + - "type": InterProEntryType representing the type of annotation. + - "name": Short name of the entry. + """ + with Path(self.entries_path).open("r") as f: + df = pd.read_csv(f, sep="\t") + assert all( + col in df.columns for col in ["ENTRY_AC", "ENTRY_TYPE", "ENTRY_NAME"] + ) + df.rename( + columns={ + "ENTRY_AC": "id", + "ENTRY_TYPE": "type", + "ENTRY_NAME": "name", + }, + inplace=True, + ) + df["type"] = df.type.str.upper().apply( + lambda type_name: InterProEntryType[type_name] + ) + return df + + @cached_property + def entries(self) -> dict[str, InterProEntry]: + """Returns all InterPro entries.""" + return { + row.id: InterProEntry( # type: ignore + id=row.id, # type: ignore + type=row.type, # type: ignore + name=row.name, # type: ignore + ) + for row in self.entries_frame.itertuples() + } + + def lookup_name(self, interpro_id: str) -> str | None: + """Short name / title for an interpro id.""" + if interpro_id not in self.entries: + return None + return self.entries[interpro_id].name + + def lookup_entry_type(self, interpro_id: str) -> InterProEntryType: + """Looks up entry-type for an interpro id.""" + if interpro_id in self.entries: + return self.entries[interpro_id].type + else: + return InterProEntryType.UNKNOWN + + @cached_property + def graph(self) -> nx.DiGraph: + """Reads the InterPro hierarchy of InterPro.""" + graph = nx.DiGraph() + with Path(self.hierarchy_graph_path).open("r") as f: + parents = [] + for line in f: + ipr = line.split("::", maxsplit=1)[0] + ipr_strip = ipr.lstrip("-") + level = (len(ipr) - len(ipr_strip)) // 2 + parents = parents[:level] + graph.add_node(ipr_strip) + if parents: + graph.add_edge(ipr_strip, parents[-1]) + parents.append(ipr_strip) + return graph + + +def parse_interpro_features( + interpro_accessions: list[str], + interpro_starts: list[int], + interpro_ends: list[int], +) -> list[InterProRangeAnnotation]: + """Parses raw InterPro ranges. + + Args: + interpro_accessions: list of InterPro accessions + interpro_starts: list of one-indexed inclusive residue locations where the + annotation from `interpro_accesisons` begin. + interpro_ends: list of one-indexed *inclusive* residue locations where the + annotation from `interpro_accesisons` end. + Returns: + Collated InterProRangeAnnotations. NOTE that index conversion will convert range + bounds to zero-indexed [inclusive, exclusive) start/end indices. + """ + assert len(interpro_accessions) == len(interpro_starts) == len(interpro_ends) + + # Residue locations from Uniprot/InterPro are [inclusive, inclusive] and 1-index. + start_idcs = np.array(interpro_starts).astype(int) + end_idcs = np.array(interpro_ends).astype(int) + + # We want to use Python's convention of [inclusive, exclusive) and 0-indexing. + # Interpro residue indices are [inclusive, inclusive] and 1-indexing. + # The conversion ends up being: + # ```python + # end_idcs += 1 # [inclusive, inclusive] -> [inclusive, exclusive) + # start_idcs -= 1 # 1 -> 0 indexing + # end_idcs -= 1 # 1 -> 0 indexing + # ``` + # Which simply results in: + start_idcs -= 1 + + ranges = [] + for interpro_accession, start_idx, end_idx in zip( + interpro_accessions, start_idcs, end_idcs + ): + # NOTE: Skip unintegrated Interpro labels, for now. + if interpro_accession == "-": + continue + + ranges.append( + InterProRangeAnnotation( + interpro_accession=interpro_accession, + start_idx=start_idx, + end_idx=end_idx, + ) + ) + + return ranges diff --git a/esm/utils/function/lsh.py b/esm/utils/function/lsh.py new file mode 100644 index 0000000..60e7e45 --- /dev/null +++ b/esm/utils/function/lsh.py @@ -0,0 +1,103 @@ +from pathlib import Path + +import numpy as np + +from esm.utils.types import PathLike + + +class LSHTable: + def __init__(self, n_bits: int, dim: int, hyperplanes: np.ndarray | None = None): + if hyperplanes is None: + hyperplanes = np.random.randn(n_bits, dim) + hyperplanes = hyperplanes / np.linalg.norm( + hyperplanes, axis=-1, keepdims=True + ) + else: + assert hyperplanes.shape == (n_bits, dim), ( + hyperplanes.shape, + (n_bits, dim), + ) + assert hyperplanes is not None + self.hyperplanes: np.ndarray = hyperplanes + self.values = 1 << np.arange(n_bits) + + def __call__(self, array, tokenize: bool = True): + similarity = self.hyperplanes @ array.T + bits = np.where(similarity >= 0, 1, 0) + if tokenize: + tokens = bits.T @ self.values + return tokens + else: + return bits.T + + +class LSHTokenized: + def __init__( + self, + n_bits: int, + dim: int, + num_tables: int = 1, + filepath: PathLike | None = None, + allow_create_hyperplanes: bool = False, # set this if you want the lsh to allow creation of hyperplanes + ): + table_hyperplanes = None + if filepath is not None: + filepath = Path(filepath) + if not filepath.exists(): + raise FileNotFoundError(filepath) + table_hyperplanes = np.load(filepath) # type: ignore + for i in range(num_tables): + assert str(i) in table_hyperplanes, f"Missing hyperplane for table {i}" + elif not allow_create_hyperplanes: + raise RuntimeError( + "Not allowed to create hyperplanes but no filepath provided" + ) + + self.tables = [ + LSHTable( + n_bits, + dim, + table_hyperplanes[str(i)] if table_hyperplanes is not None else None, + ) + for i in range(num_tables) + ] + + def write_hyperplanes(self, filepath: PathLike): + hyperplanes: dict[str, np.ndarray] = { # type: ignore + str(i): table.hyperplanes for i, table in enumerate(self.tables) + } + np.savez(filepath, **hyperplanes) + + def __call__(self, array): + tokens = np.stack([table(array) for table in self.tables], 1) + return tokens + + +class LSHBitstream: + def __init__( + self, + n_bits: int, + dim: int, + filepath: PathLike | None = None, + allow_create_hyperplanes: bool = False, # set this if you want the lsh to allow creation of hyperplanes + ): + table_hyperplanes = None + if filepath is not None: + filepath = Path(filepath) + if not filepath.exists(): + raise FileNotFoundError(filepath) + table_hyperplanes = np.load(filepath) + elif not allow_create_hyperplanes: + raise RuntimeError( + "Not allowed to create hyperplanes but no filepath provided" + ) + + self.table = LSHTable( + n_bits, dim, table_hyperplanes if table_hyperplanes is not None else None + ) + + def write_hyperplanes(self, filepath: PathLike): + np.save(filepath, self.table.hyperplanes) + + def __call__(self, array): + return self.table(array, tokenize=False) diff --git a/esm/utils/function/tfidf.py b/esm/utils/function/tfidf.py new file mode 100644 index 0000000..bd9282e --- /dev/null +++ b/esm/utils/function/tfidf.py @@ -0,0 +1,56 @@ +"""Term-Frequency / Inverse Document Frequency (TF-IDF) model.""" + +from collections import Counter +from functools import cached_property + +import numpy as np +from scipy import sparse + + +class TFIDFModel: + """Term-Frequency / Inverse Document Frequency (TF-IDF) model. + Mimics sklearn.feature_extraction.text.TfidfVectorizer with sublinear_tf=True + """ + + def __init__(self, vocabulary_path: str, idf_path: str): + with open(vocabulary_path, "r") as f: + self.vocabulary = f.read().strip().split("\n") + + with open(idf_path, "rb") as f: + self.idf_ = np.load(f) + + assert self.idf_.ndim == 1 + assert ( + len(self.idf_) == len(self.vocabulary) + ), f"IDF size must match vocabulary size, got {len(self.idf_)} and {len(self.vocabulary)}" + + @cached_property + def vocab_to_index(self) -> dict[str, int]: + return {term: index for index, term in enumerate(self.vocabulary)} + + def encode(self, terms: list[str]) -> sparse.csr_matrix: + """Encodes terms as TF-IDF vectors. + + Args: + terms: list of terms to encode. + + Returns: + TF-IDF vector encoded as sparse matrix of shape (1, num_terms) + """ + counter = Counter(filter(self.vocabulary.__contains__, terms)) + indices = [self.vocab_to_index[term] for term in counter] + + tf = np.array([count for term, count in counter.items()]) + idf = np.take(self.idf_, indices) + + values = (1 + np.log(tf)) * idf + values /= np.linalg.norm(values) + + return sparse.csr_matrix( + (values, (np.zeros_like(indices), indices)), + shape=(1, len(self.vocabulary)), + ) + + def decode(self, vec: sparse.csr_matrix) -> list[str]: + """Extract terms from TF-IDF.""" + return [self.vocabulary[i] for i in vec.indices] diff --git a/esm/utils/generation.py b/esm/utils/generation.py new file mode 100644 index 0000000..a6f9b5a --- /dev/null +++ b/esm/utils/generation.py @@ -0,0 +1,185 @@ +from typing import Callable + +import attr +import torch +from tqdm import tqdm + +from esm.sdk.api import ( + ESM3InferenceClient, + ESMProtein, + ESMProteinTensor, + GenerationConfig, + SamplingConfig, + SamplingTrackConfig, +) +from esm.tokenization import ( + EsmTokenizerBase, + TokenizerCollectionProtocol, +) +from esm.utils.constants import esm3 as C +from esm.utils.noise_schedules import NOISE_SCHEDULE_REGISTRY + + +def iterative_sampling_raw( + client: ESM3InferenceClient, + input: ESMProtein, + config: GenerationConfig, +): + # Keep structure tokens + input_tokens = client.encode(input) + + output_tokens = client.generate(input_tokens, config) + + raw_protein = client.decode(output_tokens) + + track_to_sample = config.track + + if track_to_sample not in ["function", "residue_annotations"]: + # Function and residue annotation encoding/decoding is lossy + # There is no guarantee that decoding encoded tokens will yield the same input + raw_protein.function_annotations = input.function_annotations + + return raw_protein + + +def iterative_sampling_tokens( + client: ESM3InferenceClient, + input_tokens: ESMProteinTensor, + config: GenerationConfig, + tokenizers: TokenizerCollectionProtocol, +) -> ESMProteinTensor: + track_to_sample = config.track + + # Get all tracks that require sampling + all_tracks = [ + f.name for f in attr.fields(SamplingConfig) if "embedding" not in f.name + ] + + sequence_length = len(input_tokens) + device = input_tokens.device + + # Initialize schedule and masks + decoding_schedule = NOISE_SCHEDULE_REGISTRY[config.schedule] + sampled_tokens = attr.evolve(input_tokens) # Make a copy + + if config.condition_on_coordinates_only and input_tokens.coordinates is not None: + sampled_tokens.structure = None + + sampling_mask = torch.ones( + sequence_length, + dtype=torch.bool, + device=device, + ) + sampling_mask[0] = False + sampling_mask[-1] = False + + get_tokenizer: Callable[[str], EsmTokenizerBase] = lambda s: getattr(tokenizers, s) + if getattr(sampled_tokens, track_to_sample) is None: + if track_to_sample == "function": + dims = (sequence_length, tokenizers.function.depth) + elif track_to_sample == "residue_annotations": + dims = (sequence_length, C.MAX_RESIDUE_ANNOTATIONS) + else: + dims = (sequence_length,) + masked_tokens = torch.full( + dims, + get_tokenizer(track_to_sample).mask_token_id, + dtype=torch.long, + device=device, + ) + if track_to_sample == "sequence": + masked_tokens[0] = tokenizers.sequence.cls_token_id # type: ignore + masked_tokens[-1] = tokenizers.sequence.eos_token_id # type: ignore + else: + masked_tokens[0] = get_tokenizer(track_to_sample).bos_token_id + masked_tokens[-1] = get_tokenizer(track_to_sample).eos_token_id + + setattr( + sampled_tokens, + track_to_sample, + masked_tokens, + ) + else: + is_mask: torch.Tensor = ( + getattr(input_tokens, track_to_sample) + == get_tokenizer(track_to_sample).mask_token_id + ) + if not is_mask.any().item(): + raise ValueError(f"Cannot sample {config.track} when input has no masks.") + sampling_mask = sampling_mask & is_mask + + # Decode + + def maybe_clone(x: torch.Tensor | None) -> torch.Tensor | None: + return x.clone() if x is not None else None + + L = sequence_length - 2 + positions_sampled = 0 + for t in tqdm(range(config.num_steps)): + # Single step sampling at all positions + track_sample_config = SamplingTrackConfig() + track_sample_config.invalid_ids = config.invalid_ids + track_sample_config.temperature = config.temperature + track_sample_config.top_p = config.top_p + sampling_config = SamplingConfig(**{track_to_sample: track_sample_config}) # type: ignore + + forward_and_sample_output = client.forward_and_sample( + sampled_tokens, sampling_config + ) + new_samples = forward_and_sample_output.protein_tensor + + # Calculate number of tokens to sample + perc_masked = decoding_schedule(torch.tensor((t + 1) / config.num_steps)) + num_to_sample = int((1 - perc_masked) * L) - positions_sampled + positions_sampled += num_to_sample + + # Select tokens based on lowest entropy + if track_to_sample in ["function", "residue_annotations"]: + # TODO: Implement iterative decoding for function and residue_annotations + # TODO: Fix encode/decode of interpro tokens (not yet supported) + sampled_tokens.function = maybe_clone(input_tokens.function) + sampled_tokens.residue_annotations = maybe_clone( + input_tokens.residue_annotations + ) + if track_to_sample in track_to_sample: + raise NotImplementedError( + f"Iterative decoding for {track_to_sample} is not supported yet." + ) + continue + + sampling_mask = sampling_mask & ( + getattr(sampled_tokens, track_to_sample) + == get_tokenizer(track_to_sample).mask_token_id + ) + + track_entropy: torch.Tensor = getattr( + forward_and_sample_output.entropy, track_to_sample + ) + track_entropy = track_entropy.masked_fill( + ~sampling_mask, torch.finfo(track_entropy.dtype).max + ) + _, indices = track_entropy.topk(num_to_sample, dim=-1, largest=False) + is_top_k = ~( + torch.arange(sequence_length, device=device)[:, None] != indices[None, :] + ).all(-1) + tokens_to_sample = sampling_mask & is_top_k + + old_track_samples = getattr(sampled_tokens, track_to_sample) + new_track_samples = getattr(new_samples, track_to_sample) + + new_track_samples = torch.where( + tokens_to_sample, new_track_samples, old_track_samples + ) + + setattr(sampled_tokens, track_to_sample, new_track_samples) + + # Do not update tracks that were not sampled (e.g. keep None instead of masks) + for track in all_tracks: + if track != track_to_sample: + setattr( + sampled_tokens, + track, + maybe_clone(getattr(input_tokens, track)), + ) + + return sampled_tokens diff --git a/esm/utils/misc.py b/esm/utils/misc.py new file mode 100644 index 0000000..5e168c2 --- /dev/null +++ b/esm/utils/misc.py @@ -0,0 +1,256 @@ +import math +from typing import ContextManager, Sequence, TypeVar + +import numpy as np +import torch + +MAX_SUPPORTED_DISTANCE = 1e6 + + +TSequence = TypeVar("TSequence", bound=Sequence) + + +def slice_python_object_as_numpy( + obj: TSequence, idx: int | list[int] | slice | np.ndarray +) -> TSequence: + """ + Slice a python object (like a list, string, or tuple) as if it was a numpy object. + + Example: + >>> obj = "ABCDE" + >>> slice_python_object_as_numpy(obj, [1, 3, 4]) + "BDE" + + >>> obj = [1, 2, 3, 4, 5] + >>> slice_python_object_as_numpy(obj, np.arange(5) < 3) + [1, 2, 3] + """ + if isinstance(idx, int): + idx = [idx] + + if isinstance(idx, np.ndarray) and idx.dtype == bool: + sliced_obj = [obj[i] for i in np.where(idx)[0]] + elif isinstance(idx, slice): + sliced_obj = obj[idx] + else: + sliced_obj = [obj[i] for i in idx] + + match obj, sliced_obj: + case str(), list(): + sliced_obj = "".join(sliced_obj) + case _: + sliced_obj = obj.__class__(sliced_obj) # type: ignore + + return sliced_obj # type: ignore + + +def rbf(values, v_min, v_max, n_bins=16): + """ + Returns RBF encodings in a new dimension at the end. + """ + rbf_centers = torch.linspace( + v_min, v_max, n_bins, device=values.device, dtype=values.dtype + ) + rbf_centers = rbf_centers.view([1] * len(values.shape) + [-1]) + rbf_std = (v_max - v_min) / n_bins + z = (values.unsqueeze(-1) - rbf_centers) / rbf_std + return torch.exp(-(z**2)) + + +def batched_gather(data, inds, dim=0, no_batch_dims=0): + ranges = [] + for i, s in enumerate(data.shape[:no_batch_dims]): + r = torch.arange(s) + r = r.view(*(*((1,) * i), -1, *((1,) * (len(inds.shape) - i - 1)))) + ranges.append(r) + + remaining_dims = [slice(None) for _ in range(len(data.shape) - no_batch_dims)] + remaining_dims[dim - no_batch_dims if dim >= 0 else dim] = inds + ranges.extend(remaining_dims) + return data[ranges] + + +def node_gather(s: torch.Tensor, edges: torch.Tensor) -> torch.Tensor: + return batched_gather(s.unsqueeze(-3), edges, -2, no_batch_dims=len(s.shape) - 1) + + +def knn_graph( + coords: torch.Tensor, + coord_mask: torch.Tensor, + padding_mask: torch.Tensor, + sequence_id: torch.Tensor, + *, + no_knn: int, +): + L = coords.shape[-2] + num_by_dist = min(no_knn, L) + device = coords.device + + coords = coords.nan_to_num() + coord_mask = ~(coord_mask[..., None, :] & coord_mask[..., :, None]) + padding_pairwise_mask = padding_mask[..., None, :] | padding_mask[..., :, None] + if sequence_id is not None: + padding_pairwise_mask |= torch.unsqueeze(sequence_id, 1) != torch.unsqueeze( + sequence_id, 2 + ) + dists = (coords.unsqueeze(-2) - coords.unsqueeze(-3)).norm(dim=-1) + arange = torch.arange(L, device=device) + seq_dists = (arange.unsqueeze(-1) - arange.unsqueeze(-2)).abs() + # We only support up to a certain distance, above that, we use sequence distance + # instead. This is so that when a large portion of the structure is masked out, + # the edges are built according to sequence distance. + max_dist = MAX_SUPPORTED_DISTANCE + torch._assert_async((dists[~coord_mask] < max_dist).all()) + struct_then_seq_dist = ( + seq_dists.to(dists.dtype) + .mul(1e2) + .add(max_dist) + .where(coord_mask, dists) + .masked_fill(padding_pairwise_mask, torch.inf) + ) + dists, edges = struct_then_seq_dist.sort(dim=-1, descending=False) + # This is a L x L tensor, where we index by rows first, + # and columns are the edges we should pick. + chosen_edges = edges[..., :num_by_dist] + chosen_mask = dists[..., :num_by_dist].isfinite() + return chosen_edges, chosen_mask + + +def stack_variable_length_tensors( + sequences: Sequence[torch.Tensor], + constant_value: int | float = 0, + dtype: torch.dtype | None = None, +) -> torch.Tensor: + """Automatically stack tensors together, padding variable lengths with the + value in constant_value. Handles an arbitrary number of dimensions. + + Examples: + >>> tensor1, tensor2 = torch.ones([2]), torch.ones([5]) + >>> stack_variable_length_tensors(tensor1, tensor2) + tensor of shape [2, 5]. First row is [1, 1, 0, 0, 0]. Second row is all ones. + + >>> tensor1, tensor2 = torch.ones([2, 4]), torch.ones([5, 3]) + >>> stack_variable_length_tensors(tensor1, tensor2) + tensor of shape [2, 5, 4] + """ + batch_size = len(sequences) + shape = [batch_size] + np.max([seq.shape for seq in sequences], 0).tolist() + + if dtype is None: + dtype = sequences[0].dtype + device = sequences[0].device + + array = torch.full(shape, constant_value, dtype=dtype, device=device) + for arr, seq in zip(array, sequences): + arrslice = tuple(slice(dim) for dim in seq.shape) + arr[arrslice] = seq + + return array + + +def unbinpack( + tensor: torch.Tensor, sequence_id: torch.Tensor | None, pad_value: int | float +): + """ + Args: + tensor (Tensor): [B, L, ...] + + Returns: + Tensor: [B_unbinpacked, L_unbinpack, ...] + """ + if sequence_id is None: + return tensor + + unpacked_tensors = [] + num_sequences = sequence_id.max(dim=-1).values + 1 + for batch_idx, (batch_seqid, batch_num_sequences) in enumerate( + zip(sequence_id, num_sequences) + ): + for seqid in range(batch_num_sequences): + mask = batch_seqid == seqid + unpacked = tensor[batch_idx, mask] + unpacked_tensors.append(unpacked) + return stack_variable_length_tensors(unpacked_tensors, pad_value) + + +def fp32_autocast_context(device_type: str) -> ContextManager[torch.amp.autocast]: + """ + Returns an autocast context manager that disables downcasting by AMP. + + Args: + device_type: The device type ('cpu' or 'cuda') + + Returns: + An autocast context manager with the specified behavior. + """ + if device_type == "cpu": + return torch.amp.autocast(device_type, enabled=False) + elif device_type == "cuda": + return torch.amp.autocast(device_type, dtype=torch.float32) + else: + raise ValueError(f"Unsupported device type: {device_type}") + + +def merge_ranges(ranges: list[range], merge_gap_max: int | None = None) -> list[range]: + """Merge overlapping ranges into sorted, non-overlapping segments. + + Args: + ranges: collection of ranges to merge. + merge_gap_max: optionally merge neighboring ranges that are separated by a gap + no larger than this size. + Returns: + non-overlapping ranges merged from the inputs, sorted by position. + """ + ranges = sorted(ranges, key=lambda r: r.start) + merge_gap_max = merge_gap_max if merge_gap_max is not None else 0 + assert merge_gap_max >= 0, f"Invalid merge_gap_max: {merge_gap_max}" + + merged = [] + for r in ranges: + if not merged: + merged.append(r) + else: + last = merged[-1] + if last.stop + merge_gap_max >= r.start: + merged[-1] = range(last.start, max(last.stop, r.stop)) + else: + merged.append(r) + return merged + + +def list_nan_to_none(l: list) -> list: + if l is None: + return None # type: ignore + elif isinstance(l, float): + return None if math.isnan(l) else l # type: ignore + elif isinstance(l, list): + return [list_nan_to_none(x) for x in l] + else: + # Don't go into other structures. + return l + + +def list_none_to_nan(l: list) -> list: + if l is None: + return math.nan # type: ignore + elif isinstance(l, list): + return [list_none_to_nan(x) for x in l] + else: + return l + + +def maybe_tensor(x, convert_none_to_nan: bool = False) -> torch.Tensor | None: + if x is None: + return None + if convert_none_to_nan: + x = list_none_to_nan(x) + return torch.tensor(x) + + +def maybe_list(x, convert_nan_to_none: bool = False) -> list | None: + if x is None: + return None + x = x.tolist() + if convert_nan_to_none: + x = list_nan_to_none(x) + return x diff --git a/esm/utils/noise_schedules.py b/esm/utils/noise_schedules.py new file mode 100644 index 0000000..b02052d --- /dev/null +++ b/esm/utils/noise_schedules.py @@ -0,0 +1,34 @@ +import math + +import torch + + +def cosine_schedule(t: torch.Tensor): + # t is a tensor of size (batch_size,) with values between 0 and 1. This is the + # schedule used in the MaskGIT paper + return torch.cos(t * math.pi * 0.5) + + +def cubic_schedule(t): + return 1 - t**3 + + +def linear_schedule(t): + return 1 - t + + +def square_root_schedule(t): + return 1 - torch.sqrt(t) + + +def square_schedule(t): + return 1 - t**2 + + +NOISE_SCHEDULE_REGISTRY = { + "cosine": cosine_schedule, + "linear": linear_schedule, + "square_root_schedule": square_root_schedule, + "cubic": cubic_schedule, + "square": square_schedule, +} diff --git a/esm/utils/residue_constants.py b/esm/utils/residue_constants.py new file mode 100644 index 0000000..86ea82e --- /dev/null +++ b/esm/utils/residue_constants.py @@ -0,0 +1,81 @@ +# Copyright 2021 AlQuraishi Laboratory +# Copyright 2021 DeepMind Technologies Limited +# +# 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. + +# This mapping is used when we need to store atom data in a format that requires +# fixed atom data size for every residue (e.g. a numpy array). +atom_types = [ + "N", + "CA", + "C", + "CB", + "O", + "CG", + "CG1", + "CG2", + "OG", + "OG1", + "SG", + "CD", + "CD1", + "CD2", + "ND1", + "ND2", + "OD1", + "OD2", + "SD", + "CE", + "CE1", + "CE2", + "CE3", + "NE", + "NE1", + "NE2", + "OE1", + "OE2", + "CH2", + "NH1", + "NH2", + "OH", + "CZ", + "CZ2", + "CZ3", + "NZ", + "OXT", +] +atom_order = {atom_type: i for i, atom_type in enumerate(atom_types)} +atom_type_num = len(atom_types) # := 37. + +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", +} diff --git a/esm/utils/sampling.py b/esm/utils/sampling.py new file mode 100644 index 0000000..8db88c5 --- /dev/null +++ b/esm/utils/sampling.py @@ -0,0 +1,155 @@ +import attr +import torch +import torch.nn.functional as F + +from esm.sdk.api import ( + SamplingConfig, + SamplingTrackConfig, +) +from esm.tokenization import ( + TokenizerCollection, + get_invalid_tokenizer_ids, +) +from esm.tokenization.function_tokenizer import ( + InterProQuantizedTokenizer, +) +from esm.utils.constants.esm3 import MAX_RESIDUE_ANNOTATIONS + + +def get_default_sampling_config(tokenizers: TokenizerCollection) -> SamplingConfig: + tracks = [f.name for f in attr.fields(SamplingConfig)] + sampling_config = SamplingConfig() + for current_track in tracks: + setattr( + sampling_config, + current_track, + SamplingTrackConfig( + invalid_ids=get_invalid_tokenizer_ids( + getattr(tokenizers, current_track) + ), + temperature=1.0, + top_p=1.0, + # TODO: Add different mask and padding tokens for all tracks + # Some tracks have the same pad and mask, which causes ambiguity when sampling + only_sample_masked_tokens=current_track + not in ["secondary_structure", "sasa", "function"], + ), + ) + return sampling_config + + +def sample_logits( + logits: torch.Tensor, + temperature: float | torch.Tensor, + top_p: float | torch.Tensor = 1.0, +): + """Default sampling from logits. + + Args: + logits is shape (..., vocab_size) + temperature is broadcastable to (...) + """ + + if top_p < 1.0: + logits = top_p_logits(logits, top_p=top_p) + + temperature = _tensorize_like(temperature, logits) + + if torch.all(temperature == 0): + ids = logits.argmax(-1) + return ids + + assert not torch.any(temperature == 0), "Partial temperature 0 not supported." + + batch_dims = logits.size()[:-1] + logits = logits.reshape(-1, logits.shape[-1]) + + # Sample from all logits + probs = F.softmax(logits / temperature[..., None], dim=-1) + ids = torch.multinomial(probs, 1).squeeze(1) + + ids = ids.reshape(*batch_dims) + return ids + + +def sample_function_logits( + logits: torch.Tensor, + tokenizer: InterProQuantizedTokenizer, + top_p: float | torch.Tensor = 1.0, + temperature: float | torch.Tensor = 1.0, + p_none_threshold: float = 0.05, +) -> tuple[torch.Tensor, torch.Tensor]: + [L, D, V] = logits.shape + assert D == tokenizer.depth + + if top_p < 1.0: + logits = top_p_logits(logits, top_p=top_p) + + temperature = torch.ones_like(logits[..., 0]) * temperature + + log_p = F.log_softmax(logits / temperature[..., None], dim=-1) # (L, D, V) + + # Choose which positions have no predicted function. + log_p_nones = log_p[..., tokenizer.vocab_to_index[""]] # (L, D) + p_none = torch.exp(log_p_nones).mean(dim=-1) # "Ensemble of predictions" + where_none = p_none > p_none_threshold # (L, ) + + # Set probability of to 0 for all not-none positions + none_index = tokenizer.vocab_to_index[""] + log_p[~where_none, :, none_index] = -torch.inf + + ids = torch.argmax(log_p, dim=-1) # (L, D) + ids[where_none, :] = tokenizer.vocab_to_index[""] + + return ids, log_p + + +def sample_residue_annotation_logits( + logits: torch.Tensor, annotation_threshold: float = 0.5 +) -> tuple[torch.Tensor, torch.Tensor]: + # Take top residue annotations + top_residue_annotations_idx = logits.argsort(dim=-1, descending=True)[ + ..., :MAX_RESIDUE_ANNOTATIONS + ] # (L, MAX_R) + top_residue_annotations_logprobs = torch.gather( + F.logsigmoid(logits), -1, top_residue_annotations_idx + ) # (L, MAX_R) + top_residue_annotations_probs = top_residue_annotations_logprobs.exp() + # Keep only positive predictions + is_negative = top_residue_annotations_probs < annotation_threshold + top_residue_annotations_idx[is_negative] = 0 + + top_residue_annotations_logprobs = top_residue_annotations_logprobs + + return top_residue_annotations_idx, top_residue_annotations_logprobs + + +def top_p_logits( + logits: torch.Tensor, + top_p: float | torch.Tensor, +) -> torch.Tensor: + top_p = _tensorize_like(top_p, logits) + + batch_dims = logits.size()[:-1] + logits = logits.reshape(-1, logits.shape[-1]) + + # Sort logits in descending order and extract the mask for the top_p + sorted_logits, sorted_indices = torch.sort(logits, dim=-1, descending=True) + cumsum_logits = sorted_logits.softmax(-1).cumsum(-1) + top_p_mask = cumsum_logits <= top_p[:, None] + + # Make sure at least one token is sampled + top_p_mask[:, 0] = True + + # Mask out the logits that are not in the top_p + batch_indices_to_mask, _ = torch.where(~top_p_mask) + vocab_indices_to_mask = sorted_indices[~top_p_mask] + logits[batch_indices_to_mask, vocab_indices_to_mask] = torch.finfo(logits.dtype).min + + return logits.reshape(*batch_dims, -1) + + +def _tensorize_like(value: int | float | torch.Tensor, logits: torch.Tensor): + if isinstance(value, (float, int)): + value = torch.full_like(logits[..., 0], value, dtype=logits.dtype) + return value.to(logits.device).expand_as(logits[..., 0]).reshape(-1) diff --git a/esm/utils/structure/affine3d.py b/esm/utils/structure/affine3d.py new file mode 100644 index 0000000..3792180 --- /dev/null +++ b/esm/utils/structure/affine3d.py @@ -0,0 +1,389 @@ +from __future__ import annotations + +import typing as T +from dataclasses import dataclass + +import torch +from typing_extensions import Self + +from esm.utils.misc import fp32_autocast_context + + +def maybe_compile(func, x: torch.Tensor): + # Sometimes, torch compile seems to give issues for CPU tensors... + return torch.compile(func) if x.device.type == "cuda" else func + + +@T.runtime_checkable +class Rotation(T.Protocol): + @classmethod + def identity(cls, shape: tuple[int, ...], **tensor_kwargs) -> Self: + ... + + @classmethod + def random(cls, shape: tuple[int, ...], **tensor_kwargs) -> Self: + ... + + def __getitem__(self, idx: T.Any) -> Self: + ... + + @property + def tensor(self) -> torch.Tensor: + # We claim that this should be zero-cost abstraction that returns the raw tensor backing this + # object. The raw tensor should always have exactly 1 more dim than self.shape, which should be + # implemented using reshaping + ... + + @property + def shape(self) -> torch.Size: + # The "shape" of the rotation, as if it was a torch.tensor object + # This means that 1x4 quaternions are treated as size (1,) for example + ... + + def as_matrix(self) -> RotationMatrix: + ... + + def compose(self, other: Self) -> Self: + # To be safe, we force users to explicitly convert between rotation types. + ... + + def convert_compose(self, other: Self) -> Self: + # This function will automatically convert between types of rotations + ... + + def apply(self, p: torch.Tensor) -> torch.Tensor: + # rotates points by this rotation object + ... + + def invert(self) -> Self: + ... + + @property + def dtype(self) -> torch.dtype: + return self.tensor.dtype + + @property + def device(self) -> torch.device: + return self.tensor.device + + @property + def requires_grad(self) -> bool: + return self.tensor.requires_grad + + @classmethod + def _from_tensor(cls, t: torch.Tensor) -> Self: + # This function exists to simplify the below functions, esp type signatures + # Its implementation is different from Affine3D.from_tensor and does not + # autodetect rotation types. + return cls(t) # type: ignore + + def to(self, **kwargs) -> Self: + return self._from_tensor(self.tensor.to(**kwargs)) + + def detach(self, *args, **kwargs) -> Self: + return self._from_tensor(self.tensor.detach(**kwargs)) + + def tensor_apply(self, func) -> Self: + # Applys a function to the underlying tensor + return self._from_tensor( + torch.stack([func(x) for x in self.tensor.unbind(dim=-1)], dim=-1) + ) + + +class RotationMatrix(Rotation): + def __init__(self, rots: torch.Tensor): + if rots.shape[-1] == 9: + rots = rots.unflatten(-1, (3, 3)) + assert rots.shape[-1] == 3 + assert rots.shape[-2] == 3 + # Force full precision + self._rots = rots.to(torch.float32) + + @classmethod + def identity(cls, shape, **tensor_kwargs): + rots = torch.eye(3, **tensor_kwargs) + rots = rots.view(*[1 for _ in range(len(shape))], 3, 3) + rots = rots.expand(*shape, -1, -1) + return cls(rots) + + @classmethod + def random(cls, shape, **tensor_kwargs): + v1 = torch.randn((*shape, 3), **tensor_kwargs) + v2 = torch.randn((*shape, 3), **tensor_kwargs) + return cls(_graham_schmidt(v1, v2)) + + def __getitem__(self, idx: T.Any) -> RotationMatrix: + indices = (idx,) if isinstance(idx, int) or idx is None else tuple(idx) + return RotationMatrix(self._rots[indices + (slice(None), slice(None))]) + + @property + def shape(self) -> torch.Size: + return self._rots.shape[:-2] + + def as_matrix(self) -> RotationMatrix: + return self + + def compose(self, other: RotationMatrix) -> RotationMatrix: + with fp32_autocast_context(self._rots.device.type): + return RotationMatrix(self._rots @ other._rots) + + def convert_compose(self, other: Rotation): + return self.compose(other.as_matrix()) + + def apply(self, p: torch.Tensor) -> torch.Tensor: + with fp32_autocast_context(self.device.type): + if self._rots.shape[-3] == 1: + # This is a slight speedup over einsum for batched rotations + return p @ self._rots.transpose(-1, -2).squeeze(-3) + else: + # einsum way faster than bmm! + return torch.einsum("...ij,...j", self._rots, p) + + def invert(self) -> RotationMatrix: + return RotationMatrix(self._rots.transpose(-1, -2)) + + @property + def tensor(self) -> torch.Tensor: + return self._rots.flatten(-2) + + def to_3x3(self) -> torch.Tensor: + return self._rots + + @staticmethod + def from_graham_schmidt( + x_axis: torch.Tensor, xy_plane: torch.Tensor, eps: float = 1e-12 + ) -> RotationMatrix: + # A low eps here is necessary for good stability! + return RotationMatrix( + maybe_compile(_graham_schmidt, x_axis)(x_axis, xy_plane, eps) + ) + + +@dataclass(frozen=True) +class Affine3D: + trans: torch.Tensor + rot: Rotation + + def __post_init__(self): + assert self.trans.shape[:-1] == self.rot.shape + + @staticmethod + def identity( + shape_or_affine: T.Union[tuple[int, ...], "Affine3D"], + rotation_type: T.Type[Rotation] = RotationMatrix, + **tensor_kwargs, + ): + # Creates a new identity Affine3D object with a specified shape + # or the same shape as another Affine3D object. + if isinstance(shape_or_affine, Affine3D): + kwargs = {"dtype": shape_or_affine.dtype, "device": shape_or_affine.device} + kwargs.update(tensor_kwargs) + shape = shape_or_affine.shape + rotation_type = type(shape_or_affine.rot) + else: + kwargs = tensor_kwargs + shape = shape_or_affine + return Affine3D( + torch.zeros((*shape, 3), **kwargs), rotation_type.identity(shape, **kwargs) + ) + + @staticmethod + def random( + shape: tuple[int, ...], + std: float = 1, + rotation_type: T.Type[Rotation] = RotationMatrix, + **tensor_kwargs, + ) -> "Affine3D": + return Affine3D( + trans=torch.randn((*shape, 3), **tensor_kwargs).mul(std), + rot=rotation_type.random(shape, **tensor_kwargs), + ) + + def __getitem__(self, idx: T.Any) -> "Affine3D": + indices = (idx,) if isinstance(idx, int) or idx is None else tuple(idx) + return Affine3D( + trans=self.trans[indices + (slice(None),)], + rot=self.rot[idx], + ) + + @property + def shape(self) -> torch.Size: + return self.trans.shape[:-1] + + @property + def dtype(self) -> torch.dtype: + return self.trans.dtype + + @property + def device(self) -> torch.device: + return self.trans.device + + @property + def requires_grad(self) -> bool: + return self.trans.requires_grad + + def to(self, **kwargs) -> "Affine3D": + return Affine3D(self.trans.to(**kwargs), self.rot.to(**kwargs)) + + def detach(self, *args, **kwargs) -> "Affine3D": + return Affine3D(self.trans.detach(**kwargs), self.rot.detach(**kwargs)) + + def tensor_apply(self, func) -> "Affine3D": + # Applys a function to the underlying tensor + return self.from_tensor( + torch.stack([func(x) for x in self.tensor.unbind(dim=-1)], dim=-1) + ) + + def as_matrix(self): + return Affine3D(trans=self.trans, rot=self.rot.as_matrix()) + + def compose(self, other: "Affine3D", autoconvert: bool = False): + rot = self.rot + new_rot = (rot.convert_compose if autoconvert else rot.compose)(other.rot) + new_trans = rot.apply(other.trans) + self.trans + return Affine3D(trans=new_trans, rot=new_rot) + + def compose_rotation(self, other: Rotation, autoconvert: bool = False): + return Affine3D( + trans=self.trans, + rot=(self.rot.convert_compose if autoconvert else self.rot.compose)(other), + ) + + def scale(self, v: torch.Tensor | float): + return Affine3D(self.trans * v, self.rot) + + def mask(self, mask: torch.Tensor, with_zero=False): + # Returns a transform where True positions in mask is identity + if with_zero: + tensor = self.tensor + return Affine3D.from_tensor( + torch.zeros_like(tensor).where(mask[..., None], tensor) + ) + else: + identity = self.identity( + self.shape, + rotation_type=type(self.rot), + device=self.device, + dtype=self.dtype, + ).tensor + return Affine3D.from_tensor(identity.where(mask[..., None], self.tensor)) + + def apply(self, p: torch.Tensor) -> torch.Tensor: + return self.rot.apply(p) + self.trans + + def invert(self): + inv_rot = self.rot.invert() + return Affine3D(trans=-inv_rot.apply(self.trans), rot=inv_rot) + + @property + def tensor(self) -> torch.Tensor: + return torch.cat([self.rot.tensor, self.trans], dim=-1) + + @staticmethod + def from_tensor(t: torch.Tensor) -> "Affine3D": + match t.shape[-1]: + case 4: + # Assume tensor 4x4 for backward compat with alphafold + trans = t[..., :3, 3] + rot = RotationMatrix(t[..., :3, :3]) + case 12: + trans = t[..., -3:] + rot = RotationMatrix(t[..., :-3].unflatten(-1, (3, 3))) + case _: + raise RuntimeError( + f"Cannot detect rotation fromat from {t.shape[-1] -3}-d flat vector" + ) + return Affine3D(trans, rot) + + @staticmethod + def from_tensor_pair(t: torch.Tensor, r: torch.Tensor) -> "Affine3D": + return Affine3D(t, RotationMatrix(r)) + + @staticmethod + def from_graham_schmidt( + neg_x_axis: torch.Tensor, + origin: torch.Tensor, + xy_plane: torch.Tensor, + eps: float = 1e-10, + ): + # The arguments of this function is for parity with AlphaFold + x_axis = origin - neg_x_axis + xy_plane = xy_plane - origin + return Affine3D( + trans=origin, rot=RotationMatrix.from_graham_schmidt(x_axis, xy_plane, eps) + ) + + @staticmethod + def cat(affines: list["Affine3D"], dim: int = 0): + if dim < 0: + dim = len(affines[0].shape) + dim + return Affine3D.from_tensor(torch.cat([x.tensor for x in affines], dim=dim)) + + +def _graham_schmidt(x_axis: torch.Tensor, xy_plane: torch.Tensor, eps: float = 1e-12): + # A low eps here is necessary for good stability! + with fp32_autocast_context(x_axis.device.type): + e1 = xy_plane + + denom = torch.sqrt((x_axis**2).sum(dim=-1, keepdim=True) + eps) + x_axis = x_axis / denom + dot = (x_axis * e1).sum(dim=-1, keepdim=True) + e1 = e1 - x_axis * dot + denom = torch.sqrt((e1**2).sum(dim=-1, keepdim=True) + eps) + e1 = e1 / denom + e2 = torch.cross(x_axis, e1, dim=-1) + + rots = torch.stack([x_axis, e1, e2], dim=-1) + + return rots + + +def build_affine3d_from_coordinates( + coords: torch.Tensor, # (N, CA, C). +) -> tuple[Affine3D, torch.Tensor]: + _MAX_SUPPORTED_DISTANCE = 1e6 + coord_mask = torch.all( + torch.all(torch.isfinite(coords) & (coords < _MAX_SUPPORTED_DISTANCE), dim=-1), + dim=-1, + ) + + def atom3_to_backbone_affine(bb_positions: torch.Tensor) -> Affine3D: + N, CA, C = bb_positions.unbind(dim=-2) + return Affine3D.from_graham_schmidt(C, CA, N) + + coords = coords.clone().float() + coords[~coord_mask] = 0 + + # NOTE(thayes): If you have already normalized the coordinates, then + # the black hole affine translations will be zeros and the rotations will be + # the identity. + average_per_n_ca_c = coords.masked_fill(~coord_mask[..., None, None], 0).sum(1) / ( + coord_mask.sum(-1)[..., None, None] + 1e-8 + ) + affine_from_average = atom3_to_backbone_affine( + average_per_n_ca_c.float() + ).as_matrix() + + B, S, _, _ = coords.shape + assert isinstance(B, int) + assert isinstance(S, int) + affine_rot_mats = affine_from_average.rot.tensor[..., None, :].expand(B, S, 9) + affine_trans = affine_from_average.trans[..., None, :].expand(B, S, 3) + + # We use the identity rotation whereever we have no coordinates. This is + # important because otherwise the rotation matrices will be all zeros, which + # will cause collapse in the distance/direction attention mechanism. + identity_rot = RotationMatrix.identity( + (B, S), dtype=torch.float32, device=coords.device, requires_grad=False + ) + affine_rot_mats = affine_rot_mats.where( + coord_mask.any(-1)[..., None, None], identity_rot.tensor + ) + black_hole_affine = Affine3D(affine_trans, RotationMatrix(affine_rot_mats)) + + affine = atom3_to_backbone_affine(coords.float()) + affine = Affine3D.from_tensor( + affine.tensor.where(coord_mask[..., None], black_hole_affine.tensor) + ) + + return affine, coord_mask diff --git a/esm/utils/structure/aligner.py b/esm/utils/structure/aligner.py new file mode 100644 index 0000000..613b69f --- /dev/null +++ b/esm/utils/structure/aligner.py @@ -0,0 +1,88 @@ +from __future__ import annotations + +from dataclasses import replace +from typing import TYPE_CHECKING + +import numpy as np +import torch + +from esm.utils.structure.protein_structure import ( + compute_affine_and_rmsd, +) + +if TYPE_CHECKING: + from esm.utils.structure.protein_chain import ProteinChain + + +class Aligner: + def __init__( + self, + mobile: ProteinChain, + target: ProteinChain, + only_use_backbone: bool = False, + use_reflection: bool = False, + ): + """ + Aligns a mobile protein chain against a target protein chain. + + Args: + mobile (ProteinChain): Protein chain to be aligned. + target (ProteinChain): Protein chain target. + only_use_backbone (bool): Whether to only use backbone atoms. + use_reflection (bool): Whether to align to target reflection. + """ + # Check proteins must have same number of residues + assert len(mobile) == len(target) + + # Determine overlapping atoms + joint_atom37_mask = mobile.atom37_mask.astype(bool) & target.atom37_mask.astype( + bool + ) + + # Backbone atoms are first sites in atom37 representation + if only_use_backbone: + joint_atom37_mask[:, 3:] = False + + # Extract matching atom positions and convert to batched tensors + mobile_atom_tensor = ( + torch.from_numpy(mobile.atom37_positions).type(torch.double).unsqueeze(0) + ) + target_atom_tensor = ( + torch.from_numpy(target.atom37_positions).type(torch.double).unsqueeze(0) + ) + joint_atom37_mask = ( + torch.from_numpy(joint_atom37_mask).type(torch.bool).unsqueeze(0) + ) + + # If using reflection flip target + if use_reflection: + target_atom_tensor = -target_atom_tensor + + # Compute alignment and rmsd + affine3D, rmsd = compute_affine_and_rmsd( + mobile_atom_tensor, target_atom_tensor, atom_exists_mask=joint_atom37_mask + ) + self._affine3D = affine3D + self._rmsd = rmsd.item() + + @property + def rmsd(self): + return self._rmsd + + def apply(self, mobile: ProteinChain) -> ProteinChain: + """Apply alignment to a protein chain""" + # Extract atom positions and convert to batched tensors + mobile_atom_tensor = ( + torch.from_numpy(mobile.atom37_positions[mobile.atom37_mask]) + .type(torch.float32) + .unsqueeze(0) + ) + + # Transform atom arrays + aligned_atom_tensor = self._affine3D.apply(mobile_atom_tensor).squeeze(0) + + # Rebuild atom37 positions + aligned_atom37_positions = np.full_like(mobile.atom37_positions, np.nan) + aligned_atom37_positions[mobile.atom37_mask] = aligned_atom_tensor + + return replace(mobile, atom37_positions=aligned_atom37_positions) diff --git a/esm/utils/structure/lddt.py b/esm/utils/structure/lddt.py new file mode 100644 index 0000000..487e930 --- /dev/null +++ b/esm/utils/structure/lddt.py @@ -0,0 +1,98 @@ +import torch +from einops import rearrange + +from esm.utils import residue_constants as RC + + +def compute_lddt( + all_atom_pred_pos: torch.Tensor, + all_atom_positions: torch.Tensor, + all_atom_mask: torch.Tensor, + cutoff: float = 15.0, + eps: float = 1e-10, + per_residue: bool = True, +) -> torch.Tensor: + """ + Computes LDDT for a protein. Tensor sizes below include some optional dimensions. Specifically: + Nstates: + all_atom_pred_pos can contain multiple states in the first dimension which corresponds to outputs from different layers of a model (e.g. each IPA block). The return size will be [Nstates x Batch size] if this is included. + Natoms: + LDDT can be computed for all atoms or some atoms. The second to last dimension should contain the *FLATTENED* representation of L x Natoms. If you want to calculate for atom37, e.g., this will be of size (L * 37). If you are only calculating CA LDDT, it will be of size L. + + Args: + all_atom_pred_pos (Tensor[float], [(Nstates x) B x (L * Natoms x) 3]): Tensor of predicted positions + all_atom_positions (Tensor[float], [B x (L * Natoms x) 3]): Tensor of true positions + all_atom_mask (Tensor[float], [B x (L * Natoms)]): Tensor of masks, indicating whether an atom exists. + cutoff (float): Max distance to score lddt over. + per_residue (bool): Whether to return per-residue or full-protein lddt. + + Returns: + LDDT Tensor: + if per_residue: + Tensor[float], [(Nstates x) B x (L * Natoms)] + else: + Tensor[float], [(Nstates x) B] + """ + n = all_atom_mask.shape[-2] + dmat_true = torch.sqrt( + eps + + torch.sum( + (all_atom_positions[..., None, :] - all_atom_positions[..., None, :, :]) + ** 2, + dim=-1, + ) + ) + + dmat_pred = torch.sqrt( + eps + + torch.sum( + (all_atom_pred_pos[..., None, :] - all_atom_pred_pos[..., None, :, :]) ** 2, + dim=-1, + ) + ) + dists_to_score = ( + (dmat_true < cutoff) + * all_atom_mask + * rearrange(all_atom_mask, "... a b -> ... b a") + * (1.0 - torch.eye(n, device=all_atom_mask.device)) + ) + + dist_l1 = torch.abs(dmat_true - dmat_pred) + + score = ( + (dist_l1 < 0.5).type(dist_l1.dtype) + + (dist_l1 < 1.0).type(dist_l1.dtype) + + (dist_l1 < 2.0).type(dist_l1.dtype) + + (dist_l1 < 4.0).type(dist_l1.dtype) + ) + score = score * 0.25 + + dims = (-1,) if per_residue else (-2, -1) + norm = 1.0 / (eps + torch.sum(dists_to_score, dim=dims)) + score = norm * (eps + torch.sum(dists_to_score * score, dim=dims)) + + return score + + +def compute_lddt_ca( + all_atom_pred_pos: torch.Tensor, + all_atom_positions: torch.Tensor, + all_atom_mask: torch.Tensor, + cutoff: float = 15.0, + eps: float = 1e-10, + per_residue: bool = True, +) -> torch.Tensor: + ca_pos = RC.atom_order["CA"] + if all_atom_pred_pos.dim() != 3: + all_atom_pred_pos = all_atom_pred_pos[..., ca_pos, :] + all_atom_positions = all_atom_positions[..., ca_pos, :] + all_atom_mask = all_atom_mask[..., ca_pos : (ca_pos + 1)] # keep dim + + return compute_lddt( + all_atom_pred_pos, + all_atom_positions, + all_atom_mask, + cutoff=cutoff, + eps=eps, + per_residue=per_residue, + ) diff --git a/esm/utils/structure/normalize_coordinates.py b/esm/utils/structure/normalize_coordinates.py new file mode 100644 index 0000000..6b8efd6 --- /dev/null +++ b/esm/utils/structure/normalize_coordinates.py @@ -0,0 +1,82 @@ +from typing import TypeVar + +import numpy as np +import torch +from torch import Tensor + +from esm.utils import residue_constants as RC +from esm.utils.structure.affine3d import Affine3D + +ArrayOrTensor = TypeVar("ArrayOrTensor", np.ndarray, Tensor) + + +def atom3_to_backbone_frames(bb_positions: torch.Tensor) -> Affine3D: + N, CA, C = bb_positions.unbind(dim=-2) + return Affine3D.from_graham_schmidt(C, CA, N) + + +def index_by_atom_name( + atom37: ArrayOrTensor, atom_names: str | list[str], dim: int = -2 +) -> ArrayOrTensor: + squeeze = False + if isinstance(atom_names, str): + atom_names = [atom_names] + squeeze = True + indices = [RC.atom_order[atom_name] for atom_name in atom_names] + dim = dim % atom37.ndim + index = tuple(slice(None) if dim != i else indices for i in range(atom37.ndim)) + result = atom37[index] # type: ignore + if squeeze: + result = result.squeeze(dim) + return result + + +def get_protein_normalization_frame(coords: Tensor) -> Affine3D: + """Given a set of coordinates for a protein, compute a single frame that can be used to normalize the coordinates. + Specifically, we compute the average position of the N, CA, and C atoms use those 3 points to construct a frame + using the Gram-Schmidt algorithm. The average CA position is used as the origin of the frame. + + Args: + coords (torch.FloatTensor): [L, 37, 3] tensor of coordinates + + Returns: + Affine3D: tensor of Affine3D frame + """ + bb_coords = index_by_atom_name(coords, ["N", "CA", "C"], dim=-2) + coord_mask = torch.all( + torch.all(torch.isfinite(bb_coords), dim=-1), + dim=-1, + ) + + average_position_per_n_ca_c = bb_coords.masked_fill( + ~coord_mask[..., None, None], 0 + ).sum(-3) / (coord_mask.sum(-1)[..., None, None] + 1e-8) + frame = atom3_to_backbone_frames(average_position_per_n_ca_c.float()) + + return frame + + +def apply_frame_to_coords(coords: Tensor, frame: Affine3D) -> Tensor: + """Given a set of coordinates and a single frame, apply the frame to the coordinates. + + Args: + coords (torch.FloatTensor): [L, 37, 3] tensor of coordinates + frame (Affine3D): Affine3D frame + + Returns: + torch.FloatTensor: [L, 37, 3] tensor of transformed coordinates + """ + coords_trans_rot = frame[..., None, None].invert().apply(coords) + + # only transform coordinates with frame that have a valid rotation + valid_frame = frame.trans.norm(dim=-1) > 0 + + is_inf = torch.isinf(coords) + coords = coords_trans_rot.where(valid_frame[..., None, None, None], coords) + coords.masked_fill_(is_inf, torch.inf) + + return coords + + +def normalize_coordinates(coords: Tensor) -> Tensor: + return apply_frame_to_coords(coords, get_protein_normalization_frame(coords)) diff --git a/esm/utils/structure/predicted_aligned_error.py b/esm/utils/structure/predicted_aligned_error.py new file mode 100644 index 0000000..2b999c1 --- /dev/null +++ b/esm/utils/structure/predicted_aligned_error.py @@ -0,0 +1,108 @@ +import torch +import torch.nn.functional as F + +from esm.utils.structure.affine3d import Affine3D + + +def masked_mean( + mask: torch.Tensor, + value: torch.Tensor, + dim: int | None | tuple[int, ...] = None, + eps=1e-10, +) -> torch.Tensor: + """Compute the mean of `value` where only positions where `mask == true` are + counted. + """ + mask = mask.expand(*value.shape) + return torch.sum(mask * value, dim=dim) / (eps + torch.sum(mask, dim=dim)) + + +def _pae_bins( + max_bin: float = 31, num_bins: int = 64, device: torch.device = torch.device("cpu") +): + bins = torch.linspace(0, max_bin, steps=(num_bins - 1), device=device) + step = max_bin / (num_bins - 2) + bin_centers = bins + step / 2 + bin_centers = torch.cat( + [bin_centers, (bin_centers[-1] + step).unsqueeze(-1)], dim=0 + ) + return bin_centers + + +def _compute_pae_masks(mask: torch.Tensor): + square_mask = (mask.unsqueeze(-1) * mask.unsqueeze(-2)).bool() + return square_mask + + +def compute_predicted_aligned_error( + logits: torch.Tensor, + aa_mask: torch.Tensor, + sequence_id: torch.Tensor | None = None, + max_bin: float = 31, +) -> torch.Tensor: + bins = _pae_bins(max_bin, logits.shape[-1], logits.device) + square_mask = _compute_pae_masks(aa_mask) + min_v = torch.finfo(logits.dtype).min + probs = logits.masked_fill(~square_mask.unsqueeze(-1), min_v).softmax(dim=-1) + + return (probs * bins).sum(dim=-1) + + +@torch.no_grad +def compute_tm( + logits: torch.Tensor, + aa_mask: torch.Tensor, + max_bin: float = 31.0, +): + square_mask = _compute_pae_masks(aa_mask) + seqlens = aa_mask.sum(-1, keepdim=True) + bins = _pae_bins(max_bin, logits.shape[-1], logits.device) + d0 = 1.24 * (seqlens.clamp_min(19) - 15) ** (1 / 3) - 1.8 + f_d = 1.0 / (1 + (bins / d0.unsqueeze(-1)) ** 2) + + min_v = torch.finfo(logits.dtype).min + probs = logits.masked_fill(~square_mask.unsqueeze(-1), min_v).softmax(dim=-1) + # This is the sum over bins + ptm = (probs * f_d.unsqueeze(-2)).sum(dim=-1) + # This is the mean over residues j + ptm = masked_mean(square_mask, ptm, dim=-1) + # The we do a max over residues i + return ptm.max(dim=-1).values + + +def tm_loss( + logits: torch.Tensor, + pred_affine: torch.Tensor, + targ_affine: torch.Tensor, + targ_mask: torch.Tensor, + tm_mask: torch.Tensor | None = None, + sequence_id: torch.Tensor | None = None, + max_bin: float = 31, +): + pred = Affine3D.from_tensor(pred_affine) + targ = Affine3D.from_tensor(targ_affine) + + def transform(affine: Affine3D): + pts = affine.trans[..., None, :, :] + return affine.invert()[..., None].apply(pts) + + with torch.no_grad(): + sq_diff = (transform(pred) - transform(targ)).square().sum(dim=-1) + + num_bins = logits.shape[-1] + sq_bins = torch.linspace( + 0, max_bin, num_bins - 1, device=logits.device + ).square() + # Gets the bin id by using a sum. + true_bins = (sq_diff[..., None] > sq_bins).sum(dim=-1).long() + + errors = F.cross_entropy(logits.movedim(3, 1), true_bins, reduction="none") + square_mask = _compute_pae_masks(targ_mask) + loss = masked_mean(square_mask, errors, dim=(-1, -2)) + + if tm_mask is not None: + loss = masked_mean(tm_mask, loss, dim=None) + else: + loss = loss.mean() + + return loss diff --git a/esm/utils/structure/protein_chain.py b/esm/utils/structure/protein_chain.py new file mode 100644 index 0000000..ab5ea6d --- /dev/null +++ b/esm/utils/structure/protein_chain.py @@ -0,0 +1,828 @@ +from __future__ import annotations + +import io +from dataclasses import asdict, dataclass, replace +from functools import cached_property +from pathlib import Path +from typing import Sequence, TypeVar, Union + +import biotite.structure as bs +import brotli +import msgpack +import msgpack_numpy +import numpy as np +import torch +from Bio.Data import PDBData +from biotite.application.dssp import DsspApp +from biotite.database import rcsb +from biotite.structure.io.npz import NpzFile +from biotite.structure.io.pdb import PDBFile +from scipy.spatial.distance import pdist, squareform +from torch import Tensor + +from esm.utils import residue_constants as RC +from esm.utils.constants import esm3 as C +from esm.utils.misc import slice_python_object_as_numpy +from esm.utils.structure.affine3d import Affine3D +from esm.utils.structure.aligner import Aligner +from esm.utils.structure.lddt import compute_lddt_ca +from esm.utils.structure.normalize_coordinates import ( + apply_frame_to_coords, + get_protein_normalization_frame, + normalize_coordinates, +) + +msgpack_numpy.patch() + +CHAIN_ID_CONST = "A" + + +ArrayOrTensor = TypeVar("ArrayOrTensor", np.ndarray, Tensor) +PathLike = Union[str, Path] +PathOrBuffer = Union[PathLike, io.StringIO] + + +def index_by_atom_name( + atom37: ArrayOrTensor, atom_names: str | list[str], dim: int = -2 +) -> ArrayOrTensor: + squeeze = False + if isinstance(atom_names, str): + atom_names = [atom_names] + squeeze = True + indices = [RC.atom_order[atom_name] for atom_name in atom_names] + dim = dim % atom37.ndim + index = tuple(slice(None) if dim != i else indices for i in range(atom37.ndim)) + result = atom37[index] # type: ignore + if squeeze: + result = result.squeeze(dim) + return result + + +def infer_CB(C, N, Ca, L: float = 1.522, A: float = 1.927, D: float = -2.143): + """ + Inspired by a util in trDesign: + https://github.com/gjoni/trDesign/blob/f2d5930b472e77bfacc2f437b3966e7a708a8d37/02-GD/utils.py#L92 + + input: 3 coords (a,b,c), (L)ength, (A)ngle, and (D)ihedral + output: 4th coord + """ + norm = lambda x: x / np.sqrt(np.square(x).sum(-1, keepdims=True) + 1e-8) + with np.errstate(invalid="ignore"): # inf - inf = nan is ok here + vec_bc = N - Ca + vec_ba = N - C + bc = norm(vec_bc) + n = norm(np.cross(vec_ba, bc)) + m = [bc, np.cross(n, bc), n] + d = [L * np.cos(A), L * np.sin(A) * np.cos(D), -L * np.sin(A) * np.sin(D)] + return Ca + sum([m * d for m, d in zip(m, d)]) + + +class AtomIndexer: + def __init__(self, structure: ProteinChain, property: str, dim: int): + self.structure = structure + self.property = property + self.dim = dim + + def __getitem__(self, atom_names: str | list[str]) -> np.ndarray: + return index_by_atom_name( + getattr(self.structure, self.property), atom_names, self.dim + ) + + +@dataclass +class ProteinChain: + """Dataclass with atom37 representation of a single protein chain.""" + + id: str + sequence: str + chain_id: str # author chain id + entity_id: int | None + residue_index: np.ndarray + insertion_code: np.ndarray + atom37_positions: np.ndarray + atom37_mask: np.ndarray + confidence: np.ndarray + + def __post_init__(self): + self.atom37_mask = self.atom37_mask.astype(bool) + assert self.atom37_positions.shape[0] == len(self.sequence), ( + self.atom37_positions.shape, + len(self.sequence), + ) + assert self.atom37_mask.shape[0] == len(self.sequence), ( + self.atom37_mask.shape, + len(self.sequence), + ) + assert self.residue_index.shape[0] == len(self.sequence), ( + self.residue_index.shape, + len(self.sequence), + ) + assert self.insertion_code.shape[0] == len(self.sequence), ( + self.insertion_code.shape, + len(self.sequence), + ) + assert self.confidence.shape[0] == len(self.sequence), ( + self.confidence.shape, + len(self.sequence), + ) + + @cached_property + def atoms(self) -> AtomIndexer: + return AtomIndexer(self, property="atom37_positions", dim=-2) + + @cached_property + def atom_mask(self) -> AtomIndexer: + return AtomIndexer(self, property="atom37_mask", dim=-1) + + @cached_property + def atom_array(self) -> bs.AtomArray: + atoms = [] + for res_name, res_idx, ins_code, positions, mask, conf in zip( + self.sequence, + self.residue_index, + self.insertion_code, + self.atom37_positions, + self.atom37_mask.astype(bool), + self.confidence, + ): + for i, pos in zip(np.where(mask)[0], positions[mask]): + atom = bs.Atom( + coord=pos, + chain_id="A" if self.chain_id is None else self.chain_id, + res_id=res_idx, + ins_code=ins_code, + res_name=RC.restype_1to3.get(res_name, "UNK"), + hetero=False, + atom_name=RC.atom_types[i], + element=RC.atom_types[i][0], + b_factor=conf, + ) + atoms.append(atom) + return bs.array(atoms) + + @cached_property + def residue_index_no_insertions(self) -> np.ndarray: + return self.residue_index + np.cumsum(self.insertion_code != "") + + @cached_property + def atom_array_no_insertions(self) -> bs.AtomArray: + atoms = [] + for res_idx, (res_name, positions, mask, conf) in enumerate( + zip( + self.sequence, + self.atom37_positions, + self.atom37_mask.astype(bool), + self.confidence, + ) + ): + for i, pos in zip(np.where(mask)[0], positions[mask]): + atom = bs.Atom( + coord=pos, + # hard coded to as we currently only support single chain structures + chain_id=CHAIN_ID_CONST, + res_id=res_idx + 1, + res_name=RC.restype_1to3.get(res_name, "UNK"), + hetero=False, + atom_name=RC.atom_types[i], + element=RC.atom_types[i][0], + b_factor=conf, + ) + atoms.append(atom) + return bs.array(atoms) + + def __getitem__(self, idx: int | list[int] | slice | np.ndarray): + if isinstance(idx, int): + idx = [idx] + + sequence = slice_python_object_as_numpy(self.sequence, idx) + return replace( + self, + sequence=sequence, + residue_index=self.residue_index[..., idx], + insertion_code=self.insertion_code[..., idx], + atom37_positions=self.atom37_positions[..., idx, :, :], + atom37_mask=self.atom37_mask[..., idx, :], + confidence=self.confidence[..., idx], + ) + + def __len__(self): + return len(self.sequence) + + def cbeta_contacts(self, distance_threshold: float = 8.0) -> np.ndarray: + distance = self.pdist_CB + contacts = (distance < distance_threshold).astype(np.int64) + contacts[np.isnan(distance)] = -1 + contacts = squareform(contacts) + np.fill_diagonal(contacts, -1) + return contacts + + def to_npz(self, path: PathOrBuffer): + f = NpzFile() + f.set_structure(self.atom_array) + f.write(path) + + def to_npz_string(self): + f = NpzFile() + f.set_structure(self.atom_array) + buf = io.BytesIO() + f.write(buf) + return buf.getvalue() + + def to_structure_encoder_inputs( + self, + should_normalize_coordinates: bool = True, + ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + coords = torch.tensor(self.atom37_positions, dtype=torch.float32) + plddt = torch.tensor(self.confidence, dtype=torch.float32) + residue_index = torch.tensor(self.residue_index, dtype=torch.long) + + if should_normalize_coordinates: + coords = normalize_coordinates(coords) + return coords.unsqueeze(0), plddt.unsqueeze(0), residue_index.unsqueeze(0) + + def to_pdb(self, path: PathOrBuffer, include_insertions: bool = True): + """Dssp works better w/o insertions.""" + f = PDBFile() + if not include_insertions: + f.set_structure(self.atom_array_no_insertions) + else: + f.set_structure(self.atom_array) + f.write(path) + + def to_pdb_string(self, include_insertions: bool = True) -> str: + buf = io.StringIO() + self.to_pdb(buf, include_insertions=include_insertions) + buf.seek(0) + return buf.read() + + def state_dict(self, backbone_only=False): + """This state dict is optimized for storage, so it turns things to fp16 whenever + possible. Note that we also only support int32 residue indices, I'm hoping we don't + need more than 2**32 residues...""" + dct = {k: v for k, v in asdict(self).items()} + for k, v in dct.items(): + if isinstance(v, np.ndarray): + match v.dtype: + case np.int64: + dct[k] = v.astype(np.int32) + case np.float64 | np.float32: + dct[k] = v.astype(np.float16) + case _: + pass + if backbone_only: + dct["atom37_mask"][:, 3:] = False + dct["atom37_positions"] = dct["atom37_positions"][dct["atom37_mask"]] + return dct + + def to_blob(self, backbone_only=False) -> bytes: + return brotli.compress(msgpack.dumps(self.state_dict(backbone_only))) + + @classmethod + def from_state_dict(cls, dct): + atom37 = np.full((*dct["atom37_mask"].shape, 3), np.nan) + atom37[dct["atom37_mask"]] = dct["atom37_positions"] + dct["atom37_positions"] = atom37 + dct = { + k: (v.astype(np.float32) if k in ["atom37_positions", "confidence"] else v) + for k, v in dct.items() + } + return cls(**dct) + + @classmethod + def from_blob(cls, input: Path | str | io.BytesIO | bytes): + """NOTE: blob + sparse coding + brotli + fp16 reduces memory + of chains from 52G/1M chains to 20G/1M chains, I think this is a good first + shot at compressing and dumping chains to disk. I'm sure there's better ways.""" + match input: + case Path() | str(): + bytes = Path(input).read_bytes() + case io.BytesIO(): + bytes = input.getvalue() + case _: + bytes = input + return cls.from_state_dict(msgpack.loads(brotli.decompress(bytes))) + + def dssp(self): + dssp = DsspApp.annotate_sse(self.atom_array_no_insertions) + full_dssp = np.full(len(self.sequence), "X", dtype=" float | np.ndarray: + """Compute the LDDT between this protein chain and another. + + Arguments: + target (ProteinChain): The other protein chain to compare to. + mobile_inds (list[int], np.ndarray, optional): The indices of the mobile atoms to align. These are NOT residue indices + target_inds (list[int], np.ndarray, optional): The indices of the target atoms to align. These are NOT residue indices + + Returns: + float | np.ndarray: The LDDT score between the two protein chains, either + a single float or per-residue LDDT scores if `per_residue` is True. + """ + + lddt = compute_lddt_ca( + torch.tensor(self.atom37_positions[mobile_inds]).unsqueeze(0), + torch.tensor(target.atom37_positions[target_inds]).unsqueeze(0), + torch.tensor(self.atom37_mask[mobile_inds]).unsqueeze(0), + **kwargs, + ) + return float(lddt) if lddt.numel() == 1 else lddt.numpy().flatten() + + @classmethod + def from_atom37( + cls, + atom37_positions: np.ndarray | torch.Tensor, + *, + id: str | None = None, + sequence: str | None = None, + chain_id: str | None = None, + entity_id: int | None = None, + residue_index: np.ndarray | torch.Tensor | None = None, + insertion_code: np.ndarray | None = None, + confidence: np.ndarray | torch.Tensor | None = None, + ): + if isinstance(atom37_positions, torch.Tensor): + atom37_positions = atom37_positions.cpu().numpy() + if atom37_positions.ndim == 4: + if atom37_positions.shape[0] != 1: + raise ValueError( + f"Cannot handle batched inputs, atom37_positions has shape {atom37_positions.shape}" + ) + atom37_positions = atom37_positions[0] + + assert isinstance(atom37_positions, np.ndarray) + seqlen = atom37_positions.shape[0] + + atom_mask = np.isfinite(atom37_positions).all(-1) + + if id is None: + id = "" + + if sequence is None: + sequence = "A" * seqlen + + if chain_id is None: + chain_id = "A" + + if residue_index is None: + residue_index = np.arange(1, seqlen + 1) + elif isinstance(residue_index, torch.Tensor): + residue_index = residue_index.cpu().numpy() + assert isinstance(residue_index, np.ndarray) + if residue_index.ndim == 2: + if residue_index.shape[0] != 1: + raise ValueError( + f"Cannot handle batched inputs, residue_index has shape {residue_index.shape}" + ) + residue_index = residue_index[0] + assert isinstance(residue_index, np.ndarray) + + if insertion_code is None: + insertion_code = np.array(["" for _ in range(seqlen)]) + + if confidence is None: + confidence = np.ones(seqlen, dtype=np.float32) + elif isinstance(confidence, torch.Tensor): + confidence = confidence.cpu().numpy() + assert isinstance(confidence, np.ndarray) + if confidence.ndim == 2: + if confidence.shape[0] != 1: + raise ValueError( + f"Cannot handle batched inputs, confidence has shape {confidence.shape}" + ) + confidence = confidence[0] + assert isinstance(confidence, np.ndarray) + + return cls( + id=id, + sequence=sequence, + chain_id=chain_id, + entity_id=entity_id, + atom37_positions=atom37_positions, + atom37_mask=atom_mask, + residue_index=residue_index, + insertion_code=insertion_code, + confidence=confidence, + ) + + @classmethod + def from_backbone_atom_coordinates( + cls, + backbone_atom_coordinates: np.ndarray | torch.Tensor, + **kwargs, + ): + """Create a ProteinChain from a set of backbone atom coordinates. + + This function simply expands the seqlen x 3 x 3 array of backbone atom + coordinates to a seqlen x 37 x 3 array of all atom coordinates, with the padded + positions set to infinity. This allows us to use from_atom37 to create the + appropriate ProteinChain object with the appropriate atom37_mask. + + This function passes all kwargs to from_atom37. + """ + if isinstance(backbone_atom_coordinates, torch.Tensor): + backbone_atom_coordinates = backbone_atom_coordinates.cpu().numpy() + if backbone_atom_coordinates.ndim == 4: + if backbone_atom_coordinates.shape[0] != 1: + raise ValueError( + f"Cannot handle batched inputs, backbone_atom_coordinates has " + f"shape {backbone_atom_coordinates.shape}" + ) + backbone_atom_coordinates = backbone_atom_coordinates[0] + + assert isinstance(backbone_atom_coordinates, np.ndarray) + assert backbone_atom_coordinates.ndim == 3 + assert backbone_atom_coordinates.shape[-2] == 3 + assert backbone_atom_coordinates.shape[-1] == 3 + + atom37_positions = np.full( + (backbone_atom_coordinates.shape[0], 37, 3), + np.inf, + dtype=backbone_atom_coordinates.dtype, + ) + atom37_positions[:, :3, :] = backbone_atom_coordinates + + return cls.from_atom37( + atom37_positions=atom37_positions, + **kwargs, + ) + + @classmethod + def from_pdb( + cls, + path: PathOrBuffer, + chain_id: str = "detect", + id: str | None = None, + is_predicted: bool = False, + ) -> "ProteinChain": + """Return a ProteinStructure object from an pdb file. + + Args: + path (str | Path | io.TextIO): Path or buffer to read pdb file from. Should be uncompressed. + id (str, optional): String identifier to assign to structure. Will attempt to infer otherwise. + is_predicted (bool): If True, reads b factor as the confidence readout. Default: False. + chain_id (str, optional): Select a chain corresponding to (author) chain id. "detect" uses the + first detected chain + """ + + if id is not None: + file_id = id + else: + match path: + case Path() | str(): + file_id = Path(path).with_suffix("").name + case _: + file_id = "null" + + atom_array = PDBFile.read(path).get_structure( + model=1, extra_fields=["b_factor"] + ) + if chain_id == "detect": + chain_id = atom_array.chain_id[0] + atom_array = atom_array[ + bs.filter_amino_acids(atom_array) + & ~atom_array.hetero + & (atom_array.chain_id == chain_id) + ] + + entity_id = 1 # Not supplied in PDBfiles + + sequence = "".join( + ( + r + if len(r := PDBData.protein_letters_3to1.get(monomer[0].res_name, "X")) + == 1 + else "X" + ) + for monomer in bs.residue_iter(atom_array) + ) + num_res = len(sequence) + + atom_positions = np.full( + [num_res, RC.atom_type_num, 3], + np.nan, + dtype=np.float32, + ) + atom_mask = np.full( + [num_res, RC.atom_type_num], + False, + dtype=bool, + ) + residue_index = np.full([num_res], -1, dtype=np.int64) + insertion_code = np.full([num_res], "", dtype=" "ProteinChain": + """A simple converter from bs.AtomArray -> ProteinChain. + Uses PDB file format as intermediate.""" + pdb_file = bs.io.pdb.PDBFile() # pyright: ignore + pdb_file.set_structure(atom_array) + + buf = io.StringIO() + pdb_file.write(buf) + buf.seek(0) + return cls.from_pdb(buf, id=id) + + def get_normalization_frame(self) -> Affine3D: + """Given a set of coordinates, compute a single frame. + Specifically, we compute the average position of the N, CA, and C atoms use those 3 points to construct a frame using the Gram-Schmidt algorithm. The average CA position is used as the origin of the frame. + + Returns: + Affine3D: [] tensor of Affine3D frame + """ + coords = torch.from_numpy(self.atom37_positions) + frame = get_protein_normalization_frame(coords) + + return frame + + def apply_frame(self, frame: Affine3D) -> ProteinChain: + """Given a frame, apply the frame to the protein's coordinates. + + Args: + frame (Affine3D): [] tensor of Affine3D frame + + Returns: + ProteinChain: Transformed protein chain + """ + coords = torch.from_numpy(self.atom37_positions).to(frame.trans.dtype) + coords = apply_frame_to_coords(coords, frame) + atom37_positions = coords.numpy() + return replace(self, atom37_positions=atom37_positions) + + def normalize_coordinates(self) -> ProteinChain: + """Normalize the coordinates of the protein chain.""" + return self.apply_frame(self.get_normalization_frame()) + + def infer_oxygen(self) -> ProteinChain: + """Oxygen position is fixed given N, CA, C atoms. Infer it if not provided.""" + O_vector = torch.tensor([0.6240, -1.0613, 0.0103], dtype=torch.float32) + N, CA, C = torch.from_numpy(self.atoms[["N", "CA", "C"]]).float().unbind(dim=1) + N = torch.roll(N, -3) + N[..., -1, :] = torch.nan + + # Get the frame defined by the CA-C-N atom + frames = Affine3D.from_graham_schmidt(CA, C, N) + O = frames.apply(O_vector) + atom37_positions = self.atom37_positions.copy() + atom37_mask = self.atom37_mask.copy() + + atom37_positions[:, RC.atom_order["O"]] = O.numpy() + atom37_mask[:, RC.atom_order["O"]] = ~np.isnan( + atom37_positions[:, RC.atom_order["O"]] + ).any(-1) + new_chain = replace( + self, atom37_positions=atom37_positions, atom37_mask=atom37_mask + ) + return new_chain + + @cached_property + def inferred_cbeta(self) -> np.ndarray: + """Infer cbeta positions based on N, C, CA.""" + N, CA, C = np.moveaxis(self.atoms[["N", "CA", "C"]], 1, 0) + # See usage in trDesign codebase. + # https://github.com/gjoni/trDesign/blob/f2d5930b472e77bfacc2f437b3966e7a708a8d37/02-GD/utils.py#L140 + CB = infer_CB(C, N, CA, 1.522, 1.927, -2.143) + return CB + + def infer_cbeta(self, infer_cbeta_for_glycine: bool = False) -> ProteinChain: + """Return a new chain with inferred CB atoms at all residues except GLY. + + Args: + infer_cbeta_for_glycine (bool): If True, infers a beta carbon for glycine + residues, even though that residue doesn't have one. Default off. + + NOTE: The reason for having this switch in the first place + is that sometimes we want a (inferred) CB coordinate for every residue, + for example for making a pairwise distance matrix, or doing an RMSD + calculation between two designs for a given structural template, w/ + CB atoms. + """ + atom37_positions = self.atom37_positions.copy() + atom37_mask = self.atom37_mask.copy() + + inferred_cbeta_positions = self.inferred_cbeta + if not infer_cbeta_for_glycine: + inferred_cbeta_positions[np.array(list(self.sequence)) == "G", :] = np.NAN + + atom37_positions[:, RC.atom_order["CB"]] = inferred_cbeta_positions + atom37_mask[:, RC.atom_order["CB"]] = ~np.isnan( + atom37_positions[:, RC.atom_order["CB"]] + ).any(-1) + new_chain = replace( + self, atom37_positions=atom37_positions, atom37_mask=atom37_mask + ) + return new_chain + + @cached_property + def pdist_CA(self) -> np.ndarray: + CA = self.atoms["CA"] + pdist_CA = squareform(pdist(CA)) + return pdist_CA + + @cached_property + def pdist_CB(self) -> np.ndarray: + pdist_CB = squareform(pdist(self.inferred_cbeta)) + return pdist_CB + + @classmethod + def as_complex(cls, chains: Sequence[ProteinChain]): + raise RuntimeError( + ".as_complex() has been deprecated in favor of .concat(). " + ".concat() will eventually be deprecated in favor of ProteinComplex..." + ) + + @classmethod + def concat(cls, chains: Sequence[ProteinChain]): + def join_arrays(arrays: Sequence[np.ndarray], sep: np.ndarray): + full_array = [] + for array in arrays: + full_array.append(array) + full_array.append(sep) + full_array = full_array[:-1] + return np.concatenate(full_array, 0) + + sep_tokens = { + "residue_index": np.array([-1]), + "insertion_code": np.array([""]), + "atom37_positions": np.full([1, 37, 3], np.inf), + "atom37_mask": np.zeros([1, 37]), + "confidence": np.array([0]), + } + + array_args: dict[str, np.ndarray] = { + name: join_arrays([getattr(chain, name) for chain in chains], sep) + for name, sep in sep_tokens.items() + } + + return cls( + id=chains[0].id, + sequence=C.CHAIN_BREAK_STR.join(chain.sequence for chain in chains), + chain_id="A", + entity_id=None, + **array_args, + ) + + def select_residue_indices( + self, indices: list[int | str], ignore_x_mismatch: bool = False + ) -> ProteinChain: + numeric_indices = [ + idx if isinstance(idx, int) else int(idx[1:]) for idx in indices + ] + mask = np.isin(self.residue_index, numeric_indices) + new = self[mask] + mismatches = [] + for aa, idx in zip(new.sequence, indices): + if isinstance(idx, int): + continue + if aa == "X" and ignore_x_mismatch: + continue + if aa != idx[0]: + mismatches.append((aa, idx)) + if mismatches: + mismatch_str = "; ".join( + f"Position {idx[1:]}, Expected: {idx[0]}, Received: {aa}" + for aa, idx in mismatches + ) + raise RuntimeError(mismatch_str) + + return new diff --git a/esm/utils/structure/protein_structure.py b/esm/utils/structure/protein_structure.py new file mode 100644 index 0000000..6bea8ad --- /dev/null +++ b/esm/utils/structure/protein_structure.py @@ -0,0 +1,263 @@ +from __future__ import annotations + +from typing import Tuple, TypeVar + +import numpy as np +import torch +import torch.nn.functional as F +from torch import Tensor +from torch.cuda.amp import autocast # type: ignore + +from esm.utils import residue_constants +from esm.utils.misc import unbinpack +from esm.utils.structure.affine3d import Affine3D + +ArrayOrTensor = TypeVar("ArrayOrTensor", np.ndarray, Tensor) + + +def index_by_atom_name( + atom37: ArrayOrTensor, atom_names: str | list[str], dim: int = -2 +) -> ArrayOrTensor: + squeeze = False + if isinstance(atom_names, str): + atom_names = [atom_names] + squeeze = True + indices = [residue_constants.atom_order[atom_name] for atom_name in atom_names] + dim = dim % atom37.ndim + index = tuple(slice(None) if dim != i else indices for i in range(atom37.ndim)) + result = atom37[index] # type: ignore + if squeeze: + result = result.squeeze(dim) + return result + + +def infer_cbeta_from_atom37( + atom37: ArrayOrTensor, L: float = 1.522, A: float = 1.927, D: float = -2.143 +): + """ + Inspired by a util in trDesign: + https://github.com/gjoni/trDesign/blob/f2d5930b472e77bfacc2f437b3966e7a708a8d37/02-GD/utils.py#L92 + + input: atom37, (L)ength, (A)ngle, and (D)ihedral + output: 4th coord + """ + N = index_by_atom_name(atom37, "N", dim=-2) + CA = index_by_atom_name(atom37, "CA", dim=-2) + C = index_by_atom_name(atom37, "C", dim=-2) + + if isinstance(atom37, np.ndarray): + + def normalize(x: ArrayOrTensor): + return x / np.linalg.norm(x, axis=-1, keepdims=True) + + cross = np.cross + else: + normalize = F.normalize # type: ignore + cross = torch.cross + + with np.errstate(invalid="ignore"): # inf - inf = nan is ok here + vec_nca = N - CA + vec_nc = N - C + nca = normalize(vec_nca) + n = normalize(cross(vec_nc, nca)) # type: ignore + m = [nca, cross(n, nca), n] + d = [L * np.cos(A), L * np.sin(A) * np.cos(D), -L * np.sin(A) * np.sin(D)] + return CA + sum([m * d for m, d in zip(m, d)]) + + +@torch.no_grad() +@autocast(enabled=False) +def compute_alignment_tensors( + mobile: torch.Tensor, + target: torch.Tensor, + atom_exists_mask: torch.Tensor | None = None, + sequence_id: torch.Tensor | None = None, +): + """ + Align two batches of structures with support for masking invalid atoms using PyTorch. + + Args: + - mobile (torch.Tensor): Batch of coordinates of structure to be superimposed in shape (B, N, 3) + - target (torch.Tensor): Batch of coordinates of structure that is fixed in shape (B, N, 3) + - atom_exists_mask (torch.Tensor, optional): Mask for Whether an atom exists of shape (B, N) + - sequence_id (torch.Tensor, optional): Sequence id tensor for binpacking. + + Returns: + - centered_mobile (torch.Tensor): Batch of coordinates of structure centered mobile (B, N, 3) + - centroid_mobile (torch.Tensor): Batch of coordinates of mobile centeroid (B, 3) + - centered_target (torch.Tensor): Batch of coordinates of structure centered target (B, N, 3) + - centroid_target (torch.Tensor): Batch of coordinates of target centeroid (B, 3) + - rotation_matrix (torch.Tensor): Batch of coordinates of rotation matrix (B, 3, 3) + - num_valid_atoms (torch.Tensor): Batch of number of valid atoms for alignment (B,) + """ + + # Ensure both batches have the same number of structures, atoms, and dimensions + if sequence_id is not None: + mobile = unbinpack(mobile, sequence_id, pad_value=torch.nan) + target = unbinpack(target, sequence_id, pad_value=torch.nan) + if atom_exists_mask is not None: + atom_exists_mask = unbinpack(atom_exists_mask, sequence_id, pad_value=0) + else: + atom_exists_mask = torch.isfinite(target).all(-1) + + assert mobile.shape == target.shape, "Batch structure shapes do not match!" + + # Number of structures in the batch + batch_size = mobile.shape[0] + + # if [B, Nres, Natom, 3], resize + if mobile.dim() == 4: + mobile = mobile.view(batch_size, -1, 3) + if target.dim() == 4: + target = target.view(batch_size, -1, 3) + if atom_exists_mask is not None and atom_exists_mask.dim() == 3: + atom_exists_mask = atom_exists_mask.view(batch_size, -1) + + # Number of atoms + num_atoms = mobile.shape[1] + + # Apply masks if provided + if atom_exists_mask is not None: + mobile = mobile.masked_fill(~atom_exists_mask.unsqueeze(-1), 0) + target = target.masked_fill(~atom_exists_mask.unsqueeze(-1), 0) + else: + atom_exists_mask = torch.ones( + batch_size, num_atoms, dtype=torch.bool, device=mobile.device + ) + + num_valid_atoms = atom_exists_mask.sum(dim=-1, keepdim=True) + # Compute centroids for each batch + centroid_mobile = mobile.sum(dim=-2, keepdim=True) / num_valid_atoms.unsqueeze(-1) + centroid_target = target.sum(dim=-2, keepdim=True) / num_valid_atoms.unsqueeze(-1) + + # Handle potential division by zero if all atoms are invalid in a structure + centroid_mobile[num_valid_atoms == 0] = 0 + centroid_target[num_valid_atoms == 0] = 0 + + # Center structures by subtracting centroids + centered_mobile = mobile - centroid_mobile + centered_target = target - centroid_target + + centered_mobile = centered_mobile.masked_fill(~atom_exists_mask.unsqueeze(-1), 0) + centered_target = centered_target.masked_fill(~atom_exists_mask.unsqueeze(-1), 0) + + # Compute covariance matrix for each batch + covariance_matrix = torch.matmul(centered_mobile.transpose(1, 2), centered_target) + + # Singular Value Decomposition for each batch + u, _, v = torch.svd(covariance_matrix) + + # Calculate rotation matrices for each batch + rotation_matrix = torch.matmul(u, v.transpose(1, 2)) + + return ( + centered_mobile, + centroid_mobile, + centered_target, + centroid_target, + rotation_matrix, + num_valid_atoms, + ) + + +@torch.no_grad() +@autocast(enabled=False) +def compute_rmsd_no_alignment( + aligned: torch.Tensor, + target: torch.Tensor, + num_valid_atoms: torch.Tensor, + reduction: str = "batch", +) -> torch.Tensor: + """ + Compute RMSD between two batches of structures without alignment. + + Args: + - mobile (torch.Tensor): Batch of coordinates of structure to be superimposed in shape (B, N, 3) + - target (torch.Tensor): Batch of coordinates of structure that is fixed in shape (B, N, 3) + - num_valid_atoms (torch.Tensor): Batch of number of valid atoms for alignment (B,) + - reduction (str): One of "batch", "per_sample", "per_residue". + + Returns: + + If reduction == "batch": + (torch.Tensor): 0-dim, Average Root Mean Square Deviation between the structures for each batch + If reduction == "per_sample": + (torch.Tensor): (B,)-dim, Root Mean Square Deviation between the structures for each batch + If reduction == "per_residue": + (torch.Tensor): (B, N)-dim, Root Mean Square Deviation between the structures for residue in the batch + """ + if reduction not in ("per_residue", "per_sample", "batch"): + raise ValueError("Unrecognized reduction: '{reduction}'") + # Compute RMSD for each batch + diff = aligned - target + if reduction == "per_residue": + mean_squared_error = diff.square().view(diff.size(0), -1, 9).mean(dim=-1) + else: + mean_squared_error = diff.square().sum(dim=(1, 2)) / ( + num_valid_atoms.squeeze(-1) * 3 + ) + + rmsd = torch.sqrt(mean_squared_error) + if reduction in ("per_sample", "per_residue"): + return rmsd + elif reduction == "batch": + avg_rmsd = rmsd.masked_fill(num_valid_atoms.squeeze(-1) == 0, 0).sum() / ( + (num_valid_atoms > 0).sum() + 1e-8 + ) + return avg_rmsd + else: + raise ValueError(reduction) + + +@torch.no_grad() +@autocast(enabled=False) +def compute_affine_and_rmsd( + mobile: torch.Tensor, + target: torch.Tensor, + atom_exists_mask: torch.Tensor | None = None, + sequence_id: torch.Tensor | None = None, +) -> Tuple[Affine3D, torch.Tensor]: + """ + Compute RMSD between two batches of structures with support for masking invalid atoms using PyTorch. + + Args: + - mobile (torch.Tensor): Batch of coordinates of structure to be superimposed in shape (B, N, 3) + - target (torch.Tensor): Batch of coordinates of structure that is fixed in shape (B, N, 3) + - atom_exists_mask (torch.Tensor, optional): Mask for Whether an atom exists of shape (B, N) + - sequence_id (torch.Tensor, optional): Sequence id tensor for binpacking. + + Returns: + - affine (Affine3D): Transformation between mobile and target structure + - avg_rmsd (torch.Tensor): Average Root Mean Square Deviation between the structures for each batch + """ + + ( + centered_mobile, + centroid_mobile, + centered_target, + centroid_target, + rotation_matrix, + num_valid_atoms, + ) = compute_alignment_tensors( + mobile=mobile, + target=target, + atom_exists_mask=atom_exists_mask, + sequence_id=sequence_id, + ) + + # Apply rotation to mobile centroid + translation = torch.matmul(-centroid_mobile, rotation_matrix) + centroid_target + affine = Affine3D.from_tensor_pair( + translation, rotation_matrix.unsqueeze(dim=-3).transpose(-2, -1) + ) + + # Apply transformation to centered structure to compute rmsd + rotated_mobile = torch.matmul(centered_mobile, rotation_matrix) + avg_rmsd = compute_rmsd_no_alignment( + rotated_mobile, + centered_target, + num_valid_atoms, + reduction="batch", + ) + + return affine, avg_rmsd diff --git a/esm/utils/types.py b/esm/utils/types.py new file mode 100644 index 0000000..96ba329 --- /dev/null +++ b/esm/utils/types.py @@ -0,0 +1,27 @@ +from __future__ import annotations + +import io +from dataclasses import dataclass +from pathlib import Path +from typing import Union + +PathLike = Union[str, Path] +PathOrBuffer = Union[PathLike, io.StringIO] + + +@dataclass +class FunctionAnnotation: + """Represents an annotation of a protein's function over a range of residues. + + Fields: + label (str): An entry in either the function_tokens or residue_annotations tokenizer vocabs + start (int): Start index of this annotation. 1-indexed, inclusive. + end (int): End index of this annotation. 1-indexed, inclusive. + """ + + label: str + start: int + end: int + + def to_tuple(self) -> tuple[str, int, int]: + return self.label, self.start, self.end diff --git a/examples/generate.ipynb b/examples/generate.ipynb new file mode 100644 index 0000000..399f2f7 --- /dev/null +++ b/examples/generate.ipynb @@ -0,0 +1,554 @@ +{ + "cells": [ + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ESM3\n", + "ESM3 is a frontier generative model for biology, able to jointly reason across three fundamental biological properties of proteins: sequence, structure, and function. These three data modalities are represented as tracks of discrete tokens at the input and output of ESM3. You can present the model with a combination of partial inputs across the tracks, and ESM3 will provide output predictions for all the tracks.\n", + "\n", + "ESM3 is a generative masked language model. You can prompt it with partial sequence, structure, and function keywords, and iteratively sample masked positions until all positions are unmasked. This iterative sampling is what the `.generate()` function does.\n", + "\n", + "\n", + "\n", + "The ESM3 architecture is highly scalable due to its transformer backbone and all-to-all reasoning over discrete token sequences. At its largest scale, ESM3 was trained with 1.07e24 FLOPs on 2.78 billion proteins and 771 billion unique tokens, and has 98 billion parameters.\n", + "Here we present `esm3-open-small`. With 1.4B parameters it is the smallest and fastest model in the family, trained specifically to be open sourced. ESM3-open is available under a non-commercial license." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%set_env TOKENIZERS_PARALLELISM=false\n", + "!pip install esm\n", + "import numpy as np\n", + "import torch\n", + "!pip install py3Dmol\n", + "import py3Dmol\n", + "from huggingface_hub import login\n", + "\n", + "from esm.utils.structure.protein_chain import ProteinChain\n", + "from esm.models.esm3 import ESM3\n", + "from esm.sdk.api import (\n", + " ESMProtein,\n", + " GenerationConfig,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load `esm-open-small` on GPU" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "login(token=\"YOUR_TOKEN_HERE\")\n", + "model = ESM3.from_pretrained(\"esm3_sm_open_v1\", device=torch.device(\"cuda\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Let's construct a prompt for ESM3, focusing on the task of scaffolding a motif from a natural protein" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we can use the `ProteinChain` class from the `esm` sdk to grab a protein structure from the PDB" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pdb_id = \"1ITU\" # PDB ID corresponding to Renal Dipeptidase\n", + "chain_id = \"A\" # Chain ID corresponding to Renal Dipeptidase in the PDB structure\n", + "renal_dipep_chain = ProteinChain.from_rcsb(pdb_id, chain_id)\n", + "# Alternatively, we could have used ProteinChain.from_pdb() to load a protein structure from a local PDB file" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `ProteinChain` class is a object that makes it easy to work with protein structures. It contains a `sequence` attribute that contains the amino acid sequence of the protein\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(renal_dipep_chain.sequence)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`ProteinChain` also contains an `atom37_positions` numpy array that contains the atomic coordinates of each of the residues in the protein. \n", + "\n", + "The shape of the array is `(n_residues, 37, 3)` where `n_residues` is the number of residues in the protein and 37 is the number of possible distinct atoms that may be present across all amino acids (e.g. the first three atoms are the N, C-alpha, and C atoms corresponding to the protein backbone). The 3 corresponds to the x, y, and z coordinates of each atom. The atom37 representation of protein structure allows us to use a single format to conveniently represent all amino acids -- **coordinates are only present for the atoms that are present in the amino acid and `nan` otherwise**." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(\"atom37_positions shape: \", renal_dipep_chain.atom37_positions.shape)\n", + "print(renal_dipep_chain.atom37_positions[:3])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can visualize the protein chain using the `py3Dmol` library" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# First we can create a `py3Dmol` view object\n", + "view = py3Dmol.view(width=500, height=500)\n", + "# py3Dmol requires the atomic coordinates to be in PDB format, so we convert the `ProteinChain` object to a PDB string\n", + "pdb_str = renal_dipep_chain.to_pdb_string()\n", + "# Load the PDB string into the `py3Dmol` view object\n", + "view.addModel(pdb_str, \"pdb\")\n", + "# Set the style of the protein chain\n", + "view.setStyle({\"cartoon\": {\"color\": \"spectrum\"}})\n", + "# Zoom in on the protein chain\n", + "view.zoomTo()\n", + "# Display the protein chain\n", + "view.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's try to scaffold a motif from this protein using ESM3 -- we'll prompt the model with the sequence and structure of a helix-coil motif from renal dipeptidase and have the model generate a larger scaffold that includes the motif" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "motif_inds = np.arange(123, 146)\n", + "# `ProteinChain` objects can be indexed like numpy arrays to extract the sequence and atomic coordinates of a subset of residues\n", + "motif_sequence = renal_dipep_chain[motif_inds].sequence\n", + "motif_atom37_positions = renal_dipep_chain[motif_inds].atom37_positions\n", + "print(\"Motif sequence: \", motif_sequence)\n", + "print(\"Motif atom37_positions shape: \", motif_atom37_positions.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also visualize the motif in the original chain using `py3Dmol`. We'll color the original chain in grey and the motif in blue" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "view = py3Dmol.view(width=500, height=500)\n", + "view.addModel(pdb_str, \"pdb\")\n", + "view.setStyle({\"cartoon\": {\"color\": \"lightgrey\"}})\n", + "motif_res_inds = (motif_inds + 1).tolist() # residue indices are 1-indexed in PDB files, so we add 1 to the indices\n", + "view.addStyle({\"resi\": motif_res_inds}, {\"cartoon\": {\"color\": \"cyan\"}})\n", + "view.zoomTo()\n", + "view.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we can use the `ESMProtein` class to construct a prompt that will instruct ESM3 to scaffold the motif" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "prompt_length = 200\n", + "# First, we can construct a sequence prompt of all masks\n", + "sequence_prompt = [\"_\"]*prompt_length\n", + "# Then, we can randomly insert the motif sequence into the prompt (we randomly choose 72 here)\n", + "sequence_prompt[72:72+len(motif_sequence)] = list(motif_sequence)\n", + "sequence_prompt = \"\".join(sequence_prompt)\n", + "print(\"Sequence prompt: \", sequence_prompt)\n", + "print(\"Length of sequence prompt: \", len(sequence_prompt))\n", + "\n", + "# Next, we can construct a structure prompt of all nan coordinates\n", + "structure_prompt = torch.full((prompt_length, 37, 3), np.nan)\n", + "# Then, we can insert the motif atomic coordinates into the prompt, starting at index 72\n", + "structure_prompt[72:72+len(motif_atom37_positions)] = torch.tensor(motif_atom37_positions)\n", + "print(\"Structure prompt shape: \", structure_prompt.shape)\n", + "print(\"Indices with structure conditioning: \", torch.where(~torch.isnan(structure_prompt).any(dim=-1).all(dim=-1))[0].tolist())\n", + "\n", + "# Finally, we can use the ESMProtein class to compose the sequence and structure prompts into a single prompt that can be passed to ESM3\n", + "protein_prompt = ESMProtein(sequence=sequence_prompt, coordinates=structure_prompt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we can use the `generate` method of the model to iteratively sample a protein sequence based on the prompt. Under the hood, the model performs num_steps forward passes and samples a set of tokens at each step until the chosen track being generated is fully unmasked. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# We'll have to first construct a `GenerationConfig` object that specifies the decoding parameters that we want to use\n", + "sequence_generation_config = GenerationConfig(\n", + " track=\"sequence\", # We want ESM3 to generate tokens for the sequence track\n", + " num_steps=sequence_prompt.count(\"_\") // 2, # We'll use num(mask tokens) // 2 steps to decode the sequence\n", + " temperature=0.5, # We'll use a temperature of 0.5 to control the randomness of the decoding process\n", + ")\n", + "\n", + "# Now, we can use the `generate` method of the model to decode the sequence\n", + "sequence_generation = model.generate(protein_prompt, sequence_generation_config)\n", + "print(\"Sequence Prompt:\\n\\t\", protein_prompt.sequence)\n", + "print(\"Generated sequence:\\n\\t\", sequence_generation.sequence)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also use the `generate` method to predict the structure of the generated sequence by iteratively sampling structure tokens." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "structure_prediction_config = GenerationConfig(\n", + " track=\"structure\", # We want ESM3 to generate tokens for the structure track\n", + " num_steps=len(sequence_generation) // 8,\n", + " temperature=0.7, \n", + ")\n", + "structure_prediction_prompt = ESMProtein(sequence=sequence_generation.sequence)\n", + "structure_prediction = model.generate(structure_prediction_prompt, structure_prediction_config)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we can visualize the generated structure using `py3Dmol`. We'll visualize the generated structure (right, green) alongside the original structure (left, grey) from which the motif was drawn. The motif residues are colored in cyan." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Convert the generated structure to a back into a ProteinChain object\n", + "structure_prediction_chain = structure_prediction.to_protein_chain()\n", + "# Align the generated structure to the original structure using the motif residues\n", + "motif_inds_in_generation = np.arange(72, 72+len(motif_sequence))\n", + "structure_prediction_chain.align(renal_dipep_chain, mobile_inds=motif_inds_in_generation, target_inds=motif_inds)\n", + "crmsd = structure_prediction_chain.rmsd(renal_dipep_chain, mobile_inds=motif_inds_in_generation, target_inds=motif_inds)\n", + "print(\"cRMSD of the motif in the generated structure vs the original structure: \", crmsd)\n", + "\n", + "view = py3Dmol.view(width=1000, height=500, viewergrid=(1, 2))\n", + "view.addModel(pdb_str, \"pdb\", viewer=(0, 0))\n", + "view.addModel(structure_prediction_chain.to_pdb_string(), \"pdb\", viewer=(0, 1))\n", + "view.setStyle({\"cartoon\": {\"color\": \"lightgrey\"}}, viewer=(0, 0))\n", + "view.setStyle({\"cartoon\": {\"color\": \"lightgreen\"}}, viewer=(0, 1))\n", + "view.addStyle({\"resi\": motif_res_inds}, {\"cartoon\": {\"color\": \"cyan\"}}, viewer=(0, 0))\n", + "view.addStyle({\"resi\": (motif_inds_in_generation+1).tolist()}, {\"cartoon\": {\"color\": \"cyan\"}}, viewer=(0, 1))\n", + "view.zoomTo()\n", + "view.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Secondary Structure Editing Example: Helix Shortening" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we can try another generation task with ESM3. We'll use the secondary structure track, along with the sequence track, to shorten a helix-coil-helix region (residues 39-111) in a protein structure (colored in blue below)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "helix_shortening_chain = ProteinChain.from_rcsb(\"7XBQ\", \"A\")\n", + "view = py3Dmol.view(width=500, height=500)\n", + "view.addModel(helix_shortening_chain.to_pdb_string(), \"pdb\")\n", + "view.setStyle({\"cartoon\": {\"color\": \"lightgrey\"}})\n", + "helix_region = np.arange(38, 111) # zero-indexed\n", + "view.addStyle({\"resi\": (helix_region + 1).tolist()}, {\"cartoon\": {\"color\":\"lightblue\"}})\n", + "view.zoomTo()\n", + "view.show()\n", + "helix_shortening_ss8 = \"CCCSHHHHHHHHHHHTTCHHHHHHHHHHHHHTCSSCCCCHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHTTCHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIGGGCCSHHHHHHHHHHHHHHHHHHHHHCCHHHHHHHHHHHHHHHHHHHHHHHHHSCTTCHHHHHHHHHHHHHIIIIICCHHHHHHHHHHHHHHHHTTCTTCCSSHHHHHHHHHHHHHHHHHHHC\"\n", + "print(\"Secondary structure of protein: (H: Alpha Helix, E: Beta Strand, C: Coil) \\n\\t\", helix_shortening_ss8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The helix-coil-helix region in the original protein is 73 residues long. We will try to shorten it to 45 residues by prompting the model with partial sequence and secondary structure" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "shortened_region_length = 45\n", + "\n", + "# We'll construct a sequence prompt that masks the (shortened) helix-coil-helix region, but leaves the flanking regions unmasked\n", + "sequence_prompt = helix_shortening_chain.sequence[:helix_region[0]] + \"_\" * shortened_region_length + helix_shortening_chain.sequence[helix_region[-1] + 1:]\n", + "print(\"Sequence prompt:\\n\\t\", sequence_prompt)\n", + "\n", + "# We'll construct a secondary structure prompt that retains the secondary structure of the flanking regions, and shortens the lengths of helices in the helix-coil-helix region\n", + "ss8_prompt = helix_shortening_ss8[:helix_region[0]] + (((shortened_region_length - 3) // 2) * \"H\" + \"C\"*3 + ((shortened_region_length - 3) // 2) * \"H\") + helix_shortening_ss8[helix_region[-1] + 1:]\n", + "print(\"SS8 prompt:\\n\\t\", ss8_prompt)\n", + "print(\"Proposed SS8 for shortened helix-coil-helix region:\\n\\t\", \" \"*helix_region[0] + ss8_prompt[helix_region[0]:helix_region[0]+45])\n", + "\n", + "print(\"\")\n", + "print(\"Original sequence:\\n\\t\", helix_shortening_chain.sequence)\n", + "print(\"Original SS8:\\n\\t\", helix_shortening_ss8)\n", + "print(\"Original SS8 for helix-coil-helix region:\\n\\t\", \" \"*helix_region[0] + helix_shortening_ss8[helix_region[0]:helix_region[-1]+1])\n", + "\n", + "\n", + "# We can again use the ESMProtein class to compose the sequence and secondary structure prompts into a single prompt that can be passed to ESM3\n", + "protein_prompt = ESMProtein(sequence=sequence_prompt, secondary_structure=ss8_prompt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can again use the `generate` method of the model to iteratively decode a protein sequence based on the prompt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(\"Generating protein sequence...\")\n", + "sequence_generation = model.generate(protein_prompt, GenerationConfig(track=\"sequence\", num_steps=protein_prompt.sequence.count(\"_\") // 2, temperature=0.5))\n", + "print(\"Folding protein...\")\n", + "structure_prediction = model.generate(ESMProtein(sequence=sequence_generation.sequence), GenerationConfig(track=\"structure\", num_steps=len(protein_prompt) // 4, temperature=0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we can visualize the generated structure using `py3Dmol`. We'll visualize the generated structure (right) alongside the original structure (left) from which the motif was drawn. The helix-coil-helix region in the original structure is colored in blue and the shortened region in the generated structure is colored in pink." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "predicted_chain = structure_prediction.to_protein_chain()\n", + "predicted_chain = predicted_chain.align(helix_shortening_chain, mobile_inds=np.arange(len(predicted_chain) - 120, len(predicted_chain)), target_inds=np.arange(len(helix_shortening_chain) - 120, len(helix_shortening_chain)))\n", + "view = py3Dmol.view(width=1000, height=500, viewergrid=(1, 2))\n", + "view.addModel(helix_shortening_chain.to_pdb_string(), \"pdb\", viewer=(0, 0))\n", + "view.addModel(predicted_chain.to_pdb_string(), \"pdb\", viewer=(0, 1))\n", + "view.setStyle({\"cartoon\": {\"color\": \"lightgrey\"}})\n", + "view.addStyle({\"resi\": (helix_region + 1).tolist()}, {\"cartoon\": {\"color\":\"lightblue\"}},viewer=(0, 0))\n", + "view.addStyle({\"resi\": (np.arange(helix_region[0], helix_region[0] + 45) + 1).tolist()}, {\"cartoon\": {\"color\":\"pink\"}},viewer=(0, 1))\n", + "view.zoomTo()\n", + "view.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# SASA Editing Example: Exposing a buried helix" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's grab 1LBS from the PDB and visualize it using `py3Dmol`. 1LBS has an alternating alpha-beta sandwich fold, with a buried helix in the center, highlighted in red" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lipase_chain = ProteinChain.from_rcsb(\"1LBS\", \"A\")\n", + "span_start = 105\n", + "span_end = 116\n", + "view = py3Dmol.view(width=500, height=500)\n", + "view.addModel(lipase_chain.to_pdb_string(), \"pdb\")\n", + "view.setStyle({\"cartoon\": {\"color\": \"lightgrey\"}})\n", + "view.addStyle({\"resi\": (np.arange(span_start, span_end) + 1).tolist()}, {\"cartoon\": {\"color\":\"red\"}})\n", + "view.zoomTo()\n", + "view.show()\n", + "lipase_ss8 = \"CCSSCCCCSSCHHHHHHTEEETTBBTTBCSSEEEEECCTTCCHHHHHTTTHHHHHHHTTCEEEEECCTTTTCSCHHHHHHHHHHHHHHHHHHTTSCCEEEEEETHHHHHHHHHHHHCGGGGGTEEEEEEESCCTTCBGGGHHHHHTTCBCHHHHHTBTTCHHHHHHHHTTTTBCSSCEEEEECTTCSSSCCCCSSSTTSTTCCBTSEEEEHHHHHCTTCCCCSHHHHHBHHHHHHHHHHHHCTTSSCCGGGCCSTTCCCSBCTTSCHHHHHHHHSTHHHHHHHHHHSCCBSSCCCCCGGGGGGSTTCEETTEECCC\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can construct a multimodal prompt for ESM3 to instruct it to expose the buried helix as follows:\n", + "1. Prompt with the **structure** of the buried helix highlighted in red -- this will prompt ESM3 to generate a protein that contains that same helix\n", + "2. Prompt with high **SASA** values for the residues in the buried helix -- this will prompt ESM3 to expose the helix to the surface of the protein" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "structure_prompt = torch.full((len(lipase_chain), 37, 3), torch.nan)\n", + "structure_prompt[span_start:span_end] = torch.tensor(lipase_chain[span_start:span_end].atom37_positions, dtype=torch.float32) \n", + "\n", + "sasa_prompt = [None]*len(lipase_chain)\n", + "sasa_prompt[span_start:span_end] = [40.0]*(span_end - span_start)\n", + "\n", + "print(\"SASA prompt (just for buried region): \", sasa_prompt[span_start:span_end])\n", + "\n", + "protein_prompt = ESMProtein(sequence=\"_\"*len(lipase_chain), coordinates=structure_prompt, sasa=sasa_prompt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is a more difficult task, so you may need to sample more generations from ESM before you find a solution. We'll sample 32 here and sort by the generations with the highest predicted TM-score (pTM) by ESM3. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "generated_proteins = []\n", + "N_SAMPLES = 32\n", + "for i in range(N_SAMPLES):\n", + " print(\"Generating protein sequence...\")\n", + " sequence_generation = model.generate(protein_prompt, GenerationConfig(track=\"sequence\", num_steps=len(protein_prompt) // 8, temperature=0.7))\n", + " print(\"Folding protein...\")\n", + " structure_prediction = model.generate(ESMProtein(sequence=sequence_generation.sequence), GenerationConfig(track=\"structure\", num_steps=len(protein_prompt) // 32))\n", + " generated_proteins.append(structure_prediction)\n", + "\n", + "# Sort generations by ptm\n", + "generated_proteins = sorted(generated_proteins, key=lambda x: x.ptm.item(), reverse=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's visualize the top 4 generations by pTM, alongside with the original protein (on the left)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "N_SAMPLES_TO_SHOW = 4\n", + "view = py3Dmol.view(width=1000, height=500, viewergrid=(1, N_SAMPLES_TO_SHOW+1))\n", + "view.addModel(lipase_chain.to_pdb_string(), \"pdb\", viewer=(0, 0))\n", + "for i in range(N_SAMPLES_TO_SHOW):\n", + " print(\"PTM of generated protein {}: {:.2f}\".format(i+1, generated_proteins[i].ptm.item()))\n", + " view.addModel(generated_proteins[i].to_protein_chain().to_pdb_string(), \"pdb\", viewer=(0, i+1))\n", + "view.setStyle({\"cartoon\": {\"color\": \"lightgrey\"}})\n", + "view.addStyle({\"resi\": (np.arange(span_start, span_end) + 1).tolist()}, {\"cartoon\": {\"color\": \"red\"}})\n", + "view.zoomTo()\n", + "view.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/invfold.py b/examples/invfold.py new file mode 100644 index 0000000..6fa90d0 --- /dev/null +++ b/examples/invfold.py @@ -0,0 +1,37 @@ +import torch +import torch.nn.functional as F + +from esm.pretrained import ( + ESM3_sm_open_v0, + ESM3_structure_encoder_v0, +) +from esm.tokenization.sequence_tokenizer import ( + EsmSequenceTokenizer, +) +from esm.utils.structure.protein_chain import ProteinChain + +if __name__ == "__main__": + tokenizer = EsmSequenceTokenizer() + encoder = ESM3_structure_encoder_v0("cuda") + model = ESM3_sm_open_v0("cuda") + + chain = ProteinChain.from_pdb("esm/data/1utn.pdb") + coords, plddt, residue_index = chain.to_structure_encoder_inputs() + coords = coords.cuda() + plddt = plddt.cuda() + residue_index = residue_index.cuda() + _, structure_tokens = encoder.encode(coords, residue_index=residue_index) + + # Add BOS/EOS padding + coords = F.pad(coords, (0, 0, 0, 0, 1, 1), value=torch.inf) + plddt = F.pad(plddt, (1, 1), value=0) + structure_tokens = F.pad(structure_tokens, (1, 1), value=0) + structure_tokens[:, 0] = 4098 + structure_tokens[:, -1] = 4097 + + output = model.forward( + structure_coords=coords, per_res_plddt=plddt, structure_tokens=structure_tokens + ) + sequence_tokens = torch.argmax(output.sequence_logits, dim=-1) + sequence = tokenizer.decode(sequence_tokens[0]) + print(sequence) diff --git a/examples/local_client.py b/examples/local_client.py new file mode 100644 index 0000000..e963317 --- /dev/null +++ b/examples/local_client.py @@ -0,0 +1,76 @@ +from esm.models.esm3 import ESM3 +from esm.sdk.api import ( + ESM3InferenceClient, + ESMProtein, + GenerationConfig, + SamplingConfig, + SamplingTrackConfig, +) +from esm.utils.structure.protein_chain import ProteinChain +from esm.utils.types import FunctionAnnotation + + +def get_sample_protein() -> ESMProtein: + protein = ProteinChain.from_rcsb("1utn") + protein = ESMProtein.from_protein_chain(protein) + protein.function_annotations = [ + # Peptidase S1A, chymotrypsin family: https://www.ebi.ac.uk/interpro/structure/PDB/1utn/ + FunctionAnnotation(label="peptidase", start=100, end=114), + FunctionAnnotation(label="chymotrypsin", start=190, end=202), + ] + return protein + + +def main(client: ESM3InferenceClient): + # Single step decoding + protein = get_sample_protein() + protein.function_annotations = None + protein = client.encode(protein) + single_step_protein = client.forward_and_sample( + protein, + SamplingConfig(structure=SamplingTrackConfig(topk_logprobs=2)), + ) + single_step_protein.protein_tensor.sequence = protein.sequence + single_step_protein = client.decode(single_step_protein.protein_tensor) + + # Folding + protein = get_sample_protein() + sequence_length = len(protein.sequence) # type: ignore + num_steps = int(sequence_length / 16) + protein.coordinates = None + protein.function_annotations = None + protein.sasa = None + folded_protein = client.generate( + protein, + GenerationConfig(track="structure", schedule="cosine", num_steps=num_steps), + ) + folded_protein.to_pdb("./sample_folded.pdb") + + # Inverse Folding + protein = get_sample_protein() + protein.sequence = None + protein.sasa = None + protein.function_annotations = None + inv_folded_protein = client.generate( + protein, + GenerationConfig(track="sequence", schedule="cosine", num_steps=num_steps), + ) + inv_folded_protein.to_pdb("./sample_inv_folded.pdb") + + # Chain of Thought (Function -> Secondary Structure -> Structure -> Sequence) + cot_protein = get_sample_protein() + cot_protein.sequence = "_" * len(cot_protein.sequence) # type: ignore + cot_protein.coordinates = None + cot_protein.sasa = None + cot_protein_tensor = client.encode(cot_protein) + for cot_track in ["secondary_structure", "structure", "sequence"]: + cot_protein_tensor = client.generate( + cot_protein_tensor, + GenerationConfig(track=cot_track, schedule="cosine", num_steps=10), + ) + cot_protein = client.decode(cot_protein_tensor) + cot_protein.to_pdb("./sample_cot.pdb") + + +if __name__ == "__main__": + main(ESM3.from_pretrained("esm3_sm_open_v1")) diff --git a/examples/seqfun_struct.py b/examples/seqfun_struct.py new file mode 100644 index 0000000..90b8bac --- /dev/null +++ b/examples/seqfun_struct.py @@ -0,0 +1,121 @@ +import random + +import torch +import torch.nn.functional as F + +from esm.pretrained import ( + ESM3_function_decoder_v0, + ESM3_sm_open_v0, + ESM3_structure_decoder_v0, +) +from esm.tokenization.function_tokenizer import ( + InterProQuantizedTokenizer as EsmFunctionTokenizer, +) +from esm.tokenization.sequence_tokenizer import ( + EsmSequenceTokenizer, +) +from esm.utils.constants.esm3 import ( + SEQUENCE_MASK_TOKEN, +) +from esm.utils.structure.protein_chain import ProteinChain +from esm.utils.types import FunctionAnnotation + + +@torch.no_grad() +def main(): + tokenizer = EsmSequenceTokenizer() + function_tokenizer = EsmFunctionTokenizer() + + model = ESM3_sm_open_v0("cuda") + + # PDB 1UTN + sequence = "MKTFIFLALLGAAVAFPVDDDDKIVGGYTCGANTVPYQVSLNSGYHFCGGSLINSQWVVSAAHCYKSGIQVRLGEDNINVVEGNEQFISASKSIVHPSYNSNTLNNDIMLIKLKSAASLNSRVASISLPTSCASAGTQCLISGWGNTKSSGTSYPDVLKCLKAPILSDSSCKSAYPGQITSNMFCAGYLEGGKDSCQGDSGGPVVCSGKLQGIVSWGSGCAQKNKPGVYTKVCNYVSWIKQTIASN" + tokens = tokenizer.encode(sequence) + + # Calculate the number of tokens to replace, excluding the first and last token + num_to_replace = int((len(tokens) - 2) * 0.75) + + # Randomly select indices to replace, excluding the first and last index + indices_to_replace = random.sample(range(1, len(tokens) - 1), num_to_replace) + + # Replace selected indices with 32 + for idx in indices_to_replace: + tokens[idx] = SEQUENCE_MASK_TOKEN + sequence_tokens = torch.tensor(tokens, dtype=torch.int64) + + function_annotations = [ + # Peptidase S1A, chymotrypsin family + FunctionAnnotation(label="peptidase", start=100, end=114), + FunctionAnnotation(label="chymotrypsin", start=190, end=202), + ] + function_tokens = function_tokenizer.tokenize(function_annotations, len(sequence)) + function_tokens = function_tokenizer.encode(function_tokens) + + function_tokens = function_tokens.cuda().unsqueeze(0) + sequence_tokens = sequence_tokens.cuda().unsqueeze(0) + + output = model.forward( + sequence_tokens=sequence_tokens, function_tokens=function_tokens + ) + return sequence, output, sequence_tokens + + +@torch.no_grad() +def decode(sequence, output, sequence_tokens): + # To save on VRAM, we load these in separate functions + decoder = ESM3_structure_decoder_v0("cuda") + function_decoder = ESM3_function_decoder_v0("cuda") + function_tokenizer = EsmFunctionTokenizer() + + structure_tokens = torch.argmax(output.structure_logits, dim=-1) + structure_tokens = ( + structure_tokens.where(sequence_tokens != 0, 4098) # BOS + .where(sequence_tokens != 2, 4097) # EOS + .where(sequence_tokens != 31, 4100) # Chainbreak + ) + + bb_coords = ( + decoder.decode( + structure_tokens, + torch.ones_like(sequence_tokens), + torch.zeros_like(sequence_tokens), + )["bb_pred"] + .detach() + .cpu() + ) + + chain = ProteinChain.from_backbone_atom_coordinates( + bb_coords, sequence="X" + sequence + "X" + ) + chain.infer_oxygen().to_pdb("hello.pdb") + + # Function prediction + p_none_threshold = 0.05 + log_p = F.log_softmax(output.function_logits[:, 1:-1, :], dim=3).squeeze(0) + + # Choose which positions have no predicted function. + log_p_nones = log_p[:, :, function_tokenizer.vocab_to_index[""]] + p_none = torch.exp(log_p_nones).mean(dim=1) # "Ensemble of predictions" + where_none = p_none > p_none_threshold # (length,) + + log_p[~where_none, :, function_tokenizer.vocab_to_index[""]] = -torch.inf + function_token_ids = torch.argmax(log_p, dim=2) + function_token_ids[where_none, :] = function_tokenizer.vocab_to_index[""] + + predicted_function = function_decoder.decode( + function_token_ids, + tokenizer=function_tokenizer, + annotation_threshold=0.1, + annotation_min_length=5, + annotation_gap_merge_max=3, + ) + + print("function prediction:") + print(predicted_function["interpro_preds"].nonzero()) + print(predicted_function["function_keywords"]) + + +if __name__ == "__main__": + sequence, output, sequence_tokens = main() + torch.cuda.empty_cache() + decode(sequence, output, sequence_tokens) diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..b9b4c67 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,40 @@ +[project] +name = "esm" +version = "3.0.0" +description = "EvolutionaryScale open model repository" +readme = "README.md" +requires-python = ">=3.10" +license = {file = "LICENSE.txt"} + +authors = [ + {name = "EvolutionaryScale Team"} +] + +maintainers = [ + {name = "Zeming Lin", email = "zeming+esm@evolutionaryscale.ai" } +] + +classifiers = [ + "Development Status :: 3 - Alpha", + "Topic :: Scientific/Engineering :: Bio-Informatics", + "Programming Language :: Python :: 3.10", +] + +dependencies = [ + "torch>=2.0.0", + "torchvision", + "torchtext", + "transformers", + "ipython", + "einops", + "biotite", + "msgpack-numpy", + "biopython", + "scikit-learn", + "brotli", + "attrs", + "pandas", +] + +[tool.setuptools] +packages = ["esm"]