System, computer implementation method, and computer program (partition training via one-hop history gradient)

Abstract

The inventors have found that, for any given partition, GAS utilizes the one-hop node embeddings obtained while optimizing the training objective function of other partitions, rather than the given partition itself. The inventors have found that this causes GAS to converge more slowly than desired (for example, GAS requires more training epochs than desired). [Solution] A system / technique is provided that facilitates partition training via one-hop history gradients. In various embodiments, the system may have access to a graph. In various embodiments, the system may train a graph neural network on partitions of the graph based on the history gradient of the training loss on a partition-by-partition basis with respect to one-hop node embeddings.

Description

Technical Field

[0001] This disclosure relates to the training of graph neural networks.

Summary of the Invention

Problems to be Solved by the Invention

[0002] The inventors have found that for any given partition, GAS utilizes the embedding of one-hop nodes obtained during the optimization of the training objective function of other partitions rather than the given partition. The inventors have recognized that this causes GAS to converge slower than desired (e.g., GAS requires more training epochs than desired).

Means for Solving the Problems

[0003] A summary is presented below to provide a basic understanding of one or more embodiments. This summary is not intended to identify key or essential elements or to define any scope of either particular embodiments or the scope of any claims. Its sole purpose is to present concepts in a simplified form as a prelude to the more detailed description that follows. In one or more embodiments described herein, a system, computer-implemented method, computer program product, or apparatus that facilitates training via one-hop history gradients is described.

[0004] A system is provided according to one or more embodiments. In various embodiments, the system may comprise a processor capable of executing computer executable components stored in non-temporary computer-readable memory. In various cases, the computer executable components may comprise an access component capable of accessing a graph. In various cases, the computer executable components may comprise a training component capable of training a graph neural network on partitions of the graph based on the historical gradient of the training loss on a partition basis with respect to one-hop node embeddings. In various embodiments, a first partition and a second partition of the graph may have one-hop nodes, each corresponding to a historical gradient value and a historical gradient count, where the historical gradient value may initially be zero and the historical gradient count may initially be zero. In various cases, while training a graph neural network on the first partition, the training component may add the gradient of the first loss of the first partition with respect to the first embedding of the one-hop node to the historical gradient value of the one-hop node; and may increment the historical gradient count. In various cases, while training a graph neural network on a second partition, the training component may add the gradient of the second loss of the second partition with respect to the second embedding of the one-hop node to the history gradient value; the history gradient count may be incremented. In various embodiments, while training a graph neural network on a third partition to which a one-hop node belongs, the training component may update the graph neural network based on the third loss of the third partition and based on the product of the history gradient value and the reciprocal of the history gradient count. In various cases, such training may cause the graph neural network to learn faster than it could otherwise (e.g., using fewer training epochs).

[0005] In various embodiments, the systems described above can be reformatted, reformatted, or otherwise implemented as computer implementations or as computer program products. [Brief explanation of the drawing]

[0006] [Figure 1] A block diagram of an exemplary, non-limiting system for facilitating partition training via a one-hop history gradient, according to one or more embodiments described herein, is shown.

[0007] [Figure 2] A block diagram of an exemplary, non-limiting system, including multiple partitions, a one-hop history gradient value registry, and a one-hop history gradient count registry, is shown, which facilitates partition training via one-hop history gradients according to one or more embodiments described herein.

[0008] [Figure 3] The following are illustrative, non-limiting block diagrams illustrating how a graph may be divided into multiple partitions according to one or more embodiments described herein.

[0009] [Figure 4] The following are non-limiting block diagrams illustrating one-hop history gradient value registries and one-hop history gradient count registries according to one or more embodiments described herein.

[0010] [Figure 5] An illustrative, non-limiting block diagram illustrating how a graph neural network may be trained for multiple partitions according to one or more embodiments described herein is shown. [Figure 6] An illustrative, non-limiting block diagram illustrating how a graph neural network may be trained for multiple partitions according to one or more embodiments described herein is shown. [Figure 7]An illustrative, non-limiting block diagram illustrating how a graph neural network may be trained for multiple partitions according to one or more embodiments described herein is shown. [Figure 8] An illustrative, non-limiting block diagram illustrating how a graph neural network may be trained for multiple partitions according to one or more embodiments described herein is shown. [Figure 9] An illustrative, non-limiting block diagram illustrating how a graph neural network may be trained for multiple partitions according to one or more embodiments described herein is shown.

[0011] [Figure 10] The following are illustrative, non-limiting block diagrams illustrating how the one-hop history gradient value and one-hop history gradient count of a particular node may change during training in one or more embodiments described herein. [Figure 11] The following are illustrative, non-limiting block diagrams illustrating how the one-hop history gradient value and one-hop history gradient count of a particular node may change during training in one or more embodiments described herein. [Figure 12] The following are illustrative, non-limiting block diagrams illustrating how the one-hop history gradient value and one-hop history gradient count of a particular node may change during training in one or more embodiments described herein. [Figure 13] The following are illustrative, non-limiting block diagrams illustrating how the one-hop history gradient value and one-hop history gradient count of a particular node may change during training in one or more embodiments described herein.

[0012] [Figure 14] A flowchart shows an exemplary, non-limiting computer implementation method for facilitating partition training via a one-hop history gradient, according to one or more embodiments described herein. [Figure 15]A flowchart of an exemplary non - limiting computer - implemented method for facilitating partition training via one - hop history gradients, according to one or more embodiments described herein, is shown. [Figure 16] A flowchart of an exemplary non - limiting computer - implemented method for facilitating partition training via one - hop history gradients, according to one or more embodiments described herein, is shown. [Figure 17] A flowchart of an exemplary non - limiting computer - implemented method for facilitating partition training via one - hop history gradients, according to one or more embodiments described herein, is shown.

[0013] [Figure 18] Results of an exemplary non - limiting experiment, according to one or more embodiments described herein, are shown. [Figure 19] Results of an exemplary non - limiting experiment, according to one or more embodiments described herein, are shown. [Figure 20] Results of an exemplary non - limiting experiment, according to one or more embodiments described herein, are shown.

[0014] [Figure 21] A flowchart of an exemplary non - limiting computer - implemented method for facilitating partition training via one - hop history gradients, according to one or more embodiments described herein, is shown.

[0015] [Figure 22] A block diagram of an exemplary non - limiting operating environment in which one or more embodiments described herein may be facilitated is shown.

Best Mode for Carrying Out the Invention

[0016] The following detailed description is illustrative and not intended to limit any embodiments or applications or uses of any embodiments. Furthermore, it is not intended to be bound by any express or implied information presented in the preceding background art or invention summary section or detailed description section.

[0017] Herein, one or more embodiments are described with reference to the drawings, and throughout, similar reference numerals are used to refer to similar elements. In the following description, for illustrative purposes, numerous specific details are given to provide a more complete understanding of one or more embodiments. However, it is clear that in various cases one or more embodiments may be carried out without these specific details.

[0018] A graph neural network (GNN) can be a type of artificial neural network configured to operate on a graph data structure (e.g., on a set of nodes and edges). More specifically, any node in any given graph can be considered to represent any suitable entity, object, or thing, and any edge in a given graph can be considered to represent any suitable relationship between any two nodes. It should be understood that a graph can be written or formatted in any suitable way, such as via an adjacency matrix or an edge list. Each node in a given graph has or can be labeled with its own numerical attributes or features. Similarly, each edge in a graph has or can be labeled with its own numerical attributes or features.

[0019] In various embodiments, a GNN can be configured to accept a graph as input. In some cases, a GNN can be configured to produce, for each node of the input graph, a learned embedding (e.g., a latent vector representation) as its output. In other cases, a GNN can be configured to produce, for each edge of the input graph, a learned embedding as its output. In some cases, such output node or edge embeddings can be fed into any suitable downstream classification model (also called a classification head) which can generate any suitable node-level classification labels (e.g., each classification label for each node), any suitable edge-level classification labels (e.g., each classification label for each edge), or any suitable graph-level classification labels (e.g., each classification label for the entire graph).

[0020] For a GNN to accurately or reliably perform any inference task it is configured to perform (e.g., node embedding generation, edge embedding generation), it must first be trained. Often, the graphs on which we want to train a GNN can be extremely large. In fact, such graphs are often so large that they exceed the processing or memory capacity of any computing hardware hosting the GNN (e.g., having millions of nodes or edges). Therefore, such graphs are often partitioned into smaller subgraphs, each of which can fit within the processing or memory capacity of the computing hardware hosting the GNN, and as a result, the GNN can be trained individually on each of these smaller subgraphs.

[0021] If such partition training is performed in a simplistic manner, a significant loss of information can result. After all, a GNN can incorporate various types of graph convolutional or message-passing layers that compute embeddings for specific nodes (or edges) not only based on the features or attributes of those specific nodes (or edges) but also on any other nodes (or edges) that are adjacent to those specific nodes (or edges). However, some adjacent nodes of those specific nodes may not be in the same partition as those specific nodes. In some cases, such adjacent nodes in different partitions can be referred to as one-hop nodes because, despite being in different partitions, they are separated by only one edge, or one hop. Simply training a GNN for each individual partition can be considered ignoring one-hop nodes, which can prevent the GNN from being properly trained.

[0022] Existing techniques attempt to address such challenges through a method called GNNAutoScale (GAS). Such existing techniques track or record all embeddings that each layer of the GNN creates for each node. These can be called historical embeddings. Thus, when trained on any given partition, the GNN can not only have access to the attributes or features of the nodes in that given partition, but it can also have access to the historical embeddings that the GNN's intermediate layers have previously created for any one-hop node in that given partition. In this way, the GNN can be trained without ignoring one-hop nodes.

[0023] However, the inventors of the various embodiments described herein have recognized that such existing techniques suffer from notable drawbacks. Specifically, the inventors have found that for any given partition, GAS utilizes the one-hop node embeddings obtained while optimizing the training objective function of other partitions, rather than the given partition. The inventors have found that this causes GAS to converge more slowly than desired (for example, GAS requires more training epochs than desired).

[0024] The inventors have devised various embodiments described herein that may help to solve or improve upon the aforementioned technical problems that plague existing techniques for training GNNs. Specifically, the inventors have found that the recording or tracking of historical embeddings in GAS can be supplemented by the recording or tracking of partition-level loss gradients (e.g., partial derivatives) with respect to the embeddings. For any given node, if that given node functions as or is eligible to function as a one-hop node to any partition currently used to train a GNN, such gradients can be computed or updated, and such gradients can be used to perform additional parameter updates to the GNN if that given node is within any partition currently used to train a GNN. In other words, the various embodiments described herein may involve not only the use of one-hop node historical embeddings but also the use of one-hop node historical loss-to-embedding gradients. When a GNN is trained in such a manner, significantly faster training convergence can be achieved.

[0025] Therefore, the various embodiments described herein can be considered specific technical improvements in GNN training.

[0026] Various embodiments described herein may be considered computerized tools (e.g., any preferred combination of computer executable hardware or computer executable software) that can facilitate partition training via one-hop history gradients. In various embodiments, such computerized tools may comprise an access component, a training component, or an execution component.

[0027] In various embodiments, a particular graph may exist. In various embodiments, a particular graph may consist of any suitable number of nodes and any suitable number of edges. In various cases, each node or edge of a particular graph may have any suitable numerical features or attributes of any suitable form, size, or dimensionality (for example, each node or edge may have its own scalar attribute; each node or edge may have its own vector attribute).

[0028] GNNs can exist in a variety of cases. In various embodiments, a GNN can represent any suitable deep learning internal architecture. For example, a GNN may include any suitable number of any suitable type of layers (e.g., input layers, one or more hidden layers, output layers, any of which may be graph convolutional layers, message passing layers, fully connected layers, long short-term memory (LSTM) layers, nonlinear layers, pooling layers, batch normalization layers, or padding layers). Another example is that a GNN may include any suitable number of neurons in various layers (e.g., different layers may have the same or different numbers of neurons). Yet another example is that a GNN may include any suitable activation function in various neurons (e.g., softmax, sigmoid, hyperbolic tangent, rectified linear unit (e.g., different neurons may have the same or different activation functions)). Yet another example is that a GNN may include any suitable inter-neuron or inter-layer connections (e.g., forward connections, skip connections, regressive connections).

[0029] Regardless of its specific internal architecture, a GNN can be configured to perform any suitable inference task on an input graph. As some non-limiting examples, a GNN can be configured to produce node-level embeddings, edge-level embeddings, node-level classifications, edge-level classifications, or graph-level classifications on an input graph.

[0030] In some cases, it may be desirable to train a GNN on a specific graph. As described herein, computerized tools can facilitate such training.

[0031] In various embodiments, the access component of a computerized tool may electronically access the GNN via any suitable wired or wireless electronic connection. In various cases, the access component may further access a particular graph, or otherwise receive, retrieve, or import it from any suitable source. In any case, the access component may access the GNN or a particular graph, thereby allowing other components of the computerized tool to electronically interact with the GNN (e.g., initialize, run, modify it) or electronically interact with a particular graph (e.g., read, write, edit, copy, manipulate it).

[0032] In various embodiments, the training component of a computerized tool can electronically train a GNN on a particular graph. In various embodiments, the training component can achieve such training by dividing the particular graph into multiple partitions and by utilizing a one-hop history gradient value registry and a one-hop history gradient count registry.

[0033] In various cases, multiple partitions can contain any suitable number of partitions. In various cases, each partition can be a subgraph of a particular graph; that is, each partition can contain any suitable subset of nodes and edges of a particular graph. In some embodiments, multiple partitions can be disjoint or non-overlapping; that is, each node in a particular graph can belong to exactly one partition. However, in other embodiments, multiple partitions can instead be disjoint or overlapping; that is, any given node in a particular graph can belong to more than one partition, but is not required. In any case, the union of multiple partitions can be equivalent to a particular graph.

[0034] In various embodiments, a one-hop history gradient value registry can be any suitable electronic database or data structure that contains the respective one-hop history gradient values ​​for each node in a particular graph. In various cases, the one-hop history gradient value can be any suitable scalar, initialized to 0, and representing the cumulative loss-embedding gradient for each node in a particular graph. In various cases, the training component can update the one-hop history gradient value for any given node by performing a push-add operation if that node is a one-hop node in any partition on which the GNN is currently being trained (for example, if the given node does not belong to the current partition but shares an edge with at least one node in the current partition).

[0035] In various embodiments, the one-hop history gradient count registry can be any suitable electronic database or data structure that contains the respective one-hop history gradient count for each node in a particular graph. In various cases, the one-hop history gradient count can be any suitable scalar, initialized to 0 and representing how many times the one-hop history gradient value of each node has been updated via push addition. In various cases, the training component can increment the one-hop history gradient count of any given node by 1 each time the training component performs a push addition on any one-hop history gradient count corresponding to a given node.

[0036] In various embodiments, the training component can utilize a one-hop history gradient value registry and a one-hop history gradient count registry along with multiple partitions, thereby training a GNN.

[0037] As a non-limiting example of such training, consider partition X. In various embodiments, the training component can electronically run a GNN on partition X. More specifically, a computerized tool may feed any features or attributes corresponding to the nodes or edges of partition X into the input layer of the GNN, which may complete a forward pass through one or more hidden layers of the GNN, and the output layer of the GNN may compute inference task results (e.g., node-level embeddings, node-level classification labels, edge-level embeddings, edge-level classification labels, graph-level classification labels) based on the activations provided by one or more hidden layers.

[0038] Here, assume that partition X has a one-hop node Y. In such a case, the training component can utilize the GAS technique while running the GNN on partition X. That is, any embeddings previously created by the hidden layers of the GNN for one-hop node Y can be recalled (e.g., from any suitable history embedding registry) and fed into the appropriate or respective layers of the GNN as the features or attributes of partition X complete their forward passage through the GNN. Thus, the inference task results produced by the GNN can be based not only on the features or attributes of partition X but also on the history embeddings of one-hop node Y.

[0039] The training component can, in various embodiments, compute a loss on partition X. For example, such a loss may be equal to or based on any suitable error (e.g., mean absolute error (MAE), mean squared error (MSE), cross-entropy error) between the inference task result and the inference task result of ground truth known or considered to correspond to partition X. In various embodiments, the training component may apply backpropagation (e.g., stochastic gradient descent) to such a loss, thereby producing a first update to the GNN parameters.

[0040] In various cases, the training component may compute a gradient or partial derivative of the loss associated with partition X with respect to the current or most recent embedding of one-hop node Y. In various cases, the training component may update the one-hop history gradient value registry by push-adding such a gradient or partial derivative to any one-hop history gradient value corresponding to one-hop node Y (for example, by adding the gradient or partial derivative to any current or present magnitude of a one-hop history gradient value). In response to the push-adding of the one-hop history gradient value of one-hop node Y, the training component may update the one-hop history gradient count registry by incrementing any one-hop history gradient count corresponding to one-hop node Y (for example, by adding 1 to any current or present magnitude of a one-hop history gradient count).

[0041] In various embodiments, the training component may compute a second update to the GNN parameters based on all one-hop history gradient values ​​and all one-hop history gradient counts corresponding to the nodes in partition X. More specifically, for each node in partition X, the training component may compute the partial derivative of the node's current or latest embedding with respect to the learnable parameters of the GNN; this partial derivative may be multiplied by all one-hop history gradient values ​​and the reciprocal of all one-hop history gradient counts corresponding to that node. This may result in the respective multiplication product for each node in partition X. In various cases, the second update may be equal to or based on any preferred aggregate of such multiplication products (e.g., any preferred weighted or unweighted sum or average). In various cases, the training component may then reset all one-hop history gradient values ​​and all one-hop history gradient counts corresponding to the nodes in partition X to zero.

[0042] In various embodiments, the training component may perform both a first and a second update on the GNN. This allows the learnable parameters of the GNN to change sequentially, thereby potentially increasing the accuracy or certainty of the GNN's inference task. Specifically, the first update can be seen as changing (e.g., increasing or decreasing) the GNN's parameters based on how well or poorly the GNN has analyzed the nodes of partition X with respect to the loss of partition X. In contrast, the second update can be seen as changing the GNN's parameters based on how well or poorly the GNN has previously analyzed the nodes of partition X with respect to the losses of other partitions in a multi-partition system (e.g., some nodes in partition X may be one-hop nodes in other partitions).

[0043] Such execution and updating procedures can be repeated any number of times that is suitable (e.g., once or multiple times for each partition). This allows the learnable parameters of the GNN to be iteratively optimized to accurately or reliably perform its inference task for the input graph structure.

[0044] In various embodiments, after a GNN has been trained, the execution component of a computerized tool may deploy the GNN in any suitable operating context to perform inference tasks on graphs that do not have a corresponding ground truth. As a non-limiting example, the execution component may electronically access, receive, retrieve, or acquire any other suitable graph (e.g., or any suitable partition thereof) and electronically execute the GNN that was just trained on the other graph. Such execution may produce inference or predicted inference task results for the other graph (e.g., inferred or predicted node-level embeddings, inferred or predicted edge-level embeddings, inferred or predicted node-level classification labels, inferred or predicted edge-level classification labels, inferred or predicted graph-level classification labels). In various cases, the execution component may electronically transmit the inference or predicted inference task results to any other suitable computing device, or electronically render the inference or predicted inference task results on any suitable electronic display or computer screen.

[0045] The various embodiments described herein may be used, using hardware or software, to solve problems that are inherently highly technical, non-abstract, and cannot be performed as a series of mental acts by humans (for example, to facilitate partition training via one-hop history gradients). Furthermore, some of the steps to be performed may be carried out by a dedicated computer (for example, a deep learning neural network configured to work on graph data structures).

[0046] In various embodiments, some defined tasks relating to the various embodiments described herein may include: accessing a graph by a device operably coupled to a processor; and training a graph neural network on partitions of the graph based on the historical gradient of the partition-by-partition training loss with respect to one-hop node embeddings by the device. In various cases, a first partition and a second partition of the graph may have one-hop nodes, each corresponding to a historical gradient value and a historical gradient count, where the historical gradient value may initially be zero and the historical gradient count may initially be zero. In various cases, while training a graph neural network on a first partition, the device may add the gradient of the first loss of the first partition with respect to the first embedding of the one-hop node to the historical gradient value of the one-hop node; and increment the historical gradient count. In various embodiments, while training a graph neural network on a second partition, the device may add the gradient of the second loss of the second partition with respect to the second embedding of the one-hop node to the historical gradient value; and increment the historical gradient count. In various cases, while training the graph neural network on a third partition to which a one-hop node belongs, the device may update the graph neural network based on a third loss of the third partition and based on the product of the history gradient value and the reciprocal of the history gradient count. In various cases, the device may reset the history gradient value to zero and the history gradient count to zero in response to updating the graph neural network based on the third loss. In various embodiments, such defined behavior may further include the device running the graph neural network on another graph after training, thereby producing the result of an inference task on the other graph.

[0047] Neither the human mind nor a person using pen and paper can electronically access partitions of a graph data structure; nor can a GNN be electronically trained on such partitions by using the gradient or derivative of the training loss on a partition-by-partition basis with respect to one-hop node embeddings. Ultimately, artificial neural networks are inherently computerized structures with a specific software-oriented architecture (e.g., input layers, hidden layers, or output layers; any of these may consist of trainable or untrainable internal parameters such as convolutional layers, message-passing layers, or LSTM layers). Artificial neural networks cannot be trained or run in any reasonable or practicable way without a computer, neither by the human mind nor by a person simply using pen and paper. Discussing the field of graph neural network training outside of a computing context would be entirely meaningless. Therefore, any computerized tool that can facilitate partition training of graph neural networks via one-hop history gradients is inherently computerized and cannot be implemented in any reasonable, practicable, or practicable way without a computer.

[0048] In various cases, one or more embodiments described herein may integrate the teachings described herein into practical applications. As previously stated, it is sometimes desirable to train a GNN on a graph that is too large for a given computer memory or processing capacity. To facilitate such training, some existing techniques divide such a large graph into partitions and then train a GNN individually on each partition. Unfortunately, such existing techniques ignore one-hop nodes and therefore achieve inferior GNN performance. Other existing techniques, such as GAS, attempt to solve this problem by continuing to track the history embedding of one-hop nodes. While such other existing techniques avoid catastrophic loss of information, the inventors have found that such other existing techniques still suffer from slow convergence. Specifically, the inventors have found that such other existing techniques utilize one-hop node embeddings that are optimized or updated for the training loss function of other partitions, rather than for every partition on which the GNN is currently being trained.

[0049] Accordingly, the inventors have devised various embodiments described herein which may be considered to solve, address, or otherwise improve upon the slow convergence of other existing techniques. Specifically, the various embodiments described herein may include tracking not only the history embeddings of one-hop nodes but also the loss-embedding gradients of the one-hop nodes. In particular, if it is desired to train the GNN on a graph, the various embodiments described herein may involve tracking the respective one-hop history gradient values ​​and respective one-hop history gradient counts for each node in the graph, where such values ​​and counts may all be initialized to zero. If the GNN is trained on any given partition, the various embodiments described herein may involve running the GNN on that given partition and even on all the history embeddings corresponding to the one-hop nodes of that given partition. Such running may produce an inference task result, and the loss for a given partition may be equal to any suitable error between the inference task result and the ground truth inference task result. In various embodiments, the first parameter update for a GNN can be calculated by applying backpropagation or stochastic gradient descent to its loss. In various cases, the various embodiments described herein may involve updating the one-hop history gradient values ​​of one-hop nodes in a given partition (for example, by push-adding the respective loss-embedding gradient of those one-hop nodes to those values). The various embodiments described herein may also involve updating the one-hop history gradient counts of one-hop nodes in a given partition (for example, by incrementing each of those values ​​by 1).In various cases, the various embodiments described herein may involve computing a second parameter update for the GNN by utilizing all one-hop history gradient values ​​and all one-hop history gradient counts corresponding to the nodes of a given partition (for example, for each node in a given partition, this may involve multiplying the node's one-hop history gradient value by the reciprocal of the node's one-hop history gradient count and the partial derivative of the node's embedding with respect to the GNN parameters, thereby producing each product per node in a given partition, and summing all such products together in a weighted or unweighted manner). The various embodiments described herein may also involve resetting the one-hop history gradient values ​​and one-hop history gradient counts of the nodes in a given partition to zero. In various cases, both the first and second updates may be performed on the parameters of the GNN. Such training may be repeated for each partition. The inventors have experimentally verified that training a GNN in such a manner, as shown with respect to Figures 18 to 20, results in significantly faster convergence than training a GNN according to existing techniques (e.g., according to GAS itself). For these reasons at least, the various embodiments described herein constitute concrete and tangible technical improvements or technical effects in the field of graph neural networks and are therefore certainly qualified for useful and practical applications of computers.

[0050] It should be recognized that the drawings and disclosures herein describe non-limiting examples of various embodiments. Furthermore, it should be recognized that the drawings are not necessarily drawn to scale.

[0051] Figure 1 shows a block diagram of an exemplary, non-limiting system 100 that facilitates partition training via a one-hop history gradient according to one or more embodiments described herein. As shown, the one-hop gradient system 102 can be electronically integrated with a graph 104 or a graph neural network 110 (hereinafter, "GNN110") via any suitable wired or wireless electronic connection.

[0052] In various embodiments, graph 104 can be any suitable graph data structure. In various embodiments, graph 104 may have, own, be composed of, or otherwise comprise a plurality of nodes 106 and a plurality of edges 108. In various cases, the plurality of nodes 106 may include n nodes, i.e., nodes 106(1) to 106(n), for any suitable positive integer n>1. In various cases, the plurality of edges 108 may include m edges, i.e., edges 108(1) to 108(m), for any suitable positive integer m>1. In various embodiments, each of the plurality of nodes 106 may represent any suitable entity or thing in any operating context associated with graph 104. In contrast, each of the plurality of edges 108 may represent any suitable directed or undirected relationship between any two of the plurality of nodes 106.

[0053] As a non-limiting example, Graph 104 may represent a biological network. In such a case, each of the multiple nodes 106 may represent a protein, gene, or other biomolecule, and each of the multiple edges 108 may represent a chemical or biological interaction (e.g., "antibody of ~", "antigen of ~", "enzyme of ~", "substrate of ~") between any two proteins, genes, or other biomolecules.

[0054] As another non-restrictive example, Graph 104 may represent a computer network. In such a case, each of the multiple nodes 106 may represent a computing device or processor, and each of the multiple edges 108 may represent an electronic connection or exchange of services between any two computing devices or processors (e.g., "server of ~", "client of ~").

[0055] As another non-limiting example, graph 104 may represent a transportation network. In such a case, each of the multiple nodes 106 may represent an address, building, or geographical location, and each of the multiple edges 108 may represent a travel path between any two addresses, buildings, or geographical locations.

[0056] As yet another non-limiting example, graph 104 could represent a social media network. In such a case, each of the multiple nodes 106 could represent a social media user or account, and each of the multiple edges 108 could represent a social media relationship (e.g., "friend of ~", "member of ~'s family", "following ~", "blocked by ~") between any two social media users or accounts.

[0057] As yet another non-restrictive example, graph 104 could be any other suitable type of knowledge graph. In such a case, each of the multiple nodes 106 could represent a concept or entity (e.g., person, animal, place, thing), and each of the multiple edges 108 could represent a respective epistemological relationship (e.g., "is", "located in", "contains", "consumes", "greater than", "less than") between any two concepts or entities.

[0058] Regardless of what the multiple nodes 106 specifically represent, each of the multiple nodes 106 may have, be labeled with, or otherwise correspond to one or more numerical features, characteristics, or attributes of any preferred form, size, or dimension. As a non-limiting example, each of the multiple nodes 106 may have or represent one or more scalars, one or more vectors, one or more matrices, or one or more tensors. For example, the features, characteristics, or attributes of node 106(1) may be represented or conveyed by one or more first scalars, vectors, matrices, or tensors, and the features, characteristics, or attributes of node 106(n) may be represented or conveyed by one or more nth scalars, vectors, matrices, or tensors.

[0059] Similarly, regardless of the specific relationships represented by the multiple edges 108, each of the multiple edges 108 may have, be labeled with, or otherwise correspond to one or more numerical features, characteristics, or attributes of any preferred form, size, or dimensionality. As a non-limiting example, each of the multiple edges 108 may have or represent one or more scalars, one or more vectors, one or more matrices, or one or more tensors. For example, the features, characteristics, or attributes of edge 108(1) may be represented or conveyed by one or more first scalars, vectors, matrices, or tensors, and the features, characteristics, or attributes of edge 108(m) may be represented or conveyed by one or more mth scalars, vectors, matrices, or tensors.

[0060] In some cases, graph 104 can become extremely large. That is, graph 104 may contain millions, tens of millions, hundreds of millions, or even billions of nodes or edges.

[0061] It should be understood or otherwise recognized that, in various ways, graph 104 may be written or otherwise formatted according to any preferred syntax or method. As an unrestricted example, graph 104 may be written or formatted as an adjacency matrix. As another unrestricted example, graph 104 may be written or formatted as an edge list. As yet another unrestricted example, graph 104 may be written or formatted as an adjacency list. As yet another unrestricted example, graph 104 may be written according to Graph Markup Language (GraphML) format. As yet another unrestricted example, graph 104 may be written according to JavaScript object notation (JSON) format. As yet another unrestricted example, graph 104 may be written according to resource description framework (RDF) format.

[0062] In various embodiments, GNN110 can represent any suitable deep learning internal architecture. In practice, in various cases, GNN110 may have an input layer, one or more hidden layers, and an output layer. In various cases, any of such layers can be joined together by any suitable interneuron or interlayer connections, such as forward connections, skip connections, or regressive connections. Furthermore, in various cases, any of such layers can be any suitable type of neural network layer having any suitable learnable or trainable internal parameters. For example, any of the input layer, one or more hidden layers, or output layer may be a graph convolutional layer or a message passing layer, and their learnable or trainable parameters may be a convolution kernel, message passing weights, or message aggregation weights. As another example, any of the input layer, one or more hidden layers, or output layer may be a ChebNet layer, and their learnable or trainable parameters may be Chebyshev coefficients. As yet another example, one or more of the input layers, hidden layers, or output layers may be fully connected layers, and their learnable or trainable parameters may be weight matrices or bias values. As yet another example, one or more of the input layers, hidden layers, or output layers may be batch normalization layers, and their learnable or trainable parameters may be shift factors or scale factors. As yet another example, one or more of the input layers, hidden layers, or output layers may be LSTM layers, and their learnable or trainable parameters may be input state weight matrices or hidden state weight matrices. As yet another example, one or more of the input layers, hidden layers, or output layers may be transformer layers, and their learnable or trainable parameters may be single-head or multi-head attention blocks, or other weight matrices.Furthermore, in various cases, any of these layers may be any suitable type of neural network layer having any suitable fixed or untrainable internal parameters. For example, any of these input layers, one or more hidden layers, or output layers may be nonlinear layers, padding layers, pooling layers, or concatenated layers.

[0063] Regardless of its specific internal architecture (e.g., its specific number, type, or structure of layers), GNN110 can be configured to perform any suitable inference task on any suitable input graph. In various embodiments, the inference task may be any suitable type of predictive computation that has substantial meaning in any operating context in which GNN110 is desired or intended to be deployed or implemented. As a non-limiting example, the inference task may be any suitable type of graph regression, e.g., node feature prediction (e.g., prediction of the features, characteristics, or attributes of each node); edge feature prediction (e.g., prediction of the features, characteristics, or attributes of each edge); node embedding generation (e.g., calculation of the latent vector representation of each node); edge embedding generation (e.g., calculation of the latent vector representation of each edge); or prediction of any other continuously variable values ​​associated with the input graph. As another non-restrictive example, the inference task could be any suitable type of classification, such as node-level classification (e.g., predicting a classification label for each node); edge-level classification (e.g., predicting a classification label for each edge); or graph-level classification (e.g., predicting a classification label for the entire input graph).

[0064] In various embodiments, it may be desirable to train the GNN 110 on graph 104. In some cases, the GNN 110 may not have received any training at all. However, in other cases, the GNN 110 may have already received at least some training (e.g., on one or more other graphs), and additional training on graph 104 may be desired. In any case, the one-hop gradient system 102 can facilitate such training as described herein.

[0065] In various embodiments, the one-hop gradient system 102 may include a processor 112 (e.g., a computer processing unit, a microprocessor) and a non-temporary computer-readable memory 114 operably connected to or coupled to the processor 112. The memory 114 may store computer-executable instructions that, when executed by the processor 112, cause the processor 112 or other components of the one-hop gradient system 102 (e.g., an access component 116, a training component 118, an execution component 120) to perform one or more operations. In various embodiments, the memory 114 may store computer-executable components (e.g., an access component 116, a training component 118, an execution component 120), and the processor 112 may execute these computer-executable components.

[0066] In various embodiments, the one-hop gradient system 102 may include an access component 116. In various embodiments, the access component 116 may electronically access the GNN 110 in any preferred manner, thereby enabling the one-hop gradient system 102 to electronically execute, electronically modify (e.g., edit parameters), or otherwise electronically control the GNN 110. Furthermore, in various cases, the access component 116 may electronically receive, retrieve, acquire, import, or otherwise access the graph 104 from any preferred data structure or any preferred computing device, thereby enabling the one-hop gradient system 102 to electronically read from or write to the graph 104. In any case, the access component 116 may electronically access the GNN 110 or the graph 104 (e.g., to or from it) thereby enabling other components of the one-hop gradient system 102 to electronically interact with the GNN 110 or the graph 104.

[0067] In various embodiments, the one-hop gradient system 102 may include a training component 118. In various embodiments, the training component 118 may train the GNN 110 on the graph 104 in a partitioned manner by utilizing a one-hop history gradient value registry or a one-hop history gradient count registry, as described herein.

[0068] In various embodiments, the one-hop gradient system 102 may include an execution component 120. In various cases, the execution component 120 may deploy or implement the GNN 110 after such training, as described herein.

[0069] It should be noted that in various cases, the access component 116, the training component 118, and the execution component 120 may be collectively considered as one or more software components 115 of the one-hop gradient system 102. It should be recognized that in various embodiments, one or more software components 115 are described herein as comprising three components (e.g., the access component 116, the training component 118, and the execution component 120) primarily for the sake of simplicity of description and illustration. However, one or more software components 115 are not limited to being implemented as exactly such three components in every embodiment. In fact, in some embodiments, the functions described herein for such three components may be combined in any preferred manner and thereby implemented in or by fewer than three components (for example, in some cases, a single component may perform all of the functions described herein with respect to the access component 116, the training component 118, and the execution component 120). In other embodiments, the functions of such components described herein may instead be distributed, separated, divided, or subdivided in any preferred manner, thereby being implemented in or by more than three components (for example, two or more components may facilitate the functions that can be performed by the access component 116; two or more components may facilitate the functions that can be performed by the training component 118; two or more components may facilitate the functions that can be performed by the executable execution component 120).

[0070] Figure 2 shows a block diagram of an exemplary, non-limiting system 200, which includes multiple partitions, a one-hop history gradient value registry, and a one-hop history gradient count registry, which can facilitate partition training via one-hop history gradients according to one or more embodiments described herein. As shown, system 200 may in some cases include the same components as system 100 and may further include multiple partitions 202, a one-hop history gradient value registry 204, or a one-hop history gradient count registry 206.

[0071] In various embodiments, the training component 118 can utilize multiple partitions 202, a one-hop history gradient value registry 204, or a one-hop history gradient count registry 206 to train the GNN 110 on graph 104. Non-limiting embodiments are described with respect to Figures 3 to 9.

[0072] Figure 3 shows an exemplary, non-limiting block diagram 300 illustrating a plurality of partitions 202 according to one or more embodiments described herein.

[0073] In various embodiments, the training component 118 can electronically decompose, electronically fragment, electronically separate, or otherwise electronically divide the graph 104 into a plurality of partitions 202. In various embodiments, the plurality of partitions 202 may have or otherwise contain q partitions, i.e., partitions 202(1) to partitions 202(q), for any preferred positive integer q>1. In various cases, each of the plurality of partitions 202 may be considered a subgraph of the graph 104. In other words, each of the plurality of partitions 202 may contain a subset of a plurality of nodes 106 and a subset of a plurality of edges 108. As an unrestricted example, partition 202(1) may have or be composed of a set of nodes 202(1)(a) and a set of edges 202(1)(b), where the set of nodes 202(1)(a) may be any preferred subset 106 of multiple nodes, and the set of edges 202(1)(b) may be any of multiple edges 108 joined together with any two of the set of nodes 202(1)(a). As another unrestricted example, partition 202(q) may have or be composed of a set of nodes 202(q)(a) and a set of edges 202(q)(b), where the set of nodes 202(q)(a) may be any preferred subset of multiple nodes 106, and the set of edges 202(q)(b) may be any of multiple edges 108 joined together with any two of the set of nodes 202(q)(a). In various cases, any two of the multiple partitions 202 may have the same or different sizes. That is, any two of the multiple partitions 202 may have the same or different number of nodes or the same or different number of edges. In various cases, all of the multiple partitions 202 may be dissimilar or otherwise non-overlapping. In other words, each of the multiple nodes 106 may belong to exactly one of the multiple partitions 202 (for example, none of the multiple partitions 202 may share a node).However, in other cases, any of the multiple partitions 202 may be nonprime to each other or overlap with each other in other ways. That is, at least one of the multiple nodes 106 may belong to more than one of the multiple partitions 202 (for example, some of the multiple partitions 202 may share a node). In any case, the multiple partitions 202 can be considered to fit together like puzzle pieces, thereby forming a graph 104. That is, the union of the multiple partitions 202 (plus any partition edges) may be equivalent to graph 104.

[0074] The disclosure herein primarily describes embodiments in which the training component 118 decomposes or fragments the graph 104 into a plurality of partitions 202, but these are merely non-limiting examples for the sake of simplicity of explanation and illustration. In other embodiments, any other suitable computing device (not shown) may have already decomposed or subdivided the graph 104 into a plurality of partitions 202, and the access component 116 may electronically receive, retrieve, acquire, or otherwise access the plurality of partitions 202. In any case, the training component 118 may also be considered to be able to electronically interact with the plurality of partitions 202.

[0075] Figure 4 shows an exemplary, non-limiting block diagram 400 of one-hop history gradient value registry 204 and one-hop history gradient count registry 206 according to one or more embodiments described herein.

[0076] In various embodiments, the one-hop history gradient value registry 204 may have, contain, or otherwise be composed of a plurality of one-hop history gradient values ​​402. In various cases, the plurality of one-hop history gradient values ​​402 may each correspond to a plurality of nodes 106 (for example, in a one-to-one manner). Thus, since the plurality of nodes 106 may contain n nodes, the plurality of one-hop history gradient values ​​402 may similarly contain n values, i.e., one-hop history gradient value 402(1) to one-hop history gradient value 402(n). In various cases, each of the plurality of one-hop history gradient values ​​402 may be the cumulative loss-embedding gradient of each of the plurality of nodes 106. Furthermore, each of the plurality of one-hop history gradient values ​​402 may be updated via a push addition operation whenever each of the plurality of nodes 106 becomes eligible as a one-hop node. Furthermore, each of the plurality of one-hop history gradient values ​​402 may be initialized to 0.

[0077] As a non-restrictive example, the one-hop history gradient value 402(1) may correspond to node 106(1). As described later herein, the training component 118 may train GNN 110 for each of the multiple partitions 202. Node 106(1) may qualify as a one-hop node, or be considered otherwise, if the following two conditions are met: GNN 110 is currently or will be trained on a partition that does not contain node 106(1); and node 106(1) shares an edge with at least one node that is contained in the partition on which GNN 110 is currently or will be trained. Therefore, the one-hop history gradient value 402(1) may be a scalar whose magnitude is initially set to 0. Whenever the training component 118 determines or concludes that node 106(1) is qualify as a one-hop node, the training component 118 may update the one-hop history gradient value 402(1) as follows: The training component 118 may calculate or compute the gradient or partial derivative of the training loss shown by GNN110 for any of the multiple partitions 202 that GNN110 is currently or currently training, with respect to the most recent or otherwise previous (historically) embeddings that GNN110 has made for node 106(1). The training component 118 may then push-add its calculated or computed gradient to the one-hop history gradient value 402(1). In other words, the new magnitude of the one-hop history gradient value 402(1) may be equal to its current magnitude plus its calculated or computed gradient.

[0078] As another non-restrictive example, the one-hop history gradient value 402(n) may correspond to node 106(n). Again, as will be described later herein, the training component 118 may train the GNN 110 for each of the multiple partitions 202. Node 106(n) may qualify as a one-hop node, or be considered otherwise, if the following two conditions are met: GNN 110 is currently or will be trained on a partition that does not contain node 106(n); and node 106(n) shares an edge with at least one node contained in the partition on which GNN 110 is currently or will be trained. Thus, the one-hop history gradient value 402(n) may be a scalar whose magnitude is initially set to 0. Whenever the training component 118 determines or concludes that node 106(n) is qualify as a one-hop node, the training component 118 may update the one-hop history gradient value 402(n) as follows: The training component 118 may calculate or compute the gradient or partial derivative of the training loss shown by GNN110 with respect to the latest or otherwise earlier (historically, the term "history") embedding of node 106(n) for any of the multiple partitions 202 in which GNN110 is currently or currently being trained. The training component 118 may then push-add its calculated or computed gradient to the one-hop history gradient value 402(n). In other words, the new magnitude of the one-hop history gradient value 402(n) may be equal to its current magnitude plus its calculated or computed gradient.

[0079] In various embodiments, the one-hop history gradient count registry 206 may have, include, or otherwise be composed of a plurality of one-hop history gradient counts 404. In various cases, the plurality of one-hop history gradient counts 404 may correspond (for example, in a one-to-one manner) to a plurality of nodes 106 and a plurality of one-hop history gradient values ​​402, respectively. Thus, since the plurality of nodes 106 may include n nodes and the plurality of one-hop history gradient values ​​402 may include n values, the plurality of one-hop history gradient counts 404 may similarly include n counts, i.e., one-hop history gradient count 404(1) to one-hop history gradient count 404(n). In various cases, each of the plurality of one-hop history gradient counts 404 may be an integer indicating how many times one of the plurality of one-hop history gradient values ​​402 has been updated via push addition. Furthermore, each of the plurality of one-hop history gradient counts 404 may be initialized to 0.

[0080] As a non-restrictive example, the one-hop history gradient count 404(1) may correspond to node 106(1) and the one-hop history gradient value 402(1). Thus, the one-hop history gradient count 404(1) can be a scalar that is initially 0, and the training component 118 may increment the one-hop history gradient count 404(1) by 1 each time the training component 118 updates the one-hop history gradient value 402(1) (for example, by adding 1 to the one-hop history gradient count 404(1)).

[0081] As another non-restrictive example, the one-hop history gradient count 404(n) could correspond to node 106(n) and the one-hop history gradient value 402(n). Thus, the one-hop history gradient count 404(n) could be a scalar that is initially 0, and the training component 118 could increment the one-hop history gradient count 404(n) by 1 each time the training component 118 updates the one-hop history gradient value 402(n) (for example, by adding 1 to the one-hop history gradient count 404(n)).

[0082] In various embodiments, the training component 118 may train the GNN 110 for each of the multiple partitions 202 (for example, starting with randomly initialized parameters or non-randomly initialized parameters), and such training may utilize or otherwise utilize the one-hop history gradient value registry 204 and the one-hop history gradient count registry 206. Non-limiting embodiments are described with respect to Figures 5 to 9.

[0083] Figures 5 to 9 show illustrative, non-limiting block diagrams 500, 600, 700, 800, and 900 illustrating how the GNN 110 may be trained for any one of the multiple partitions 202 according to one or more embodiments described herein.

[0084] For example, consider Figure 5. For any suitable positive integer 1 ≤ j ≤ q, there may be a partition 202(j). Partition 202(j) can therefore be considered to consist of a set of nodes 202(j)(a) and a set of edges 202(j)(b). In various cases, the training component 118 may run GNN110 on partition 202(j). In various cases, such a run may cause GNN110 to produce output 504. More specifically, the training component 118 may supply or transfer any attributes, features, or characteristics associated with the set of nodes 202(j)(a) and the set of edges 202(j)(b) to the input layer of GNN110. In various embodiments, such attributes, features, or characteristics may complete a forward pass through one or more hidden layers of GNN110. In various cases, the output layer of the GNN110 may calculate or otherwise calculate output 504 based on any activation map provided by one or more hidden layers of the GNN110.

[0085] Here, we assume that partition 202(j) has a one-hop node 502. In other words, one-hop node 502 is not contained within the set of nodes 202(j)(a), but can be one of the set of nodes 106 that share an edge with at least one of the nodes in the set of nodes 202(j)(a). Figure 5 shows partition 202(j) as having a single one-hop node, but this is merely a non-restrictive example for the sake of simplicity of explanation and illustration. It should be recognized or otherwise understood that partition 202(j) may, in some cases, have two or more one-hop nodes. In any case, one of the hidden layers of GNN110 may be a message-passing layer or a graph convolutional layer that updates the embedding of any given node based on previously created embeddings of not only those given nodes but also of all adjacent nodes of those given nodes (e.g., sharing an edge). Since the one-hop node 502 shares an edge with at least one of the node set 202(j)(a), at least some of the message-passing layers or graph convolutional layers of the GNN110 may be configured to receive previously created embeddings of the one-hop node 502 during the forward pass of the attributes, features, or characteristics of partition 202(j). Thus, during such a forward pass, the training component 118 may invoke or otherwise retrieve any suitable history embeddings previously created by the GNN110 for the one-hop node 502 (e.g., those created by the hidden layers of the GNN110 during a previous run on the partition that contained the one-hop node 502), and may supply or transfer such history embeddings to the appropriate message-passing layer or graph convolutional layer in the GNN110. Thus, those history embeddings of the one-hop node 502 may be considered to accompany the attributes, features, or characteristics of partition 202(j) during the forward pass. Therefore, output 504 may be based not only on the attributes, features, or characteristics of partition 202(j), but also on the history embedding of one-hop node 502.The use of such one-hop node 502 history embedding should be understood or recognized as an application of GAS techniques.

[0086] Note that in any case, the form, size, or dimensionality of output 504 may be determined by the number, arrangement, size, or other characteristics of the neurons, convolutional kernels, LSTM layers, or other intrinsic parameters of the output layer (or any other layer) of GNN110. Thus, output 504 can be forced to have any desired form, size, or dimensionality by adding, removing, or otherwise adjusting the characteristics of the output layer (or any other layer) of GNN110. In various embodiments, output 504 may be considered the predicted or inferred inference task result that GNN110 considers to correspond to partition 202(j). As an unrestricted example, assume that the inference task is node-level classification. In such a case, output 504 may contain, include, or otherwise contain the respective classification labels for each of the set of nodes 202(j)(a). As another unrestricted example, assume that the inference task is edge-level classification. In such cases, output 504 may contain, include, or otherwise contain the respective classification labels for each of the edge sets 202(j)(b). As yet another non-restrictive example, suppose the inference task is graph-level classification. In such cases, output 504 may contain, include, or otherwise contain the classification labels for the entire partition 202(j). Regardless of the specific form or content of output 504, it should be noted that if GNN110 has not been trained at all or with little training, output 504 may be highly inaccurate or inappropriate.

[0087] Next, consider Figure 6. In various embodiments, a ground truth annotation 602 may exist. In various cases, a ground truth annotation 602 may be any correct or accurate inference task result known or thought to correspond to partition 202(j). As an unrestricted example, if the inference task is node-level classification, the ground truth annotation 602 may contain, include, or otherwise contain each correct or accurate classification label known or thought to correspond to each of the set of nodes 202(j)(a). As another unrestricted example, if the inference task is edge-level classification, the ground truth annotation 602 may contain, include, or otherwise contain each correct or accurate classification label known or thought to correspond to each of the set of edges 202(j)(b). As yet another non-restrictive example, if the inference task is graph-level classification, the ground truth annotation 602 may contain, include, or otherwise contain the correct or accurate classification label that is known or thought to correspond to the entirety of partition 202(j).

[0088] In various cases, the training component 118 may calculate a partition-unit loss 604 based on the output 504 and the ground truth annotation 602. More specifically, the partition-unit loss 604 may be equal to or based on any preferred error between the output 504 and the ground truth annotation 602 (e.g., MAE, MSE, cross-entropy error). In various embodiments, the training component 118 may apply any preferred backpropagation technique (e.g., stochastic gradient descent) to the partition-unit loss 604. In various cases, the numerical or mathematical result of such backpropagation may be referred to as the current partition-unit parameter update 606. In other words, the current partition-unit parameter update 606 may be any preferred electronic data that specifies how much each learnable or trainable parameter of the GNN 110 should be increased or decreased in order to reduce or minimize the partition-unit loss 604. It should be noted that the term "current" may be considered appropriate because the partition-level loss 604 is based on partition 202(j), which is the partition on which GNN110 is currently or currently being trained.

[0089] Now, let's consider Figure 7. In various embodiments, there may be one-hop history gradient values ​​702 and one-hop history gradient counts 704. In various embodiments, the one-hop history gradient value 702 may be any of the multiple one-hop history gradient values ​​402 corresponding to the one-hop node 502. Similarly, the one-hop history gradient count 704 may be any of the multiple one-hop history gradient counts 404 corresponding to the one-hop node 502. In various cases, the training component 118 may update the one-hop history gradient value 702 based on the partition-level loss 604. More specifically, the training component 118 may calculate or compute the gradient (alternatively referred to as a partial derivative) of the partition-level loss 604 with respect to any current or recent history embedding corresponding to the one-hop node 502. In various cases, the training component 118 may push-add its computed gradient to the one-hop history gradient value 702. In other words, the new state of the one-hop history gradient value may be equal to the sum of the current state of the one-hop history gradient value 702 and the gradient of the partition-unit loss 604 with respect to the current or most recent history embedding of the one-hop node 502. In various embodiments, the training component 118 may also update the one-hop history gradient count 704 in response to updating the one-hop history gradient value 702. Specifically, the training component 118 may increment the one-hop history gradient count 704 by 1.

[0090] Consider Figure 8. In various embodiments, there may be a set of one-hop history gradient values ​​802 and a set of one-hop history gradient counts 804. In various embodiments, the set of one-hop history gradient values ​​802 and the set of one-hop history gradient counts 804 may correspond to a set of nodes 202(j)(a), respectively. For example, suppose the set of nodes 202(j)(a) has t nodes, any suitable positive integer t, i.e., from node 202(j)(a)(1) to node 202(j)(a)(t). In such a case, the set of one-hop history gradient values ​​802 may therefore have t values, i.e., from one-hop history gradient value 802(1) to one-hop history gradient value 802(t). Similarly, the set of one-hop history gradient counts 804 may have t values, i.e., from one-hop history gradient count 804(1) to one-hop history gradient count 804(t). In various forms, each of the set of one-hop history gradient values ​​802 can be any of the multiple one-hop history gradient values ​​402 corresponding to each of the set of nodes 202(j)(a) (for example, one-hop history gradient value 802(1) can be any of the multiple one-hop history gradient values ​​402 corresponding to node 202(j)(a)(1); one-hop history gradient value 802(t) can be any of the multiple one-hop history gradient values ​​402 corresponding to node 202(j)(a)(t)). Similarly, each of the set 804 one-hop history gradient counts can be any of the multiple one-hop history gradient counts 404 corresponding to each of the set 202(j)(a) (for example, one-hop history gradient count 804(1) can be any of the multiple one-hop history gradient counts 404 corresponding to node 202(j)(a)(1); one-hop history gradient count 804(t) can be any of the multiple one-hop history gradient counts 404 corresponding to node 202(j)(a)(t)).

[0091] In various cases, the training component 118 may calculate or otherwise calculate a delayed partition-unit parameter update 806 based on a set of one-hop history gradient values ​​802 and a set of one-hop history gradient counts 804. As a non-limiting example, the delayed partition-unit parameter update 806 may be equal to or otherwise based on any preferred weighted or unweighted dot product between the set of one-hop history gradient values ​​802 and the set of one-hop history gradient counts 804. Specifically, the training component 118 may multiply the one-hop history gradient value 802(1) by the reciprocal of the one-hop history gradient count 804(1) and the derivative of the current or latest history embedding node 202(j)(a)(1) with respect to the learnable or trainable parameters of the GNN110, thereby producing a first multiplicative product. Similarly, the training component 118 may multiply the one-hop history gradient value 802(t) by the reciprocal of the one-hop history gradient count 804(t) and the derivative of the current or latest history embedding node 202(j)(a)(t) with respect to the learnable or trainable parameters of the GNN 110, thereby producing the t-th multiplication product. In various cases, the training component 118 may sum, average, or otherwise aggregate these t multiplication products together in a weighted or unweighted manner, and the result of such summation, averaging, or aggregation may be considered a delayed partition-unit parameter update 806. When the delayed partition-unit parameter update 806 is being calculated, it should be understood that any node in partition 202(j) with a one-hop history gradient count of 0 may be omitted or excluded from such calculation.

[0092] It should be noted that the set of one-hop history gradient values ​​802 and the set of one-hop history gradient counts 804 may be initialized to all zeros and may have been previously updated by the training component 118 during a previous run of the GNN 110 on other partitions 202 (e.g., on a partition other than partition 202(j)). Therefore, the term "delayed" may be appropriate (for example, the set of one-hop history gradient values ​​802 and the set of one-hop history gradient counts 804 hold information about how the GNN 110 performed during a previous run on a previous partition).

[0093] In various cases, the training component 118 may reset all of the one-hop history gradient values ​​802 and all of the one-hop history gradient counts 804 to zero in response to the calculation of delayed partition-based parameter updates 806.

[0094] Now, consider Figure 9. In various embodiments, the training component 118 can electronically apply both current partition-level parameter updates 606 and delayed partition-level parameter updates 806 to the GNN 110. In other words, the training component 118 can sequentially change the learnable or trainable parameters of the GNN 110 in any way defined by the current partition-level parameter updates 606 and delayed partition-level parameter updates 806. Note that the current partition-level parameter update 606 can be considered to define how the learnable or trainable parameters of the GNN 110 are changed based on the set of nodes 202(j)(a) that function as members of partition 202(j). In contrast, the delayed partition-level parameter update 806 can be considered to define how the learnable or trainable parameters of the GNN 110 are changed based on the set of nodes 202(j)(a) that previously functioned as one-hop nodes for other partitions.

[0095] In various embodiments, the training component 118 may train the GNN 110 once or multiple times for each of the multiple partitions 202 in this manner (for example, as described with respect to Figures 5 to 9). This can ultimately lead to the learnable or trainable parameters of the GNN 110 being iteratively optimized to accurately, correctly, or reliably perform the inference task for any suitable input graph or its partitions. It should be understood or otherwise recognized that the training component 118 may implement any suitable number of training epochs or any suitable training termination criteria.

[0096] Figures 5–9 primarily relate to supervised training of GNN110, but this is merely a non-limiting example for the sake of simplicity in explanation and illustration. It should be recognized that the training component 118 can utilize any other suitable type or paradigm of training (e.g., unsupervised training, semi-supervised training, reinforcement learning, associative training) with respect to GNN110.

[0097] Figures 10–13 show illustrative, non-limiting block diagrams illustrating how the one-hop history gradient value and one-hop history gradient count of a particular node may change during training in one or more embodiments described herein.

[0098] First, consider Figure 10. In various embodiments, graph 1000 may exist. In the non-limiting example of Figure 10, nodes p1 and p2 may represent proteins; nodes s1 and s2 may represent the amino acid sequences of those two proteins; nodes m1 and m2 may represent experiments performed on those two proteins; nodes y1 and y2 may represent numerical measurements (e.g., binding affinity measurements) obtained from those experiments; node d may represent a drug under development; node sm may represent the simplified molecular input line entry system (SMILES) representation of that drug under development. In the non-limiting example of Figure 10, graph 1000 has directed edges.

[0099] For the purpose of illustrating this non-restrictive example, the following discussion examines how the one-hop history gradient value and the one-hop history gradient count for node d change during training of GNN110 on graph 1000. Initially, the one-hop history gradient value for node d may be 0, and the one-hop history gradient count for node d may be 0.

[0100] Now, consider Figure 11. Assume that GNN110 is trained on partition 1102 of graph 1000. That is, GNN110 can be run on partition 1102, and based on the run of GNN110 on partition 1102, the loss L1 can be calculated. For example, the loss L1 may be equal to the error between the inference task result that GNN110 produces on partition 1102 and the known ground truth annotation corresponding to partition 1102. Thus, the learnable or trainable parameters of GNN110 can be updated in a normal or standard manner by applying backpropagation to the loss L1. Note here that node d is eligible as a one-hop node for partition 1102. After all, node d is not in partition 1102 but shares an edge with at least one node (e.g., m1) that is in partition 1102. Since node d is a one-hop node of partition 1102, one or more history embeddings of node d can be invoked and fed into the appropriate hidden layer of GNN110 while partition 1102 completes its forward traverse through GNN110. Additionally, since node d is a one-hop node of partition 1102, the one-hop history gradient value for node d can be updated. Specifically, the one-hop history gradient value of node d is its current value (0) multiplied by the following amount:

number

[0101] Next, consider Figure 12. Assume that GNN110 is subsequently trained on partition 1202 of graph 1000. That is, GNN110 can be run on partition 1202, and the loss L2 can be calculated based on GNN110's run on partition 1202. For example, the loss L2 may be equal to the error between the inference task result that GNN110 produces on partition 1202 and the known ground truth annotation corresponding to partition 1202. Thus, the learnable or trainable parameters of GNN110 can be updated in a normal or standard manner by applying backpropagation to the loss L2. Note that node d qualifies as a one-hop node for partition 1202. After all, node d is not in partition 1202 but shares an edge with at least one node (e.g., m2) that is in partition 1202. Since node d is a one-hop node of partition 1202, one or more history embeddings of node d can be invoked and fed into the appropriate hidden layer of GNN110 while partition 1202 completes its forward traverse through GNN110. Additionally, since node d is a one-hop node of partition 1202, the one-hop history gradient value for node d can be updated. Specifically, the one-hop history gradient value for node d is updated to its current value

number

number

number

[0102] Now, consider Figure 13. Assume that GNN110 is subsequently trained on partition 1302 of graph 1000. That is, GNN110 can be run on partition 1302, and the loss L3 can be calculated based on GNN110's run on partition 1302. For example, the loss L3 may be equal to the error between the inference task result that GNN110 produces on partition 1302 and the known ground truth annotation corresponding to partition 1302. Thus, the learnable or trainable parameters of GNN110 can be updated in the usual or standard way by applying backpropagation to the loss L3. Note that node d is contained within partition 1302. Since node d is contained within partition 1302 and has a non-zero one-hop history gradient count, a delayed parameter update (different from or otherwise not considered by a simple backpropagation from the loss L3) can be calculated based on node d. Specifically, the delayed parameter update may be equal to or otherwise based on the product of the derivatives of the GNN110's learnable or trainable parameters, which are the one-hop history gradient value of node d; the reciprocal of the one-hop history gradient count of node d; and the very current or very present embedding of node d. That is, the delayed parameter update is,

number

[0103] In some cases, if the GNN110 satisfies Lipschitz continuity, the effectiveness of delayed parameter updates can be enhanced. It should be understood, or otherwise recognized, that the GNN110 can be compelled to satisfy Lipschitz continuity through the inclusion of an auxiliary Lipschitz continuity loss during GNN110 training.

[0104] Note that the one-hop history gradient value of node d can be considered to represent the cumulative role that node d has played as a one-hop node to a partition different from the current or present partition (e.g., partition 1302). Furthermore, note that the one-hop history gradient count of node d can be considered a normalization factor that penalizes long-term delays in gradient updates (for example, the more times node d has acted as a one-hop node before being in the current or present partition, the more its one-hop history gradient value is attenuated by the reciprocal of its one-hop history gradient count).

[0105] Figures 14–17 show flowcharts of exemplary, non-limiting computer implementation methods 1400, 1500, 1600, and 1700 that facilitate partition training via one-hop history gradients according to one or more embodiments described herein. In various cases, the one-hop gradient system 102 may facilitate any of the computer implementation methods 1400, 1500, 1600, or 1700.

[0106] First, consider Figure 14. In various embodiments, operation 1402 may include accessing a GNN (e.g., 110) to be trained on a graph (e.g., 104) by a device operably coupled to a processor (e.g., 112) (e.g., via 116).

[0107] In various embodiments, operation 1404 may include the device (e.g., via 118) dividing the graph into multiple partitions (e.g., 202).

[0108] In various cases, operation 1406 may include initializing each node in the graph by the device (e.g., via 118) to zero its respective one-hop history gradient value (e.g., one of each of 402) and its respective one-hop history gradient count (e.g., one of each of 404).

[0109] In various cases, operation 1408 may include determining by the device (e.g., via 118) whether the GNN has been trained for each of the multiple partitions. If so, the computer implementation method 1400 may terminate (e.g., the training of the GNN may be considered complete or terminated). Otherwise, the computer implementation method 1400 may proceed to operation 1410.

[0110] In various embodiments, operation 1410 may include the device (e.g., via 118) selecting a partition (e.g., 202(j)) that the GNN has not yet trained.

[0111] In various cases, operation 1412 may include the device (e.g., via 118) identifying the one-hop node (e.g., 502) of the selected partition.

[0112] In various cases, operation 1414 may involve the device (e.g., via 118) calculating the loss associated with the selected partition (e.g., 604) based on supplying the GNN with the node features of the selected partition and the history node embeddings of the one-hop nodes. Note that this may be considered an application of the GAS technique.

[0113] In various embodiments, the computer implementation method 1400 may proceed to operation 1502 of the computer implementation method 1500.

[0114] Now, consider Figure 15. In various cases, operation 1502 may include updating the one-hop history gradient value (e.g., 702) of a one-hop node by the device (e.g., via 118) push-adding the derivative of the loss with respect to the embedding of the one-hop node for each one-hop node in the selected partition.

[0115] In various cases, operation 1504 may include, for each one-hop node in the selected partition, the device (e.g., via 118) incrementing the one-hop history gradient count of the one-hop node (e.g., 704) by 1.

[0116] In various embodiments, the computer implementation method 1500 may proceed to operation 1602 of the computer implementation method 1600.

[0117] Next, consider Figure 16. In various cases, operation 1602 may include the device (e.g., via 118) determining whether any node in the selected partition can function as a one-hop node for some other partitions. If not, the computer implementation method 1600 may proceed to operation 1604. If it does, the computer implementation method 1600 may instead proceed to operation 1608.

[0118] In various cases, operation 1604 may include updating the GNN parameters based on the loss by the device (e.g., via 118) (for example, if none of the nodes in the selected partition are acting as one-hop nodes for some other partitions, there may be no delayed parameter updates for the selected partition).

[0119] In various embodiments, operation 1606 may include the device returning to operation 1408 of the computer implementation method 1400 (for example, via 118).

[0120] In various cases, operation 1608 may involve the device initializing another loss (e.g., 806) to zero.

[0121] In various cases, operation 1610 may include determining, by the device (e.g., via 118), whether each node in the selected partition that is eligible or functions as a one-hop node from some other partition has a one-hop history gradient count of zero. If so (e.g., all nodes in the selected partition have a one-hop history gradient count of zero), computer implementation method 1600 may proceed to operation 1612. Otherwise (e.g., at least one of the nodes in the selected partition has a non-zero one-hop history gradient count), computer implementation method 1600 may instead proceed to operation 1702 of computer implementation method 1700.

[0122] In various embodiments, operation 1612 may include updating the parameters of the GNN by the device (e.g., via 118) based on both losses and other losses (e.g., delayed parameter updates may be performed).

[0123] In various cases, operation 1614 may include the device returning to operation 1408 of the computer implementation method 1400 (for example, via 118).

[0124] Consider Figure 17. In various embodiments, operation 1702 may include the device (e.g., via 118) selecting a node in a selected partition (e.g., 202(j)(a)(1)) that is eligible or functions as a one-hop node for some other partitions and has a non-zero one-hop history gradient count (e.g., 804(1)).

[0125] In various embodiments, operation 1704 may include the device (e.g., via 118) calculating the derivative of the embedded of a selected node with respect to the parameters of the GNN. Note that since the selected node is a member of a selected partition, the contents of operation 1704 can be rephrased as the calculation of the gradient of the in-partition node embedded with respect to the learnable or trainable parameters of the GNN.

[0126] In various cases, operation 1706 may involve the device (e.g., via 118) multiplying its derivative by the one-hop history gradient value associated with the selected node (e.g., 802(1)) and the reciprocal of the one-hop history gradient count associated with the selected node.

[0127] In various cases, operation 1708 may include the device adding the multiplication product obtained in operation 1706 to another loss (for example, via 118, in a weighted or unweighted manner).

[0128] In various embodiments, operation 1710 may include the device (e.g., via 118) resetting both the one-hop history gradient value and the one-hop history gradient count of the selected node to zero.

[0129] In various cases, operation 1712 may include the device returning to operation 1610 of the computer implementation method 1600 (for example, via 118).

[0130] In various embodiments, upon completion of training the GNN 110, the execution component 120 may deploy the GNN 110 in any suitable operating context, thereby performing an inference task on an input graph where ground truth annotation is unavailable. As a non-limiting example, the execution component 120 may electronically acquire, receive, retrieve, or otherwise access any other suitable graph (not shown) or any suitable partition thereof, and the execution component 120 may electronically execute the GNN 110 on such other graph or such partition. In various cases, such execution may cause the GNN 110 to produce inference task results on the other graph or its partition. In various cases, the execution component 120 may electronically render such inference task results on any suitable electronic display, or electronically transmit such inference task results to any other suitable computing device.

[0131] Figures 18–20 show the results of illustrative, non-limiting experiments using one or more embodiments described herein. Specifically, the inventors have conducted various experiments comparing various embodiments described herein (sometimes referred to as GradientAutoScale or GRADAS) with existing techniques (GNNAutoScale or GAS). As shown, Figures 18, 19, and 20 show charts 1800, 1900, and 2000, respectively, demonstrating the training loss versus training epochs achieved by GAS and GRADAS during partition training of each of the three graphs. As shown, GRADAS achieved significantly faster minimization of training loss compared to GAS for all three graphs. In other words, a given or threshold-level GNN inference execution can be achieved by GRADAS using far fewer training epochs than required by GAS. In other words, GRADAS converges much faster than GAS converges. The experimental results support that the various embodiments described herein constitute concrete, tangible technical improvements in the field of GNNs.

[0132] Figure 21 shows a flowchart of an exemplary, non-limiting computer implementation method 2100 that facilitates partition training via a one-hop history gradient, according to one or more embodiments described herein. In various cases, a one-hop gradient system 102 can facilitate the computer implementation method 2100.

[0133] In various embodiments, operation 2102 may include accessing a graph (e.g., 104) by a device operably coupled to a processor (e.g., 112) (e.g., via 116).

[0134] In various embodiments, operation 2104 may include training a graph neural network (e.g., 110) on a partition of the graph (e.g., 202) based on the historical gradient of the partition-by-partition training loss with respect to one-hop node embeddings (e.g., based on 204) by the device (e.g., via 118).

[0135] Although not explicitly shown in Figure 21, the first partition of the graph (e.g., 1102) and the second partition of the graph (e.g., 1202) may have one-hop nodes (e.g., d), where one-hop nodes may correspond to a history gradient value and a history gradient count, where the history gradient value may initially be zero and the history gradient count may initially be zero. In various embodiments, while training the graph neural network on the first partition, the device may use the history gradient value of the one-hop node to obtain the gradient of the first loss of the first partition with respect to the first embedding of the one-hop node (e.g.,

number

number

number

[0136] Although not explicitly shown in Figure 21, the partitions of the graph can be disjoint or, conversely, overlap.

[0137] Although not explicitly shown in Figure 21, the computer implementation method 2100 may include, by means of the device (e.g., via 120), running the graph neural network on another graph after training, thereby producing the result of an inference task on the other graph.

[0138] Figure 22 and the following discussion are intended to provide a brief and general description of a preferred computing environment 2200 in which one or more embodiments described herein may be implemented. For example, various aspects of this disclosure are described by descriptive text, flowcharts, block diagrams of computer systems, or block diagrams of machine logic included in embodiments of computer program products (CPPs). With respect to any flowchart, depending on the technology involved, operations may be performed in a different order than those shown in a given flowchart. For example, again depending on the technology involved, two operations shown in consecutive blocks of a flowchart may be performed in reverse order, as a single integrated stage, simultaneously, or with at least partial time overlap.

[0139] Embodiments of a computer program product ("CPP Embodiments" or "CPP") are terms used in this disclosure to describe any set of one or more storage media ("mediums") that are collectively comprised of a set of one or more storage devices that collectively contain machine-readable code corresponding to instructions or data for performing computer operations defined in a given CPP claim. "Storage device" is any tangible device capable of holding and storing instructions for use by a computer processor. Computer-readable storage media may, but are not limited to, electronic storage media, magnetic storage media, optical storage media, electromagnetic storage media, semiconductor storage media, mechanical storage media, or any preferred combination thereof. Some known types of storage devices, including these media, include diskettes, 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 disk (DVD), memory stick, floppy disk, mechanically encoded devices (such as pits / lands formed on the main surface of a punch card or disk), or any suitable combination of the foregoing. Computer-readable storage media, when used in this disclosure, should not be interpreted as storage in the form of temporary signals themselves, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides, light pulses passing through optical fiber cables, electrical signals communicated through wires, or other transmission media.As those skilled in the art will understand, data is typically moved at several intermittent points during the normal operation of a storage device, such as during access, defragmentation, or garbage collection; however, data is not transient while it is stored, and therefore the storage device is not transient.

[0140] The computing environment 2200 includes an example of an environment for executing at least a portion of the computer code involved in performing the method of the present invention, such as the one-hop gradient training code 2280. In addition to block 2280, the computing environment 2200 includes, for example, a computer 2201, a wide area network (WAN) 2202, an end user device (EUD) 2203, a remote server 2204, a public cloud 2205, and a private cloud 2206. In this embodiment, computer 2201 includes a processor set 2210 (including a processing circuit configuration 2220 and a cache 2221), a communication fabric 2211, volatile memory 2212, persistent storage 2213 (including an operating system 2222 and block 2280 as identified above), a peripheral device set 2214 (including a user interface (UI) device set 2223, storage 2224, and an Internet of Things (IoT) sensor set 2225), and a network module 2215. The remote server 2204 includes a remote database 2230. Public cloud 2205 includes gateway 2240, cloud orchestration module 2241, host physical machine set 2242, virtual machine set 2243, and container set 2244.

[0141] Computer 2201 may take the form of a desktop computer, laptop computer, tablet computer, smartphone, smartwatch, or other wearable computer, mainframe computer, quantum computer, or any other form of computer or mobile device, currently known or to be developed in the future, that can run programs, access networks, or query databases such as remote database 2230. As is well understood in the field of computer technology, and depending on the technology, the execution of a computer implementation may be distributed among multiple computers or multiple locations. On the other hand, in this presentation of the computing environment 2200, in order to keep the presentation as concise as possible, the detailed discussion focuses on a single computer, specifically computer 2201. Although computer 2201 is not shown in the cloud in Figure 22, it may be located in the cloud. On the other hand, computer 2201 is not required to be located in the cloud, except to any extent that may be explicitly shown.

[0142] The processor set 2210 includes one or more computer processors of any type currently known or to be developed in the future. The processing circuit configuration 2220 may be distributed across multiple packages, e.g., multiple coordinated integrated circuit chips. The processing circuit configuration 2220 may implement multiple processor threads or multiple processor cores. The cache 2221 is memory located within the processor chip package and is typically used for data or code that should be available for high-speed access by threads or cores running on the processor set 2210. The cache memory is typically organized into multiple levels depending on its relative proximity to the processing circuit configuration. Alternatively, some or all of the cache for the processor set may be located "off-chip". In some computing environments, the processor set 2210 may operate using qubits and be designed to perform quantum computing.

[0143] Computer-readable program instructions are typically loaded into computer 2201, causing the processor set 2210 of computer 2201 to execute a series of operational steps, thereby executing the computer implementation method, the instructions thus executed instantiating the method (collectively referred to as the “Method of the Invention”) as defined in the flowchart or description of the computer implementation method contained herein. These computer-readable program instructions are stored in various types of computer-readable storage media, such as cache 2221 and other storage media discussed below. The program instructions and associated data are accessed by the processor set 2210 to control and direct the execution of the Method of the Invention. In the computing environment 2200, at least some of the instructions for executing the Method of the Invention may be stored in block 2280 in persistent storage 2213.

[0144] The communication fabric 2211 is a signal conduction path that enables various components of the computer 2201 to communicate with one another. Typically, this fabric is made up of switches and conduction paths, such as buses, bridges, physical input / output ports, and switches and conduction paths that constitute similar components. Other types of signal communication paths may be used, such as fiber optic communication paths or wireless communication paths.

[0145] Volatile memory 2212 is any type of volatile memory that is currently known or may be developed in the future. Examples include dynamic random-access memory (RAM) or static RAM. Typically, volatile memory is characterized by random access, but this is not required unless explicitly stated. In computer 2201, volatile memory 2212 is located in a single package and is internal to computer 2201, but alternatively or additionally, volatile memory may be distributed across multiple packages or located externally to computer 2201.

[0146] The persistent storage 2213 is any form of non-volatile storage for a computer that is currently known or may be developed in the future. The non-volatility of this storage means that the stored data is maintained regardless of whether the computer 2201 or the persistent storage 2213 directly is powered. The persistent storage 2213 may be read-only memory (ROM), but typically at least a portion of the persistent storage allows for writing, deleting, and rewriting of data. Some well-known forms of persistent storage include magnetic disks and solid-state storage devices. The operating system 2222 can take multiple forms, including various known proprietary operating systems or open-source portable operating system interface (CSI) type operating systems that employ a kernel. The code contained in block 2280 typically includes at least a portion of computer code involved in performing the method of the present invention.

[0147] The peripheral device set 2214 includes a set of peripheral devices for the computer 2201. Data communication connections between the computer 2201's peripheral devices and other components can be implemented in various ways, including Bluetooth® connections, Near-Field Communication (NFC) connections, connections made by cables (such as universal serial bus (USB) type cables), insert-type connections (e.g., secure digital (SD) cards), connections made through local area communication networks, and even connections made through wide area networks such as the Internet. In various embodiments, the UI device set 2223 may include components such as display screens, speakers, microphones, wearable devices (such as goggles and smartwatches), keyboards, mice, printers, touchpads, game controllers, and haptic devices. Storage 2224 is external storage such as an external hard drive, or insertable storage such as an SD card. Storage 2224 may be persistent or volatile. In some embodiments, storage 2224 may take the form of a quantum computing memory device for storing data in the form of qubits. In embodiments where computer 2201 is required to have a large amount of storage (for example, when computer 2201 locally stores and manages a large database), in this case, this storage may be provided by peripheral storage devices designed to store large amounts of data, such as a storage area network (SAN) shared by multiple geographically distributed computers. The IoT sensor set 2225 consists of sensors that can be used in Internet of Things applications. For example, one sensor may be a thermometer and another may be a motion detector.

[0148] The network module 2215 is a collection of computer software, hardware, and firmware that enables computer 2201 to communicate with other computers via the WAN 2202. The network module 2215 may include hardware such as a modem or Wi-Fi® signal transceiver, software for packetizing or de-packetizing data for communication network transmission, or web browser software for communicating data over the internet. In some embodiments, the network control and network forwarding functions of the network module 2215 are performed on the same physical hardware device. In other embodiments (e.g., embodiments utilizing software-defined networking (SDN)), the control and forwarding functions of the network module 2215 are performed on physically separate devices, such that the control function manages several different network hardware devices. Computer-readable program instructions for performing the methods of the present invention can typically be downloaded from an external computer or external storage device to computer 2201 via a network adapter card or network interface included in the network module 2215.

[0149] WAN2202 is any wide area network (e.g., the Internet) that can communicate computer data over non-local distances using any technology currently known or to be developed for communicating computer data. In some embodiments, a WAN may be replaced or complemented by a local area network (LAN), such as a Wi-Fi network, which is designed to communicate data between devices located in a local area. A WAN or LAN typically includes computer hardware such as copper transmission cables, optical transmission fibers, wireless transmissions, routers, firewalls, switches, gateway computers, and edge servers.

[0150] An end-user device (EUD) 2203 is any computer system used and controlled by an end-user (e.g., a customer of the company operating computer 2201) and can take any of the forms discussed above in relation to computer 2201. Typically, EUD 2203 receives useful and valuable data from the operation of computer 2201. For example, in a hypothetical case where computer 2201 is designed to provide recommendations to an end-user, these recommendations would typically be communicated from the network module 2215 of computer 2201 to EUD 2203 via WAN 2202. In this way, EUD 2203 can display or otherwise present the recommendations to the end-user. In some embodiments, EUD 2203 may be a client device such as a thin client, heavy client, mainframe computer, or desktop computer.

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

[0152] Public Cloud 2205 is any computer system available for use by multiple entities that provides on-demand availability of computer system resources or other computing capabilities, particularly data storage (cloud storage) and computing power, without direct, active management of its scale. Direct and active management of the computing resources of Public Cloud 2205 is performed by the computer hardware or software of Cloud Orchestration Module 2241. The computing resources provided by Public Cloud 2205 are typically implemented by virtual computing environments running on various computers that make up the host physical machine set 2242, which is a collection (universe) of physical computers within or available to Public Cloud 2205. Virtual computing environments (VCEs) typically take the form of virtual machines in the virtual machine set 2243 or containers in the container set 2244. These VCEs may be stored as images and may be transferred either as images or after instantiation of the VCEs, among and between hosts of various physical machines. The cloud orchestration module 2241 manages image migration and storage, deploys new VCE instances, and manages active instanceizations of VCE deployments. The gateway 2240 is a collection of computer software, hardware, and firmware that enables the public cloud 2205 to communicate over the WAN 2202.

[0153] Here, some further explanation of virtualized computing environments (VCEs) is provided. A VCE can be stored as an "image." From this image, a new active instance of the VCE can be instantiated. Two well-known 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 in which the kernel allows for the existence of multiple isolated user-space instances called containers. These isolated user-space instances typically behave like actual computers in terms of the programs running within them. Computer programs running on a normal operating system can utilize all of that computer's resources, such as connected devices, files and folders, network shares, CPU power, and quantifiable hardware capabilities. However, programs running inside a container can only use the contents of the container and the devices allocated to the container, which is a known feature of containerization.

[0154] Private Cloud 2206 is similar to Public Cloud 2205, except that its computing resources are available for use by a single enterprise only. While Private Cloud 2206 is shown as being in communication with WAN 2202, in other embodiments, a private cloud may be completely isolated from the internet and accessible only through a local / private network. A hybrid cloud is a configuration of multiple clouds of different types (e.g., private, community, or public cloud types), often implemented by different vendors. Each of the multiple clouds remains a separate and independent entity, but the larger hybrid cloud architecture is connected by standardized or proprietary technologies that enable orchestration, management, or data / application portability across the multiple configuration clouds. In this embodiment, both Public Cloud 2205 and Private Cloud 2206 are part of a larger hybrid cloud.

[0155] The embodiments described herein may cover one or more systems, methods, apparatus, or computer program products at any possible level of integration of technical details. A computer program product may include a computer-readable storage medium (or more media) having computer-readable program instructions for causing a processor to execute aspects of one or more embodiments described herein. The computer-readable storage medium may be a tangible device capable of holding and storing instructions for use by an instruction execution device. The computer-readable storage medium may be, 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 preferred combination thereof. A non-exhaustive list of more specific examples of computer-readable storage media may also include, namely, portable computer diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disk read-only memory (CD-ROM), digital versatile disks (DVDs), memory sticks, floppy disks, mechanically encoded devices such as punch cards or grooved raised structures on which instructions are recorded, or any preferred combination of those described above. When used in this disclosure, computer-readable storage media should not be construed as transient signals themselves, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., light pulses passing through optical fiber cables), or electrical signals transmitted through wires.

[0156] The computer-readable program instructions described herein may be downloaded from a computer-readable storage medium to each computing / processing device, or to an external computer or external storage device via a network, such as the Internet, a local area network, a wide area network, or a wireless network. The network may include copper transmission cables, optical transmission fibers, wireless transmissions, routers, firewalls, switches, gateway computers, or edge servers. A network adapter card or network interface within each computing / processing device receives computer-readable program instructions from the network and transfers the computer-readable program instructions for storage in the computer-readable storage medium within each computing / processing device. Computer-readable program instructions for performing the operation of one or more embodiments described herein may be assembler instructions, instruction-set-architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state-setting data, configuration data for integrated circuit configurations, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​such as Smalltalk®, C++, or similar, procedural programming languages ​​such as the C programming language or similar programming languages, or similar programming languages. Computer-readable program instructions may run as a standalone software package entirely on a computer, partially on a computer, partially on a computer, partially on a remote computer, or entirely on a remote computer or a server. In the latter scenario, the remote computer may be connected to the computer through any type of network, including a local area network (LAN) or wide area network (WAN), or this connection may be to an external computer (for example, via the Internet using an Internet service provider).In one or more embodiments, an electronic circuit configuration including, for example, a programmable logic circuit configuration, a field-programmable gate array (FPGA), or a programmable logic array (PLA) may be individualized by executing computer-readable program instructions by utilizing state information of computer-readable program instructions in order to perform an aspect of one or more embodiments described herein.

[0157] Aspects of one or more embodiments described herein are described herein with reference to flowcharts or block diagrams of methods, apparatus (systems), and computer program products according to one or more embodiments described herein. It will be understood that each block in a flowchart or block diagram, and combinations of blocks in a flowchart or block diagram, can be implemented by computer-readable program instructions. These computer-readable program instructions can be provided to the processor of a general-purpose computer, a dedicated computer, or other programmable data processing device to create a machine, thereby enabling instructions executed via the processor of the computer or other programmable data processing device to create means for implementing functions / operations defined within a block or multiple blocks of a flowchart or block diagram. These computer-readable program instructions can also be stored in a computer-readable storage medium that can instruct a computer, a programmable data processing device, or other device to function in a particular manner, thereby enabling the computer-readable storage medium storing the instructions internally to include a product containing instructions capable of implementing modes of functions / operations defined within a block or multiple blocks of a flowchart or block diagram. Computer-readable program instructions can also be loaded onto a computer, another programmable data processing device, or other device to cause a series of operational actions to be executed on the computer, another programmable device, or other device, thereby creating a computer implementation process, where instructions executed on the computer, another programmable device, or other device implement functions / operations defined within a block or multiple blocks of a flowchart or block diagram.

[0158] The flowcharts and block diagrams in the figures illustrate the architecture, functionality, or operation of possible implementations of a system, computer-implementable method, or computer program product according to one or more embodiments described herein. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of instructions containing one or more executable instructions for implementing a defined logic function. In one or more alternative implementations, the functions described in a block may occur in an order different from that shown in the drawings. For example, two consecutively shown blocks may be executed substantially simultaneously, or blocks may sometimes be executed in reverse order depending on the functions involved. It should also be noted that each block in a block diagram or flowchart, or any combination of blocks in a block diagram or flowchart, may be implemented by a dedicated hardware-based system capable of performing a defined function or operation, or one or more combinations of dedicated hardware or computer instructions.

[0159] While the subject matter has been described above in the general context of computer executable instructions for computer program products running on one or more computers, those skilled in the art will recognize that one or more embodiments described herein may be implemented at least partially in parallel with one or more other program modules. Generally, a program module includes routines, programs, components, or data structures that perform a specific task or implement a specific abstract data type. Furthermore, the computer implementation methods described above may also be implemented in other computer system configurations, including single-processor or multi-processor computer systems, minicomputing devices, mainframe computers, and even computers, handheld computing devices (e.g., PDAs®, telephones), or microprocessor-based or programmable consumer or industrial electronic equipment. The exemplary embodiments may also be implemented in a distributed computing environment where tasks are performed by remote processing devices connected through a communication network. However, one or more, if not all, of the embodiments described herein may be implemented on a standalone computer. In a distributed computing environment, program modules may reside in both local and remote memory storage devices.

[0160] As used herein, the terms “component,” “system,” “platform,” or “interface” may refer to or include computer-related entities or entities relating to operating machines having one or more specific functions. Entities described herein may be hardware, a combination of hardware and software, software, or running software. For example, a component may be, but is not limited to, a process running on a processor, a processor, an object, an executable file, a thread of execution, a program, or a computer. Exemplarily, an application running on a server and the server itself may both be components. One or more components may reside within a process or thread of execution, and components may be localized on one computer or distributed across two or more computers. In another example, each component may run from various computer-readable media that internally store various data structures. Components may communicate via local or remote processes, such as by signaling, which has one or more data packets (e.g., data from one component communicating with another component in a network such as the Internet, a local system, a distributed system, or other systems via signaling). As another example, a component may be a device having a specific function provided by mechanical parts operated by an electrical or electronic circuit configuration which is operated by a software or firmware application executed by a processor. In such a case, the processor may be inside or outside the device and may execute at least part of the software or firmware application. As yet another example, a component may be a device that provides a specific function through electronic components without using mechanical parts, and such electronic components may include a processor or other means for executing software or firmware that provides at least part of the electronic components' function.In one embodiment, the component may emulate an electronic component via, for example, a virtual machine in a cloud computing system.

[0161] In addition, the term “or” is intended to mean an inclusive “or,” not an exclusive “or.” That is, unless otherwise specified or it is clear from the context, “X uses A or B” is intended to mean any of the natural inclusive substitutions. That is, “X uses A or B” is satisfied under any of the aforementioned cases: when X uses A; when X uses B; or when X uses both A and B. Wherever used herein, the terms “and / or” are intended to have the same meaning as “or.” Furthermore, the articles “a” and “an” used in the specification and accompanying drawings of this subject matter should generally be interpreted as “one or more,” unless otherwise specified or it is clear from the context that they refer to a singular form. Wherever used herein, the terms “example” or “exemplary” are used to mean an example, case, or illustration. To avoid doubt, the subject matter described herein is not limited to such examples. In addition, any embodiment or design described herein as “example” or “exemplary” should not necessarily be construed as being preferable or advantageous to other embodiments or designs, nor is it intended to exclude equivalent exemplary structures and techniques known to those skilled in the art.

[0162] The disclosure herein describes non-limiting examples of various embodiments. For ease of description, various parts of the disclosure herein use the terms “each,” “all,” or “all” when discussing various embodiments. Such use of the terms “each,” “all,” or “all” is non-limiting. In other words, where the disclosure herein provides a statement that applies to “each,” “all,” or “all” of a particular object or component, it should be understood that this is a non-limiting example of various embodiments, and it should be further understood that in various other embodiments, such a statement may apply to fewer than “each,” “all,” or “all” of some particular object or component.

[0163] As used herein, the term “processor” can mean substantially any computing processing unit or device, including but not limited to single-core processors; single processors with software multithreading capabilities; multi-core processors; multi-core processors with software multithreading capabilities; multi-core processors with hardware multithreading technology; parallel platforms; or parallel platforms with distributed shared memory. Additionally, a processor can mean integrated circuits, application-specific integrated circuits (ASICs), digital signal processors (DSPs), field-programmable gate arrays (FPGAs), programmable logic controllers (PLCs), complex-programmable logic devices (CPLDs), discrete gate or transistor logic, discrete hardware components, or any combination thereof designed to perform the functions described herein. Furthermore, processors may leverage nanoscale architectures such as molecular and quantum dot-based transistors, switches, or gates, but are not limited to optimizing space utilization or improving the performance of associated equipment. Processors can be implemented as a combination of computing processing units.

[0164] In this specification, terms such as “memory,” “storage,” “data memory,” “data storage,” “database,” and substantially any other information storage component relating to the operation and function of a component are used to refer to “memory” or “memory component” entities embodied in a component containing memory. The memory or memory components described herein may be either volatile memory or non-volatile memory, or may include both volatile and non-volatile memory. For example, but not limited to, non-volatile memory may include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable ROM (EEPROM), flash memory, or non-volatile random-access memory (RAM) (e.g., ferroelectric RAM (FeRAM)). Volatile memory may include RAM that can act as, for example, external cache memory. For illustrative purposes only, and without limitation, RAM can be available in many forms, including synchronous RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate SDRAM (DDR SDRAM), enhanced SDRAM (ESDRAM), Synchlink DRAM (SLDRAM), direct Rambus RAM (DRRAM), direct Rambus dynamic RAM (DRDRAM), or Rambus dynamic RAM (RDRAM).Furthermore, the memory components disclosed in the described systems or computer implementations are intended, but not limited to, these to include, any other suitable types of memory.

[0165] The above descriptions include only examples of systems and computer implementations. Naturally, for the purpose of describing one or more embodiments, it is impossible to describe all possible combinations of components or computer implementations; however, those skilled in the art will recognize that numerous further combinations or arrangements of one or more embodiments are possible. Furthermore, to the extent that the terms “includes,” “have,” “possess,” and similar terms are used in the detailed description, claims, accessories, or drawings, such terms are intended to be as comprehensive as the term “equipment” when interpreted as “equipment” is used as a transitional term in a claim.

[0166] While descriptions of various embodiments have been presented for illustrative purposes, they are not intended to be exhaustive or to limit the embodiments described herein. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. The terminology used herein has been selected to best describe the principles, practical applications, or technical improvements to the technologies available on the market, or to enable other those skilled in the art to understand the embodiments described herein.

Claims

1. A processor that executes computer executable components stored in non-temporary computer-readable memory, wherein the computer executable components are: Access components for accessing graphs; and A training component that trains a graph neural network on partitions of the graph based on the historical gradient of the training loss on a partition-by-partition basis for one-hop node embeddings. A system that has

2. The system according to claim 1, wherein the first partition and the second partition of the graph have one-hop nodes, the one-hop nodes correspond to a historical gradient value and a historical gradient count, the historical gradient value is initially zero and the historical gradient count is initially zero.

3. While training the graph neural network on the first partition, the training component, The gradient of the first loss of the first partition relating to the first embedding of the one-hop node is added to the historical gradient value of the one-hop node; The aforementioned history gradient count is incremented. The system according to claim 2.

4. While training the graph neural network on the second partition, the training component, The gradient of the second loss of the second partition relating to the second embedding of the one-hop node is added to the aforementioned historical gradient value; The aforementioned history gradient count is incremented. The system according to claim 3.

5. While training the graph neural network on the third partition to which the one-hop node belongs, the training component: The system according to claim 4, wherein the graph neural network is updated based on the third loss of the third partition and based on the product of the historical gradient value and the reciprocal of the historical gradient count.

6. The aforementioned training component is The system according to claim 5, wherein the graph neural network is updated based on the third loss, and the history gradient value and the history gradient count are reset to zero.

7. The system according to any one of claims 1 to 6, wherein the partitions of the graph are relatively prime.

8. The system according to any one of claims 1 to 6, wherein the partitions of the graph overlap.

9. The aforementioned computer executable component is The system according to any one of claims 1 to 6, further comprising an execution component that, after training, runs the graph neural network on another graph, thereby producing an inference task result for the other graph.

10. The step of accessing the graph by a device operably coupled to the processor; and The device trains a graph neural network on partitions of the graph based on the historical gradient of the training loss for each partition related to one-hop node embedding. A computer implementation method comprising the above.

11. The computer implementation method according to claim 10, wherein the first partition of the graph and the second partition of the graph have one-hop nodes, the one-hop nodes correspond to a history gradient value and a history gradient count, the history gradient value is initially zero and the history gradient count is initially zero.

12. While training the graph neural network on the first partition, the device The gradient of the first loss of the first partition relating to the first embedding of the one-hop node is added to the historical gradient value of the one-hop node; The aforementioned history gradient count is incremented. The computer implementation method according to claim 11.

13. While training the graph neural network on the second partition, the device The gradient of the second loss of the second partition relating to the second embedding of the one-hop node is added to the aforementioned historical gradient value; The aforementioned history gradient count is incremented. The computer implementation method according to claim 12.

14. While training the graph neural network on the third partition to which the one-hop node belongs, the device The computer implementation method according to claim 13, wherein the graph neural network is updated based on the third loss of the third partition and based on the product of the history gradient value and the reciprocal of the history gradient count.

15. The device described above, The computer implementation method according to claim 14, wherein the graph neural network is updated based on the third loss, and the history gradient value and the history gradient count are reset to zero.

16. The computer implementation method according to any one of claims 10 to 15, wherein the partitions of the graph are relatively prime.

17. The computer implementation method according to any one of claims 10 to 15, wherein the partitions of the graph overlap.

18. The device then runs the graph neural network on another graph after training, thereby generating an inference task result for the other graph. A computer implementation method according to any one of claims 10 to 15, further comprising the above.

19. In the processor, Procedure for accessing the graph; and A procedure for training a graph neural network on partitions of a graph based on the historical gradient of the training loss on a partition-by-partition basis for one-hop node embeddings, or based on the gradient of node embeddings within a partition for learnable parameters of the graph neural network. A computer program to facilitate partition training via one-hop history gradients for execution.

20. The aforementioned processor, The computer program according to claim 19, further comprising, after training, having the graph neural network perform a procedure on another graph, thereby producing an inference task result for the other graph.

Images