def define_optimizer(args, model, data_shape, placeholders):
input_dim = data_shape[0]
num_nodes, num_features = data_shape[1], data_shape[1]
if args.model_type == 'VAE':
with tf.name_scope('optimizer'):
opt = OptimizerVAE(
reconstructions=tf.reshape(model.reconstructions, [-1]),
inputs=tf.reshape(placeholders['inputs'][:, :16110], [-1]),
labels=tf.reshape(placeholders['inputs'][:, 16110:], [-1]),
preds=tf.reshape(model.preds, [-1]),
model=model,
learning_rate=args.learning_rate,
lambd=placeholders['lambd'],
tolerance=args.tol)
elif args.model_type == 'VGAE':
with tf.name_scope('optimizer'):
opt = OptimizerVGAE(preds=model.reconstructions,
labels=tf.reshape(placeholders['adj_orig'],
[-1]),
model=model,
num_nodes=num_nodes,
learning_rate=args.learning_rate,
lambd=placeholders['lambd'],
tolerance=args.tol)
else:
opt = None, None
return opt
def get_optimizer(model_str, model, discriminator, placeholders, pos_weight,
norm, d_real, num_nodes):
if model_str == 'arga_ae':
d_fake = discriminator.construct(model.embeddings, reuse=True)
opt = OptimizerAE(preds=model.reconstructions,
labels=tf.reshape(
tf.sparse_tensor_to_dense(
placeholders['adj_orig'],
validate_indices=False), [-1]),
pos_weight=pos_weight,
norm=norm,
d_real=d_real,
d_fake=d_fake)
elif model_str == 'arga_vae':
opt = OptimizerVAE(preds=model.reconstructions,
labels=tf.reshape(
tf.sparse_tensor_to_dense(
placeholders['adj_orig'],
validate_indices=False), [-1]),
model=model,
num_nodes=num_nodes,
pos_weight=pos_weight,
norm=norm,
d_real=d_real,
d_fake=discriminator.construct(model.embeddings,
reuse=True))
return opt
def get_optimizer(model_str, model, placeholders, num_nodes, alpha):
if model_str == 'gcn_ae':
opt = OptimizerAE(preds_attribute=model.attribute_reconstructions,
labels_attribute=tf.sparse_tensor_to_dense(placeholders['features']),
preds_structure=model.structure_reconstructions,
labels_structure=tf.sparse_tensor_to_dense(placeholders['adj_orig']), alpha=alpha)
elif model_str == 'gcn_vae':
opt = OptimizerVAE(preds=model.reconstructions,
labels=placeholders['features'],
model=model, num_nodes=num_nodes)
return opt
# Optimizer
with tf.name_scope('optimizer'):
if model_str == 'gcn_ae':
opt = OptimizerAE(preds=model.reconstructions,
labels=tf.reshape(
tf.sparse_tensor_to_dense(
placeholders['adj_orig'],
validate_indices=False), [-1]),
pos_weight=pos_weight,
norm=norm)
elif model_str == 'gcn_vae':
opt = OptimizerVAE(preds=model.reconstructions,
labels=tf.reshape(
tf.sparse_tensor_to_dense(
placeholders['adj_orig'],
validate_indices=False), [-1]),
model=model,
num_nodes=num_nodes,
pos_weight=pos_weight,
norm=norm)
logging.info('initialize session')
# Initialize session
sess = tf.Session()
sess.run(tf.global_variables_initializer())
adj_label = adj_train + sp.eye(adj_train.shape[0])
adj_label = sparse_to_tuple(adj_label)
logging.info('train model')
# Train model
for epoch in range(FLAGS.epochs):
t = time.time()
def train_gcn(features, adj_train, train_edges, train_edges_false, test_edges,
test_edges_false):
# Settings
flags = tf.app.flags
FLAGS = flags.FLAGS
flags.DEFINE_float('learning_rate', 0.005, 'Initial learning rate.')
flags.DEFINE_integer('epochs', 200, 'Number of epochs to train.')
flags.DEFINE_integer('hidden1', 96, 'Number of units in hidden layer 1.')
flags.DEFINE_integer('hidden2', 48, 'Number of units in hidden layer 2.')
flags.DEFINE_float('weight_decay', 0.,
'Weight for L2 loss on embedding matrix.')
flags.DEFINE_float('dropout', 0., 'Dropout rate (1 - keep probability).')
flags.DEFINE_string('model', 'gcn_vae', 'Model string.')
flags.DEFINE_integer('features', 1,
'Whether to use features (1) or not (0).')
model_str = FLAGS.model
#1-dim index array, used in cost function to only focus on those interactions with high confidence
mask_index = construct_optimizer_list(features.shape[0], train_edges,
train_edges_false)
# Store original adjacency matrix (without diagonal entries) for later
adj_orig = adj_train
adj_orig = adj_orig - sp.dia_matrix(
(adj_orig.diagonal()[np.newaxis, :], [0]), shape=adj_orig.shape)
adj_orig.eliminate_zeros()
adj = adj_train
if FLAGS.features == 0:
features = sp.identity(features.shape[0]) # featureless
# Some preprocessing
adj_norm = preprocess_graph(adj)
# Define placeholders
placeholders = {
'features': tf.sparse_placeholder(tf.float64),
'adj': tf.sparse_placeholder(tf.float64),
'adj_orig': tf.sparse_placeholder(tf.float64),
'dropout': tf.placeholder_with_default(0., shape=())
}
num_nodes = adj.shape[0]
features = sparse_to_tuple(features.tocoo())
num_features = features[2][1]
features_nonzero = features[1].shape[0]
# Create model
model = None
if model_str == 'gcn_ae':
model = GCNModelAE(placeholders, num_features, features_nonzero)
elif model_str == 'gcn_vae':
model = GCNModelVAE(placeholders, num_features, num_nodes,
features_nonzero)
pos_weight = 1
norm = 1
#pos_weight = train_edges_false.shape[0] / float(train_edges.shape[0])
#norm = (train_edges.shape[0]+train_edges_false.shape[0]) / float(train_edges_false.shape[0]*train_edges_false.shape[0])
# Optimizer
with tf.name_scope('optimizer'):
if model_str == 'gcn_ae':
opt = OptimizerAE(preds=model.reconstructions,
labels=tf.reshape(
tf.sparse_tensor_to_dense(
placeholders['adj_orig'],
validate_indices=False), [-1]),
pos_weight=pos_weight,
norm=norm,
mask=mask_index)
elif model_str == 'gcn_vae':
opt = OptimizerVAE(preds=model.reconstructions,
labels=tf.reshape(
tf.sparse_tensor_to_dense(
placeholders['adj_orig'],
validate_indices=False), [-1]),
model=model,
num_nodes=num_nodes,
pos_weight=pos_weight,
norm=norm,
mask=mask_index)
# Initialize session
sess = tf.Session()
sess.run(tf.global_variables_initializer())
adj_label = adj_train + sp.eye(adj_train.shape[0])
adj_label = sparse_to_tuple(adj_label)
# Train model
for epoch in range(FLAGS.epochs):
t = time.time()
# Construct feed dictionary
feed_dict = construct_feed_dict(adj_norm, adj_label, features,
placeholders)
feed_dict.update({placeholders['dropout']: FLAGS.dropout})
# Run single weight update
outs = sess.run([opt.opt_op, opt.cost], feed_dict=feed_dict)
print("Epoch:", '%04d' % (epoch + 1), "train_loss=",
"{:.5f}".format(outs[1]))
print("Optimization Finished!")
#return embedding for each protein
emb = sess.run(model.z_mean, feed_dict=feed_dict)
return emb
norm=norm)
elif model_str == 'gcn_vae':
n, _, _ = model.logits_output.get_shape().as_list()
tensor_list = []
for adj_channel in placeholders['adj']:
channel_tensor = tf.reshape(
tf.sparse_tensor_to_dense(adj_channel, validate_indices=False),
[n, n])
tensor_list.append(channel_tensor)
adj_tensor = tf.stack(tensor_list, axis=2)
opt = OptimizerVAE(preds=model.logits_output,
labels=adj_tensor,
pos_weight=pos_weight,
model=model,
num_nodes=n,
norm=norm)
# Initialize session
sess = tf.Session()
sess.run(tf.global_variables_initializer())
cost_val = []
acc_val = []
# 给定混淆矩阵M，计算查全和查准率。
def get_precision_recall_score_confusion(M):
n = len(M)
model = GCNModelAE(placeholders, num_features, num_nodes, args)
else:
print('Training a Variational Autoencoder')
model = GCNModelVAE(placeholders, num_features, num_nodes, args)
# Optimizer
with tf.name_scope('optimizer'):
if args.autoencoder:
opt = OptimizerAE(preds=model.reconstructions,
labels=tf.reshape(placeholders['adj_orig'], [-1]),
model=model, num_nodes=num_nodes,
learning_rate=args.learning_rate)
else:
opt = OptimizerVAE(preds=model.reconstructions,
labels=tf.reshape(placeholders['adj_orig'], [-1]),
model=model, num_nodes=num_nodes,
learning_rate=args.learning_rate,
lambd=placeholders['lambd'], tolerance=0.1)
def get_next_batch(batch_size, adj, adj_norm):
adj_idx = np.random.randint(adj.shape[0], size=batch_size)
adj_norm_batch = adj_norm[adj_idx, :, :]
adj_norm_batch = np.reshape(adj_norm_batch, [batch_size, num_nodes, num_nodes])
adj_orig_batch = adj[adj_idx, :, :]
adj_orig_batch = np.reshape(adj_orig_batch, [batch_size, num_nodes, num_nodes])
return adj_norm_batch, adj_orig_batch, adj_idx
# Initialize session
session = tf.Session()
if args.debug:
def train_gcn(features, adj_train, args, graph_type):
model_str = args.model
# Store original adjacency matrix (without diagonal entries) for later
adj_orig = adj_train
adj_orig = adj_orig - sp.dia_matrix((adj_orig.diagonal()[np.newaxis, :], [0]), shape=adj_orig.shape)
adj_orig.eliminate_zeros()
adj = adj_train
# Some preprocessing
adj_norm = preprocess_graph(adj)
# Define placeholders
placeholders = {
'features': tf.sparse_placeholder(tf.float64),
'adj': tf.sparse_placeholder(tf.float64),
'adj_orig': tf.sparse_placeholder(tf.float64),
'dropout': tf.placeholder_with_default(0., shape=())
}
num_nodes = adj.shape[0]
features = sparse_to_tuple(features.tocoo())
num_features = features[2][1]
features_nonzero = features[1].shape[0]
# Create model
model = None
if model_str == 'gcn_ae':
model = GCNModelAE(placeholders, num_features, features_nonzero, args.hidden1, args.hidden2)
elif model_str == 'gcn_vae':
model = GCNModelVAE(placeholders, num_features, num_nodes, features_nonzero, args.hidden1, args.hidden2)
# Optimizer
with tf.name_scope('optimizer'):
if model_str == 'gcn_ae':
opt = OptimizerAE(preds=model.reconstructions,
labels=tf.reshape(tf.sparse_tensor_to_dense(placeholders['adj_orig'],
validate_indices=False), [-1]),
pos_weight=1,
norm=1,
lr=args.lr)
elif model_str == 'gcn_vae':
opt = OptimizerVAE(preds=model.reconstructions,
labels=tf.reshape(tf.sparse_tensor_to_dense(placeholders['adj_orig'],
validate_indices=False), [-1]),
model=model, num_nodes=num_nodes,
pos_weight=1,
norm=1,
lr=args.lr)
# Initialize session
sess = tf.Session()
sess.run(tf.global_variables_initializer())
adj_label = adj_train + sp.eye(adj_train.shape[0])
adj_label = sparse_to_tuple(adj_label)
# Train model
# use different epochs for ppi and similarity network
if graph_type == "sequence_similarity":
epochs = args.epochs_simi
else:
epochs = args.epochs_ppi
for epoch in range(epochs):
t = time.time()
# Construct feed dictionary
feed_dict = construct_feed_dict(adj_norm, adj_label, features, placeholders)
feed_dict.update({placeholders['dropout']: args.dropout})
# Run single weight update
outs = sess.run([opt.opt_op, opt.cost], feed_dict=feed_dict)
if epoch % 10 == 0:
print("Epoch:", '%04d' % (epoch+1), "train_loss=", "{:.5f}".format(outs[1]))
print("Optimization Finished!")
#return embedding for each protein
emb = sess.run(model.z_mean,feed_dict=feed_dict)
return emb
# Optimizer
with tf.name_scope('optimizer'):
if model_str == 'gcn_ae':
opt = OptimizerAE(preds=model.reconstructions,
labels=tf.sparse_tensor_to_dense(
placeholders['adj_orig'],
pos_weight=pos_weight,
norm=norm))
elif model_str == 'gcn_vae':
opt = OptimizerVAE(
preds=model.reconstructions,
labels=tf.sparse_tensor_to_dense(placeholders['features']),
model=model,
num_nodes=num_nodes,
pos_weight=pos_weight,
norm=norm,
index_non=tf.constant(features_training_non_zero_index,
dtype='float32'),
count_non=count_training,
index_zero=tf.constant(features_training_zero_index,
dtype='float32'),
count_zero=count_test)
# Initialize session
sess = tf.Session()
sess.run(tf.global_variables_initializer())
adj_label = sp.csr_matrix(features_training)
adj_label = sparse_to_tuple(adj_label)
