sseung0703 / gala_tf2.0 Goto Github PK

Hey,

You are using the GALA constructor without passing the DAD matrix to it in the validate.py which is a required arguement. Also, model.update_DAD function doesn’t exist in GALA model

Hello,
Thank you so much for providing this code.
Could you please kindly upload the improved version soon?

Thank you for your contribution!

I would love to see the example code to reproduce the node clustering experiments mentioned in the paper (cora/citeseer/wiki/pubmed). I tried to reproduce the results but I'm off the track...

I uploaded my simple tf2 implementation (it can be run directly on colab along the cora.npz file):
https://github.com/daniel-unyi-42/GALA

Thank you for any help.

Hello,
thanks for your brilliant works.
I tried to implement your idea with PyTorch since I'm not familiar with Tensorflow.
These 2 functions are my implementation of Laplacian Smoothing and Laplacian sharpening, where A is the adjacency matrix:
def laplacian_smooth(A):
"""
args:
A: batches of adjacency matrices of symmetric Interactions
size of A: [batch_size, num_edgeTypes, num_nodes, num_nodes]
return: A_norm = (D**-0.5)A(D**-0.5), where D is the diagonal matrix of A
"""
I = torch.eye(A.size(-1))
I = I.unsqueeze(0).unsqueeze(1)
I = I.expand(A.size(0), A.size(1), I.size(2), I.size(3))
#size: [batch_size, num_edgeTypes, num_atoms, num_atoms]
A_p = A+I
D_values = A_p.sum(-1) #Degree values; size: [batch_size, num_nodes]
D_values_p = torch.pow(D_values, -0.5)
D_p = torch.diag_embed(D_values_p) #size: [batch_size, num_nodes, num_nodes]
return torch.matmul(D_p, torch.matmul(A_p, D_p))

def laplacian_sharpen(A):
"""
args:
A; batches of adjacency matrices corresponding to edge types
size: [batch_size, num_edgeTypes, num_nodes, num_nodes]
"""
I = torch.eye(A.size(-1))
I = I.unsqueeze(0).unsqueeze(1)
I = I.expand(A.size(0), A.size(1), I.size(2), I.size(3))
#size: [batch_size, num_edgeTypes, num_atoms, num_atoms]
Ap = 2*I-A
D_values = A.sum(-1)+2 #shape: [batch_size, num_edgeTypes, num_atoms]
D_values_p = torch.pow(D_values, -0.5)
D_p = torch.diag_embed(D_values_p)

return torch.matmul(D_p, torch.matmul(Ap, D_p))

Are there any problems with my implementation?

I test the model on the Cora dataset.
I use the Frobenius norm as reconstruction error, i.e. torch.norm(X-X_rec, p="pro") to train the 2-layer encoder and 2-layer decoder to minimise the reconstruction error.
After training, I use K-Means(n_cluster=7) to cluster the latents and found the NMI of the clustering results is very low compared with the results in your paper. Could you tell me more details of your model, such as which activation function used in the output layer of the encoder, what are the dimensions of hidden layers and the output layer of the encoder?