def run_train(model, flags_obj, master, is_chief):
utils_context.training = True
batch_size = flags_obj.batch_size // model.batch_size_ratio
if flags_obj.model == 'line' or flags_obj.model == 'randomwalk':
source = euler_ops.sample_node(count=batch_size,
node_type=flags_obj.all_node_type)
else:
source = euler_ops.sample_node(count=batch_size,
node_type=flags_obj.train_node_type)
source.set_shape([batch_size])
# dataset = tf.data.TextLineDataset(flags_obj.id_file)
# dataset = dataset.map(
# lambda id_str: tf.string_to_number(id_str, out_type=tf.int64))
# dataset = dataset.shuffle(buffer_size=20000)
# dataset = dataset.batch(batch_size)
# dataset = dataset.repeat(flags_obj.num_epochs)
# source = dataset.make_one_shot_iterator().get_next()
_, loss, metric_name, metric = model(source)
optimizer_class = optimizers.get(flags_obj.optimizer)
optimizer = optimizer_class(learning_rate=flags_obj.learning_rate)
global_step = tf.train.get_or_create_global_step()
train_op = optimizer.minimize(loss, global_step=global_step)
hooks = []
tensor_to_log = {'step': global_step, 'loss': loss, metric_name: metric}
hooks.append(
tf.train.LoggingTensorHook(tensor_to_log,
every_n_iter=flags_obj.log_steps))
num_steps = int(
(flags_obj.max_id + 1) // batch_size * flags_obj.num_epochs)
hooks.append(tf.train.StopAtStepHook(last_step=num_steps))
if len(flags_obj.worker_hosts) == 0 or flags_obj.task_index == 1:
hooks.append(
tf.train.ProfilerHook(save_secs=180,
output_dir=flags_obj.model_dir))
if len(flags_obj.worker_hosts):
hooks.append(utils_hooks.SyncExitHook(len(flags_obj.worker_hosts)))
if hasattr(model, 'make_session_run_hook'):
hooks.append(model.make_session_run_hook())
with tf.train.MonitoredTrainingSession(master=master,
is_chief=is_chief,
checkpoint_dir=flags_obj.model_dir,
log_step_count_steps=None,
hooks=hooks) as sess:
while not sess.should_stop():
sess.run(train_op)
def run_train(model, flags_obj, master, is_chief):
utils_context.training = True
batch_size = flags_obj.batch_size // model.batch_size_ratio
source = euler_ops.sample_node(count=batch_size,
node_type=flags_obj.train_node_type)
source.set_shape([batch_size])
sim_outputs, cor_outputs = model(source)
_, sim_loss, metric_name, sim_metric = sim_outputs
_, cor_loss, ___________, cor_metric = cor_outputs
loss = sim_loss + cor_loss
optimizer_class = optimizers.get(flags_obj.optimizer)
optimizer = optimizer_class(flags_obj.learning_rate)
global_step = tf.train.get_or_create_global_step()
train_op = optimizer.minimize(loss, global_step=global_step)
hooks = []
tensor_to_log = {
'step': global_step,
'loss': loss,
'sim_loss': sim_loss,
'cor_loss': cor_loss,
'sim_metric': sim_metric,
'cor_metric': cor_metric
}
hooks.append(
tf.train.LoggingTensorHook(tensor_to_log,
every_n_iter=flags_obj.log_steps))
num_steps = int(
(flags_obj.max_id + 1) // flags_obj.batch_size * flags_obj.num_epochs)
hooks.append(tf.train.StopAtStepHook(last_step=num_steps))
extra_param_name = '_'.join(map(str, flags_obj.fanouts))
output_dir = ckpt_dir = '{}/{}/{}_{}_{}/'.format(flags_obj.model_dir,
flags_obj.model,
extra_param_name,
flags_obj.dim,
flags_obj.embedding_dim)
print("output dir: {}".format(output_dir))
if len(flags_obj.worker_hosts) == 0 or flags_obj.task_index == 1:
hooks.append(
tf.train.ProfilerHook(save_secs=180, output_dir=output_dir))
if len(flags_obj.worker_hosts):
hooks.append(utils_hooks.SyncExitHook(len(flags_obj.worker_hosts)))
if hasattr(model, 'make_session_run_hook'):
hooks.append(model.make_session_run_hook())
with tf.train.MonitoredTrainingSession(master=master,
is_chief=is_chief,
checkpoint_dir=ckpt_dir,
log_step_count_steps=None,
hooks=hooks,
config=config) as sess:
while not sess.should_stop():
sess.run(train_op)
def to_sample(self, inputs, view):
path_list = [
euler_ops.random_walk(inputs, pattern, p=1, q=1, default_node=-1)
for pattern in self.path_patterns[view]
]
pair_list = [
euler_ops.gen_pair(path, self.left_win_size, self.right_win_size)
for path in path_list
]
pairs = tf.concat(pair_list, 1) #[batch_size, num_pairs ,2]
num_pairs = pairs.shape[1]
mask = tf.fill(tf.shape(pairs), -1)
mask = tf.cast(mask, tf.int64)
bool_mask = tf.not_equal(pairs, mask)
s0, s1 = tf.split(bool_mask, [1, 1], 2)
bool_indices = tf.logical_and(s0, s1) #[bs, num_pairs, 1]
bool_indices = tf.squeeze(bool_indices, [2]) #[bs, num_pairs]
where_true = tf.where(bool_indices) #[num_true, 2]
res_pairs = tf.gather_nd(pairs, where_true) #[num_true,2]
src, pos = tf.split(res_pairs, [1, 1], axis=-1)
src = tf.reshape(src, [-1, 1])
pos = tf.reshape(pos, [-1, 1])
num_true = tf.size(pos)
self.real_batch_size = num_true
negs = euler_ops.sample_node(num_true * self.num_negs, -1)
negs = tf.reshape(negs, [num_true * self.num_negs])
return src, pos, negs
def to_sample(self, inputs, edge_type):
batch_size = tf.size(inputs)
src = tf.expand_dims(inputs, -1)
pos = euler_ops.sample_neighbor(inputs, edge_type, 1,
self.max_id + 1)[0]
negs = euler_ops.sample_node(batch_size * self.num_negs,
self.node_type)
negs = tf.reshape(negs, [batch_size, self.num_negs])
return src, pos, negs
def sample_negatives(self):
negs = euler_ops.sample_node(self.num_negs, self.node_type)
negs.set_shape([self.num_negs])
return negs