initial submission

DeepMFPP/ESM2/config.json

@@ -0,0 +1,30 @@
+{
+  "_name_or_path": "/tmp/facebook/esm2_t12_35M_UR50D",
+  "architectures": [
+    "EsmForMaskedLM"
+  ],
+  "attention_probs_dropout_prob": 0.0,
+  "classifier_dropout": null,
+  "emb_layer_norm_before": false,
+  "esmfold_config": null,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.0,
+  "hidden_size": 480,
+  "initializer_range": 0.02,
+  "intermediate_size": 1920,
+  "is_folding_model": false,
+  "layer_norm_eps": 1e-05,
+  "mask_token_id": 32,
+  "max_position_embeddings": 1026,
+  "model_type": "esm",
+  "num_attention_heads": 20,
+  "num_hidden_layers": 12,
+  "pad_token_id": 1,
+  "position_embedding_type": "rotary",
+  "token_dropout": true,
+  "torch_dtype": "float32",
+  "transformers_version": "4.25.0.dev0",
+  "use_cache": true,
+  "vocab_list": null,
+  "vocab_size": 33
+}

DeepMFPP/ESM2/esm2_t12_35M_UR50D-contact-regression.pt

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

DeepMFPP/ESM2/esm2_t12_35M_UR50D.pt

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

DeepMFPP/ESM2/model_index.json

@@ -0,0 +1,33 @@
+{
+  "_class_name": "StableDiffusionPipeline",
+  "_diffusers_version": "0.8.0",
+  "feature_extractor": [
+    "transformers",
+    "CLIPFeatureExtractor"
+  ],
+  "safety_checker": [
+    null,
+    null
+  ],
+  "scheduler": [
+    "diffusers",
+    "DDIMScheduler"
+  ],
+  "text_encoder": [
+    "transformers",
+    "CLIPTextModel"
+  ],
+  "tokenizer": [
+    "transformers",
+    "CLIPTokenizer"
+  ],
+  "unet": [
+    "diffusers",
+    "UNet2DConditionModel"
+  ],
+  "vae": [
+    "diffusers",
+    "AutoencoderKL"
+  ],
+  "requires_safety_checker": false
+}

DeepMFPP/ESM2/special_tokens_map.json

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

DeepMFPP/ESM2/tokenizer_config.json

@@ -0,0 +1,4 @@
+{
+  "model_max_length": 1000000000000000019884624838656,
+  "tokenizer_class": "EsmTokenizer"
+}

DeepMFPP/ESM2/vocab.txt

@@ -0,0 +1,33 @@
+<cls>
+<pad>
+<eos>
+<unk>
+L
+A
+G
+V
+S
+E
+R
+T
+I
+D
+P
+K
+Q
+N
+F
+Y
+M
+H
+W
+C
+X
+B
+U
+Z
+O
+.
+-
+<null_1>
+<mask>

DeepMFPP/config.py

@@ -0,0 +1,63 @@
+import os
+import torch
+
+class ArgsConfig:
+    def __init__(self) -> None:
+        self.batch_size = 192
+        self.embedding_size = 480
+        self.epochs = 100
+        self.kflod = 5
+        self.max_len = 51
+        self.lr = 1.8e-3
+        self.weight_decay = 0
+        self.dropout = 0.6
+        self.ctl = False
+        
+        self.margin = 2.8
+        self.scale_factor = 1
+        self.training_ratio = 1.1
+        self.model_name = 'DeepMFPP-MFTP'
+        self.loss_fn_name = 'MLFDL'
+        self.exp_nums = None
+        self.aa_dict = 'esm' # 'protbert' /'esm'/ None
+        self.class_weight = False
+        # self.lr_step_size = 250
+        # self.lr_milestones = [20,60,120,180,240]
+        # self.lr_gamma = 0.75
+        self.fldl_clip_pos = 0.7
+        self.fldl_clip_neg = 0.5
+        self.fldl_pos_weight = 0.4
+        self.info = f"FDL{0.7,0.5,0.3},CosLR,cw={self.class_weight}"  #对当前训练做的补充说明
+
+        # self.data_dir = './data/AllData.txt'
+        # self.train_data_dir = './data/MFTP-Data/train.txt' # MLBP-Data/train.txt  MFTP-Data/train.txt
+        # self.test_data_dir = './data/MFTP-Data/test.txt' # MLBP-Data/test.txt  MFTP-Data/test.txt
+        # MLBP-Data/train_0.5_min-2_maj-1.txt 
+        # MFTP-Data/traindata_da/train_rs_2.txt
+        # self.train_data_da_dir = './data/MFTP-Data/traindata_da/train_rs_2.txt' 
+        # self.ebv_dir = './eq_21_21.pkl'
+        self.use_ebv = False
+
+        # self.log_dir = './result/logs'
+        # self.save_dir = './result/model_para'
+        # self.tensorboard_log_dir = './tensorboard'
+        self.ems_path = './DeepMFPP/ESM2/esm2_t12_35M_UR50D.pt'
+        self.esm_layer_idx = 12
+        # self.save_para_dir = os.path.join(self.save_dir,self.model_name)
+        self.random_seed = 2023
+        self.num_classes = 21
+        self.split_size = 0.8
+        # self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.device = torch.device("cpu")
+        self.continue_training = False
+        # self.checkpoint_path = r'result\model_para\CNN_BIGRU_test1\1.pth'
+        
+        # if not os.path.exists(self.log_dir):
+        #     os.mkdir(self.log_dir)
+        # if not os.path.exists(self.save_dir):
+        #     os.mkdir(self.save_dir)
+        # if not os.path.exists(self.save_para_dir):
+        #     os.mkdir(self.save_para_dir)
+        # if not os.path.exists(self.tensorboard_log_dir):
+        #     os.mkdir(self.tensorboard_log_dir)
+        

DeepMFPP/data_helper.py

@@ -0,0 +1,156 @@
+import numpy as np
+import torch
+import torch.nn.utils.rnn as rnn_utils
+
+def Data2EqlTensor(lines,max_len:int=51,AminoAcid_vocab=None):
+    '''
+    Args:
+        flie:文件路径 \n
+        max_len:设定转换后的氨基酸序列最大长度 \n
+        vocab_dict:esm or protbert ,默认为按顺序映射的词典
+    '''
+    # 只保留20种氨基酸和填充数,其余几种非常规氨基酸均用填充数代替
+    # 使用 esm和portbert字典时，nn.embedding()的vocab_size = 25
+    if AminoAcid_vocab =='esm':
+        aa_dict = {'[PAD]': 1, 'L': 4, 'A': 5, 'G': 6, 'V': 7, 'S': 8, 'E': 9, 'R': 10, 'T': 11, 'I': 12, 'D': 13, 'P': 14, 'K': 15, 'Q': 16, 
+                   'N': 17, 'F': 18, 'Y': 19, 'M': 20, 'H': 21, 'W': 22, 'C': 23, 'X': 1, 'B': 1, 'U': 1, 'Z': 1, 'O': 1}
+    elif AminoAcid_vocab == 'protbert':
+        aa_dict = {'[PAD]':0,'L': 5, 'A': 6, 'G': 7, 'V': 8, 'E': 9, 'S': 10, 'I': 11, 'K': 12, 'R': 13, 'D': 14, 'T': 15, 
+               'P': 16, 'N': 17, 'Q': 18, 'F': 19, 'Y': 20, 'M': 21, 'H': 22, 'C': 23, 'W': 24, 'X': 0, 'U': 0, 'B': 0, 'Z': 0, 'O': 0}
+    else:
+        aa_dict = {'[PAD]':0,'A':1,'C':2,'D':3,'E':4,'F':5,'G':6,'H':7,'I':8,'K':9,'L':10,'M':11,'N':12,'P':13,'Q':14,'R':15,
+               'S':16,'T':17,'V':18,'W':19,'Y':20,'U':0,'X':0,'J':0}
+    ## Esm vocab
+    ## protbert vocab
+    
+    padding_key = '[PAD]'
+    default_padding_value = 0
+    if padding_key in aa_dict:
+        dict_padding_value = aa_dict.get('[PAD]')
+    else:
+        dict_padding_value = default_padding_value
+        print(f"No padding value in the implicit dictionary, set to {default_padding_value} by default")
+
+    # assert len(lines) % 2 == 0, "Invalid file format. Number of lines should be even."
+    
+    long_pep_counter = 0
+    pep_codes = []
+    labels = []
+    ids = []
+    pad_flag = 1
+    for id,pep in lines:
+        ids.append(id)
+        x = len(pep)
+    
+        if  x < max_len:
+            current_pep=[]
+            for aa in pep:
+                if aa.upper() in aa_dict.keys():
+                    current_pep.append(aa_dict[aa.upper()])
+            # 将第一个长度<max_len的序列填充到40，确保当输入序列均<max_len时，所有序列仍然能够填充到max_len
+            if pad_flag:
+                current_pep.extend([dict_padding_value] * (max_len - len(current_pep)))
+                pad_flag = 0       
+            pep_codes.append(torch.tensor(current_pep)) # torch.tensor(current_pep)
+        else:
+            pep_head = pep[0:int(max_len/2)]
+            pep_tail = pep[int(x-int(max_len/2)):int(x)]
+            new_pep = pep_head+pep_tail
+            current_pep=[]
+            for aa in new_pep:
+                current_pep.append(aa_dict[aa])
+            pep_codes.append(torch.tensor(current_pep))
+            long_pep_counter += 1
+
+    print("length > {}:{}".format(max_len,long_pep_counter))
+    data = rnn_utils.pad_sequence(pep_codes,batch_first=True,padding_value=dict_padding_value)
+    return data,torch.tensor(labels)
+
+def SeqsData2EqlTensor(file_path:str,max_len:int,AminoAcid_vocab=None):
+    '''
+    Args:
+        flie:文件路径 \n
+        max_len:设定转换后的氨基酸序列最大长度 \n
+        vocab_dict:esm or protbert ,默认为按顺序映射的词典
+    '''
+    # 只保留20种氨基酸和填充数,其余几种非常规氨基酸均用填充数代替
+    # 使用 esm和portbert字典时，nn.embedding()的vocab_size = 25
+    if AminoAcid_vocab =='esm':
+        aa_dict = {'[PAD]': 1, 'L': 4, 'A': 5, 'G': 6, 'V': 7, 'S': 8, 'E': 9, 'R': 10, 'T': 11, 'I': 12, 'D': 13, 'P': 14, 'K': 15, 'Q': 16, 
+                   'N': 17, 'F': 18, 'Y': 19, 'M': 20, 'H': 21, 'W': 22, 'C': 23, 'X': 1, 'B': 1, 'U': 1, 'Z': 1, 'O': 1}
+    elif AminoAcid_vocab == 'protbert':
+        aa_dict = {'[PAD]':0,'L': 5, 'A': 6, 'G': 7, 'V': 8, 'E': 9, 'S': 10, 'I': 11, 'K': 12, 'R': 13, 'D': 14, 'T': 15, 
+               'P': 16, 'N': 17, 'Q': 18, 'F': 19, 'Y': 20, 'M': 21, 'H': 22, 'C': 23, 'W': 24, 'X': 0, 'U': 0, 'B': 0, 'Z': 0, 'O': 0}
+    else:
+        aa_dict = {'[PAD]':0,'A':1,'C':2,'D':3,'E':4,'F':5,'G':6,'H':7,'I':8,'K':9,'L':10,'M':11,'N':12,'P':13,'Q':14,'R':15,
+               'S':16,'T':17,'V':18,'W':19,'Y':20,'U':0,'X':0,'J':0}
+    ## Esm vocab
+    ## protbert vocab
+    
+    padding_key = '[PAD]'
+    default_padding_value = 0
+    if padding_key in aa_dict:
+        dict_padding_value = aa_dict.get('[PAD]')
+    else:
+        dict_padding_value = default_padding_value
+        print(f"No padding value in the implicit dictionary, set to {default_padding_value} by default")
+
+    with open(file_path, 'r') as inf:
+        lines = inf.read().splitlines()
+    assert len(lines) % 2 == 0, "Invalid file format. Number of lines should be even."
+    
+    long_pep_counter=0
+    pep_codes=[]
+    labels=[]
+    for line in lines:
+        if line[0] == '>':
+            labels.append([int(i) for i in line[1:]])
+        else:
+            x = len(line)
+        
+            if  x < max_len:
+                current_pep=[]
+                for aa in line:
+                    if aa.upper() in aa_dict.keys():
+                        current_pep.append(aa_dict[aa.upper()])
+                pep_codes.append(torch.tensor(current_pep)) #torch.tensor(current_pep)
+            else:
+                pep_head = line[0:int(max_len/2)]
+                pep_tail = line[int(x-int(max_len/2)):int(x)]
+                new_pep = pep_head+pep_tail
+                current_pep=[]
+                for aa in new_pep:
+                    current_pep.append(aa_dict[aa])
+                pep_codes.append(torch.tensor(current_pep))
+                long_pep_counter += 1
+
+    print("length > {}:{}".format(max_len,long_pep_counter))
+    data = rnn_utils.pad_sequence(pep_codes,batch_first=True,padding_value=dict_padding_value)
+    return data,torch.tensor(labels)
+
+def index_alignment(batch,condition_num=0,subtraction_num1=4,subtraction_num2=1):
+    '''将其他蛋白质语言模型的字典索引和默认字典索引进行对齐，保持氨基酸索引只有20个数构成，且范围在[1,20]，[PAD]=0或者1 \n
+    "esm"模型，condition_num=1,subtraction_num1=3，subtraction_num2=1； \n
+    "protbert"模型，condition_num=0,subtraction_num1=4
+
+    Args:               
+        batch:形状为[batch_size,seq_len]的二维张量 \n
+        condition_num:字典中的[PAD]值 \n 
+        subtraction_num1:对齐非[PAD]元素所需减掉的差值 \n
+        subtraction_num2:对齐[PAD]元素所需减掉的差值
+    
+    return:
+        shape:[batch_size,seq_len],dtype=tensor.
+    '''
+    condition = batch == condition_num
+    # 创建一个张量，形状和batch相同，表示非[PAD]元素要减去的值
+    subtraction = torch.full_like(batch, subtraction_num1)
+    if condition_num==0:
+        # 使用torch.where()函数来选择batch中为0的元素或者batch减去subtraction中的元素
+        output = torch.where(condition, batch, batch - subtraction)
+    elif condition_num==1:
+        # 创建一个张量，形状和batch相同，表示[PAD]元素要减去的值
+        subtraction_2 = torch.full_like(batch, subtraction_num2)
+        output = torch.where(condition, batch-subtraction_2, batch - subtraction)
+    
+    return output

DeepMFPP/model.py

@@ -0,0 +1,142 @@
+import torch
+import esm,math
+import torch.nn as nn
+import torch.nn.functional as F
+from DeepMFPP.utils import PositionalEncoding,FAN_encode
+from DeepMFPP.data_helper import index_alignment
+
+class DeepMFPP(nn.Module):
+    def __init__(self, vocab_size: int, embedding_size: int, fan_layer_num: int=1, num_heads: int=8, encoder_layer_num: int = 1, 
+                 output_size: int = 21, layer_idx=None, esm_path=None, dropout: float = 0.6, max_pool=5, Contrastive_Learning=False):
+        super(DeepMFPP,self).__init__()
+        
+        self.vocab_size = vocab_size
+        self.embedding_size = embedding_size
+        self.output_size = output_size
+        self.dropout = dropout
+        self.dropout_layer = nn.Dropout(self.dropout)
+        self.encoder_layer_num = encoder_layer_num
+        self.fan_layer_num = fan_layer_num
+        self.num_heads = num_heads
+        self.max_pool = max_pool
+        self.ctl = Contrastive_Learning
+        self.ffn_size = self.embedding_size*2
+        self.dropout_layer1 = nn.Dropout(0.4)
+
+        self.ESMmodel,_ = esm.pretrained.load_model_and_alphabet_local(esm_path)
+        self.ESMmodel.eval()
+        self.layer_idx = layer_idx
+
+        self.out_chs = 64
+        final_feats_shape = self.out_chs*50
+        self.embedding = nn.Embedding(self.vocab_size, self.embedding_size)
+        self.pos_encoding = PositionalEncoding(num_hiddens=self.embedding_size,dropout=self.dropout)
+        # self.attention_encode = AttentionEncode(self.dropout, self.embedding_size, self.num_heads,ffn=False)
+        
+        self.ffn = nn.Sequential(
+            nn.Linear(self.embedding_size, self.embedding_size*2, bias=True),
+            nn.GELU(),
+            # nn.LeakyReLU(),
+            nn.Linear(self.embedding_size*2, self.embedding_size, bias=True),
+        )
+        self.ln1 = nn.LayerNorm(self.embedding_size)
+        self.softmax = nn.Softmax(dim=-1)
+        self.W_o = nn.Linear(self.embedding_size,self.embedding_size)
+
+        self.kernel_sizes = [3,5,7,11,15]
+        self.MaxPool1d = nn.MaxPool1d(kernel_size=self.max_pool)
+        self.all_conv = nn.ModuleList([
+            nn.Sequential(
+                nn.Conv1d(self.embedding_size,out_channels=self.out_chs,kernel_size=self.kernel_sizes[i],padding=(self.kernel_sizes[i]-1)//2),
+                nn.BatchNorm1d(self.out_chs),
+                nn.LeakyReLU()
+            )
+            for i in range(len(self.kernel_sizes))
+        ])
+
+        # self.project_layer =nn.Linear(self.embedding_size,64)
+        self.fan = FAN_encode(self.dropout, final_feats_shape)
+        self.proj_layer = nn.Sequential(    nn.Linear(final_feats_shape,1280),
+                                    nn.BatchNorm1d(1280),
+                                    nn.LeakyReLU(),
+                                    nn.Linear(1280,128)
+                                    )
+        self.fc = nn.Sequential(   
+                                    nn.BatchNorm1d(128),
+                                    nn.LeakyReLU(),
+                                    nn.Linear(128,self.output_size)
+                                    )
+            
+    def CNN1DNet(self,x):
+
+        for i in range(len(self.kernel_sizes)):
+            conv = self.all_conv[i]
+            conv_x = conv(x)
+            conv_x = self.MaxPool1d(conv_x)
+            if i == 0:
+                all_feats = conv_x
+            else:
+                all_feats = torch.cat([all_feats,conv_x],dim=-1)
+        
+        return all_feats
+
+    def forward(self, x):
+        B,S = x.shape
+        H = self.embedding_size
+        
+        # --- ESM layer ----
+        with torch.no_grad():
+            results = self.ESMmodel(x, repr_layers=[self.layer_idx], return_contacts=False)
+        esm_x = results["representations"][self.layer_idx] #* 50 480 /640 /1280
+
+        # --- feature A Embedding+PE layer ----
+        index_ali_x = index_alignment(x,condition_num=1,subtraction_num1=3,subtraction_num2=1)
+        embedding_x = self.embedding(index_ali_x) # [batch_size,seq_len,embedding_size] 
+        pos_x = self.pos_encoding(embedding_x * math.sqrt(self.embedding_size)) # [batch_size,seq_len,embedding_size]
+        feats1 = pos_x
+        # feats1 = embedding_x
+        # feats_fuse = feats1
+
+        # for _ in range(self.encoder_layer_num):
+        #     feats1 = self.attention_encode(feats1)
+        # feats1 += embedding_x # B,S,H
+        # feats1 += esm_x
+
+        feats2 = esm_x
+        # feats_fuse = feats2
+
+        # # --- Self-attention feature fuse ---
+        d = feats1.size(-1)
+        q,k = feats1, feats2
+        v = feats1 + feats2 #+ esm_x
+        feats_qk = q @ k.transpose(-1, -2)*math.sqrt(d)
+        feats_qk = self.softmax(feats_qk)
+        feats_v = feats_qk @ v
+        # 线性变换投影到输出向量空间
+        feats_v = self.W_o(feats_v) # [B,S,H]
+        ffn_y = self.ffn(self.ln1(feats_v))   # 这两行的结构好像只能这样写
+        feats_fuse = v + self.dropout_layer(ffn_y)
+        # feats_fuse = feats1 + feats2
+        # feats_final = self.dropout_layer(self.project_layer(feats_fuse))
+
+        # # --- 1DCNN layer ---
+        cnn_input = feats_fuse
+        cnn_input = cnn_input.permute(0, 2, 1) # [B,H,S]
+        feats3 = self.CNN1DNet(cnn_input) # [B,F,S] F:out_chas 
+        feats3 = self.dropout_layer(feats3)
+        feats_final = feats3
+
+        # --- FFN layer ---
+        fan_input = feats_final.view(x.size(0),-1) # B,seq_len*feat_dim:50*64
+        fan_input = fan_input.unsqueeze(1) # B,1,seq_len*feat_dim:50*64  AddNorm中的normalized=[1, shape]
+        for _ in range(self.fan_layer_num):
+            fan_encode = self.fan(fan_input)
+        fan_out = fan_encode.squeeze(1)
+        # fan_out = fan_input.squeeze(1)
+
+        # --- CLSFC layer ---
+        hidden = self.proj_layer(fan_out)
+        logits = self.fc(hidden)
+
+        # return  feats1,feats2,feats_fuse,feats_final,fan_out,hidden,logits 
+        return  hidden,logits

DeepMFPP/predictor.py

@@ -0,0 +1,70 @@
+from DeepMFPP.model import DeepMFPP
+import torch
+import torch.nn as nn
+import numpy as np
+from DeepMFPP.config import ArgsConfig
+
+args = ArgsConfig()
+args.embedding_size = 480
+args.aa_dict = 'esm'
+args.loss_fn_name = 'MLFDL'
+args.weight_decay = 0
+args.batch_size = 192
+args.dropout = 0.62
+args.scale_factor = 100
+args.fldl_pos_weight = 0.4
+
+sigmoid = nn.Sigmoid()
+def predict(seqs:torch.Tensor,data:list,model_path:str, top_k:int=0,threshold:float=0.5, device=args.device):
+    torch.manual_seed(args.random_seed)
+    with torch.no_grad():
+        model = DeepMFPP(vocab_size=21,embedding_size=args.embedding_size, encoder_layer_num=1, fan_layer_num=1, num_heads=8,output_size=args.num_classes,
+                  esm_path=args.ems_path,layer_idx=args.esm_layer_idx,dropout=args.dropout,Contrastive_Learning=args.ctl).to(args.device)
+        model.eval()
+        state_dict = torch.load(model_path, map_location=device)
+        model.load_state_dict(state_dict,strict=False)
+        model.to(args.device)
+        # print(device)
+        seqs.to(args.device)
+        _, logits = model(seqs)
+        prob = sigmoid(logits)
+        # logits = np.round(logits.cpu().numpy(),3)
+        # prob = np.round(prob.cpu().numpy(),3)
+        # logits = logits.cpu().numpy()
+        prob = prob.cpu().numpy()
+        # print(logits)
+        # print(prob)
+    categories = ['AAP', 'ABP', 'ACP', 'ACVP','ADP', 'AEP', 'AFP', 'AHIVP', 'AHP', 'AIP', 'AMRSAP', 
+                    'APP', 'ATP', 'AVP', 'BBP', 'BIP', 'CPP', 'DPPIP', 'QSP', 'SBP', 'THP']
+    final_out = []
+    for i, j, k in zip(data, logits, prob):
+        temp = [i[0], i[1]]  # , f"logits:{j}", f"probability:{k}"
+
+        # 过滤概率值大于阈值的预测结果
+        result_dict = {}
+        for label, p in zip(categories, k):
+            # print(p)
+            if p > threshold:
+                result_dict[label] = round(float(p), 4)
+        
+        # 返回概率值大于阈值的字典对
+        # 示例: {'AVP': 0.567, 'ATP': 0.678, ...}
+        if result_dict:
+            sorted_result = {k: v for k, v in sorted(result_dict.items(), key=lambda item: item[1], reverse=True)}
+        else:
+            sorted_result = {}
+        # print(sorted_result)
+
+        if top_k: 
+            sorted_items_list = list(sorted_result.items())
+            top_k_result = dict(sorted_items_list[:top_k])
+            top_k_result_str = ", ".join(f"{key}: {value}" for key, value in top_k_result.items())
+            temp.extend([top_k_result_str])
+            
+        else:
+            sorted_result_str = ", ".join(f"{key}: {value}" for key, value in sorted_result.items())
+            temp.extend([sorted_result_str])
+        
+        final_out.append(temp)
+            
+    return final_out

DeepMFPP/utils.py

@@ -0,0 +1,95 @@
+import torch.nn as nn
+import torch
+import torch.nn.functional as F
+import numpy as np
+
+# transformer modules
+class AddNorm(nn.Module):
+    """残差连接后进行层归一化"""
+
+    def __init__(self, normalized, dropout):
+        super(AddNorm, self).__init__()
+        self.dropout = nn.Dropout(dropout)
+        self.ln = nn.LayerNorm(normalized)
+
+    def forward(self, x, y):
+        return  self.ln(x + self.dropout(y)) 
+
+
+class PositionWiseFFN(nn.Module):
+    """基于位置的前馈⽹络"""
+
+    def __init__(self, ffn_input, ffn_hiddens,mlp_bias=True):
+        super(PositionWiseFFN, self).__init__()
+        self.ffn = nn.Sequential(
+            nn.Linear(ffn_input, ffn_hiddens, bias=mlp_bias),
+            nn.ReLU(),
+            nn.Linear(ffn_hiddens, ffn_input, bias=mlp_bias),
+        )
+
+    def forward(self, x):
+        return self.ffn(x)
+    
+class PositionalEncoding(nn.Module):
+    """位置编码"""
+
+    def __init__(self, num_hiddens, dropout, max_len=1000):
+        super(PositionalEncoding, self).__init__()
+        self.dropout = nn.Dropout(dropout)
+        # 创建⼀个⾜够⻓的P
+        self.P = torch.zeros((1, max_len, num_hiddens))
+        X = torch.arange(max_len, dtype=torch.float32).reshape(-1, 1) / torch.pow(10000, torch.arange(0, num_hiddens, 2,
+                                                                                                      dtype=torch.float32) / num_hiddens)
+        self.P[:, :, 0::2] = torch.sin(X)
+        self.P[:, :, 1::2] = torch.cos(X)
+
+    def forward(self, X):
+        X = X + self.P[:, :X.shape[1], :].to(X.device)
+        return self.dropout(X)
+    
+class AttentionEncode(nn.Module):
+
+    def __init__(self, dropout, embedding_size, num_heads,ffn=False):
+        super(AttentionEncode, self).__init__()
+        self.dropout = dropout
+        self.embedding_size = embedding_size
+        self.num_heads = num_heads
+        self.seq_len = 50
+        self.is_ffn = ffn
+        
+        self.att = nn.MultiheadAttention(embed_dim=self.embedding_size,
+                                         num_heads=num_heads,
+                                         dropout=0.6
+                                         )
+    
+        self.addNorm = AddNorm(normalized=[self.seq_len, self.embedding_size], dropout=self.dropout)
+
+        self.FFN = PositionWiseFFN(ffn_input=self.embedding_size, ffn_hiddens=self.embedding_size*2)
+
+    def forward(self, x):
+        bs,_,_ = x.size()
+        MHAtt, _ = self.att(x, x, x)
+        MHAtt_encode = self.addNorm(x, MHAtt)
+
+        if self.is_ffn:
+            ffn_in = MHAtt_encode # bs,seq_len,feat_dims
+            ffn_out = self.FFN(ffn_in)
+            MHAtt_encode = self.addNorm(ffn_in,ffn_out)
+
+        return MHAtt_encode
+
+class FAN_encode(nn.Module):
+
+    def __init__(self, dropout, shape):
+        super(FAN_encode, self).__init__()
+        self.dropout = dropout
+        self.addNorm = AddNorm(normalized=[1, shape], dropout=self.dropout)
+        self.FFN = PositionWiseFFN(ffn_input=shape, ffn_hiddens=(2*shape))
+        self.ln = nn.LayerNorm(shape)
+
+    def forward(self, x):
+        #x = self.ln(x)
+        ffn_out = self.FFN(x)
+        encode_output = self.addNorm(x, ffn_out)
+
+        return encode_output

README.md

@@ -1,10 +1,10 @@
 ---
-title: DeepMFPP
-emoji: 🏢
+title: DeepPD
+emoji: 🐠
 colorFrom: gray
-colorTo: red
+colorTo: green
 sdk: gradio
-sdk_version: 4.13.0
+sdk_version: 3.33.1
 app_file: app.py
 pinned: false
 license: mit

app.ipynb

@@ -0,0 +1,322 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from Bio import SeqIO\n",
+    "from DeepMFPP.data_helper import Data2EqlTensor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "('ARRRRCSDRFRNCPADEALCGRRRR', 25)"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    ">000000000000000010000\n",
+    ">010000000010000000000\n",
+    ">010001000010000000000\n",
+    ">011000000001000000000\n",
+    ">100000000000000000000\n",
+    "\"\"\"\n",
+    "\n",
+    "file_path = './test_samples.fa'\n",
+    "data = []\n",
+    "for record in SeqIO.parse(file_path, 'fasta'):\n",
+    "    data.append((record.id, str(record.seq)))\n",
+    "\n",
+    "data[0][1],len(data[0][1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[('peptide_1', 'ARRRRCSDRFRNCPADEALCGRRRR'),\n",
+       " ('peptide_2', 'FFHHIFRGIVHVGKTIHKLVTGT'),\n",
+       " ('peptide_3', 'GLRKRLRKFRNKIKEKLKKIGQKIQGFVPKLAPRTDY'),\n",
+       " ('peptide_4', 'FLGALWNVAKSVF'),\n",
+       " ('peptide_5', 'KIKSCYYLPCFVTS')]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "length > 50:0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([5, 50])"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "seqs,ids = Data2EqlTensor(data,50)\n",
+    "seqs.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "seqs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from DeepMFPP.model import DeepMFPP\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import numpy as np\n",
+    "from DeepMFPP.config import ArgsConfig\n",
+    "\n",
+    "args = ArgsConfig()\n",
+    "args.embedding_size = 480\n",
+    "args.aa_dict = 'esm'\n",
+    "args.loss_fn_name = 'MLFDL'\n",
+    "args.weight_decay = 0\n",
+    "args.batch_size = 192\n",
+    "args.dropout = 0.62\n",
+    "args.scale_factor = 100\n",
+    "args.fldl_pos_weight = 0.4\n",
+    "\n",
+    "sigmoid = nn.Sigmoid()\n",
+    "def predict(seqs:torch.Tensor,data:list,model_path:str, top_k:int=0,threshold:float=0.5, device=args.device):\n",
+    "    torch.manual_seed(args.random_seed)\n",
+    "    with torch.no_grad():\n",
+    "        model = DeepMFPP(vocab_size=21,embedding_size=args.embedding_size, encoder_layer_num=1, fan_layer_num=1, num_heads=8,output_size=args.num_classes,\n",
+    "                  esm_path=args.ems_path,layer_idx=args.esm_layer_idx,dropout=args.dropout,Contrastive_Learning=args.ctl).to(args.device)\n",
+    "        model.eval()\n",
+    "        state_dict = torch.load(model_path, map_location=device)\n",
+    "        model.load_state_dict(state_dict,strict=False)\n",
+    "        model.to(args.device)\n",
+    "        # print(device)\n",
+    "        seqs.to(args.device)\n",
+    "        _, logits = model(seqs)\n",
+    "        prob = sigmoid(logits)\n",
+    "        # logits = np.round(logits.cpu().numpy(),3)\n",
+    "        # prob = np.round(prob.cpu().numpy(),3)\n",
+    "        # logits = logits.cpu().numpy()\n",
+    "        prob = prob.cpu().numpy()\n",
+    "        # print(logits)\n",
+    "        # print(prob)\n",
+    "    categories = ['AAP', 'ABP', 'ACP', 'ACVP','ADP', 'AEP', 'AFP', 'AHIVP', 'AHP', 'AIP', 'AMRSAP', \n",
+    "                    'APP', 'ATP', 'AVP', 'BBP', 'BIP', 'CPP', 'DPPIP', 'QSP', 'SBP', 'THP']\n",
+    "    final_out = []\n",
+    "    for i, j, k in zip(data, logits, prob):\n",
+    "        temp = [i[0], i[1]]  # , f\"logits:{j}\", f\"probability:{k}\"\n",
+    "        \n",
+    "        # 过滤概率值大于阈值的预测结果\n",
+    "        result_dict = {}\n",
+    "        for label, p in zip(categories, k):\n",
+    "            # print(p)\n",
+    "            if p > threshold:\n",
+    "                result_dict[label] = round(float(p), 4)\n",
+    "        \n",
+    "        # 返回概率值大于阈值的字典对\n",
+    "        # 示例: {'AVP': 0.567, 'ATP': 0.678, ...}\n",
+    "        if result_dict:\n",
+    "            sorted_result = {k: v for k, v in sorted(result_dict.items(), key=lambda item: item[1], reverse=True)}\n",
+    "        else:\n",
+    "            sorted_result = {}\n",
+    "        # print(sorted_result)\n",
+    "\n",
+    "        # 选择概率值最高的 top_k 个预测结果\n",
+    "        if top_k: \n",
+    "            sorted_items_list = list(sorted_result.items())\n",
+    "            top_k_result = dict(sorted_items_list[:top_k])\n",
+    "            top_k_result_str = \", \".join(f\"{key}: {value}\" for key, value in top_k_result.items())\n",
+    "            temp.extend([top_k_result_str])\n",
+    "            \n",
+    "        else:\n",
+    "            sorted_result_str = \", \".join(f\"{key}: {value}\" for key, value in sorted_result.items())\n",
+    "            temp.extend([sorted_result_str])\n",
+    "        \n",
+    "        final_out.append(temp)\n",
+    "            \n",
+    "    return final_out"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+    "\n",
+    "def MFPs_classifier(file:str,threshold:float=0.5,top_k=0):\n",
+    "    data = []\n",
+    "    for record in SeqIO.parse(file, 'fasta'):\n",
+    "        data.append((record.id, str(record.seq)))\n",
+    "    seqs,_ = Data2EqlTensor(data,51,AminoAcid_vocab=args.aa_dict)\n",
+    "    model_weight_path = './weight/DeepMFPP-Best.pth'\n",
+    "    MFPs_pred = predict(seqs=seqs, data=data, model_path=model_weight_path, threshold=threshold,top_k=top_k,device=device)\n",
+    "    \n",
+    "    return MFPs_pred"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "length > 51:0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[['peptide_1',\n",
+       "  'ARRRRCSDRFRNCPADEALCGRRRR',\n",
+       "  'ADP: 0.5739, BBP: 0.5358, AAP: 0.5204, AIP: 0.5153, DPPIP: 0.5056, ABP: 0.5'],\n",
+       " ['peptide_2',\n",
+       "  'FFHHIFRGIVHVGKTIHKLVTGT',\n",
+       "  'ADP: 0.5633, AIP: 0.5371, BBP: 0.5369, AAP: 0.5235, DPPIP: 0.5084, SBP: 0.5065, AHP: 0.5059, APP: 0.5027, ACP: 0.502'],\n",
+       " ['peptide_3',\n",
+       "  'GLRKRLRKFRNKIKEKLKKIGQKIQGFVPKLAPRTDY',\n",
+       "  'AAP: 0.5418, ADP: 0.5346, ABP: 0.5167, DPPIP: 0.5162, AIP: 0.5081, QSP: 0.5047, APP: 0.5034'],\n",
+       " ['peptide_4',\n",
+       "  'FLGALWNVAKSVF',\n",
+       "  'ADP: 0.5684, BBP: 0.5619, AHP: 0.5381, AAP: 0.5319, AIP: 0.5189, ACP: 0.5124, QSP: 0.5104, SBP: 0.5059, DPPIP: 0.5012'],\n",
+       " ['peptide_5',\n",
+       "  'KIKSCYYLPCFVTS',\n",
+       "  'ADP: 0.5862, BBP: 0.5636, ACP: 0.5271, AHP: 0.5266, AIP: 0.5244, AAP: 0.5149, DPPIP: 0.5111, QSP: 0.5093, APP: 0.5074']]"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "out = MFPs_classifier(file_path,threshold=0.5,top_k=0)\n",
+    "out"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor(0.4508)"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x = -0.1974\n",
+    "sigmoid(torch.tensor(x))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[('ADP', 0.5739), ('BBP', 0.5358), ('AAP', 0.5204), ('AIP', 0.5153), ('DPPIP', 0.5056), ('ABP', 0.5001)] 6\n",
+      "{'ADP': 0.5739, 'BBP': 0.5358, 'AAP': 0.5204}\n"
+     ]
+    }
+   ],
+   "source": [
+    "original_dict = {'ADP': 0.5739, 'BBP': 0.5358, 'AAP': 0.5204, 'AIP': 0.5153, 'DPPIP': 0.5056, 'ABP': 0.5001}\n",
+    "n = 3  # 要保留的键值对数量\n",
+    "\n",
+    "sliced_items = list(original_dict.items())\n",
+    "print(sliced_items,len(sliced_items))\n",
+    "sliced_dict = dict(sliced_items[:n])\n",
+    "print(sliced_dict)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "env3.8",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.0"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

app.py

@@ -0,0 +1,72 @@
+import torch
+from DeepMFPP.predictor import predict
+from DeepMFPP.data_helper import Data2EqlTensor
+import gradio as gr
+from Bio import SeqIO
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+def MFPs_classifier(file:str,threshold:float=0.5,top_k=0):
+    data = []
+    for record in SeqIO.parse(file.name, 'fasta'): # notebook测试时 for record in SeqIO.parse(file, 'fasta')
+        data.append((record.id, str(record.seq))) 
+    seqs,_ = Data2EqlTensor(data,51,AminoAcid_vocab='esm')
+    model_weight_path = './weight/DeepMFPP-Best.pth'
+    MFPs_pred = predict(seqs=seqs, data=data, model_path=model_weight_path, threshold=threshold,top_k=top_k,device=device)
+    
+    return MFPs_pred
+"""
+[['peptide_1', 'ARRRRCSDRFRNCPADEALCGRRRR'],
+ {'ADP': 0.5739, 'BBP': 0.5358},
+ ['peptide_2', 'FFHHIFRGIVHVGKTIHKLVTGT'],
+ {'ADP': 0.5633, 'AIP': 0.5371},
+ ['peptide_3', 'GLRKRLRKFRNKIKEKLKKIGQKIQGFVPKLAPRTDY'],
+ {'AAP': 0.5418, 'ADP': 0.5346},
+ ['peptide_4', 'FLGALWNVAKSVF'],
+ {'ADP': 0.5684, 'BBP': 0.5619},
+ ['peptide_5', 'KIKSCYYLPCFVTS'],
+ {'ADP': 0.5862, 'BBP': 0.5636}]
+"""
+
+with gr.Blocks() as demo:
+    gr.Markdown(" ## DeepMFPP")
+    gr.Markdown("In this study, we developed a multi-functional peptides(MFPs) prediction model. The model was used to predict the \
+                functional labels (21 categories of MFPs involved in our study) that peptide sequences have.")
+    
+    with gr.Tab("MFPs Prediction Model"):
+        with gr.Row():
+            with gr.Column(scale=2):
+                input_fasta = gr.File()
+            with gr.Column(scale=2):
+                cutoff = gr.Slider(0, 1, step=0.01, value=0.5, interactive=True, label="Threshold")
+                top_k = gr.Slider(0, 21, step=1, value=0, interactive=True, label="top_k")
+                
+                gr.Markdown("### Note")
+                gr.Markdown("- Limit the number of input sequences to less than 128.")
+                gr.Markdown("- If top_k is set to 0, the combination of all probability values (processed by the sigmoid function) \
+                            larger than the threshold is returned by default. Otherwise, the specified top k predictions are returned")
+                gr.Markdown("- The file should be the Fasta format.")
+                gr.Markdown("- If the length of the sequence is less than 50, use 0 to fill to 50; if the length is over 50, \
+                            We used only the first 25 amino acids of each N-terminal and C-terminal of the sequence for prediction.")
+                image_button_MFPs = gr.Button("Submit")
+        with gr.Column():
+            # gr.Markdown(" ### Flip text or image files using this demo.")
+            gr.Markdown("Note: The predicted probabilities are processed by sigmoid function")
+            MFPs_output = gr.DataFrame(
+                headers=["Sequence Id", "Sequence", "Categories and probabilities"],
+                datatype=["str", "str", "str"],)
+            
+            
+    image_button_MFPs.click(MFPs_classifier, inputs=[input_fasta, cutoff,top_k], outputs=MFPs_output)
+    
+    with gr.Accordion("Citation"):
+        gr.Markdown("- GitHub: https://github.com/leonern/DeepMFPP-GitHub")
+
+    with gr.Accordion("License"):
+        gr.Markdown("- Released under the [MIT license](https://github.com/leonern/DeepMFPP-GitHub/blob/main/LICENSE). ")
+
+    with gr.Accordion("Contact"):
+        gr.Markdown("- If you have any questions, please file a Github issue or contact me at 107552103310@stu.xju.edu.cn")
+
+
+demo.queue(4)
+demo.launch() #share=True

requirements.txt

@@ -0,0 +1,7 @@
+torch
+numpy
+biopython
+transformers
+gradio
+Bio
+fair-esm

test_samples.fa

@@ -0,0 +1,10 @@
+>peptide_1
+ARRRRCSDRFRNCPADEALCGRRRR
+>peptide_2
+FFHHIFRGIVHVGKTIHKLVTGT
+>peptide_3
+GLRKRLRKFRNKIKEKLKKIGQKIQGFVPKLAPRTDY
+>peptide_4
+FLGALWNVAKSVF
+>peptide_5
+KIKSCYYLPCFVTS

weight/DeepMFPP-Best.pth

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