WO2018222064A1

WO2018222064A1 - Systems and methods of hierarchical community detection in graphs

Info

Publication number: WO2018222064A1
Application number: PCT/RU2017/000365
Authority: WO
Inventors: Viktor Vladimirovich SMIRNOV; Alexander Vladimirovich SLESARENKO; Alexander Nikolaevich Filippov
Original assignee: Huawei Technologies Co., Ltd.
Priority date: 2017-05-29
Filing date: 2017-05-29
Publication date: 2018-12-06
Also published as: CN110325984A; CN110325984B

Abstract

There is provided an apparatus for detecting communities within a graph, comprising: a processor configured to compute the following cycle: creating a directed Decoupling graph of communities of vertices from computed possible moves between communities of the graph, filtering edges of the directed Decoupling graph to obtain respective communities each including one of: incoming edges to vertices of the respective community, or outgoing edges from vertices of the respective community, and updating vertices of the marked graph with community labels from edges of the filtered directed Decoupling graph, wherein a packed graph created by merging vertices of each community of the filtered directed Decoupling graph and merging multiple edges between couples of vertices of the packed graph into a single edge denotes the computed hierarchical communities of the marked graph. The graph eventually converges to a solution when executed in a parallel and/or distributed computing system.

Description

SYSTEMS AND METHODS OF HIERARCHICAL COMMUNITY DETECTION IN

GRAPHS

BACKGROUND

The present invention, in some embodiments thereof, relates to community detection and, more specifically, but not exclusively, to systems and methods of hierarchical community detection in graphs.

Community detection (CD) is a procedure of identifying communities within a graph. The communities are identified as closely related vertices. CD finds applications in a variety of areas, including for example, computer vision, economics, social sciences, medical studies, and genetic studies.

There are two general approaches to community detection; flat and hierarchical. A hierarchical CD is a community detection procedure that yields a layered topology of the identified communities within the graph. Hierarchical CD is usually more computationally complex than flat CD, but yields layered community topology and may provide better precision.

Hierarchical community detection methods may include one of two general approaches, divisive (top-down) and agglomerative (bottom-up). The agglomerative approach generally provides more control over the process obtaining the solution.

Community detection in Big Data, which includes massive graphs, for example, representing internet connectivity, is a computationally difficult problem. For practical use, methods of community detection in Big Data graphs should be fast enough to produce results in a reasonable amount of time. Due to the large size of the graph being analyzed, methods that are 0(n²) complex may not generate solutions in a reasonable time. To identify communities in Big Data graphs within a reasonable amount of time, CD methods should be designed to be closer to a linear time complexity.

Reference is now made to FIG. 1, which is a schematic depicting a graph 102 with identified hierarchical communities (represented by different shading) and a corresponding dendrogram 104 (corresponding to the community shading of graph 102), useful to help understand some embodiments of the present invention. SUMMARY

It is an object of the present invention to provide an apparatus, a method, a computer program product, and a system for detecting communities within a graph.

The foregoing and other objects are achieved by the features of the independent claims. Further implementation forms are apparent from the dependent claims, the description and the figures.

According to a first aspect, an apparatus for detecting communities within a graph G=(V,E), with vertices V and edges E, is configured to: compute, starting with a marked graph (G1=V1 ,E1), a packed graph in an iterative manner, that is, in an iteration cycle, wherein the graph G=(V,E) acts as the marked graph for the first iteration of the iteration cycle, the packed graph acts as the marked graph for a next iteration of the iteration cycle, until a graph modularity value denoting connectivity of communities of the packed graph of a current iteration stabilizes or reverses relative to the graph modularity value of the previously computed packed graph, wherein the packed graph of each iteration is computed recursively by: obtaining all vertex moves between communities for each vertex v in VI of the marked graph (Gl), wherein a vertex move between any two communities is an edge e in El of the marked graph (Gl), connecting two vertices from the two communities, when no vertex moves exist, stopping the iteration cycle, when at least one possible vertex move exists, creating a directed Decoupling graph (D(G1)) of communities of vertices from the obtained vertex moves between communities, wherein each vertex of the directed Decoupling graph (D(G1)) denotes a respective community of the marked graph, and the obtained vertex moves between communities are denoted as edges of the directed Decoupling graph (D(G1)), filtering edges of the directed Decoupling graph (D(G1 )) to obtain a filtered directed Decoupling graph (FD(G1)), wherein each vertex of the filtered directed Decoupling graph (D(G1)) has only incoming or only outgoing edges, and updating vertices of the marked graph (Gl ) with community labels from edges of the filtered directed Decoupling graph D(G1) to create an updated graph (Gl '), create the packed graph of the current iteration by merging vertices of each community of the updated graph (Gl ') into a single vertex, and merging multiple edges between couples of vertices of the packed graph into a single edge between corresponding couples of vertices with summarized weight; and output the packed graph of the final iteration representing the computed hierarchical communities of the marked graph of the first iteration.

According to a second aspect, a method of detecting communities within a graph G=(V,E), with vertices V and edges E, the method comprises: computing, starting with a marked graph (G1=V1 ,E1), a packed graph in an iterative cycle, wherein the graph G=(V,E) acts as the marked graph for the first iteration of the iteration cycle, the packed graph acts as the marked graph for a next iteration of the iteration cycle, until a graph modularity value denoting connectivity of communities of the packed graph of a current iteration stabilizes or reverses relative to the graph modularity value of the previously computed packed graph, wherein the packed graph of each iteration is computed recursively by: computing all vertex moves between communities for each vertex v in VI of the marked graph (Gl), wherein a vertex move between any two communities is an edge e in El of the marked graph (Gl), connecting two vertices from the two communities, when no vertex moves exist, stopping the cycle, when at least one possible vertex move exists, creating a directed Decoupling graph (D(G1)) of communities of vertices from the computed moves between communities, wherein each vertex of the directed Decoupling graph (D(G1 )) denotes a respective community of the marked graph, and the computed moves between communities are denoted as edges of the directed Decoupling graph (D(G1)), filtering edges of the directed Decoupling graph (D(G1)) to obtain a filtered directed Decoupling graph (FD(G1)), wherein each vertex of the filtered directed Decoupling graph (D(G1)) has only incoming or only outgoing edges, and updating vertices of the marked graph (Gl) with community labels from edges of the filtered directed Decoupling graph D(G1) to create an updated graph (Gl '), creating the packed graph of the current iteration by merging vertices of each community of the updated graph (Gl ') into a single vertex, and merging multiple edges between couples of vertices of the packed graph into a single edge between corresponding couples of vertices with summarized weight, and outputting the packed graph of the final iteration representing the computed hierarchical communities of the input marked graph, that is, the marked graph of the first iteration.

Filtering the edges to obtain a graph having communities with vertices that are either all associated with incoming edges, or all associated with outgoing edges, ensures that the graph eventually converges to a solution when executed in a parallel and/or distributed computing system. For example, a naive based parallelization approach may cycle vertices between communities which may prevent eventual convergence to a solution.

Filtering the edges to obtain a graph having communities with vertices that are either all associated with incoming edges, or all associated with outgoing edges, provides linear-time complexity, which provides for processing of very large graphs within a reasonable amount of time, since movement and updating of the vertices is performed in parallel by the distributed nodes. For example, relative to other methods that are 0(n²) complex.

In a further implementation form of the first and second aspects, the method further comprises and/or the apparatus is further configured to create/obtain the marked graph (Gl) by initializing the vertices of the input graph (G) with community labels by placing each vertex into a respective community.

The vertices of the marked graph (Gl) and/or edges of the filtered directed Decoupling graph (D(G1)) may be distributed over nodes of a distributed system for parallel and/or distributed updating.

In a further implementation form of the first and second aspects, the method further comprises and/or the apparatus is further configured to distribute the marked graph (Gl) across nodes of at least one of a parallel and a distributed computing system, and to obtain the possible vertex moves, wherein each node computes the possible vertex moves for at least one distinct vertex of the marked graph (Gl ).

The apparatus, system, method, and/or code instructions described herein are executable in a parallel and/or distributed computing system. The parallel and/or distributed execution identifies communities in very large graphs (on the order of at least 10⁶- 10⁸ vertices, and on the order of 10⁹ edges, or larger) which would otherwise take an impractical long time to process using standard methods. Data may be stored locally at each node of the parallel and/or distributed computing system, which reduces network traffic which would otherwise occur as one node accesses data stored in other nodes. In contrast, other common methods are designed to run sequentially, resulting in excessively long processing times. Even if the other methods are executed in a parallel and/or distributed computing system, due to the sequential design of the algorithm, only one core processes the graph at a time. Moreover, where data is stored across multiple nodes in distributed file systems, the single executing node accesses other nodes to obtain the distributed data, causing excessive network activity.

In a further implementation form of the first and second aspect, the apparatus comprises a plurality of processors, configured to compute the packed graph in parallel, each processor performing for at least one distinct community, merging vertices of each community of the filtered directed Decoupling graph (D(G1)) into a single vertex, and merging duplicate edges of the packed graph into a single edge.

The Decoupling graph is centrally processed when all data is received from the other node(s) to ensure that the completed graph is processed. Computing the Decoupling graph, and filtering the edges of the Decoupling graph may be executed by the single processor using relatively few computational resources and/or within a reasonable amount of time, since the computations are relatively simple.

The network traffic between nodes is reduced relative to other methods. The network traffic associated with moving and storing the Decoupling graph is 0(n), where n denotes the number of vertices in the graph since one vertex can have only one associated move. In contrast, the network traffic associated with moving and storing the entire graph is performed in one iteration denoted by 0(m), where m denotes the number of edges in the graph.

In a further implementation form of the first and second aspect, the graph modularity denotes a global cost function indicative of density of edges between vertices within each community of the packed graph compared to density of edges between vertices of different communities of the packed graph.

In a further implementation form of the first and second aspect, the method further comprises and/or the process is further configured for selecting vertex moves from the computed possible moves between communities according to a local move modularity value computed for each vertex denoting the change in density of edges between vertices within the respective community of each vertex move, wherein the directed Decoupling graph (D(G1 )) of communities of vertices is created according to the selected vertex moves.

The greedy based computation, in which vertex moves are selected according to the most significant change in the local move modality value (e.g., greatest change) is sufficiently accurately in practice while providing linear time complexity, which provides for processing of very large graphs within a reasonable amount of time.

In a further implementation form of the first and second aspect, the directed Decoupling graph (D(G1 )) is created and filtered by performing: selecting a first vertex move from the computed possible moves according to a vertex move local modality value, designate a first emitter community and a second acceptor community according to the selected first vertex move, wherein the emitter community denotes the origin of the vertex of the first vertex move and the acceptor community denotes the destination of the vertex of the first vertex move, iterating for the remaining moves: selecting another vertex move from the computed possible moves according to the local move modality value denoting the most significant change in density of edges from the remaining possible moves, filtering the another vertex move from consideration when the vertex from the another vertex move originates in one of the acceptor communities and terminates in one of the emitter communities, and designating another emitter community and another acceptor community according to the selected second vertex move.

According to a third aspect, a system is provided for determining communities within a graph G=(V,E), with vertices V and edges E, the system comprising the apparatus according to the first aspect, a distributed system, the distributed system comprising a plurality of nodes, a graph repository, and a user interface, the apparatus being configured to receive a graph G=(V,E) from the graph repository, distribute the graph G across nodes of the distributed system; receive from the distributed system possible vertex moves of the graph G, computed for each vertex v of V in parallel by the nodes of the distributed system, and determine communities within a graph G based on the received vertex moves.

According to a fourth aspect, a computer-readable storage medium is provided, comprising instructions, which when executed by a computer, cause the computer to carry out the steps of the method of the second aspect.

According to a fifth aspect, a computer program product is provided comprising instructions, which when the program is executed by a computer or processor, cause the computer or processor to carry out the steps of the method of the second aspect. Unless otherwise defined, all technical and/or scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which the invention pertains. Although methods and materials similar or equivalent to those described herein can be used in the practice or testing of embodiments of the invention, exemplary methods and/or materials are described below. In case of conflict, the patent specification, including definitions, will control. In addition, the materials, methods, and examples are illustrative only and are not intended to be necessarily limiting.

BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS

Some embodiments of the invention are herein described, by way of example only, with reference to the accompanying drawings. With specific reference now to the drawings in detail, it is stressed that the particulars shown are by way of example and for purposes of illustrative discussion of embodiments of the invention. In this regard, the description taken with the drawings makes apparent to those skilled in the art how embodiments of the invention may be practiced.

In the drawings:

FIG. 1 is a schematic depicting a graph with identified hierarchical communities and a corresponding dendrogram, useful to help understand some embodiments of the present invention;

FIG. 2 is a schematic that visually depicts a sequentially implemented process of hierarchical community detection in graphs, useful to help understand some embodiments of the present invention;

FIG. 3 is a flowchart depicting the sequential design of the Lo vain method described herein, useful to help understand some embodiments of the present invention;

FIG. 4 is a schematic that visually illustrates that prior art methods cannot compute communities for a graph even when implemented in a parallel environment, useful to help understand some embodiments of the present invention;

FIG. 5 is a schematic that visually illustrates lack of graph convergence by parallel movement of vertices across communities according to prior art methods designed for sequential processing, useful to help understand some embodiments of the present invention; FIG. 6 is a schematic that visually illustrates that prior art methods designed for sequential execution cannot ensure graph convergence when implemented in a parallel environment, useful to help understand some embodiments of the present invention;

FIG. 7 is a flowchart of a method of detecting communities within a graph for implementation within a distributed system, in accordance with some embodiments of the present invention;

FIG. 8 is a block diagram of components of a system for detecting communities within a graph implemented by a distributed system, in accordance with some embodiments of the present invention;

FIG. 9 is a schematic depicting the process of restricting communities to shrink or grow during each iteration, in accordance with some embodiments of the present invention;

FIG. 10 is a schematic depicting the process of centrally filtering the edges of the directed Decoupling graph (D(G1)) in a distributed system, in accordance with some embodiments of the present invention;

FIG. 1 1 is a schematic depicting the process of computing decoupled vertex moves based on the greedy variant of the method described with reference to FIG. 7, in accordance with some embodiments of the present invention;

FIG. 12 is a schematic depicting parallel processing for computing hierarchical communities in a graph, in accordance with some embodiments of the present invention;

FIG. 13 is a table summarizing experimental results of the systems, apparatus, methods, and/or code instructions described herein;

FIG. 14 is a table summarizing computational performance of the systems, apparatus, methods, and/or code instructions described herein in identifying communities in Big Data graphs; and

FIG. 15 is a schematic that graphically depicts one iteration of the process of computing the packed graph, according to blocks 702-710 described with reference to FIG. 7, in accordance with some embodiments of the present invention. DETAILED DESCRIPTION The present invention, in some embodiments thereof, relates to community detection and, more specifically, but not exclusively, to systems and methods of hierarchical community detection in graphs.

As used herein, the term graph means a set of objects denoted as vertices or nodes that are associated with one or more other vertices or nodes with edges. An input graph, which denotes the graph that is processed for detecting communities therein, is sometimes denoted herein as G, or G=(V,E), where V denotes the vertices and E denotes the edges. A marked graph, which denotes a processing of the input graph, is sometimes denoted herein as G1=(V1 ,E1 ), or Gl . A directed Decoupling graph, which denotes a processing of the marked graph, is sometimes denoted herein as D(G1). A filtered directed Decoupling graph, which is created by filtering edges of the directed Decoupling graph D(G1), is sometimes denoted herein as FD(G1 ). A packed graph is computed based on the filtered directed Decoupling graph FD(G1).

As used herein, the term community means a sub-set of vertices of the graph each associated with a common community label. The sub-set of vertices of each community have relatively stronger relationships (e.g., edge weights, number of edges) between vertices of the common community relative to vertices located outside of the community (optionally in another community).

As used herein, the term community label means a numeric property of the graph vertex, defining which community the graph vertex belongs to.

As used herein, the term vertex move means a logical move of a graph vertex from the respective community to some neighboring community across some edge. For example, assignment of a certain community label (obtained from the neighboring vertex) of a target community to a moving vertex across an appropriate edge in a reversed direction.

An aspect of some embodiments of the present invention relate to a system, an apparatus, a method, and/or code instructions (stored in a data storage device executable by one or more processors) for distributed computation of communities, optionally hierarchical communities, within an input graph. A directed Decoupling graph of communities of vertices is created from computed possible vertex moves between communities of each vertex of a marked graph computed from the input graph. Each vertex of the directed Decoupling graph denotes a respective community of the marked graph. The computed moves between communities are denoted as edges of the directed Decoupling graph. Edges of the directed Decoupling graph are filtered to obtain a filtered directed Decoupling graph, where each vertex of the filtered directed Decoupling graph has only incoming edges or only outgoing edges. The vertices of the marked graph are updated with community labels from edges of the filtered directed Decoupling graph, to create an updated graph.

The directed Decoupling graph (D(G1)) is a temporary (optionally logical) data object created in the process of updating graph (Gl) with new community labels. The directed Decoupling graph (D(G1 )) prevents convergence failure of marked graph (Gl), by increasing the modularity of the updated graph (Gl).

A packed graph is iteratively computed. The packed graph of each iteration is computed by merging vertices of each community of the updated graph into a single vertex. Multiple edges between couples of vertices of the packed graph are merged into a single edge between corresponding couples of vertices with summarized weight. The packed graph of the current iteration acts as the marked graph for the next iteration until a graph modularity value denoting connectivity of communities of the packed graph of the current iteration stabilizes or reverses relative to the graph modularity value of the previously computed packed graph.

The packed graph of the final iteration, denoting the computed hierarchical communities of the marked graph, is outputted.

Optionally, the possible vertex moves of the marked graph are computed in parallel, by nodes of a distributed computing system. Alternatively or additionally, the packed graph is computed in parallel from the updated graph by nodes of the distributed computing system.

Before explaining at least one embodiment of the invention in detail, it is to be understood that the invention is not necessarily limited in its application to the details of construction and the arrangement of the components and/or methods set forth in the following description and/or illustrated in the drawings and/or the Examples. The invention is capable of other embodiments or of being practiced or carried out in various ways.

The present invention may be a system, a method, and/or a computer program product. The computer program product may include a computer readable storage medium (or media) having computer readable program instructions thereon for causing a processor to carry out aspects of the present invention.

The computer readable storage medium can be a tangible device that can retain and store instructions for use by an instruction execution device. The computer readable storage medium may be, for example, but is not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing.

Computer readable program instructions described herein can be downloaded to respective computing/processing devices from a computer readable storage medium or to an external computer or external storage device via a network, for example, the Internet, a local area network, a wide area network and/or a wireless network.

The computer readable program instructions may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider). In some embodiments, electronic circuitry including, for example, programmable logic circuitry, field-programmable gate arrays (FPGA), or programmable logic arrays (PLA) may execute the computer readable program instructions by utilizing state information of the computer readable program instructions to personalize the electronic circuitry, in order to perform aspects of the present invention.

Aspects of the present invention are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer readable program instructions.

The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of instructions, which comprises one or more executable instructions for implementing the specified logical function(s). In some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts or carry out combinations of special purpose hardware and computer instructions.

Reference is now made to FIG. 2, which is a schematic that visually depicts a process of hierarchical community detection in graphs that is implemented sequentially, useful to help understand some embodiments of the present invention. In contrast to the systems, apparatus, methods, and/or code instructions described herein that detected communities in a graph using parallel processing, the process depicted in FIG. 2 based on the Louvain method, also known as Fast Unfold, is designed for sequential execution. The Louvain method is based on heuristically optimizing the modularity of the graph, which is computed as a global cost function. The Louvain method is based on iteratively repeating two phases until graph convergence is obtained (e.g., according to a convergence requirement). The first phase 202 is a flat community detection phase, also termed Modularity Optimization. The second phase 204 is a graph compression phase, also termed Community Aggregation.

During first phase 202, each graph vertex is placed in its own community by marking the graph vertices with community labels. Vertices are sequentially moved across communities according to common communities, in a manner that increases modularity of the graph. During second phase 204, the communities formed by the movement of the vertices are converted into vertices of a new compressed graph. Edges inside the communities are converted into self-loops of the new vertices. Edges between communities are merged to create new graph edges of the compressed graph.

First phase 202 is designed for sequential based implementation based on asynchronous updates. During each sequential iteration, a single vertex is selected, an optimal move (label assignation) is calculated for the vertex, and the vertex is labeled with the new community label according to the calculated optimal move. The graph converges according to the following modularity increase equations, and is computed for every movement of vertex / into a community Ck.

AQ, = AQ : - AQ;_C

Equation (1)

Where: QL =— ∑^e* ^{' w}< ^{' w} _k m

Equation (2)

respectively denote positive and negative changes in modularity resulting from moving the vertex out from one community and into another community.

" =∑*,„ w_c, = ∑e_to Equation (3) n kec, _yn

Equation (3) respectively denotes weight of the vertex / and weight of community Ci computed by summing the weights of the adjacent links.

Methods based on Equations (l )-(3) are not designed for parallel processing. Since Equation (2) is dependent on the values computed by Equation (3), and the values computed by Equation (3) change for each community that absorbed or emitted a vertex, only one vertex may actually be moved at a time, preventing computations based on parallel vertex moves.

The Louvain method may be expressed in terms of sequential steps as follows, which further clarifies the difference with the parallel based processing performed by the systems, apparatus, methods, and/or code instructions described herein:

1. Set current iteration to 0. Set graph G to input graph.

2. Place all vertices in G into a set S and randomly shuffle the set.

3. If iS is empty go to step 7 otherwise obtain a vertex n from set S.

4. Find the best move v for given n.

5. If modularity increase of v is negative go to step 3. 6. Move n into a community according to v and go to step 3.

7. Pack the graph G by merging vertices in the same communities into one vertex of a new graph G_p and by merging duplicate edges in G_p into singular edges with summarized weights.

8. Calculate modularity Qi of packed graph.

9. If Qi > Qi -l or if / = 0 then set to i + 1, G to G_p and go to step 2, else go to step 10.

10. The computed graph denotes the solution with hierarchical communities. Reference is now made to FIG. 3, which is a flowchart depicting the sequential design of the Louvain method described herein, useful to help understand some embodiments of the present invention. The sequential process depicted in FIG. 3 is in contrast to the parallel based processing performed by the systems, apparatus, methods, and/or code instructions described herein.

At 302, G is set to the input graph. The initial set C of communities of vertices is defined. At 304, an unmoved node n is selected from G. At 306, the best move v for node n is found according to the highest increase in modularity of the graph. At 308, node n is updated with best move v. At 310, an analysis is performed to determine whether the maximum number of defined iterations is reached and/or whether the communities converged. At 312, when additional iterations may be performed and/or when communities have not yet converted, the process is iterated by repeating blocks 304-310. At 314, when the maximum number of iterations is reached and/or when communities converged, the computed graph G and set of identified communities C is outputted.

As discussed above, the Louvain method, and other methods for detecting communities in graphs are designed to execute sequentially. For processing of very large graphs, on the order of about 10⁶-10⁸ vertices and more, having about 10⁹ or more edges, sequential based processing is inefficient, and unable to compute a solution within a reasonable amount of time using reasonable available processing resources. The systems, methods, and/or code instructions described herein perform parallel and/or distributed based processing that computes a solution (i.e., identifies communities) for very large graphs within a reasonable amount of time and/or using a reasonable amount of computational resources. Reference is now made to FIG. 4, which is a schematic that visually illustrates that prior art methods cannot compute communities for a graph even when implemented in a parallel environment 402, useful to help understand some embodiments of the present invention. Parallel environment 402 may include multiple nodes, with each node running one or more CPUs, optionally multi-core CPUs. When parallel environment 402 receives an input graph 404 and computes an output graph with communities 406 based on a prior art method (e.g., Louvain) implemented in parallel environment 402, only one core of one CPU of a single node is active in executing the method. The remaining cores, CPUs, and nodes are idle, not participating in the computation. The parallelization is prevented by the fact that the update over the vertex according to the identified optimal vertex move affects other vertices. Therefore, a second vertex move cannot be computed in parallel, but must wait until the first vertex move computation is complete.

Moreover, the very large graph (falling into the category of big data) may be stored across many nodes of parallel environment 402 using a distributed file system (DFS). Since the computations to identify communities within the distributed graph are condensed to a single core, random access from the active single core to the other nodes storing the distributed graph is required. The transfer of the portions of the distributed graph from the other nodes to the single active core may cause excessively high network activity. The entire distributed graph may need to be stored in the local memory of the single active node during the computation, which may not be feasible when the graph is very large, beyond the storage capacity of the memory of the single active node.

Reference is now made to FIG. 5, which is a schematic that visually illustrates lack of graph convergence by parallel movement of vertices across communities according to prior art methods designed for sequential processing, useful to help understand some embodiments of the present invention. FIG. 5 depicts implementation of a na^'ive based approach applied to a prior art method (e.g., Louvain) executing within a parallel environment. For clarity of explanation, Graph 502 includes a small number of vertices and edges. When all nodes are moved in parallel, the graph may be unable to form stable communities, and therefore the graph may be unable to converge. A solution cannot be computed when the graph does not converge. Reference is now made to FIG. 6, which is a schematic that visually illustrates that prior art methods designed for sequential execution cannot ensure graph convergence when implemented in a parallel environment, useful to help understand some embodiments of the present invention. For clarity of explanation, Graph 602 includes three vertices and three edges, and Graph 604 includes two vertices and two edges.

Graph 602 is processed into Graphs 602B and 602C by sequentially moving one vertex at a time based on prior art methods (e.g., Louvain), which correctly yields a clique. Graph 604 is processed into Graph 604B by sequentially moving one vertex at a time based on prior art methods (e.g., Louvain), which correctly yields a clique.

In contrast, Graph 602 is processed into Graphs 602D and 602E by moving all vertices in parallel, which makes the vertices cycle across each other, and never converging to a stable distribution. Communities within Graphs 602D and 602E cannot be identified. Graph 604 is processed into Graph 604C by moving all vertices in parallel, which makes the vertices cycle across each other, and never converging to a stable distribution. Communities within Graph 604C cannot be identified.

Reference is now made to FIG. 7, which is a flowchart of a method of detecting communities within a graph for implementation within a distributed system, in accordance with some embodiments of the present invention. Reference is also made to FIG. 8, which is a block diagram of components of a system 800 for detecting communities within a graph implemented by a distributed system 802, in accordance with some embodiments of the present invention.

Distributed system 802 is designed to execute code instructions in parallel. Distributed system 802 includes multiple nodes 804. Distributed system 802 may be implemented as a single unit (e.g., a box), or as multiple interconnected units (e.g., multiple boxes connected to each other).

Each node 804 may be implemented as, for example, a hardware processor, a virtual processor, a virtual machine, a group of processors arranged for parallel processing, a multi-core processor, a computing device (i.e., at least a processor and associated data storage device), and/or a group of computing devices arranged as a sub- distributed system. Nodes 804 may be homogenous or heterogeneous. Nodes 804 may be independent computational components, for example, a network server, a web server, a computing cloud, a local server, a remote server, a client terminal running code, a mobile device, a stationary device, a server, a smartphone, a laptop, a tablet computer, a wearable computing device, a glasses computing device, a watch computing device, and a desktop computer. Processors of nodes 804 are implemented as, for example, a central processing unit(s) (CPU), a graphics processing unit(s) (GPU), field programmable gate array(s) (FPGA), digital signal processor(s) (DSP), and application specific integrated circuit(s) (ASIC).

A computing device (i.e, an apparatus for determining communities within a graph) 806 is in communication with distributed system 802 (also sometimes referred to herein as a parallel processing system). Computing device 806 may act as a controller of distributed system 802, for example, a scheduler and/or distributor of the work across nodes 804 of distributed system 802. Computing device 806 may be integrated within distributed system 802. Computing device 806 may be implemented as one or more nodes within distributed system 802.

Computing device 806 may be implemented, for example, as software code instructions stored and executed by processor(s) of distributed system 802, as code instructions stored and executed by one or more nodes of distributed system 802, as a hardware card installed within distributed system 802 and/or within one or more nodes 804, and/or as an independent computing device locally or remotely connected to distributed system 802 using a network or direct connection (e.g., cable, short range wireless link).

Computing device 806 may be implemented as, for example, a computing cloud, a cloud network, a computer network, a virtual machine(s) (e.g., hypervisor, virtual server), a single computing device (e.g., client terminal), a group of computing devices arranged in parallel, a server, a client terminal, a mobile device, a stationary device, a kiosk, a smartphone, a laptop, a tablet computer, a wearable computing device, a glasses computing device, a watch computing device, and a desktop computer.

Computing device 806 includes one or more processors 808 and a data storage device 810 (e.g., memory) storing code instructions that implement the acts of the method described with reference to FIG. 7 when executed by processor(s) 808.

Processor(s) 808 may be implemented as for example, central processing unit(s) (CPU), graphics processing unit(s) (GPU), field programmable gate array(s) (FPGA), digital signal processor(s) (DSP), application specific integrated circuit(s) (ASIC), customized circuit(s), processors for interfacing with other units, and/or specialized hardware accelerators. Processor(s) 808 may be implemented as a single processor, a multi-core processor, and/or a cluster of processors arranged for parallel processing (which may include homogenous and/or heterogeneous processor architectures).

Data storage device 810 may be implemented as, for example, a random access memory (RAM), read-only memory (ROM), and/or a storage device, for example, nonvolatile memory, magnetic media, semiconductor memory devices, hard drive, removable storage, and optical media (e.g., DVD, CD-ROM).

Computing device 806 receives the graph from a graph repository 812, for example, a remote server, a computing cloud, a remote storage device, and/or local storage. Alternatively, computing device 806 computes the graph, for example, by creating the graph by tracing social connections of a social networking web site.

Computing device 806 is associated with one or more user interfaces 814 that include a mechanism for a user to enter data (e.g., designate the graph) and/or for a user to view the identified communities. Exemplary user interfaces 814 include one or more of: a display, a touch screen, a keyboard, a mouse, and voice activated software operating with speakers and a microphone.

Referring now back to FIG. 7, at 702, a marked graph (G1=V1 ,E1) is created by initializing vertices of an input graph (G, or G=(V,E)) with community labels, by placing vertices of the input graph (G) into respective communities. Optionally each vertex is placed in a respective community.

Input graph (G) may be received by computing device 806 from graph repository 812. Input graph (G) may be obtained from storage on a storage device, automatically computed by code, and/or manually entered by a user using user interface 814.

At 704, vertex moves (one or more moves, optionally all vertex moves) between communities for each vertex (denoted v in VI) of the marked graph (Gl) are computed. A vertex move between any two communities is an edge (denoted E in El) of the marked graph (Gl ), connecting two vertices from the two communities. It is noted that some vertices may not be associated with any moves, for example as described with reference to act 712. The marked graph (Gl) is distributed across nodes of parallel and/or distributed computing system 802. Nodes (optionally each available node) 804 of distributed system 702 compute the possible vertex moves for one or more distinct vertices of the marked graph (Gl).

The parallel and/or distributed execution identifies communities in very large graphs (on the order of at least 10⁶-10⁸ vertices, and on the order of 10⁹ edges, or larger) which would otherwise take an impractical long time to process using standard methods. Data may be stored locally at each node of the parallel and/or distributed computing system, which reduces network traffic which would otherwise occur as one node accesses data stored in other nodes. In contrast, other common methods are designed to run sequentially, resulting in excessively long processing times. Even if the other methods are executed in a parallel and/or distributed computing system, due to the sequential design of the algorithm, only one core processes the graph at a time. Moreover, where data is stored across multiple nodes in distributed file systems, the single executing node accesses other nodes to obtain the distributed data, causing excessive network activity.

Vertex moves are selected from the computed possible moves between communities. The vertex moves may be selected according to a local move modularity value computed for respective vertices (e.g., each vertex).

At 706, a directed Decoupling graph (D(G1)) of communities of vertices is created from the computed possible moves between communities according to the selected vertex moves. Each vertex of the directed Decoupling graph (D(G1)) denotes a respective community of the marked graph (Gl ). The computed possible moves between communities are denoted as edges of the directed Decoupling graph (D(G1)).

At 708, edges of the directed Decoupling graph (D(G1)) are filtered to obtain filtered directed Decoupling graph (FD(G1 )). Each vertex of the filtered directed Decoupling graph (FD(G1)) community includes (only) incoming edges to vertices of the respective community, or (only) outgoing edges from vertices of the respective community. During each iteration (e.g., as described with reference to step 712) each community is restricted to either emit vertices (thereby shrinking in size) or receive vertices (thereby growing in size). As used herein, the term decoupling refers to the process of separating vertex moves that do not affect convergences of the directed Decoupling graph (D(G1)) from other moves that would may prevent convergence or significantly increase the convergence time and/or computations resources to compute the convergence. Decoupled moves may be performed in parallel while preserving the ability of the graph to converge.

Filtering the edges to obtain a graph having communities with vertices that are either all associated with incoming edges, or all associated with outgoing edges, ensures that the graph eventually converges to a solution when executed in a distributed computing system. For example, as described herein, the naive based parallelization approach may cycle vertices between communities which may prevent eventual convergence to a solution.

Reference is now made to FIG. 9, which is a schematic depicting the process of restricting communities to shrink or grow during each iteration of the method described with reference to FIG. 7, in accordance with some embodiments of the present invention. Communities 902A and 902B are designated as emitters, and are restricted to shrink is size by emitting vertices. Communities 904A and 904B are designated as receivers, and are restricted to grow in size by receiving vertices.

Referring now back to act 708 of FIG. 7, optionally, the directed Decoupling graph (D(G1)) is computed and/or the edges of the directed Decoupling graph (D(G1)) are filtered by a single node 804 with aggregation (optionally barrier synchronization) from other nodes 804 of distributed system 802 computing the possible vertex moves for one or more distinct vertices of the marked graph (Gl).

The directed Decoupling graph (D(G1)) is centrally processed when all data is received from the other node(s) to ensure that the completed graph is processed. Computing the directed Decoupling graph (D(G1)), and filtering the edges of the directed Decoupling graph (D(G1 )) may be executed by the single node using relatively few computational resources and/or within a reasonable amount of time, since the computations are relatively simple.

The network traffic between nodes is reduced relative to other sequential based methods. The network traffic associated with moving and storing the directed Decoupling graph (D(G1 )) is 0(n), where n denotes the number of vertices in the graph since one vertex can have only one associated move. In contrast, the network traffic associated with moving and storing the entire graph is performed in one iteration denoted by 0{m), where m denotes the number of edges in the graph.

Vertices of the marked graph (Gl) are updated with community labels from edges of the filtered directed Decoupling graph (FD(G1)) to create an updated graph (Gl '). The vertices of the marked graph (Gl) and/or edges of the filtered directed Decoupling graph (FD(G1)) may be distributed over nodes 804 of distributed system 802 for parallel and/or distributed updating.

Reference is now made to FIG. 10, which is a schematic depicting the process of centrally filtering the edges of the directed Decoupling graph (D(G1 )) in a distributed system, in accordance with some embodiments of the present invention. The process described with reference to FIG. 10 denotes optimization of the communities. Input graph 1002 is received, processed to create marked graph (Gl ), and distributed to nodes 1004 of a distributed computed system. Each node 1004 may include one or more CPUs each with one or more cores. Nodes 1004 compute vertex moves (one move 1006 is shown for clarity) in parallel (as described with reference to act 704 of FIG. 7). The computed vertex moves (e.g., 1006) are transmitted to a single node 1008 (which may include one or more CPUs and/or one or more cores) for central filtration, i.e., decoupling. Node 1006 aggregates the moves (e.g., 1008) computed by the distributed nodes, optionally based on barrier synchronization. The vertices of the marked graph (Gl) are distributed to nodes 1004 of the distributed system for distributed update (one update 1010 shown for clarity) of the vertices with community labels from edges of the filtered directed Decoupling graph (FD(G1)). Packed graph 1012 is created based on the updated vertices and outputted, providing the computed hierarchical communities.

Referring now back to FIG. 7, at 710, the packed graph (of the current iteration as described with reference to act 712) is created by merging vertices of each community of the filtered directed Decoupling graph (FD(G1)) into a single vertex. Multiple edges between couples of vertices of the packed graph are merged into a single edge between corresponding couples of vertices with summarized weight.

The packed graph is created in parallel by multiple nodes 804 of distributed system 802 each performing for at least one distinct community, the merging of vertices of each community of the filtered directed Decoupling graph (FD(G1)) into the single vertex, and the merging of the duplicate edges of the packed graph into the single edge.

At 712, when one or more vertex moves are possible, blocks 702-710 are iterated. Starting with the marked graph (G1=V1 ,E1), the packed graph is computed recursively, and in an iterative manner, by executing blocks 702-710 to create the packed graph for each iteration. The packed graph acts as the marked graph (Gl) for the next iteration. The iterations may be terminated when the graph modularity value denoting connectivity of communities of the packed graph of the current iteration stabilizes or reverses relative to the graph modularity value of the previously computed packed graph.

The graph modularity value denotes a global cost function indicative of density of edges between vertices within each community of the packed graph compared to density of edges between vertices of different communities of the packed graph.

Reference is now made to FIG. 15, which is a schematic that graphically depicts one iteration of the process of computing the packed graph, according to blocks 702- 710 described with reference to FIG. 7, in accordance with some embodiments of the present invention. Element 1500 graphically depicts one iteration of 1502- 1510, corresponding to blocks 702-710 described with reference to FIG. 7.

Input graph 1501 is received, for processing and detection of communities, as described herein. At 1502, marked graph (Gl) is created, as described with reference to block 702 of FIG. 7. At 1504, possible vertex moves are computed for marked graph (Gl ), as described with reference to block 704 of FIG. 7. At 1506, a directed Decoupling graph (D(G1 )) is created based on the possible vertex moves, as described with reference to block 706 of FIG. 7 At 1508, a filtered directed Decoupling graph (FD(G1)) is created by filtering the edges of the directed Decoupling graph of 1506, as described herein. Each vertex of the filtered directed Decoupling graph (FD(G1)) has only incoming or only outgoing edges. At 1509, the applicable moves are determined from the filtered directed Decoupling graph (FD(G1)). At 1510, the vertices of the marked graph (Gl ) are updated with the community labels from the edges of the filtered Decoupling graph (FD(G1 )), creating an updated graph (GT), as described with reference to block 710 of FIG. 7. At 1512, the updated graph proceeds to the next iteration as the marked graph, as described with reference to block 712 of FIG. 7.

Referring now back to FIG. 7, at 714, when no possible vertex moves are available, the iteration cycles are terminated. The packed graph of the final iteration denoting the computed hierarchical communities of the marked graph is outputted.

The packed graph denoting the computed hierarchical communities may be presented on a display (e.g., user interface 814), stored on a local data storage device (e.g., 810), transmitted to a remote server, and/or may serve as input to another set of code instructions (e.g., further processing of the computed hierarchical communities).

Another implementation of the method described with reference to FIG. 7 is now described. The implementation is based on a greedy variant of the method described with reference to FIG. 7. For clarity and simplicity of explanation, the variations from the acts of the method described with reference to FIG. 7 are described. The greedy based computation, in which vertex moves are selected according to the most significant change in the local move modality value (e.g., greatest change) is sufficiently accurately in practice while providing linear time complexity, which provides for processing of very large graphs within a reasonable amount of time.

At 704, the set of possible moves of the graph vertices (denoted P) is computed in parallel. The set P includes conflicting moves that are not independent from one another. The conflicting moves, when performed in parallel and/or simultaneously, prevent graph convergence, or require significant time and/or computational resources to compute convergence.

A first vertex move is selected from the computed possible moves according to the local move modality value. The local move modality value may be computed by sorting the members of the set P according to decreasing order of change in the local move modality value, to obtain a sorted set (denoted as S), and selecting the first member of S having the highest change in the local move modality value.

Optionally, an empty emitter set (denoted as E), an empty acceptor set (denoted as A), and an empty decoupled moves set (denoted as D) are created. At 708, a first emitter community and a second acceptor community are designated according to the selected first vertex move. The emitter community denotes the origin of the vertex of the first vertex move and the acceptor community denotes the destination of the vertex of the first vertex move.

Optionally, the first emitter community is placed in set E, and the second acceptor community is placed in set

The following is iterated for the remaining moves for filtering edges of the directed Decoupled graph (D(G)): Another vertex move is selected from the computed possible moves according to the location move modality value. The other vertex move is filtered from consideration when the vertex from the other vertex move originates in one of the acceptor communities and terminates in one of the emitter communities. The filtering may be performed by checking whether the source communities (i.e., emitters) of the other vertex move conflict with sets E and A. The checking may be performed to determine whether the source community (i.e., emitter) of the other move does not already exist in set A, and/or whether the destination community (i.e. acceptor) of the other vertex move does not already exist in set E. Another emitter community and another acceptor community are designated according to the selected second vertex move when the selected second move does not pose a conflict with previously filtered moves. The designation of the selected second vertex move may be performed by adding the source community of the second move to the set E and adding the destination community of the second move to set A. The second vertex move (i.e., the decoupled move) is added to set D. When a conflict of the second vertex move with earlier vertex move is detected, the second vertex move is discarded.

The iteration is performed for the remaining moves according to decreasing order of change in the local move modality value, optionally according to the moves stored in set S. Set D is populated during the iterations. Set D is distributed over nodes 804 of distributed system 802 for updating the vertices of the marked graph (Gl) with community labels obtained from edges of the moves stored in set D.

At 710, the packed graph is created.

At 712, new local move modality values are computed for the packed graph, and blocks 704-710 are iterated. Reference is now made to FIG. 1 1, which is a schematic depicting the process of computing decoupled vertex moves based on the greedy variant of the method described with reference to FIG. 7, in accordance with some embodiments of the present invention. At 1 102, the set of possible moves of vertices of graph 1 104 P is computed in parallel. At 1 106, the sorted set S of potential vertex moves is created by sorting the members of the set P 1 102 according to decreasing order of change in the local move modality value. At 1 108, set D storing decoupled moves is created, as described herein. Set D 1 108 is distributed among nodes of the distributed system for performing the vertex updates, as described herein. Conflicting moves 1 1 10 are discarded, as described herein.

Reference is now made to FIG. 12, which is a schematic depicting parallel processing for computing hierarchical communities in a graph, based on the method described with reference to FIG. 7, and/or implemented by system 800 described with reference to FIG. 8, in accordance with some embodiments of the present invention. The process described with reference to FIG. 12 denotes optimization of the communities without depicting the graph aggregation phase. At 1202, the initial graph (G) is received, and marked graph (Gl) is computed, as described herein. At 1204, the marked graph (Gl) is distributed across nodes (denoted n) of the distributed computing system. At 1206, the possible vertex moves (denoted v) are computed by the nodes of the distributed computing system, as described herein. At 1208, the vertices of the marked graph (Gl) are updated by the nodes of the distributed computing system, as described herein. Schematic 1210 depicts the process of filtering edges of the directed Decoupling graph (D(G)) according to the local move modality value. At 1212, when the maximum number of iterations has not yet been reached, and/or communities have not yet converged, blocks 1204-1210 are iterated. Alternatively, at 1214, when the maximum number of iterations are reached and/or communities converted, the hierarchical communities are provided.

The method, code instructions, and/or acts executed by the system, as described herein, may be expressed in terms of sequential steps as follows, which further clarifies the parallel based processing described herein:

1. Set current iteration to 0. Distribute graph G across nodes (optionally all nodes) of the distributed computation system, optionally in a balanced manner.

2. Independently obtain a set P of possible vertex moves (optionally all moves) of the vertices (optionally all vertices) across communities in graph G on the nodes (optionally all nodes) in parallel.

3. When no moves are possible in step 2 go to step 7 otherwise go to step 4.

4. Create a directed Decoupling graph D from P with communities of G as vertices of D and vertex moves from P as edges of D.

5. Remove edges from graph D, such that any vertex in D has only incoming edges or only out-going edges.

6. Convert remaining edges of D into a set D of decoupled vertex moves in G, and distribute D over nodes (optionally all nodes) in the distributed system for updating community labels of vertices in parallel. Go to step 2.

7. Pack the graph G in parallel by merging vertices of common communities into a single vertex of a new graph G_p and by merging duplicate edges of G_p into singular edges with summarized weights.

8. Calculate initial modularity Q, of the packed graph in parallel.

9. When Qi > Qi - i or when = 0, set / to i + I, G to G_p and go to step 2, else go to step 10.

10. The outputted graph denotes the hierarchical communities.

The greedy based implementation of the method, code instructions, and/or acts executed by the system, as described herein, may be expressed in terms of sequential steps as follows. The greedy based implementation is based on computing modularity increment resulting from individual vertex moves to approximate the maximal global modularity gain. The greedy based implementation further clarifies the parallel based processing described herein.

1. Set current iteration to 0. Set graph G to input graph.

2. Obtain possible moves (optionally all possible moves), in parallel, of vertices (optionally all vertices) across communities in graph G.

3. When no moves are possible in step 2 go to step 8 otherwise go to step 4.

4. Sort possible moves according to decreasing moves' modularity increments denoted AQ. 5. Mark the first move (having the largest AQ) as decoupled and mark the current and new communities of the first move as emitter and acceptor accordingly.

6. Starting with the next move (i.e., second largest AQ), mark moves as decoupled when such the moving vertex does not leave communities-acceptors and does not enter communities-emitters of already decoupled moves. Mark the current and new communities based on the moving vertex as emitters and acceptors as discussed with reference to step 5.

7. When marking moves from the collection is completed, keep the decoupled moves, and discard other moves not designated as decoupled.

8. Pack the graph G in parallel: by merging vertices of common communities into a single vertex of a new graph G_p and by merging duplicate edges of G_p into singular edges with summarized weights.

9. Calculate initial modularity Q, of packed graph in parallel.

10. When Qi > Q, ./ or when i = 0, set i to i + 1, G to G_p and go to step 2, else go to step 1 1.

1 1. The outputted graph denotes the hierarchical communities.

Various implementations and aspects of the systems and/or methods and/or code instructions delineated hereinabove and as claimed in the claims section below find experimental support in the following examples.

EXAMPLES

Reference is now made to the following examples, which together with the above descriptions illustrate some implementations of the systems and/or methods and/or code instructions described herein in a non limiting fashion.

Reference is now made to FIG. 13, which is a table summarizing experimental results in which the systems, apparatus, methods, and/or code instructions described herein that perform parallel processing for identification of communities in a graph are compared to the sequential Louvain method (described herein), and the naive parallelization method implemented by parallelizing the Louvain method designed for sequential processing (described herein). Graphs were obtained from publicly available datasets, and custom created datasets. The na^'ive parallelization method is implemented in Apache Spark. The sequential Louvain method is written in the Scala language.

The slower behavior denoted by * is due to the Apache Spark overhead in very small tasks compared to the sequential JVM. Works** denotes that the sequential Louvain method either fails to run or doesn't complete execution in 24 hours.

Reference is now made to FIG. 14, which is a table summarizing computational performance of the systems, apparatus, methods, and/or code instructions described herein in identifying communities in Big Data graphs.

As discussed above, even though the decoupling act of the process of identifying the communities in the graph is performed on a single node or a single thread, potentially creating a sequential bottleneck since the act cannot be effectively parallelized, which may limit parallelization according to Amdahl's Law or Gustafson's law, according to the results presented in FIGs. 13-14, the sequential time of the decoupling act is diminished in comparison to the total runtime. For example, less than 5% (e.g., from 1 :600 to 1 :27 the portion of running). In practice the overhead resulting from the act of the process that is performed at the single node or thread may be considered tolerable or negligible.

Other systems, methods, features, and advantages of the present disclosure will be or become apparent to one with skill in the art upon examination of the following drawings and detailed description. It is intended that all such additional systems, methods, features, and advantages be included within this description, be within the scope of the present disclosure, and be protected by the accompanying claims.

The descriptions of the various embodiments of the present invention have been presented for purposes of illustration, but are not intended to be exhaustive or limited to the embodiments disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the described embodiments. The terminology used herein was chosen to best explain the principles of the embodiments, the practical application or technical improvement over technologies found in the marketplace, or to enable others of ordinary skill in the art to understand the embodiments disclosed herein. It is expected that during the life of a patent maturing from this application many relevant distributed systems will be developed and the scope of the term distributed system is intended to include all such new technologies a priori.

As used herein the term "about" refers to ± 10 %.

The terms "comprises", "comprising", "includes", "including", "having" and their conjugates mean "including but not limited to". This term encompasses the terms "consisting of and "consisting essentially of.

The phrase "consisting essentially of means that the composition or method may include additional ingredients and/or steps, but only if the additional ingredients and/or steps do not materially alter the basic and novel characteristics of the claimed composition or method.

As used herein, the singular form "a", "an" and "the" include plural references unless the context clearly dictates otherwise. For example, the term "a compound" or "at least one compound" may include a plurality of compounds, including mixtures thereof.

The word "exemplary" is used herein to mean "serving as an example, instance or illustration". Any embodiment described as "exemplary" is not necessarily to be construed as preferred or advantageous over other embodiments and/or to exclude the incorporation of features from other embodiments.

The word "optionally" is used herein to mean "is provided in some embodiments and not provided in other embodiments". Any particular embodiment of the invention may include a plurality of "optional" features unless such features conflict.

Throughout this application, various embodiments of this invention may be presented in a range format. It should be understood that the description in range format is merely for convenience and brevity and should not be construed as an inflexible limitation on the scope of the invention. Accordingly, the description of a range should be considered to have specifically disclosed all the possible subranges as well as individual numerical values within that range. For example, description of a range such as from 1 to 6 should be considered to have specifically disclosed subranges such as from 1 to 3, from 1 to 4, from 1 to 5, from 2 to 4, from 2 to 6, from 3 to 6 etc., as well as individual numbers within that range, for example, 1 , 2, 3, 4, 5, and 6. This applies regardless of the breadth of the range. Whenever a numerical range is indicated herein, it is meant to include any cited numeral (fractional or integral) within the indicated range. The phrases "ranging/ranges between" a first indicate number and a second indicate number and "ranging/ranges from" a first indicate number "to" a second indicate number are used herein interchangeably and are meant to include the first and second indicated numbers and all the fractional and integral numerals therebetween.

It is appreciated that certain features of the invention, which are, for clarity, described in the context of separate embodiments, may also be provided in combination in a single embodiment. Conversely, various features of the invention, which are, for brevity, described in the context of a single embodiment, may also be provided separately or in any suitable subcombination or as suitable in any other described embodiment of the invention. Certain features described in the context of various embodiments are not to be considered essential features of those embodiments, unless the embodiment is inoperative without those elements.

All publications, patents and patent applications mentioned in this specification are herein incorporated in their entirety by reference into the specification, to the same extent as if each individual publication, patent or patent application was specifically and individually indicated to be incorporated herein by reference. In addition, citation or identification of any reference in this application shall not be construed as an admission that such reference is available as prior art to the present invention. To the extent that section headings are used, they should not be construed as necessarily limiting.

Claims

WHAT IS CLAIMED IS:

1 . An apparatus (806) for determining communities within a graph G=(V,E) (812), with vertices V and edges E, the apparatus (806) being configured to:

compute, starting with a marked graph (G1=V1,E1), a packed graph in an iteration cycle, wherein the graph G=(V,E) acts as the marked graph for the first iteration of the iteration cycle, the packed graph acts as the marked graph for a next iteration of the iteration cycle, until a graph modularity value denoting connectivity of communities of the packed graph of a current iteration stabilizes or reverses relative to the graph modularity value of the previously computed packed graph,

wherein the apparatus is configured to compute the packed graph of each iteration recursively by:

obtaining all vertex moves between communities for each vertex v in VI of the marked graph (Gl), wherein a vertex move between any two communities is an edge e in El of the marked graph (Gl), connecting two vertices from the two communities;

when no vertex moves exist, stopping the iteration cycle, when at least one possible vertex move exists, creating a directed Decoupling graph (D(G1)) of communities of vertices from the obtained vertex moves between communities, wherein each vertex of the directed Decoupling graph (D(G1)) denotes a respective community of the marked graph, and the obtained vertex moves between communities are denoted as edges of the directed Decoupling graph (D(G1)),

filtering edges of the directed Decoupling graph (D(G1)) to obtain a filtered directed Decoupling graph (FD(G1)), wherein each vertex of the filtered directed Decoupling graph (FD(G1)) has only incoming or only outgoing edges, and updating vertices of the marked graph (Gl ) with community labels from edges of the filtered directed Decoupling graph FD(G1) to create an updated graph (Gl ');

create the packed graph of the current iteration by merging vertices of each community of the updated graph (Gl ') into a single vertex, and merging multiple edges between couples of vertices of the packed graph into a single edge between corresponding couples of vertices with summarized weight; and output the packed graph of the final iteration, the packed graph of the final iteration representing the computed hierarchical communities of the marked graph of the first iteration.

2. The apparatus (806) according to claim 1 , further configured to obtain the marked graph (Gl ) of the first iteration by initializing the vertices of the input graph (G) with community labels by placing each vertex into a respective community.

3. The apparatus (806) according to any of the previous claims, further configured to distribute the marked graph (Gl) across nodes (804) of a distributed computing system (802), and to obtain the possible vertex moves, wherein each node (804) computes the possible vertex moves for at least one distinct vertex of the marked graph (Gl ).

4. The apparatus (806) according to any of the previous claims, wherein the apparatus comprises a plurality of processors (808), the processors being configured to compute the packed graph in parallel, each processor performing for at least one distinct community, merging vertices of each community of the filtered directed Decoupling graph (D(G1)) into a single vertex, and merging duplicate edges of the packed graph into a single edge.

5. The apparatus (806) according to any of the previous claims, wherein the graph modularity denotes a global cost function indicative of density of edges between vertices within each community of the packed graph compared to density of edges between vertices of different communities of the packed graph.

6. The apparatus (806) according to any of the claims 4 to 5, wherein one of the processor (808) is further configured to select vertex moves from the computed possible moves between communities according to a local move modularity value computed for each vertex denoting the change in density of edges between vertices within the respective community of each vertex move, wherein the directed Decoupling graph (D(G1)) of communities of vertices is created according to the selected vertex moves.

7. The apparatus (806) according to claim 7, wherein the apparatus is configured to create and filter the directed Decoupling graph (D(G1)) by performing:

selecting a first vertex move from the computed possible moves according to a vertex move local modality value;

designating a first emitter community and a second acceptor community according to the selected first vertex move, wherein the emitter community denotes the origin of the vertex of the first vertex move and the acceptor community denotes the destination of the vertex of the first vertex move;

iterating for the remaining moves:

selecting another vertex move from the computed possible moves according to the local move modality value denoting the most significant change in density of edges from the remaining possible moves,

filtering the another vertex move from consideration when the vertex from the another vertex move originates in one of the acceptor communities and terminates in one of the emitter communities, and

designating another emitter community and another acceptor community according to the selected second vertex move.

8. A system (800) for determining communities within a graph G=(V,E), with vertices V and edges E, the system comprising:

the apparatus (806) according to one of claims 1 to 7;

a distributed system (802), comprising a plurality of nodes (804);

a graph repository (812); and

a user interface (814);

wherein the apparatus (806) is configured to:

receive a graph G=(V,E) from the graph repository (812); distribute the graph G across nodes (804) of the distributed system (802); receive from the distributed system (802) possible vertex moves of the graph G, computed for each vertex v of V in parallel by the nodes (804) of the distributed system (802), and determine communities within the graph G based on the received vertex moves.

9. A method of determining communities within a graph G=(V,E), with vertices V and edges E, the method comprising:

computing, starting with a marked graph (G1=V1 ,E1), a packed graph in an iteration cycle, wherein the graph G=(V,E) acts as the marked graph for the first iteration of the iteration cycle, the packed graph acts as the marked graph for a next iteration of the iteration cycle, until a graph modularity value denoting connectivity of communities of the packed graph of a current iteration stabilizes or reverses relative to the graph modularity value of the previously computed packed graph, wherein the packed graph of each iteration is computed recursively by: computing all vertex moves between communities for each vertex v in VI of the marked graph (Gl ), wherein a vertex move between any two communities is an edge e in El of the marked graph (Gl), connecting two vertices from the two communities (712);

when no vertex moves exist, stopping the iteration cycle, when at least one possible vertex move exists, creating a directed Decoupling graph (D(G1 )) of communities of vertices from the computed moves between communities, wherein each vertex of the directed Decoupling graph (D(G1)) denotes a respective community of the marked graph, and the computed moves between communities are denoted as edges of the directed Decoupling graph (D(G1)) (706),

filtering edges of the directed Decoupling graph (D(G1)) to obtain a filtered directed Decoupling graph (FD(G1)), wherein each vertex of the filtered directed Decoupling graph (D(G1)) has only incoming or only outgoing edges (708),

and updating vertices of the marked graph (Gl) with community labels from edges of the filtered directed Decoupling graph D(G1) to create an updated graph (Gl ');

creating the packed graph of the current iteration by merging vertices of each community of the updated graph (Gl ') into a single vertex, and merging multiple edges between couples of vertices of the packed graph into a single edge between corresponding couples of vertices with summarized weight (710); and

outputting the packed graph of the final iteration, the packed graph of the final iteration representing the computed hierarchical communities of the marked graph of the first iteration (714).

10. A computer-readable storage medium comprising instructions, which when executed by a computer, cause the computer to carry out the steps of the method of claim 9.

1 1. A computer program product comprising instructions, which when the program is executed by a computer, cause the computer to carry out the steps of the method of claim 9.