| | """ |
| | /* |
| | 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) |
