"learning graph embedding with adversarial training methods" paper reading

Published in IEEE T CYBERNETICS 2020.

abstract

Numerous graph embedding tasks focus on preserving graph structure or minimizing reconstruction loss on graph data. These methods ignore the embedding distribution of latent code, which may lead to poor representation in many cases. In this paper, an adversarially regularized framework for graph embedding is proposed. The adversarial training principle is used to make the latent code match a prior gaussian or uniform distribution. Based on this framework we develop two variants of the adversarial model: ARGA, ARVGA. Numerous experimental results demonstrate the effectiveness of our method.

Key point: Previous graph embedding methods ignore the embedding distribution of latent code, which may lead to poor representation in many cases. (Reasonable distribution needs to be considered in the process of learning graph embedding).

1. introduction

Our framework not only needs to minimize the reconstruction loss of the topology, but also needs to make the learned latent embedding match a prior distribution.

4.proposed algorithm

adversarially regularized graph autoencoder(ARGA):

Including two parts: graph convolutional autoencoder (input is graph A and node content X, used to learn a latent representation Z), adversarial regularization (used to make latent codes match a priori distribution through the confrontation training module, and distinguish the current zi $z_i\in Whether\; Z$ comes from the encoder or from the prior distribution).

4.1 graph convolutional autoencoder

Two basic questions: 1. How to synthesize structural information and content information in the encoder at the same time 2. What kind of information needs to be reconstructed by the decoder.

graph convolutional encoder model $G(X,A)$ :
frequency domain convolution process:

$Z^{(l+1)}=f(Z^{(l)},A|W^{(l)}),$

Z ( l ) , Z ( l + 1 ) Z^{(l)},Z^{(l+1) }$Z^{\left(l\right)},Z^{(l+1)}$ are the input and output of convolution respectively,$A$ is the defined adjacency matrix,$Z^0=X\in {\mathbb{R}}^{n\times m}$,$n,m$ represents the number of nodes and the number of features, respectively.

$f(Z^{\left(l\right)},A|W^l)=\varphi ({\tilde{D}}^{-\frac{1}{2}}\tilde{A}{\tilde{D}}^{-\frac{1}{2}}{Z}^{(l)}{W}^{(l)}),$

$G(X,A)$ Two layers of GCN convolution are used. In our article, two variants of the encoding model are also developed: graph encoder, variational graph encoder.

The graph encoder is defined as follows:

$$\begin{gathered} Z^{(1)}=f_{Rel}(X,A|W^{(0)}); \\ {Z}^{(2)}=f_{linear}(Z^{(1)},A|W^{(1)}). \end{gathered}$$

即graph convolutional encoder $G(Z,A)=q(Z|X,A)$ , while encoding the graph structure and node content into a representation$Z=q(Z|X,A)=Z^{(2)}.$

The variational graph encoder is defined as an inference model:

$$\begin{gathered} q(Z|X,A)=\prod _{i=1}^{n}q(z_i|X,A), \\ q(z_i|X,A)=\mathcal{N}(z_i|{\mu }_i,diag(\sigma \_\_{}^2)). \end{gathered}$$

where $m=Z^{(2)}$是mean vectors $z_i$Definition, $log\sigma =f_{linear}(Z^{(1)},A|W^{{}^{\prime }\left(1\right)})$in which$W^{{}^{\prime }(1)}=W^{\left(0\right)}$ , and$\mu$ shares weights.

decoder model:
used to reconstruct graph data. ARGA decoder $p(\hat{A}|Z)$predicts whether there is a link between two nodes. More specifically, we train a link prediction layer based on graph embeddings:

$$\begin{gathered} p(\hat{A}|Z)=\prod _{i=1}^n\prod _{j=1}^{n}p({\hat{A}}_{ij}|z_i,z_j); \\ p({\hat{A}}_{i,j}=1|z_i,z_j)=sigmoid(z_i^T,z_j), \end{gathered}$$

Here the predicted value $\widehat{(}A)$ should be the same as ground truth$A$ close.

graph autoencoder model:
embedding $Z$ and the reconstructed graph$\hat{A}$ can be represented as follows:

$\hat{A}=sigmoid(Z{Z}^T),Z=q(Z|X,A).$

Optimization:
For the graph encoder, we minimize the reconstruction loss of the graph data:

$L_0={\mathbb{E}}_{q(Z|(X,A))}[logp(A|Z)]$

For the variational graph encoder, we optimize the variational lower bound:

$L_1={\mathbb{E}}_{q(Z|(X,A))}[logp(A|Z)]-KL[q(Z|X,Z)||p(Z)]$

where $p\left(Z\right)$ is the prior distribution, which can be uniform distribution or gaussian distribution

$p(Z)={\prod }_{i}p(z_i)={\prod }_i\mathcal{N}(z_i|0,I).$

4.2 adversarial model $\mathcal{D}(Z)$

The underlying idea of ​​our model is to make the latent distribution $Z$ matches a prior distribution, which is achieved by adversarially training the model. The adversarial model is based on the standard MLP, and the output layer is only one-dimensional with a sigmoid function. The adversarial model acts as a discriminator to identify a latent code from the prior$p_z$(positive)或者graph encoder $G(X,A)$ (negative). By minimizing the cross entropy of the two classifiers, the embedding will eventually be regularized and improved during the training process, and the cost is defined as follows:

$-\frac{1}{2}{\mathbb{E}}_{z\sim p_z}log\mathcal{D}(Z)-\frac{1}{2}{E}_{x}log(1-\mathcal{D}(G(X,A))),$

$p_z$is the prior distribution.

adversarial graph autoencoder model：

Train with discriminator $D\left(Z\right)$ encoder model:

$\underset{G}{\min }\underset{\mathcal{D}}{\max }{\mathbb{E}}_{z\sim p_z}\left[logD\right(Z\left)\right]+E_{x\sim p(x)}[log(1-\mathcal{D}(G(X,A)))].$

Among them, $G(X,A)$为generator，$D\left(Z\right)$为 discriminator。

4.3 algorithm explanation

4.4 decoder variations

In the ARGA and ARVGA models, the decoder is just the link prediction layer of the dot product of embedding z. But the decoder can also be a combination of a graph convolutional layer or a link prediction layer and a graph convolutional decoder layer.

GCN decoder for graph structure reconstruction (ARGA_GD):
Modify the encoder to reconstruct the graph structure by adding two graph convolution layers. A variant of this method is called ARGA_GD. In this method, the input of the decoder is the embedding of the encoder, and the construction process of the decoder for graph convolution is as follows:

$$\begin{gathered} Z_D=f_{linear}(Z,A|W_D^{(1)}), \\ O=f_{linear}(Z_D,A|W_D^{(2)}), \end{gathered}$$

Among them, $Z,Z_D,O$ is the embedding learned from the graph encoder, and the output of the first layer and the second layer of the graph decoder. The reconstruction loss is calculated as follows:

$L_{ARGA\_G}={\mathbb{E}}_{q(O|(X,A))}[logp(A|O)]$

GCN decoder for both graph structure and content information reconstruction(ARGA_AX):

We modify the dimension of the second graph convolutional layer to be the number of features associated with each node, so the output of the second layer is $O\in {\mathbb{R}}^{n\times f}\ni X.$ The reconstruction loss consists of two kinds of errors$.$First is the reconstruction loss:

$L_A={\mathbb{E}}_{q(O|(X,A))}[logp(A|O)],$

This is followed by the reconstruction loss of the node content:

$L_X={\mathbb{E}}_{q|(O|(X,A))}[logp(X|O)].$

The final reconstruction loss is: $L_O=L_A+L_X.$

5.experiments