Method for lightweight prediction of PPI based on Node2vec

Abstract

The invention discloses a method for lightweight prediction of PPI based on Node2vec, and the method comprises the following steps: a protein initial representation module: learning protein initial representation from a protein interaction network G = (V, E) in an unsupervised manner by using Node2vec; the multi-scale relation structure representation module is used for setting two GNNs with different scales to capture shallow layer and deep layer structure information in the protein interaction network, and the GNNs comprise an SGCN variant for the shallow layer structure information and a Mama module for the deep layer structure information; carrying out weighted sum summation on the protein feature representations obtained by SGCN and Mama learning to obtain final protein representation; in the prediction module, the deep protein representation and the shallow protein representation are subjected to element multiplication, semantic information of the features is enhanced, and then prediction is carried out. An unsupervised learning method Node2vec is introduced to carry out unsupervised learning on initial expression of protein, then graph nerve + attention is adopted to carry out supervised fine learning, and local features and global features in the initial expression of the protein are planned as a whole.

Description

Technical Field

[0001] The present invention relates to the technical field of PPI prediction, and in particular to a method for lightweight PPI prediction based on Node2vec. Background Art

[0002] Protein-protein interactions (PPIs) are essential for various cellular functions and biological processes as they form the basis for a variety of biological activities, such as signal transduction, cell cycle progression, and metabolic pathways. Therefore, understanding, identifying, and predicting PPIs are essential for medical, pharmaceutical, and genetic research. In recent decades, various experimental techniques for high-throughput PPI prediction have emerged, including methods such as yeast two-hybrid screening and mass spectrometry protein complex identification. However, experimental PPI detection in wet labs is usually expensive and time-consuming, which poses a challenge to meet the growing demand for large-scale PPI prediction. Therefore, there is an urgent need to develop computational methods that can effectively predict unknown PPIs. With the advancement of artificial intelligence technology, computational methods for PPI prediction have shifted the paradigm from traditional machine learning methods to deep learning techniques.

[0003] Supervised learning methods can achieve excellent results when there is a sufficient amount of labeled data. However, in protein-protein interaction (PPI) prediction, it is costly to obtain and label large datasets, and a large amount of unlabeled data remains underutilized. In recent years, semi-supervised and self-supervised methods have emerged to exploit large amounts of unlabeled data to reveal hidden patterns and structures. Some researchers have improved the clustering performance of single-cell RNA sequencing data by incorporating prior biological knowledge. Others have used labeled and unlabeled data to predict protein-protein interactions. With the development of next-generation sequencing technology, thousands of protein sequences have been identified and added to various databases such as the Protein Data Bank (PDB). As the protein sequence corpus continues to grow, many studies have attempted to apply pre-training methods from natural language processing (NLP) to the field of biological sequences. Baidu has proposed large-scale unsupervised protein pre-training models and tools such as MSA Transformer, Protein, Wendao, and Helix, which use these large sequence corpora to infer protein structure and function from unlabeled data.

[0004] These unsupervised methods have advantages when labeled data is scarce because they do not rely on explicit annotations for training. However, while they can capture broad patterns from large datasets, they can also come with a significant computational burden. Summary of the invention

[0005] The purpose of the present invention is to provide a lightweight PPI prediction method based on Node2vec for the above-mentioned existing problems, by introducing the unsupervised learning method Node2vec to learn the initial representation of proteins in an unsupervised manner, and then adopting the supervised fine learning of graph neural network + attention, coordinating the local features and global features in the initial representation of proteins, and capturing the local and global structures in the PPI network through the Node2vec walk strategy. Thereby, a rich feature representation is provided for the nodes, and the homogeneity and isomorphism of the PPI network are better balanced. After the initial representation of the protein is obtained by Node2vec, the local modal features of the protein are further learned using the supervised learning method GIN, and the relational features of different scales are captured by the multi-layer graph neural network and the Mamba mechanism, and finally predicted by the classifier to obtain their local modal features and global modal features.

[0006] The technical solution of the present invention is as follows:

[0007] A lightweight PPI prediction method based on Node2vec includes the following steps:

[0008] Protein initial representation module: Use Node2vec to unsupervisedly learn protein initial representation from the protein interaction network G = (V, E);

[0009] Multi-scale relational structure representation module: Two GNNs of different scales are set to capture shallow and deep structural information in protein interaction networks, including SGCN variants for shallow structural information and Mamba modules for deep structural information;

[0010] The protein feature representations learned by SGCN and Mamba are weighted and summed to obtain the final protein representation;

[0011] In the prediction module, the deep protein representation and the shallow protein representation are element-wise multiplied to enhance the semantic information of the features while preserving detailed information, and then prediction is made.

[0012] Furthermore, the multi-scale relationship structure representation module specifically includes the following steps:

[0013] After obtaining the initial protein representation, a PPI network with the initial protein representation as node information is constructed, and GNN is used to learn the multi-scale relationship modal features between proteins;

[0014] Different types of GNNs are set up to simultaneously capture the shallow and deep relational modal features of the PPI network, and then the final protein feature representation is characterized by fusing the shallow and deep relational modal features.

[0015] Furthermore, the multi-scale relational structure representation module adopts a graph isomorphism network to learn the shallow feature representation of proteins, and the graph isomorphism network includes the following steps:

[0016] Each GIN layer uses a sum aggregation function to integrate the features of neighbor nodes and uses a multi-layer perceptron to update the aggregated features;

[0017] For each protein node p, the update rule of its feature representation is:

[0018]

[0019] Among them, N k(p) represents the set of k-hop neighbors of node p, σ (l) and ∈ (l) They are layer-specific activation functions and learnable self-loop parameters, respectively. Through a recursive aggregation and update mechanism, GIN is able to learn and extract high-level compact representations of proteins from the pre-trained features of Node2vec.

[0020] Furthermore, the multi-scale relational structure representation module uses Graph-Mamba to integrate GAT and Mamba mechanisms to extract deep relational modal features in the PPI network, specifically including the following steps:

[0021] GAT uses the attention mechanism to learn the importance of each neighboring node to the current node. i,j , connect the edge features with the features of the neighboring nodes and the current node:

[0022]

[0023] Where T represents transpose, || represents connection, α is a learnable parameter for learning the attention coefficient in a single-layer feedforward neural network, W is a linear transformation shared among all node and edge features, X is the node feature, E is the edge feature, is a neighboring node of the current node i, k represents all neighboring nodes j of the current node i, once the α of all neighboring nodes is obtained i,j , the features of the current node are updated by the weighted sum of the features of its neighboring nodes;

[0024] Set up a Graph-Mamba framework to learn long-distance features through Mamba. The Graph-Mamba framework includes at least five stacked GMB layers.

[0025] Furthermore, the structure of Mamba includes:

[0026] MAMBA is mainly based on the structured state space model, which is a sequence model in which the linear ordinary differential equation passes through a potential state h(t)∈R N The feature x(t)∈R containing the node importance learned by GAT N Mapped to the output sequence y(t)∈R N ;

[0027] The core idea of ​​SSM is to use state space representation to describe the dynamic behavior and input-output relationship of the system:

[0028] h′(t)=Ah(t)+Bx(t),

[0029] y(t)=Ch(t),

[0030] Among them, A∈R N ×N and B,C∈R N Represent the state matrix, input matrix and output matrix respectively;

[0031] Discretize the above calculation formula into:

[0032]

[0033] y t =Ch t ,

[0034] in, and Δ is the discretized state parameter, Δ is the discretization step size;

[0035] Consider N = 1, A = -1, B = 1, and Δ t =softplus(Linear(x t ), for the selective SSM, the discretized recursive output is defined as:

[0036] g t =σ(Linear(x t )),

[0037] h t =(1-g t )h t-1 +g t x t

[0038] g t The range is between 0 and 1, allowing the model to completely filter out irrelevant context when necessary. The current input x t Can pass g t Controlling current input and previous context when updating hidden state

[0039] h t-1 The balance between the two is to obtain data-dependent and The projection matrices B and C are parameterized as linear projections of the input x to further control x t Update the degree of hidden state and h t For output y t impact.

[0040] Proof: Substitute the expression of Δt into the zero-order hold discretization formula:

[0041] and

[0042]

[0043]

[0044] This is done by parameterizing B, C, and Δ with respect to the input x, where B enables the model to control the input x. t For the hidden state h t The influence of C enables the model to control h t For output y t The influence of Δ control on x t The degree of attention or neglect, a larger Δ means paying more attention to x than the previous hidden state t ;

[0045] Each node in the graph is a token. Mamba’s selection mechanism enables the model to minimize the influence of unimportant nodes in each hidden state calculation step. Laplace position encoding serves as Mamba’s position information.

[0046] The formula for position encoding is as follows:

[0047] L = DA,

[0048] Among them, A is the adjacency matrix of the PPI network, D is the degree matrix of the PPI network nodes, and the position code P is generated by calculating the eigenvalues ​​and eigenvectors of the graph Laplacian matrix L, and the position code P is added to the input features of Mamba:

[0049]

[0050] in, is the feature after position encoding of node i, h i is the initial feature of node i, p i is the position code of node i;

[0051] The updated node embeddings are combined through the MLP layer to generate the output node embeddings, using the output of the previous layer as the input of the next layer, which is iterated through 5 GMB layers to obtain the final output node embeddings. The update process of the node embeddings in the MLP is as follows:

[0052] h (i+1) =ReLU(BatchNorm(W (2) ReLU(W (1) h (i) +b (1) )+b (2) )),

[0053] h(i) is the input node embedding of the i-th layer, W (1) and W (1) is the weight matrix of the linear layer, b (1) and b (2) It is the bias term of the linear layer, and generates the output node embedding after two layers of linear transformation, two ReLU activations and one batch normalization in one update.

[0054] Furthermore, the protein initial representation module specifically includes the following steps:

[0055] For a given protein interaction network G = (V, E), a random walk is performed on each node to generate a sequence. In Node2vec, the random walk is controlled by adjusting two parameters p and q, which respectively represent the degree of breadth-first search and depth-first search in the random walk process;

[0056] From Node v i Start a random walk and move to node v next j The probability is expressed as:

[0057]

[0058] Where E represents the edge set in the graph;

[0059] After generating the node sequence, the node sequence is used to train the Word2Vec model to learn the low-dimensional representation of the node.

[0060] Furthermore, the calculation formula of the Word2Vec model is:

[0061] For a node sequence (v1,v2,…,v T ), maximize each node v i The neighboring node v i+j The conditional probability is:

[0062]

[0063] Among them, p(v i+j |v i ; θ) represents the i In the case of i+j , θ represents the model parameters, and k represents the size of the context window.

[0064] Furthermore, the prediction module will simultaneously receive the shallow relational modal features H output from the multi-scale relational modal feature learning module. s , and the deep relation modal feature H d , and then assign weights for summing and fusion to obtain the final protein feature representation H, which is calculated as follows:

[0065] H=w1H s +w2H d ,

[0066] The protein interaction representation Z is obtained by performing the Hadamard product on the relevant protein feature representations, and the calculation formula is:

[0067] z k =h i *h j ,if A ij =1,

[0068] Z=[z1...z n ],

[0069] The protein interaction representation Z is input into the MLP as a classifier to predict the protein interaction type.

[0070] Compared with the prior art, the present invention has the following beneficial effects:

[0071] 1. A lightweight PPI prediction method based on Node2vec, protein initial representation module: Node2Vec is used to design an unsupervised graph representation learning method on the protein interaction network. The node representation obtained from Node2vec learning will be used as the node information in the PPIs network;

[0072] 2. A lightweight PPI prediction method based on Node2vec, multi-scale relational structure representation module: two GNNs of different scales are set to capture shallow and deep structural information in protein interaction networks, including SGCN variants for shallow structural information and Mamba modules for deep structural information. The protein feature representations learned by SGCN and Mamba are weighted and summed to obtain the final protein representation. Finally, in the prediction module, the deep protein representation and the shallow protein representation are element-wise multiplied to enhance the semantic information of the features while retaining detailed information, and then prediction is performed. BRIEF DESCRIPTION OF THE DRAWINGS

[0073] Figure 1 This is a schematic diagram of the architecture of this application.

[0074] Figure 2 A detailed grouping comparison of unknown protein-protein interactions (PPIs) between 82 and GNN-PPI under cross-dataset conditions.

[0075] Figure 3 To compare the F1 scores of 82 and GNN-PPI under three partitions under the condition of cross dataset, using SHS27k as the training set and string as the test set.

[0076] Figure 4 To compare the F1 scores of 82 and GNN-PPI under three partitions under the condition of cross-dataset, using SHS148k as the training set and string as the test set. DETAILED DESCRIPTION

[0077] It should be noted that relational terms such as "first" and "second" are used only to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Moreover, the terms "include", "comprise" or any other variants thereof are intended to cover non-exclusive inclusion, so that a process, method, article or device including a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, article or device. In the absence of further restrictions, the elements defined by the sentence "comprise a ..." do not exclude the existence of other identical elements in the process, method, article or device including the elements.

[0078] The features and performance of the present invention are further described in detail below in conjunction with the embodiments.

[0079] Given N proteins P = {P1, P2, ···, P N} and a set of PPIs (protein-protein interactions) X = {(P i ,P j )|P i ,P j ∈P,i≠j}, construct a PPI graph G T =(V T ,E T ), where each node p i ∈V T Represents a protein P i ∈P, each edge ei,j ∈E T If and only if (P i ,P j )∈X. Consider a semi-supervised PPI prediction task where only some PPIs X L ∈X and its corresponding interaction type Y L It is known that the tag set can be represented as D L =(X L ,Y L ), the unlabeled set is denoted as D U =(X U ,Y U ), where X U =X / X L The goal of PPI prediction is to L ) in a transfer setting to learn a mapping F:X→Y so that it can be used to infer unlabeled PPIs X U Interaction type Y U .

[0080] See also Figure 1-3 , a lightweight method for predicting PPI based on Node2vec, such as Figure 1 As shown, the following steps are included:

[0081] Protein initial representation module: Use Node2vec to unsupervisedly learn protein initial representation from the protein interaction network G = (V, E);

[0082] The protein initial representation module specifically includes the following steps:

[0083] For a given protein interaction network G = (V, E), a random walk is performed on each node to generate a sequence. In Node2vec, the random walk is controlled by adjusting two parameters p and q, which respectively represent the degree of breadth-first search and depth-first search in the random walk process;

[0084] From Node v i Start a random walk and move to node v next j The probability is expressed as:

[0085]

[0086] Where E represents the edge set in the graph;

[0087] After generating the node sequence, the node sequence is used to train the Word2Vec model to learn the low-dimensional representation of the node.

[0088] The goal of the Word2Vec model is to maximize the conditional probability of neighboring nodes given a node sequence.

[0089] The calculation formula of the Word2Vec model is:

[0090] For a node sequence (v1,v2,…,v T ), maximize each node v i The neighboring node v itj The conditional probability is:

[0091]

[0092] Among them, p(v i+j |v i ; θ) represents the i In the case of i+j , θ represents the model parameters, and k represents the size of the context window.

[0093] The Node2vec method can learn low-dimensional representations of nodes in the protein interaction network, thereby effectively capturing the structural and semantic information between nodes. Finally, each learned low-dimensional representation of the node is used as the initial representation of the protein.

[0094] Multi-scale relational structure representation module: Two GNNs of different scales are set to capture shallow and deep structural information in protein interaction networks, including SGCN variants for shallow structural information and Mamba modules for deep structural information;

[0095] The multi-scale relationship structure representation module specifically includes the following steps:

[0096] After obtaining the initial protein representation, a PPI network with the initial protein representation as node information is constructed, and GNN is used to learn the multi-scale relationship modal features between proteins;

[0097] Different types of GNNs are set up to capture both the shallow and deep relational modal features of the PPI network, and then the shallow and deep relational modal features are fused to represent the final protein feature representation. Protein representation actually contains three scales of protein relational modal information, namely, the relational modal information learned unsupervised in the protein initial representation module, the shallow relational modal information, and the deep relational modal information.

[0098] The multi-scale relational structure representation module uses a graph isomorphism network to learn the shallow feature representation of proteins. The graph isomorphism network includes the following steps:

[0099] Each GIN layer uses a summation aggregation function to integrate the features of neighboring nodes and uses multi-layer perceptrons (MLPs) to update the aggregated features; this design allows not only the direct neighbors of each protein to be considered in each iteration, but also to gradually expand to a wider neighborhood range through a multi-layer structure.

[0100] For each protein node p, the update rule of its feature representation is:

[0101]

[0102] Among them, N k(p) represents the set of k-hop neighbors of node p, σ (l) and ∈ (l) They are layer-specific activation functions and learnable self-loop parameters, respectively. Through a recursive aggregation and update mechanism, GIN is able to learn and extract high-level compact representations of proteins from the pre-trained features of Node2vec.

[0103] Through such a configuration, the GIN model can effectively extract high-level features useful for PPI prediction while maintaining the original topology and functional properties of the protein. In addition, the protein representation learned by GIN not only contains individual properties, but also incorporates the interaction information between proteins, thus providing a strong foundation for subsequent PPI prediction and biological function analysis.

[0104] The multi-scale relational structure representation module uses Graph-Mamba to integrate GAT and Mamba mechanisms to extract deep relational modal features in the PPI network, which specifically includes the following steps:

[0105] GAT uses the attention mechanism to learn the importance of each neighboring node to the current node. i,j , connect the edge features with the features of the neighboring nodes and the current node:

[0106]

[0107] Where T represents transpose, || represents connection, α is a learnable parameter for learning the attention coefficient in a single-layer feedforward neural network, W is a linear transformation shared among all node and edge features, X is the node feature, E is the edge feature, is a neighboring node of the current node i, k represents all neighboring nodes j of the current node i, once the α of all neighboring nodes is obtained i,j , the features of the current node are updated by the weighted sum of the features of its neighboring nodes;

[0108] Setting up the Graph-Mamba framework, Mamba is used to learn long-distance features. The Graph-Mamba framework includes at least five stacked GMB layers. It provides better adaptability in modeling long sequences, enabling the model to adaptively select relevant information from the context.

[0109] Mamba introduces a selection mechanism that allows the model to selectively retain information and learn deeper information. In PPI graph learning, with protein nodes as input sequences, the selection mechanism allows the hidden state to be updated based on the related protein nodes in the previous sequence. It is controlled by the current input protein node and subsequently affects the output embedding of the current node. The ability to select and reset enables Mamba to extract protein-related dependencies given a long-range context while minimizing the influence of unimportant protein nodes at each recursive step.

[0110] The structure of Mamba includes:

[0111] MAMBA is mainly based on the structured state space model (SSM), which is a sequence model in which a linear ordinary differential equation (ODE) is expressed through a latent state h(t)∈R N The feature x(t)∈R containing the node importance learned by GAT N Mapped to the output sequence y(t)∈R N ;

[0112] The core idea of ​​SSM is to use state space representation to describe the dynamic behavior and input-output relationship of the system:

[0113] h′(t)=Ah(t)+Bx(t),

[0114] y(t)=Ch(t),

[0115] Among them, A∈R N ×N and B,C∈R N Represent the state matrix, input matrix and output matrix respectively;

[0116] Discretize the above calculation formula into:

[0117]

[0118] y t =Ch t ,

[0119] in, and Δ is the discretized state parameter and Δ is the discretization step size; SSM has rich theoretical properties, but suffers from high computational cost and numerical instability. The structured state space sequence model (S4) solves these limitations by imposing structural constraints on the state matrix A based on the HIPPO matrix, thereby significantly improving performance and efficiency.

[0120] S4 shows better adaptability in modeling long sequences, but performs poorly when content-aware reasoning is required, due to its time-invariance. Specifically, the matrices A, B, and C are the same for all input tokens in a sequence. Mamba is implemented by simply making the SSM parameters B, C, and Δ a function of the input x.

[0121] The intuition of the Mamba selection mechanism is illustrated using the reparameterized discretization step size Δ as an example. Δt plays a generalized role similar to the gating mechanism in RNN to promote input-dependent selection. For further reference to the SSM selection mechanism, the following theorem is given,

[0122] Consider N = 1, A = -1, B = 1, and Δ t =softplus(Linear(x t ), for the selective SSM, the discretized recursive output is defined as:

[0123] g t =σ(Linear(x t )),

[0124] h t =(1-g t )h t-1 +g t x t

[0125] g t The range is between 0 and 1, allowing the model to completely filter out irrelevant context when necessary. The current input x t Can pass g t Controlling the current input and previous context when updating the hidden state t-1 The balance between the two is to obtain data-dependent and The projection matrices B and C are parameterized as linear projections of the input x to further control x t Update the degree of hidden state and h t For output y t impact.

[0126] Proof: Substitute the expression of Δt into the zero-order hold discretization formula: and

[0127]

[0128] This is done by parameterizing B, C, and Δ with respect to the input x, where B enables the model to control the input x. t For the hidden state h t The influence of C enables the model to control h t For output y t The influence of Δ control on x t The degree of attention or neglect, a larger Δ means paying more attention to x than the previous hidden state t ;

[0129] Each node in the graph is a token. Mamba’s selection mechanism enables the model to minimize the influence of unimportant nodes in each hidden state calculation step. Laplace position encoding serves as Mamba’s position information.

[0130] The formula for position encoding is as follows:

[0131] L = DA,

[0132] Among them, A is the adjacency matrix of the PPI network, D is the degree matrix of the PPI network nodes, and the position code P is generated by calculating the eigenvalues ​​and eigenvectors of the graph Laplacian matrix L, and the position code P is added to the input features of Mamba:

[0133]

[0134] in, is the feature after position encoding of node i, h i is the initial feature of node i, p i is the position code of node i;

[0135] The updated node embeddings are combined through the MLP layer to generate the output node embeddings, using the output of the previous layer as the input of the next layer, which is iterated through 5 GMB layers to obtain the final output node embeddings. The update process of the node embeddings in the MLP is as follows:

[0136] h (i+1) =ReLU(BatchNorm(W (2) ReLU(W (1) h (i) +b (1) )+b (2) )),

[0137] h(i) is the input node embedding of the i-th layer, W (1) and W (1) is the weight matrix of the linear layer, b (1) and b(2) It is the bias term of the linear layer, and generates the output node embedding after two layers of linear transformation, two ReLU activations and one batch normalization in one update.

[0138] Graph-Mamba combines the selection mechanism in the Mamba module with loop scanning in sequence modeling to achieve two-layer graph sparsification. The first layer involves the selection mechanism in the Mamba module, which effectively filters relevant information in long-distance contexts. The second layer is implemented by the proposed node priority method, which enables important nodes in the graph to access more contexts. Therefore, these sequence modeling features provide a promising approach to combine data dependency and heuristic selection for graph sparsification.

[0139] The protein feature representations learned by SGCN and Mamba are weighted and summed to obtain the final protein representation;

[0140] In the prediction module, the deep protein representation and the shallow protein representation are element-wise multiplied to enhance the semantic information of the features while preserving detailed information, and then prediction is made.

[0141] The prediction module will simultaneously receive the shallow relational modal features H output by the multi-scale relational modal feature learning module. s , and the deep relation modal feature H d , and then assign weights for summing and fusion to obtain the final protein feature representation H, which is calculated as follows:

[0142] H=w1H s +w2H d ,

[0143] The protein interaction representation Z is obtained by performing the Hadamard product on the relevant protein feature representations, and the calculation formula is:

[0144] z k =h i *h j ,if A ij =1,

[0145] Z=[z1...z n ],

[0146] The protein interaction representation Z is input into the MLP as a classifier to predict the protein interaction type.

[0147] experiment:

[0148] The lightweight PPI prediction method proposed in this application is referred to as "82" in the experiment.

[0149] Datasets: Extensive experiments were conducted on three public PPI datasets, namely STRING, SHS27k, and SHS148k. The STRING dataset contains human PPI data from the STRING database, totaling 1,150,830 entries, covering 14,952 proteins and 572,568 interactions. Each protein-protein interaction is annotated as at least one of the following seven types: Activation, Binding, Catalysis, Expression, Inhibition, Post-translational modification (Ptmod), and Reaction. "One interaction + one annotation" is called a PPI data entry. Proteins with more than 50 amino acids and sequence identity less than 40% were randomly selected from the human subset in the STRING database to generate two more challenging datasets, SHS27k and SHS148k. The SHS27k dataset contains 16,912 PPI entries, covering 1,663 proteins and 7,401 interactions. The SHS148k dataset contains 99,782 PPI entries, covering 5,082 proteins and 43,397 interactions. In addition, three partitioning algorithms, including Random, Breadth-First Search (BFS), and Depth-First Search (DFS), were used to partition each dataset into a training set and a test set in a ratio of 8:2. In order to better evaluate the generalization ability, the test data was further divided into three subsets based on whether the two proteins have been seen in the training data: (1) BS: both have been seen; (2) ES: one of the proteins has been seen; (3) NS: neither has been seen. In practice, BFS and DFS partitioning are more challenging because their test data only contain ES and NS subsets, and the test set obtained by BFS is very difficult for the model to predict interactions because it contains a larger proportion of unknown proteins. It is assumed that the dataset partitioning using BFS is more in line with practical applications and may reflect the performance of the model in actual scenarios to a certain extent.

[0150] Evaluation metrics and hyperparameters:

[0151] All experiments were performed using Python v3.8.3 and PyTorch v1.8.1. The experimental results are the average of three repeated experiments and are calculated on an NVIDIA RTX 3090 GPU with 24GB memory. In the model, the protein node feature dimension obtained by Node2vec is 256, and the hidden dimension of the classifier is set to 512. The number of layers of the GMB encoder is set to 5. The model is trained for 600 epochs with a batch size of 2056 on the SHS27k dataset and 600 epochs with a batch size of 2056 on the SHS148k dataset, using the Adam optimizer, a learning rate (lr) of 0.01, and a weight decay of 5e-4. The decay patience value of the learning rate is set to 30 and the decay rate is set to 0.5. The evaluation indicator for multi-label PPI prediction is Micro-F1. Micro-F1 is widely used in multi-label classification. Due to the extreme imbalance of different PPI types in the dataset used, micro-average F1 (micro-F1) may be more suitable than macro-average F1 (macro-F1) to evaluate the performance of multi-label PPI type prediction. Micro-F1 is obtained by calculating the harmonic mean of the total precision and recall of all types.

[0152]

[0153] Baseline: Currently, the methods that can effectively predict PPI include sequence-based: DL-PPI, DNN-PPI, GNN-PPI, and structure-based: DSSGN-PPI, HIGH-PPI. Furthermore, some scholars have used unlabeled data for pre-training, including AFTGAN, to more accurately predict PPI. Comparisons with these methods have been made, and the performance has comprehensively surpassed the non-pre-trained methods, exceeding or at least being equivalent to the pre-trained methods. It is worth mentioning that the pre-trained model will consume a lot of computing resources and time. The model in this application only uses the most basic PPI network to achieve the effect of pre-training.

[0154] Three important observations can be made from Table 1: (1) For models trained only on downstream labeled data, the two structure-based models, HIGH-PPI and DSSGNN-PPI, both outperform other sequence-based baselines, but both methods still lag behind the methods. (2) AFTGAN is a sequence-based model, and its performance is lower than that of the structure-based model. However, because AFTGAN adds ESM-1b embeddings containing a lot of biological information as protein sequence features, the performance of AFTGAN is better than other sequence-based models, but still lower than the model that only uses the PPI network, which further illustrates the high efficiency of the model in predicting new PPI relationships. (3) For the structure-based model: HIGH-PPI, since protein interactions are closely related to protein structure, its performance will be significantly improved compared with the method that only uses sequence information. However, the introduction of structural information will inevitably bring a large burden of computational resources. The method of this application can exceed the performance of the method that only uses structural information by using only sequence information.

[0155] Table 1

[0156]

[0157]

[0158] Generalization analysis: Each PPI consists of two proteins. Unknown PPIs can be further divided into more detailed categories based on the visibility of the proteins to the method. Proteins that appear in training are known proteins to the method, so in testing, both proteins in the interaction are known protein representations (BS), any but not both proteins in the interaction are known protein representations (ES), and none of the proteins in the interaction are known protein representations (NS). Among them, ES and NS are unknown protein interactions. Figure 2 As shown, in the PPI prediction on the "ES" and "NS" datasets, GNN-PPI and 82 have a large performance degradation, because new proteins that the model has never seen during training appear in these two sets. Despite this, the method of the present application has a significant improvement over GNN-PPI. Especially in the "NS" category, the method of the present application has a high improvement (7% on average), in which the performance of competing methods drops rapidly. This is because the "NS" PPI does not contain any known proteins, which requires the model to have a higher generalization ability. However, due to the corpus information of PPI learned by the model during training and the learning of multi-scale shallow interactions and deep interactions, the method has obvious advantages in dealing with this unknown protein interaction prediction task.

[0159] In order to better evaluate the generalization ability of the method, the method of training with one dataset and then testing the performance of the model on another larger dataset is evaluated, that is, heterogeneous training set-test set. For example, a model trained on the SHS27k dataset will encounter proteins with fewer amino acids on the STRING dataset. More importantly, unlike the BFS and DFS partitions on the SHS27k dataset, when migrating to STRING, more than 80% of the PPIs in the test data are in the NS subset. Figure 3 and Figure 4 The performance of 82 and GNNPPI under two domain migration settings is reported in . It can be seen that 82 outperforms GNNPPI in all settings, especially when migrating from SHS148k to STRING.

[0160] Ablation experiment:

[0161] The proposed method mainly consists of three parts: unsupervised generation of PPI initial representation part (referred to as Node), supervised local feature extraction part (referred to as GIN), and supervised global feature extraction part (referred to as GM). The protein initial representation obtained by unsupervised learning of the proposed protein initial feature representation module also comes from the PPI network, which is also a kind of protein relationship modal information at a certain scale. Therefore, an MLP classifier is used to directly use the protein initial representation to predict protein interactions. The Node in the table represents this situation. In order to prove the effectiveness of each part, different combinations of these components are tested. As shown in Table 2, the best performance is obtained by the complete 82; when the GM module for extracting global modal information is eliminated, the performance is lower than that of the complete 82, which shows that global features contribute to improving protein interaction prediction. When the local feature module GIN is eliminated, the performance of the model has a more obvious decline. This is because for the PPI network, the nearest neighbors contain most of the effective information. When the local features are missing, the model performance is greatly reduced. When only the protein relationship modal information obtained at the scale of unsupervised learning of the protein initial representation module is used, and a simple MLP is used as a classifier, the model performance drops sharply.

[0162] Table 2

[0163]

[0164] The above-mentioned embodiments only express the specific implementation methods of the present application, and the descriptions thereof are relatively specific and detailed, but they cannot be understood as limiting the protection scope of the present application. It should be pointed out that, for ordinary technicians in this field, several variations and improvements can be made without departing from the technical solution concept of the present application, and these all belong to the protection scope of the present application.

Claims

1. A lightweight PPI prediction method based on Node2vec, characterized in that: The following steps are involved: Protein initial representation module: Use Node2vec to unsupervisedly learn protein initial representation from the protein interaction network G = (V, E); Multi-scale relational structure representation module: Two GNNs of different scales are set to capture shallow and deep structural information in protein interaction networks, including SGCN variants for shallow structural information and Mamba modules for deep structural information; The protein feature representations learned by SGCN and Mamba are weighted and summed to obtain the final protein representation; In the prediction module, the deep protein representation and the shallow protein representation are element-wise multiplied to enhance the semantic information of the features while preserving detailed information, and then prediction is made.

2. According to claim 1, a method for lightweight prediction of PPI based on Node2vec is characterized in that: The multi-scale relationship structure representation module specifically includes the following steps: After obtaining the initial protein representation, a PPI network with the initial protein representation as node information is constructed, and GNN is used to learn the multi-scale relationship modal features between proteins; Different types of GNNs are set up to simultaneously capture the shallow and deep relational modal features of the PPI network, and then the final protein feature representation is characterized by fusing the shallow and deep relational modal features.

3. A method for lightweight prediction of PPI based on Node2vec according to claim 1 or 2, characterized in that: The multi-scale relational structure representation module adopts a graph isomorphism network to learn the shallow feature representation of proteins. The graph isomorphism network includes the following steps: Each GIN layer uses a sum aggregation function to integrate the features of neighbor nodes and uses a multi-layer perceptron to update the aggregated features; For each protein node p, the update rule of its feature representation is: Among them, N k(p) represents the set of k-hop neighbors of node p, σ (l) and ∈ (l) They are hierarchical activation functions and learnable self-loop parameters, respectively. Through recursive aggregation and update mechanisms, GIN can learn and extract high-level compact representations of proteins from the pre-trained features of Node2vec.

4. The method for lightweight prediction of PPI based on Node2vec according to claim 1 or 2, characterized in that: The multi-scale relational structure representation module uses Graph-Mamba to integrate GAT and Mamba mechanisms to extract deep relational modal features in the PPI network, specifically including the following steps: GAT uses the attention mechanism to learn the importance of each neighboring node to the current node. i,j , connect the edge features with the features of the neighboring nodes and the current node: Where T represents transpose, || represents connection, α is a learnable parameter for learning the attention coefficient in a single-layer feedforward neural network, W is a linear transformation shared among all node and edge features, X is the node feature, E is the edge feature, is a neighboring node of the current node i, k represents all neighboring nodes j of the current node i, once the α of all neighboring nodes is obtained i,j , the features of the current node are updated by the weighted sum of the features of its neighboring nodes; Set up a Graph-Mamba framework to learn long-distance features through Mamba. The Graph-Mamba framework includes at least five stacked GMB layers.

5. The method for lightweight prediction of PPI based on Node2vec according to claim 4, characterized in that: The structure of the Mamba includes: MAMBA is mainly based on the structured state space model, which is a sequence model in which the linear ordinary differential equation passes through a potential state h(t)∈R N The feature x(t)∈R containing the node importance learned by GAT N Mapped to the output sequence y(t)∈R N ; The core idea of ​​SSM is to use state space representation to describe the dynamic behavior and input-output relationship of the system: h′(t)=Ah(t)+Bx(t), y(t)=Ch(t), Among them, A∈R N ×N and B,C∈R N Represent the state matrix, input matrix and output matrix respectively; Discretize the above calculation formula into: the t =Ch t , in, and is the discretized state parameter, Δ is the discretization step size; Consider N = 1, A = -1, B = 1, and Δ t =softplus(Linear(x t ), for the selective SSM, the discretized recursive output is defined as: g t =σ(Linear(x t )), h t =(1-g t )h t-1 +g t x t g t The range is between 0 and 1, allowing the model to completely filter out irrelevant context when necessary. The current input x t Can pass g t Controlling the current input and previous context when updating the hidden state t-1 The balance between the two is to obtain data-dependent and The projection matrices B and C are parameterized as linear projections of the input x to further control x t Update the degree of hidden state and h t For output y t The impact of Proof: Substitute the expression of Δt into the zero-order hold discretization formula: and This is done by parameterizing B, C, and Δ with respect to the input x, where B enables the model to control the input x. t For the hidden state h t The influence of C enables the model to control h t For output y t The influence of Δ control on x t The degree of attention or neglect, a larger Δ means paying more attention to x than the previous hidden state t ; Each node in the graph is a token. Mamba’s selection mechanism enables the model to minimize the influence of unimportant nodes in each hidden state calculation step. Laplace position encoding serves as Mamba’s position information. The formula for position encoding is as follows: L = DA, Among them, A is the adjacency matrix of the PPI network, D is the degree matrix of the PPI network nodes, and the position code P is generated by calculating the eigenvalues ​​and eigenvectors of the graph Laplacian matrix L, and the position code P is added to the input features of Mamba: in, is the feature after position encoding of node i, h i is the initial feature of node i, p i is the position code of node i; The updated node embeddings are combined through the MLP layer to generate the output node embeddings, using the output of the previous layer as the input of the next layer, which is iterated through 5 GMB layers to obtain the final output node embeddings. The update process of the node embeddings in the MLP is as follows: h (i+1) =ReLU(BatchNorm(In (2) ReLU(W (1) h (i) +b (1) )+b (2) )), h(i) is the input node embedding of the i-th layer, W (1) and W (1) is the weight matrix of the linear layer, b (1) and b (2) It is the bias term of the linear layer, and generates the output node embedding after two layers of linear transformation, two ReLU activations and one batch normalization in one update.

6. The method for lightweight prediction of PPI based on Node2vec according to claim 1, characterized in that: The protein initial representation module specifically includes the following steps: For a given protein interaction network G = (V, E), a random walk is performed on each node to generate a sequence. In Node2vec, the random walk is controlled by adjusting two parameters p and q, which respectively represent the degree of breadth-first search and depth-first search in the random walk process; From Node v i Start a random walk and move to node v next j The probability is expressed as: Where E represents the edge set in the graph; After generating the node sequence, the node sequence is used to train the Word2Vec model to learn the low-dimensional representation of the node.

7. The method for lightweight prediction of PPI based on Node2vec according to claim 6, characterized in that: The calculation formula of the Word2Vec model is: For a node sequence (v1,v2,…,v T ), maximize each node v i The neighboring node v i+j The conditional probability is: Among them, p(v i+j |v i ; θ) represents the i In the case of i+j , θ represents the model parameters, and k represents the size of the context window.

8. The method for lightweight prediction of PPI based on Node2vec according to claim 1, characterized in that: The prediction module will simultaneously receive the shallow relational modal features H output from the multi-scale relational modal feature learning module s , and the deep relation modal feature H d , and then assign weights for summing and fusion to obtain the final protein feature representation H, which is calculated as follows: H=w1H s +w2H d , The protein interaction representation Z is obtained by performing the Hadamard product on the relevant protein feature representations, and the calculation formula is: z k =h i *h j ,if A ij =1, Z=[z1...z n ], The protein interaction representation Z is input into the MLP as a classifier to predict the protein interaction type.

Images