Hash-based projection of node embeddings via transformed personalized web page ranks

Abstract

Systems and methods for generating single-node representations in graphs composed of linked nodes. The present technology enables dynamic generation of individual node embeddings in sub-linear time (less than O(n), where n is the number of nodes in the graph G), using only the PPR vectors of the individual nodes and a random projection to reduce the dimensionality of the PPR vectors of that node. In one example, the present technology includes a computer-implemented method comprising: obtaining, from a database, a graph having a plurality of nodes; generating, for a given node of the plurality of nodes, a personal PageRank vector; and producing, for the given node, an embedding vector by randomly projecting the personal PageRank vector, wherein the embedding vector has a lower dimensionality than the personal PageRank vector.

Description

BACKGROUND

[0001] Graphs can be used to model a variety of interesting problems in which data can be represented as objects connected to each other, such as in social networks, computer networks, chemical molecules, and knowledge graphs. In many cases, it is beneficial to generate an embedding representation of a graph, in which a d-dimensional embedding vector is assigned to each node in a given graph G. Such node embeddings can be used for downstream machine learning tasks, such as visualization (e.g., in which a high-dimensional graph is reduced to lower dimensions), node classification (e.g., in which missing information in one node is predicted using features of neighboring nodes), anomaly detection (e.g., in which an anomalous group of nodes is highlighted), and link prediction (e.g., in which new links between nodes are predicted, such as suggesting new connections in a social network).

[0002] Existing methods for generating graph embeddings generally assume that graph data fits easily into memory and is stable. However, in many cases, graph data can actually be large, making storage and / or processing on certain devices (e.g., personal computers, mobile devices) difficult or infeasible. Also, in many cases, graph data can be volatile, and thus can become too old to rely on for certain tasks (e.g., social networks change constantly as new users join and new relationships form). Assuming that network embeddings must generally be consistent across all nodes in the graph data, a standard approach to handle such changing behavior is to re-run the embedding algorithm on a periodic (e.g., weekly) basis in order to balance the time required to generate a new graph representation against the need for a representation that is as up-to-date as possible. Meanwhile, many common uses of graph embeddings, such as node classification, can only require a current representation of a single node or a small group of nodes, making it particularly inefficient to recompute the entire graph embedding on a needed basis.

[0003] In response, the present technology presents systems and methods in which the embedding of a node is constrained to use only local structural information and cannot access representations of other nodes in the graph or rely on a trained global model state. Furthermore, the present technology can generate embeddings that are consistent with the representations of other nodes in the graph, such that a new node embedding can be combined with the rest of the graph embedding and used for downstream tasks. To accomplish this, the present technology presents systems and methods that utilize a higher-order rank matrix based on global personalized PageRank ("PPR") as the basis for computing local node embeddings with local PPR hashing. These systems and methods can produce node embeddings that are comparable in quality to prior art methods, but with several orders of magnitude in efficiency in terms of clock time and short-term memory consumption. For example, these systems and methods can be configured to produce node embeddings that fit into the volatile memory of a desktop and / or mobile computing device. Furthermore, these systems and methods enable different node embeddings to be updated in parallel, such as in a server farm system and / or a multi-processor or multi-core processor based system, enabling multiple simultaneous queries to be responded to, and enabling each response to be based on locally updated embeddings specific to each query. Finally, these systems and methods enable the processing to be customized so as to provide embeddings within a preset amount of time, which enables the present technology to be applied in contexts such as fraud detection, where embeddings must be generated within a guaranteed amount of time (e.g., 200 ms). SUMMARY

[0004] The present technology relates to improved systems and methods for generating single node representations in a graph comprising linked nodes. In this regard, the present technology provides systems and methods for dynamically generating individual node embeddings in sub-linear time (less than O(n), where n is the number of nodes in the graph G), using only the PPR vector of the individual node and a random projection to reduce the dimensionality of the PPR vector of that node.

[0005] In one aspect, the present disclosure describes a processing system comprising: a memory, and one or more processors coupled to the memory and configured to perform the following operations: obtaining, from a database, a graph having a plurality of nodes; generating, for a given node of the plurality of nodes, a personal web page rank vector; and producing, for the given node, an embedding vector by randomly projecting the personal web page rank vector, wherein the embedding vector has a lower dimensionality than the personal web page rank vector. In some aspects, the one or more processors are further configured to perform one or more of the following operations in parallel with one or more operations of claim 1: generating, for another node of the plurality of nodes, another personal web page rank vector, the another node being different from the given node; and producing, for the another node, another embedding vector by randomly projecting the another personal web page rank vector, wherein the another embedding vector has a lower dimensionality than the another personal web page rank vector. In some aspects, the one or more processors are further configured to generate the personal web page rank vector for the given node based at least in part on a precision value. In some aspects, the one or more processors are further configured to generate the personal web page rank vector for the given node based at least in part on a return probability. In some aspects, the one or more processors are further configured to generate the personal web page rank vector as a sparse vector. In some aspects, the one or more processors are further configured to produce the embedding vector for the given node by randomly projecting the personal web page rank vector based at least in part on a preselected dimensionality of the embedding vector. In some aspects, the one or more processors are further configured to produce the embedding vector for the given node by randomly projecting the personal web page rank vector based at least in part on one or more hash functions. In some aspects, the one or more processors are further configured to update an embedding of the graph based on the embedding vector of the given node. In some aspects, the one or more processors are further configured to produce a link prediction based at least in part on the embedding vector of the given node, wherein the link prediction represents a prediction of a new link between the given node and another node of the plurality of nodes. In some aspects, the one or more processors are further configured to produce a node classification based at least in part on the embedding vector of the given node, wherein the node classification represents a prediction of information to be associated with the given node based on one or more features of other nodes of the plurality of nodes that are adjacent to the given node.

[0006] In another aspect, the present disclosure describes a computer-implemented method comprising the steps of: obtaining, with one or more processors of a processing system, a graph having a plurality of nodes from a database; generating, with the one or more processors, a personal web page rank vector for a given node of the plurality of nodes; and producing, with the one or more processors, an embedding vector for the given node by randomly projecting the personal web page rank vector, wherein the embedding vector has a lower dimensionality than the personal web page rank vector. In some aspects, the method further comprises one or more of the following steps performed in parallel with one or more steps of claim 11 : generating, with the one or more processors, an additional personal web page rank vector for an additional node of the plurality of nodes, the additional node being different from the given node; and producing, with the one or more processors, an additional embedding vector for the additional node by randomly projecting the additional personal web page rank vector, wherein the additional embedding vector has a lower dimensionality than the additional personal web page rank vector. In some aspects, generating the personal web page rank vector for the given node is based at least in part on a precision value. In some aspects, generating the personal web page rank vector for the given node is based at least in part on a return probability. In some aspects, the personal web page rank vector is a sparse vector. In some aspects, producing the embedding vector for the given node by randomly projecting the personal web page rank vector is based at least in part on a preselected dimensionality of the embedding vector. In some aspects, producing the embedding vector for the given node by randomly projecting the personal web page rank vector is based at least in part on one or more hash functions. In some aspects, the method further comprises updating an embedding of the graph based on the embedding vector for the given node. In some aspects, the method further comprises producing a link prediction based at least in part on the embedding vector for the given node, wherein the link prediction represents a prediction of a new link between the given node and another node of the plurality of nodes. In some aspects, the method further comprises producing a node classification based at least in part on the embedding vector for the given node, wherein the node classification represents a prediction of information to be associated with the given node based on one or more features of other nodes of the plurality of nodes that are adjacent to the given node. BRIEF DESCRIPTION OF DRAWINGS

[0007] Figure 1 is a functional diagram of an example system in accordance with aspects of the present disclosure.

[0008] Figure 2 is a functional diagram of an example system in accordance with aspects of the present disclosure.

[0009] Figure 3 is a flowchart illustrating an example method for generating a local node embedding for a selected node v in a graph G having n total nodes in accordance with aspects of the present disclosure.

[0010] Figure 4is a flowchart showing an exemplary method for generating a PPR vector for a selected node v in a graph G having n total nodes, in accordance with aspects of the present disclosure.

[0011] Figure 5 is a flowchart showing an exemplary method for performing a random projection of a PPR vector to generate a local node embedding for a selected node v, in accordance with aspects of the present disclosure. DETAILED DESCRIPTION

[0012] The present technology will now be described with reference to the following exemplary systems and methods.

[0013] Example system

[0014] In Figure 1 A high-level system diagram 100 of an exemplary processing system for performing the methods described herein is shown in FIG. 1. The processing system 102 can include one or more processors 104 and memory 106 storing instructions and data. The instructions and data can include the graphs, node embeddings, and routines described herein. The processing system 102 can reside on a single computing device. For example, the processing system 102 can be a server, personal computer, or mobile device, and the graphs, node embeddings, and routines can thus be local to that single computing device. Similarly, the processing system 102 can reside on a cloud computing system or other distributed system, such that the graphs, node embeddings, and routines can reside on one or more different physical computing devices.

[0015] At this point, Figure 2 A further high-level system diagram 200 is shown, in which an exemplary processing system 202 for performing the methods described herein is shown as a set of n servers 202a-202n, each of which includes one or more processors 204 and memory 206 storing instructions 208 and data 210. Further, in the example of Figure 2 The processing system 202 is shown in communication with one or more networks 212 through which the processing system 202 can communicate with one or more other computing devices, in the example of FIG. 2. For example, the one or more networks 212 can allow a user to interact with the processing system 202 using a personal computing device 214 (which is shown as a laptop computer, but can take any known form, including a desktop computer, tablet, smartphone, etc.). Likewise, the one or more networks 212 can allow the processing system 202 to communicate with one or more remote databases, such as database 216. At this point, in some aspects of the present technology, the database 216 can store the graphs, node embeddings, and / or routines described herein, and thus can form (along with the processing system 202) a distributed processing system for practicing the methods described below.

[0016] The processing systems described herein can be implemented on any type of computing device, such as any type of general purpose computing device, server, or collection thereof, and can further include other components typically present in a general purpose computing device or server. The memory 106, 206 stores information accessible by the one or more processors 104, 204, including instructions 108, 208 that can be executed or otherwise used by the processor 104, 204, and data 110, 210 which can be retrieved, manipulated or stored by the processor 104, 204. The memory 106, 206 can be of any non-transitory type of which the one or more processors 104, 204 are capable of accessing. For example, the memory 106, 206 can include non-transitory media such as a hard drive, memory card, optical disc, solid-state memory, tape storage, etc. Computing devices suitable for the roles described herein can include different combinations of the foregoing, whereby different portions of the instructions and data are stored on different types of media.

[0017] In all cases, the computing devices described herein can further include any other components typically used in conjunction with a computing device such as a user interface subsystem. A user interface subsystem can include one or more user inputs (e.g., a mouse, keyboard, touchscreen, and / or microphone) and one or more electronic displays (e.g., a monitor having a screen or any other electronic device operable to display information). In addition to electronic displays, output devices such as speakers, lights, and vibrating, pulsing, or haptic elements can also be included in the computing devices described herein.

[0018] The one or more processors included in each computing device can be any conventional processor such as commercially available central processing units (“CPUs”), graphics processing units (“GPUs”), tensor processing units (“TPUs”), etc. Alternatively, the one or more processors can be a dedicated device such as an ASIC or other hardware-based processor. Each processor can have multiple cores capable of operating in parallel. The processors, memory, and other elements of a single computing device can be stored within a single physical housing, or can be distributed among two or more housings. Similarly, the memory of a computing device can include a hard drive or other storage media located in a housing different from that of the processor (such as in an external database or networked storage device). Thus, a reference to a processor or computing device will be understood to include a reference to a collection of processors or computing devices or memory that can operate in parallel, or can not operate in parallel, as well as to one or more servers of a load-balanced server farm or cloud-based system.

[0019] The computing devices described herein can store instructions that are either directly executable by the processor (such as machine code) or indirectly executable (such as scripts). The computing devices can also store data that can be retrieved, stored or modified by one or more processors in accordance with the instructions. The instructions can be stored as computing device code on a computing device-readable medium of the computing device. In this context, the terms "instructions" and "programs" can be used interchangeably herein. The instructions can also be stored in the object code format for direct processing by the processor, or in any other computing device language including scripts or collections of independent source code modules, that are interpreted on demand or precompiled. As examples, the programming language can be C#,

[0020] Example method

[0021] Figure 3 An exemplary method 300 is depicted showing how a processing system (e.g., processing system 102 or 202) can generate a local node embedding for a selected node v in a graph G having n total nodes, in accordance with aspects of the present disclosure.

[0022] In step 302, the processing system receives a selected node v, a desired dimensionality d of the node embedding, a desired precision ε and return probability a to be used in computing a personalized PageRank ("PPR") vector, and a random hash function h d and h sgn as inputs.

[0023] The function h d and h sgn is a global hash function. In the exemplary method of Figure 3 and Figure 5 , h d is a function randomly sampled from a universal hash family U d that returns natural numbers between 0 and (d - 1), and h sgn is a function randomly sampled from a universal hash family U -1，1 that returns -1 or 1. However, any suitable random projection based hashing strategy for reducing the dimensionality of the PPR vector can be used, as long as it provides an unbiased estimator for the inner product value computed in step 512 (below) of Figure 5 , and requires less than O(n) memory and provides a bounded variance. For example, in some aspects of the present technology, the variance of the inner product computed in step 512 can be O(log(n 2 / d)).

[0024] Precision ∈ is a value representing the error factor for the PPR approximation. This precision value ∈, together with the local topology of the graph, effectively determines how large a neighborhood around node v will need to be stored in short-term memory and processed in order to estimate the PPR vector of node v. At this point, when Figure 3 and Figure 4 When the PushFlow routine described in the example methods estimates the true PPR value for each node, depending on the factor ∈ , a smaller ∈ value gives a better overall approximation, at the cost of requiring more iterations and short-term memory. The accuracy value ∈ can be “tuned” by testing different values ​​of ∈ on the dataset until a suitable result is achieved and then using that value for future PPR estimates. For example, the value ∈ can be tuned so that the size of the PPR approximation does not exceed a predefined memory limit, such as the amount of memory available on the computing device, the size of the processor's memory cache, etc.

[0025] The return probability α is a value representing the probability that a given "random walk" from node v will eventually return (or "teleport") to node v before reaching the end of the neighborhood (defined by the precision value ∈). This return probability value α, together with the local topology of the graph, effectively determines how the PPR vector will unfold from node v. The return probability α can be a measured value or an assumed value. For example, if graph G represents a set of web pages, the return probability α can be calculated based on the frequency with which a set of actual users surfing those web pages start from a given web page and eventually return to that same web page. However, in some aspects of this technique, the return probability α can simply be a selected value. In this respect, similar to the precision value ∈, the return probability α can also be "tuned" by testing different values ​​of α on the dataset until a suitable result is achieved and then using that value for future PPR estimations.

[0026] In step 304, the processing system calculates the PPR vector of node v based on graph G, node v, precision value ∈, and return probability α, and stores the PPR vector in πv. For illustration... Figures 3 to 5 As an example method, we will assume that πv is a vector with z components [c1, c2, c3, ..., c2]. z A vector πv. Each component c of the vector πv is an index-value pair such that c... j =(j, r j The node identifier j can be an integer or any other unique hashable identifier, such as a string. Using index-value pairs for each component of πv allows the PPR vector to store only non-zero elements. Therefore, although the PPR vector will have n values ​​for a graph with n total nodes, using index-value pairs allows πv to store only non-zero values, resulting in a smaller number of only z total components.

[0027] In Figure 3 and Figure 4 example, the processing system will use a sparse personalized web page rank routine called PushFlow to compute the PPR vector for node v, PushFlow is described in Andersen et al., Using pagerank to locally partition a graph (Internet Mathematics 4.1 (2007), pages 35-64). However, the present technology can utilize any routine for computing PPR that employs heuristics that guarantee its locality, such as the PPR routines described in Bahmani et al., Fast Incremental and Personalized PageRank (Proceedings of the VLDB Endowment, Volume 4, Issue 3 (2011), pages 173-184); Lofgren et al., Personalized PageRank to a Target Node (arXiv: 1304.4658v2, April 11, 2014); or Yang et al., P-Norm Flow Diffusion for Local Graph Clustering (SIAM Workshop on Network Science 2020), available at https: / / ns20.cs.cornell.edu / abstracts / SIAMNS_2020_paper_12.pdf. Moreover, in some aspects of the present technology, an adjacency matrix representing all connections between all nodes within graph G can be used in place of the PPR vector, and this adjacency matrix can then be randomly projected (as described below). Moreover, in some aspects of the present technology, the adjacency matrix can be powered and then randomly projected (again, as described below).

[0028] In step 306, the processing system performs a random projection on the PPR vector πvbased on a random hash function h d and h sgn This produces a final vector w of dimension d representing an updated local node embedding for node v. As described above, this vector w can be used for downstream tasks specific to node v, such as classifying node v, or generating link predictions for node v. At this point, in addition to creating an updated vector for node v, the process can be repeated for one or more additional nodes adjacent to node vFigure 3 This method ensures that any such classification or node prediction for node v will also take into account any updated properties of its neighboring nodes. Similarly, for applications where additional updates to representations are needed for other nodes elsewhere in the graph (e.g., nodes not adjacent to node v), updates can be made for each of these remote nodes. Figure 3 The method.

[0029] Furthermore, since the method described in this paper creates an updated representation of node v that is consistent with the representations of other nodes in graph G, the processing system can dynamically generate updated node representations whenever a node is modified. In this way, vector w can be integrated with the existing node embeddings of graph G, enabling downstream tasks that depend on the entire graph embedding (e.g., visualization tasks) to be performed on the fully updated graph embedding.

[0030] Figure 4 An exemplary method 400, depicting a processing system (e.g., processing system 102 or 202) according to various aspects of this disclosure, is provided to illustrate how a processing system can generate a PPR vector for a selected node v in a graph G having n total nodes. In this respect, in some aspects of the art, method 400 can be used to compute the PPR vector, as described above regarding... Figure 3 As described in step 304.

[0031] In step 402, the processing system receives the selected node v, precision ∈, and return probability α (each of which has been described above) to be used when computing the PPR vector as input. The processing system will also have access to graph G. However, for the purposes of method 400, graph G does not need to be stored in short-term memory, thereby reducing short-term memory consumption.

[0032] In step 404, the processing system initializes the residual vector r as an empty sparse vector with dimension n. In other words, the residual vector r is initialized as a sparse vector with n possible components, each of which is initially empty. Again, n is a number representing the total number of nodes in graph G.

[0033] In step 406, the processing system initializes the PPR vector π as an empty sparse vector with dimension n. Therefore, the PPR vector π is also initialized as a sparse vector with n possible components, each of which is initially empty.

[0034] In step 408, an initial value of 1 is assigned to the elements of the residual vector r or r[v] corresponding to the selected node v.

[0035] In step 410, the loop of steps 412 to 418 is repeated starting while, for any node w in graph G, the residual value r[w] for that node is greater than the degree of the node multiplied by a selected precision value e. At this point, the degree of node w or deg(w) represents the number of nodes that node w is connected to. Thus, in the first round, when r[v] has been initialised to 1, the condition can be met in respect of node v (assuming reasonable values for e and deg(w)) and the loop will start as indicated by the "Yes" arrow pointing to step 412.

[0036] In step 412, the processing system copies the existing value of r[w] to a temporary variable. For the purposes of illustrating the example method 400, this temporary variable will be referred to as r'.

[0037] In step 414, the processing system increments the existing value of r[w] by (a*r'). This results in the increased value being stored in the component of r associated with node w, thereby implicitly creating an index-value pair between node w and the increased value. For example, on the first step where r is initially empty, step 414 will result in (a*r') being stored to r[w], which will implicitly create the index-value pair (w, (a*r')) within r.

[0038] In step 416, the processing system assigns a new value to r[w] in accordance with the following Equation 1. Since Equation 1 multiplies the stored value of r[w] or r' by the fraction ((1 - a) / 2), this results in the value of r[w] being decreased.

[0039]

[0040] In step 418, for each node u connected to node w, the processing system increases the residual value r[u] of that node in accordance with the following Equation 2.

[0041]

[0042] In this case, when deg(w) will return the number of nodes connected to node w, Equation 2 results in the residual value of each node u being increased by an equal share of the original residual value of node w. In total, the original residual value r' of node w will therefore be split as follows during a round through steps 412 to 418:

[0043] • (a*r') will be allocated to r[w] as described in step 414;

[0044] • [((1 - a)r') / 2] will remain in r[w] as described in step 416; and

[0045] • [((1 - a) r') / 2] will be split equally among each r[u] as described in step 418.

[0046] Thus, steps 410-418 result in node w having "too much" residual value (as determined by the test in step 410), causing that residual value to flow away from r[w] and into the PPR value for node w and the residuals for its neighboring nodes u.

[0047] After each round through steps 410-418, the loop will return to step 410 (as indicated by the arrow connecting step 418 back to step 410) for another determination of whether there are any nodes with "too much" residual value. At this point, as a result of how the residual values are redistributed in steps 410-418, it is possible that each round creates additional nodes with "too much" residual value. Thus, the loop of steps 410-418 will repeat until, at step 410, the processing system determines that there are no remaining nodes with "too much" residual value. At this point, the existing form of the p vector will be the final PPR vector for nodes v, and the method will proceed to step 420, as indicated by the "no" arrow.

[0048] The p vector produced at the end of steps 410-418 will be a sparse PPR vector for nodes v, containing only the non-zero values (and their associated index values) stored to p[w] in each round through steps 410-418. Thus, in step 420, the processing system will return the sparse PPR vector as the final PPR vector p.

[0049] Although the resulting PPR vector p can have a much lower dimensionality than it would have in the case where it is not sparse (and thus also must store zero values for any nodes that were not updated in a round through steps 410-418), even p can still have too high a dimensionality for it to be used for certain tasks and / or on certain hardware platforms. In this regard, because large input vectors increase the size (and speed) of models that use it, the relatively high dimensionality of p can make it impractical or impossible to use as an input to other models. For example, a p vector with 1 million entries for nodes would require a model to have at least 1 million * k parameters, where k is the output size of the first hidden layer. Thus, a model of that size can become too large to fit into the memory of a given computing device. Likewise, larger models take longer to train and evaluate.

[0050] Accordingly, to produce more usable local node embeddings, the present technology relies on random projections to reduce the dimensionality of πv. This enables πvto be converted into a low-dimensional embedding that the model can learn to generalize from using only a small number of training examples. The smaller dimensionality of the embedding also allows the model to be much smaller and require less computational power, enabling the embedding to be used on computing devices such as mobile phones, tablets, and personal computers as opposed to larger and more powerful computing devices such as enterprise-level hardware. Additionally, the smaller individual node embeddings will produce proportionally smaller graph embeddings, allowing for the use of a full graph representation in situations where it would simply be infeasible to instantiate a full PPR matrix.

[0051] Figure 5 An exemplary method 500 is depicted that shows how a processing system (e.g., processing system 102 or 202) can perform a random projection of a PPR vector to generate a local node embedding for a selected node v in accordance with aspects of the present disclosure. In this regard, in some aspects of the present technology, method 500 can be used to perform the random projection described above with respect to step 306 of method 400. Figure 3

[0052] In step 502, the processing system receives as input the PPR vector πvto be randomly projected, the desired dimensionality d of the node embedding, and the random hash function h d and h sgn each of which have been described above.

[0053] In step 504, the processing system initializes an empty vector w having dimensionality d. In other words, w is initialized as a vector having d components, each of which is 0.

[0054] In step 506, the processing system initializes a variable j with a value of 1.

[0055] In step 508, a loop begins in which steps 510-514 are performed for each component cj in πv. Again, as described above, πvconsists of the non-zero values of the PPR vector for node v, and each component cj is an index-value pair such that c j = (j, r j ).

[0056] In step 510, the processing system computes h d (j) and h sgn (j) using the global hash function described above.

[0057] In step 512, the processing system uses the random natural number returned by the hash function h d (j) to select a component of the vector w (denoted herein as w ​), and increases selected components of the vector w according to Equation 3 below.

[0058]

[0059] In step 514, the processing system determines whether the current value of j is less than the number of components z in the PPR vector πv. If so, the processing system will follow the "yes" arrow to step 516. At step 516, the processing system increases j by 1, and then follows the arrow back to step 508, so that steps 510 through 514 can be repeated for the next component of πv.

[0060] This loop will continue to repeat for each next value of j until, at step 514, the processing system determines that j is not less than z, at which time the processing system will follow the "no" arrow forward to step 518. At step 518, the processing system will return the vector w, which represents the updated local node embedding for node v.

[0061] The above alternative examples are not mutually exclusive unless otherwise specified, but can be implemented in various combinations to achieve unique advantages. Since these and other variations and combinations of features described above can be utilized without departing from the subject matter defined by the claims, the description of the exemplary systems and methods should be regarded as illustrative rather than restrictive, and the description should be construed in accordance with the teachings provided herein rather than in accordance with the description of the exemplary examples. Moreover, the provision of the examples described herein, including the descriptions of the examples in the Summary section of this document, should not be construed as limiting the scope of the claims to the specific examples presented herein; rather, the examples are intended to provide illustrative examples of the many possible embodiments of the subject matter defined by the claims. In addition, the same reference numerals in different drawings can identify the same or similar elements.

Claims

1. A processing system, comprising: Memory; as well as One or more processors, coupled to the memory and configured to perform the following operations: Accessing a graph with multiple nodes from a database; A local personal webpage ranking algorithm is used to generate a personal webpage ranking vector for a given node among the plurality of nodes, wherein the personal webpage ranking vector is generated for the given node based at least in part on a precision value of the personal webpage ranking vector, the precision value together with the local topology of the graph around the given node to determine how large a neighborhood around the given node will need to be stored in short-term memory and processed, and the precision value is selected based on predefined memory limits. as well as An embedding vector is generated for the given node by randomly projecting the personal webpage ranking vector, wherein the embedding vector has a lower dimension than the personal webpage ranking vector.

2. The system according to claim 1, wherein, The one or more processors are further configured to perform the following operations, and to perform one or more of the following operations in parallel with one or more operations of claim 1: The local personal webpage ranking algorithm is used to generate additional personal webpage ranking vectors for other nodes among the plurality of nodes, wherein the additional nodes are different from the given node, and the additional personal webpage ranking vectors for the additional nodes are generated at least in part based on the precision value; and An additional embedding vector is generated for the other node by randomly projecting the other personal webpage ranking vector, wherein the additional embedding vector has a lower dimension than the other personal webpage ranking vector.

3. The system according to claim 1, wherein, The one or more processors are further configured to generate the personal webpage ranking vector for the given node based at least in part on the return probability.

4. The system according to claim 1, wherein, The one or more processors are further configured to generate the individual webpage ranking vector as a sparse vector.

5. The system according to claim 1, wherein, The one or more processors are further configured to update the embedding of the graph based on the embedding vector of the given node.

6. The system according to claim 1, wherein, The one or more processors are further configured to generate link predictions at least in part based on the embedding vector of the given node, wherein the link predictions represent predictions of new links between the given node and another node among the plurality of nodes.

7. The system according to claim 1, wherein, The one or more processors are further configured to generate a node classification based at least in part on the embedding vector of the given node, wherein the node classification represents a prediction of information to be associated with the given node based on one or more features of other nodes adjacent to the given node among the plurality of nodes.

8. The system according to claim 1, wherein, The one or more processors are further configured to operate as follows: Modify one or more nodes in the graph; and In response to modifications to one or more nodes in the graph, one or more updated embedding vectors are generated for one or more nodes in the graph.

9. The system according to claim 1, wherein, The random projection is based on one or more global hash functions.

10. The system according to claim 9, wherein, The one or more global hash functions include those returning 0 to ( d The first global hash function is sampled from a general hash family of natural numbers between -1 and 1, and the second global hash function is randomly sampled from a general hash family that returns -1 or 1, where d is the dimension of the embedding vector.

11. The system according to any one of claims 9 and 10, wherein, The random projection includes: Initialize dimensions with zero values d vector w ; For a predetermined number of iterations: For each non-zero value of the personal webpage ranking vector: The values ​​of the first and second global hash functions are determined based on variable j; The vector to be modified is selected based on the value of the first global hash function. w The amount, and The vector w The selected component is increased by the product of the value of the second global hash function and the non-zero value of the personal webpage ranking vector multiplied by the logarithm of the number of nodes in the graph and the maximum value of zero; and Output the vector w This serves as the ranking vector for the individual webpage.

12. A computer-implemented method, comprising the following steps: Access a graph with multiple nodes from a database using one or more processors of the processing system; The one or more processors use a local personal webpage ranking algorithm to generate a personal webpage ranking vector for a given node among the plurality of nodes, wherein the personal webpage ranking vector is generated for the given node based at least in part on a precision value of the personal webpage ranking vector, the precision value together with the local topology of the graph around the given node to determine how large a neighborhood around the given node will need to be stored in short-term memory and processed, and the precision value is selected based on predefined memory limits; as well as The one or more processors are used to generate an embedding vector for the given node by randomly projecting the personal webpage ranking vector, wherein the embedding vector has a lower dimension than the personal webpage ranking vector.

13. The method of claim 12, further comprising the step of wherein one or more steps of claim 12 are performed in parallel with one or more steps of claim 12: Using the one or more processors, the local personal webpage ranking algorithm is used to generate additional personal webpage ranking vectors for other nodes among the plurality of nodes, wherein the additional nodes are different from the given node, and the additional personal webpage ranking vectors for the additional nodes are generated at least in part based on the precision value; and The one or more processors are used to generate additional embedding vectors for the additional nodes by randomly projecting the additional personal webpage ranking vectors, wherein... The additional embedding vector has a lower dimension than the additional personal webpage ranking vector.

14. The method according to claim 12, wherein, The generation of the personal webpage ranking vector for the given node is based at least in part on the return probability.

15. The method according to claim 12, wherein, The personal webpage ranking vector is a sparse vector.

16. The method of claim 12, further comprising updating the embedding of the graph based on the embedding vector of the given node.

17. The method of claim 12, further comprising generating link predictions at least in part based on the embedding vector of the given node, wherein, The link prediction refers to the prediction of a new link between the given node and another node among the plurality of nodes.

18. The method of claim 12, further comprising generating a node classification at least in part based on the embedding vector of the given node, wherein, The node classification represents a prediction of information to be associated with the given node based on one or more features of other nodes adjacent to the given node among the plurality of nodes.

19. The method of claim 12, further comprising: Modify one or more nodes in the graph; as well as In response to modifications to one or more nodes in the graph, one or more updated embedding vectors are generated for one or more nodes in the graph.

20. The method according to claim 12, wherein, The random projection is based on one or more global hash functions.

21. The method according to claim 20, wherein, The one or more global hash functions include those returning 0 to ( d The first global hash function is sampled from a general hash family of natural numbers between -1 and 1, and the second global hash function is randomly sampled from a general hash family that returns -1 or 1, where d is the dimension of the embedding vector.

22. The method according to any one of claims 20 and 21, wherein, The random projection includes: Initialize dimensions with zero values d vector w ; For a predetermined number of iterations: For each non-zero value of the personal webpage ranking vector: The values ​​of the first and second global hash functions are determined based on variable j; The vector to be modified is selected based on the value of the first global hash function. w The amount, and The vector w The selected component is increased by the product of the value of the second global hash function and the non-zero value of the personal webpage ranking vector multiplied by the logarithm of the number of nodes in the graph and the maximum value of zero; and Output the vector w as the ranking vector for the individual webpage.

23. A computer program product comprising computer-readable instructions that, when executed by a computer, cause the computer to perform the method according to any one of claims 12 to 22.

Images