Update deepbind.py

deepbind.py

@@ -2,26 +2,21 @@
 /*
 Copyright (c) 2023, thewall.
 All rights reserved.
-
 BSD 3-clause license:
 Redistribution and use in source and binary forms,
 with or without modification, are permitted provided
 that the following conditions are met:
-
   1. Redistributions of source code must retain the
      above copyright notice, this list of conditions
      and the following disclaimer.
-
   2. Redistributions in binary form must reproduce
      the above copyright notice, this list of conditions
      and the following disclaimer in the documentation
      and/or other materials provided with the distribution.
-
   3. Neither the name of the copyright holder nor the
      names of its contributors may be used to endorse or
      promote products derived from this software without
      specific prior written permission.
-
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
@@ -35,7 +30,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 """
-
+import os
 import datasets
 import torch
 from torch import nn
@@ -45,14 +40,18 @@ import pandas as pd
 from typing import List
 from functools import partial
 
+MODEL_CONFIG = datasets.load_dataset(path="thewall/deepbindweight", split="all")
+SELEX_CONFIG = pd.read_excel(MODEL_CONFIG[0]['selex'], index_col=0)
 
 class DeepBind(nn.Module):
     ALPHABET = "ATGCN"
-    ALPHABET_MAP = {key:i for i, key in enumerate(ALPHABET)}
+    ALPHABET_MAP = {key: i for i, key in enumerate(ALPHABET)}
     ALPHABET_MAP["U"] = 1
     ALPHABET_COMPLEMENT = "TACGN"
     COMPLEMENT_ID_MAP = np.array([1, 0, 3, 2, 4])
-    def __init__(self, reverse_complement=True, num_detectors=16, detector_len=24, has_avg_pooling=True, num_hidden=1, tokenizer=None):
+
+    def __init__(self, reverse_complement=True, num_detectors=16, detector_len=24, has_avg_pooling=True, num_hidden=1,
+                 tokenizer=None):
         super(DeepBind, self).__init__()
         self.reverse_complement = reverse_complement
         self.num_detectors = num_detectors
@@ -64,8 +63,8 @@ class DeepBind(nn.Module):
         if has_avg_pooling:
             self.avg_pool = nn.AvgPool1d(detector_len)
         self.max_pool = nn.MaxPool1d(detector_len)
-        fcs = [nn.Linear(num_detectors*2 if self.has_avg_pooling else num_detectors, num_hidden)]
-        if num_hidden>1:
+        fcs = [nn.Linear(num_detectors * 2 if self.has_avg_pooling else num_detectors, num_hidden)]
+        if num_hidden > 1:
             fcs.append(nn.ReLU())
             fcs.append(nn.Linear(num_hidden, 1))
         self.fc = nn.Sequential(*fcs)
@@ -90,7 +89,7 @@ class DeepBind(nn.Module):
 
     def build_embedding(self):
         """ATGC->ACGT:0321"""
-        embedding = torch.zeros(5,4)
+        embedding = torch.zeros(5, 4)
         embedding[0, 0] = 1
         embedding[1, 3] = 1
         embedding[2, 2] = 1
@@ -105,7 +104,7 @@ class DeepBind(nn.Module):
 
     def _load_detector(self, fobj):
         # dtype = functools.partial(lambda x:torch.Tensor(eval(x))
-        dtype = lambda x:torch.Tensor(eval(x))
+        dtype = lambda x: torch.Tensor(eval(x))
         weight1 = self._load_param(fobj, "detectors", dtype).reshape(self.detector_len, 4, self.num_detectors)
         biases1 = self._load_param(fobj, "thresholds", dtype)
         # Tx4xC->Cx4xT
@@ -114,20 +113,20 @@ class DeepBind(nn.Module):
 
     def _load_fc1(self, fobj):
         num_hidden1 = self.num_detectors * 2 if self.has_avg_pooling else self.num_detectors
-        dtype = lambda x:torch.Tensor(np.array(eval(x)))
+        dtype = lambda x: torch.Tensor(np.array(eval(x)))
         weight1 = self._load_param(fobj, "weights1", dtype).reshape(num_hidden1, self.num_hidden)
         biases1 = self._load_param(fobj, "biases1", dtype)
         self.fc[0].weight.data = weight1.T.contiguous().to(device=self.fc[0].weight.device)
         self.fc[0].bias.data = biases1.to(device=self.fc[0].bias.device)
 
     def _load_fc2(self, fobj):
-        dtype = lambda x:torch.Tensor(np.array(eval(x)))
+        dtype = lambda x: torch.Tensor(np.array(eval(x)))
         weight2 = self._load_param(fobj, "weights2", dtype)
         biases2 = self._load_param(fobj, "biases2", dtype)
-        assert not (weight2 is None and self.num_hidden>1)
-        assert not (biases2 is None and self.num_hidden>1)
-        if self.num_hidden>1:
-            self.fc[2].weight.data = weight2.reshape(1,-1).to(device=self.fc[2].weight.device)
+        assert not (weight2 is None and self.num_hidden > 1)
+        assert not (biases2 is None and self.num_hidden > 1)
+        if self.num_hidden > 1:
+            self.fc[2].weight.data = weight2.reshape(1, -1).to(device=self.fc[2].weight.device)
             self.fc[2].bias.data = biases2.to(device=self.fc[2].bias.device)
 
     @classmethod
@@ -135,27 +134,27 @@ class DeepBind(nn.Module):
         line = fobj.readline().strip()
         tmp = line.split("=")
         assert tmp[0].strip() == param_name
-        if len(tmp)>1 and len(tmp[1].strip())>0:
+        if len(tmp) > 1 and len(tmp[1].strip()) > 0:
             return dtype(tmp[1].strip())
 
     @classmethod
     def load_model(cls, sra_id="ERR173157", file=None, ID=None):
         if file is None:
-            config = datasets.load_dataset(path="thewall/deepbindweight", split="all")
             if ID is None:
-                data = pd.read_excel(config[0]['selex'], index_col=0)
+                data = SELEX_CONFIG
                 ID = data.loc[sra_id]["ID"]
-            file = datasets.load_dataset(path="thewall/deepbindweight", name=ID, split="all")[0]['config']
-        keys = [("reverse_complement", lambda x:bool(eval(x))), ("num_detectors", int), ("detector_len", int),
-                ("has_avg_pooling", lambda x:bool(eval(x))), ("num_hidden", int)]
+            file = os.path.join(MODEL_CONFIG['config'][0], "params", f"{ID}.txt")
+        keys = [("reverse_complement", lambda x: bool(eval(x))), ("num_detectors", int), ("detector_len", int),
+                ("has_avg_pooling", lambda x: bool(eval(x))), ("num_hidden", int)]
+
         hparams = {}
         with open(file) as fobj:
             version = fobj.readline()[1:].strip()
             for key in keys:
                 value = cls._load_param(fobj, key[0], key[1])
-                hparams[key[0]]=value
-            if hparams['num_hidden']==0:
-                hparams['num_hidden']=1
+                hparams[key[0]] = value
+            if hparams['num_hidden'] == 0:
+                hparams['num_hidden'] = 1
             model = cls(**hparams)
             model._load_detector(fobj)
             model._load_fc1(fobj)
@@ -175,9 +174,9 @@ class DeepBind(nn.Module):
         return ans
 
     @torch.no_grad()
-    def batch_inference(self, sequence: List[str], window_size=0, average_flag=False):
-        if isinstance(sequence, str):
-            sequence = [sequence]
+    def batch_inference(self, sequences: List[str], window_size=0, average_flag=False):
+        if isinstance(sequences, str):
+            sequences = [sequences]
         self.tokenizer.enable_padding()
         encodings = self.tokenizer.encode_batch(sequences)
         ids = torch.Tensor([encoding.ids for encoding in encodings]).to(device=self.device)
@@ -195,9 +194,9 @@ class DeepBind(nn.Module):
         if window_size < 1:
             window_size = int(self.detector_len * 1.5)
         scores = torch.zeros_like(seq_len).float()
-        masked = seq_len<=window_size
+        masked = seq_len <= window_size
         for idx in torch.where(masked)[0]:
-            scores[idx] = self.forward(ids[idx:idx+1, :seq_len[idx]].int())
+            scores[idx] = self.forward(ids[idx:idx + 1, :seq_len[idx]].int())
 
         fold_ids = F.unfold(ids[~masked].unsqueeze(1).unsqueeze(1), kernel_size=(1, window_size), stride=1)
         B, W, G = fold_ids.shape
@@ -205,11 +204,12 @@ class DeepBind(nn.Module):
         ans = self.forward(fold_ids.int())
         ans = ans.reshape(B, G)
         if average_flag:
-            valid_len = seq_len-window_size+1
+            valid_len = seq_len - window_size + 1
             for idx, value in zip(torch.where(~masked)[0], ans):
                 scores[idx] = value[:valid_len[idx]].mean()
         else:
-            unvalid_mask = torch.arange(G).unsqueeze(0).to(seq_len.device)>=(seq_len[~masked]-window_size+1).unsqueeze(1)
+            unvalid_mask = torch.arange(G).unsqueeze(0).to(seq_len.device) >= (
+                        seq_len[~masked] - window_size + 1).unsqueeze(1)
             ans[unvalid_mask] = -torch.inf
             scores[~masked] = ans.max(dim=1)[0]
         return scores
@@ -226,14 +226,14 @@ class DeepBind(nn.Module):
 
     def scan_model(self, seq: torch.IntTensor, window_size: int = 0, average_flag: bool = False):
         seq_len = seq.shape[1]
-        if window_size<1:
-            window_size = int(self.detector_len*1.5)
-        if seq_len<=window_size:
+        if window_size < 1:
+            window_size = int(self.detector_len * 1.5)
+        if seq_len <= window_size:
             return self.forward(seq)
         else:
             scores = []
-            for i in range(0, seq_len-window_size+1):
-                scores.append(self.forward(seq[:,i:i+window_size]))
+            for i in range(0, seq_len - window_size + 1):
+                scores.append(self.forward(seq[:, i:i + window_size]))
             scores = torch.stack(scores, dim=-1)
             if average_flag:
                 return scores.mean(dim=-1)
@@ -241,7 +241,7 @@ class DeepBind(nn.Module):
                 return scores.max(dim=-1)[0]
 
     def forward(self, seq: torch.IntTensor):
-        seq = F.pad(seq, (self.detector_len-1, self.detector_len-1), value=4)
+        seq = F.pad(seq, (self.detector_len - 1, self.detector_len - 1), value=4)
         x = self.embedding(seq)
         x = x.permute(0, 2, 1)
         x = self.detectors(x)
@@ -257,16 +257,16 @@ class DeepBind(nn.Module):
         return x
 
 
-if __name__=="__main__":
+if __name__ == "__main__":
     """
        AGGUAAUAAUUUGCAUGAAAUAACUUGGAGAGGAUAGC
        AGACAGAGCUUCCAUCAGCGCUAGCAGCAGAGACCAUU
        GAGGTTACGCGGCAAGATAA
        TACCACTAGGGGGCGCCACC
-    
+
     To generate 16 predictions (4 models, 4 sequences), run
     the deepbind executable as follows:
-    
+
        % deepbind example.ids < example.seq
        D00210.001   D00120.001   D00410.003   D00328.003
         7.451420    -0.166146    -0.408751    -0.026180
@@ -284,13 +284,17 @@ if __name__=="__main__":
     import random
     import time
     from tqdm import tqdm
+
     sequences = ["".join([random.choice("ATGC") for _ in range(40)]) for i in range(1000)]
+
+
     def test_fn(sequences, fn):
         start_time = time.time()
         for start in tqdm(range(0, len(sequences), 256)):
-            batch = sequences[start: min(start+256, len(sequences))]
+            batch = sequences[start: min(start + 256, len(sequences))]
             fn(batch)
-        print(time.time()-start_time)
+        print(time.time() - start_time)
+
 
     # test_fn(sequences, model.inference)
     # test_fn(sequences, model.batch_inference)