SELFATTENTIVE ATTRIBUTED NETWORK EMBEDDING

0Associated
Cases 
0Associated
Defendants 
0Accused
Products 
0Forward
Citations 
0
Petitions 
1
Assignment
First Claim
1. A method for determining a network embedding, comprising:
 training a network embedding model using a processor, based on training data that includes topology information for networks and attribute information relating to vertices of the networks;
generating an embedded representation using the trained network embedding model to represent an input network, with associated attribute information, in a network topology space; and
performing a machine learning task using the embedded representation as input to a machine learning model.
1 Assignment
0 Petitions
Accused Products
Abstract
Methods and systems for determining a network embedding include training a network embedding model using training data that includes topology information for networks and attribute information relating to vertices of the networks. An embedded representation is generated using the trained network embedding model to represent an input network, with associated attribute information, in a network topology space. A machine learning task is performed using the embedded representation as input to a machine learning model.
0 Citations
No References
No References
20 Claims
 1. A method for determining a network embedding, comprising:
training a network embedding model using a processor, based on training data that includes topology information for networks and attribute information relating to vertices of the networks; generating an embedded representation using the trained network embedding model to represent an input network, with associated attribute information, in a network topology space; and performing a machine learning task using the embedded representation as input to a machine learning model.  View Dependent Claims (2, 3, 4, 5, 6, 7, 8, 9, 10)
 11. A system for determining a network embedding, comprising:
a model trainer configured to train a network embedding model using training data that includes topology information for networks and attribute information relating to vertices of the networks, wherein the network embedding model is configured to generate an embedded representation to represent an input network, with associated attribute information, in a network topology space; and a machine learning model configured to perform a machine learning task using the embedded representation output by the network embedding model as input.  View Dependent Claims (12, 13, 14, 15, 16, 17, 18, 19, 20)
1 Specification
This application claims priority to U.S. Provisional Patent Application No. 62/751,875, filed on Oct. 29, 2018, and to U.S. Provisional Patent Application No. 62/752,379, filed on Oct. 30, 2018, both incorporated herein by reference herein their entirety.
The present invention relates to representing network topologies in machine learning, and more particularly to using adversarial learning to efficiently learn vertex embeddings on attributed networks.
Network embedding is a challenge in many machine learning tasks. However, existing approaches learn node representations based only on the topological structure.
A method for determining a network embedding includes training a network embedding model using a processor, based on training data that includes topology information for networks and attribute information relating to vertices of the networks. An embedded representation is generated using the trained network embedding model to represent an input network, with associated attribute information, in a network topology space. A machine learning task is performed using the embedded representation as input to a machine learning model.
A system for determining a network embedding includes a model trainer configured to train a network embedding model using training data that includes topology information for networks and attribute information relating to vertices of the networks. The network embedding model is configured to generate an embedded representation to represent an input network, with associated attribute information, in a network topology space. A machine learning model is configured to perform a machine learning task using the embedded representation output by the network embedding model as input.
These and other features and advantages will become apparent from the following detailed description of illustrative embodiments thereof, which is to be read in connection with the accompanying drawings.
The disclosure will provide details in the following description of preferred embodiments with reference to the following figures wherein:
Embodiments of the present invention provide machine learning systems that use rich attributes of a network, in addition to the network topological structure, to embed the network in a form that can be used by the machine learning model. The network embedding is a lowdimensional representation of vertices in the network that benefits downstream tasks, such as vertex classification and link prediction. The use of the rich attributes that are available in realworld networks is complementary in learning better embedding representations, especially when the network is highly sparse. Interpretability is also important for data fusion on network structure and attribute information.
Toward that end, the present embodiments use an adversarial, regularized embedded learning approach that efficiently learns vertex embeddings on attributed networks via adversarial learning. The present embodiments capture network structure by jointly considering both localitypreserving and global reconstruction constraints in network topology space and attribute space.
In particular, a deep model captures the underlying high nonlinearity of both the topological structure and the attributes. The proposed model enforces the learned vertex representations to preserve locality from the original networks. In addition, to learn a consistent and complementary representation from the topological structure and attributes of the network, the present embodiments combine these two kinds of information to encapsulate the join inference in a generative adversarial training process.
The deep model employs two deep autoencoding architectures, to capture the underlying nonlinearities. A discrete recurrent neural network (RNN) autoencoder is used to learn a continuous vertex representation distribution in a topology space, with sampled sequences of vertices as inputs. A multilayer perceptron (MLP) autoencoder is used in parallel with the RNN autoencoder to learn the distribution in an attribute space. The interactions of attributes among different fields are modeled using a selfattention mechanism.
Referring now in detail to the figures in which like numerals represent the same or similar elements and initially to
The deep learning model includes two parallel autoencoder structures. In an RNN autoencoder structure, each vertex of a network is encoded to provide vertex encodings 102. These vertex encodings 102 are used as input to an RNN encoder 104. An RNN decoder 106 uses the output of the RNN encoder 104, along with a locality constraint 108, to generate a reconstructed set of vertices, which can be used to verify the operation of the RNN autoencoder in block 110 by comparing the reconstructed vertices to the encoded vertices. This provides feedback for training the RNN autoencoder. The locality constraint 108 preserves neighborhood proximity from the original network structure.
In an MLP autoencoder structure, a table of vertex attributes 112 is processed by an interaction layer 114. Interaction layer 114 models the interactions between attributes among different fields using a selfattention mechanism. The output of the interaction layer is processed by MLP encoder 116 to form an encoding of the attributes. MLP decoder 118 then decodes the encoded attributes to generate reconstructed attributes for attribute verification in block 120. The encoded vertices generated by the RNN encoder 104 and the encoded attributes generated by the MLP encoder 116 are used as input to discriminator 122.
As noted above, network embedding learns representations that encode structural information of a network. Network embedding learns a mapping that embeds vertices of the network as points in a lowdimensional space. Given an encoded vertex set {x^{(1)}, . . . , x^{(n)}, finding an embedding f_{ϕ}(x^{(i)}) of each x^{(i) }can be formalized as an optimization problem:
where f_{ϕ}(x)∈^{d }is the ddimensional embedding result for a given input x, (·) is the loss function between a pair of inputs, φ_{ij }is the weight between x^{(i) }and x^{(j)}, and (·) serves as a regularizer such as an autoencoder. The present embodiments make use of Laplacian eigenmaps as a loss function to preserve the locality property of the network structure. The embedding can be obtained by minimizing the following objective function:
where ϕ and ψ are parameters of the encoder and decoder functions, respectively, in network topology space, where λ is a userdetermined hyperparameter (e.g., fixed using crossvalidation), and where n is a total number of nodes in the graph.
Generative adversarial networks (GANs) build an adversarial training platform for two players, namely the generator g_{θ}(·) and the discriminator d_{w}(·), to play a minmax game. The variables θ and w represent model parameters.
The generator g_{θ}(·) attempts to map noise to the input space as closely as the true data, while the discriminator d_{w}(x) represents the probability that x comes from the data, rather than from the noise. The discriminator 122 aims to distinguish the real data distribution _{data}(x) and the noisegenerated sample distribution _{g}(z), where z˜(0,1). The JensenShannon divergence can be used by GANs, but is known to suffer from training instability. To overcome this, Wasserstein GANs use the earthmover distance and solve the problem:
The Lipschitz constraint on the discriminator can be kept by clipping the weights of the discriminator within a compact space.
In the following discussion, an attributed network with n vertices is expressed as G(,ε,Z), where ε is the set of network edges and Z∈^{n×d}^{0}^{a }is an attribute matrix, with z=Z_{i}∈^{n×d}^{0}^{g }representing the attribute vector of the i^{th }vertex. The encoded vectors are expressed as X∈^{n×d}^{0}^{g}, for example encoded by a lookup table or by onehot encoding. The vector x=X_{i}∈^{d}^{0}^{g }denotes the vector representation of the i^{th }vertex. A random walk generator is used to obtain truncated random walks on the network, expressed as sequences of vertices, that are rooted from each verted v∈ in G (, ε, Z). A walk can be sampled randomly from the neighbors of the last visited vertex until a preset maximum length is reached.
Given a network G (,ε,Z), vertices of similar attributes are likely to be close to one another (e.g., connected by edges) than dissimilar ones. That is, the lowdimensional vertex representations of {X_{i}}_{i=1}^{n }are drawn from a distribution similar to that of the representations of the attributes {Z_{i}}_{i=1}^{n}. It is assumed that the formation of a network is highly correlated with vertex attributes, such that leveraging vertex attribute information can improve network embedding performance. Therefore, the present embodiments learn a lowdimensional vertex embedding that is based on the network topology G(·) and the attribute matrix Z, such that the learned representations can preserve the proximity in existing in both the network topology space and the attribute space. Both network structure and attribute information can be viewed as latent factors to drive the formation of the network.
The learned representation of the network topological structure can be expressed as f_{ϕ}^{g}(x), and the learned representation of the network attribute information can be expressed as f_{θ}^{a}(z). A mapping is learned, f{X,Z}→M, by minimizing the disagreement (f_{ϕ}^{g}(X), f_{θ}^{a}(Z)) between the learned topology space and structure space. M∈^{n×d }is the resultant representation matrix. Each row of M can be viewed as a vertex feature vector.
The RNN autoencoder structure is used to learn a continuous vertex representation distribution in the topology space with sampled sequences of vertices as inputs. The RNN autoencoder can be trained individually by minimizing the negative loglikelihood of reconstruction, which is indicated by cross entropy loss in the implementation as:
_{AE}^{(g)}(ϕ,ψ;x)=−_{(x)}[dist(x,h_{ψ}^{(g)}(f_{ϕ}^{(g)}(x))]
where dist(x,y)=x log y+(1−x)log(1−y). In this case, xis a sampled batch from training data, f_{ϕ}^{(g)}(x) is the embedded latent representation of x, and ϕ and ψ are parameters of the encoder and decoder functions in the network topology space, respectively.
Similarly, in the attribute space, the MLP autoencoder structure is adopted to learn the distribution:
_{AE}^{(a)}(ϕ,ξ;z)=−_{(z)}[dist(z,h_{ξ}^{(a)}(f_{θ}^{(a)}(z))]
where θ and ξ are parameters of the encoder and decoder functions in the attribute space, respectively.
During training of the RNN autoencoder, not only are the encoder and decoder updated, but the localitypreserving loss 108 is also jointly minimized:
where f_{ϕ}^{(g)}(x)∈^{d }is the embedding result for a given input x and ϕ_{ij }is the weight between vertices i and j.
To minimize the discrepancies between attribute distribution and network topology distribution, the present embodiments use a generative adversarial training process as a complementary regularizer. Advantages include guiding the extraction of useful information from data and providing a more robust discretespace representation learning that can address the overfitting problem on sparsely sampled walks. The present embodiments thus introduce a discriminator 122 in the latent space which separates generated vectors from the encoder network f_{ϕ}^{(g)}(·) with network topology and the encoder network f_{θ}^{(a)}(·) with attributes.
f_{θ}^{(g)}(x)˜_{ϕ}(x) is a sample drawn from the distribution of the network space _{ϕ}(x) and f_{θ}^{(a)}(z)˜_{θ}(z) denotes a sample drawn from the distribution of the attribute space _{θ}(z). The dual form of the earth mover distance between _{ϕ}(x) and _{θ}(z) can be determined as follows:
where ∥d(·)∥_{L≤1 }is the Libschitz continuity constraint, with Lipschitz constant 1. If a family of functions {d_{w}(·)} are all KLipschitz for some K, then:
Parameterized encoders f_{ϕ}^{(g)}(x) and f_{θ}^{(a)}(z) can be used as generators, with the training of generator and discriminator being performed separately. The cost function for the generators can be defined by:
_{GEN}(θ,ϕ;x,z)=_{(x)}[d_{w}(f_{ϕ}^{(g)}(x)]−_{(z)}[d_{w}(f_{ϕ}^{(g)}(x)]
Similarly, the cost function of the discriminator can be defined by:
_{DIS}(w;x,z)=−_{(x)}[d_{w}(f_{ϕ}^{(g)}(x)]+_{(z)}[d_{w}(f_{ϕ}^{(g)}(x)]
The present embodiments learn smooth representations by jointly minimizing the reconstruction errors of the autoencoders within an adversarial training process.
To learn smooth representations by jointly minimizing the reconstructions of the autoencoders and the localitypreserving loss, the joint optimization problem may be expressed as:
(ϕ,θ,ψ,ξ,w)=_{AE}^{(g)}(ϕ,ψ;x)+_{AE}^{(a)}(θ,ξ;z)+λ_{1}_{LE}(ϕ;x)+λ_{2}W(_{ϕ(x)},_{θ(z)})
where λ_{1 }and λ_{2 }are hyperparameters that control the importance of different losses.
To learn the interactions among vertex attributes (cross features), an interaction layer 114 is used in attribute space. In the interaction layer 114, selfattention is used to map the attributes of different fields with weighted sums to the output by computing the similarity against different attribute fields. With p being the total number of fields in the input attributes, for each field {z_{0}^{(i)}}_{i=1}^{p}, a linear mapping function Φ(·) is used to map the field to a lowdimensional dense vector Φ(z_{0}^{(i)})∈^{d}^{1}^{a}. By applying the mapping function on all fields, the output of one instance I would be a concatenation of multiple embedding vectors denoted by Z_{0}_{i}=Φ([z_{0}^{(1)},z_{0}^{(2)}, . . . , z_{0}^{(p)}]).
The scaled dotproduct attention is used to compute the outputs with attention weights. This selfattention mechanism includes three parts, the queries Q, the keys K, and the values V. All of these parts are derived from the same embedding Z_{0 }with ReLU activation, such that Q=ReLU(Z_{0}W_{q}), K=ReLU(Z_{0}W_{k}), and V=ReLU(Z_{0}W_{v}), where W_{q},W_{k},W_{v}∈^{d}^{1}^{(a)}^{×d}^{1}^{(a) }are parameters to be learned. The attention map is then determined using queries and keys. Each entry of the attention map represents the interaction intensity of attributes between two different fields. The output of the selfattention module is computed together with the values:
where σ(·) is the Softmax function. Additionally, an attribute field may also be involved in the interaction in different representation subspaces. Multiheaded attention is used because it allows the model to jointly attend to information from different subspaces. The final output from the interaction layer is defined as:
where ⊕ denotes concatenation, h is the number of heads, Z∈{circumflex over ( )}(n×d_{0}^{(a)}, and d_{0}^{(a)}=(h+1)×p×d_{1}^{(a)}.
_{θ}(z) is the distribution of f_{θ}^{(a)}(z), where z is a sample drawn from the distribution _{attribute}(z), and f_{θ}^{(a)}(·) is a function satisfying the local Lipschitz constants [L(θ,z)]<+∞. Then:
The joint architecture uses a dedicated training objective for each part. To train the model, block coordinate descent can be used to alternate between optimizing different parts of the model. For the RNN autoencoder reconstruction error in the network topology space _{AE}^{(g)}(ϕ,ψ;x) and the localitypreserving loss _{LE}(ϕ;x), the parameters ϕ and ψ are updated. For the MPL autoencoder reconstruction error in the attribute space _{AE}^{(a)}(θ,ξ;z), the parameters θ and ξ are updated. The interaction layer 114 is optimized as an endtoend model. For the discriminator 122, the parameter w is updated. For the RNN encoder and the MLP encoder, the parameters ϕ and θ are updated.
Referring now to
Block 204 encodes the network topology in a topology space. Block 204 samples {x^{(i)}}_{i=1}^{B}˜_{graph}(x) from the random walks from a single batch B and computes a latent representation f_{ϕ}^{(g)}(x^{(i)}). A reconstruction output h_{ψ}^{(g)}(f_{ϕ}^{(g)}(x^{(i)})) is determined and the losses _{AE}^{(g)}(ϕ,ψ;x) and _{LE}(ϕ;x) are calculated as described above. The loss is backpropagated and the parameters ϕ and ψ are updated using the respective differentials described above.
Block 206 encodes the vertex attributes in an attribute space. The output Z of the interaction layer 114 is determined as described above. Block 206 samples {z^{(i)}}_{i=1}^{B}˜_{attribute}(z) from the attribute vectors from a single batch B and computes the) latent representation f_{θ}^{(a)}(z^{(i)}). A reconstruction output h_{ξ}^{(a)}(f_{θ}^{(a)}(z^{(i)})) is determined and the loss _{AE}^{(a)}(θ,ξ;z) is calculated as described above. The loss is backpropagated and the parameters θ and ξ are updated using the respective differentials described above.
Block 208 trains the discriminator 122. Block 208 samples {x^{(i)}}_{i=1}^{B}˜_{graph}(x) from the random walks and {z^{(i)}}_{i=1}^{B}˜_{attribute}(z) from the attribute vectors and computes the respective representations f_{ϕ}^{(g)}(x^{(i)}) and f_{θ}^{(a)}(z^{(i)}). A discriminator loss _{DIS}(w;x,z) is calculated as described above and is backpropagated. The parameter w is updated using the differential described above. This is repeated for a number of discriminator training iterations.
Block 210 jointly trains the RNN encoder 104 and the MLP encoder 116 using adversarial training. Block 210 samples {x^{(i)}}_{i=1}^{B}˜_{graph}(x) from the random walks and {z^{(i)}}_{i=1}^{B}˜_{attribute}(z) from the attribute vectors and computes the respective representations f_{ϕ}^{(g)}(x^{(i)}) and f_{θ}^{(a)}(z^{(i)})). A generator loss _{GEN}(θ,ϕ;x,z) is calculated as described above and is backpropagated. The parameters θ and ϕ are updated again using the above differentials.
The training of block 200 is repeated across a number of training epochs until a maximum number of iterations is reached.
Using this generative adversarial training, the latent space of the RNN autoencoder provides an optimal embedding of the network vertices with guided information from the attribute space. The use of the RNN encoder in the topology space takes the vertex order information from the sampled random walks. After the training, vertex representations f_{ϕ}^{(g)}(x^{(i)}) are determined by passing the input walks through the RNN encoder 104. The adversarial training process is equivalent to optimizing the optimal transport cost between the input and output distributions of the RNN and MLP autoencoders, which forces the latent embeddings in topology space and attribute space to follow the same prior distribution.
Referring now to
Once the models are trained, block 306 accepts new network vertices and their attributes and uses the trained embedding model to form associated representations. Block 308 uses the representations as inputs to the trained machine learning model to perform a task. Such tasks can include, for example, network reconstruction, multilabel classification, and link prediction.
For example, if block 308 performs classification, vertex features can be used as input to a onevsrest logistic regression to train the machine learning model in block 306. To make a comprehensive evaluation, sets of 10%, 30%, and 50% of the total number of vertices are selected as a training set, with the remaining number of vertices in each case being used as a test set. Evaluation metrics can include, e.g., MicroF1 and MacroF1. The present network embeddings outperform other embedding approaches on the vertex classification task. Vertex attribute information contributes substantially to classification and provides superior accuracy if both network topology and attributes are considered.
If block 308 performs link prediction, the objective is to infer missing edges in a network that has had a certain fraction of edges removed. For example, if 20% of edges are randomly removed from a network, these edges serve as positive samples, with an equal number of vertex pairs without edges between them being negative samples. With the vertex representation learned by the network embedding in block 306, block 308 determines a link prediction ranking sore from the _{2 }norm of two vertex vectors. The present embodiments outperform existing approaches by a substantial margin, in some experiments providing a 3% to % 19 improvement.
The present embodiments thereby provide a distinct advantage over systems that consider only network topology and provide superior accuracy in any appropriate machine learning task.
Embodiments described herein may be entirely hardware, entirely software or including both hardware and software elements. In a preferred embodiment, the present invention is implemented in software, which includes but is not limited to firmware, resident software, microcode, etc.
Embodiments may include a computer program product accessible from a computerusable or computerreadable medium providing program code for use by or in connection with a computer or any instruction execution system. A computerusable or computer readable medium may include any apparatus that stores, communicates, propagates, or transports the program for use by or in connection with the instruction execution system, apparatus, or device. The medium can be magnetic, optical, electronic, electromagnetic, infrared, or semiconductor system (or apparatus or device) or a propagation medium. The medium may include a computerreadable storage medium such as a semiconductor or solid state memory, magnetic tape, a removable computer diskette, a random access memory (RAM), a readonly memory (ROM), a rigid magnetic disk and an optical disk, etc.
Each computer program may be tangibly stored in a machinereadable storage media or device (e.g., program memory or magnetic disk) readable by a general or special purpose programmable computer, for configuring and controlling operation of a computer when the storage media or device is read by the computer to perform the procedures described herein. The inventive system may also be considered to be embodied in a computerreadable storage medium, configured with a computer program, where the storage medium so configured causes a computer to operate in a specific and predefined manner to perform the functions described herein.
A data processing system suitable for storing and/or executing program code may include at least one processor coupled directly or indirectly to memory elements through a system bus. The memory elements can include local memory employed during actual execution of the program code, bulk storage, and cache memories which provide temporary storage of at least some program code to reduce the number of times code is retrieved from bulk storage during execution. Input/output or I/O devices (including but not limited to keyboards, displays, pointing devices, etc.) may be coupled to the system either directly or through intervening I/O controllers.
Network adapters may also be coupled to the system to enable the data processing system to become coupled to other data processing systems or remote printers or storage devices through intervening private or public networks. Modems, cable modem and Ethernet cards are just a few of the currently available types of network adapters.
As employed herein, the term “hardware processor subsystem” or “hardware processor” can refer to a processor, memory, software or combinations thereof that cooperate to perform one or more specific tasks. In useful embodiments, the hardware processor subsystem can include one or more data processing elements (e.g., logic circuits, processing circuits, instruction execution devices, etc.). The one or more data processing elements can be included in a central processing unit, a graphics processing unit, and/or a separate processor or computing elementbased controller (e.g., logic gates, etc.). The hardware processor subsystem can include one or more onboard memories (e.g., caches, dedicated memory arrays, read only memory, etc.). In some embodiments, the hardware processor subsystem can include one or more memories that can be on or off board or that can be dedicated for use by the hardware processor subsystem (e.g., ROM, RAM, basic input/output system (BIOS), etc.).
In some embodiments, the hardware processor subsystem can include and execute one or more software elements. The one or more software elements can include an operating system and/or one or more applications and/or specific code to achieve a specified result.
In other embodiments, the hardware processor subsystem can include dedicated, specialized circuitry that performs one or more electronic processing functions to achieve a specified result. Such circuitry can include one or more applicationspecific integrated circuits (ASICs), fieldprogrammable gate arrays (FPGAs), and/or programmable logic arrays (PLAs).
These and other variations of a hardware processor subsystem are also contemplated in accordance with embodiments of the present invention.
Reference in the specification to “one embodiment” or “an embodiment” of the present invention, as well as other variations thereof, means that a particular feature, structure, characteristic, and so forth described in connection with the embodiment is included in at least one embodiment of the present invention. Thus, the appearances of the phrase “in one embodiment” or “in an embodiment”, as well any other variations, appearing in various places throughout the specification are not necessarily all referring to the same embodiment. However, it is to be appreciated that features of one or more embodiments can be combined given the teachings of the present invention provided herein.
It is to be appreciated that the use of any of the following “/”, “and/or”, and “at least one of”, for example, in the cases of “A/B”, “A and/or B” and “at least one of A and B”, is intended to encompass the selection of the first listed option (A) only, or the selection of the second listed option (B) only, or the selection of both options (A and B). As a further example, in the cases of “A, B, and/or C” and “at least one of A, B, and C”, such phrasing is intended to encompass the selection of the first listed option (A) only, or the selection of the second listed option (B) only, or the selection of the third listed option (C) only, or the selection of the first and the second listed options (A and B) only, or the selection of the first and third listed options (A and C) only, or the selection of the second and third listed options (B and C) only, or the selection of all three options (A and B and C). This may be extended for as many items listed.
Embodiments of the present invention can be implemented using artificial neural networks (ANNs). In general terms, an ANN is an information processing system that is inspired by biological nervous systems, such as the brain. The key element of ANNs is the structure of the information processing system, which includes a large number of highly interconnected processing elements (called “neurons”) working in parallel to solve specific problems. ANNs are furthermore trained inuse, with learning that involves adjustments to weights that exist between the neurons. An ANN is configured for a specific application, such as pattern recognition or data classification, through such a learning process.
Referring now to
This represents a “feedforward” computation, where information propagates from input neurons 402 to the output neurons 406. Upon completion of a feedforward computation, the output is compared to a desired output available from training data. The error relative to the training data is then processed in “feedback” computation, where the hidden neurons 404 and input neurons 402 receive information regarding the error propagating backward from the output neurons 406. Once the backward error propagation has been completed, weight updates are performed, with the weighted connections 408 being updated to account for the received error. This represents just one variety of ANN.
Referring now to
Furthermore, the layers of neurons described below and the weights connecting them are described in a general manner and can be replaced by any type of neural network layers with any appropriate degree or type of interconnectivity. For example, layers can include recurrent, convolutional layers, pooling layers, fully connected layers, softmax layers, or any other appropriate type of neural network layer. Furthermore, layers can be added or removed as needed and the weights can be omitted for more complicated forms of interconnection.
During feedforward operation, a set of input neurons 502 each provide an input signal in parallel to a respective row of weights 504. The weights 504 each have a respective settable value, such that a weight output passes from the weight 504 to a respective hidden neuron 506 to represent the weighted input to the hidden neuron 506. In software embodiments, the weights 504 may simply be represented as coefficient values that are multiplied against the relevant signals. The signals from each weight adds columnwise and flows to a hidden neuron 506.
The hidden neurons 506 use the signals from the array of weights 504 to perform some calculation. The hidden neurons 506 then output a signal of their own to another array of weights 504. This array performs in the same way, with a column of weights 504 receiving a signal from their respective hidden neuron 506 to produce a weighted signal output that adds rowwise and is provided to the output neuron 508.
It should be understood that any number of these stages may be implemented, by interposing additional layers of arrays and hidden neurons 506. It should also be noted that some neurons may be constant neurons 509, which provide a constant output to the array. The constant neurons 509 can be present among the input neurons 502 and/or hidden neurons 506 and are only used during feedforward operation.
During back propagation, the output neurons 508 provide a signal back across the array of weights 504. The output layer compares the generated network response to training data and computes an error. The error signal can be made proportional to the error value. In this example, a row of weights 504 receives a signal from a respective output neuron 508 in parallel and produces an output which adds columnwise to provide an input to hidden neurons 506. The hidden neurons 506 combine the weighted feedback signal with a derivative of its feedforward calculation and stores an error value before outputting a feedback signal to its respective column of weights 504. This back propagation travels through the entire network 500 until all hidden neurons 506 and the input neurons 502 have stored an error value.
During weight updates, the stored error values are used to update the settable values of the weights 504. In this manner the weights 504 can be trained to adapt the neural network 500 to errors in its processing. It should be noted that the three modes of operation, feed forward, back propagation, and weight update, do not overlap with one another.
Referring now to
The machine learning model 608 is configured to perform some machine learning task using inputs that include a network embedding. The network embedding is generated by the network embedding model 606. Because the network embedding model 606 forms representations of input network vertices using both network topology and attribute information, the representations formed by the network embedding model 606 provide superior results when used as inputs to the machine learning model 608.
The foregoing is to be understood as being in every respect illustrative and exemplary, but not restrictive, and the scope of the invention disclosed herein is not to be determined from the Detailed Description, but rather from the claims as interpreted according to the full breadth permitted by the patent laws. It is to be understood that the embodiments shown and described herein are only illustrative of the present invention and that those skilled in the art may implement various modifications without departing from the scope and spirit of the invention. Those skilled in the art could implement various other feature combinations without departing from the scope and spirit of the invention. Having thus described aspects of the invention, with the details and particularity required by the patent laws, what is claimed and desired protected by Letters Patent is set forth in the appended claims.