KR20040102887A - A Method for Visualizing Protein Interaction Networks - Google Patents

Abstract

PURPOSE: A method for visualizing large-scale protein-protein interaction network is provided to visualize the protein-protein interaction network fast and simply by adjusting a position of each node to a center of neighboring nodes of each node after preferentially arranging all connected components in the network and arranging the nodes to the center of a pivot node in the connected component. CONSTITUTION: The connected component in the protein-protein interaction network is identified/arranged. A middle node and the pivot node in each connected component are determined. A distance to each node from the pivot node within each connected component is respectively calculated and each node related to the pivot node is arranged based on the calculated distance. Each connected component is rearranged by arranging a cut-vertex related to the middle node and the middle node related to the neighboring node of the cut-vertex. Each connected component is rearranged by arranging each node to the neighboring node within the distance fixed to each node as the center.

Description

A Method for Visualizing Protein Interaction Networks

The present invention relates to a method of visualizing a protein-protein interaction network, and more particularly, to a protein interaction network that quickly and simply visualizes a large-scale protein interaction network including thousands or more proteins. The visualization method of the.

Conventional biochemistry experiments have produced small amounts of data for individual protein interactions, whereas recent advances in high-speed interaction detection such as yeast two-heterologous and mass spectrometry techniques have led to rapid increases in protein interaction data over recent three years. It's been expanding. This interaction data is useful in text files or databases. However, because of the volume of data, it has been demonstrated that graphically representing protein interactions is easier to understand than representing long lists of interacting proteins.

In the past, protein interactions were visualized in an undirected graph G = (V, E). Where xV represents protein and (x, y) E represents the interaction of proteins x and y. Visualization of the graph is straightforward when dealing with fewer nodes and edges. In practice, however, protein interaction networks include thousands or more nodes. These protein interaction networks are too slow to interactively analyze large amounts of data by creating complex drawings with many edge crossings or static drawings that are difficult to modify, or are directly from protein interaction databases. As a result, input data having a specific form is required rather than obtaining the data, so that the utility of many graph drawing tools is very limited. The fundamental disadvantage of protein interaction networks depends on their readability. Therefore, protein interaction networks should focus on the fast and accurate transfer of interaction information.

Conventional force-directed layout algorithms, called INTERVIEWERs, are the most widely known way of visualizing an undirected graph. The algorithm creates an optimal layout based on the force model. However, a simple implementation of this conventional force-directional layout presents practical difficulties when drawing a graph with more than a few hundred nodes. This difficulty comes from two sources. First, layout adjustment involves the calculation of the force between all node pairs at each stage of the optimization process. Second, for large graphs, the optimization process is very much involved in converting the initial random layout into an optimal layout. Because you have to repeat.

For these reasons, when interactively visualizing a large protein interaction network containing thousands of proteins or more using conventional graph drawing tools, the processing speed is too slow or there are many edge crossings. There is a problem that the graph is drawn, and in particular, an obscure drawing having many edge intersections is abandoned.

The present invention has been proposed to solve the conventional problem that arises in the interactive visualization of large-scale protein interaction networks comprising thousands of proteins as described above, and all linked components of large-scale protein interaction networks. (connected component) is placed first, and nodes are arranged around a pivot node in the connected component, and then each node is positioned around the adjacent node for each node quickly and simply. Its purpose is to provide a method for visualizing protein interaction networks.

1 is an exemplary diagram showing an example of a cut point and a node in a graph according to the present invention.

2 is an exemplary view showing an example of a graph layout including a pivot node according to the present invention.

3 is a graph in which the original graph according to the present invention is replaced with a click.

4 is a network abstracting a sub-network into a composite node in the original network according to the present invention.

5 shows a network with 44387 interactions between 4242 human proteins, according to one embodiment of the invention.

6 illustrates an example of network abstraction in accordance with the present invention.

Explanation of symbols on the main parts of the drawings

11,12,13: Path 21: Pivot Node

c1, c2: cutvertex v5 ~ v11: intermediate node

G1: first intermediate node group G2: second intermediate node group

According to an aspect of the present invention, there is provided a method of visualizing a protein interaction network, the method comprising: identifying and disposing a connected component in a protein-protein interaction network; Determining a intermediate node and a pivot node in each of the connected components; Calculating each distance from the pivot node to each node in the connected components, and placing each node associated with the pivot node based on the calculated distance; Disposing the respective connected components by disposing a cutvertex associated with the intermediate node and an intermediate node associated with an adjacent node of the cutvertex; And a fifth step of disposing each of the connected components by arranging each of the nodes with respect to adjacent nodes within a distance set for each node.

Here, the visualization method of the network according to the present invention may further include the step of reducing the number of nodes and edges by replacing one node group having the same interaction with a single compound node.

The above objects and features will become more apparent from the following detailed description taken in conjunction with the accompanying drawings. However, the accompanying drawings are only illustrative of the preferred embodiments of the present invention, the present invention is not limited thereto. In addition, the network and the graph according to the present invention is the same concept and will be mixed in the following description. Preferred embodiments of the present invention will be described in detail with reference to the accompanying drawings.

1 is an exemplary diagram showing an example of a cut point and a node in a graph according to the present invention. Referring to an example of the graph shown in FIG. 1, in the graph G, c1 and c2 are cutpoints (also called articulation points) (hereinafter, referred to as 'cutvertex' for convenience of terminology). In the present invention, cutvertex refers to a node that is disconnected from the graph when it is removed from the graph to which it belongs. That is, when the node c1 is removed from FIG. 1, the node v1 and the node v2 are disconnected from the graph G. In this case, the node c1 is called cutvertex. Of course c2 is also cutvertex.

The degree of node v represents the number of edges of node v, denoted by deg (v). In graph G, the path is a sequence of distinct nodes (v1, v2, ..., vn) in graph G, where (vi, vi + ı) ∈E when 1 ≤ i ≤ n-1 . Graph G '= (V', E ') which is a subgraph of graph G = (V, E), where V' V and E 'V E' (V 'x V').

As shown in Fig. 1, when multiple paths exist between a pair of cutvertex, the nodes on the paths are called intermediate nodes. In the example diagram of FIG. 1, three paths 11, 12, 13 exist between a pair of cutvertex (c1, c2) in one connected component, and intermediate nodes v5 to v11 are located on each path. Is shown. If the multiple paths 11, 12, 13 between the pair of cutvertex (c1, c2) have different lengths, the intermediate nodes on the path of the same length are grouped together. For example, as shown in FIG. 1, if the lengths of the upper two paths 11 and 12 among the multiple paths between the pair of cutvertex (c1, c2) are the same, the two paths 11 and 12 are the same. Intermediate nodes (v5, v6, v8, v9) present in the group is grouped into a first intermediate node group (G1), and exist on the remaining path 13 is different from the two paths (11, 12) path length. The intermediate nodes v7, v10, and v11 are grouped into a second intermediate node group G2.

The protein interaction network visualization method of the present invention draws a graph using a multilevel technique. The multilevel includes a grouping step and a layout step. In the grouping step, all connected components (maximum subgraphs connected in the graph) of the entire network are identified and grouped, and after finding the intermediate node and pivot node in each connected component, The distance from the pivot node to each node within each connected component is calculated. Here, the pivot node becomes a key node in the layout of the graph. More specifically, the pivot node is a node selected in the form set for the layout of the graph according to the present invention. Since the connected components are arranged in consideration of the distance from the pivot node, the results vary depending on the selection method and the number. Can show. Also, if the number of pivot nodes is selected too much, it takes time to calculate the distance from the pivot node to each node in each connected component. On the contrary, if the number of pivot nodes is selected too few, the pivot nodes may be selected. The result for the layout of connected components to which they belong is bad.

On the other hand, in the arrangement step, by identifying the layout of the connected components of the entire network to identify the layout between each of the connected components, for each of the connected components, the layout of the node associated with the pivot node of the connected component By finding, adjusts the global layout within the connected component. Subsequently, the layout of each connected component is rearranged by rearranging the cutvertex of the intermediate nodes and the intermediate nodes associated with the immediate neighbor node of the cutvertex. This adjusts the local layout of intermediate nodes within the connected component. Subsequently, the local layout of all nodes within each connected component is adjusted by rearranging the layout of each connected component by rearranging all nodes associated with the node within 2 distances from each node.

FIG. 2 is an exemplary view showing a graph layout including a pivot node according to the present invention, and FIG. 2 (a) shows a layout of a graph including a pivot node selected from a mesh according to the present invention. 2 (b) shows the layout of the graph including pivot nodes selected from the protein interaction network according to the present invention. As shown in FIG. 2, to create a high quality layout, the pivot node 21 that is distributed almost uniformly to each connected component is selected. The number of pivot nodes 21 and the distance between them are determined according to the number of nodes and the diameter of the network. At this time, the diameter of the network is the maximum distance between two nodes in the network. In general, a pivot node is selected for a network having a diameter larger than the number of nodes than a network having a diameter smaller than the number of nodes. For small networks with 100 or fewer nodes, select the pivot node so that the distance between the nodes is 3 or less. Networks with diameters of 20 or less also reduce the distance between pivot nodes to the distance that the pivot node can be selected. As described above, in the visualization method of the protein interaction network of the present invention, a specific method of identifying and arranging connected components, selecting a pivot node, and calculating the distance between each node and arranging each node is described in detail below. Explain.

The protein interaction network visualization process of the present invention will be described with reference to an algorithm according to one embodiment. Here, the algorithm according to the visualization process of the protein interaction network of the present invention described below is only one embodiment of the present invention, it should be noted that the present invention is not limited to this and can be modified in various forms. . In particular, the algorithm described below may be embodied in other programs, preferably readable and executable on a computer.

In addition, the algorithms described below to implement the visualization method of the protein interaction network according to the present invention will be easily understood by those skilled in the art, and further, the algorithms described below It can be easily implemented in a device such as a computer.

Hereinafter, a visualization process of the protein interaction network according to the present invention will be described with reference to an algorithm according to an embodiment of the present invention.

First, Algorithm 1 according to an embodiment of the present invention shows a process of grouping and arranging nodes of a disconnected graph into connected components in an entire network.

Algorithm 1 shows a process of finding a connected component that is each connected subgraph in a graph. For a node v to which at least one edge is connected among V, which is a set of all nodes of the entire graph, if the node v does not belong to another connected component, a new grouping identifier is assigned to the node v. Next, the nodes connected to the node v are found while searching for neighbor nodes connected to the node v one by one. In this case, in the process of finding all connected nodes with respect to the node v, for all neighbor nodes u of the I-th node GLst [i] among the set GLsts that collect the nodes belonging to the connected components, the neighbor node u is After checking whether it belongs to another connected component, if the neighbor node u does not belong to another connected component, the u is added to the GLst, and the process is repeated for another neighbor node.

Algorithm 2 according to an embodiment of the present invention is an algorithm for calculating a distance between two nodes v and w, and shows a process of calculating the distance between two nodes when two nodes belong to one connected component. Here, the distance is calculated by setting the distance from one node to an adjacent node as 1. That is, the distance from node a to adjacent node b is 1, and the distance from node a to node c adjacent to node b is 2.

Referring to Algorithm 2, the distance between the start node v and each node is calculated by first inputting 0, which is the distance between the start node v and itself, to DLst and executing the repeat ~ until part from the first node of the DLst. do. More specifically, the distance currentDist from the current node v 'and the starting node v to the current node v' in the DLst is obtained, and for all adjacent nodes u through the v ', the DLst is not included in the DLst. Add 1 to currentDist at distance v 'of u. If u is w for the last calculation, currentDist + 1 is returned as a result value. DLst.First tells you to go to the first node in DLst, and DLst.Add adds a node and its distance to the list of DLsts. DLst.Next moves to the next level of the list, and DLst.Eof becomes true if there are no more nodes, and false if there are any.

Since Algorithm 1 and Algorithm 2 are executed on a node having at least one edge, an edgeless node is arranged to have two or more connected components of size two or more in the process of identifying and placing the connected components of the entire network. Then placed. Also, In the case of a graph having three nodes, the time complexity of Algorithm 1 is O (n), and the time complexity of Algorithm 2 is O (n · PvN |). Where | PvN | is the number of pivot nodes.

Algorithm 3 identifies the pivot node after identifying and placing all connected components of the entire network. This is an algorithm that determines the internal pivot node for each connected component.

The algorithm 3 is executed after the layout of all connected components in the entire network is determined. First, we start by calculating the first node V [0] of each connected component as the first pivot node. In Algorithm 3, DLst is a variable for calculating the distance between each pivot node from other nodes, and PvN has a distance table for storing each pivot node and the distance from the pivot node to other nodes. . MaxDist is also a variable for storing the maximum distance of the currently connected component. After initializing DLst in DLst.Clear, initialize the current pivot node and its distance to 0, and call ChkDistance to calculate the distance from each pivot node.

As described above, the algorithm called in Algorithm 3 for determining the pivot node is Algorithm 4 below. Algorithm 4 takes parameters such as DLst, DistTable, and MaxDist to perform calculations. It adds the distances from the current node's neighbor node to DLst and DistTable, and is likely to become a pivot node among the current nodes v. This algorithm shows how to select and call as ChkPvN to add as a pivot node.

In Algorithm 4, DLst.GetCurrent (v, dist) is a command for obtaining the current node v and its distance dist. If the current distance is larger than the maximum distance MaxDist, the MaxDist is replaced with the current distance. And bAddPvN checks whether the current node is likely to be a pivot node. First, there are two parts to check at this stage. The two cases are the case where there is no node that can be added to the DLst among the neighbor nodes of the current node v, and the node at the point 1 / n of MaxDist (one third in the algorithm 4, for example). Therefore, the above two cases are first examined.

In the sixth step of Algorithm 4, it is checked whether the node w neighboring the current node v is already in the DLst. If not, bAddPvN is set to false and the current distance is set to dist + 1 in the DLst. In addition, in the case of DistTable (w), since the distance is input to the DistTable in the order of the current connected components, not the node order in the DLst, dist + corresponding to the distance from the pivot node to w in DistTable (w). You will enter 1.

When both bAddPvN and ChkPvN (v) are true, the current v is added to the pivot node, and a new DistTable 'that the v is to be used is newly defined, and 0 corresponding to the distance between the current node v and itself is entered. The ChkPvN (v) function becomes true for nodes satisfying the result through the following process.

1) If the number of nodes in the connected component is less than 40, the distance from all existing pivot nodes to v nodes shall be at least 2.

2) If the number of nodes in the connected component is more than 40 and less than 100 nodes, the distance from all existing pivot nodes to v nodes shall be at least 3.

3) If the number of nodes in the connected component is 100 or more,

(a) if the diameter (d) of the connected components is less than 7, the number of edges (degree (v)) of the v-nodes should be 3 or more,

(b) If 7 ≤ d <15, degree (v) must be 4 or more,

(c) If 15 ≤ d <20, degree (v) should be 5 or more,

(d) Otherwise, when the ratio of the diameter of the connected component to the number of nodes of the connected component is R,

i) If R <0.01, the distance from all existing pivot nodes to v nodes must be at least 40.

ii) If 0.01 < R &lt; 0.02, the distance from all existing pivot nodes to v nodes must be at least 17, and if the total number of nodes> 1000, adjust the distance to 30.

iii) If 0.02 ≤ R <0.035, the distance from all existing pivot nodes to v nodes should be at least 13, and if the number of total nodes> 1000 then adjust the distance to 20.

iv) If 0.035 ≤ R <0.07, the distance from all existing pivot nodes to v nodes should be at least 10.

v) If R ≧ 0.07, the distance from all existing pivot nodes to v nodes must be at least 5.

The above processes 1 to 3 are only one embodiment of the present invention, and the numerical values applied in the above process may be changed according to conditions such as the size of the entire network, the number of nodes, and the like. One embodiment for determining the appropriate number is shown.

When selecting a pivot node in Algorithms 3 and 4, the distances of the pivot node from all other nodes are all calculated. Algorithm 4 checks whether the current node is a pivot node, determines the possibility of including the node in a pivot node set PvN that depends on the distance from an existing pivot node if it is not a pivot node, and Diameter, number of nodes and number of edges) of the connected components. Algorithms 3 and 4 take O (n) time for a single pivot node, so the overall time complexity for selecting all pivot nodes is O (lPvNl · n).

Algorithm 5 shows the process of determining the position of the other nodes V 'with respect to the current node v. This determines the distance (u, v), which is the distance between the set V 'of other nodes and the other node u according to each deployment step. The position of the current node v is always determined relative to the reference node set V ', where V' is a subset of V.

In Algorithm 5, Δ (delta) represents a relative coordinate minus v coordinates, and D is set to 0 to change its initial value after calculation for each u. Δ (1-Distance (u, v) / ) Moves in the negative direction if the current u, v distance is larger than Distance (u, v), which is the distance on the graph, and in the positive direction (+). In other words, the above equation is expressed in the form of Δ- (Distance (u, v) × Δ), so that each component of each direction component x, y, z corresponds to the actual distance on the graph. The value obtained by subtracting (Distance × unit vector) is added to D.

Since it is moved about V 'which is a set of all other nodes, D is divided by the number of nodes belonging to V', and the average value is obtained. The new v is obtained by moving it from the current v position by that position.

Using the algorithm 5, the actual entire network is arranged through the following process. First, the layout of the entire network is divided into a global layout for placing connected components and a local layout for placing each connected component therein, and the local layout is again a pivot node arrangement, an intermediate node arrangement and an adjacent node arrangement. Divided.

V 'is a set of pivot nodes of other connected components that do not belong to v for global placement, V' is a set of pivot nodes of connected components to which v belongs to, and for intermediate node placement, V ' Is a cutvertex and a set of nodes directly adjacent to the cutvertex. Also, in adjacent node arrangements V 'is a set of adjacent nodes at a distance of less than 2 with v.

More specifically, in the case of the global arrangement, v becomes the pivot nodes of the connected component currently being calculated and V 'becomes the pivot nodes calculated in the previous step. Distance (u, v) is calculated using the maximum distance of all connected components.

In the local placement of the pivot node, v is all nodes of the currently connected component, and V 'is a pivot node of the connected component. In this case, Distance (u, v) uses the DistTable calculated by Algorithm 3 to determine the pivot node.

In the intermediate node arrangement, v becomes a node belonging to the middle node among adjacent nodes of both cutvertex, and V 'has cutvertex with nodes neighboring cutvertex. In this case, Distance (u, v) is calculated as follows. First, in the connected component of FIG. 1, when the node v to which v5 is to be disposed is referred to as a node v, the distance from the other nodes in the v5 node is first the distance from the neighbor node c1 of the v5 node is 1, and the neighbor nodes v1 of the c1 are first. The distance of v2, v6, v7) is 2. Also, the distance to c2, the opposite cutvertex, is minus one from the distance between c1 and c2, and the distance to v8 is minus two from the distance between c1 and c2. Further, the distances to v3, v4, v9 and v10 become the distances of c1 and c2.

In addition, as shown in the example of FIG. 1, when there are cutvertex (c1, c2) on both sides and when there is cutvertex on only one side and the terminal node on the other side, both of them handle intermediate nodes v5 to v11, If only one side of the cutvertex (c1) is present, the intermediate node arrangement is executed only with the cutvertex (c1) and the nodes (v5, v6, v7) connected thereto. Furthermore, even when arranging intermediate nodes, not all nodes are arranged but only nodes connected to cutvertex, and nodes v11 in the middle of intermediate nodes are not arranged accordingly.

Finally, in the neighbor node arrangement, the node to be calculated is set to v, and the set of nodes having a distance of 2 from the node v is called V '. In this case, Distance (u, v) is the distance from the v node to each node. Among the global and local layouts described above, the process of pivot node placement and intermediate node placement is repeated. This repetition is repeated until the ratio of each edge distance to the actual distance falls below a certain level. Finally, the neighboring node layout completes the entire placement process.

It takes O (lV'l) time to execute the algorithm 5 once. Therefore, the overall time complexity from the global deployment stage to the local deployment stage is O (n · lPvNl). Where lPvNl is the number of pivot nodes.

Complex protein interaction networks with many edges and nodes often reduce the readability of the network because of the cluttered edges and nodes. In general, there are two ways to analyze such a complex network. One method is to extract the sub-networks from the entire network and analyze the sub-networks one by one, and the other is to abstract the entire network into smaller networks. The present invention can extract a subnetwork in several ways. For example, the present invention may extract sub-networks of proteins within a specific interaction distance from one or more target proteins or sub-networks of proteins shared by several protein interaction networks. Abstraction networks can be extended to specific networks on demand. In the case of an abstraction of a network, the present invention provides two functions. First, it provides the ability to abstract cliques into star subgraphs. In other words, the click (complete subgraph with each pair of nodes connected by edges) is replaced with a star-shaped subgraph located in the center of the dummy node. This appears like a circle in the abstraction graph. Second, it provides the ability to abstract one node group with the same interaction into a composite node. That is, one node group with the same interaction partner is abstracted into a single compound node. This appears like a diamond in the abstraction graph.

A clique with n nodes includes n (n-1) / 2 edges, and the star-shaped graph for the click contains exactly n edges. Thus, clicks with star-shaped graphs substantially reduce the number of edges. Finding the maximum size click in the graph is a NP-hard problem. Algorithms 6 and 7 present an efficient method of identifying edge-disjoint clicks in accordance with the invention. Since the abstraction of a click of size 3 does not reduce the number of edges, the abstraction is performed in the case of a click of size 4 or more (see Algorithm 6).

Algorithm 6 is an algorithm for finding a clique, which is a complete subgraph in the graph, and can be used as a method of reducing the number of edges by displaying the cleak through one dummy node. For every node v belonging to the connected component V, the neighbor node u of that v is calculated. After initializing Lst, if u and v have not already clicked, set the initial value of Lst as (index of u in v, v + 1), (index of v in u, u + 1). It is put in. Subsequently, it checks whether the node corresponding to Lst [0], Idx has already formed a click among v and v adjacent nodes and passes it to ChkClique. After Lst [0] .Idx is increased to 1, it is repeated until Lst [0] .Idx is equal to or larger than the number of edges of the node corresponding to Lst [0] .node. Through this process, if the number of nodes remaining in Lst is 4 or more, clicks are composed of nodes in Lst. Figure 3 shows the result of replacing the graph according to the invention with a click.

Algorithm 7 is a function called in Algorithm 6, which checks the nodes in Lst and adds them by determining if other nodes can be added to Lst. Here, N represents the current location in Lst, and NVal has the node to add.

Referring to Algorithm 7, if N is equal to the number of nodes in Lst (that is, it is determined that all nodes can be added to NVal), then NVal is added to Lst and idx is initialized to 0 first. Put it. Otherwise, when NVal is the node corresponding to the front node, increase the idx of the current stage until it is equal to or larger than the node corresponding to idx of the node of the current stage. If it is the same, the next step is checked and if the node corresponding to idx is a later node, it goes back to the higher level and selects a new NVal. This check is performed on all neighboring nodes of the node corresponding to the highest level to find a click.

In addition, a method of identifying all groups of nodes having the same interaction is described in Algorithm 8. Abstracting the click into a star-shaped graph merely reduces the number of edges, while abstracting it into a composite node of nodes with the same interaction reduces the number of nodes as well as the number of edges.

Algorithm 8 is an algorithm for finding nodes having the same connection relationship and representing them as one dummy node. First, for all the nodes v corresponding to V, if the v is not already included in the composite node, after initializing the CList, the edge configuration equal to v among all nodes with the same number of neighbors of v and its v nodes is obtained. Add node v 'to the CList. If there are no more nodes to add, convert them to composite nodes for the nodes in the CList. 4 is a network abstracting a sub-network into a composite node in the original network according to the present invention. As shown in FIG. 4, it is possible to very simply represent a dense subgraph at a terminal by abstracting a group of nodes having the same interaction pattern into a composite node.

5 shows a network with 44387 interactions between 4242 human proteins, according to one embodiment of the invention. This appears to have edge crossings but does not actually include edge crossings when visualized in a three dimensional drawing on a video monitor.

6 illustrates an example of network abstraction in accordance with the present invention. Fig. 6 (a) is a protein interaction network with 307 nodes and 1063 edges, and Fig. 6 (b) shows a star formation centered at the dummy node of the click of Fig. 6 (a), as indicated by a circle. Is a graph having 311 nodes and 700 edges simplified by substituting a subgraph of Fig. 6 (c) shows one node group having the same interaction partner in 6 (b), as indicated by the rhombus shape. It is a graph with 47 nodes and 115 edges, simplified by abstracting them into composite nodes. Referring to FIG. 6, in the case of a graph having many clicks, only one abstraction function has a great effect on reducing the complexity of the graph. For graphs with fewer clicks, the complexity can be greatly reduced by applying two abbreviations.

Table 1 shown below shows the results of executing the algorithm of the present invention and two other graph-drawing programs, Pajek and Tulip, to compare the actual execution time between the algorithm provided by the present invention and other algorithms.

Program (Algorithm) Y2H Data3751 Node12917 Edge BIND Data4048 Node8286 Edge DIP Data 4690 Nodes 14460 Edge Human Map 18654 Node184407 Edge Human Map 212056 Node 6989558 Edge The present invention 7 sec 6 sec 7 sec 19 seconds 8 minutes 20 seconds Pajek (K-K) 2 minutes 31 seconds 1 minute 37 seconds 3 minutes 04 seconds 56 minutes 38 seconds Over capacity Pajek (F-R) 28 minutes 23 seconds 20 minutes 02 seconds 42 minutes 45 seconds 2 hours 28 minutes 40 seconds 5 hours 43 minutes 32 seconds Tulip (GEM) 2 minutes 10 seconds 4 minutes 40 seconds 18 minutes 40 seconds 9 hours 19 minutes 10 seconds More than 10 hours Tulip (S-E) 24 minutes 35 seconds 35 minutes 47 seconds 56 minutes 45 seconds More than 10 hours More than 10 hours

Table 1 shows five layout algorithms for the same set of test cases, that is, the layout algorithm of the present invention, Kamada & Kawai's layout of Pajek, Frunchterman-Reingold's layout of Pajek, GEM layout of Pajek, and Spring-Electric force of Tulip. Shows the execution time of each layout. Pajek with Kamada & Kawai 'layout was unable to visualize human map2 due to an error of' memory exceeded '. Referring to Table 1, it can be seen that the execution time of the placement algorithm of the present invention is faster than that of the force-directional layout algorithm.

As described above, the present invention provides a new algorithm for drawing large-scale protein interaction networks in three-dimensional space. Algorithms according to the present invention are faster to execute than other force-oriented drawing algorithms and can be used for the visualization of protein interactions as well as for interactive investigation of individual connected components or subgraphs, making them very useful for studying large-scale protein interactions. useful. In addition, the algorithm according to the present invention makes it easy to visualize and analyze large amounts of updated data by requesting an integrated protein interaction database and providing a frame network that directly visualizes the request results. Furthermore, it can be seen that the present invention produces clear and aesthetically pleasing drawings for large scale protein interaction networks, and is also faster to execute than other force-directed algorithms. Work is expanding to web-based applications that support wired and wireless communication.

Meanwhile, the network layout algorithm and the abstraction function of the present invention can be executed in Borland Dephi 6.0 and the like. In addition, a database of protein interactions can be constructed using Microsoft Data Access Components 2.7. The present invention can be executed by any PC as long as Windows 2000 / XP / Me / 98 / NT4.0 is mounted as the execution system. Apparatus and means for implementing the network visualization algorithm according to the present invention will be readily applicable to those of ordinary skill in the art, such as the program or system described above.

The detailed description and drawings of the present invention disclose a preferred embodiment to help understand the present invention, and do not limit the scope of the present invention, and the scope of the present invention is determined by the above detailed description. Rather, it should be determined by the appended claims.

According to the present invention, the following effects are compared with the conventional force-directional layout algorithm called the interviewer.

First, you can create better drawings without having to calculate the force between the pairs of nodes and run faster.

Second, by providing a number of shaping functions, a complex network can be reduced to a simpler network.

Third, according to the present invention, multiple protein interaction networks can be compared with one another for common proteins or interactions of the proteins shared by some or all of the networks.

Fourth, the present invention is easy to use because it is executable in a web browser.

Claims (7)

Identifying and placing connected components in a protein-protein interaction network; Determining a intermediate node and a pivot node in each of the connected components; Calculating each distance from the pivot node to each node in the connected components, and placing each node associated with the pivot node based on the calculated distance; Disposing the respective connected components by disposing a cutvertex associated with the intermediate node and an intermediate node associated with an adjacent node of the cutvertex; And And arranging each node with respect to adjacent nodes within a distance set for each node to rearrange the connected components. The method of claim 1, wherein the first step, Determining whether a node having at least one edge already belongs to another connected component; If it does not belong to the determination result, assigning an identifier of a new connected component to the node and searching for a neighbor node connected to the node; And And determining that the neighbor node connected to the node belongs to another connected component, and if not, adding the neighbor node to the connected component of the node. The method of claim 1, The determination of the pivot node of the second step, Setting a first node of the connected component as a first pivot node; Determining whether the current node is a pivot node and calculating a distance from the first pivot node if the node is not a pivot node; Determining a pivot node by examining the likelihood that the current node becomes a pivot node based on the calculated distance and the number of nodes in the connected component. The method according to claim 1 or 3, And the distance from the pivot node to the current node is at least three when the number of nodes of the connected components is substantially 100 or less. The method of claim 1, A method for visualizing a protein interaction network, wherein the distance between adjacent nodes is one. The method of claim 1, wherein the fifth step, The method of claim 1, wherein each node is arranged around an adjacent node having a distance of less than 2 for each node. The method of claim 1, And a node group having the same interaction further comprises reducing a number of nodes and edges by replacing with a single compound node.