|
from functools import partial
|
|
import sys
|
|
|
|
sys.path.append("lib")
|
|
from lib.metrics import sce_loss
|
|
import torch
|
|
import torch.nn as nn
|
|
import torch.nn.functional as F
|
|
import dgl.nn as dglnn
|
|
|
|
|
|
class GMae(nn.Module):
|
|
def __init__(self, encoder, decoder,
|
|
in_dim, hidden_dim, out_dim, mask_rate=0.3, replace_rate=0.1, alpha_l=2,
|
|
embedding_layer_classes=5, embedding_layer_dim=4):
|
|
super(GMae, self).__init__()
|
|
self.Z_embedding = nn.Embedding(embedding_layer_classes, embedding_layer_dim)
|
|
self.encoder = encoder
|
|
self.decoder = decoder
|
|
self.mask_rate = mask_rate
|
|
self.replace_rate = replace_rate
|
|
self.alpha_l = alpha_l
|
|
self.in_dim = in_dim
|
|
self.hidden_dim = hidden_dim
|
|
self.out_dim = out_dim
|
|
self.embedding_layer_classes = embedding_layer_classes
|
|
self.embedding_layer_dim = embedding_layer_dim
|
|
self.enc_mask_token = nn.Parameter(torch.zeros(1, in_dim))
|
|
self.criterion = partial(sce_loss, alpha=alpha_l)
|
|
self.encoder_to_decoder = nn.Linear(hidden_dim, hidden_dim, bias=False)
|
|
|
|
def encode_atom_index(self, Z_index):
|
|
return self.Z_embedding(Z_index)
|
|
|
|
def encoding_mask_noise(self, g, x, mask_rate=0.3):
|
|
num_nodes = g.num_nodes()
|
|
perm = torch.randperm(num_nodes, device=x.device)
|
|
|
|
num_mask_nodes = int(mask_rate * num_nodes)
|
|
mask_nodes = perm[: num_mask_nodes]
|
|
keep_nodes = perm[num_mask_nodes:]
|
|
|
|
if self.replace_rate > 0:
|
|
num_noise_nodes = int(self.replace_rate * num_mask_nodes)
|
|
perm_mask = torch.randperm(num_mask_nodes, device=x.device)
|
|
token_nodes = mask_nodes[perm_mask[: int((1 - self.replace_rate) * num_mask_nodes)]]
|
|
noise_nodes = mask_nodes[perm_mask[-int(self.replace_rate * num_mask_nodes):]]
|
|
noise_to_be_chosen = torch.randperm(num_nodes, device=x.device)[:num_noise_nodes]
|
|
out_x = x.clone()
|
|
out_x[token_nodes] = 0.0
|
|
out_x[noise_nodes] = x[noise_to_be_chosen]
|
|
else:
|
|
out_x = x.clone()
|
|
token_nodes = mask_nodes
|
|
out_x[mask_nodes] = 0.0
|
|
|
|
out_x[token_nodes] += self.enc_mask_token
|
|
use_g = g.clone()
|
|
|
|
return use_g, out_x, (mask_nodes, keep_nodes)
|
|
|
|
def mask_attr_prediction(self, g, x):
|
|
use_g, use_x, (mask_nodes, keep_nodes) = self.encoding_mask_noise(g, x, self.mask_rate)
|
|
enc_rep = self.encoder(use_g, use_x)
|
|
|
|
rep = self.encoder_to_decoder(enc_rep)
|
|
recon = self.decoder(use_g, rep)
|
|
x_init = x[mask_nodes]
|
|
x_rec = recon[mask_nodes]
|
|
loss = self.criterion(x_rec, x_init)
|
|
return loss
|
|
|
|
def embed(self, g, x):
|
|
rep = self.encoder(g, x)
|
|
return rep
|
|
|
|
|
|
class SimpleGnn(nn.Module):
|
|
def __init__(self, in_feats, hid_feats, out_feats):
|
|
super().__init__()
|
|
self.conv1 = dglnn.SAGEConv(
|
|
in_feats=in_feats, out_feats=hid_feats, aggregator_type="mean")
|
|
self.conv2 = dglnn.SAGEConv(
|
|
in_feats=hid_feats, out_feats=out_feats, aggregator_type="mean")
|
|
|
|
def forward(self, graph, inputs):
|
|
h = self.conv1(graph, inputs)
|
|
h = F.relu(h)
|
|
h = self.conv2(graph, h)
|
|
return h
|
|
|
