Upload folder using huggingface_hub

.ipynb_checkpoints/config-checkpoint.json

@@ -0,0 +1,30 @@
+from modeling import KinaseSubstrateConfig, KinaseSubstrateModel
+import torch
+
+# Build config
+config = KinaseSubstrateConfig(
+    tape_model_name="bert-base",
+    num_labels=2,
+    threshold=ckpt["threshold"],   # from your checkpoint
+    with_sep=True,
+    max_len=1024,
+    # Tell HF where to find the custom classes:
+    auto_map={
+        "AutoConfig": "modeling.KinaseSubstrateConfig",
+        "AutoModel": "modeling.KinaseSubstrateModel",
+    },
+    custom_pipelines={
+        "kinase-substrate": {
+            "impl": "pipeline.KinaseSubstratePipeline",
+            "pt": ["AutoModel"],
+        }
+    },
+)
+
+# Build and load model
+model = KinaseSubstrateModel(config)
+model.backbone.load_state_dict(ckpt["state_dict"])  # load your trained weights
+
+# Save
+model.save_pretrained("./my_kinase_model")
+config.save_pretrained("./my_kinase_model")

.ipynb_checkpoints/config_raw-checkpoint.json

@@ -0,0 +1,23 @@
+{
+  "attention_probs_dropout_prob": 0.1,
+  "base_model": "transformer",
+  "finetuning_task": null,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "initializer_range": 0.02,
+  "input_size": 768,
+  "intermediate_size": 3072,
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 8192,
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "num_labels": 2,
+  "output_attentions": false,
+  "output_hidden_states": false,
+  "output_size": 768,
+  "pruned_heads": {},
+  "torchscript": false,
+  "type_vocab_size": 1,
+  "vocab_size": 30
+}

.ipynb_checkpoints/modeling-checkpoint.py

@@ -0,0 +1,47 @@
+from transformers import PreTrainedModel, PretrainedConfig
+import torch
+import torch.nn as nn
+from tape import ProteinBertForSequenceClassification, TAPETokenizer
+
+
+class KinaseSubstrateConfig(PretrainedConfig):
+    model_type = "kinase_substrate_bert"
+
+    def __init__(
+        self,
+        tape_model_name="bert-base",
+        num_labels=2,
+        threshold=0.5,
+        with_sep=True,
+        max_len=1024,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.tape_model_name = tape_model_name
+        self.num_labels = num_labels
+        self.threshold = threshold
+        self.with_sep = with_sep
+        self.max_len = max_len
+
+
+class KinaseSubstrateModel(PreTrainedModel):
+    config_class = KinaseSubstrateConfig
+
+    def __init__(self, config: KinaseSubstrateConfig):
+        super().__init__(config)
+        self.backbone = ProteinBertForSequenceClassification.from_pretrained(
+            config.tape_model_name, num_labels=config.num_labels
+        )
+
+    def forward(self, input_ids, input_mask=None, targets=None):
+        return self.backbone(
+            input_ids=input_ids,
+            input_mask=input_mask,
+            targets=targets,
+        )
+
+    def predict_proba(self, input_ids, input_mask):
+        self.eval()
+        with torch.no_grad():
+            (_, _), logits = self.forward(input_ids=input_ids, input_mask=input_mask)
+            return torch.softmax(logits, dim=-1)[:, 1]

.ipynb_checkpoints/pipeline-checkpoint.py

@@ -0,0 +1,55 @@
+from transformers import Pipeline
+from tape import TAPETokenizer
+import torch
+import numpy as np
+
+
+class KinaseSubstratePipeline(Pipeline):
+    """
+    Usage:
+        pipe = pipeline(
+            "kinase-substrate",
+            model="your-username/kinase-substrate-classifier",
+            trust_remote_code=True,
+        )
+        result = pipe({"kinase_seq": "MGSSHHH...", "substrate_seq": "ARTKQTAR..."})
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.tape_tokenizer = TAPETokenizer(vocab="iupac")
+
+    def _sanitize_parameters(self, **kwargs):
+        return {}, {}, {}
+
+    def preprocess(self, inputs):
+        kinase_seq = inputs["kinase_seq"].upper().replace(" ", "")
+        substrate_seq = inputs["substrate_seq"].upper().replace(" ", "")
+
+        cfg = self.model.config
+        kin_toks = self.tape_tokenizer.tokenize(kinase_seq)
+        sub_toks = self.tape_tokenizer.tokenize(substrate_seq)
+        toks = kin_toks + (["<sep>"] if cfg.with_sep else []) + sub_toks
+        toks = self.tape_tokenizer.add_special_tokens(toks)
+        ids = self.tape_tokenizer.convert_tokens_to_ids(toks)[: cfg.max_len]
+
+        input_ids = torch.tensor([ids], dtype=torch.long)
+        input_mask = torch.ones_like(input_ids)
+
+        return {"input_ids": input_ids, "input_mask": input_mask}
+
+    def _forward(self, model_inputs):
+        prob = self.model.predict_proba(
+            input_ids=model_inputs["input_ids"].to(self.device),
+            input_mask=model_inputs["input_mask"].to(self.device),
+        )
+        return {"prob": prob.cpu().numpy()}
+
+    def postprocess(self, model_outputs):
+        prob = float(model_outputs["prob"][0])
+        threshold = self.model.config.threshold
+        return {
+            "probability": round(prob, 4),
+            "label": "interaction" if prob >= threshold else "no_interaction",
+            "threshold": threshold,
+        }

config.json

@@ -1,23 +1,30 @@
-{
-  "attention_probs_dropout_prob": 0.1,
-  "base_model": "transformer",
-  "finetuning_task": null,
-  "hidden_act": "gelu",
-  "hidden_dropout_prob": 0.1,
-  "hidden_size": 768,
-  "initializer_range": 0.02,
-  "input_size": 768,
-  "intermediate_size": 3072,
-  "layer_norm_eps": 1e-12,
-  "max_position_embeddings": 8192,
-  "num_attention_heads": 12,
-  "num_hidden_layers": 12,
-  "num_labels": 2,
-  "output_attentions": false,
-  "output_hidden_states": false,
-  "output_size": 768,
-  "pruned_heads": {},
-  "torchscript": false,
-  "type_vocab_size": 1,
-  "vocab_size": 30
-}
+from modeling import KinaseSubstrateConfig, KinaseSubstrateModel
+import torch
+
+# Build config
+config = KinaseSubstrateConfig(
+    tape_model_name="bert-base",
+    num_labels=2,
+    threshold=ckpt["threshold"],   # from your checkpoint
+    with_sep=True,
+    max_len=1024,
+    # Tell HF where to find the custom classes:
+    auto_map={
+        "AutoConfig": "modeling.KinaseSubstrateConfig",
+        "AutoModel": "modeling.KinaseSubstrateModel",
+    },
+    custom_pipelines={
+        "kinase-substrate": {
+            "impl": "pipeline.KinaseSubstratePipeline",
+            "pt": ["AutoModel"],
+        }
+    },
+)
+
+# Build and load model
+model = KinaseSubstrateModel(config)
+model.backbone.load_state_dict(ckpt["state_dict"])  # load your trained weights
+
+# Save
+model.save_pretrained("./my_kinase_model")
+config.save_pretrained("./my_kinase_model")

config_raw.json

@@ -0,0 +1,23 @@
+{
+  "attention_probs_dropout_prob": 0.1,
+  "base_model": "transformer",
+  "finetuning_task": null,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "initializer_range": 0.02,
+  "input_size": 768,
+  "intermediate_size": 3072,
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 8192,
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "num_labels": 2,
+  "output_attentions": false,
+  "output_hidden_states": false,
+  "output_size": 768,
+  "pruned_heads": {},
+  "torchscript": false,
+  "type_vocab_size": 1,
+  "vocab_size": 30
+}

modeling.py

@@ -0,0 +1,47 @@
+from transformers import PreTrainedModel, PretrainedConfig
+import torch
+import torch.nn as nn
+from tape import ProteinBertForSequenceClassification, TAPETokenizer
+
+
+class KinaseSubstrateConfig(PretrainedConfig):
+    model_type = "kinase_substrate_bert"
+
+    def __init__(
+        self,
+        tape_model_name="bert-base",
+        num_labels=2,
+        threshold=0.5,
+        with_sep=True,
+        max_len=1024,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.tape_model_name = tape_model_name
+        self.num_labels = num_labels
+        self.threshold = threshold
+        self.with_sep = with_sep
+        self.max_len = max_len
+
+
+class KinaseSubstrateModel(PreTrainedModel):
+    config_class = KinaseSubstrateConfig
+
+    def __init__(self, config: KinaseSubstrateConfig):
+        super().__init__(config)
+        self.backbone = ProteinBertForSequenceClassification.from_pretrained(
+            config.tape_model_name, num_labels=config.num_labels
+        )
+
+    def forward(self, input_ids, input_mask=None, targets=None):
+        return self.backbone(
+            input_ids=input_ids,
+            input_mask=input_mask,
+            targets=targets,
+        )
+
+    def predict_proba(self, input_ids, input_mask):
+        self.eval()
+        with torch.no_grad():
+            (_, _), logits = self.forward(input_ids=input_ids, input_mask=input_mask)
+            return torch.softmax(logits, dim=-1)[:, 1]

pipeline.py

@@ -0,0 +1,55 @@
+from transformers import Pipeline
+from tape import TAPETokenizer
+import torch
+import numpy as np
+
+
+class KinaseSubstratePipeline(Pipeline):
+    """
+    Usage:
+        pipe = pipeline(
+            "kinase-substrate",
+            model="your-username/kinase-substrate-classifier",
+            trust_remote_code=True,
+        )
+        result = pipe({"kinase_seq": "MGSSHHH...", "substrate_seq": "ARTKQTAR..."})
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.tape_tokenizer = TAPETokenizer(vocab="iupac")
+
+    def _sanitize_parameters(self, **kwargs):
+        return {}, {}, {}
+
+    def preprocess(self, inputs):
+        kinase_seq = inputs["kinase_seq"].upper().replace(" ", "")
+        substrate_seq = inputs["substrate_seq"].upper().replace(" ", "")
+
+        cfg = self.model.config
+        kin_toks = self.tape_tokenizer.tokenize(kinase_seq)
+        sub_toks = self.tape_tokenizer.tokenize(substrate_seq)
+        toks = kin_toks + (["<sep>"] if cfg.with_sep else []) + sub_toks
+        toks = self.tape_tokenizer.add_special_tokens(toks)
+        ids = self.tape_tokenizer.convert_tokens_to_ids(toks)[: cfg.max_len]
+
+        input_ids = torch.tensor([ids], dtype=torch.long)
+        input_mask = torch.ones_like(input_ids)
+
+        return {"input_ids": input_ids, "input_mask": input_mask}
+
+    def _forward(self, model_inputs):
+        prob = self.model.predict_proba(
+            input_ids=model_inputs["input_ids"].to(self.device),
+            input_mask=model_inputs["input_mask"].to(self.device),
+        )
+        return {"prob": prob.cpu().numpy()}
+
+    def postprocess(self, model_outputs):
+        prob = float(model_outputs["prob"][0])
+        threshold = self.model.config.threshold
+        return {
+            "probability": round(prob, 4),
+            "label": "interaction" if prob >= threshold else "no_interaction",
+            "threshold": threshold,
+        }