Add files using upload-large-folder tool

.gitattributes

@@ -58,3 +58,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+data_raw/reactome/UniProt2Reactome_All_Levels.txt filter=lfs diff=lfs merge=lfs -text
+data_raw/mutation_ppi_external/intact/mutations.tsv filter=lfs diff=lfs merge=lfs -text
+data_raw/ptmd/unzipped/PTMD2_Ubiquitination.csv filter=lfs diff=lfs merge=lfs -text
+data_raw/ptmd/unzipped/PTMD2_Phosphorylation.csv filter=lfs diff=lfs merge=lfs -text

data_raw/amplify/AMPLIFY_120M/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

data_raw/amplify/AMPLIFY_120M/AMPLIFY_120M_SHA256.tsv

@@ -0,0 +1,11 @@
+relative_path	size_bytes	sha256	repository	revision
+.gitattributes	1519	11ad7efa24975ee4b0c3c3a38ed18737f0658a5f75a0a96787b576a78a023361	chandar-lab/AMPLIFY_120M	d918a9e8c64dc43f6ec4996022c3deba14d66470
+README.md	5579	23d6eb44faa2283b2a7c71cbdd900596ffc5b2b557c33ae3aef233295298bb3f	chandar-lab/AMPLIFY_120M	d918a9e8c64dc43f6ec4996022c3deba14d66470
+amplify.py	11950	aaefa417bcc6562cab45d244669c765b8fc0238af6712958e63d1eb52d81b3f2	chandar-lab/AMPLIFY_120M	d918a9e8c64dc43f6ec4996022c3deba14d66470
+config.json	906	b28a52518d6006d5f0ceda4737b8623a30760fc79294f84771eb061b7bb8c5d3	chandar-lab/AMPLIFY_120M	d918a9e8c64dc43f6ec4996022c3deba14d66470
+model.safetensors	473126988	a2375f1f54cbe00bdbe27eedcd039c92d12f165720c0349bc582a6eb42c099ce	chandar-lab/AMPLIFY_120M	d918a9e8c64dc43f6ec4996022c3deba14d66470
+rmsnorm.py	1172	3f63bdd73a4c8c35f67622f799e592062066b602c82d6c98569754facdbb382d	chandar-lab/AMPLIFY_120M	d918a9e8c64dc43f6ec4996022c3deba14d66470
+rotary.py	3337	ab73337b627e7a104d2c0c7299f929d6da836417d8b8203c47e3a9bc2d3918ab	chandar-lab/AMPLIFY_120M	d918a9e8c64dc43f6ec4996022c3deba14d66470
+special_tokens_map.json	125	bd9d67e56bef291e8ef29559a842f0bc62e46799dae42c63490a77a688682275	chandar-lab/AMPLIFY_120M	d918a9e8c64dc43f6ec4996022c3deba14d66470
+tokenizer.json	2619	07043215b16802129fee788489f51e245f8d28e1d05fedb42cdb6900749f54db	chandar-lab/AMPLIFY_120M	d918a9e8c64dc43f6ec4996022c3deba14d66470
+tokenizer_config.json	1234	935811b1dcacff5e6763c260a00599244630d63a6280a341c82918c513fa1b12	chandar-lab/AMPLIFY_120M	d918a9e8c64dc43f6ec4996022c3deba14d66470

data_raw/amplify/AMPLIFY_120M/README.md

@@ -0,0 +1,117 @@
+---
+license: mit
+datasets:
+  - chandar-lab/UR100P
+language:
+  - en
+tags:
+  - biology
+---
+
+## AMPLIFY
+
+AMPLIFY is an efficient, state-of-the-art protein language model pre-trained using masked language modeling on UniRef100, OAS, and SCOP ([UR100P](https://huggingface.co/datasets/chandar-lab/UR100P)). AMPLIFY can generate residue and protein embeddings, suggest mutations, differentiate disordered proteins from non-protein sequences, and much more. AMPLIFY is available in two sizes, 120M and 350M parameters, with the `_base` models not extended beyond 512 residues (Stage 1). The model architecture and pre-training procedure are detailed below. For more details, please refer to the [accompanying paper](https://www.biorxiv.org/content/10.1101/2024.09.23.614603v1).
+
+- [`AMPLIFY_350M`](https://huggingface.co/chandar-lab/AMPLIFY_350M)
+- [`AMPLIFY_350M_base`](https://huggingface.co/chandar-lab/AMPLIFY_350M_base)
+- [`AMPLIFY_120M`](https://huggingface.co/chandar-lab/AMPLIFY_120M)
+- [`AMPLIFY_120M_base`](https://huggingface.co/chandar-lab/AMPLIFY_120M_base)
+
+### Model Descritpion
+
+|                                | AMPLIFY 120M | AMPLIFY 350M |
+| :----------------------------- | -----------: | -----------: |
+| `hidden-size`                  |          640 |          960 |
+| `num-hidden-layers`            |           24 |           32 |
+| `num-attention-heads`          |           10 |           15 |
+| `intermediate-size`            |         2560 |         3840 |
+| `max-position-embeddings`      |         2048 |         2048 |
+| `vocab-size`                   |           27 |           27 |
+| `rope-theta`                   |        10000 |        10000 |
+| `dropout-prob`                 |            0 |            0 |
+| `embedding-init-range`         |         0.02 |         0.02 |
+| `norm-eps`                     |      1.0e-05 |      1.0e-05 |
+| `hidden-act`                   |       swiglu |       swiglu |
+| `pre-activation-layer-norm`    |         true |         true |
+| `layer-norm-after-embedding`   |        false |        false |
+| `layer-norm-before-last-layer` |         true |         true |
+| `rms-norm`                     |         true |         true |
+| `ffn-bias`                     |        false |        false |
+| `attn-bias`                    |        false |        false |
+
+### Training Descritpion
+
+|                     |     Stage 1 |                      Stage 2 |
+| :------------------ | ----------: | ---------------------------: |
+| `dataset`           |      UR100P |                       UR100P |
+| `max-steps`         |     1000000 | 25000 (120M) or 50000 (350M) |
+| `max-length`        |         512 |                         2048 |
+| `optimizer`         |       adamw |                        adamw |
+| `lr`                |       0.001 |                       0.0001 |
+| `betas`             | (0.9, 0.95) |                  (0.9, 0.95) |
+| `eps`               |     1.0e-08 |                      1.0e-08 |
+| `weight-decay`      |        0.01 |                         0.01 |
+| `scheduler`         | cosinedecay |                         none |
+| `warmup-steps`      |       1,000 |                         none |
+| `final-step`        |     900,000 |                         none |
+| `warmup-steps`      |       1,000 |                         none |
+| `gradient-clipping` |         1.0 |                          1.0 |
+| `tf32`              |        true |                         true |
+| `mixed-precision`   |        bf16 |                         bf16 |
+| `padding`           |  max-length |                   max-length |
+| `random-truncate`   |        true |                         true |
+| `mask-probability`  |        0.15 |                         0.15 |
+| `total-batch-size`  |        4096 |                         4096 |
+| `deepspeed`         |        true |                         true |
+| `zero-stage`        |           3 |                            3 |
+
+## Get Started
+
+```python
+from transformers import AutoModel
+from transformers import AutoTokenizer
+from datasets import load_dataset
+
+# Load AMPLIFY and tokenizer
+model = AutoModel.from_pretrained("chandar-lab/AMPLIFY_350M", trust_remote_code=True)
+tokenizer = AutoTokenizer.from_pretrained("chandar-lab/AMPLIFY_350M", trust_remote_code=True)
+
+# Move the model to GPU (required due to Flash Attention)
+model = model.to("cuda")
+
+# Load the UniProt validation set
+dataset = load_dataset("chandar-lab/UR100P", data_dir="UniProt", split="test")
+
+for sample in dataset:
+    # Protein
+    print("Sample: ", sample["name"], sample["sequence"])
+
+    # Tokenize the protein
+    input = tokenizer.encode(sample["sequence"], return_tensors="pt")
+    print("Input: ", input)
+
+    # Move to the GPU and make a prediction
+    input = input.to("cuda")
+    output = model(input)
+    print("Output: ", output)
+
+    break
+```
+
+## Citations
+
+If you find the models useful in your research, we ask that you cite the paper:
+
+```bibtex
+@article{Fournier2024.09.23.614603,
+	title        = {Protein Language Models: Is Scaling Necessary?},
+	author       = {Fournier, Quentin and Vernon, Robert M. and van der Sloot, Almer and Schulz, Benjamin and Chandar, Sarath and Langmead, Christopher James},
+	year         = {2024},
+	journal      = {bioRxiv},
+	publisher    = {Cold Spring Harbor Laboratory},
+	doi          = {10.1101/2024.09.23.614603},
+	url          = {https://www.biorxiv.org/content/early/2024/09/23/2024.09.23.614603},
+	elocation-id = {2024.09.23.614603},
+	eprint       = {https://www.biorxiv.org/content/early/2024/09/23/2024.09.23.614603.full.pdf}
+}
+```

data_raw/amplify/AMPLIFY_120M/amplify.py

@@ -0,0 +1,304 @@
+# From https://stackoverflow.com/a/23689767
+# From https://github.com/pytorch/pytorch/issues/97899
+# From https://github.com/facebookresearch/llama/blob/main/llama/model.py
+
+import torch
+from torch import nn
+from torch.nn.functional import scaled_dot_product_attention
+try:
+    from xformers.ops import SwiGLU, memory_efficient_attention
+    XFORMERS_AVAILABLE = True
+except Exception:
+    XFORMERS_AVAILABLE = False
+    class SwiGLU(nn.Module):
+        def __init__(self, dim, hidden, out, bias=False):
+            super().__init__()
+            self.w12 = nn.Linear(dim, hidden * 2, bias=bias)
+            self.w3 = nn.Linear(hidden, out, bias=bias)
+        def forward(self, x):
+            a, b = self.w12(x).chunk(2, dim=-1)
+            return self.w3(torch.nn.functional.silu(a) * b)
+    def memory_efficient_attention(query, key, value, attn_bias=None, p=0.0):
+        q = query.transpose(1, 2); k = key.transpose(1, 2); v = value.transpose(1, 2)
+        mask = attn_bias
+        if mask is not None:
+            mask = mask.to(q.dtype)
+        if mask is not None and mask.ndim == 2:
+            mask = mask[:, None, None, :]
+        return torch.nn.functional.scaled_dot_product_attention(
+            q, k, v, attn_mask=mask, dropout_p=p
+        ).transpose(1, 2)
+
+from .rmsnorm import RMSNorm
+from .rotary import precompute_freqs_cis, apply_rotary_emb
+
+from transformers import PreTrainedModel, PretrainedConfig
+from transformers.modeling_outputs import MaskedLMOutput
+
+
+class DotDict(dict):
+    """Dictionary that supports the dot notation to access attributes (similarly to HuggingFace)."""
+
+    __getattr__ = dict.get
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+
+
+class AMPLIFYConfig(PretrainedConfig):
+    model_type = "AMPLIFY"
+
+    # All config parameters must have a default value.
+    def __init__(
+        self,
+        hidden_size: int = 960,
+        num_hidden_layers: int = 32,
+        num_attention_heads: int = 15,
+        intermediate_size: int = 3840,
+        dropout_prob: float = 0,
+        embedding_init_range: float = 0.02,
+        decoder_init_range: float = 0.02,
+        rms_norm: bool = True,
+        norm_eps: float = 1e-05,
+        hidden_act: str = "SwiGLU",
+        layer_norm_after_embedding: bool = False,
+        layer_norm_before_last_layer: bool = True,
+        vocab_size: int = 27,
+        ffn_bias: bool = False,
+        att_bias: bool = False,
+        pad_token_id: int = 0,
+        max_length: int = 2048,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+        self.hidden_size = hidden_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.intermediate_size = intermediate_size
+        self.dropout_prob = dropout_prob
+        self.embedding_init_range = embedding_init_range
+        self.decoder_init_range = decoder_init_range
+        self.rms_norm = rms_norm
+        self.norm_eps = norm_eps
+        self.hidden_act = hidden_act
+        self.layer_norm_after_embedding = layer_norm_after_embedding
+        self.layer_norm_before_last_layer = layer_norm_before_last_layer
+        self.vocab_size = vocab_size
+        self.ffn_bias = ffn_bias
+        self.att_bias = att_bias
+        self.pad_token_id = pad_token_id
+        self.max_length = max_length
+
+
+class EncoderBlock(nn.Module):
+    """Transformer encoder block."""
+
+    def __init__(self, config: AMPLIFYConfig):
+        """Initialize a EncoderBlock.
+
+        Args:
+            hidden_size (int): _description_
+            num_attention_heads (int): _description_
+            intermediate_size (int, optional): _description_. Defaults to 2048.
+            dropout_prob (float, optional): _description_. Defaults to 0.1.
+            activation (str, optional): _description_. Defaults to "relu".
+            rms_norm (bool, optional): _description_. Defaults to True.
+            norm_eps (float, optional): _description_. Defaults to 1e-5.
+            pad_token_id (int, optional): _description_. Defaults to 0.
+            max_length (int, optional): _description_. Defaults to 2048.
+            ffn_bias (bool, optional): _description_. Defaults to False.
+            att_bias (bool, optional): _description_. Defaults to False.
+        """
+        super().__init__()
+
+        self.config = config
+        self.d_head = config.hidden_size // config.num_attention_heads
+
+        # Attention
+        self.q = nn.Linear(in_features=config.hidden_size, out_features=config.hidden_size, bias=config.att_bias)
+        self.k = nn.Linear(in_features=config.hidden_size, out_features=config.hidden_size, bias=config.att_bias)
+        self.v = nn.Linear(in_features=config.hidden_size, out_features=config.hidden_size, bias=config.att_bias)
+        self.wo = nn.Linear(in_features=config.hidden_size, out_features=config.hidden_size, bias=config.att_bias)
+        self.resid_dropout = nn.Dropout(config.dropout_prob)
+
+        # Feedforward network
+        match config.hidden_act.lower():
+            case "swiglu":
+                # To keep the number of parameters and the amount of computation constant, we reduce the number of
+                # hidden units by a factor of 2/3 (https://arxiv.org/pdf/2002.05202.pdf) and make it a multiple of 8 to
+                # avoid RuntimeError due to misaligned operand
+                multiple_of = 8
+                intermediate_size = int(2 * config.intermediate_size / 3)
+                intermediate_size = multiple_of * ((intermediate_size + multiple_of - 1) // multiple_of)
+                self.ffn = SwiGLU(config.hidden_size, intermediate_size, config.hidden_size, bias=config.ffn_bias)
+            case "relu":
+                self.ffn = nn.Sequential(
+                    nn.Linear(config.hidden_size, config.intermediate_size, bias=config.ffn_bias),
+                    nn.ReLU(),
+                    nn.Linear(config.intermediate_size, config.hidden_size, bias=config.ffn_bias),
+                )
+            case "gelu":
+                self.ffn = nn.Sequential(
+                    nn.Linear(config.hidden_size, config.intermediate_size, bias=config.ffn_bias),
+                    nn.GELU(),
+                    nn.Linear(config.intermediate_size, config.hidden_size, bias=config.ffn_bias),
+                )
+
+        self.attention_norm = (
+            RMSNorm(config.hidden_size, config.norm_eps)
+            if config.rms_norm
+            else nn.LayerNorm(config.hidden_size, config.norm_eps)
+        )
+        self.ffn_norm = (
+            RMSNorm(config.hidden_size, config.norm_eps)
+            if config.rms_norm
+            else nn.LayerNorm(config.hidden_size, config.norm_eps)
+        )
+
+        self.ffn_dropout = nn.Dropout(config.dropout_prob)
+
+    def forward(self, x: torch.Tensor, attention_mask: torch.Tensor, freqs_cis: torch.Tensor, output_attentions: bool):
+        attn, contact = self._att_block(self.attention_norm(x), attention_mask, freqs_cis, output_attentions)
+        x = x + attn
+        x = x + self._ff_block(self.ffn_norm(x))
+        return x, contact
+
+    def _att_block(
+        self, x: torch.Tensor, attention_mask: torch.Tensor, freqs_cis: torch.Tensor, output_attentions: bool
+    ):
+        batch_size, seq_len, _ = x.shape
+        xq, xk, xv = self.q(x), self.k(x), self.v(x)
+
+        # Reshape for rotary embeddings
+        xq = xq.view(batch_size, seq_len, self.config.num_attention_heads, self.d_head)
+        xk = xk.view(batch_size, seq_len, self.config.num_attention_heads, self.d_head)
+        xv = xv.view(batch_size, seq_len, self.config.num_attention_heads, self.d_head)
+        xq, xk = apply_rotary_emb(xq, xk, freqs_cis)
+
+        # Compute the attention weight
+        attn_weights = None
+        if output_attentions:
+            attn_weights = xq.permute(0, 2, 1, 3) @ xk.permute(0, 2, 3, 1) / (xq.size(-1) ** 0.5)
+            if attention_mask is not None:
+                attn_weights = attn_weights + attention_mask
+            attn_weights = attn_weights.softmax(-1)
+
+        # Compute the attention using xformers if the tensors are on GPU
+        if x.is_cuda:
+            # Input and output are of dimension (B, M, H, K) where B is the batch size, M the sequence length,
+            # H the number of heads, and K the embeding size per head
+            attn = memory_efficient_attention(
+                query=xq,
+                key=xk,
+                value=xv,
+                attn_bias=attention_mask,
+                p=self.config.dropout_prob if self.training else 0,
+            )
+        else:
+            # Input and output are of dimension (B, H, M, K)
+            attn = scaled_dot_product_attention(
+                query=xq.transpose(1, 2),
+                key=xk.transpose(1, 2),
+                value=xv.transpose(1, 2),
+                attn_mask=attention_mask,
+                dropout_p=self.config.dropout_prob if self.training else 0,
+            ).transpose(1, 2)
+
+        attn_scores = self.wo(attn.view(batch_size, seq_len, self.config.num_attention_heads * self.d_head))
+        return (self.resid_dropout(attn_scores), attn_weights)
+
+    def _ff_block(self, x: torch.Tensor):
+        return self.ffn_dropout(self.ffn(x))
+
+
+class AMPLIFYPreTrainedModel(PreTrainedModel):
+    config_class = AMPLIFYConfig
+
+    def _init_weights(self, module):
+        if isinstance(module, nn.Linear):
+            module.weight.data.uniform_(-self.config.decoder_init_range, self.config.decoder_init_range)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif isinstance(module, nn.Embedding):
+            module.weight.data.uniform_(-self.config.embedding_init_range, self.config.embedding_init_range)
+
+
+class AMPLIFY(AMPLIFYPreTrainedModel):
+    """The main model class.
+
+    Args:
+       config (amplify.model.amplify.AMPLIFYConfig): model configuration, usually defined from the Hydra configuration.
+    """
+
+    def __init__(self, config: AMPLIFYConfig, **kwargs):
+        super().__init__(config)
+
+        self.config = config
+
+        self.encoder = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
+
+        if config.layer_norm_after_embedding:
+            self.layer_norm_1 = (
+                RMSNorm(config.hidden_size, config.norm_eps)
+                if config.rms_norm
+                else nn.LayerNorm(config.hidden_size, config.norm_eps)
+            )
+
+        self.transformer_encoder = nn.ModuleList()
+        for _ in range(config.num_hidden_layers):
+            self.transformer_encoder.append(EncoderBlock(config))
+
+        if config.layer_norm_before_last_layer:
+            self.layer_norm_2 = (
+                RMSNorm(config.hidden_size, config.norm_eps)
+                if config.rms_norm
+                else nn.LayerNorm(config.hidden_size, config.norm_eps)
+            )
+
+        self.decoder = nn.Linear(config.hidden_size, config.vocab_size)
+
+        self.freqs_cis = precompute_freqs_cis(config.hidden_size // config.num_attention_heads, config.max_length)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def forward(self, input_ids, attention_mask=None, output_hidden_states=False, output_attentions=False, **kwargs):
+        # Initialize
+        hidden_states, attentions = [], []
+
+        # Expand and repeat: (Batch, Length) -> (Batch, Heads, Length, Length)
+        if attention_mask is not None and not torch.all(attention_mask == 0):
+            assert attention_mask.dtype != torch.bool and 1.0 not in attention_mask, (
+                "AMPLIFY expects an additive attention_mask.\n"
+                "Modify the output of the tokenizer with attention_mask = torch.where(attention_mask, float(0.0), float('-inf'))"
+            )
+            attention_mask = (
+                attention_mask.unsqueeze(1)
+                .unsqueeze(1)
+                .repeat(1, self.config.num_attention_heads, attention_mask.size(-1), 1)
+            )
+        else:
+            attention_mask = None
+
+        # RoPE
+        self.freqs_cis = self.freqs_cis.to(input_ids.device, non_blocking=True)
+        freqs_cis = self.freqs_cis[: input_ids.shape[1]]
+
+        # Embedding
+        x = self.encoder(input_ids)
+        if self.config.layer_norm_after_embedding:
+            x = self.layer_norm_1(x)
+
+        # Transformer encoder
+        for layer in self.transformer_encoder:
+            x, attn = layer(x, attention_mask, freqs_cis, output_attentions)
+            if output_hidden_states:
+                hidden_states.append(x)
+            if output_attentions:
+                attentions.append(attn)
+
+        # Classification head with layer norm
+        logits = self.decoder(self.layer_norm_2(x) if self.config.layer_norm_before_last_layer else x)
+
+        # Return logits or the output of the last hidden layer
+        return MaskedLMOutput(logits=logits, hidden_states=hidden_states, attentions=attentions)

data_raw/amplify/AMPLIFY_120M/amplify.py.pre_xformers_fallback_20260809

@@ -0,0 +1,282 @@
+# From https://stackoverflow.com/a/23689767
+# From https://github.com/pytorch/pytorch/issues/97899
+# From https://github.com/facebookresearch/llama/blob/main/llama/model.py
+
+import torch
+from torch import nn
+from torch.nn.functional import scaled_dot_product_attention
+from xformers.ops import SwiGLU, memory_efficient_attention
+
+from .rmsnorm import RMSNorm
+from .rotary import precompute_freqs_cis, apply_rotary_emb
+
+from transformers import PreTrainedModel, PretrainedConfig
+from transformers.modeling_outputs import MaskedLMOutput
+
+
+class DotDict(dict):
+    """Dictionary that supports the dot notation to access attributes (similarly to HuggingFace)."""
+
+    __getattr__ = dict.get
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+
+
+class AMPLIFYConfig(PretrainedConfig):
+    model_type = "AMPLIFY"
+
+    # All config parameters must have a default value.
+    def __init__(
+        self,
+        hidden_size: int = 960,
+        num_hidden_layers: int = 32,
+        num_attention_heads: int = 15,
+        intermediate_size: int = 3840,
+        dropout_prob: float = 0,
+        embedding_init_range: float = 0.02,
+        decoder_init_range: float = 0.02,
+        rms_norm: bool = True,
+        norm_eps: float = 1e-05,
+        hidden_act: str = "SwiGLU",
+        layer_norm_after_embedding: bool = False,
+        layer_norm_before_last_layer: bool = True,
+        vocab_size: int = 27,
+        ffn_bias: bool = False,
+        att_bias: bool = False,
+        pad_token_id: int = 0,
+        max_length: int = 2048,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+        self.hidden_size = hidden_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.intermediate_size = intermediate_size
+        self.dropout_prob = dropout_prob
+        self.embedding_init_range = embedding_init_range
+        self.decoder_init_range = decoder_init_range
+        self.rms_norm = rms_norm
+        self.norm_eps = norm_eps
+        self.hidden_act = hidden_act
+        self.layer_norm_after_embedding = layer_norm_after_embedding
+        self.layer_norm_before_last_layer = layer_norm_before_last_layer
+        self.vocab_size = vocab_size
+        self.ffn_bias = ffn_bias
+        self.att_bias = att_bias
+        self.pad_token_id = pad_token_id
+        self.max_length = max_length
+
+
+class EncoderBlock(nn.Module):
+    """Transformer encoder block."""
+
+    def __init__(self, config: AMPLIFYConfig):
+        """Initialize a EncoderBlock.
+
+        Args:
+            hidden_size (int): _description_
+            num_attention_heads (int): _description_
+            intermediate_size (int, optional): _description_. Defaults to 2048.
+            dropout_prob (float, optional): _description_. Defaults to 0.1.
+            activation (str, optional): _description_. Defaults to "relu".
+            rms_norm (bool, optional): _description_. Defaults to True.
+            norm_eps (float, optional): _description_. Defaults to 1e-5.
+            pad_token_id (int, optional): _description_. Defaults to 0.
+            max_length (int, optional): _description_. Defaults to 2048.
+            ffn_bias (bool, optional): _description_. Defaults to False.
+            att_bias (bool, optional): _description_. Defaults to False.
+        """
+        super().__init__()
+
+        self.config = config
+        self.d_head = config.hidden_size // config.num_attention_heads
+
+        # Attention
+        self.q = nn.Linear(in_features=config.hidden_size, out_features=config.hidden_size, bias=config.att_bias)
+        self.k = nn.Linear(in_features=config.hidden_size, out_features=config.hidden_size, bias=config.att_bias)
+        self.v = nn.Linear(in_features=config.hidden_size, out_features=config.hidden_size, bias=config.att_bias)
+        self.wo = nn.Linear(in_features=config.hidden_size, out_features=config.hidden_size, bias=config.att_bias)
+        self.resid_dropout = nn.Dropout(config.dropout_prob)
+
+        # Feedforward network
+        match config.hidden_act.lower():
+            case "swiglu":
+                # To keep the number of parameters and the amount of computation constant, we reduce the number of
+                # hidden units by a factor of 2/3 (https://arxiv.org/pdf/2002.05202.pdf) and make it a multiple of 8 to
+                # avoid RuntimeError due to misaligned operand
+                multiple_of = 8
+                intermediate_size = int(2 * config.intermediate_size / 3)
+                intermediate_size = multiple_of * ((intermediate_size + multiple_of - 1) // multiple_of)
+                self.ffn = SwiGLU(config.hidden_size, intermediate_size, config.hidden_size, bias=config.ffn_bias)
+            case "relu":
+                self.ffn = nn.Sequential(
+                    nn.Linear(config.hidden_size, config.intermediate_size, bias=config.ffn_bias),
+                    nn.ReLU(),
+                    nn.Linear(config.intermediate_size, config.hidden_size, bias=config.ffn_bias),
+                )
+            case "gelu":
+                self.ffn = nn.Sequential(
+                    nn.Linear(config.hidden_size, config.intermediate_size, bias=config.ffn_bias),
+                    nn.GELU(),
+                    nn.Linear(config.intermediate_size, config.hidden_size, bias=config.ffn_bias),
+                )
+
+        self.attention_norm = (
+            RMSNorm(config.hidden_size, config.norm_eps)
+            if config.rms_norm
+            else nn.LayerNorm(config.hidden_size, config.norm_eps)
+        )
+        self.ffn_norm = (
+            RMSNorm(config.hidden_size, config.norm_eps)
+            if config.rms_norm
+            else nn.LayerNorm(config.hidden_size, config.norm_eps)
+        )
+
+        self.ffn_dropout = nn.Dropout(config.dropout_prob)
+
+    def forward(self, x: torch.Tensor, attention_mask: torch.Tensor, freqs_cis: torch.Tensor, output_attentions: bool):
+        attn, contact = self._att_block(self.attention_norm(x), attention_mask, freqs_cis, output_attentions)
+        x = x + attn
+        x = x + self._ff_block(self.ffn_norm(x))
+        return x, contact
+
+    def _att_block(
+        self, x: torch.Tensor, attention_mask: torch.Tensor, freqs_cis: torch.Tensor, output_attentions: bool
+    ):
+        batch_size, seq_len, _ = x.shape
+        xq, xk, xv = self.q(x), self.k(x), self.v(x)
+
+        # Reshape for rotary embeddings
+        xq = xq.view(batch_size, seq_len, self.config.num_attention_heads, self.d_head)
+        xk = xk.view(batch_size, seq_len, self.config.num_attention_heads, self.d_head)
+        xv = xv.view(batch_size, seq_len, self.config.num_attention_heads, self.d_head)
+        xq, xk = apply_rotary_emb(xq, xk, freqs_cis)
+
+        # Compute the attention weight
+        attn_weights = None
+        if output_attentions:
+            attn_weights = xq.permute(0, 2, 1, 3) @ xk.permute(0, 2, 3, 1) / (xq.size(-1) ** 0.5)
+            if attention_mask is not None:
+                attn_weights = attn_weights + attention_mask
+            attn_weights = attn_weights.softmax(-1)
+
+        # Compute the attention using xformers if the tensors are on GPU
+        if x.is_cuda:
+            # Input and output are of dimension (B, M, H, K) where B is the batch size, M the sequence length,
+            # H the number of heads, and K the embeding size per head
+            attn = memory_efficient_attention(
+                query=xq,
+                key=xk,
+                value=xv,
+                attn_bias=attention_mask,
+                p=self.config.dropout_prob if self.training else 0,
+            )
+        else:
+            # Input and output are of dimension (B, H, M, K)
+            attn = scaled_dot_product_attention(
+                query=xq.transpose(1, 2),
+                key=xk.transpose(1, 2),
+                value=xv.transpose(1, 2),
+                attn_mask=attention_mask,
+                dropout_p=self.config.dropout_prob if self.training else 0,
+            ).transpose(1, 2)
+
+        attn_scores = self.wo(attn.view(batch_size, seq_len, self.config.num_attention_heads * self.d_head))
+        return (self.resid_dropout(attn_scores), attn_weights)
+
+    def _ff_block(self, x: torch.Tensor):
+        return self.ffn_dropout(self.ffn(x))
+
+
+class AMPLIFYPreTrainedModel(PreTrainedModel):
+    config_class = AMPLIFYConfig
+
+    def _init_weights(self, module):
+        if isinstance(module, nn.Linear):
+            module.weight.data.uniform_(-self.config.decoder_init_range, self.config.decoder_init_range)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif isinstance(module, nn.Embedding):
+            module.weight.data.uniform_(-self.config.embedding_init_range, self.config.embedding_init_range)
+
+
+class AMPLIFY(AMPLIFYPreTrainedModel):
+    """The main model class.
+
+    Args:
+       config (amplify.model.amplify.AMPLIFYConfig): model configuration, usually defined from the Hydra configuration.
+    """
+
+    def __init__(self, config: AMPLIFYConfig, **kwargs):
+        super().__init__(config)
+
+        self.config = config
+
+        self.encoder = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
+
+        if config.layer_norm_after_embedding:
+            self.layer_norm_1 = (
+                RMSNorm(config.hidden_size, config.norm_eps)
+                if config.rms_norm
+                else nn.LayerNorm(config.hidden_size, config.norm_eps)
+            )
+
+        self.transformer_encoder = nn.ModuleList()
+        for _ in range(config.num_hidden_layers):
+            self.transformer_encoder.append(EncoderBlock(config))
+
+        if config.layer_norm_before_last_layer:
+            self.layer_norm_2 = (
+                RMSNorm(config.hidden_size, config.norm_eps)
+                if config.rms_norm
+                else nn.LayerNorm(config.hidden_size, config.norm_eps)
+            )
+
+        self.decoder = nn.Linear(config.hidden_size, config.vocab_size)
+
+        self.freqs_cis = precompute_freqs_cis(config.hidden_size // config.num_attention_heads, config.max_length)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def forward(self, input_ids, attention_mask=None, output_hidden_states=False, output_attentions=False, **kwargs):
+        # Initialize
+        hidden_states, attentions = [], []
+
+        # Expand and repeat: (Batch, Length) -> (Batch, Heads, Length, Length)
+        if attention_mask is not None and not torch.all(attention_mask == 0):
+            assert attention_mask.dtype != torch.bool and 1.0 not in attention_mask, (
+                "AMPLIFY expects an additive attention_mask.\n"
+                "Modify the output of the tokenizer with attention_mask = torch.where(attention_mask, float(0.0), float('-inf'))"
+            )
+            attention_mask = (
+                attention_mask.unsqueeze(1)
+                .unsqueeze(1)
+                .repeat(1, self.config.num_attention_heads, attention_mask.size(-1), 1)
+            )
+        else:
+            attention_mask = None
+
+        # RoPE
+        self.freqs_cis = self.freqs_cis.to(input_ids.device, non_blocking=True)
+        freqs_cis = self.freqs_cis[: input_ids.shape[1]]
+
+        # Embedding
+        x = self.encoder(input_ids)
+        if self.config.layer_norm_after_embedding:
+            x = self.layer_norm_1(x)
+
+        # Transformer encoder
+        for layer in self.transformer_encoder:
+            x, attn = layer(x, attention_mask, freqs_cis, output_attentions)
+            if output_hidden_states:
+                hidden_states.append(x)
+            if output_attentions:
+                attentions.append(attn)
+
+        # Classification head with layer norm
+        logits = self.decoder(self.layer_norm_2(x) if self.config.layer_norm_before_last_layer else x)
+
+        # Return logits or the output of the last hidden layer
+        return MaskedLMOutput(logits=logits, hidden_states=hidden_states, attentions=attentions)

data_raw/amplify/AMPLIFY_120M/config.json

@@ -0,0 +1,37 @@
+{
+  "_name_": "AMPLIFY",
+  "architectures": [
+    "AMPLIFY"
+  ],
+  "att_bias": false,
+  "auto_map": {
+    "AutoConfig": "amplify.AMPLIFYConfig",
+    "AutoModel": "amplify.AMPLIFY"
+  },
+  "bos_token_id": 3,
+  "decoder_init_range": 0.02,
+  "dropout_prob": 0,
+  "embedding_init_range": 0.02,
+  "eos_token_id": 4,
+  "ffn_bias": false,
+  "hidden_act": "SwiGLU",
+  "hidden_size": 640,
+  "intermediate_size": 2560,
+  "layer_norm_after_embedding": false,
+  "layer_norm_before_last_layer": true,
+  "mask_token_id": 2,
+  "max_length": 2048,
+  "model_type": "AMPLIFY",
+  "norm_eps": 1e-05,
+  "num_attention_heads": 10,
+  "num_hidden_layers": 24,
+  "other_special_token_ids": null,
+  "pad_token_id": 0,
+  "pre_activation_layer_norm": true,
+  "rms_norm": true,
+  "torch_dtype": "float32",
+  "transformers_version": "4.38.2",
+  "unk_token_id": 1,
+  "vocab_path": "conf/tokenizer/amplify_vocab.txt",
+  "vocab_size": 27
+}

data_raw/amplify/AMPLIFY_120M/model.safetensors

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

data_raw/amplify/AMPLIFY_120M/rmsnorm.py

@@ -0,0 +1,32 @@
+import torch
+from torch import nn
+
+
+class RMSNorm(nn.Module):
+    def __init__(self, dim: int, eps: float = 1e-6):
+        """
+        Initialize the RMSNorm normalization layer.
+        Args:
+            dim (int): The dimension of the input tensor.
+            eps (float, optional): A small value added to the denominator for numerical stability. Default is 1e-6.
+        Attributes:
+            eps (float): A small value added to the denominator for numerical stability.
+            weight (nn.Parameter): Learnable scaling parameter.
+        """
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(dim))
+
+    def _norm(self, x):
+        return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)
+
+    def forward(self, x):
+        """
+        Forward pass through the RMSNorm layer.
+        Args:
+            x (torch.Tensor): The input tensor.
+        Returns:
+            torch.Tensor: The output tensor after applying RMSNorm.
+        """
+        output = self._norm(x.float()).type_as(x) # Avoids mixed precision issues as in https://github.com/chandar-lab/AMPLIFY/issues/19
+        return output * self.weight

data_raw/amplify/AMPLIFY_120M/rotary.py

@@ -0,0 +1,80 @@
+import torch
+from typing import Tuple
+
+
+def precompute_freqs_cis(dim: int, end: int, theta: float = 10000.0):
+    """
+    Precompute the frequency tensor for complex exponentials (cis) with given dimensions.
+
+    This function calculates a frequency tensor with complex exponentials using the given dimension 'dim'
+    and the end index 'end'. The 'theta' parameter scales the frequencies.
+    The returned tensor contains complex values in complex64 data type.
+
+    Args:
+        dim (int): Dimension of the frequency tensor.
+        end (int): End index for precomputing frequencies.
+        theta (float, optional): Scaling factor for frequency computation. Defaults to 10000.0.
+
+    Returns:
+        torch.Tensor: Precomputed frequency tensor with complex exponentials.
+    """
+
+    freqs = 1.0 / (theta ** (torch.arange(0, dim, 2)[: (dim // 2)].float() / dim))
+    t = torch.arange(end, device=freqs.device)  # type: ignore
+    freqs = torch.outer(t, freqs).float()  # type: ignore
+    return torch.polar(torch.ones_like(freqs), freqs)  # complex64
+
+
+def reshape_for_broadcast(freqs_cis: torch.Tensor, x: torch.Tensor):
+    """
+    Reshape frequency tensor for broadcasting it with another tensor.
+
+    This function reshapes the frequency tensor to have the same shape as the target tensor 'x'
+    for the purpose of broadcasting the frequency tensor during element-wise operations.
+
+    Args:
+        freqs_cis (torch.Tensor): Frequency tensor to be reshaped.
+        x (torch.Tensor): Target tensor for broadcasting compatibility.
+
+    Returns:
+        torch.Tensor: Reshaped frequency tensor.
+
+    Raises:
+        AssertionError: If the frequency tensor doesn't match the expected shape.
+        AssertionError: If the target tensor 'x' doesn't have the expected number of dimensions.
+    """
+
+    ndim = x.ndim
+    assert 0 <= 1 < ndim
+    assert freqs_cis.shape == (x.shape[1], x.shape[-1])
+    shape = [d if i == 1 or i == ndim - 1 else 1 for i, d in enumerate(x.shape)]
+    return freqs_cis.view(*shape)
+
+
+def apply_rotary_emb(
+    xq: torch.Tensor,
+    xk: torch.Tensor,
+    freqs_cis: torch.Tensor,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Apply rotary embeddings to input tensors using the given frequency tensor.
+
+    This function applies rotary embeddings to the given query 'xq' and key 'xk' tensors using the provided
+    frequency tensor 'freqs_cis'. The input tensors are reshaped as complex numbers, and the frequency tensor
+    is reshaped for broadcasting compatibility. The resulting tensors contain rotary embeddings and are
+    returned as real tensors.
+
+    Args:
+        xq (torch.Tensor): Query tensor to apply rotary embeddings.
+        xk (torch.Tensor): Key tensor to apply rotary embeddings.
+        freqs_cis (torch.Tensor): Precomputed frequency tensor for complex exponentials.
+
+    Returns:
+        Tuple[torch.Tensor, torch.Tensor]: Tuple of modified query tensor and key tensor with rotary embeddings.
+    """
+    xq_ = torch.view_as_complex(xq.float().reshape(*xq.shape[:-1], -1, 2))
+    xk_ = torch.view_as_complex(xk.float().reshape(*xk.shape[:-1], -1, 2))
+    freqs_cis = reshape_for_broadcast(freqs_cis, xq_)
+    xq_out = torch.view_as_real(xq_ * freqs_cis).flatten(3)
+    xk_out = torch.view_as_real(xk_ * freqs_cis).flatten(3)
+    return xq_out.type_as(xq), xk_out.type_as(xk)

data_raw/amplify/AMPLIFY_120M/special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "bos_token": "<bos>",
+  "eos_token": "<eos>",
+  "mask_token": "<mask>",
+  "pad_token": "<pad>",
+  "unk_token": "<unk>"
+}

data_raw/amplify/AMPLIFY_120M/tokenizer.json

@@ -0,0 +1,154 @@
+{
+  "version": "1.0",
+  "truncation": null,
+  "padding": null,
+  "added_tokens": [
+    {
+      "id": 0,
+      "content": "<pad>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    {
+      "id": 1,
+      "content": "<unk>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    {
+      "id": 2,
+      "content": "<mask>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    {
+      "id": 3,
+      "content": "<bos>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    {
+      "id": 4,
+      "content": "<eos>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    }
+  ],
+  "normalizer": null,
+  "pre_tokenizer": {
+    "type": "Split",
+    "pattern": {
+      "String": ""
+    },
+    "behavior": "Removed",
+    "invert": false
+  },
+  "post_processor": {
+    "type": "TemplateProcessing",
+    "single": [
+      {
+        "SpecialToken": {
+          "id": "<bos>",
+          "type_id": 0
+        }
+      },
+      {
+        "Sequence": {
+          "id": "A",
+          "type_id": 0
+        }
+      },
+      {
+        "SpecialToken": {
+          "id": "<eos>",
+          "type_id": 0
+        }
+      }
+    ],
+    "pair": [
+      {
+        "Sequence": {
+          "id": "A",
+          "type_id": 0
+        }
+      },
+      {
+        "Sequence": {
+          "id": "B",
+          "type_id": 1
+        }
+      }
+    ],
+    "special_tokens": {
+      "<bos>": {
+        "id": "<bos>",
+        "ids": [
+          3
+        ],
+        "tokens": [
+          "<bos>"
+        ]
+      },
+      "<eos>": {
+        "id": "<eos>",
+        "ids": [
+          4
+        ],
+        "tokens": [
+          "<eos>"
+        ]
+      }
+    }
+  },
+  "decoder": null,
+  "model": {
+    "type": "WordPiece",
+    "unk_token": "<unk>",
+    "continuing_subword_prefix": "##",
+    "max_input_chars_per_word": 100,
+    "vocab": {
+      "<pad>": 0,
+      "<unk>": 1,
+      "<mask>": 2,
+      "<bos>": 3,
+      "<eos>": 4,
+      "|": 5,
+      "L": 6,
+      "A": 7,
+      "G": 8,
+      "V": 9,
+      "S": 10,
+      "E": 11,
+      "R": 12,
+      "T": 13,
+      "I": 14,
+      "D": 15,
+      "P": 16,
+      "K": 17,
+      "Q": 18,
+      "N": 19,
+      "F": 20,
+      "Y": 21,
+      "M": 22,
+      "H": 23,
+      "W": 24,
+      "C": 25,
+      "B": 26
+    }
+  }
+}

data_raw/amplify/AMPLIFY_120M/tokenizer_config.json

@@ -0,0 +1,58 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<pad>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "<mask>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "<bos>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "4": {
+      "content": "<eos>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "bos_token": "<bos>",
+  "clean_up_tokenization_spaces": true,
+  "eos_token": "<eos>",
+  "mask_token": "<mask>",
+  "model_input_names": [
+    "input_ids",
+    "attention_mask"
+  ],
+  "model_max_length": 2048,
+  "pad_token": "<pad>",
+  "padding_side": "right",
+  "tokenizer_class": "PreTrainedTokenizerFast",
+  "truncation_side": "right",
+  "unk_token": "<unk>"
+}

data_raw/clinvar/variant_summary.txt.gz

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

data_raw/mutation_ppi_external/intact/mutations.tsv

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

data_raw/protein_complex_external/complexportal/COMPLEXPORTAL_UPLOAD_VERIFIED.flag

@@ -0,0 +1,6 @@
+COMPLEXPORTAL_UPLOAD_VERIFIED=true
+file=9606.tsv
+sha256=29d3aeec7ede35e8686de3cf73620b5871c3e68d7ca069385153a9b28e80012a
+size_bytes=5292514
+rows=2499
+parseable=true

data_raw/protein_complex_external/complexportal/CURATED_COMPLEXPORTAL_CONFIRMED.flag

@@ -0,0 +1,8 @@
+CURATED_COMPLEXPORTAL_CONFIRMED=true
+source=EMBL-EBI Complex Portal
+species=Homo sapiens
+taxonomy=9606
+format=ComplexTAB
+dataset=curated
+file=9606.tsv
+predicted_file_used=false

data_raw/protein_complex_external/complexportal/LOCAL_DOWNLOAD_MANIFEST.txt

@@ -0,0 +1,7 @@
+Working directory: /Users/zhangchris/Desktop/bio/protein_complex_ground_truth_tmp/complexportal
+File: 9606.tsv
+Size bytes: 5292514
+Rows: 2499
+SHA256: 29d3aeec7ede35e8686de3cf73620b5871c3e68d7ca069385153a9b28e80012
+Source SHA256: 4c2b1c3e0a7ac2d8635d17e8c77dc786504dfaa81d94a8618f3131dee2a4155b
+Downloaded: 2026-08-09 10:18:22 +0800

data_raw/protein_complex_external/complexportal/SHA256_9606_LOCAL.txt

@@ -0,0 +1,2 @@
+29d3aeec7ede35e8686de3cf73620b5871c3e68d7ca069385153a9b28e80012  9606.tsv
+4c2b1c3e0a7ac2d8635d17e8c77dc786504dfaa81d94a8618f3131dee2a4155b  SOURCE.txt

data_raw/protein_complex_external/complexportal/SHA256_9606_REMOTE.txt

@@ -0,0 +1,2 @@
+29d3aeec7ede35e8686de3cf73620b5871c3e68d7ca069385153a9b28e80012a  9606.tsv
+4c2b1c3e0a7ac2d8635d17e8c77dc786504dfaa81d94a8618f3131dee2a4155b  SOURCE.txt

data_raw/protein_complex_external/complexportal/SOURCE.txt

@@ -0,0 +1,9 @@
+Source: EMBL-EBI Complex Portal
+Species: Homo sapiens
+NCBI Taxonomy ID: 9606
+Format: ComplexTAB
+Dataset type: curated protein complexes
+File: 9606.tsv
+Official URL: https://ftp.ebi.ac.uk/pub/databases/intact/complex/current/complextab/9606.tsv
+Download date: 2026-08-09
+Purpose: independent curated human protein-complex ground truth for AMPLIFY Protein Complex Discovery

data_raw/protein_complex_external/complexportal/UPLOAD_VERIFICATION.tsv

@@ -0,0 +1,2 @@
+file	local_sha256	remote_sha256	sha_match	local_size	remote_size	size_match	remote_rows	parseable	status
+9606.tsv	29d3aeec7ede35e8686de3cf73620b5871c3e68d7ca069385153a9b28e80012a	29d3aeec7ede35e8686de3cf73620b5871c3e68d7ca069385153a9b28e80012a	true	5292514	5292514	true	2499	true	PASS

data_raw/ptmd/Acetylation.zip

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

data_raw/ptmd/Phosphorylation.zip

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

data_raw/ptmd/Ubiquitination.zip

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

data_raw/ptmd/unzipped/PTMD2_Phosphorylation.csv

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

data_raw/ptmd/unzipped/PTMD2_Ubiquitination.csv

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

data_raw/ptmint/SHA256SUMS.txt

@@ -0,0 +1 @@
+4cd357c9558c015ec87c2c1c186329ae4d4f3c0b8892b0d5808cf07114f1e0c4  PTM experimental evidence.csv

data_raw/ptmint/SOURCE_URL.txt

@@ -0,0 +1,4 @@
+Official database: https://ptmint.sjtu.edu.cn/
+Official download page: https://ptmint.sjtu.edu.cn/Download
+Direct file URL: https://ptmint.sjtu.edu.cn/data/PTM%20experimental%20evidence.csv
+Downloaded: 2026-08-01 Asia/Shanghai

data_raw/reactome/UniProt2Reactome_All_Levels.txt

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

data_raw/uniprot/UP000005640_9606.fasta.gz

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

data_raw/uniprot/UP000005640_9606_isoforms.fasta.gz

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

data_raw/uniprot/uniprot_sprot_human.dat.gz

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