def __init__(self, A, X, Z, num_vicious_nodes, num_vicious_edges, dmin=1):
"""
:param A: sparse matrix, the adjacency matrix ,[n X n]
:param X: sparse or dense matrix, the feature matrix ,[n x d], d is the dimension of features
:param Z: sparse matrix, the labels, [n x c], c is the dimension of one-hot label
:param num_vicious_nodes: int, the number of vicious nodes
:param num_vicious_edges: int, the number of vicous edges
:param dmin: int, min degree assigned for vicious nodes
"""
self.A = A.tocsr()
self.A_orig = self.A.copy()
self.A.setdiag(0)
self.X = X
self.Z = Z
self.labels = list(np.squeeze(np.argmax(self.Z, axis=1)))
self.num_vicious_nodes = num_vicious_nodes
self.num_vicious_edges = num_vicious_edges
self.An = utils.preprocess_graph(self.A)
self.degree = np.squeeze(self.A.sum(axis=1).getA()) + 1
self.old_degree = np.squeeze(self.A.sum(axis=1).getA()) + 1
if sp.issparse(self.X):
self.cooc_X = sp.csr_matrix(self.X.T.dot(self.X))
self.cooc_X[self.cooc_X.nonzero()] = 1
self.X_d = int(np.sum(X) / self.X.shape[0])
else:
self.cooc_X = None
self.X_d = None
self.D_inv = sp.diags(1 / self.degree)
self.D_inv_sqrt = sp.diags(1 / np.sqrt(self.degree))
self.dv = self.get_random_degrees(dmin)
def read_data(adj_path, feature_path, label_path):
with open(adj_path, 'rb') as f:
_A_obs = pickle.load(f)
with open(feature_path, 'rb') as f:
_X_obs = pickle.load(f)
with open(label_path, 'rb') as f:
_z_obs = pickle.load(f)
_A_obs = _A_obs + _A_obs.T
_A_obs[_A_obs > 1] = 1
_A_obs.setdiag(0)
_A_obs = _A_obs.astype("float32")
_A_obs.eliminate_zeros()
_X_obs = _X_obs.astype("float32")
assert np.abs(_A_obs - _A_obs.T).sum() == 0, "Input graph is not symmetric"
assert _A_obs.max() == 1 and len(np.unique(
_A_obs[_A_obs.nonzero()].A1)) == 1, "Graph must be unweighted"
assert _A_obs.sum(0).A1.min() > 0, "Graph contains singleton nodes"
_An = utils.preprocess_graph(_A_obs)
_K = _z_obs.max() + 1
_Z_obs = np.eye(_K)[_z_obs]
sizes = [64, _K]
return _An, _X_obs, _Z_obs, sizes
adj, features = load_gene_data(use_features=True,
_adj='homology',
_feat='ontology')
# create graph from adjacency matrix
G = nx.from_numpy_matrix(adj.toarray())
# print(adj.shape)
#
# print(G.number_of_edges())
# print(G.number_of_nodes())
adj_label = adj
adj_label = torch.FloatTensor(adj_label.toarray())
adj_train = preprocess_graph(adj)
# Model and optimizer
model = GCNModelAE_UN(nfeat=features.shape[1],
nhid=args.hidden,
nclass=args.nclass,
dropout=args.dropout)
optimizer = optim.Adam(model.parameters(),
lr=args.lr,
weight_decay=args.weight_decay)
triplet_loss = TripletLoss(G, False)
indices = []
losses = []
def gae_for(args):
print("Using {} dataset".format(args.dataset_str))
adj, features = load_data(args.dataset_str)
# print(features)
# exit(0)
n_nodes, feat_dim = features.shape
print("#nodes={}".format(n_nodes))
# Store original adjacency matrix (without diagonal entries) for later
print(
"Store original adjacency matrix (without diagonal entries) for later..."
)
adj_orig = adj
adj_orig = adj_orig - sp.dia_matrix(
(adj_orig.diagonal()[np.newaxis, :], [0]), shape=adj_orig.shape)
adj_orig.eliminate_zeros()
print("Sample the edges for training and testing...")
adj_train, train_edges, val_edges, val_edges_false, test_edges, test_edges_false = mask_test_edges(
adj)
adj = adj_train
# Some preprocessing
print("Some preprocessing...")
adj_norm = preprocess_graph(adj)
adj_label = adj_train + sp.eye(adj_train.shape[0])
# adj_label = sparse_to_tuple(adj_label)
adj_label = torch.FloatTensor(adj_label.toarray())
pos_weight = float(adj.shape[0] * adj.shape[0] - adj.sum()) / adj.sum()
norm = adj.shape[0] * adj.shape[0] / float(
(adj.shape[0] * adj.shape[0] - adj.sum()) * 2)
model = GCNModelVAE(feat_dim, args.hidden1, args.hidden2, args.dropout)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
hidden_emb = None
for epoch in range(args.epochs):
t = time.time()
model.train()
optimizer.zero_grad()
recovered, mu, logvar = model(features, adj_norm)
pos_weight = torch.Tensor([pos_weight])
loss = loss_function(preds=recovered,
labels=adj_label,
mu=mu,
logvar=logvar,
n_nodes=n_nodes,
norm=norm,
pos_weight=pos_weight)
loss.backward()
cur_loss = loss.item()
optimizer.step()
hidden_emb = mu.data.numpy()
roc_curr, ap_curr = get_roc_score(hidden_emb, adj_orig, val_edges,
val_edges_false)
print("Epoch:", '%04d' % (epoch + 1), "train_loss=",
"{:.5f}".format(cur_loss), "val_ap=", "{:.5f}".format(ap_curr),
"time=", "{:.5f}".format(time.time() - t))
print("Optimization Finished!")
roc_score, ap_score = get_roc_score(hidden_emb, adj_orig, test_edges,
test_edges_false)
print('Test ROC score: ' + str(roc_score))
print('Test AP score: ' + str(ap_score))
num_edges = adj.sum() # 今，重みなしグラフを考えているので，全て足すとエッジ数になる
# featureless
# 現状，featuresがないので，単位行列（one-hotベクトル）を入れる
features = sparse_to_tuple(sp.identity(num_nodes))
num_features = features[2][1]
features_nonzero = features[1].shape[0] # [1]成分は，ノンゼロvalues
# Store original adjacency matrix (without diagonal entries) for later
adj_orig = adj - sp.dia_matrix((adj.diagonal()[np.newaxis, :], [0]), shape=adj.shape)
adj_orig.eliminate_zeros()
adj_train, train_edges, val_edges, val_edges_false, test_edges, test_edges_false = mask_test_edges(adj)
adj = adj_train
adj_norm = preprocess_graph(adj)
# Define placeholders
# 現状， featureはないので， sp.sparse表現でone-hotベクトルを入れているが， ここは変更する（一般にsparse表現ではない）
placeholders = {
'features': tf.sparse_placeholder(tf.float32),
'adj': tf.sparse_placeholder(tf.float32),
'adj_orig': tf.sparse_placeholder(tf.float32),
'dropout': tf.placeholder_with_default(0., shape=())
}
# Create model
model = GCNModel(placeholders, num_features, features_nonzero, name='yeast_gcn')
# Create optimizer
def gae_for(args):
print("Using {} dataset".format(args.dataset_str))
adj, features = load_data(args.dataset_str)
features = features.to(args.device)
n_nodes, feat_dim = features.shape
# Store original adjacency matrix (without diagonal entries) for later
adj_orig = adj
adj_orig = adj_orig - sp.dia_matrix(
(adj_orig.diagonal()[np.newaxis, :], [0]), shape=adj_orig.shape)
adj_orig.eliminate_zeros()
adj_train, train_edges, val_edges, val_edges_false, test_edges, test_edges_false = mask_test_edges(
adj)
adj = adj_train
# Some preprocessing
adj_norm = preprocess_graph(adj)
adj_norm = adj_norm.to(args.device)
adj_label = adj_train + sp.eye(adj_train.shape[0])
# adj_label = sparse_to_tuple(adj_label)
adj_label = torch.FloatTensor(adj_label.toarray())
adj_orig_tile = adj_label.unsqueeze(2).repeat(1, 1, args.K)
adj_orig_tile = adj_orig_tile.to(args.device)
pos_weight = torch.tensor(
float(adj.shape[0] * adj.shape[0] - adj.sum()) /
adj.sum()).float().to(device=args.device)
norm = adj.shape[0] * adj.shape[0] / float(
(adj.shape[0] * adj.shape[0] - adj.sum()) * 2)
psi_input_dim = args.noise_dim + feat_dim
logv_input_dim = feat_dim
model = GCNModelVAE(psi_input_dim, logv_input_dim, args.hidden1,
args.hidden2, args.dropout, args.K, args.J,
args.noise_dim, args.device).to(args.device)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
for epoch in range(args.epochs):
warm_up = torch.min(torch.FloatTensor([epoch / 300,
1])).to(args.device)
t = time.time()
model.train()
optimizer.zero_grad()
reconstruct_iw, log_prior_iw, log_H_iw, psi_iw_vec = model(
features, adj_norm)
hidden_emb = psi_iw_vec.data.contiguous().cpu().numpy()
loss = loss_function(reconstructed_iw=reconstruct_iw,
log_prior_iw=log_prior_iw,
log_H_iw=log_H_iw,
adj_orig_tile=adj_orig_tile,
nodes=n_nodes,
K=args.K,
pos_weight=pos_weight,
norm=norm,
warm_up=warm_up,
device=args.device)
loss.backward()
cur_loss = loss.item()
optimizer.step()
roc_score_val, ap_score_val = get_roc_score(hidden_emb, adj_orig,
val_edges, val_edges_false)
roc_score_test, ap_score_test = get_roc_score(hidden_emb, adj_orig,
test_edges,
test_edges_false)
print('Epoch:', '%04d ---> ' % (epoch + 1),
'training_loss = {:.5f} '.format(cur_loss),
'val_AP = {:.5f} '.format(ap_score_val),
'val_ROC = {:.5f} '.format(roc_score_val),
'test_AP = {:.5f} '.format(ap_score_test),
'test_ROC = {:.5f} '.format(roc_score_test),
'time = {:.5f} '.format(time.time() - t))
writer.add_scalar('Loss/train_loss', cur_loss, epoch)
writer.add_scalar('Average Precision/test', ap_score_test, epoch)
writer.add_scalar('Average Precision/val', ap_score_val, epoch)
writer.add_scalar('Area under Roc(AUC)/test', roc_score_test, epoch)
writer.add_scalar('Area under Roc(AUC)/val', roc_score_val, epoch)
print("Optimization Finished!")
def gae_for(args):
print("Using {} dataset".format(args.dataset_str))
adj, features, y_test, tx, ty, test_maks, true_labels = load_data(
args.dataset_str)
n_nodes, feat_dim = features.shape
# Store original adjacency matrix (without diagonal entries) for later
adj_orig = adj
adj_orig = adj_orig - sp.dia_matrix(
(adj_orig.diagonal()[np.newaxis, :], [0]), shape=adj_orig.shape)
adj_orig.eliminate_zeros()
adj_train, train_edges, val_edges, val_edges_false, test_edges, test_edges_false = mask_test_edges(
adj)
adj = adj_train
# Before proceeding further, make the structure for doing deepWalk
if args.dw == 1:
print('Using deepWalk regularization...')
G = load_edgelist_from_csr_matrix(adj_orig, undirected=True)
print("Number of nodes: {}".format(len(G.nodes())))
num_walks = len(G.nodes()) * args.number_walks
print("Number of walks: {}".format(num_walks))
data_size = num_walks * args.walk_length
print("Data size (walks*length): {}".format(data_size))
# Some preprocessing
adj_norm = preprocess_graph(adj)
adj_label = adj_train + sp.eye(adj_train.shape[0])
# adj_label = sparse_to_tuple(adj_label)
# adj_label = torch.DoubleTensor(adj_label.toarray())
adj_label = torch.FloatTensor(adj_label.toarray())
pos_weight = float(adj.shape[0] * adj.shape[0] - adj.sum()) / adj.sum()
norm = adj.shape[0] * adj.shape[0] / float(
(adj.shape[0] * adj.shape[0] - adj.sum()) * 2)
if args.model == 'gcn_vae':
model = GCNModelVAE(feat_dim, args.hidden1, args.hidden2, args.dropout)
else:
model = GCNModelAE(feat_dim, args.hidden1, args.hidden2, args.dropout)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
if args.dw == 1:
sg = SkipGram(args.hidden2, adj.shape[0])
optimizer_dw = optim.Adam(sg.parameters(), lr=args.lr_dw)
# Construct the nodes for doing random walk. Doing it before since the seed is fixed
nodes_in_G = list(G.nodes())
chunks = len(nodes_in_G) // args.number_walks
random.Random().shuffle(nodes_in_G)
hidden_emb = None
for epoch in tqdm(range(args.epochs)):
t = time.time()
model.train()
optimizer.zero_grad()
z, mu, logvar = model(features, adj_norm)
# After back-propagating gae loss, now do the deepWalk regularization
if args.dw == 1:
sg.train()
if args.full_number_walks > 0:
walks = build_deepwalk_corpus(G,
num_paths=args.full_number_walks,
path_length=args.walk_length,
alpha=0,
rand=random.Random(SEED))
else:
walks = build_deepwalk_corpus_iter(
G,
num_paths=args.number_walks,
path_length=args.walk_length,
alpha=0,
rand=random.Random(SEED),
chunk=epoch % chunks,
nodes=nodes_in_G)
for walk in walks:
if args.context == 1:
# Construct the pairs for predicting context node
# for each node, treated as center word
curr_pair = (int(walk[center_node_pos]), [])
for center_node_pos in range(len(walk)):
# for each window position
for w in range(-args.window_size,
args.window_size + 1):
context_node_pos = center_node_pos + w
# make soure not jump out sentence
if context_node_pos < 0 or context_node_pos >= len(
walk
) or center_node_pos == context_node_pos:
continue
context_node_idx = walk[context_node_pos]
curr_pair[1].append(int(context_node_idx))
else:
# first item in the walk is the starting node
curr_pair = (int(walk[0]), [
int(context_node_idx) for context_node_idx in walk[1:]
])
if args.ns == 1:
neg_nodes = []
pos_nodes = set(walk)
while len(neg_nodes) < args.walk_length - 1:
rand_node = random.randint(0, n_nodes - 1)
if rand_node not in pos_nodes:
neg_nodes.append(rand_node)
neg_nodes = torch.from_numpy(np.array(neg_nodes)).long()
# Do actual prediction
src_node = torch.from_numpy(np.array([curr_pair[0]])).long()
tgt_nodes = torch.from_numpy(np.array(curr_pair[1])).long()
optimizer_dw.zero_grad()
log_pos = sg(src_node, tgt_nodes, neg_sample=False)
if args.ns == 1:
loss_neg = sg(src_node, neg_nodes, neg_sample=True)
loss_dw = log_pos + loss_neg
else:
loss_dw = log_pos
loss_dw.backward(retain_graph=True)
cur_dw_loss = loss_dw.item()
optimizer_dw.step()
loss = loss_function(preds=model.dc(z),
labels=adj_label,
mu=mu,
logvar=logvar,
n_nodes=n_nodes,
norm=norm,
pos_weight=pos_weight)
loss.backward()
cur_loss = loss.item()
optimizer.step()
hidden_emb = mu.data.numpy()
roc_curr, ap_curr = get_roc_score(hidden_emb, adj_orig, val_edges,
val_edges_false)
if args.dw == 1:
tqdm.write(
"Epoch: {}, train_loss_gae={:.5f}, train_loss_dw={:.5f}, val_ap={:.5f}, time={:.5f}"
.format(epoch + 1, cur_loss, cur_dw_loss, ap_curr,
time.time() - t))
else:
tqdm.write(
"Epoch: {}, train_loss_gae={:.5f}, val_ap={:.5f}, time={:.5f}".
format(epoch + 1, cur_loss, ap_curr,
time.time() - t))
if (epoch + 1) % 10 == 0:
tqdm.write("Evaluating intermediate results...")
kmeans = KMeans(n_clusters=args.n_clusters,
random_state=0).fit(hidden_emb)
predict_labels = kmeans.predict(hidden_emb)
cm = clustering_metrics(true_labels, predict_labels)
cm.evaluationClusterModelFromLabel(tqdm)
roc_score, ap_score = get_roc_score(hidden_emb, adj_orig,
test_edges, test_edges_false)
tqdm.write('ROC: {}, AP: {}'.format(roc_score, ap_score))
np.save('logs/emb_epoch_{}.npy'.format(epoch + 1), hidden_emb)
tqdm.write("Optimization Finished!")
roc_score, ap_score = get_roc_score(hidden_emb, adj_orig, test_edges,
test_edges_false)
tqdm.write('Test ROC score: ' + str(roc_score))
tqdm.write('Test AP score: ' + str(ap_score))
kmeans = KMeans(n_clusters=args.n_clusters, random_state=0).fit(hidden_emb)
predict_labels = kmeans.predict(hidden_emb)
cm = clustering_metrics(true_labels, predict_labels)
cm.evaluationClusterModelFromLabel(tqdm)
if args.plot == 1:
cm.plotClusters(tqdm, hidden_emb, true_labels)
def train(self, W, logits, idx,
perturb_features = True, direct_attack=True, verbose=False):
"""
AFGSM attack
:param W: the weights of GCN
:param logits: the logits of GCN
:param idx: the target node
:param perturb_features: bool, if True, perturb features
:param direct_attack: bool, if True, direct attack
:param verbose: bool, whether to show losses
"""
sur_margins = []
true_label = np.argmax(self.Z[idx, :])
best_wrong_label = np.argmax(logits[idx, :] - 1000 * self.Z[idx, :])
w = W[:, best_wrong_label] - W[:, true_label]
w_idx = np.argsort(w)[::-1]
for i in range(w_idx.shape[0]): #values too small are ignored
if w[w_idx[i]]<0.001:
w_idx = w_idx[0:i]
break
self.d_inv_sqrt = 1 / np.sqrt(self.degree)
self.d_inv_sqrt = np.squeeze(self.d_inv_sqrt)
if direct_attack:
M1 = np.squeeze(1 / np.sqrt(self.dv[0]) * self.d_inv_sqrt * np.squeeze(self.X.dot(w)))
else:
M1 = None
A_idx = self.A[:, idx]
A_idx[idx] = 1
A_idx = np.squeeze(A_idx.toarray())
M2 = np.squeeze(self.d_inv_sqrt * A_idx)
for i in range(self.num_vicious_nodes):
if i>=1:
M1, M2 = self.update_M(M1, M2, w, idx, i, direct_attack)
e = sp.csr_matrix(np.zeros((self.A.shape[0], 1)))
x = self.X[np.random.randint(0, self.X.shape[0]), :]
if sp.issparse(self.X):
x_nnz = np.array(x.nonzero())
if x_nnz.shape[1] > self.X_d:
sample_idx = np.random.randint(0, x_nnz.shape[1], size=[x_nnz.shape[1] - self.X_d])
x[:, x_nnz[:, sample_idx][1, :]] = 0
X_mod = sp.vstack((self.X, x))
else:
X_mod = np.vstack((self.X, x))
z_vi = np.random.randint(0, self.Z.shape[1])
Z_vi = np.zeros((1, self.Z.shape[1]),dtype=np.int32)
Z_vi[0, z_vi] = 1
Z = np.vstack((self.Z, Z_vi))
self.labels.append(np.random.randint(0, self.Z.shape[1]))
if perturb_features:
x = self.get_sampled_features(w, w_idx, False)
X_mod = sp.vstack((self.X, x))
if direct_attack:
grad_e = np.squeeze(M1 + M2 * (x.dot(w)))
grad_e[idx] = 999999
else:
grad_e = np.squeeze(M2 * (x.dot(w)))
grad_e[idx] = -999999
gradients_idx = np.argsort(grad_e)[::-1][0:self.dv[i]]
if np.sum(grad_e > 0) < self.dv[i]:
e[grad_e > 0, 0] = 1
else:
e[gradients_idx, 0] = 1
A_mod = sp.hstack((sp.vstack((self.A, e.T)), sp.vstack((e, 0))))
if verbose:
with tf.Graph().as_default():
_An_mod = utils.preprocess_graph(A_mod)
logits_attacked = _An_mod.dot(_An_mod).dot(X_mod).dot(W)
loss_ = self.cal_loss(logits_attacked, idx)
print("losses:", loss_)
sur_margins.append(loss_)
self.A = A_mod.tocsr()
if sp.issparse(self.X):
self.X =X_mod.tocsr()
else:
self.X = X_mod
self.Z = Z
self.old_degree = self.degree
self.degree = list(self.degree)
self.degree.append(np.sum(e)+1)
self.degree = np.array(self.degree)
self.degree[e.nonzero()[0]] += 1
def adaptive_train(self, sizes, idx, split_train, split_val,
perturb_features = True, direct_attack=True, verbose=True,):
"""
adaptive attack, AFGSM-ada
:param sizes: list, the hidden size of GCN
:param idx: int, the target node ID
:param split_train: list, train set for GCN
:param split_val: list, valuation set for GCN
:param perturb_features: bool, if True, perturb features
:param direct_attack: bool, if True, direct attack
:param verbose: bool, whether to show losses
"""
true_label = np.argmax(self.Z[idx, :])
for i in range(self.num_vicious_nodes):
with tf.Graph().as_default():
_An = utils.preprocess_graph(self.A)
surrogate_model = GCN.GCN(sizes, _An, self.X, with_relu=False, name="surrogate",gpu_id=0)
surrogate_model.train(split_train, split_val, self.Z)
W1 = surrogate_model.W1.eval(session=surrogate_model.session)
W2 = surrogate_model.W2.eval(session=surrogate_model.session)
logits = surrogate_model.logits.eval(session=surrogate_model.session)
surrogate_model.session.close()
W = np.dot(W1, W2)
best_wrong_label = np.argmax(logits[idx, :] - 1000 * self.Z[idx, :])
w = W[:, best_wrong_label] - W[:, true_label]
w_idx = np.argsort(w)[::-1]
for j in range(w_idx.shape[0]):
if w[w_idx[j]] < 0:
w_idx = w_idx[0:j]
break
self.D_inv = sp.diags(1 / self.degree)
self.D_inv_sqrt = sp.diags(1 / np.sqrt(self.degree))
self.d_inv_sqrt = 1 / np.sqrt(self.degree)
self.d_inv_sqrt = np.squeeze(self.d_inv_sqrt)
if direct_attack:
M1 = np.squeeze(1 / np.sqrt(self.dv[0]) * self.d_inv_sqrt*(self.X.dot(w)))
else:
M1 = None
A_idx = self.A[:, idx]
A_idx[idx] = 1
M2 = np.squeeze(self.d_inv_sqrt * A_idx)
e = sp.csr_matrix(np.zeros((self.A.shape[0], 1)))
x = self.X[np.random.randint(0, self.X.shape[0]), :]
x_nnz = np.array(x.nonzero())
if x_nnz.shape[1] > self.X_d:
sample_idx = np.random.randint(0, x_nnz.shape[1], size=[x_nnz.shape[1] - self.X_d])
x[:, x_nnz[:, sample_idx][1, :]] = 0
X_mod = sp.vstack((self.X, x))
z_vi = np.random.randint(0, self.Z.shape[1])
Z_vi = np.zeros((1, self.Z.shape[1]), dtype=np.int32)
Z_vi[0, z_vi] = 1
Z = np.vstack((self.Z, Z_vi))
self.labels.append(np.random.randint(0, self.Z.shape[1]))
if perturb_features:
x = self.get_sampled_features(w, w_idx, False)
X_mod = sp.vstack((self.X, x))
if direct_attack:
grad_e = np.squeeze(M1 + M2 * (x.dot(w)))
grad_e[idx] = 999999
else:
grad_e = np.squeeze(M2 * (x.dot(w)))
grad_e[idx] = -999999
gradients_idx = np.argsort(grad_e)[::-1][0:self.dv[i]]
if np.sum(grad_e > 0) < self.dv[i]:
e[grad_e > 0, 0] = 1
else:
e[gradients_idx, 0] = 1
A_mod = sp.hstack((sp.vstack((self.A, e.T)), sp.vstack((e, 0))))
if verbose:
with tf.Graph().as_default():
_An_mod = utils.preprocess_graph(A_mod)
logits_attacked = _An_mod.dot(_An_mod).dot(X_mod).dot(W)
loss_ = self.cal_loss(logits_attacked, idx)
print("losses:", loss_)
self.A = A_mod.tocsr()
self.X = X_mod.tocsr()
self.Z = Z
self.old_degree = self.degree
self.degree = list(self.degree)
self.degree.append(np.sum(e) + 1)
self.degree = np.array(self.degree)
self.degree[e.nonzero()[0]] += 1
def gae_for(args):
print("Using {} dataset".format(args.dataset_str))
adj, features, y_test, tx, ty, test_maks, true_labels = load_data(args.dataset_str)
n_nodes, feat_dim = features.shape
# Store original adjacency matrix (without diagonal entries) for later
adj_orig = adj
adj_orig = adj_orig - sp.dia_matrix((adj_orig.diagonal()[np.newaxis, :], [0]), shape=adj_orig.shape)
adj_orig.eliminate_zeros()
adj_train, train_edges, val_edges, val_edges_false, test_edges, test_edges_false = mask_test_edges(adj)
adj = adj_train
# Some preprocessing
adj_norm = preprocess_graph(adj)
adj_label = adj_train + sp.eye(adj_train.shape[0])
# adj_label = sparse_to_tuple(adj_label)
# adj_label = torch.DoubleTensor(adj_label.toarray())
adj_label = torch.FloatTensor(adj_label.toarray())
pos_weight = float(adj.shape[0] * adj.shape[0] - adj.sum()) / adj.sum()
norm = adj.shape[0] * adj.shape[0] / float((adj.shape[0] * adj.shape[0] - adj.sum()) * 2)
if args.model == 'gcn_vae':
model = GCNModelVAE(feat_dim, args.hidden1, args.hidden2, args.dropout)
else:
model = GCNModelAE(feat_dim, args.hidden1, args.hidden2, args.dropout)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
hidden_emb = None
for epoch in tqdm(range(args.epochs)):
t = time.time()
model.train()
optimizer.zero_grad()
z, mu, logvar = model(features, adj_norm)
loss = loss_function(preds=model.dc(z), labels=adj_label,
mu=mu, logvar=logvar, n_nodes=n_nodes,
norm=norm, pos_weight=pos_weight)
loss.backward()
cur_loss = loss.item()
optimizer.step()
hidden_emb = mu.data.numpy()
roc_curr, ap_curr = get_roc_score(hidden_emb, adj_orig, val_edges, val_edges_false)
tqdm.write("Epoch: {}, train_loss_gae={:.5f}, val_ap={:.5f}, time={:.5f}".format(
epoch + 1, cur_loss,
ap_curr, time.time() - t))
if (epoch + 1) % 10 == 0:
tqdm.write("Evaluating intermediate results...")
kmeans = KMeans(n_clusters=args.n_clusters, random_state=0).fit(hidden_emb)
predict_labels = kmeans.predict(hidden_emb)
cm = clustering_metrics(true_labels, predict_labels)
cm.evaluationClusterModelFromLabel(tqdm)
roc_score, ap_score = get_roc_score(hidden_emb, adj_orig, test_edges, test_edges_false)
tqdm.write('ROC: {}, AP: {}'.format(roc_score, ap_score))
np.save('logs/emb_epoch_{}.npy'.format(epoch + 1), hidden_emb)
tqdm.write("Optimization Finished!")
roc_score, ap_score = get_roc_score(hidden_emb, adj_orig, test_edges, test_edges_false)
tqdm.write('Test ROC score: ' + str(roc_score))
tqdm.write('Test AP score: ' + str(ap_score))
kmeans = KMeans(n_clusters=args.n_clusters, random_state=0).fit(hidden_emb)
predict_labels = kmeans.predict(hidden_emb)
cm = clustering_metrics(true_labels, predict_labels)
cm.evaluationClusterModelFromLabel(tqdm)
if args.plot == 1:
cm.plotClusters(tqdm, hidden_emb, true_labels)
_A_obs = _A_obs[lcc][:, lcc]
_A_obs.setdiag(0)
_A_obs = _A_obs.astype("float32")
_A_obs.eliminate_zeros()
_X_obs = _X_obs.astype("float32")
assert np.abs(_A_obs - _A_obs.T).sum() == 0, "Input graph is not symmetric"
assert _A_obs.max() == 1 and len(np.unique(
_A_obs[_A_obs.nonzero()].A1)) == 1, "Graph must be unweighted"
assert _A_obs.sum(0).A1.min() > 0, "Graph contains singleton nodes"
_X_obs = _X_obs[lcc]
_z_obs = _z_obs[lcc]
_An = utils.preprocess_graph(_A_obs)
X_degree = np.squeeze(np.array(sp.spmatrix.sum(_X_obs, axis=1)))
mean_x = int(np.mean(X_degree))
_N = _A_obs.shape[0]
_K = _z_obs.max() + 1
_Z_obs = np.eye(_K)[_z_obs]
sizes = [16, _K]
unlabeled_share = 0.8
val_share = 0.1
train_share = 1 - unlabeled_share - val_share
np.random.seed(seed)
label_idx = _z_obs[idx]
def gae_for(args):
print("Using {} dataset".format(args.dataset_str))
# adj, features, y_test, tx, ty, test_maks, true_labels = load_data('cora')
# print(true_labels)
# adj, features, y_test, test_maks, true_labels=load_npz('amazon_electronics_photo')
# print(true_labels)
# adj=preprocess_high_order_adj( adj, 2, 0.01 )
# print(adj)
# if args.dataset_split == 'jknet':
g, features, true_labels, train_mask, val_mask, test_mask, num_features, num_labels = utils_data.load_data(
args.dataset_str, None, 0.6, 0.2)
adj = g.adj(scipy_fmt='coo')
true_labels = true_labels.detach().numpy()
# print(true_labels)
# else:
# g, features, labels, train_mask, val_mask, test_mask, num_features, num_labels = utils_data.load_data(
# args.dataset_str, args.dataset_split)
args.n_clusters = true_labels.max() + 1
print(args.n_clusters, "ssssssss")
# Store original adjacency matrix (without diagonal entries) for later
adj_orig = adj
adj_orig = adj_orig - sp.dia_matrix(
(adj_orig.diagonal()[np.newaxis, :], [0]), shape=adj_orig.shape)
adj_orig.eliminate_zeros()
adj_train, train_edges, val_edges, val_edges_false, test_edges, test_edges_false = mask_test_edges(
adj)
# adj = adj_train
# Some preprocessing
adj_norm = preprocess_graph(adj)
# adj_norm = torch.sparse.FloatTensor(sp.coo_matrix(adj))
# adj_norm=torch.tensor(adj.todense(),dtype=torch.float)
# print(adj_norm)
adj_label = adj_train + sp.eye(adj_train.shape[0])
# adj_label = sparse_to_tuple(adj_label)
adj_label = torch.FloatTensor(adj_label.toarray())
pos_weight = float(adj.shape[0] * adj.shape[0] - adj.sum()) / adj.sum()
norm = adj.shape[0] * adj.shape[0] / float(
(adj.shape[0] * adj.shape[0] - adj.sum()) * 2)
z_x = torch.zeros(features.shape[0], args.hidden1)
z_w = torch.zeros(features.shape[0], args.hidden2)
z_shuffle = torch.cat((features, z_x, z_w), axis=1)
n_nodes, feat_dim = z_shuffle.shape
model = GCNModelVAE(feat_dim, args.hidden1, args.hidden2, args.dropout,
args.n_clusters)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
z_x, mu_x, _, z_w, mu_w, _, _, logvar_px, qz = model(z_shuffle, adj_norm)
z_shuffle = torch.cat((features, z_x.detach_(), z_w.detach_()), axis=1)
hidden_emb = None
for epoch in tqdm(range(args.epochs)):
t = time.time()
model.train()
optimizer.zero_grad()
# z_shuffle=torch.cat((features,z_x.detach_(),z_w.detach_()),axis=1)
z_x, mu_x, logvar_x, z_w, mu_w, logvar_w, mu_px, logvar_px, qz = model(
z_shuffle, adj_norm)
# print(z_x.shape,"z_x.shape")
# After back-propagating gae loss, now do the deepWalk regularization
# mu_x = mu_x.unsqueeze(-1)
# mu_x = mu_x.expand(-1, args.hidden2)
logvar_x1 = logvar_x.unsqueeze(-1)
logvar_x1 = logvar_x1.expand(-1, args.hidden2, args.n_clusters)
mu_x1 = mu_x.unsqueeze(-1)
mu_x1 = mu_x1.expand(-1, args.hidden2, args.n_clusters)
if torch.cuda.is_available():
mu_x1 = mu_x1.cuda()
logvar_x1 = logvar_x1.cuda()
# KLD_W = -0.5 / n_nodes* torch.sum(1 + logvar_w - mu_w.pow(2) - logvar_w.exp())
# KLD_Z = -torch.sum(qz * torch.log(qz + 1e-10))/n_nodes
KLD_Z = -0.5 / n_nodes * torch.mean(
torch.sum(1 + qz * torch.log(qz + 1e-10), 1))
# print(KLD_Z,"klz")
# qz = qz.unsqueeze(-1)
# qz = qz.expand(-1, 1)
# print(logvar_px.shape,logvar_x1.shape,"hhhhi")
# KLD_QX_PX = 0.5 / n_nodes* (((logvar_px - logvar_x) + ((logvar_x.exp() + (mu_x - mu_px).pow(2))/logvar_px.exp())) - 1)
# # print(KLD_QX_PX.shape,qz.shape,"hhhhi")
# KLD_QX_PX = KLD_QX_PX.unsqueeze(1)
# qz = qz.unsqueeze(-1)
# print(KLD_QX_PX.shape,qz.shape,"hhhhi")
# KLD_QX_PX = KLD_QX_PX.expand(2708, 1, args.hidden2)
KLD_QX_PX = loss_function(preds=model.dc(z_x),
labels=adj_label,
mu=(mu_x1 - mu_px),
logvar=(logvar_px - logvar_x1),
n_nodes=n_nodes,
norm=norm,
pos_weight=pos_weight)
KLD_QX_PX = KLD_QX_PX = KLD_QX_PX.expand(n_nodes, 1, args.hidden2)
E_KLD_QX_PX = torch.sum(
torch.bmm(KLD_QX_PX,
qz.unsqueeze(-1) / n_nodes))
# print(E_KLD_QX_PX)
# print(model.dc(z_x).shape,adj_label.shape,"hdhhhhhhd")
model.train()
optimizer.zero_grad()
lbl_1 = torch.ones(n_nodes)
lbl_2 = torch.zeros(n_nodes)
lbl = torch.cat((lbl_1, lbl_2))
idx = np.random.permutation(n_nodes)
# print(features.shape,z_x.shape,adj_norm.shape)
shuf_fts = z_shuffle[idx, :]
# FeatHL=torch.cat((features,shuf_fts),axis=1)
# _, featHL_dim = FeatHL.shape
# modelHL = GCNModelVAE(featHL_dim, args.hidden1, args.hidden2, args.dropout,2)
n_nodes1, feat_dim1 = z_shuffle.shape
# model1 = GCNModelVAE(feat_dim1, args.hidden1, args.hidden2, args.dropout,args.n_clusters)
# z_xL1, mu_xL1, logvar_xL1,z_wL1, mu_wL1, logvar_wL1,mu_pxL1, logvar_pxL1,_ = model1(z_shuffle, adj_norm)
z_xL2, mu_xL2, logvar_xL2, z_wL2, mu_wL2, logvar_wL2, mu_pxL2, logvar_pxL2, qz2 = model(
shuf_fts, adj_norm)
KLD_Z2 = 0.5 / n_nodes * torch.mean(
torch.sum(1 + qz2 * torch.log(qz2 + 1e-10), 1))
KLD_QX_PX2 = loss_function(preds=model.dc(z_wL2),
labels=adj_label,
mu=mu_wL2,
logvar=logvar_wL2,
n_nodes=n_nodes,
norm=norm,
pos_weight=pos_weight)
KLD_QX_PX2 = KLD_QX_PX2.expand(n_nodes, 1, args.hidden2)
E_KLD_QX_PX2 = torch.sum(
torch.bmm(KLD_QX_PX2,
qz2.unsqueeze(-1) / n_nodes))
lossF = (1.0/loss_function(preds=model.dc(z_xL2), labels=adj_label,
mu=mu_xL2, logvar=logvar_xL2, n_nodes=n_nodes,
norm=norm, pos_weight=pos_weight))+\
(1.0/E_KLD_QX_PX2)+KLD_Z2
# z_xL2, mu_xL2, logvar_xL2,z_wL2, mu_wL2, logvar_wL2,mu_pxL2, logvar_pxL2,qz2 = model(shuf_fts, adj_norm)
# lossF = (1.0/loss_function(preds=model.dc(z_xL2), labels=adj_label,
# mu=mu_xL2, logvar=logvar_xL2, n_nodes=n_nodes,
# norm=norm, pos_weight=pos_weight))+\
# (1.0/E_KLD_QX_PX2)+ KLD_Z2+lossF
# lossF = loss_functionShuffle(preds=model.dc(z_xL2), labels=adj_label,
# mu=mu_xL2, logvar=logvar_xL2, n_nodes=n_nodes,
# norm=norm, pos_weight=pos_weight)+\
# loss_functionShuffle(preds=model.dc(z_wL2), labels=adj_label,
# mu=mu_wL2, logvar=logvar_wL2, n_nodes=n_nodes,
# norm=norm, pos_weight=pos_weight)
# LossF=Variable(torch.tensor(lossF).type(torch.FloatTensor),requires_grad=True)
# lossF.backward()
loss = loss_function(
preds=model.dc(z_x),
labels=adj_label,
mu=mu_x,
logvar=logvar_x,
n_nodes=n_nodes,
norm=norm,
pos_weight=pos_weight) + loss_function(
preds=model.dc(z_w),
labels=adj_label,
mu=mu_w,
logvar=logvar_w,
n_nodes=n_nodes,
norm=norm,
pos_weight=pos_weight) + lossF + KLD_Z + E_KLD_QX_PX
# if lossF<0.02:
# break
# lossF.backward()
# HL=np.concatenate((mu_xL1.data.numpy(),mu_wL1.data.numpy()),axis=1)
# HL2=np.concatenate((mu_xL2.data.numpy(),mu_wL2.data.numpy()),axis=1)
# kmeans = KMeans(n_clusters=2, random_state=0).fit(HL)
# kmeans2 = KMeans(n_clusters=2, random_state=0).fit(HL2)
# predict_labels = kmeans.predict(HL)
# predict_labels2 = kmeans.predict(HL2)
# pr=np.amax(kmeans.fit_transform(HL), axis=1)
# pr2=np.amax(kmeans.fit_transform(HL2), axis=1)
# pr=torch.cat((torch.tensor(pr), torch.tensor(pr2)))
# b_xent = nn.BCEWithLogitsLoss()
# lossF = b_xent(torch.FloatTensor(pr),torch.FloatTensor(lbl))
# print(lossF)
# print(loss, lossF)
loss.backward(retain_graph=True)
cur_loss = loss.item()
optimizer.step()
hidden_emb = np.concatenate((mu_x.data.numpy(), mu_w.data.numpy()),
axis=1)
# hidden_emb=mu_x.data.numpy()
# print(hidden_emb.shape)
# roc_curr, ap_curr = get_roc_score(hidden_emb, adj_orig, val_edges, val_edges_false)
# if args.dw == 1:
# tqdm.write("Epoch: {}, train_loss_gae={:.5f}, train_loss_dw={:.5f}, val_ap={:.5f}, time={:.5f}".format(
# epoch + 1, cur_loss, cur_dw_loss,
# ap_curr, time.time() - t))
# else:
# tqdm.write("Epoch: {}, train_loss_gae={:.5f}, val_ap={:.5f}, time={:.5f}".format(
# epoch + 1, cur_loss,
# ap_curr, time.time() - t))
roc_score, ap_score = get_roc_score(hidden_emb, adj_orig, test_edges,
test_edges_false)
# # tqdm.write('ROC: {}, AP: {}'.format(roc_score, ap_score))
wandb.log({"roc_score1": roc_score})
wandb.log({"ap_score1": ap_score})
if (epoch + 1) % 10 == 0:
tqdm.write("Evaluating intermediate results...")
kmeans = KMeans(n_clusters=args.n_clusters,
random_state=0).fit(hidden_emb)
predict_labels = kmeans.predict(hidden_emb)
# print(np.argmax(kmeans.fit_transform(hidden_emb), axis=1).shape)
pr = np.amax(kmeans.fit_transform(hidden_emb), axis=1)
b_xent = nn.BCEWithLogitsLoss()
print(loss, lossF)
# lossF = b_xent(torch.FloatTensor(pr),torch.FloatTensor(true_labels))
cm = clustering_metrics(true_labels, predict_labels)
cm.evaluationClusterModelFromLabel(tqdm)
roc_score, ap_score = get_roc_score(hidden_emb, adj_orig,
test_edges, test_edges_false)
tqdm.write('ROC: {}, AP: {}'.format(roc_score, ap_score))
# np.save('logs/emb_epoch_{}.npy'.format(epoch + 1), hidden_emb)
print(loss, lossF)
print("Kmeans ACC", purity_score(true_labels, predict_labels))
# roc_score, ap_score = get_roc_score(hidden_emb, adj_orig, test_edges, test_edges_false)
# tqdm.write('Test ROC score: ' + str(roc_score))
# tqdm.write('Test AP score: ' + str(ap_score))
tqdm.write("Optimization Finished!")
roc_score, ap_score = get_roc_score(hidden_emb, adj_orig, test_edges,
test_edges_false)
tqdm.write('Test ROC score: ' + str(roc_score))
tqdm.write('Test AP score: ' + str(ap_score))
kmeans = KMeans(n_clusters=args.n_clusters, random_state=0).fit(hidden_emb)
predict_labels = kmeans.predict(hidden_emb)
cm = clustering_metrics(true_labels, predict_labels)
cm.evaluationClusterModelFromLabel(tqdm)
print("Kmeans ACC", purity_score(true_labels, predict_labels))
if args.plot == 1:
cm.plotClusters(tqdm, hidden_emb, true_labels)
def gae_for(args):
print("Using {} dataset".format(args.dataset_str))
# Set tensor dtype to float16
# torch.set_default_tensor_type(torch.HalfTensor)
adj, features = load_data(args.dataset_str)
_, n_nodes, feat_dim = features.shape
# Store original adjacency matrix (without diagonal entries) for later
adj_orig = adj
adj_orig = adj_orig - sp.dia_matrix(
(adj_orig.diagonal()[np.newaxis, :], [0]), shape=adj_orig.shape)
adj_orig.eliminate_zeros()
adj_train, train_edges, val_edges, val_edges_false, test_edges, test_edges_false = mask_test_edges(
adj)
adj = adj_train
# Some preprocessing
adj_norm = preprocess_graph(adj)
adj_label = adj_train + sp.eye(adj_train.shape[0])
# adj_label = sparse_to_tuple(adj_label)
adj_label = torch.FloatTensor(adj_label.toarray())
pos_weight = torch.tensor(
[float(adj.shape[0] * adj.shape[0] - adj.sum()) / adj.sum()])
norm = adj.shape[0] * adj.shape[0] / float(
(adj.shape[0] * adj.shape[0] - adj.sum()) * 2)
model = GCNModelSIGVAE(args.edim,
feat_dim,
args.hidden1,
args.hidden2,
args.dropout,
encsto=args.encsto,
gdc=args.gdc,
ndist=args.noise_dist,
copyK=args.K,
copyJ=args.J,
device=args.device)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
hidden_emb = None
model.to(args.device)
features = features.to(args.device)
adj_norm = adj_norm.to(args.device)
adj_label = adj_label.to(args.device)
pos_weight = pos_weight.to(args.device)
for epoch in range(args.epochs):
t = time.time()
model.train()
optimizer.zero_grad()
recovered, mu, logvar, z, z_scaled, eps, rk, snr = model(
features, adj_norm)
loss_rec, loss_prior, loss_post = loss_function(preds=recovered,
labels=adj_label,
mu=mu,
logvar=logvar,
emb=z,
eps=eps,
n_nodes=n_nodes,
norm=norm,
pos_weight=pos_weight)
WU = np.min([epoch / 300., 1.])
reg = (loss_post - loss_prior) * WU / (n_nodes**2)
loss_train = loss_rec + WU * reg
# loss_train = loss_rec
loss_train.backward()
cur_loss = loss_train.item()
cur_rec = loss_rec.item()
# cur_rec_bce = loss_rec1.item()
optimizer.step()
hidden_emb = z_scaled.detach().cpu().numpy()
roc_curr, ap_curr = get_roc_score(hidden_emb, val_edges,
val_edges_false, args.gdc)
print("Epoch:", '%04d' % (epoch + 1), "train_loss=",
"{:.5f}".format(cur_loss), "rec_loss=", "{:.5f}".format(cur_rec),
"val_ap=", "{:.5f}".format(ap_curr), "time=",
"{:.5f}".format(time.time() - t))
# print(rk.detach().cpu().numpy())
cur_snr = snr.detach().cpu().numpy()
print("SNR: ", cur_snr)
if ((epoch + 1) % args.monit == 0):
model.eval()
recovered, mu, logvar, z, z_scaled, eps, rk, _ = model(
features, adj_norm)
hidden_emb = z_scaled.detach().cpu().numpy()
roc_score, ap_score = get_roc_score(hidden_emb, test_edges,
test_edges_false, args.gdc)
rslt = "Test ROC score: {:.4f}, Test AP score: {:.4f}\n".format(
roc_score, ap_score)
print("\n", rslt, "\n")
with open("results.txt", "a+") as f:
f.write(rslt)
print("Optimization Finished!")
def gae_for(args, iter='0.txt'):
# print("Using {} dataset".format(args.ds))
# adj_cd, features = load_data(args.ds)
'Load features!'
if args.ds.startswith('tf'):
if args.labels == 'y':
adj_cd, adj_dd, features, tags_nodes = my_load_data_tfidf_semi(
args.wmd)
else:
adj_cd, adj_dd, features = my_load_data_tfidf(args.wmd)
else:
#
if args.labels == 'y':
adj_cd, adj_dd, features, tags_nodes = my_load_data_p2v_semi(
args.wmd)
else:
adj_cd, adj_dd, features = my_load_data_p2v(args.wmd)
# adj_cd, adj_dd, features = my_load_data_p2v()
'Load test adjacency matrix'
adj_test = load_test()
# adj_test = load_test_10_percent(iter)
n_nodes, feat_dim = features.shape
# Store original adjacency matrix (without diagonal entries) for later
adj_orig_cd = adj_cd
'do again for adj_dd'
adj_orig_dd = adj_dd
adj_train_cd, train_edges, val_edges, val_edges_false = mask_train_edges(
adj_cd)
'do again for adj_dd'
adj_train_dd, train_edges_dd, _, _ = mask_train_edges(adj_dd) #
adj_cd = adj_train_cd
adj_dd = adj_train_dd
test_edges, test_edges_false = make_test_edges(adj_train_cd, adj_test)
# Some preprocessing: calculate norm
adj_norm_cd = preprocess_graph(adj_cd)
'For loss function: add diag values'
adj_label_cd = adj_train_cd + sp.eye(adj_train_cd.shape[0])
adj_label_cd = torch.FloatTensor(adj_label_cd.toarray())
pos_weight_cd = float(adj_cd.shape[0] * adj_cd.shape[0] -
adj_cd.sum()) / adj_cd.sum()
norm_cd = adj_cd.shape[0] * adj_cd.shape[0] / float(
(adj_cd.shape[0] * adj_cd.shape[0] - adj_cd.sum()) * 2)
'do it again for adj_dd'
adj_norm_dd = preprocess_graph(adj_dd)
adj_label_dd = adj_train_dd + sp.eye(adj_train_dd.shape[0])
adj_label_dd = torch.FloatTensor(adj_label_dd.toarray())
pos_weight_dd = float(adj_dd.shape[0] * adj_dd.shape[0] -
adj_dd.sum()) / adj_dd.sum()
norm_dd = adj_dd.shape[0] * adj_dd.shape[0] / float(
(adj_dd.shape[0] * adj_dd.shape[0] - adj_dd.sum()) * 2)
if args.labels == 'y':
model = GCNModelVAE_Semi(feat_dim, args.hidden1, args.hidden2,
args.dropout, args.class_dim)
else:
model = GCNModelVAE(feat_dim, args.hidden1, args.hidden2, args.dropout)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
print('Now start training...')
hidden_emb = None
for epoch in range(args.epochs):
t = time.time()
model.train()
optimizer.zero_grad()
# import pdb;pdb.set_trace
if args.labels == 'y':
recovered, mu, logvar, pred_nodes = model(
features, [adj_norm_cd, adj_norm_dd])
loss = loss_function_relation_semi(preds=recovered,
labels=(adj_label_cd,
adj_label_dd),
mu=mu,
logvar=logvar,
n_nodes=n_nodes,
norm=(norm_cd, norm_dd),
pos_weight=(pos_weight_cd,
pos_weight_dd),
pred_nodes=pred_nodes,
tags_nodes=tags_nodes)
else:
recovered, mu, logvar = model(features, [adj_norm_cd, adj_norm_dd])
loss = loss_function_relation(preds=recovered,
labels=(adj_label_cd, adj_label_dd),
mu=mu,
logvar=logvar,
n_nodes=n_nodes,
norm=(norm_cd, norm_dd),
pos_weight=(pos_weight_cd,
pos_weight_dd))
loss.backward()
cur_loss = loss.item()
optimizer.step()
hidden_emb = mu.data.numpy()
acc_curr, p, r, f1, map_curr, roc_curr = my_eval(
hidden_emb, (adj_orig_cd, adj_orig_dd), val_edges, val_edges_false)
print("Epoch:", '%04d' % (epoch + 1), "train_loss=",
"{:.5f}".format(cur_loss), "val_ap=", "{:.5f}".format(map_curr),
"val_ac=", "{:.5f}".format(acc_curr), "time=",
"{:.5f}".format(time.time() - t))
print("Optimization Finished!")
acc_score, p, r, f1, map_score, roc_score = my_eval_test(
hidden_emb, (adj_orig_cd, adj_orig_dd), test_edges, test_edges_false)
# print('Test ROC score: ' + str(roc_score))
# print('Test AP score: ' + str(ap_score))
# print ("Test accuracy ", "{:.5f}".format(acc_score))
# print ('P {:.5f}, R {:.5f}, F1 {:.5f}'.format(p,r,f1))
print('Acc, P, R, F1, MAP, AUC')
print('{:5f},{:5f},{:5f},{:5f},{:5f},{:5f}'.format(acc_score, p, r, f1,
map_score, roc_score))
return acc_score, p, r, f1, map_score, roc_score
