An RNA sequence design method based on isometric geometry and graph neural network

Abstract

This invention relates to an RNA sequence design method based on isovariant geometry and graph neural networks, comprising: first, RNA three-dimensional structure data and corresponding sequences; then, after dataset encapsulation and feature extraction, vector embeddings that can be processed by graph neural networks are generated; next, the data is fed into the Equiformer+GVP model for modeling, and the model outputs the probability distribution of four bases at each nucleotide position; finally, the bases are selected according to the probability distribution to form the predicted RNA sequence. Among these methods, E(3) isovariant constraints are introduced to achieve geometric consistency expression, and multi-scale geometric feature encoding is combined to enhance the model's understanding of local and global structures, significantly improving the model's physical rationality, prediction accuracy and universality; and the three-dimensional geometric skeleton of the RNA molecule is used as the only input, eliminating the dependence on secondary structures or external contact diagrams, and learning and generation are performed directly at the three-dimensional spatial coordinate level, thereby achieving significant improvements in physical consistency, geometric completeness and generalization ability.

Description

Technical Field

[0001] This invention relates to the fields of biology and molecular information processing technology, specifically to an RNA sequence design method based on isovariant geometry and graph neural networks. Background Technology

[0002] With the application of AI in various industries, the study of molecular structure-function relationships in computational biology and molecular information processing has become an important direction in life sciences. Traditional experimental design relies mainly on repeatability to verify RNA sequences that meet specific structural or functional requirements. To efficiently explore the correspondence between RNA sequences and three-dimensional structures in a computer environment, one mainstream technique is to automatically generate or evaluate candidate sequences based on neural networks. In the RNA computational design process, relying on biological structure databases and molecular modeling platforms, the mainstream approach to analyze and predict sequences based on experimental RNA structure data is generally based on two approaches: One approach is based on physicochemical energy models, which compare multiple sequence alignment (MSA) with evolutionary information, use covariance analysis or Markov random fields to infer the interaction patterns between sequences, use energy minimization algorithms to infer the most likely folding structure, and use dynamic programming or heuristic algorithms to find sequences in the candidate sequence space that can fold into the target structure. The second approach is based on deep learning methods, which train on large-scale RNA structure data, inputting RNA structural or sequence features, such as distance matrices, secondary structure diagrams, or atomic coordinate information, and using convolutional, recurrent, or graph neural networks to capture the dependencies between residues and output the base probability distribution at each position. It automatically learns the mapping relationship between sequences and spatial configurations while ensuring spatial geometric consistency.

[0003] Methods based on physicochemical energy models rely excessively on artificially constructed energy functions and parameter systems. Due to the complexity of interactions within RNA molecules, energy functions often fail to accurately characterize long-range interactions and nonlocal geometric constraints between bases, leading to discrepancies between calculated results and the actual structure. Meanwhile, these algorithms employ dynamic programming or heuristic solutions in the search space, resulting in high computational complexity. As sequence length and structural complexity increase, they are prone to problems such as computational explosion and low convergence efficiency. Although deep learning-based statistical modeling methods overcome some limitations of physical modeling, they still suffer from insufficient geometric consistency. For example, RhoDesign (Nature Computational Science. 2024 Nov;4(11):829-39) is an RNA design model based on structural condition generation networks. Given the three-dimensional backbone and secondary structure information of RNA, it can map the geometric and topological features of residues into a unified high-dimensional representation through GVP. Subsequently, Transformer encoding and decoding are used to gradually generate the base type probability of each residue according to the structural context, thereby obtaining a complete RNA sequence that conforms to the spatial conformation. However, it relies on externally provided secondary structure contact maps, and its prediction performance depends to a large extent on the quality of the input structure. Its generalization ability is limited under conditions without secondary structure constraints. gRNAde (RNA Design: Methods and Protocols. New York, NY: Springer US, 2024). (121-135) The RNA molecule is abstracted as a graph structure consisting of residue nodes and paired edges. The model extracts the local geometric features of each node in the input stage, and then performs message passing and feature aggregation through a multi-state graph neural network. After multiple iterations, the most likely base type is predicted at the output, but three-dimensional spatial information is ignored, making it difficult to guarantee the geometric consistency of the prediction results under rotation and translation. The RiboDiffusion model (Bioinformatics. 2024 Jul;40(Supplement_1):i347-56) belongs to the RNA design framework based on diffusion generation mechanism. Its main function is to gradually restore the RNA sequence that conforms to the target structure from the random initial sequence through continuous noise perturbation and reverse generation process. However, due to the limited number of publicly available RNA structure samples, the noise modeling and reverse generation steps in the diffusion process require a large number of samples to support them. The model is prone to overfitting or decreased generalization ability on unknown structures. In summary, the structural information representation in the existing neural networks mostly adopts scalar feature representation, which does not fully handle geometric attributes such as direction, angle and orientation. This makes it difficult for the model to accurately capture the spatial relationship between RNA residues, resulting in the prediction results being sensitive to coordinate changes and insufficient generalization performance. Summary of the Invention

[0004] The purpose of this invention is to overcome the problems of incomplete spatial modeling, insufficient geometric invariance, and limited ability to fuse structural information in existing technologies, and to provide an RNA sequence design method based on isovariant geometry and graph neural networks to achieve high-precision prediction between RNA sequences and three-dimensional structures.

[0005] To solve the above-mentioned technical problems, the present invention adopts the following technical solution: an RNA sequence design method based on isovariant geometry and graph neural networks, comprising the following steps:

[0006] Read the raw RNA dataset, perform preprocessing, and output the tensor quantization results;

[0007] Based on the tensor quantization results, after dataset encapsulation and feature extraction, vector embeddings that can be processed by graph neural networks are generated.

[0008] An Equiformer+GVP model is constructed, and using vector embedding as input, it outputs the probability distribution of the four bases for each residue. Based on the probability distribution, the residue with the highest probability class is selected as the predicted RNA sequence. The feature extraction module of the Equiformer+GVP model includes:

[0009] GVP-GNN layer: used to transform vector embeddings into rich (s,v) node features and edge features;

[0010] The Equiformer layer takes the node / edge features output by the GVP-GNN layer and performs SE(3) equal-variable propagation on the graph structure to extract the structural context.

[0011] Preferably, the original RNA dataset includes:

[0012] Sequence file: Contains the base sequence of the RNA and the corresponding PDB ID;

[0013] Structure file: Stores a three-dimensional coordinate matrix of the six main chain atoms of each residue of RNA.

[0014] Preferably, the pretreatment includes:

[0015] Construct the RNADataset class: inherit from PyTorch Dataset, and return the complete features of a sample in __getitem__, including: sequence string, main chain coordinates of residues, and sample name;

[0016] Use np.nan_to_num to automatically replace NaN values ​​in the coordinate matrix and use a mask to mark illegal residues;

[0017] The featureize function is called to perform tensor quantization on the batch data.

[0018] Preferably, when performing tensor quantization on a batch of data, for each batch: the three-dimensional coordinates of the six main chain atoms of the residue are stacked into a tensor X, and padded to the longest sequence length Lmax in the corresponding batch to form a unified dimension; the sequence bases are converted into index form to generate a tensor S; a mask is generated based on the validity of the coordinates to distinguish between the real residues and the padded parts; the lengths and names of each sequence are recorded.

[0019] Preferably, dataset encapsulation and feature extraction specifically include:

[0020] Construct the k-nearest neighbor graph: Using the coordinates X_backbone=X[:,:,0,:] of the main chain atom P as the representative point, calculate the Euclidean distance matrix of all residue pairs, and use a mask to set the invalid points to large values; select the top_k=30 nearest neighbors for each node to obtain the adjacency index E_idx and the neighbor distance D_neighbors, and generate the adjacency mask mask_attend at the same time;

[0021] After constructing the k-nearest neighbor graph, geometric feature calculations were performed on the three-dimensional coordinates of the RNA backbone atoms; including:

[0022] Node features include bond angle features, dihedral angle features, radius of curvature features, and curvature direction features; and

[0023] Inter-residue distance: 5 pairs of main chain atoms, each pair is encoded into an RBF vector of dimension [B,Lmax,80] using 16 RBF kernels;

[0024] Edge features, including relative direction vectors and orientation quaternions; and

[0025] Inter-residue distance: 6 pairs of main chain atoms, each pair is encoded into an RBF vector of dimension [B,Lmax,K,96] using 16 RBF kernels;

[0026] The node features and edge features are concatenated to obtain the flattened original node features h_V_1 and original edge features h_E_1; and the "se" feature h_V_1_se / h_E_1_se is retained.

[0027] Preferably, the concatenated flat features are arranged in a binary form (s,v), where s represents scalar features and v represents vector features. The node part is reshaped into 4 sets of 3D vectors, and the edge part is reshaped into 6 sets of 3D vectors. These are then fed into the GVP-GNN layer for geometric perception embedding to obtain (h_V_gvp, h_E_gvp). These are then merged and fed into the embedding layer to 128 dimensions to obtain h_V / h_E for downstream encoding / decoding.

[0028] Preferably, the effective node offset of each batch is calculated using a mask, the edge index E_idx of the local batch is converted into the global COO edge index [2,E](dst,src), and an undirected adjacency is constructed (adj_mat=adj|adj^T); at the same time, the tension X is reduced to the effective node using mask.nonzero(), and batch_id is retained to track the source of samples within the batch.

[0029] Preferably, the node “se” feature h_V_1_se, together with coors=X[:,:,0,:] and the mask, is input into the Equiformer layer to obtain the equivariant attention output eq_out;

[0030] Take eq_out[0][0] and eq_out[0][1] as two paths, aggregate them according to the effective nodes, and concatenate them with h_V to form h_V_S. Then project them to 128 dimensions through node_se_embedding→Normalize to obtain a node representation that integrates the global equivariant mode.

[0031] Preferably, in the feature construction stage: first, the edge features and the representations of the two end nodes are spliced ​​together to construct the joint feature h_EV=cat[h_E,h_V_S[E_idx[0]],h_V_S[E_idx[1]]], and then input it into the encoder layer together with (h_V_S, E_idx,batch_id).

[0032] Preferably, the encoder layer output is used as the decoder input, each decoder layer updates h_V, and the node features h_V output by the decoder are grouped according to batch_id and averaged to obtain the overall representation graph_embs of each RNA molecule;

[0033] The final node feature h_V is input into the readout layer to obtain the classification prediction vector logits, which corresponds to the base type distribution of each residue. During training, the vector is aligned with the true label S through cross-entropy loss and the padding sites are ignored by combining a mask. During prediction, the highest probability class of the residue is output as the predicted RNA sequence.

[0034] Beneficial effects: This invention introduces E(3) equal variation constraints to achieve geometric consistency expression, combines multi-scale geometric feature encoding to enhance the model’s understanding of local and global structures, and realizes a unified process from data processing to prediction evaluation with an end-to-end architecture, thereby significantly improving the physical rationality, prediction accuracy and universality of the model; and compared with the prior art, this invention uses the three-dimensional geometric skeleton of RNA molecules as the only input, abandons the dependence on secondary structures or external contact diagrams, and directly learns and generates at the three-dimensional spatial coordinate level, thereby achieving significant improvements in physical consistency, geometric completeness and generalization ability. Attached Figure Description

[0035] Figure 1 This is a flowchart of the RNA sequence design method based on isovariant geometry and graph neural networks of the present invention;

[0036] Figure 2 This is a flowchart of the training / inference process of the Equiformer+GVP model of this invention;

[0037] Figure 3 This is a flowchart of the geometric vector perceptron algorithm. Detailed Implementation

[0038] To make the objectives and advantages of this invention clearer, the invention will be specifically described below with reference to embodiments. It should be understood that the following text is merely used to describe one or more specific embodiments of the invention and does not strictly limit the scope of protection specifically claimed by the invention.

[0039] Example: Reference Figure 1 The method for designing RNA sequences based on isovariant geometry and graph neural networks, as shown, includes the following steps:

[0040] Read the raw RNA dataset, which includes: a sequence file containing the base sequence of the RNA and the corresponding PDB ID; and a structure file (NPY format) storing the three-dimensional coordinate matrix of the six main chain atoms (P, O5', C5', C4', C3', O3') for each residue of the RNA.

[0041] Preprocessing:

[0042] Construct the RNADataset class: inherit from PyTorch Dataset, and return the complete features of a sample in __getitem__, including: sequence string, main chain coordinates of residues (grouped by atom type), and sample name;

[0043] Perform data cleaning: Use np.nan_to_num to automatically replace NaN values ​​in the coordinate matrix and use a mask to mark illegal residues;

[0044] The `featurize` function is called to perform tensor quantization on the batch data. For each batch: the three-dimensional coordinates of the six main chain atoms of the residues are stacked into a tensor X, and padded to the longest sequence length Lmax in the corresponding batch to form a uniform dimension; the sequence (A, U, C, G) bases are converted into index form (0–3) to generate a tensor S; a mask is generated based on the validity of the coordinates to distinguish between real residues and padding parts; the lengths and names of each sequence are recorded.

[0045] Output the final tensor result: The function returns (X,S,mask,lengths,names), where: X is a three-dimensional coordinate tensor of [B,Lmax,6,3]; S is an integer tensor of [B,Lmax], representing the sequence bases; mask is a 0 / 1 mask of [B,Lmax], indicating the effective residues; lengths records the actual length of each RNA; and names stores the sample ID.

[0046] Based on the tensor quantization results, after dataset encapsulation and feature extraction, vector embeddings that can be processed by graph neural networks are generated. An Equiformer+GVP model is constructed, whose feature extraction module includes a GVP-GNN layer and an Equiformer layer. The vector embeddings are taken as input. Specifically, this includes:

[0047] Step 1: Instantiate RNAFeatures, select the summarization input dimension (node_in / edge_in) based on the features, define the linear embedding layer node_embedding / edge_embedding and the normalization layer Normalize, and construct two types of GVP embedders embed_node / embed_edge. At the same time, initialize Equiformer (dim=128, dim_in=131, heads=2, depth=1, num_neighbors=30) for global geometric feature enhancement.

[0048] Step 2: Receive (X,S,mask) (shapes [B,Lmax,6,3], [B, Lmax], [B,Lmax]) during forward pass; if in training mode and augment_eps>0, add a small Gaussian perturbation to coordinate X to enhance robustness;

[0049] Step 3: Construct the k-nearest neighbor graph (kNN): Using the coordinates X_backbone=X[:,:,0,:] of the main chain atom P as the representative point, calculate the Euclidean distance matrix of all residue pairs, and use a mask to set the invalid points to large values; select the top_k=30 nearest neighbors for each node to obtain the adjacency index E_idx and the neighbor distance D_neighbors, and generate the adjacency mask mask_attend at the same time;

[0050] Step 4: After constructing the k-nearest neighbor graph, perform geometric feature calculations on the three-dimensional coordinates of the RNA backbone atoms; including:

[0051] Node characteristics:

[0052] Bond angle characteristics: 20 triplet bond angles [B,Lmax,20] are calculated for each group of main chain atoms;

[0053] set up It consists of four consecutive main chain atoms:

[0054] ;

[0055] Dihedral features: The main chain consists of six dihedral angles α, β, γ, δ, ε, and ζ, which are expanded into vectors of dimension [B, Lmax, 12] by sine and cosine expansion. A unit vector representing the directions of three consecutive main chain bonds, used to calculate dihedral angles; Depend on and The dihedral angle defined by the included angle between them

[0056] :O3′(i−1)–P(i)–O5′(i)–C5′(i);

[0057] :P(i)–O5′(i)–C5′(i)–C4′(i);

[0058] :O5′(i)–C5′(i)–C4′(i)–C3′(i);

[0059] :C5′(i)–C4′(i)–C3′(i)–O3′(i);

[0060] :C4′(i)–C3′(i)–O3′(i)–P(i+1);

[0061] ζ: C3′(i)–O3′(i)–P(i+1)–O5′(i+1);

[0062] ;

[0063] ;

[0064] ;

[0065] Curvature radius characteristic: The radius R of the arc formed by three consecutive main chain atoms in dimension [B,Lmax,3].

[0066] ;

[0067] Curvature direction characteristics: the cosine angle between adjacent curvature vectors and the direction difference.

[0068] Residue distance (RBF encoding): 5 pairs of main chain atoms (such as O5'-P, C5'-P, etc.), each pair is encoded into an RBF vector of dimension [B, Lmax, 80] using 16 RBF kernels.

[0069] Edge features:

[0070] Relative direction vector: the relative coordinates of residues to their neighbors, normalized to a vector of dimension [B, Lmax, K, 9];

[0071] Orientation Quaternion: The local coordinate system rotation matrix is ​​converted into a quaternion of dimension [B,Lmax,K,4].

[0072] Using C3′ as the reference point, a local coordinate system is constructed by combining P, O5′, C5′, C4′, and O3′. The relative orientation between residues is described by the rotation relationship of the local coordinate system, and is represented by quaternions.

[0073] The first basis vector of the local coordinate system is formed by the difference in the directions of adjacent main chains;

[0074] This represents a unit vector along the direction of the third coordinate axis (z-axis).

[0075] The normal vector of the local coordinate system is obtained by the cross product of the directions of adjacent main chains;

[0076] Indicates the first Local orthogonal coordinate system (rotation matrix) of residues;

[0077] Represented by rotation matrix The unit quaternion obtained from the conversion;

[0078] Represents the scalar components of a quaternion; The vector components of a quaternion are used to describe rotation axis and angle information.

[0079]

[0080] ,

[0081] Calculate the relative rotation matrix: ;

[0082] Convert the rotation matrix to a quaternion: ;

[0083] Calculate the trace of the rotation matrix: ;

[0084] Based on the trace, directly construct the principal components of the quaternion: ;

[0085] The remaining three components are given by the antisymmetric part of the rotation matrix:

[0086] ;

[0087] Finally, the quaternions are normalized: ;

[0088] Residue distance (RBF encoding): 6 pairs of main chain atoms, each pair is encoded into an RBF vector of dimension [B,Lmax,K,96] using 16 RBF kernels;

[0089] Step 5: Use cat (concatenate) to obtain the original flat node features h_V_1 and edge features h_E_1 respectively; and retain the "se" features h_V_1_se / h_E_1_se for use by Equiformer;

[0090] Step 6: The concatenated flat features are reshaped into (s,v) binary form, where s represents scalar features and v represents vector features. The node part is reshaped into 4 sets of 3D vectors and the edge part is reshaped into 6 sets of 3D vectors. These are then fed into the GVP-GNN layer for geometric perception embedding to obtain (h_V_gvp, h_E_gvp). These are then merged and fed into the embedding layer to 128 dimensions to obtain h_V / h_E for downstream encoding / decoding.

[0091] Step 7: Calculate the effective node offset for each batch using a mask, convert the local batch edge index E_idx to the global COO edge index [2,E] (dst,src), and construct an undirected adjacency (adj_mat=adj|adj^T); at the same time, use mask.nonzero() to shrink the tensor X to the effective node, and retain batch_id to track the source of samples within the batch;

[0092] Step 8: Input the node “se” feature h_V_1_se, along with coors=X[:,:,0,:] (P main chain atomic coordinates) and the mask into the Equiformer layer to obtain the equivariant attention output eq_out (containing scalar / vector channels); take the two paths eq_out[0][0] and eq_out[0][1] and aggregate them according to the effective nodes; and concatenate them with h_V to form h_V_S, and project them to 128 dimensions through node_se_embedding→Normalize to obtain the node representation that integrates the global equivariant mode;

[0093] Step 9: Return the feature output for use by the encoding / decoding layer and graph operators:

[0094] The shape of the main chain atomic coordinate tensor X is Indicates the number of effective residues. This indicates the number of valid residues within this batch;

[0095] 6 represents the number of main chain atoms (P, O5′, C5′, C4′, C3′, O3′), and 3 represents the three-dimensional coordinates.

[0096] Sequence index tensor S;

[0097] Node feature tensor h_V[N_valid, d], d: unified feature dimension (128);

[0098] The edge feature tensor h_E[N_valid, d], where K is the number of neighbors (30);

[0099] h_V_gvp, h_E_gvp, scalar / vector pairs after GVP embedding;

[0100] h_V_S, the node representation enhanced by Equiformer.

[0101] The Equiformer+GVP model was trained and optimized to output the probability distribution of the four bases for each residue. Based on the probability distribution, the residue with the highest probability class was selected as the predicted RNA sequence. Specifically:

[0102] In the feature construction stage: first, the edge features and the representations of the two end nodes are spliced ​​together to construct the joint feature h_EV=cat[h_E,h_V_S[E_idx[0]],h_V_S[E_idx[1]]], and then it is input into the encoder layer together with (h_V_S,E_idx,batch_id); after multiple layers are stacked, h_V_S fuses the context relationship across residues and the three-dimensional geometric dependence to form a structurally enhanced node representation;

[0103] Construct a joint input based on the original node features h_V: h_EV=cat[h_E,h_V[E_idx[0]],h_V[E_idx[1]]]; each decoder layer updates h_V, and the final output h_V serves as the direct basis for node prediction;

[0104] The node features h_V output by the decoder are grouped according to batch_id and the average value is taken to obtain the overall representation graph_embs of each RNA molecule;

[0105] At the residue level, the model inputs the final node feature h_V into the readout layer to obtain the classification prediction vector logits, which corresponds to the base type distribution (A / U / C / G) of each residue. During training, it aligns with the true label S through cross-entropy loss and ignores padding sites by combining a mask. During prediction, it outputs the residue's highest probability class as the model's prediction sequence.

[0106] For the deep integration of isovariant modeling and geometric vector perceptron (GVP):

[0107] refer to Figure 2 The GVP module maps the spatial structure and sequence information of RNA into graphical data, where nodes represent nucleotide residues and edges represent spatial adjacency. The model maintains scalar features (such as chemical properties) and vector features (such as geometric orientation) for each node, and calculates updated scalar s' and vector V' features through a scalar-vector combined neural network layer.

[0108] Vector part:

[0109] vector First, through linear transformation , and then through Project onto the target dimension; calculate the L2 norm of the vector ( ), as supplementary information for the scalar; then calculate the norm for the other path, and pass through (Non-negative activation, such as ReLU) yields a scaling factor; this scaling factor is multiplied by the vector features to obtain the final vector output. .

[0110] Scalar part:

[0111] The input s is concatenated with the vector norm and then passed through a fully connected layer. Get new scalar output .

[0112] Message Passing Layer: In the graph neural network layer, GVP is embedded into the message passing framework.

[0113] Features of neighboring nodes With edge features Apply GVP to obtain message vectors; aggregate neighbor messages: ;

[0114] Update the central node: ;

[0115] For the Equiformer layer, refer to Figure 3 Equiformer is an SE(3) isovariant graph neural network model component integrated into this platform, used for isovariant feature learning in the three-dimensional geometry of RNA. This module uses nodes (residues) and edges (geometric interactions) as basic units and utilizes the isovariant graph attention mechanism to model the local and global relationships in the spatial structure of RNA.

[0116] The node / edge features encoded by GVP are fed into the TFNConv convolutional layer in Equiformer, where SE(3) isovariant propagation is performed on the graph structure to extract the structural context.

[0117] Input data: Each node The input to the edge is a scalar and vector feature pair:

[0118] ;

[0119] Each edge Contains direction and distance information: ;

[0120] Embedding layer combines geometric direction vectors Perform linear transformation and DTP expansion:

[0121] ;

[0122] Attention layer of isomorphic graph:

[0123] Input mapping and message construction: Performing a linear mapping between the features of node i and its neighbors.

[0124] ;

[0125] in Indicates the node Vector features by direction Expand.

[0126] Gating and Nonlinear Activation: Applying Gating and Activation Function Adjustment to Intermediate Features

[0127] ;

[0128] Calculate attention weights: Calculate attention scores based on geometric distance and node features.

[0129] ;

[0130] Aggregate neighbor information by weighted summation:

[0131] ;

[0132] Update node characteristics: ;

[0133] (2) Comprehensive coding design of multi-scale geometric features:

[0134] In the feature extraction stage, local conformational features (such as bond angles, dihedral angles, curvature, etc.) and mid-to-long-range spatial adjacency features (including orientation, orientation and radial basis function (RBF) distance, etc.) are encoded simultaneously to achieve a unified representation of geometric information at different scales and improve the model's ability to model the spatial conformation and long-range interactions of RNA molecules.

[0135] In a specific case: RNA single-stranded structure samples with a resolution better than 3.5 Å were used as the training and testing set. The model input consisted of RNA sequences and the corresponding coordinates of the six principal atoms. The training batch size was set to 2, and the learning rate was 1×10⁻⁻⁶. 4 The optimizer was AdamW, and the training run was 150 epochs. The average sequence recovery rate was 52.20%, and the perplexity was 2.21. It does not rely on additional secondary structure contact maps or diffusion generation modules, and exhibits higher physical consistency and generalization ability.

[0136] With 1A9N:

[0137] CCUGGUAUUGCAGUACCUCCAGGU;

[0138] 2ZH6:

[0139] GGCCCGGGGCGGUUCGAUUCCGCCCUGGGCCACU;

[0140] 9DE7:

[0141] GUCUCUCUGGUUAAGCCAGACGAGCCGAAAAGCUCUCUGGCUAACUAGGGAACCA

[0142] For test cases;

[0143] The prediction result is:

[0144] CCUGGUAUUGCAGUACCUCCAGGU;

[0145] ACCCCGGGGGGGUUCGAUUCCGCCCUGGGGUACC;

[0146] AUAUCUCGGAACGAGUCAGUAGUGGUGAAAACCACAAUGACCGUUUCGGGAAUGG;

[0147] The average sequence recovery rate was 52.20%, and the perplexity was 2.21.

[0148] The embodiments of the present invention have been described in detail above with reference to the examples. However, the present invention is not limited to the above embodiments. For those skilled in the art, after learning the contents described in the present invention, several equivalent changes and substitutions can be made without departing from the principle of the present invention. These equivalent changes and substitutions should also be considered to fall within the protection scope of the present invention.

Claims

1. An RNA sequence design method based on isovariant geometry and graph neural networks, characterized in that: Includes the following steps: Read the raw RNA dataset, perform preprocessing, and output the tensor quantization results; Based on the tensor quantization results, after dataset encapsulation and feature extraction, vector embeddings that can be processed by graph neural networks are generated. Construct an Equiformer+GVP model and, using vector embedding as input, output the probability distribution of the four bases for each residue; The highest probability class of the output residues is selected as the predicted RNA sequence based on the probability distribution; the feature extraction module of the Equiformer+GVP model includes: GVP-GNN layer: used to transform vector embeddings into rich (s,v) node features and edge features; The Equiformer layer takes the node / edge features output by the GVP-GNN layer and performs SE(3) equal-variable propagation on the graph structure to extract the structural context.

2. The RNA sequence design method based on isovariant geometry and graph neural networks according to claim 1, characterized in that: The original RNA dataset includes: Sequence file: Contains the base sequence of the RNA and the corresponding PDB ID; Structure file: Stores a three-dimensional coordinate matrix of the six main chain atoms of each residue of RNA.

3. The RNA sequence design method based on isovariant geometry and graph neural networks according to claim 2, characterized in that: Preprocessing includes: Construct the RNADataset class: inherit from PyTorch Dataset, and return the complete features of a sample in __getitem__, including: sequence string, main chain coordinates of residues, and sample name; Use np.nan_to_num to automatically replace NaN values ​​in the coordinate matrix and use a mask to mark illegal residues; The featureize function is called to perform tensor quantization on the batch data.

4. The RNA sequence design method based on isovariant geometry and graph neural networks according to claim 3, characterized in that: When performing tensor quantization on a batch of data, for each batch: stack the three-dimensional coordinates of the six main chain atoms of the residue into a tensor X, and pad it to the longest sequence length Lmax in the corresponding batch to form a uniform dimension; convert the sequence bases into index form to generate a tensor S; A mask is generated based on the validity of the coordinates to distinguish between real residues and padding; the lengths and names of each sequence are recorded.

5. The RNA sequence design method based on isovariant geometry and graph neural networks according to claim 4, characterized in that: Dataset encapsulation and feature extraction, specifically including: Construct the k-nearest neighbor graph: Using the coordinates X_backbone=X[:,:,0,:] of the main chain atom P as the representative point, calculate the Euclidean distance matrix of all residue pairs, and use a mask to set the invalid points to large values; select the top_k=30 nearest neighbors for each node to obtain the adjacency index E_idx and the neighbor distance D_neighbors, and generate the adjacency mask mask_attend at the same time; After constructing the k-nearest neighbor graph, geometric feature calculations were performed on the three-dimensional coordinates of the RNA backbone atoms; including: Node features include bond angle features, dihedral angle features, radius of curvature features, and curvature direction features; and Inter-residue distance: 5 pairs of main chain atoms, each pair is encoded into an RBF vector of dimension [B,Lmax,80] using 16 RBF kernels; Edge features, including relative direction vectors and orientation quaternions; and Inter-residue distance: 6 pairs of main chain atoms, each pair is encoded into an RBF vector of dimension [B,Lmax,K,96] using 16 RBF kernels; The node features and edge features are concatenated to obtain the flattened original node features h_V_1 and original edge features h_E_1; and the "se" feature h_V_1_se / h_E_1_se is retained.

6. The RNA sequence design method based on isovariant geometry and graph neural networks according to claim 5, characterized in that: The concatenated flat features are processed in a binary form (s,v), where s represents scalar features and v represents vector features. The node part is reshaped into 4 sets of 3D vectors, and the edge part is reshaped into 6 sets of 3D vectors. These are then fed into the GVP-GNN layer for geometric perception embedding to obtain (h_V_gvp, h_E_gvp). These are then merged and fed into the embedding layer to 128 dimensions, resulting in h_V / h_E for downstream encoding / decoding.

7. The RNA sequence design method based on isovariant geometry and graph neural networks according to claim 6, characterized in that: The effective node offset of each batch is calculated using a mask. The edge index E_idx of the local batch is converted into the global COO edge index [2,E] (dst,src), and an undirected adjacency is constructed (adj_mat=adj|adj^T). At the same time, the tension X is reduced to the effective node using mask.nonzero(), and batch_id is retained to track the source of samples within the batch.

8. The RNA sequence design method based on isovariant geometry and graph neural networks according to claim 7, characterized in that: Input the node "se" feature h_V_1_se, along with coors=X[:,:,0,:] and the mask into the Equiformer layer to obtain the equivariant attention output eq_out; Take eq_out[0][0] and eq_out[0][1] as two paths, aggregate them according to the effective nodes, and concatenate them with h_V to form h_V_S. Then project them to 128 dimensions through node_se_embedding→Normalize to obtain a node representation that integrates the global equivariant mode.

9. The RNA sequence design method based on isovariant geometry and graph neural networks according to claim 8, characterized in that: In the feature construction stage: first, the edge features and the representations of the two end nodes are concatenated to construct the joint feature h_EV=cat[h_E,h_V_S[E_idx[0]],h_V_S[E_idx[1]]], and then input it into the encoder layer together with (h_V_S, E_idx,batch_id).

10. The RNA sequence design method based on isovariant geometry and graph neural networks according to claim 9, characterized in that: Using the encoder layer output as the decoder input, each decoder layer updates h_V, and the node features h_V output by the decoder are grouped according to batch_id and averaged to obtain the overall representation graph_embs of each RNA molecule; The final node feature h_V is input into the readout layer to obtain the classification prediction vector logits, which corresponds to the base type distribution of each residue. During training, the vector is aligned with the true label S through cross-entropy loss and the padding sites are ignored by combining a mask. During prediction, the highest probability class of the residue is output as the predicted RNA sequence.

Images