System for updating most influencing node of dynamic graph

Abstract

The invention provides a system for updating most influencing nodes of a dynamic graph. Methods and systems for identifying influencing nodes of a graph are also provided. The graph is represented by an adjacency matrix, and graph updates are represented using different sub-graphs corresponding to the graph. Each update of the graph is calculated by approximating partial spectral factorization data of a sub-graph of the graph using a previously stored adjacency matrix and information about additional nodes added to the sub-graph during the update. Each sub-graph is accessed only once. The most affecting node of the graph is identified based on the partial spectral factorization data.

Description

Background Art

[0001] The present disclosure generally relates to graph theory, and more particularly, to determining influential nodes in a graph using subgraph centrality metrics and partial spectral factorization.

[0002] Graph theory is the study of graphs, which are mathematical structures used to model pairwise relationships between objects. A graph in this context consists of vertices or nodes and lines called edges that connect them. Graphs are widely used in applications for modeling many types of relationships and process dynamics in physical, biological, social, and information systems. Thus, many practical problems in modern technology, science, and commercial applications can often be represented by graphs.

[0003] Node centrality is a widely used metric for determining the relative importance of a node within a complete network or graph. Centrality indicators assign a number or rank corresponding to its network position to the nodes within a graph. Node centrality can be used to determine which nodes are important in a complex network, to understand influencers, or to find hot links. For example, node centrality is commonly used to determine the degree of influence of a person within a social network, or in the theory of space syntax, how important a room is within a building or how well a road is used within an urban network.

[0004] Subgraph centrality is a widely used centrality metric for identifying the most influential nodes of a graph. When the graph is static and can fit into system memory, the subgraph centrality of each node is equal to the corresponding diagonal entry of the exponent of the adjacency matrix. However, many real-world graphs must be accessed from secondary memory or are updated over time since they are dynamic graphs. Summary of the Invention

[0005] According to aspects of the present disclosure, a computer-implemented method is provided that includes obtaining an adjacency matrix corresponding to a first subgraph of a graph. The adjacency matrix is used to calculate a function of the adjacency matrix based on partial spectral factorization data of a previously stored adjacency matrix for a second subgraph of the graph, and updating data associated with additional nodes of the first subgraph. The second subgraph is a subset of the first subgraph.

[0006] In other aspects of the present disclosure, a computer-implemented method for updating a dynamic graph is provided, which includes obtaining an adjacency matrix of a first subgraph of the dynamic graph at time step t+1. The method further includes accessing a projection matrix of an adjacency matrix of a second subgraph of the dynamic graph stored previously. The accessed projection matrix together with the previously stored adjacency matrix corresponds to the previous time step t, and the accessed projection matrix together with the updated data of the dynamic graph received at time step t+1 are used to approximate the projection matrix of the adjacency matrix at time step t+1. The approximated projection matrix is in turn used to approximate the leading eigenpairs of the adjacency matrix at time step t+1. Then the dynamic graph is updated based on the approximated leading eigenpairs, and then the updated dynamic graph is stored.

[0007] In other aspects of the present disclosure, a system is provided. The system includes circuitry configured to obtain an adjacency matrix corresponding to a first subgraph of a graph. The circuitry is further configured to calculate a function of the adjacency matrix based on previously stored partial spectral factorization data of an adjacency matrix of a second subgraph of the graph, and update data associated with additional nodes of the first subgraph. The second subgraph is a subset of the first subgraph.

[0008] In other aspects of the present disclosure, a computer program product for calculating a function of an adjacency matrix is provided. The computer program product includes a computer-readable storage medium having program instructions. The program instructions are executable by the system to cause the system to obtain an adjacency matrix corresponding to a first subgraph of a graph. The program instructions are executable by the system to cause the system to calculate a function of the adjacency matrix based on previously stored partial spectral factorization data of an adjacency matrix of a second subgraph of the graph, and update data associated with additional nodes of the first subgraph.

[0009] Additional technical features and benefits are achieved through the technical implementation of the present invention. Embodiments and aspects of the present disclosure are described in detail herein and are considered to be part of the claimed subject matter. For a better understanding, reference is made to the detailed description and the drawings. BRIEF DESCRIPTION OF THE DRAWINGS

[0010] The following description will provide details of the preferred embodiments with reference to the following drawings, wherein:

[0011] Figure 1 is a block diagram of a computing environment for calculating a graph function according to an embodiment of the present disclosure;

[0012] Figure 2 is a block diagram of an environment for calculating a graph function according to an embodiment of the present disclosure;

[0013] Figure 3 is a diagram of a graph that evolves dynamically over time according to an embodiment of the present disclosure;

[0014] Figure 4A flowchart of an exemplary method for computing a graph function according to an embodiment of the present disclosure;

[0015] Figure 5 A diagram showing projection data calculation for computing a graph function by an improved graph function calculator according to an embodiment of the present disclosure;

[0016] Figure 6 A flowchart of a method for computing a graph function according to an embodiment of the present disclosure;

[0017] Figure 7 A flowchart of a method for computing a graph function according to an embodiment of the present disclosure;

[0018] Figure 8 A diagram of an example algorithm for identifying the most influential nodes of a dynamic graph according to an embodiment of the present disclosure; and

[0019] Figure 9 A flowchart of a method for updating a dynamic graph according to an embodiment of the present disclosure. Detailed Description

[0020] In graph theory and network analysis, centrality indicators assign numbers or ranks to nodes within a graph corresponding to their network positions. Subgraph centrality is a widely used centrality measure for identifying the most influential nodes (or vertices) of a graph. When the graph is static and can fit within system memory, the subgraph centrality of each node is equal to the corresponding diagonal entry of the exponent of the adjacency matrix. However, many real-world graphs are either accessed from secondary memory or updated over time. Additionally, in the case of dynamic graphs, i.e., graphs that are dynamically created and updated, their corresponding adjacency matrices may not fit within system memory due to their large and dynamically changing sizes.

[0021] A common operation involving any graph (specifically, a dynamic graph) is to identify the most influential nodes of the graph (network) for performing graph analysis. Each node of the graph is associated with a real scalar called a centrality score, and the goal is to identify the N ∈ N nodes of the graph with the largest centrality scores (top N recommendations). Some applications of top-N centrality include identifying the most influential nodes in a social network, the main hubs of a road and city network, and the most important proteins in a cellular network. There are different types of centrality measures that are used as computational metrics to quantify the relative importance of each node of a graph in an application. Some of these types of centrality measures include degree centrality, betweenness centrality, eigenvector centrality, closeness centrality, PageRank centrality, etc. Another centrality measure is subgraph centrality, which quantifies the number of closed walks starting and ending at that node. Subgraph centrality gives a measure of the participation of a node in multiple subgraphs within the graph.

[0022] In one or more embodiments of the present disclosure, for the graph computing exponential subgraph centrality measure, it is further used to calculate the most influential nodes of a graph. The subgraph centrality measure is used to analyze networks from a diverse range of applications, including but not limited to biology, neuroscience, and economics. Given an undirected graph with n ∈ N nodes associated with an n×n adjacency matrix A, the subgraph centrality of the i-th graph vertex is equal to the magnitude of the i-th diagonal entry of the matrix exponential e A of.

[0023] For small graphs, calculating the subgraph centrality of each vertex can be achieved by matrix diagonalization at a cost of O(n 3 ). However, graphs arising from modern data analysis tasks are typically characterized by a large number of vertices and edge connections, thus making the cubic complexity of the exact subgraph centrality calculation quite expensive. This also leads to problems where the graph is not suitable for system memory or is not in the core due to its large size and high computational complexity.

[0024] In one or more embodiments of the present disclosure, a method is provided for approximately identifying the most influential nodes of a graph G when only a small subset of the rows of the adjacency matrix A of the graph G can reside in the system memory at any given time.

[0025] In one or more embodiments of the present disclosure, a method is provided for calculating centrality scores, particularly subgraph centrality scores of different nodes of a graph, in an application where the graph evolves dynamically over different time steps.

[0026] In one or more embodiments of the present disclosure, a method is provided for identifying the most influential nodes (i.e., the top N recommendations) of a graph by accessing each submatrix (for subgraphs) of the adjacency matrix only once. To achieve this, information on matrix updates is accumulated by updating partial spectral factorization data of the adjacency matrix via Rayleigh-Ritz projection.

[0027] One or more embodiments of the present disclosure as disclosed herein provide a reduced computational complexity associated with graph updates. In one or more embodiments, the computational complexity is on the order of linear complexity rather than the cubic complexity of traditional methods, thereby saving and enhancing the performance of the computational resources of the application. Additionally, in one or more embodiments of the present disclosure, the memory requirements associated with storing large and complex dynamically evolving graphs are simplified since the updated data is accessed only once for each graph update.

[0028] According to one aspect of the present disclosure, a computer-implemented method is provided. The computer-implemented method includes obtaining an adjacency matrix corresponding to a first subgraph of a graph. The computer-implemented method includes calculating a function of the adjacency matrix based on previously stored partial spectral factorization data for an adjacency matrix of a second subgraph of the graph, and updating data associated with nodes added to the second subgraph to obtain the first subgraph. The second subgraph is a subset of the first subgraph. Calculating the function of the adjacency matrix based on the partial spectral factorization data only requires accessing each adjacency matrix once, which is computationally less costly and enables very large graphs to be stored in system memory as well, since only the updated data for such graphs, which is also in the form of partial spectral factors, needs to be updated.

[0029] In various embodiments, the adjacency matrix of the first subgraph is associated with the state of the graph at a current time instance, and the previously stored adjacency matrix of the second subgraph is associated with the state of the graph at a previous time instance, such that the previous time instance is earlier than the current time instance. As a result, in order to calculate any function on the adjacency matrix, only the calculations related to the updated data need to be re-executed, while the previously stored data is stored compactly using partial spectral factors.

[0030] In various embodiments, the calculated function is used to calculate subgraph centrality data of the graph. Subgraph centrality is used to determine the top N node sets of the graph. The top N node sets are the nodes of the graph having indices associated with the highest subgraph centrality data. This dataset of the top N nodes provides a dataset that is connected to most of the other nodes of the graph stored in the database. This dataset of the top N nodes can be stored in the database as the most influential nodes of the graph and can be used in different types of computational applications related to accessing data of the influential nodes of the graph, such as protein analysis computational applications, social networking platforms, content platforms for authors, etc.

[0031] In various embodiments, the graph is a dynamic graph, and the top N node sets are the most influential nodes of the dynamic graph. A dynamic graph includes frequently updated data, and thus efficient calculations are required, for example, when updating each time, recalculating the most influential nodes. Therefore, using the top N node sets calculated by subgraph centrality based on partial spectral factorization data is faster and computationally efficient.

[0032] In various embodiments, the dynamic graph corresponds to a graph approximation of a social network, such that the nodes of the dynamic graph represent users of the social network, and the edges of the dynamic graph represent connections between users of the social network, and further such that the most influential nodes of the dynamic graph represent users of an influencer user type in the social network. The social network may be implemented as a social network platform that stores data of users of the social network in a database. The graph approximation of the dynamic graph is stored in the database and is accessed whenever a request is received to access data of the most influential nodes of the graph. Such a request may be received from a computing device through which a user accesses a social network application hosted by the social network platform.

[0033] In various embodiments, based on Rayleigh-Ritz projection calculations, partial spectral factorization data is determined based on calculating a projection matrix of the adjacency matrix of a first subgraph. The Rayleigh-Ritz projection calculations include calculating Ritz pairs, which are further used as approximations of the leading eigenvalues of the adjacency matrix. The problem of k-subgraph centrality is substantially equivalent to calculating the k algebraic leading eigenpairs of the adjacency matrix. The use of Rayleigh-Ritz projection calculations transforms the complexity of the calculation of subgraph centrality into the calculation of leading approximate eigenpairs, which can be done using a sparse eigenvalue solver. Thus, the computational complexity of calculating subgraph centrality is reduced by using Rayleigh-Ritz projection calculations.

[0034] In various embodiments, a computer-implemented method includes receiving updated data associated with nodes added to a second subgraph at time instance t+1. Further, a projection matrix of the adjacency matrix at time instance t+1 is calculated based on Rayleigh-Ritz projection calculations. For the projection matrix, k leading eigenpairs are calculated. The computer-implemented method includes determining k leading Ritz pairs of the k leading eigenpairs of the projection matrix and then updating t+1. The above steps are repeated until a specified end condition is reached. As the graph data remains dynamically updated, this repetition provides an iterative calculation of the k leading eigenpairs. This helps to maintain up-to-date data on the k leading eigenpairs of the graph, which can be used to perform further calculations in real time, such as calculating subgraph centrality.

[0035] In various embodiments, the specified end condition is based on the availability of updated data of the graph. As a result, as long as an update to the graph is received, the most up-to-date influential node data is effectively calculated and stored in a database or memory storing the graph data.

[0036] In various embodiments, when the end condition is reached, the subgraph centrality of the graph is calculated based on determining the k leading Ritz pairs. This ensures that the problem of calculating subgraph centrality is a convergent problem.

[0037] In various embodiments, calculating the projection matrix of an adjacency matrix includes, at time instance t+1, calculating the k leading Ritz pairs of the projection matrix to be the same as the k leading eigenpairs of the adjacency matrix. This provides a method for identifying the k leading Ritz pairs of the projection matrix to be used in subgraph centrality calculations. Calculating the k leading Ritz pairs in this manner has a high precision value associated with the identification of the most influential nodes of the graph.

[0038] In various embodiments, calculating the projection matrix of an adjacency matrix includes calculating the k leading eigenpairs of the adjacency matrix based on Schur components. This method provides a precision value of nearly 70% when identifying the most influential nodes in a graph.

[0039] In various embodiments, calculating the projection matrix of an adjacency matrix includes calculating a matrix formed by computing the orthogonal basis components of the k leading eigenpairs of the adjacency matrix. This method provides a high precision value associated with the identification of the most influential nodes of the graph.

[0040] In various embodiments, calculating the projection matrix of an adjacency matrix includes using the K leading eigenvectors of a symmetric matrix to approximate the k leading eigenpairs of the adjacency matrix. This method provides a high precision value associated with the identification of the most influential nodes of the graph.

[0041] In various embodiments, a previously stored adjacency matrix corresponds to a previous time instance t, and this adjacency matrix corresponds to a subsequent time instance t+1. This provides access to each submatrix of the adjacency matrix only once.

[0042] According to aspects of the present disclosure, a computer-implemented method for updating a dynamic graph is provided. The computer-implemented method includes obtaining, at time step t+1, the adjacency matrix of a first subgraph of the dynamic graph. The computer-implemented method includes accessing the projection matrix of the adjacency matrix of a second subgraph of the previously stored dynamic graph. The computer-implemented method includes approximating the projection matrix of the adjacency matrix at time step T+1 based on the accessed projection matrix of the previously stored adjacency matrix at time step T, and updating the data of the dynamic graph received at time step T+1. The computer-implemented method includes approximating the leading eigenpairs of the adjacency matrix at the time step t+1 based on the approximated projection matrix. The computer-implemented method includes updating the dynamic graph based on the approximated leading eigenpairs. The computer-implemented method includes storing the updated dynamic graph. The computer-implemented method provides a computationally efficient calculation of the most influential nodes of the dynamic graph, which also stays up-to-date by accessing the memory storing the dynamic graph in an efficient manner.

[0043] According to aspects of the present disclosure, a system is provided. The system includes circuitry configured to obtain an adjacency matrix corresponding to a first subgraph of a graph. The circuitry is further configured to calculate a function of the adjacency matrix for a second subgraph of the graph based on previously stored partial spectral factorization data of the adjacency matrix of the graph, and update data associated with nodes added to the second subgraph to obtain the first subgraph, where the second subgraph is a subset of the first subgraph. The system provides a computing device and / or software program configured to efficiently calculate data of the most influential nodes of a graph, which is a computational approximation of a real-world application such as a social network application, a protein analysis computational application, etc.

[0044] According to aspects of the present disclosure, a computer program product for calculating a function of an adjacency matrix is provided. The computer program product includes a computer-readable storage medium having program instructions embodied therewith, the program instructions executable by a system to cause the system to obtain an adjacency matrix corresponding to a first subgraph of a graph. The system is further caused to calculate a function of the adjacency matrix based on previously stored partial spectral factorization data of the adjacency matrix of a second subgraph of the graph, and update data associated with nodes added to the second subgraph to obtain the first subgraph, where the second subgraph is a subset of the first subgraph. The computer program product thus provides a computing device and / or software program configured to efficiently calculate data of the most influential nodes of a graph, which is a computational approximation of a real-world application such as a social network application, a protein analysis computational application, etc.

[0045] Aspects of the present disclosure are described by narrative text, flowcharts, block diagrams of computer systems, and / or block diagrams of machine logic included in embodiments of a computer program product (CPP). With respect to any flowchart, depending on the technology involved, operations may be performed in an order different from the order shown in a given flowchart. For example, again depending on the technology involved, two operations shown in consecutive flowchart blocks may be performed in reverse order, as a single integrated step, simultaneously, or in a manner that at least partially overlaps in time.

[0046] A computer program product embodiment (“CPP embodiment” or “CPP”) is a term used in this disclosure to describe any collection of one or more storage media (also referred to as “media”) that are jointly included in a collection of one or more storage devices, the collection of one or more storage devices jointly including machine-readable code corresponding to instructions and / or data for performing computer operations specified in a given CPP claim. A “storage device” is any tangible device that can hold and store instructions used by a computer processor. By way of non-limitation, computer-readable storage media can be electronic storage media, magnetic storage media, optical storage media, electromagnetic storage media, semiconductor storage media, mechanical storage media, or any suitable combination of the foregoing. Some known types of storage devices that include these media include: magnetic disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), compact disc read-only memory (CD-ROM), digital versatile disc (DVD), memory stick, floppy disk, mechanically encoded devices such as punch cards or pits / lands formed in the main surface of a disc, or any suitable combination of the foregoing. Computer-readable storage media, as the term is used in this disclosure, should not be construed as storing in the form of a transient signal per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide, optical pulses passing through an optical fiber cable, electrical signals transmitted through a wire, and / or other transmission media. As will be understood by those skilled in the art, data is typically moved at certain incidental points in time during the normal operation of a storage device, such as during access, defragmentation, or garbage collection, but this does not make the storage device transient because the data is not transient when it is stored.

[0047] Figure 1 is a block diagram showing a computing environment for computing graph functions according to an embodiment of the present disclosure. Refer to Figure 1, shows a computing environment 100, which includes an example of an environment for executing at least some of the computer code involved in performing the methods of the present invention, such as an improved graph function calculator 120B. In addition to block 120B, the computing environment 100 includes, for example, a computer 102, a wide area network (WAN) 104, an end-user device (EUD) 106, a remote server 108, a public cloud 110, and a private cloud 112. In this embodiment, the computer 102 includes a set of processors 114 (including processing circuitry 114A and cache 114B), a communication structure 116, volatile memory 118, a permanent storage device 120 (including an operating system 120A and block 120B, as described above), a set of peripheral devices 122 (including a set of user interface (UI) devices 122A, a storage device 122B, and a set of Internet of Things (IoT) sensors 122C), and a network module 124. The remote server 108 includes a remote database 108A. The public cloud 110 includes a gateway 110A, a cloud coordination module 110B, a set of host physical machines 110C, a set of virtual machines 110D, and a set of containers 110E.

[0048] The computer 102 can take the form of a desktop computer, a laptop computer, a tablet computer, a smart phone, a smart watch or other wearable computer, a mainframe computer, a quantum computer, or any other form of computer or mobile device that is now known or will be developed in the future and is capable of running programs, accessing networks, or querying databases such as the remote database 108A. As is well known in the computer technology field and depending on the technology, the performance of computer-implemented methods can be distributed among multiple computers and / or among multiple locations. On the other hand, in this presentation of the computing environment 100, the detailed discussion focuses on a single computer, specifically the computer 102, to keep the presentation as simple as possible. The computer 102 can be located in the cloud, even if Figure 1 it is not shown in the cloud in the figure. On the other hand, the computer 102 does not need to be in the cloud, unless to any extent that can be definitely indicated.

[0049] The processor set 114 includes one or more computer processors of any type now known or to be developed in the future. The processing circuitry 114A may be distributed across multiple packages, such as multiple cooperating integrated circuit chips. The processing circuitry 114A may implement multiple processor threads and / or multiple processor cores. The cache 114B may be memory located within the processor chip package and is generally used for data or code that should be made available for rapid access by threads or cores running on the processor set 114. The cache memory is typically organized into multiple levels based on its relative proximity to the processing circuitry 114A. Alternatively, some or all of the cache 114B of the processor set 114 may be located "off-chip". In some computing environments, the processor set 114 may be designed to work with qubits and perform quantum computing.

[0050] Computer-readable program instructions are typically loaded onto the computer 102 so that a series of operational steps are performed by the processor set 114 of the computer 102 and thereby implement a computer-implemented method such that the instructions so executed will instantiate the method specified in the flowchart and / or the narrative description of the computer-implemented method included in this document (collectively referred to as "the method of the present invention"). These computer-readable program instructions are stored in various types of computer-readable storage media, such as the cache 114B and other storage media discussed below. The program instructions and associated data are accessed by the processor set 114 to control and direct the execution of the method of the present invention. In the computing environment 100, at least some of the instructions for executing the method of the present invention may be stored in the permanent storage device 120 in block 120B.

[0051] The communication structure 116 is a signal conduction path that allows the various components of the computer 102 to communicate with each other. Typically, this structure consists of switches and conductive paths, such as switches and conductive paths that make up a bus, a bridge, a physical input / output port, etc. Other types of signal communication paths may be used, such as fiber optic communication paths and / or wireless communication paths.

[0052] The volatile memory 118 is any type of volatile memory now known or to be developed in the future. Examples include dynamic random access memory (RAM) or static RAM. Typically, volatile memory 118 is characterized by random access, but this is not required unless expressly indicated. In the computer 102, the volatile memory 118 is located within a single package and inside the computer 102, but alternatively or additionally, the volatile memory 118 may be distributed across multiple packages and / or be located external to the computer 102.

[0053] The permanent memory 120 is any form of non-volatile memory for a computer that is known now or developed in the future. The non-volatility of this memory means that the stored data is retained regardless of whether power is supplied to the computer 102 and / or directly to the permanent memory 120. The permanent memory 120 can be a read-only memory (ROM), but generally at least a portion of the permanent memory 120 allows for the writing, deletion, and re-writing of data. Some common forms of persistent storage devices 120 include magnetic disks and solid-state storage devices. The operating system 120A can take several forms, such as various known proprietary operating systems or open-source portable operating system interface type operating systems that employ a kernel. The improved graphing calculator includes code contained in block 120B, which generally includes at least some of the computer code involved in performing the methods of the present invention.

[0054] The peripheral device set 122 includes the peripheral device set of the computer 102. Data communication connections between the peripheral devices and other components of the computer 102 can be implemented in various ways, such as Bluetooth connections, near-field communication (NFC) connections, connections made by cables (such as universal serial bus (USB)-type cables), plug-in connections (e.g., Secure Digital (SD) cards), connections made through a local communication network, and even connections made through a wide area network such as the Internet. In various embodiments, the UI device set 122A can include components such as a display screen, speakers, microphones, wearable devices (such as goggles and smartwatches), keyboards, mice, printers, touchpads, game controllers, and haptic devices. The memory 122B is an external memory, such as an external hard drive, or a pluggable memory, such as an SD card. The storage device 122B can be permanent and / or volatile. In some embodiments, the storage device 122B can take the form of a quantum computing storage device for storing data in the form of qubits. In embodiments where the computer 102 needs to have a large amount of storage (e.g., in the case where the computer 102 locally stores and manages a large database), this storage can be provided by a peripheral storage device designed to store a very large amount of data, such as a storage area network (SAN) shared by multiple geographically distributed computers. The IoT sensor set 122C consists of sensors that can be used in Internet of Things applications. For example, one sensor can be a thermometer, and another sensor can be a motion detector.

[0055] The network module 124 is a collection of computer software, hardware, and firmware that allows the computer 102 to communicate with other computers via the WAN 104. The network module 124 can include hardware, such as a modem or a Wi-Fi signal transceiver, software for packetizing and / or depacketizing data transmitted over the communication network, and / or web browser software for transmitting data over the Internet. In some embodiments, the network control function and the network forwarding function of the network module 124 are executed on the same physical hardware device. In other embodiments (e.g., embodiments utilizing software-defined networking (SDN)), the control function and the forwarding function of the network module 124 are executed on physically separate devices, such that the control function manages several different network hardware devices. The computer-readable program instructions for performing the methods of the present invention can generally be downloaded to the computer 102 from an external computer or an external storage device via a network adapter or a network interface included in the network module 124.

[0056] The WAN 104 is any wide area network (e.g., the Internet) capable of transmitting computer data over non-local distances via any technology, now known or hereafter developed, for transmitting computer data. In some embodiments, the WAN 104 can be replaced and / or supplemented by a local area network (LAN) designed to transmit data between devices located in a local area, such as a Wi-Fi network. The WAN 104 and / or the LAN generally includes computer hardware, such as copper transmission cables, fiber optic transmissions, wireless transmissions, routers, firewalls, switches, gateway computers, and edge servers.

[0057] The end user device (EUD) 106 is any computer system used and controlled by an end user (e.g., a customer of an enterprise operating the computer 102) and can take any form discussed above in connection with the computer 102. The EUD 106 typically receives useful and beneficial data from the operation of the computer 102. For example, in the hypothetical case where the computer 102 is designed to provide recommendations to an end user, the recommendation will typically be transmitted from the network module 124 of the computer 102 to the EUD 106 via the WAN 104. In this way, the EUD 106 can display or present the recommendation to the end user. In some embodiments, the EUD 106 can be a client device, such as a thin client, a thick client, a mainframe computer, a desktop computer, etc.

[0058] The remote server 108 is any computer system that provides at least some data and / or functionality to the computer 102. The remote server 108 may be controlled and used by the same entity that operates the computer 102. The remote server 108 represents a machine that collects and stores useful data for use by other computers such as the computer 102. For example, in the hypothetical case where the computer 102 is designed and programmed to provide recommendations based on historical data, then the historical data may be provided to the computer 102 from the remote database 108A of the remote server 108.

[0059] The public cloud 110 is any computer system that can be used by multiple entities, which provides on-demand availability of computer system resources and / or other computing capabilities (especially data storage (cloud storage) and computing power), without direct active management by the user. Cloud computing typically leverages the sharing of resources to achieve consistency and economy of scale. The direct and active management of the computing resources of the public cloud 110 is performed by the computer hardware and / or software of the cloud coordination module 110B. The computing resources provided by the public cloud 110 are typically implemented by virtual computing environments running on various computers that make up the set of host physical machines 110C, which is the universe of physical computers within and / or available for the public cloud 110. The virtual computing environment (VCE) typically takes the form of virtual machines from the set of virtual machines 110D and / or containers from the set of containers 110E. It should be understood that these VCEs can be stored as images and can be transferred between various physical machine hosts as images or after instantiation of the VCE. The cloud coordination module 110B manages the transfer and storage of images, deploys new instantiations of the VCE, and manages the active instantiations of the VCE deployment. The gateway 110A is a collection of computer software, hardware, and firmware that allows the public cloud 110 to communicate via the WAN 104.

[0060] Some further explanations of the virtualized computing environment (VCE) will now be provided. The VCE can be stored as an "image". New active instances of the VCE can be instantiated from the image. Two common types of VCEs are virtual machines and containers. A container is a VCE that uses operating system-level virtualization. This refers to an operating system feature where the kernel allows for the existence of multiple isolated user space instances, called containers. From the perspective of the programs running within them, these isolated user space instances typically behave as actual computers. A computer program running on a normal operating system can utilize all the resources of that computer, such as connected devices, files and folders, network shares, CPU capabilities, and quantifiable hardware capabilities. However, a program running within a container can only use the contents of the container and the devices allocated to the container, which is a feature known as containerization.

[0061] A private cloud 112 is similar to a public cloud 110, except that the computing resources are only available for use by a single enterprise. Although the private cloud 112 is depicted as communicating with the WAN 104, in other embodiments, the private cloud can be completely disconnected from the Internet and only accessible through a local / private network. A hybrid cloud is a combination of multiple clouds of different types (e.g., private, community, or public cloud types) that are typically implemented by different vendors. Each of the multiple clouds remains a separate and discrete entity, but the larger hybrid cloud architecture is bound together by standardized or proprietary technologies that enable coordination, management, and / or data / application portability between the multiple constituent clouds. In this embodiment, both the public cloud 110 and the private cloud 112 are part of a larger hybrid cloud.

[0062] In one or more embodiments of the present disclosure, the computer 102 is used to store improved graph computing functions 120B that provide function computing for graphs. These functions include, but are not limited to, the previously defined centrality metrics, particularly subgraph centrality.

[0063] Figure 2 is a block diagram of an environment for computing graph functions according to an embodiment of the present disclosure. Explained in conjunction with Figure 1 the elements of Figure 2 . Refer to Figure 2 , which shows a graph of the network environment 200. The network environment 200 includes a system 202, a display screen 204, a server 206, and a user 208. The network environment 200 may further include Figure 1 the EUD 106 and the WAN 104 of Figure 1 . In one embodiment, the system 202 may be an example of the computer 102 of

[0064] In an embodiment of the present invention, the system 202 includes an application installed on the computer 102 and is accessed by a user associated with the EUD106.

[0065] In an embodiment of the present disclosure, the system 202 may include appropriate logic, circuits, interfaces, and / or code that can be configured to compute graph functions.

[0066] Examples of the system 202 may include, but are not limited to, computing devices, virtual computing devices, mainframes, servers, computer workstations, smart phones, cellular phones, mobile phones, gaming devices, consumer electronics (CE) devices, and / or any other devices with tracking computing capabilities.

[0067] The EUD 106 may include appropriate logic, circuitry, interfaces, and / or code that may provide an adjacency matrix as user input to the system 202. In another embodiment, the EUD 106 may be configured to output a computed graphical function of the adjacency matrix on the display screen 204. Specifically, the system 202 may control the display screen 204 of the EUD 106 to display the computed graphical function of the adjacency matrix on the display screen 204. The EUD 106 may be associated with a user 208 who may desire to compute graphical functions to generate solutions to graph analysis problems. Examples of the EUD 106 may include, but are not limited to, computing devices, mainframe machines, servers, computer workstations, smart phones, cellular phones, mobile phones, gaming devices, consumer electronics (CE) devices, and / or any other devices having graphical function computing capabilities.

[0068] The display screen 204 may include appropriate logic, circuitry, and interfaces that may be configured to display graphical functions of graph analysis problems. In an embodiment, the display screen 204 may further display one or more user interface elements from which the user 208 may provide user input. In some embodiments, the display screen 204 may be an external display device associated with the EUD 106. The display screen 204 may be a touch screen that may enable the user to provide user input via the display screen 204. The touch screen may be at least one of a resistive touch screen, a capacitive touch screen, or a thermal touch screen. The display screen 204 may be implemented by several known techniques, such as, but not limited to, a liquid crystal display (LCD) monitor, a light emitting diode (LED) monitor, a plasma monitor, or an organic LED (OLED) display technology, or at least one of other display devices. According to an embodiment, the display screen 204 may refer to the display screen of a head-mounted device (HMD), a smart glass device, a see-through display, a projection-based display, an electrochromic display, or a transparent display.

[0069] The server 206 may include appropriate logic, circuitry, and interfaces and / or code that may be configured to store the graph 200 and its data. The server 206 may further be configured to store the computation results of graphical functions, such as the projection matrix of the graph 200, an approximate graph, graph update data, etc. The server 206 may be implemented as a cloud server and may perform operations via web applications, cloud applications, HTTP requests, repository operations, file transfers, etc. Other example implementations of the server 206 may include, but are not limited to, database servers, file servers, web servers, media servers, application servers, mainframe servers, or cloud computing servers.

[0070] In at least one embodiment, the server 206 can be implemented as a plurality of distributed cloud-based resources by using several techniques known to those of ordinary skill in the art. Those of ordinary skill in the art will understand that the scope of the present disclosure may not be limited to implementing the server 206 and the system 202 as two separate entities. In certain embodiments, without departing from the scope of the present disclosure, the functions of the server 206 can be wholly or at least partially incorporated into the system 202, and vice versa.

[0071] In operation, the user 208 may wish to solve a graph analysis problem. A graph analysis problem can correspond to a class of computational problems that may involve studying and mapping insights from a graph.

[0072] In one embodiment, the graph analysis problem can be associated with real-world problems because the graph analysis problem can provide a powerful framework for modeling, understanding, and solving complex problems that may involve relationships, connections, and interactions between entities.

[0073] In an embodiment of the present disclosure, when the graph represents a dynamic graph, the graph analysis problem can include the analysis of the dynamic graph.

[0074] In an embodiment of the present disclosure, the dynamic graph corresponds to a graph approximation of a social network, such that the nodes of the dynamic graph represent users of the social network, and the edges of the dynamic graph represent the connections between the users of the social network, and further such that the most influential nodes of the dynamic graph represent users of the influencer user type in the social network. The edges of the dynamic graph represent the friendship relationships between the users of the social network. In this dynamic graph, adding a user to the network is equivalent to adding a new node, and adding a friend means inserting a new edge.

[0075] In an embodiment of the present invention, the above-mentioned dynamic graph corresponds to a road network. The nodes of such a dynamic graph are destinations, and the connections between the destinations (e.g., connections via different paths) are the edges of the dynamic graph. The most influential nodes of the dynamic graph can then represent the main centers of the road network that experience high traffic / human flow.

[0076] In an embodiment of the present disclosure, the dynamic graph corresponds to a collaboration network. The nodes of the dynamic graph can be authors, and the edges represent papers (or collaborations between different authors). The most influential nodes of the dynamic graph can then represent the most influential authors.

[0077] In an embodiment of the present disclosure, the dynamic graph corresponds to a protein network. The nodes of the dynamic graph represent proteins, and the edges of the dynamic graph represent the interactions between proteins. The most influential nodes of the dynamic graph can then represent the most important proteins.

[0078] In one or more embodiments of the present disclosure, a dynamic graph evolves dynamically at different time steps. Since nodes are added to (or removed from) the dynamic graph at different time steps, the dynamic graph has different states at different time steps. For real-time applications that use a dynamic graph, information about the state of the dynamic graph at different time steps forms graph update data. For most real-time applications, it is necessary to accurately and efficiently accumulate the graph update data. Figure 3 Shows such a graph that evolves dynamically over time.

[0079] Figure 3 Is a diagram of the graph 300 that evolves dynamically over time. In one or more embodiments of the present disclosure, the graph 300 represents a dynamic graph (hereinafter, the terms dynamic graph and graph 300 will be used interchangeably within the scope of the present disclosure).

[0080] As Figure 3 Shown, the graph 300 has a state 302 at time step t, which is represented by the subgraph In addition, the graph 300 has a state 304 at time step t + 1, which is represented by the subgraph The subgraph Is the first subgraph of the graph 300, and the subgraph Is the second subgraph of the graph 300. Each of the first subgraph and the second subgraph has one or more nodes.

[0081] The subgraph Has four nodes - node a, node b, node c, and node d, and the subgraph Has seven nodes, four previous nodes - node a, node b, node c, and node d, and three additional nodes – node e, node f, and node g. The connections between the nodes represent edges. At time step t + 1, three additional nodes e, f, and g are added to the subgraph To obtain the subgraph In addition, the data including the three additional nodes is the update data associated with the (three) additional nodes that are added to the second subgraph To obtain the first subgraph Such that the second subgraph Is a subset of the first subgraph Those of ordinary skill in the art can understand that, for the sake of brevity,

[0082] The number of nodes shown in the diagrams of Figure 3 Is limited. However, Figure 3 Such diagrams depicted in Can have any number of nodes in equivalent applications without departing from the scope of the present disclosure.

[0083] In an embodiment of the present disclosure, FIG. 300 is stored in computer 102, such as in the persistent storage device 120 of computer 102.

[0084] In another embodiment of the present disclosure, FIG. 300 is stored in remote server 108, such as in remote database 108A, and is accessed from computer 102.

[0085] In an embodiment of the present disclosure, computer 102 accesses applications, such as social networking sites, navigation and mapping services, bioinformatics analysis applications, business analysis applications, an analysis platform hosting an analytics service, enterprise resource management applications, applications related to the management of data in a data center, financial applications, etc. The applications store data required to implement different functions of the applications in the form of FIG. 300, particularly in the form of a dynamic graph.

[0086] In an embodiment of the present disclosure, FIG. 300 is used for analysis, and thus the data of FIG. 300 is managed using the schema and data mapping algorithms associated with the graph platform. The graph platform can be implemented by any one of, for example, computer 102 or remote server 108.

[0087] In an embodiment of the present disclosure, the graph platform is a relational graph platform, and data in the relational graph platform is processed using data mining algorithms.

[0088] In an embodiment of the present disclosure, FIG. 300 is accessed to compute a function of FIG. 300 for system 200, and the function can be any one of an application ("app") or a product embodied in the form of software code or dedicated hardware, which implements different types of analysis operations on FIG. 300. Some of these analysis operations are described above. The analysis is completed by executing the improved graph function calculator 120B described previously in Figure 1 is described.

[0089] In one embodiment of the present disclosure, each sub - graph of sub - graph 300– of FIG. 300, namely the second sub - graph and the first sub - graph, is represented by an adjacency matrix. An adjacency matrix can be a square matrix that can represent the connections or relationships between nodes (or vertices) in a graph. Each entry in the adjacency matrix can correspond to a potential edge between two nodes, and its value indicates whether there is a connection between those nodes. Generally, in a graph, the adjacency matrix can be symmetric, with a “1” in entry (i, j) if nodes i and j are connected and a “0” if they are not. Thus, the adjacency matrix can provide a structured way to encode the connectivity of a graph and can be a fundamental tool for performing one or more graph - related computations and algorithms, making it essential in various graph analysis problems ranging from social network analysis to transportation route optimization. In an embodiment of the present disclosure, FIG. 300 is an undirected graph of n ∈ N nodes or vertices associated with an N×N adjacency matrix A, and the sub - graph centrality of the i - th graph node is equal to the magnitude of the i - th diagonal entry of the matrix exponential e A of

[0090] In one embodiment of the present disclosure, system 202 is configured to obtain the adjacency matrix A corresponding to the first sub - graph of FIG. 300 t+1 . Further, system 300 is configured to calculate a function of the adjacency matrix A based on partial spectral factorization data of the adjacency matrix A t of the previously stored second sub - graph of the graph, and update the data associated with the additional nodes added to the second sub - graph t+1 to obtain the first sub - graph

[0091] In an embodiment of the present disclosure, the adjacency matrix A of the first sub - graph t+1 is associated with the state of FIG. 300 at the current time instance t + 1, and the previously stored adjacency matrix A of the second sub - graph t is associated with the state of FIG. 300 at the previous time instance t, such that the previous time instance is earlier than the current time instance. Thus, the second sub - graph is a subset of the first sub - graph, i.e.,

[0092] In an embodiment of the present disclosure, Figure 1 the improved graph function calculator 120B calculates the adjacency matrix A of the sub - graph t+1The function is also used to calculate the subgraph centrality data of the graph 300 by the improved graph function calculator 120B. Additionally, the improved graph function calculator 120B is configured to determine the top N node sets of the graph 300 based on the calculated subgraph centrality such that the top N node sets are the nodes of the graph 300 having the indices associated with the highest subgraph centrality data. Then, these top N nodes are used to identify the most influential nodes of the graph 300 as part of the graph analysis problem.

[0093] In an embodiment of the present disclosure, the graph that can be referred to as The graph 300 is stored external to the main system memory, such as external to the persistent storage device 120 of the computer 102, and is parsed over a number of time steps such that the partial graph processed up to time step 't' is an induced subgraph of the partial graph processed up to time step 't + 1' up to.

[0094] Let ∈ R nXn represent the adjacency matrix associated with the undirected graph where represents a set of vertices of and j The diagonal entry φ of the matrix A th represents the number of closed walks of length j that start and end at the vertex φ. The subgraph centrality of the vertex φ is expressed as:

[0095] Considering all n vertices, the subgraph centrality of the vertices of

[0096]

[0097] is given as an n-length vector as shown in Equation (1): i , x i )) represents the i-th eigenpair of A, and the eigenvalues are algebraically sorted as λ 1 ≥...≥λ n . Equation (1) requires the calculation of all n eigenpairs of A and thus becomes impractical for any case other than small-scale graphs. In one or more embodiments of the present disclosure, the application of subgraph centrality typically only requires detecting a few of its most influential vertices. The contribution of each rank 1 term in Equation (1) is weighted by the scalar which means that the contribution of each eigenpair is relative to λi The algebraic value decreases rapidly.

[0098] Let satisfy 1 ≤ k ≤ n, and define the matrix Λ k = diag(λ 1 , …, λ k ) and = X k = [x 1 ,..., x k . Then, the k-subgraph centrality of graph is defined as in Equation (2) below:

[0099]

[0100] By setting k = 1 and increasing its value until the first N recommended values approximated by two consecutive k-subgraph centralities equal the machine epsilon, the k value sufficient to determine the first N centrality scores can be determined in real time.

[0101] In some embodiments, the first N recommendations include identifying the indices of the maximum entries. These are the first N node sets of the graph, or any of the subgraphs with indices associated with the highest subgraph centrality data. Based on the computed graph function, the subgraph centrality data of graph 300 is computed sequentially. In one embodiment of the present disclosure, the function is a leading eigenpair identification function, for example. In one embodiment of the present disclosure, the function is the k-subgraph centrality according to Equation (2). The computation of the improved graph function is efficiently accomplished by the proposed embodiment because each submatrix corresponding to the adjacency matrix of a subgraph of graph 300 is accessed only once. Figure 4 Figure shows a method outlining the implementation of the improved graph function.

[0102] Figure 4 is a flowchart of a method showing exemplary operations for graph function computation according to an embodiment of the present disclosure. In conjunction with Figure 1 , Figure 2 and Figure 3 the elements of are explained Figure 4 . Referring to Figure 4 , a flowchart of method 400 is shown, which shows exemplary operations from 402 to 406 as described herein. The exemplary operations shown in method 400 may begin at 402 and may be performed by any computing system, device, or apparatus, such as by the computer 102 of Figure 1 or the system 202 of Figure 2 , although shown in discrete blocks, depending on the particular implementation, the exemplary operations associated with one or more blocks of method 400 may be divided into additional blocks, combined into fewer blocks, or eliminated.

[0103] At 402, method 400 for computing a graph function begins. At 404, an adjacency matrix for a first subgraph of the graph is obtained. For example, an adjacency matrix A corresponding to the first subgraph is obtained. t+1 In one embodiment, the adjacency matrix A is obtained from out-of-core storage, such as from remote server 108. In one embodiment, the adjacency matrix A is computed by processor group 114 of computer 102. t+1 t+1

[0104] At 406, a function of the adjacency matrix A, also equivalently referred to as a graph function, is computed. The computation of the graph function is completed based on previously stored partial spectral factorization data for an adjacency matrix of a second subgraph of the graph and update data associated with nodes added to the second subgraph to obtain the first subgraph. For example, referring to, the graph function is computed based on the previously stored adjacency matrix A of the second subgraph and update data for additional nodes (node e, node f, and node g) added to the second subgraph to obtain the first subgraph. t+1 Figure 3 t

[0105] In an embodiment of the present disclosure, the graph function is the k-subgraph centrality defined in Equation (2). The nodes of the graph are partitioned into non-overlapping subsets such that Similarly, the set of edges of G is partitioned into f non-overlapping sets ε 1 ,..., ε f , for example ε 1 ∪... ∪ ε f = ε. Starting from an initial edge set , it is defined that:

[0106]

[0107] According to Equation (3), the edge set ε q includes any of all edges: a) both endpoints of which are located in wherein, or b) one endpoint of which is located in wherein and the other is located in wherein, where g < q.

[0108] The above partitioning enables access in a sequential order consisting of f time steps wherein during time step "t + 1", with respect to sets and ε​​​​​​​​​t+1 The relevant information is accessed by system 202 or equivalently by the improved graph function calculator 120B.

[0109] In some embodiments of the present disclosure, the graph information accessed before the current time step is overwritten by low-rank partial spectral factorization data. Based on the Rayleigh-Ritz projection calculation, based on calculating the first subgraph of the adjacency matrix A t+1 the projection matrix to determine the partial spectral factorization data. Refer to Figure 5 for further explanation of the calculation of the Rayleigh-Ritz projection.

[0110] Figure 5 is a graph showing the projection data calculation for calculating the graph function by the improved graph function calculator 120B according to an embodiment of the present disclosure.

[0111] Refer to Figure 5 , which is the induced subgraph processed up to time step "t" where the matrix pair (X t,k , Λ t,k ) corresponds to the k leading eigenpairs of the adjacency matrix A t . is also the induced subgraph processed up to time step "t+1". To calculate the graph function at time step "t+1", the improved graph function calculator 120B is configured to first obtain the adjacency matrix A of the first subgraph t+1 . The obtained adjacency matrix A of the first subgraph t+1 is the surrogate adjacency matrix. Calculate the matrix pair (X t+1,k , Λ t+1,k ). The matrix pair (X t+1,k , Λ t+1,k ) approximates the k leading eigenpairs of the surrogate adjacency matrix A t+1 .

[0112]

[0113] As Figure 5 shown, and C t+1 form the updated data associated with the nodes added to the second subgraph to obtain the first subgraph .

[0114] and serve as the initial conditions,

[0115] The matrix W t+1 includes data corresponding to the couplings between the nodes n of the second subgraph t (node A, node B, node C) and the set of nodes s added to the second subgraph to obtain the first subgraph . If the i-th node of t+1 is connected to the j-th node of the set , then the (i, j) entry of the matrix is non-zero.

[0116] The matrix C t+1 includes data corresponding to the couplings between the nodes of the set . The edges in the graph are formed by the set ε t+1 ={(e, f), (f, g), (b, e), (c, g)}.

[0117] Then, the substitution adjacency matrix A t+1 is used to calculate graph functions, such as using the method shown in Figure 6 .

[0118] Figure 6 is a flowchart of a method 600 for calculating graph functions according to an embodiment of the present disclosure. In combination with Figure 1 , Figure 2 , Figure 3 , Figure 4 and Figure 5 the component explanations are Figure 6 . Referring to Figure 6 , a flowchart of the method 600 is shown, which shows exemplary operations from 602 to 612 as described herein. The exemplary operations shown in the method 600 can start at 602 and can be performed by any computing system, device, or apparatus, such as by the computer 102 of Figure 1 or the system 202 of Figure 2 , although shown in discrete boxes, depending on the particular implementation, the exemplary operations associated with one or more boxes of the method 600 can be divided into additional boxes, combined into fewer boxes, or eliminated.

[0119] At 602, updated data associated with the nodes added to the first subgraph is received. For example, referring to Figure 5 , at time step (also equivalently referred to as time instance) t + 1, three additional nodes: node e, node f, and node g are added to the second subgraph The addition of these additional nodes results in the formation of the first subgraph at time step t + 1​ Similarly, as combined with Figure 5 discussed, the updated data includes matrix W t+1 , and C t+1 .

[0120] At 604, the projection matrix of the adjacency matrix is calculated based on the Rayleigh - Ritz projection calculation. The updated data is used to calculate the projection matrix of the adjacency matrix at time instance t + 1 based on the Rayleigh - Ritz projection calculation.

[0121] At time instance t + 1, the first sub - graph has an adjacency matrix A t+1 . To calculate A t+1 , the projection matrix Z t+1 is calculated.

[0122] The problem of k - sub - graph centrality is essentially equivalent to calculating the k algebraic leading eigen - pairs of the adjacency matrix (e.g., A t+1 ). For example, the sparse eigenvalue solver calculates a part of the eigen - pairs by applying the Rayleigh - Ritz technique to a subspace that ideally encapsulates the invariant subspace associated with the sought - after eigenvalues of matrix A . In the absence of rounding errors, the eigen - pairs of matrix A t+1 can be recovered as a subset of the Ritz pairs of matrix Z t+1 AZ, where matrix Z represents its orthonormal basis T . Since A is sparse, the standard way to form the projection matrix Z is to adopt the Krylov subspace method and set the projection subspace to t+1

[0123] for some integer T v scaled to v = 1 and a random vector and For symmetric matrices, the Krylov subspace method of choice is the Lanczos iteration method. Assuming m - 1 iterations, the Lanczos algorithm establishes the following relationship:

[0124]

[0125] where e m represents the last column of the m×m identity matrix, Z represents its orthonormal basis the m×m tridiagonal matrix T = Z T AZ represents the orthogonal embedding of A and its leading eigenvalues are approximately the eigenvalues of A. More specifically, let (τ i , f i ), i = 1, ..., k, denote the k leading eigenpairs of matrix T such that τ 1 ≥τ 2 ≥...≥τ k . Then, the i-th leading eigenpair (λ i , x i ) of A is approximated by the i-th leading Ritz pair (τ i , Zf i ). These are called Rayleigh - Ritz projection calculations and produce approximate eigenpairs of the matrix by applying the Galerkin condition, where the residual associated with each approximate eigenvector is orthogonal to the ansatz subspace. After the Rayleigh - Ritz projection calculation, at 606, the k leading eigenpairs of the projection matrix are calculated at time instance t + 1. The projection matrix at time instance t + 1 is denoted as Z t+1 . At 608, the k leading Ritz pairs of the k leading eigenpairs of the projection matrix are determined. At 610, it is determined whether an end condition is reached. If the specified condition is not reached, the time instance t is updated to time instance t + 1, and operations 602 - 610 are repeated until the end condition is reached. The specified end condition is based on the availability of updated data of Figure . As long as updated data is available, method 600 and the corresponding operations 602 - 610 are iteratively executed.

[0126] Once the specified end condition is reached and no further updated data is available, at 612, the graph function is calculated.

[0127] In one embodiment of the present disclosure, the graph function is a sub - graph centrality function. The calculation of the sub - graph centrality function is shown in Figure 7 .

[0128] Figure 7 is a flowchart of method 700 for calculating a graph function according to an embodiment of the present disclosure. In conjunction with elements from Figure 1 , Figure 2 , Figure 3 , Figure 4 , Figure 5 and Figure 6 are explained Figure 7 . Referring to Figure 7 , a flowchart of method 700 is shown, which shows exemplary operations from 702 to 704 as described herein. The exemplary operations shown in method 700 can start at 702 and can be performed by any computing system, device, or equipment, such as by computer 102 of Figure 1 or Figure 2by the system 202, and although shown with discrete operations, the exemplary operations of method 700 may be divided into additional sub-operations, combined into fewer operations, and / or eliminated according to a particular implementation.

[0129] In one embodiment of the present disclosure, the graph function computed in method 600 is used to compute the subgraph centrality of a graph. Thus, at 702, the subgraph centrality of a graph is computed based on the computed graph function. For example, the k leading Ritz pairs determined when an end condition is reached are used to compute the subgraph centrality of the graph at the time instance when the end condition is reached. For example, at time instance t + 1, the i-th leading eigenpair (λt+1,i, xt+1,i) of A t+1 is approximated by the i-th leading Ritz pair (τt+1,i, Zt+1rt+1,i).

[0130] In an embodiment of the present disclosure, the Rayleigh-Ritz eigenvalue problem is solved by a dense eigenvalue solver. Thus, the computational complexity of this task is cubic with respect to the number of columns of the projection matrix Z t+1 In one embodiment of the present disclosure, computing the projection matrix Zt+1 of the adjacency matrix A t+1 includes computing the k leading Ritz pairs of the projection matrix to be the same as the k leading eigenpairs of the adjacency matrix at time instance t + 1. Set Ran(Z t+1 ) such that the k leading Ritz pairs of the matrix are the exact k leading eigenpairs of the matrix A t+1 In exact arithmetic, perform the Rayleigh-Ritz projection with the matrix Z t+1 such that Ran(Z t+1 ) ≡ Ran(A t+1 ) returns the exact eigenvectors associated with all non-zero eigenvalues of the matrix A t+1 Thus, the projection matrix Z t+1 is computed as Equation (4):

[0131]

[0132] In one embodiment of the present disclosure, computing the projection matrix of the adjacency matrix includes computing a matrix formed by computing the orthogonal basis components of the k leading eigenpairs of the adjacency matrix.

[0133] Let and Q t+1 = Orth(F t+1 ). Thus, the projection matrix Z t+1 is computed as Equation (5):

[0134]

[0135] The projection matrix thus forms an orthogonal basis for the column space of matrix A t+1 of

[0136] In one embodiment of the present disclosure, matrix Q t+1 is replaced by a low-rank approximation of matrix F t+1 . The target rank is In calculating the rank-l t+1 approximation of matrix F t+1 , the matrix formed by the l t+1 left singular vectors of matrix F t+1 replaces Q in Equation (5) . t+1

[0137] In one embodiment of the present disclosure, calculating the projection matrix of the adjacency matrix includes calculating the k leading eigenpairs of the adjacency matrix based on Schur components. In this case, the projection matrix Z t+1 is calculated as in Equation (6):

[0138]

[0139] where

[0140]

[0141] and

[0142] In one embodiment of the present disclosure, calculating the projection matrix of the adjacency matrix includes approximating the k leading eigenpairs of the adjacency matrix using the K principal eigenvectors of the symmetric matrix. Thus, the projection matrix Zt+1 is calculated as Equation (7):

[0143]

[0144] After calculating the projection matrix Z t+1 in any of the above ways, the k leading eigenpairs of A t+1 are used to calculate the k subgraph centralities of the graph , as described in the earlier Equation (2). At 704, the calculated k subgraph centralities of the graph are then further used to determine the set of the top N nodes of the graph . The set of the top N nodes is the nodes of the graph with indices associated with the highest subgraph centrality data.

[0145] In one embodiment of the present disclosure, these top N nodes are then used to identify the graph ​The most influential nodes.

[0146] In an embodiment, each time the time step t is updated, the updated adjacency matrix is calculated as described above. Additionally, the previously stored adjacency matrix corresponding to the previous time instance t (e.g., A t ) is replaced with the adjacency matrix corresponding to the subsequent time instance t+1 (e.g., A t+1 ). Thus, each adjacency matrix corresponding to a subgraph is only accessed once, resulting in savings in computation and storage. Moreover, in some embodiments, the approximation of A t+1 calculated using the projection matrix as described above has a linear computational complexity, thus providing an algorithm for determining the updates to the graph and subsequently the nodes of the graph that have the greatest impact.

[0147] Figure 8 FIG. is a diagram illustrating an example algorithm 800 for identifying the most influential nodes of a dynamic graph according to an embodiment of the present disclosure.

[0148] At 802, algorithm 800 begins with a matrix, and at 804, the k leading eigenpairs of A 1 are calculated.

[0149] The matrix A 1 is then augmented to obtain the matrix A 2 by adding additional nodes (and corresponding edges) to the matrix A 1 to form the matrix A 2 . At 804, since this matrix is now replaced by the action , it is no longer necessary to keep A 1 in the system 202 memory. The matrix remains in product form and is never explicitly formed. At 806, the k leading eigenpairs of A 1,k , Λ 1,k are approximated by updating (X 2,k , Λ 2,k ) to (X 2 ) via the previously described Rayleigh-Ritz projection. This process is repeated until all nodes and edges of the graph have been processed.

[0150] In one embodiment, the k leading eigenpairs of the entire adjacency matrix A are approximated during this process. At 808, these k eigenpairs are then used to approximate the graph function SC k (G) according to Equation (2). And at 810, the indices associated with its N largest entries are returned.

[0151] By iteratively updating t to t+1 and using the projection matrix Z t+1 to update the matrix A tThe k leading eigenpairs are updated to matrix A t+1 of the eigenpairs, and calculate their values as described above to execute Algorithm 800 for each time instance. Figure 9 A method of performing such an update is illustrated in

[0152] Figure 9 is a flowchart of a method 900 for updating a dynamic graph according to an embodiment of the present disclosure. Elements from previous figures are explained in conjunction Figure 9 . Referring to Figure 9 , a flowchart of method 900 is shown, which shows exemplary operations from 902 to 912 as described herein. The exemplary operations shown in method 900 may begin at 902 and may be performed by any computing system, device, or apparatus, such as by Figure 1 computer 102 of Figure 2 system 202, although shown in discrete blocks, depending on the particular implementation, the exemplary operations associated with one or more blocks of method 900 may be divided into additional blocks, combined into fewer blocks, and / or eliminated.

[0153] In one embodiment of the present disclosure, at 902, an adjacency matrix A of a first subgraph of the dynamic graph is obtained t+1 . For example, the graph is obtained, such as from the memory of system 202 of the adjacency matrix A t+1 . At 904, a set of k leading eigenpairs of a previously stored adjacency matrix for a second subgraph is obtained. For example, the previously stored adjacency matrix A t has a set of leading eigenpairs X t,k , Λ t,k , which is stored in the memory of system 202. At 906, a projection matrix of the adjacency matrix at time instance t + 1 is approximated. For example, any one of the foregoing equations (4)-(7) is used for matrix A t+1 to approximate the projection matrix Z t+1 .

[0154] At 908, the k leading eigenpairs of matrix A t+1 are approximated. For example, the k leading eigenpairs Z t T +1 A t+1 Z t+1 are calculated. Using this matrix (X t+1,k , Λ t+1,k ) to further form K leading Ritz pairs. At 910, the dynamic graph is updated using the k leading Ritz pairs, and at 912, the updated dynamic graph is then stored in the memory of system 202.

[0155] Storing the data of the dynamic graph (also interchangeably referred to as dynamic graph data) in the above embodiments is efficient and bandwidth-saving, as the graph data is approximated in the form of a matrix product constructed using Rayleigh-Ritz projection. Additionally, rank-k partial spectral factorization is used to augment the dynamic graph data, and the rank-k partial spectral factorization is further used to compute graph functions such as subgraph centrality and to identify the most influential nodes of the dynamic graph, which is required in many real-world applications such as social networks, road networks, biocompound analysis, etc.

[0156] In one or more embodiments of the present disclosure, the traversal on the subgraph and its adjacency matrix is performed only once, and thus it is attractive for large graphs that cannot fit into the system memory or become available dynamically.

[0157] The description of the various embodiments of the present disclosure has been presented for purposes of illustration, but is not intended to be exhaustive or limited to the disclosed embodiments. Many modifications and variations will be apparent to a person of ordinary skill in the art without departing from the scope and spirit of the described embodiments. The terms used herein were chosen to best explain the principles of the embodiments, the practical application, or technical improvements made to the technologies found in the marketplace, or to enable other persons of ordinary skill in the art to understand the embodiments disclosed herein.

Claims

1. A computer-implemented method comprising: Get the adjacency matrix corresponding to the first subgraph of the graph; as well as A function of calculating the adjacency matrix based on previously stored partial spectral factorization data of the adjacency matrix of a second subgraph of the graph, and updating data associated with nodes added to the second subgraph to obtain the first subgraph, wherein the second subgraph is a subset of the first subgraph.

2. The computer-implemented method of claim 1 , wherein: The adjacency matrix of the first subgraph is associated with a state of the graph at a current time instance, and the previously stored adjacency matrix of the second subgraph is associated with a state of the graph at a previous time instance, such that the previous time instance is earlier than the current time instance.

3. The computer-implemented method of claim 1 , further comprising: Calculating subgraph centrality data of the graph based on the calculated function; as well as A top N set of nodes of the graph is determined based on the calculated subgraph centrality, wherein the top N set of nodes are nodes of the graph having indexes associated with highest subgraph centrality data. 4 . The computer-implemented method of claim 3 , wherein the graph is a dynamic graph and the set of top N nodes are the most influential nodes of the dynamic graph.

5. The computer-implemented method of claim 4, wherein: The dynamic graph corresponds to a graph approximation of a social network, such that nodes of the dynamic graph represent users of the social network, and edges of the dynamic graph represent connections between the users of the social network, and further such that the most influential nodes of the dynamic graph represent users of an influencer user type in the social network.

6. The computer-implemented method of claim 1 , wherein: The partial spectral factorization data is determined based on computing a projection matrix of the adjacency matrix of the first subgraph, based on a Rayleigh-Ritz projection calculation.

7. The computer-implemented method of claim 6, further comprising: a) receiving update data associated with said node added to said second subgraph at time instance t+1; b) calculating a projection matrix of the adjacency matrix at the time instance t+1 based on a Rayleigh-Ritz projection calculation; c) calculating k leading feature pairs of the projection matrix at time instance t+1; d) determining k leading Ritz pairs of the k leading eigenpairs of the projection matrix; e) Update t+1; and f) Repeat steps ae until the specified end condition is reached.

8. The computer-implemented method of claim 7, wherein the specified end condition is based on availability of the update data for the graph.

9. The computer-implemented method of claim 8, further comprising computing a subgraph centrality of the graph based on determining the k leading Ritz pairs when the end condition is reached.

10. The computer-implemented method of claim 7, wherein: Computing the projection matrix of the adjacency matrix includes: at time instance t+1, computing the k leading Ritz pairs of the projection matrix to be the same as the k leading eigenpairs of the adjacency matrix.

11. The computer-implemented method of claim 7, wherein: Computing the projection matrix of the adjacency matrix includes computing the k leading eigenpairs of the adjacency matrix based on Schur components.

12. The computer-implemented method of claim 7, wherein: Computing the projection matrix of the adjacency matrix includes computing a matrix formed by computing orthogonal basis components of the k leading feature pairs of the adjacency matrix.

13. The computer-implemented method of claim 7, wherein computing the projection matrix of the adjacency matrix comprises approximating the K leading eigenpairs of the adjacency matrix using K principal eigenvectors of a symmetric matrix.

14. The computer-implemented method of claim 7, further comprising: Replace the previously stored adjacency matrix corresponding to the previous time instance t with the adjacency matrix corresponding to the subsequent time instance t+1.

15. A computer-implemented method for updating a dynamic graph, comprising: Obtaining an adjacency matrix of a first subgraph of the dynamic graph at time step t+1; accessing a previously stored projection matrix of an adjacency matrix of a second subgraph of the dynamic graph; approximating a projection matrix of the adjacency matrix at the time step t+1 based on: the accessed projection matrix for the previously stored adjacency matrix at time step t, and update data of the dynamic graph received at time step t+1; approximating leading eigenpairs of the adjacency matrix at the time step t+1 based on the approximated projection matrix; updating the dynamic graph based on the approximated leading feature pairs; as well as The updated dynamic graph is stored.

16. The computer-implemented method of claim 15, further comprising: Calculating subgraph centrality data for the stored updated dynamic graph; as well as The most influential nodes of the dynamic graph are determined based on the calculated subgraph centrality data.

17. The computer-implemented method of claim 15, wherein: Updating the dynamic graph based on the approximated leading feature pairs is iteratively performed until a specified end condition is met.

18. The computer-implemented method of claim 17, wherein: The specified end condition includes determining the availability of update data for the dynamic graphic.

19. A system comprising: Circuitry configured to perform a computer-implemented method according to any one of claims 1-18.

20. A computer program product for computing a function of an adjacency matrix, the computer program product comprising a computer readable storage medium having program instructions embodied therein, the program instructions executable by a system to cause the system to perform a computer implemented method according to any one of claims 1-18.

21. A system comprising modules respectively configured to perform the steps of the method according to any one of claims 1 to 18.

Images