Learning attribute graph representation edge by edge

Abstract

Techniques for learning a property graph representation edge by edge are described. An input graph includes a plurality of vertices and a plurality of edges. Each vertex in the plurality of vertices is associated with a vertex property of the corresponding vertex. A vertex-to-property mapping is generated, the mapping mapping each vertex to a vertex property signature in a plurality of vertex property signatures. A plurality of edge words are generated. Each edge word corresponds to one or more edges, each edge starting at a first vertex having a particular vertex property signature in the plurality of vertex property signatures and terminating at a second vertex having a particular vertex property signature in the plurality of vertex property signatures. A plurality of sentences are generated, each sentence comprising edge words connected along a path in a plurality of paths in the input graph. A document vectorization model is used to generate a machine learning vector representing the input graph.

Description

Technical Field

[0001] The present invention relates to graph processing and machine learning techniques based on learned graph representations. Background Art

[0002] The approaches described in this section are approaches that could be pursued, but not necessarily approaches that have been previously conceived or pursued. Therefore, unless otherwise indicated, it should not be assumed that any approach described in this section qualifies as prior art merely by virtue of its inclusion in this section.

[0003] The important capability of property graphs is their ability to model the underlying relationships in the graph and capture link information (i.e., entity relationships) that other data models cannot capture. In any property graph, nodes (i.e., entities) and edges (i.e., link relationships between entities) are associated with some properties, which are <key, value> pairs, such as label:customer (label: customer) or label:employee (label: employee).

[0004] At the same time, machine learning techniques are being adopted in multiple fields to discover "hidden insights" by learning from patterns and trends in data. Property graphs are used for various tasks, such as link prediction (e.g., friendship recommendation), classification (e.g., fraud detection), ranking (e.g., node importance), or similarity search (e.g., searching for similar compounds). Such tasks bring about the possibility of applying various machine learning techniques to property graphs.

[0005] Graph representation learning has enabled a smooth integration of machine learning techniques and property graphs. The goal of graph representation learning is to find task-independent ways to represent graph structures (in low-dimensional space) so that classical machine learning models can be used for multiple applications using the learned representations. One approach to characterize graph structures is graph kernels, which mainly use hand-crafted features such as shortest paths, graphlets, and page rank scores. However, neural embeddings provide a new direction for graph representation learning: combining the success of machine learning with property graphs.

[0006] One type of representation learning is vertex-level representation learning, which represents close nodes (where closeness can be structural proximity or attribute-oriented proximity) as similar vectors in the representation vector space. This learning objective is beneficial for vertex-level tasks such as vertex classification or vertex clustering. Traditionally, machine learning techniques rely on handcrafted user-defined features (e.g., centrality measures) to encode structural information about vertices in the graph. However, another approach is to learn embeddings by adopting random walks (taking vertices as learning units), followed by skipgram models to learn vertex representations. A variant of random walk maximizes the likelihood of preserving the neighborhood of a node by exploring different neighborhoods using biased random walks.

[0007] Some tasks may require a higher granularity of the graph, i.e., a representation of the entire graph, compared to a vertex-level representation. Graph representations can benefit multiple tasks, such as graph classification tasks (fraud or anomalous patterns), similarity searches on databases of graphs (e.g., drugs), or even fingerprinting. Similar to vertex representations, there is the option of handcrafted user-defined features to encode structural information of the graph (e.g., subgraphs). Another approach considers the entire graph as a document and the rooted subgraph surrounding each node in the graph as the words that constitute the document, but does not consider any ordering between the words (i.e., subgraphs).

[0008] However, both representations have their drawbacks as neither is optimal when used with various machine learning models.

[0009] This article discusses methods for improving the quality of graph-based machine learning results.

[0010] The approaches described in this section are approaches that could be pursued, but not necessarily approaches that have been previously conceived or pursued. Therefore, unless otherwise indicated, it should not be assumed that any approach described in this section qualifies as prior art merely by virtue of its inclusion in this section. BRIEF DESCRIPTION OF THE DRAWINGS

[0011] In the attached figure:

[0012] Figure 1 A property graph with associated properties for each vertex is illustrated.

[0013] Figure 2 Illustration of the marginal word generation graph.

[0014] Figure 3 An example process for edge-by-edge learning of a property graph representation is shown in accordance with an embodiment.

[0015] Figure 4The improved classification accuracy using the techniques described in this article and two different datasets is illustrated.

[0016] Figure 5 is a diagram depicting a software system upon which embodiments of the present invention may be implemented.

[0017] Figure 6 is a diagram depicting a computer system that may be used in embodiments of the present invention. DETAILED DESCRIPTION

[0018] In the following description, for the purpose of explanation, many specific details are set forth in order to provide a thorough understanding of the present invention. However, it will be apparent that the present invention can be practiced without these specific details. In other cases, well-known structures and devices are shown in block diagram form to avoid unnecessary confusion of the present invention.

[0019] General Overview

[0020] This paper describes techniques for learning attributed graph representations edge by edge.

[0021] The property graph includes a plurality of vertices and a plurality of edges. Each vertex in the plurality of vertices is associated with a vertex attribute of the corresponding vertex. For example, a particular vertex of the property graph may include attributes such as "entity type", "graph size", "similar entity count", and "vertex-id", such as Figure 1 The property diagram shown in .

[0022] Using the property graph, a vertex-to-property mapping is generated for each vertex in a plurality of vertices of the graph. The mapping maps each vertex to a vertex attribute signature in a plurality of vertex attribute signatures, where each vertex attribute signature includes a string representation of a vertex attribute. Using the hyperparameters, a series of random walks are generated. Each random walk includes a sequence of vertex-ids, where each vertex has a set of vertex attributes. For example, Figure 1 A random walk of a graph may include [1~2~3~4] or [1~4~3~2], where each number indicates a vertex-id.

[0023] Then, multiple edge words are generated. Each edge word corresponds to one or more edges of the property graph, each edge starting from a first vertex having a specific vertex attribute signature from a plurality of vertex attribute signatures, and terminating at a second vertex having a specific vertex attribute signature from a plurality of vertex attribute signatures. Each edge word includes a string representation of the concatenation of the vertex attributes of the first vertex and the vertex attributes of the second vertex. For example, an edge word may include the string "Entity:USER Size:M(4)Count:N(1)Entity:ALERT Size:M(4)Count:N(2)" to represent Figure 1 The edge between vertex "1" and vertex "2" in .

[0024] Multiple sentences are then generated. Each sentence includes edge words directly connected along paths in multiple paths in the input graph. Sentences can be generated based on random walks and edge words, and represented by a string of concatenated edge words. For example, a sentence may include the string "Entity:USER Size:M(4)Count:N(1)Entity:ALERT Size:M(4)Count:N(2)Entity:ALERT Size:M(4)Count:N(2)Entity:ADDRESS Size:M(4)Count:N(1)Entity:ADDRESS Size:M(4)Count:N(1)Entity:ALERT Size:M(4)Count:N(2)".

[0025] Using multiple sentences and multiple edge words, a document vectorization model is used to generate a machine learning vector that represents the input graph. As described herein, sentences can be used as input to a vectorization model (such as doc2vec) to produce learned vectors that capture an improved representation of the data of the property graph.

[0026] Therefore, the technique described in this paper extracts features from the attribute graph representation of the dataset. These features can be used to train ML models and serve as very strong signals, significantly improving the quality of the answers.

[0027] Compared to the prior art, the techniques described herein better capture the information of the original graph representation of the data set, resulting in a higher quality of answers and greatly improving the classification accuracy of the machine learning classification model. The techniques described herein result in dimensionality reduction, that is, a low-dimensional representation of the vertices in the graph. The dimensionality of the features can be reduced, thereby requiring smaller input vectors and / or matrices to store and process, thereby reducing the storage and CPU processing required to train the machine learning model or execute the machine learning model in the application of the machine learning model. In addition, the trained machine learning model can have smaller model artifacts (see the machine learning model section), thereby further reducing the storage and CPU processing required to train the machine learning model or execute the machine learning model in the application of the machine learning model.

[0028] Graph Initialization

[0029] Graph analysis software such as Parallel Graph Analysis (PGX) can be used to initialize the property graph for vectorization. As mentioned in this article, PGX is a toolkit for graph analysis—both running algorithms such as PageRank for graphs and performing SQL-like pattern matching for graphs using the results of algorithm analysis. The algorithms are parallelized to achieve excellent performance. The PGX toolkit includes both a single-node in-memory engine and a distributed engine for extremely large graphs. Graphs can be loaded from a variety of sources, including flat files, SQL and NoSQL databases, and Apache Spark and Hadoop. PGX is commercially available through ORACLE.

[0030] In an embodiment, a graph analysis software such as PGX loads a graph having an Edgelist file and an EdgeJSON file. The Edgelist file contains graph information in an edgelist format, which is related to vertex objects and edge objects used to construct the graph.

[0031] The Edge JSON file is a JSON file that reads graph data from the Edgelist file and generates a graph. In an embodiment, the Edge JSON file generates a PgxGraph, which is a java class of a graph that can be operated by PGg. In an embodiment, the "readGraphWithProperties" function of PGX is used to load the graph.

[0032] Graphs are generated based on raw vertex attributes and calculated vertex attributes. In the above edge list format, multiple raw vertex attributes can be predefined when loading the graph into a graph analysis framework (such as PGX). For example, if there are multiple graphs with varying graph-ids, then a vertex attribute can be added that indicates which graph a particular vertex belongs to. The complete collection of graphs can then be loaded into PGX as a single large graph with multiple connected components, and this specific vertex attribute can be used to filter the individual connected components into separate graphs. In addition, all vertices in different graphs are assigned unique vertex-ids in our dataset (i.e., no two graphs will have the same vertex-id).

[0033] Depending on the requirements of the associated ML model that uses the graph data as input, additional vertex attributes, referred to herein as computed attributes, may be defined. For example, an ML model may need to incorporate some "importance" values ​​for individual vertices while matching similar graphs. Such importance values ​​may be added to the vertices as computed attributes. In our empirical evaluation, we also use the size of the graph (of which the vertex is a part) as one of our vertex attributes.

[0034] In another example, the size of the graph that the vertex is a part of can be included as one of the vertex attributes.

[0035] Figure 1 shows a property graph with associated properties for each vertex. Figure 1 , the property graph includes four vertices 102, 104, 106, 108. Each vertex 102, 104, 106, 108 has attributes associated with it, such as "entity", "graph size", "similar entity count" and "vertex-id". The graph includes one primitive attribute for each vertex 102, 104, 106, 108: "entity", and 2 calculated attributes: "property size" and "similar entity count". The attributes may include functions such as "M(..)" and "N(..)" from the "graph size" and "similar entity count" fields, respectively, which may be adjusted depending on the level of granularity required for different attributes. In an embodiment, the property graph is an undirected graph. An undirected graph may be defined as a graph whose edges are unordered pairs of vertices. That is, each edge connects two vertices, and each edge is bidirectional.

[0036] Random Walk

[0037] Once the property graph is initialized, graph analysis software such as PGX can be used to generate random walks of the graph in a parallelized manner. A random walk is a sequence of vertices in the graph. Generating random walks for a graph requires at least two hyperparameters, such as the number of random walks per vertex and the maximum length of a random walk.

[0038] The number of random walks per vertex hyperparameter controls the different possible random walks starting from a given vertex and ideally captures the neighborhood of any given vertex.

[0039] The maximum length of the random walk hyperparameter controls the depth of the neighborhood to be considered for learning the graph representation. This parameter is task dependent and may need to be tuned.

[0040]

[0041] As shown in the above code snippet, the "random_walk_generator" function returns a random walk based on the hyperparameters "length" and "num_walks". In the above code snippet, the collection of all graphs is treated as a single large graph and is input into the "RandomWalkGenerator" function for parallelization of extracting random walks on all graphs. The graph-id corresponding to the random walk is obtained by taking the graph-id attribute of the vertex.

[0042] Figure 2 Illustration of the marginal word generation graph. Figure 2A vertex-to-random walk mapping 202 is included, which maps the random walks generated by the above code snippet to vertex-ids. Each generated random walk is a string of vertex-ids, where each vertex-id of the random walk is separated by a delimiter. Because the hyperparameter 204 indicates that each vertex has 2 walks, where the maximum walk length is 3, in the vertex-to-random walk mapping 202, each vertex-id has two walks, where the length associated with it is 3. As shown, each random walk includes a sequence of vertex-ids, where each vertex has a set of vertex attributes, which can be primitive, calculated, or both.

[0043] Marginal word generation

[0044] After the random walk is generated, an attribute edge vocabulary 206 is generated by utilizing the random walk.

[0045] In an embodiment, there are two sub-steps to create the attribute edge vocabulary 206. The first sub-step includes generating a vertex-to-string mapping 208. To generate the vertex-to-string mapping 208, the vertex-ids of the vertices of the graph are mapped to vertex attribute strings in the following format: "Entity:..Size:M(..)Count:N(..)", where the attributes are "Entity" (the type of entity), "Size" (the number of vertices in the component graph), and "Count" (the number of other similar entities in the component graph). For example, the vertex-to-string mapping 208 shows "vertex-id:1" being mapped to the string "Entity:USER Size:M(4)Count:N(1)".

[0046] The second sub-step includes generating an edge word dictionary. The edges of the graph are identified based on the random walk of each vertex. For example, a mapping 202 of vertices to random walks can be used to identify edges. Each edge includes a source vertex and a destination vertex, for example: "[1~2]", where "1" is the source vertex and "2" is the destination vertex. The strings of the source vertex and destination vertex of the edge are retrieved from the mapping of vertices to strings, and the source vertex and destination vertex of the edge are cascaded to form an edge word. For example, "Entity:USER Size:M(4)Count:N(1)Entity:ALERT Size:M(4)Count:N(2)" represents the edge word of the edge "[1~2]" as shown in the edge word dictionary 210. For each random walk, the edge is determined and mapped to an edge word, as shown in the edge word dictionary 210.

[0047] The edge word dictionary 210 is then used with the vertex-to-random walk mapping 202 to generate the attribute edge vocabulary 206. Edges are identified from the vertex-to-random walk mapping 202, and each edge is replaced with a corresponding edge word from the edge word dictionary. The edge words associated with the random walk are then concatenated to form a sentence for the random walk.

[0048] For example, for the random walk "1~2~3~4", the edges "[1~2]~[2~3]~[3~4]" are identified. The source vertex and the destination vertex of each edge are concatenated to form edge words for each of the three identified edges, which are stored in the edge word dictionary 210. The three edge words are: "Entity:USER Size:M(4)Count:N(1)Entity:ALERT Size:M(4)Count:N(2)", "Entity:ALERT Size:M(4)Count:N(2)Entity:ADDRESS Size:M(4)Count:N(1)", and "Entity:ADDRESS Size:M(4)Count:N(1)Entity:ALERT Size:M(4)Count:N(2)". These three edge words are then concatenated to form a random walk sentence: “Entity:USER Size:M(4)Count:N(1)Entity:ALERT Size:M(4)Count:N(2)Entity:ALERT Size:M(4)Count:N(2)Entity:ADDRESS Size:M(4)Count:N(1)Entity:ADDRESSSize:M(4)Count:N(1)Entity:ALERT Size:M(4Count:N(2)”. Pointers such as “PGX1”, “PGX2”, “PGX3”, “PGX4” can be used to point to sentences consisting of edge words, as shown in the edge word dictionary 210 and the attribute edge vocabulary 206.

[0049] Vectorization

[0050] Once the graph has been transformed into sentences and edge words, these sentences and edge words are used to learn graph representations. Unsupervised algorithms such as Doc2vec can be used to generate vectors based on sentences and edge words. Doc2vec learns fixed-length feature representations from variable-length text (i.e., documents) fragments. Doc2vec treats each graph as a document and the edge words as the corresponding words in that document. The distributed memory model used by Doc2vec employs a neural network as discussed in this article and is optimized for hierarchical softmax and negative sampling to improve actual performance. Technical details and examples of doc2vec are taught in the related reference "DISTRIBUTED REPRESENTATIONS OF SENTENCES AND DOCUMENTS" published by Quoc Le and Tomas Mikolov in June 2014.

[0051] Example Process

[0052] Figure 3 An example process flow 300 for learning a property graph representation edge by edge is shown. Flow 300 is one example of a flow for learning a property graph representation edge by edge. In various arrangements, other flows may include fewer or more elements.

[0053] In step 310, an input graph is received. The input graph includes a plurality of vertices and a plurality of edges, each vertex of the plurality of vertices being associated with a vertex attribute of the vertex. For example, Figure 1 An example input graph is illustrated. Each vertex 102, 104, 106, 108 includes properties such as "entity", "graph size", "similar entity count", and "vertex-id". Each property of each vertex has a corresponding value, such as "USER" for the property "entity".

[0054] In step 320, a vertex-to-attribute mapping is generated for each vertex in the plurality of vertices. The vertex-to-attribute mapping maps each vertex in the plurality of vertices to a vertex attribute signature in the plurality of vertex attribute signatures. For example, Figure 2The vertex-to-string mapping 208 in the figure illustrates an example vertex-to-attribute mapping. As shown in the vertex-to-string mapping 208, each vertex-id is mapped to the attribute and value of the corresponding vertex, which is called a vertex attribute signature. The vertex-to-string mapping 208 shows four different vertex attribute signatures, including: "Entity:USER Size:M(4)Count:N(1)", "Entity:ALERT Size:M(4)Count:N(2)", "Entity:ADDRESS Size:M(4)Count:N(1)", "Entity:ALERT Size:M(4)Count:N(2)". Each vertex attribute signature is mapped to vertex-id: 1, 2, 3, 4 respectively. By Figure 1 It reads attributes and values ​​from the input graph and concatenates each attribute and corresponding value to the string representation of each vertex to generate a vertex-to-attribute mapping and a vertex attribute signature.

[0055] In step 330, a plurality of edge words are generated. Each edge word in the plurality of edge words corresponds to one or more edges, each edge starting at a first vertex having a first specific vertex attribute signature in a plurality of vertex attribute signatures and terminating at a second vertex having a second specific vertex attribute signature in a plurality of vertex attribute signatures. For example, Figure 2 The edge word dictionary 210 in the figure illustrates examples of multiple edge words. As shown in the edge word dictionary 210, each edge word is mapped to a corresponding edge. The edge word dictionary 210 lists four edge words, including: "Entity:USER Size:M(4)Count:N(1)Entity:ALERT Size:M(4)Count:N(2)", "Entity:ALERT, Size:M(4)Count:N(2)Entity:ADDRESS Size:M(4)Count:N(1)", "Entity:ADDRESS Size:M(4)Count:N(1)Entity:ALERT Size:M(4)Count:N(2)", "Entity:ALERT Size:M(4)Count:N(2)Entity:USER Size:M(4)Count:N(1)". Each edge word is associated with one or more edges, as shown in the edge word dictionary 210.

[0056] In an embodiment, edge words are generated based on edges identified from random walks and vertex-to-attribute mappings. Once an edge is identified from a random walk, the vertex attribute signatures of each vertex of the edge are concatenated to generate an edge word. For example, according to the vertex-to-random walk mapping 202, vertex-id:1 includes random walks 1-2-3-4 and 1-4-3-2. According to the random walk, several edges are identified, including [1-2], [2-3], [3-4], [1-4], [4-3], [3-2]. For edge [1-2], the edge starts at vertex "1" and ends at vertex "2". The vertex-to-string mapping 208 identifies the vertex-to-attribute signatures of each vertex as "Entity:USER Size:M(4)Count:N(1)" and "Entity:ALERT Size:M(4)Count:N(2)", respectively. The vertex attribute signatures are then concatenated to generate edge words: “Entity: USER Size: M(4) Count: N(1) Entity: ALERT Size: M(4) Count: N(2)”, and the edge words are stored in edge word dictionary 210. As shown in edge word dictionary 210, the edge word “Entity: USER Size: M(4) Count: N(1) Entity: ALERT Size: M(4) Count: N(2)” corresponds to two edges: “[1-2], [1-4]”.

[0057] In step 340, a plurality of sentences are generated, each of which includes edge words directly connected along a path in the plurality of paths in the input graph. For example, Figure 2 The attribute edge vocabulary table 206 in the diagram illustrates multiple generated sentences. Each entry in the attribute edge vocabulary table 206 represents a sentence. The first entry "[1~2]~[2~3]~[3~4]=PGX1~PGX2~PGX3". The pointers "PGX1", "PGX2", and "PGX3" point to the edge words in the edge word dictionary 210.

[0058] Identify a path from a random walk. For example, according to the mapping 202 of vertices to random walks, the random walk "1-2-3-4" is converted into a sequential set of edges, such as "[1-2]-[2-3]-[3-4]". The edge word dictionary 210 is used to identify each edge word corresponding to each edge of the path. For example, the edge word dictionary 210 is used to identify that the edge [1-2] is mapped to the edge word: "Entity:USER Size:M(4)Count:N(1)Entity:ALERT Size:M(4)Count:N(2)", which also corresponds to the pointer "PGX1".

[0059] Once each edge word in the path is identified, these edge words are concatenated to form a sentence. For example, for the path "[1~2]~[2~3]~[3~4]", the sentence is: "Entity:USER Size:M(4)Count:N(1)Entity:ALERT Size:M(4)Count:N(2)Entity:ALERT Size:M(4)Count:N(2)Entity:ADDRESS Size:M(4)Count:N(1)Entity:ADDRESS Size:M(4)Count:N(1)Entity:ALERT Size:M(4)Count:N(2)".

[0060] In step 350, a document vectorization model is used to generate a machine learning vector representing the input graph using the plurality of sentences and the plurality of edge words. For example, the plurality of sentences generated in step 340 are used as input to the document vectorization model. In an embodiment, the document vectorization model includes doc2vec.

[0061] In an embodiment, steps 310-350 are performed for multiple input graphs. Thus, machine learning vectors are generated for multiple input graphs.

[0062] Benefits of improved classification accuracy

[0063] Figure 4 The improved classification accuracy using the techniques described herein and two different data sets is illustrated. For example, the NCI109 data set consists of compounds screened for activity against non-small cell lung cancer and ovarian cancer cell lines. PROTEINS is a collection of graphs (graphs are classified as enzymes or non-enzymes) where nodes are secondary structure elements and edges indicate amino acid sequences or neighborhoods in 3D space. A classifier (e.g., a convolutional neural network) is trained to predict the associated labels of each graph by using the learned embedding for the methods described herein (e.g., using doc2vec to generate vectors of sentences based on edge words) and another method (e.g., using graph2vec as input features of the graph to generate vectors based on the entire graph). The ratio of training:test is set to 9:1, and each data set is evaluated on the test set.

[0064] Compared to another graph representation structure using subgraphs, namely graph2vec, the techniques described herein result in a 15% improvement in classification accuracy. The improvements can be seen graphically in the protein 402 graph and NCII09404, which is the difference in classification accuracy between the graph2vec and doc2vec algorithms. The technical details and examples of graph2vec are taught in the related reference "GRAPH2VEC: LEARNING DISTRIBUTED REPRESENTATIONS OF GRAPHS" by Annamalai Narayanan, Mahinthan Chandramohan, Rajaskar Venkatesan, Lihui Chen, Yang Liu, and Shantanu Jaiswa in July 2017. This improvement is attributed to the effect of attribute edges as compact learning units, while subgraph representations suffer in part from the sparsity problem of embedding due to the strict embedding attribute relationships in their subgraph learning units.

[0065] cloud computing

[0066] The term "cloud computing" is used generally herein to describe a computing model that enables on-demand access to a shared pool of computing resources, such as computer networks, servers, software applications, and services, and allows resources to be rapidly provisioned and released with minimal management effort or service provider interaction.

[0067] A cloud computing environment (sometimes referred to as a cloud environment or just a cloud) can be implemented in a variety of different ways to best suit different requirements. For example, in a public cloud environment, the underlying computing infrastructure is owned by an organization that makes its cloud services available to other organizations or the public. In contrast, a private cloud environment is generally intended for use by or within a single organization. A community cloud is intended to be shared by several organizations within a community; while a hybrid cloud includes two or more types of clouds (e.g., private, community, or public) bound together by data and application portability.

[0068] In general, the cloud computing model enables some of those responsibilities that might previously have been provided by an organization's own information technology department to be delivered instead as a service layer within a cloud environment for use by consumers (either inside or outside the organization, depending on the public / private nature of the cloud). Depending on the specific implementation, the precise definition of the components or features provided by or within each cloud service layer may vary, but common examples include: Software as a Service (SaaS), in which consumers use software applications running on a cloud infrastructure, while the SaaS provider manages or controls the underlying cloud infrastructure and applications. Platform as a Service (PaaS), in which consumers can use software programming languages ​​and development tools supported by the PaaS provider to develop, deploy, and otherwise control their own applications, while the PaaS provider manages or controls other aspects of the cloud environment (i.e., everything under the runtime execution environment). Infrastructure as a Service (IaaS), in which consumers can deploy and run arbitrary software applications, and / or provision processes, storage, networks, and other basic computing resources, while the IaaS provider manages or controls the underlying physical cloud infrastructure (i.e., everything below the operating system layer). Database as a Service (DBaaS), in which the consumer uses a database server or database management system running on a cloud infrastructure, while the DbaaS provider manages or controls the underlying cloud infrastructure, applications, and servers, including one or more database servers.

[0069] The above basic computer hardware and software and cloud computing environment are provided to illustrate the basic underlying computer components that can be used to implement the example embodiment(s). However, the example embodiment(s) are not necessarily limited to any particular computing environment or computing device configuration. Instead, the example embodiment(s) can be implemented in any type of system architecture or processing environment that a person skilled in the art will understand from this disclosure as being capable of supporting the features and functions of the example embodiment(s) provided herein.

[0070] Software Overview

[0071] Figure 5 Can be used to control Figure 6 6 is a block diagram of a basic software system 500 for the operation of a computing system 600. The software system 500 and its components (including their connections, relationships, and functions) are merely exemplary and are not meant to limit implementation of the example embodiment(s). Other software systems suitable for implementing the example embodiment(s) may have different components, including components with different connections, relationships, and functions.

[0072] A software system 500 is provided for directing the operation of a computing system 600. The software system 500 includes a kernel or operating system (OS) 510, which may be stored in system memory (RAM) 606 and on fixed storage (eg, hard disk or flash memory) 610.

[0073] OS 510 manages low-level aspects of computer operation, including managing the execution of processes, memory allocation, file input and output (I / O), and device I / O. One or more application programs, represented as 502A, 502B, 502C ... 502N, can be "loaded" (e.g., transferred from fixed storage 610 into memory 606) for execution by system 500. Applications or other software intended for use on computer system 600 can also be stored as a set of downloadable computer-executable instructions, for example, for downloading and installation from an Internet location (e.g., a Web server, app store, or other online service).

[0074] The software system 500 includes a graphical user interface (GUI) 515 for receiving user commands and data in a graphical manner (e.g., "point and click" or "touch gestures"). These inputs can in turn be acted upon by the system 500 according to instructions from the operating system 510 and / or (one or more) applications 502. The GUI 515 is also used to display the results of operations from the OS 510 and (one or more) applications 502, after which the user can provide additional input or terminate the session (e.g., log off).

[0075] The OS 510 may execute directly on the bare hardware 520 (e.g., processor(s) 604) of the computer system 600. Alternatively, a hypervisor or virtual machine monitor (VMM) 530 may be inserted between the bare hardware 520 and the OS 510. In this configuration, the VMM 530 acts as a software "buffer" or virtualization layer between the OS 510 and the bare hardware 520 of the computer system 600.

[0076] VMM 530 instantiates and runs one or more virtual machine instances ("guest machines"). Each guest machine includes a "guest" operating system (such as OS 510) and one or more applications (such as (one or more) applications 502) that are designed to execute on the guest operating system. VMM 530 presents a virtual operating platform to the guest operating system and manages the execution of the guest operating system.

[0077] In some cases, VMM 530 can allow a guest operating system to run as if it were running directly on bare hardware 520 of computer system 600. In these cases, the same version of the guest operating system that is configured to execute directly on bare hardware 520 can also execute on VMM 530 without modification or reconfiguration. In other words, in some cases, VMM 530 can provide full hardware and CPU virtualization to the guest operating system.

[0078] In other cases, the guest operating system may be specially designed or configured to execute on VMM 530 to improve efficiency. In these cases, the guest operating system "knows" that it is executing on a virtual machine monitor. In other words, in some cases, VMM 530 can provide paravirtualization to the guest operating system.

[0079] A computer system process includes an allocation of hardware processor time and an allocation of memory (physical and / or virtual) for storing instructions executed by the hardware processor, for storing data generated by the hardware processor in executing instructions, and / or for storing hardware processor state (e.g., contents of registers) between allocations of hardware processor time when the computer system process is not running. A computer system process runs under the control of an operating system and may run under the control of other programs executing on the computer system.

[0080] Multiple threads can run within a process. Each thread also includes an allocation of hardware processing time, but shares access to the memory allocated to the process. When the thread is not running, this memory is used to store the contents of the processor between allocations. The term "thread" can also be used to refer to a computer system process when multiple threads are not running.

[0081] Machine Learning Models

[0082] A machine learning model is trained using a specific machine learning algorithm. Once trained, the input is applied to the machine learning model to make a prediction, which may also be referred to herein as a predicted output or output.

[0083] A machine learning model includes a model data representation or model artifact. Model artifacts include parameter values, which may be referred to herein as theta values, and are applied to inputs by a machine learning algorithm to generate predicted outputs. Training a machine learning model requires determining theta values ​​of the model artifacts. The structure and organization of theta values ​​depends on the machine learning algorithm.

[0084] In supervised training, training data is used by a supervised training algorithm to train a machine learning model. The training data includes inputs and "known" outputs. In an embodiment, the supervised training algorithm is an iterative process. In each iteration, the machine learning algorithm applies the model product and the input to generate a predicted output. The error or variance between the predicted output and the known output is calculated using an objective function. In practice, the output of the objective function indicates the accuracy of the machine learning model based on the specific state of the model product in the iteration. By applying an optimization algorithm based on the objective function, the theta value of the model product can be adjusted. An example of an optimization algorithm is gradient descent. Iterations can be repeated until the desired accuracy is achieved or some other criterion is met.

[0085] In software implementations, when a machine learning model is referred to as receiving inputs, executing, and / or generating outputs or predictions, a computer system process executing a machine learning algorithm applies a model product to the inputs to generate a predicted output. The computer system process executes the machine learning algorithm by executing software configured to cause the algorithm to be executed.

[0086] Classes of problems that machine learning (ML) excels at include clustering, classification, regression, anomaly detection, prediction, and dimensionality reduction (i.e., simplification). Examples of machine learning algorithms include decision trees, support vector machines (SVMs), Bayesian networks, randomized algorithms such as genetic algorithms (GAs), and connection topologies such as artificial neural networks (ANNs). Implementations of machine learning can rely on matrices, symbolic models, and hierarchical and / or associative data structures. Parameterized (i.e., configurable) implementations of the best types of machine learning algorithms can be found in open source libraries such as Google's TensorFlow for Python and C++ or Georgia Tech's MLPack for C++. Shogun is an open source C++ML library with adapters for several programming languages ​​including C#, Ruby, Lua, Java, Matlab, R, and Python.

[0087] Artificial Neural Networks

[0088] An artificial neural network (ANN) is a machine learning model that models at a high level a system of neurons interconnected by directed edges. An overview of neural networks is described in the context of a hierarchical feedforward neural network. Other types of neural networks share characteristics of the neural networks described below.

[0089] In a layered feedforward network such as a multilayer perceptron (MLP), each layer comprises a set of neurons. A layered neural network comprises an input layer, an output layer, and one or more intermediate layers known as hidden layers.

[0090] The neurons in the input layer and the output layer are referred to as input neurons and output neurons, respectively. Neurons in the hidden layer or the output layer may be referred to as activation neurons in this article. Activation neurons are associated with an activation function. The input layer does not contain any activation neurons.

[0091] From each neuron in the input layer and hidden layer, there may be one or more directed edges pointing to an activated neuron in a subsequent hidden layer or output layer. Each edge is associated with a weight. An edge from a neuron to an activated neuron represents the input from the neuron to the activated neuron, as adjusted by the weight.

[0092] For a given input to a neural network, each neuron in the neural network has an activation value. For an input neuron, the activation value is simply the input value for that input. For an activation neuron, the activation value is the output of the corresponding activation function that activated the neuron.

[0093] Each edge from a particular neuron to an activated neuron represents that the activation value of the particular neuron is the input to the activated neuron, i.e., the input to the activation function of the activated neuron, as adjusted by the weight of the edge. Thus, an activated neuron in a subsequent layer represents that the activation value of the particular neuron is the input to the activation function of the activated neuron, as adjusted by the weight of the edge. An activated neuron may have multiple edges pointing to the activated neuron, each edge representing that the activation value from the originating neuron (as adjusted by the weight of the edge) is the input to the activation function of the activated neuron.

[0094] Each activated neuron is associated with a bias. To generate an activation value for an activated neuron, the neuron's activation function is applied to the weighted activation value and the bias.

[0095] Illustrative data structures for neural networks

[0096] The product of the neural network may include matrices of weights and biases. Training the neural network may iteratively adjust the matrices of weights and biases.

[0097] For layered feedforward networks, as well as other types of neural networks, the product may include one or more matrices of edges W. Matrix W represents the edges from layer L-1 to layer L. Assuming the number of neurons in layers L-1 and L is N[L-1] and N[L] respectively, then the dimensions of matrix W are N[L-1] columns and N[L-1] rows.

[0098] The bias for a particular layer L may also be stored in a matrix B having one column and N[L] rows.

[0099] The matrices W and B may be stored in RAM memory as vectors or arrays, or as a comma-separated set of values ​​in memory. When the product is stored permanently in a persistent storage device, the matrices W and B may be stored as comma-separated values ​​in a compressed and / or serialized form or other suitable persistent form.

[0100] A specific input applied to a neural network includes the value of each input neuron. A specific input can be stored as a vector. The training data includes multiple inputs, each input is called a sample in a sample set. Each sample includes the value of each input neuron. Samples can be stored as a vector of input values, and multiple samples can be stored as a matrix, where each row in the matrix is ​​a sample.

[0101] When input is applied to a neural network, activation values ​​are generated for the hidden and output layers. For each layer, the activation values ​​can be stored in a column of a matrix A that has a row for each neuron in the layer. In a vectorized approach for training, the activation values ​​can be stored in a matrix that has a column for each sample in the training data.

[0102] Training a neural network requires storing and processing additional matrices. The optimization algorithm generates matrices of derivative values ​​used to adjust the weights W and bias B matrices. Generating derivative values ​​can use and require matrices that store intermediate values ​​generated when calculating the activation values ​​of each layer.

[0103] The number of neurons and / or edges determines the size of the matrices required to implement a neural network. The fewer the number of neurons and edges in a neural network, the fewer matrices and the amount of memory required to store the matrices. Additionally, a smaller number of neurons and edges reduces the amount of computation required to apply or train a neural network. Fewer neurons means fewer activation values ​​that need to be calculated and / or fewer derivatives that need to be calculated during training.

[0104] The properties of the matrix used to implement the neural network correspond to neurons and edges. A cell in the matrix W represents a specific edge from the L-1 layer to a neuron in the L layer. An activated neuron represents an activation function for a layer that includes an activation function. An activated neuron in the L layer corresponds to the rows of weights in the matrix W for the edges between the L layer and the L-1 layer and the columns of weights in the matrix W for the edges between the L layer and the L+1 layer. During execution of the neural network, a neuron also corresponds to one or more activation values ​​stored in the matrix A for that layer and generated by the activation function.

[0105] ANN is responsible for vectorization for data parallelism, which can utilize vector hardware, such as single instruction multiple data (SIMD), such as utilizing a graphics processing unit (GPU). Matrix partitioning can achieve horizontal scaling, such as utilizing symmetric multiprocessing (SMP), such as utilizing a multi-core central processing unit (CPU) and / or multiple coprocessors (such as GPU). Feedforward calculations within ANN can occur with only one step per neural layer. The activation values ​​in one layer are calculated based on the weighted propagation of the activation values ​​of the previous layer, so that the values ​​are calculated in turn for each subsequent layer, such as sequentially calculating the values ​​for each subsequent layer, such as utilizing the corresponding iterations of a for loop. Layering imposes an ordering of non-parallelizable calculations. Therefore, the network depth (i.e., the number of layers) may cause computational delays. Deep learning requires giving multilayer perceptrons (MLPs) many layers. Each layer implements data abstraction, while complex (i.e., multidimensional with several inputs) abstractions require multiple layers to implement cascaded processing. Implementations of ANNs based on reusable matrices and matrix operations for feed-forward processing are readily available and parallelizable in neural network libraries such as Google's TensorFlow for Python and C++, OpenNN for C++, and Fast Artificial Neural Networks (FANN) from the University of Copenhagen. These libraries also provide model training algorithms such as backpropagation.

[0106] Backpropagation

[0107] The output of an ANN can be more or less correct. For example, an ANN that recognizes letters may mistake I for L because the letters have similar features. The correct output may have a specific value (one or more), while the actual output may have a slightly different value. The arithmetic or geometric difference between the correct output and the actual output can be measured as an error according to a loss function, such that zero represents error-free (i.e., completely accurate) behavior. For any edge in any layer, the difference between the correct output and the actual output is the delta value.

[0108] Backward propagation requires distributing the error backwards in different amounts to all connected edges within the ANN through the layers of the ANN. The propagation of the error causes the adjustment of the edge weights, which depends on the gradient of the error on each edge. The gradient of the edge is calculated by multiplying the error increment of the edge by the activation value of the upstream neuron. When the gradient is negative, the greater the magnitude of the error contributed by the edge to the network, the more the weight of the edge should be reduced, which is negative reinforcement. When the gradient is positive, positive reinforcement requires increasing the weight of the edge whose activation will reduce the error. The edge weight is adjusted according to the percentage of the gradient of the edge. The steeper the gradient, the greater the adjustment. Not all edge weights are adjusted by the same amount. As model training continues with additional input samples, the error of the ANN should decrease. When the error stabilizes (i.e., stops decreasing) or disappears below a threshold (i.e., close to zero), training can stop. Christopher M. Bishop teaches example mathematical formulas and techniques for a feed-forward multilayer perceptron (MLP), including matrix operations and backpropagation, in the related reference "EXACT CALCULATION OF THE HESSIAN MATRIX FOR THE MULTI-LAYER PERCEPTRON".

[0109] Model training can be supervised, or unsupervised. For supervised training, the expected (i.e., correct) output is already known for each example in the training set. The training set is configured by pre-assigning classification labels to each example (e.g., by a human expert). For example, a training set for optical character recognition may have blurred photos of individual letters, and an expert may pre-label each photo according to which letter is shown. Error calculation and backpropagation occur as explained above.

[0110] Because the desired output needs to be discovered during training, more unsupervised model training is involved. It may be easier to adopt unsupervised training because no human experts are needed to pre-label the training examples. Therefore, unsupervised training saves manpower. The natural way to implement unsupervised training is to use an autoencoder, which is a type of ANN. The autoencoder is used as an encoder / decoder (codec) with two sets of layers. The first set of layers encodes the input example into a compressed code that needs to be learned during model training. The second set of layers decodes the compressed code to regenerate the original input example. The two sets of layers are trained together as a combined ANN. The error is defined as the difference between the original input and the input regenerated after decoding. After sufficient training, the decoder outputs the original input more or less exactly.

[0111] For each input example, the autoencoder relies on a compressed code as an intermediate format. The intermediate compressed code does not exist initially, but only appears through model training, which may be counterintuitive. Unsupervised training can implement an intermediate encoded vocabulary based on features and distinctions of non-expected correlations. For example, which examples and which labels are used during supervised training can depend on the human expert's understanding of the problem space, which is somewhat unscientific (e.g., anecdotal) or incomplete. Unsupervised training, on the other hand, is more or less entirely based on statistical trends to discover a suitable intermediate vocabulary, which reliably converges to optimality with sufficient training due to internal feedback generated by regenerative decoding. The implementation and integration techniques of autoencoders are taught in the related U.S. patent application No. 14 / 558,700 entitled "AUTO-ENCODER ENHANCED SELF-DIAGNOSTIC COMPONENTS FOR MODEL MONITORING". The patent application promotes supervised or unsupervised ANN models to first-class objects, which are responsible for management techniques such as monitoring and governance during model development (such as during training).

[0112] In-depth context overview

[0113] As described above, ANNs can be stateless, so that the timing of activation is more or less independent of ANN behavior. For example, recognizing a specific letter can occur in isolation without context. More complex classifications can depend more or less on additional contextual information. For example, the information content (i.e., complexity) of an instantaneous input can be less than the information content of the surrounding context. Therefore, semantics can occur based on context, such as a time series across inputs or an extended pattern (e.g., a complex geometric shape) within an input example. Various techniques have emerged to make deep learning contextual. A general strategy is context encoding, which packs stimulus inputs and their context (i.e., surrounding / related details) into the same (e.g., dense) coding unit that can be applied to ANNs for analysis. One form of context encoding is graph embedding, which constructs and prunes (e.g., limits its scope) (e.g., in time or semantics) a logical graph of related events or records. Graph embedding can be used as context encoding and input stimuli to ANNs.

[0114] Hidden states (i.e., memories) are powerful ANN enhancements for sequence processing (especially in time). Sorting can facilitate prediction and operational anomaly detection, which can be an important technique. Recurrent neural networks (RNNs) are stateful MLPs that are arranged in topological steps and can be operated more or less as stages of a processing pipeline. In a folded / rolled-up embodiment, all steps have exactly the same connection weights, and a single one-dimensional weight vector can be shared for all steps. In a recursive embodiment, only one step recycles some of its output back to that one step to recursively implement sorting. In an expanded / opened embodiment, each step can have a different connection weight. For example, the weights for each step can appear in the corresponding columns of a two-dimensional weight matrix.

[0115] The sequence of inputs can be applied to the corresponding steps of the RNN simultaneously or sequentially to cause analysis of the entire sequence. For each input in the sequence, the RNN predicts the next sequence input based on all previous inputs in the sequence. The RNN can predict or otherwise output almost all input sequences that have been received and the next sequence input that has not yet been received. Predicting the next input by itself can be valuable. Comparing the predicted sequence with the sequence actually received (and applied) can facilitate anomaly detection. For example, an RNN-based spelling model can predict that U follows Q when reading a word letter by letter. If the letter that actually follows Q is not the expected U, then an anomaly is detected.

[0116] Unlike neural layers composed of individual neurons, each recursive step of an RNN can be an MLP composed of cells, each of which contains a few specially arranged neurons. RNN neurons operate as memory cells. RNN cells can be implemented by long short-term memory (LSTM) cells. The way LSTM arranges column neurons is different from how transistors are arranged in flip-flops, but the common goal of LSTM and digital logic is to specially arrange several control gates with states. For example, a neural memory cell can have an input gate, an output gate, and a forget (i.e., reset) gate. Unlike binary circuits, the input gate and output gate can conduct (e.g., unit-normalized) values ​​retained by the cell, also as values.

[0117] Compared to other MLPs, RNN has two main internal enhancement functions. The first is a local memory unit, such as LSTM, which involves microscopic details. The other is the cross-activation of the recursive step, which is macroscopic (i.e., overall topology). Each step receives two inputs and outputs two outputs. One input is an external activation from the item in the order of the input. The other input is the output of the adjacent previous step in which the details from some or all previous steps can be embedded, which realizes the sequential history (i.e., time context). The other output is the predicted next item in the sequence. Example mathematical formulas and techniques for RNN and LSTM are taught in the related U.S. patent application No. 15 / 347,501 entitled "MEMORYCELL UNIT AND RECURRENT NEURAL NETWORK INCLUDING MULTIPLE MEMORY CELL UNITS".

[0118] Complex analysis can be achieved through so-called MLP stacks. An example stack may sandwich an RNN between an upstream encoder ANN and a downstream decoder ANN, one or both of which may be autoencoders. The stack may have fan-in and / or fan-out between the MLPs. For example, the RNN may directly activate two downstream ANNs, such as an anomaly detector and an autodecoder. The autodecoder may exist only during model training, such as for monitoring visibility of training or in a feedback loop for unsupervised training. RNN model training can use backpropagation over a period of time, which is a technique that can achieve higher accuracy for RNN models compared to ordinary backpropagation. Example mathematical formulas, pseudocodes, and techniques for training RNN models using backpropagation through time are taught in the related WIPO patent application No. PCT / US2017 / 033698 entitled “MEMORY-EFFICIENT BACKPROGATION THROUGHTIME”.

[0119] Hardware Overview

[0120] According to one embodiment, the technology described herein is implemented by one or more special-purpose computing devices. The special-purpose computing device can be hard-wired to perform the present technology, or can include a digital electronic device that is permanently programmed to perform the present technology, such as one or more application-specific integrated circuits (ASICs) or field programmable gate arrays (FPGAs), or can include one or more general-purpose hardware processors that are programmed to perform the present technology according to program instructions in firmware, memory, other storage devices, or combinations. This special-purpose computing device can also combine customized hard-wired logic, ASICs or FPGAs with customized programming to implement the present technology. The special-purpose computing device can be a desktop computer system, a portable computer system, a handheld device, a networking device, or any other device that combines hard-wiring and / or program logic to implement the technology.

[0121] For example, Figure 6 6 is a block diagram illustrating a computer system 600 upon which embodiments of the present invention may be implemented. Computer system 600 includes a bus 602 or other communication mechanism for communicating information and a hardware processor 604 coupled with bus 602 for processing information. Hardware processor 604 may be, for example, a general purpose microprocessor.

[0122] The computer system 600 also includes a main memory 606, such as a random access memory (RAM) or other dynamic storage device, coupled to the bus 602 for storing information and instructions to be executed by the processor 604. The main memory 606 may also be used to store temporary variables or other intermediate information during execution of instructions to be executed by the processor 604. Such instructions, when stored in a non-transitory storage medium accessible to the processor 604, make the computer system 600 a special-purpose machine customized to perform the operations specified in the instructions.

[0123] Computer system 600 also includes a read only memory (ROM) 608 or other static storage device coupled to bus 602 for storing static information and instructions for processor 604. A storage device 610, such as a magnetic or optical disk, is provided and coupled to bus 602 for storing information and instructions.

[0124] The computer system 600 may be coupled to a display 612, such as a cathode ray tube (CRT), via the bus 602 for displaying information to a computer user. An input device 614, including alphanumeric and other keys, is coupled to the bus 602 for communicating information and command selections to the processor 604. Another type of user input device is a cursor control 616, such as a mouse, trackball, or cursor direction keys, for communicating direction information and command selections to the processor 604 and for controlling cursor movement on the display 612. Such input devices typically have two degrees of freedom in two axes, a first axis (e.g., x) and a second axis (e.g., y), to allow the device to specify a position in a plane.

[0125] The computer system 600 may implement the techniques described herein using custom hardwired logic, one or more ASICs or FPGAs, firmware, and / or program logic that is combined with the computer system to make the computer system 600 a special purpose machine or program the computer system 600 to be a special purpose machine. According to one embodiment, the techniques herein are performed by the computer system 600 in response to the processor 604 executing one or more sequences of one or more instructions contained in the main memory 606. These instructions may be read into the main memory 606 from another storage medium, such as the storage device 610. Execution of the sequences of instructions contained in the main memory 606 causes the processor 604 to perform the process steps described herein. In alternative embodiments, hardwired circuitry may be used in place of or in combination with software instructions.

[0126] The term "storage medium" as used herein refers to any non-transitory medium that stores data and / or instructions that cause a machine to operate in a particular manner. Such storage media may include non-volatile media and / or volatile media. Non-volatile media include, for example, optical or magnetic disks, such as storage device 610. Volatile media include dynamic memory, such as main memory 606. Common forms of storage media include, for example, floppy disks, flexible disks, hard disks, solid-state drives, magnetic tapes or any other magnetic data storage media, CD-ROMs, any other optical data storage media, any physical media with a hole pattern, RAM, PROM and EPROM, FLASH-EPROM, NVRAM, any other memory chip, or cassette tape.

[0127] Storage media are distinct from but may be used in conjunction with transmission media. Transmission media participate in the transfer of information between storage media. For example, transmission media include coaxial cables, copper wire, and optical fiber, including the wires comprising bus 602. Transmission media may also take the form of acoustic or light waves, such as those generated during radio wave and infrared data communications.

[0128] Various forms of media may be involved in carrying one or more sequences of one or more instructions to processor 604 for execution. For example, the instructions may initially be carried on a disk or solid-state drive of a remote computer. The remote computer can load the instructions into its dynamic memory and send the instructions over a telephone line using a modem. A modem local to computer system 600 can receive the data on the telephone line and use an infrared transmitter to convert the data to an infrared signal. An infrared detector can receive the data carried in the infrared signal and appropriate circuitry can place the data on bus 602. Bus 602 carries the data to main memory 606, from which processor 604 retrieves and executes the instructions. The instructions received by main memory 606 may optionally be stored on storage device 610 before or after execution by processor 604.

[0129] Computer system 600 also includes a communication interface 618 coupled to bus 602. Communication interface 618 provides bidirectional data communication coupled to network link 620, wherein network link 620 is connected to local network 622. For example, communication interface 618 can be an integrated services digital network (ISDN) card, a cable modem, a satellite modem, or a modem that provides data communication connection to a telephone line of a corresponding type. As another example, communication interface 618 can be a LAN card that provides data communication connection to a compatible local area network (LAN). Wireless links can also be implemented. In any such implementation, communication interface 618 sends and receives electrical signals, electromagnetic signals, or optical signals that carry digital data streams representing various types of information.

[0130] The network link 620 typically provides data communication to other data devices through one or more networks. For example, the network link 620 can provide a connection to a host computer 624 or to data equipment operated by an Internet Service Provider (ISP) 626 through a local network 622. The ISP 626 in turn provides data communication services through the global packet data communication network now commonly referred to as the "Internet" 628. Both the local network 622 and the Internet 628 use electrical, electromagnetic, or optical signals that carry digital data streams. The signals through the various networks and the signals on the network link 620 and through the communication interface 618 are example forms of transmission media that carry the digital data to or from the computer system 600.

[0131] Computer system 600 can send messages and receive data, including program code, through the network(s), network link 620, and communication interface 618. In the Internet example, server 630 can transmit the requested code for an application program through Internet 628, ISP 626, local network 622, and communication interface 618.

[0132] The received code may be executed by processor 604 as it is received, and / or stored in storage device 610 or other non-volatile storage for later execution.

[0133] In the foregoing specification, embodiments of the present invention have been described with reference to numerous specific details, which may vary from implementation to implementation. Therefore, the specification and drawings should be viewed in an illustrative rather than a restrictive sense. The sole and exclusive indicator of the scope of the invention and what the applicant intends to be the scope of the invention is the literal and equivalent range of the resulting claims in the specific form of the set of claims issued from this application, including any subsequent corrections.

Claims

1. A computer-implemented method comprising: receiving an input graph comprising a plurality of subgraphs, wherein the input graph comprises data for a task comprising at least one of friendship recommendation, fraud detection, node importance ranking, or searching for similar compounds, and wherein the input graph comprises a plurality of vertices and a plurality of edges, each vertex of the plurality of vertices being associated with a vertex property of the vertex; generating a vertex-to-attribute mapping, wherein, for each vertex in the plurality of vertices, the vertex-to-attribute mapping maps the vertex to a vertex attribute signature in a plurality of vertex attribute signatures; generating a plurality of edge words, each edge word corresponding to one or more edges, each edge starting at a first vertex having a particular vertex attribute signature from the plurality of vertex attribute signatures and terminating at a second vertex having a particular vertex attribute signature from the plurality of vertex attribute signatures; generating a plurality of random walks based on one or more hyperparameters, each random walk comprising a sequence of vertices from a subgraph of the plurality of subgraphs of the input graph, wherein each path of a plurality of paths is based on a random walk of the plurality of random walks; generating a plurality of sentences, each sentence comprising edge words directly connected along a path in the plurality of paths in the input graph, each sentence representing a subgraph in the plurality of subgraphs of the input graph; Using the plurality of sentences, a doc2vec algorithm is used to generate machine learning vectors, each of the plurality of machine learning vectors representing a subgraph in the plurality of subgraphs.

2. The computer-implemented method of claim 1, wherein the input graph comprises an undirected graph. 3 . The computer-implemented method of claim 1 , wherein each vertex attribute signature comprises a string representation of a vertex attribute of a vertex.

4. The computer-implemented method of claim 1, each word comprising a string representation of a concatenation of a specific vertex attribute signature of a first vertex and a specific vertex attribute signature of a second vertex.

5. The computer-implemented method of claim 1, wherein the plurality of edge words are generated based on the plurality of random walks and the mapping of vertices to attributes.

6. The computer-implemented method of claim 1, wherein each sentence of the plurality of sentences comprises a string representation of an edge word of the plurality of edge words concatenated with one or more other edge words of the plurality of edge words.

7. The computer-implemented method of claim 1 , further comprising: A classifier is trained based on the machine learning vector.

8. One or more non-transitory computer-readable media storing instructions that, when executed by one or more processors, cause the computer-implemented method of any one of claims 1-7 to be performed.

9. A system implemented at least in part by computing hardware, comprising one or more computing devices including components, the computing hardware being configured to implement the computer-implemented method of any one of claims 1-7.

10. A computer program product comprising instructions which, when executed by one or more processors of a computer, cause the computer to perform the computer-implemented method of any one of claims 1 to 7.

Images