def weight_setup(self, weighting): """ """ if weighting == "overlap": self.weights = overlap_generator(overlap, self.graph) elif weighting == "unit": self.weights = overlap_generator(unit, self.graph) elif weighting == "min_norm": self.weights = overlap_generator(min_norm, self.graph) else: self.weights = overlap_generator(normalized_overlap, self.graph)
def weight_setup(self, weighting): """ Calculating the edge weights. :param weighting: Type of edge weights. """ if weighting == "overlap": self.weights = overlap_generator(overlap, self.graph) elif weighting == "unit": self.weights = overlap_generator(unit, self.graph) elif weighting == "min_norm": self.weights = overlap_generator(min_norm, self.graph) else: self.weights = overlap_generator(normalized_overlap, self.graph)
def build(self): """ Method to create the computational graph. """ self.computation_graph = tf.Graph() with self.computation_graph.as_default(): self.walker_layer = DeepWalker(self.args, self.vocab_size, self.degrees) self.cluster_layer = Clustering(self.args) self.regularizer_layer = Regularization(self.args) self.gamma = tf.placeholder("float") self.loss = self.walker_layer() self.loss = self.loss + self.gamma * self.cluster_layer( self.walker_layer) self.loss = self.loss + self.regularizer_layer(self.walker_layer) self.batch = tf.Variable(0) self.step = tf.placeholder("float") self.learning_rate_new = tf.train.polynomial_decay( self.args.initial_learning_rate, self.batch, self.true_step_size, self.args.minimal_learning_rate, self.args.annealing_factor) self.train_op = tf.train.AdamOptimizer( self.learning_rate_new).minimize(self.loss, global_step=self.batch) self.init = tf.global_variables_initializer() self.weights = overlap_generator(self.args, self.graph)
def optimize(self): """ Method to run the optimization and halt it when overfitting started. The output matrices are all saved when optimization has finished. """ self.best_modularity = 0 self.stop_index = 0 with tf.Session(graph=self.computation_graph) as session: self.init.run() self.logs = log_setup(self.args) print("Optimization started.\n") self.build_graph() feed_dict = { self.S_0: overlap_generator(self.G), self.B1: np.array(nx.adjacency_matrix(self.G).todense()), self.B2: modularity_generator(self.G) } for i in tqdm(range(self.args.iteration_number)): start = time.time() H = session.run(self.H, feed_dict=feed_dict) current_modularity = self.update_state(H) end = time.time() log_updater(self.logs, i, end - start, current_modularity) if self.stop_index > self.args.early_stopping: break self.initiate_dump(session, feed_dict)
def __init__(self, args, graph): """ Every model needs the same initialization -- args, graph. We delete the sampler object to save memory. We also build the computation graph up. """ self.args = args self.graph = graph self.targets = overlap_generator(self.args.target_weighting, self.graph) self.weights = overlap_generator(self.args.regularization_weighting, self.graph) self.nodes = self.graph.nodes() self.vocab_size = len(self.nodes) self.true_step_size = ((len(self.weights.keys()) / 2) * args.batch_size * self.args.epochs) self.edges = nx.edges(self.graph) self.build()