| """ |
| /* |
| 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 |
| A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| """ |
| import os |
| import datasets |
| import torch |
| from torch import nn |
| import torch.nn.functional as F |
| import numpy as np |
| import pandas as pd |
| from typing import List |
| from functools import partial |
|
|
| DEEPBIND_MODEL_CONFIG = datasets.load_dataset(path="thewall/deepbindweight", split="all") |
| SELEX_CONFIG = pd.read_excel(DEEPBIND_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["U"] = 1 |
| ALPHABET_COMPLEMENT = "TACGN" |
| COMPLEMENT_ID_MAP = torch.IntTensor([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): |
| super(DeepBind, self).__init__() |
| self.reverse_complement = reverse_complement |
| self.num_detectors = num_detectors |
| self.detector_len = detector_len |
| self.has_avg_pooling = has_avg_pooling |
| self.num_hidden = num_hidden |
| self.build_embedding() |
| self.detectors = nn.Conv1d(4, num_detectors, detector_len) |
| 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.append(nn.ReLU()) |
| fcs.append(nn.Linear(num_hidden, 1)) |
| self.fc = nn.Sequential(*fcs) |
| self.tokenizer = tokenizer if tokenizer is not None else self.get_tokenizer() |
|
|
| @classmethod |
| def get_tokenizer(cls): |
| from tokenizers import Tokenizer, models, decoders |
| tokenizer = Tokenizer(models.BPE(vocab=cls.ALPHABET_MAP, merges=[])) |
| tokenizer.decoder = decoders.ByteLevel() |
| return tokenizer |
|
|
| @classmethod |
| def complement_idxs_encode_batch(cls, idxs, reverse=False): |
| return torch.stack(list(map(partial(cls.complement_idxs_encode, reverse=reverse), idxs))) |
|
|
| @classmethod |
| def complement_idxs_encode(cls, idxs, reverse=False): |
| if reverse: |
| idxs = reversed(idxs) |
| return cls.COMPLEMENT_ID_MAP[idxs] |
|
|
| def build_embedding(self): |
| """ATGC->ACGT:0321""" |
| embedding = torch.zeros(5, 4) |
| embedding[0, 0] = 1 |
| embedding[1, 3] = 1 |
| embedding[2, 2] = 1 |
| embedding[3, 1] = 1 |
| embedding[-1] = 0.25 |
| self.embedding = nn.Embedding.from_pretrained(embedding, freeze=True) |
| return embedding |
|
|
| @property |
| def device(self): |
| return self.detectors.bias.device |
|
|
| def _load_detector(self, fobj): |
| |
| 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) |
| |
| self.detectors.weight.data = weight1.permute(2, 1, 0).contiguous().to(device=self.detectors.weight.device) |
| self.detectors.bias.data = biases1.to(device=self.detectors.bias.device) |
|
|
| 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))) |
| 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))) |
| 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) |
| self.fc[2].bias.data = biases2.to(device=self.fc[2].bias.device) |
|
|
| @classmethod |
| def _load_param(cls, fobj, param_name, dtype): |
| line = fobj.readline().strip() |
| tmp = line.split("=") |
| assert tmp[0].strip() == param_name |
| 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: |
| if ID is None: |
| data = SELEX_CONFIG |
| ID = data.loc[sra_id]["ID"] |
| file = os.path.join(DEEPBIND_MODEL_CONFIG['config'][0], 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 |
| model = cls(**hparams) |
| model._load_detector(fobj) |
| model._load_fc1(fobj) |
| model._load_fc2(fobj) |
| print(f"load model from {file}") |
| return model |
|
|
| def inference(self, sequence: List[str], window_size=0, average_flag=False): |
| if isinstance(sequence, str): |
| sequence = [sequence] |
| ans = [] |
| self.tokenizer.no_padding() |
| for seq in sequence: |
| inputs = torch.IntTensor(self.tokenizer.encode(seq).ids).unsqueeze(0).to(device=self.device) |
| score = self.test(inputs, window_size, average_flag).item() |
| ans.append(score) |
| return ans |
|
|
| @torch.no_grad() |
| 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) |
| mask = torch.BoolTensor([encoding.attention_mask for encoding in encodings]).to(device=self.device) |
| seq_len = mask.sum(dim=1) |
| score = self.batch_scan_model(ids, seq_len, window_size, average_flag) |
| if self.reverse_complement: |
| rev_seq = self.complement_idxs_encode_batch(ids.cpu().long(), reverse=True) |
| rev_seq = torch.Tensor(rev_seq).to(device=self.device).float() |
| rev_score = self.batch_scan_model(rev_seq, seq_len, window_size, average_flag) |
| score = torch.stack([rev_score, score], dim=-1).max(dim=-1)[0] |
| return score.cpu().tolist() |
|
|
| def batch_scan_model(self, ids, seq_len, window_size: int = 0, average_flag: bool = False): |
| if window_size < 1: |
| window_size = int(self.detector_len * 1.5) |
| scores = torch.zeros_like(seq_len).float() |
| masked = seq_len <= window_size |
| for idx in torch.where(masked)[0]: |
| scores[idx] = self.forward(ids[idx:idx + 1, :seq_len[idx]].int()) |
| if torch.all(masked): |
| return scores |
| fold_ids = F.unfold(ids[~masked].unsqueeze(1).unsqueeze(1), kernel_size=(1, window_size), stride=1) |
| B, W, G = fold_ids.shape |
| fold_ids = fold_ids.permute(0, 2, 1).reshape(-1, W) |
| ans = self.forward(fold_ids.int()) |
| ans = ans.reshape(B, G) |
| if average_flag: |
| 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) |
| ans[unvalid_mask] = -torch.inf |
| scores[~masked] = ans.max(dim=1)[0] |
| return scores |
|
|
| @torch.no_grad() |
| def test(self, seq: torch.IntTensor, window_size=0, average_flag=False): |
| score = self.scan_model(seq, window_size, average_flag) |
| if self.reverse_complement: |
| rev_seq = self.complement_idxs_encode_batch(seq.cpu().long(), reverse=True) |
| rev_seq = torch.IntTensor(rev_seq).to(device=seq.device) |
| rev_score = self.scan_model(rev_seq, window_size, average_flag) |
| score = torch.cat([rev_score, score], dim=-1).max(dim=-1)[0] |
| return score |
|
|
| 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: |
| 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])) |
| scores = torch.stack(scores, dim=-1) |
| if average_flag: |
| return scores.mean(dim=-1) |
| else: |
| 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) |
| x = self.embedding(seq) |
| x = x.permute(0, 2, 1) |
| x = self.detectors(x) |
| x = torch.relu(x) |
| x = x.permute(0, 2, 1) |
| if self.has_avg_pooling: |
| x = torch.stack([torch.max(x, dim=1)[0], torch.mean(x, dim=1)], dim=-1) |
| x = torch.flatten(x, 1) |
| else: |
| x = torch.max(x, dim=1)[0] |
| x = x.squeeze(dim=-1) |
| x = self.fc(x) |
| return x |
|
|
|
|
| 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 |
| -0.155398 4.113817 0.516956 -0.248167 |
| -0.140683 0.181295 5.885349 -0.026180 |
| -0.174985 -0.152521 -0.379695 17.682623 |
| """ |
| sequences = ["AGGUAAUAAUUUGCAUGAAAUAACUUGGAGAGGAUAGC", |
| "AGACAGAGCUUCCAUCAGCGCUAGCAGCAGAGACCAUU", |
| "GAGGTTACGCGGCAAGATAA", |
| "TACCACTAGGGGGCGCCACC"] |
| model = DeepBind.load_model(ID='D00410.003') |
| print(model.batch_inference(sequences)) |
|
|
| 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))] |
| fn(batch) |
| print(time.time() - start_time) |
|
|
|
|
| |
| |
| model = model.cuda() |
| test_fn(sequences, model.batch_inference) |
| test_fn(sequences, model.inference) |
| test_fn(sequences, model.batch_inference) |
| test_fn(sequences, model.inference) |
