| 79 | |
| 80 | |
| 81 | class SDNE(object): |
| 82 | def __init__(self, graph, hidden_size=[32, 16], alpha=1e-6, beta=5., nu1=1e-5, nu2=1e-4, ): |
| 83 | |
| 84 | self.graph = graph |
| 85 | # self.g.remove_edges_from(self.g.selfloop_edges()) |
| 86 | self.idx2node, self.node2idx = preprocess_nxgraph(self.graph) |
| 87 | |
| 88 | self.node_size = self.graph.number_of_nodes() |
| 89 | self.hidden_size = hidden_size |
| 90 | self.alpha = alpha |
| 91 | self.beta = beta |
| 92 | self.nu1 = nu1 |
| 93 | self.nu2 = nu2 |
| 94 | |
| 95 | self.A, self.L = _create_A_L(self.graph, self.node2idx) # Adj Matrix,L Matrix |
| 96 | self.reset_model() |
| 97 | self._embeddings = {} |
| 98 | |
| 99 | def reset_model(self, opt='adam'): |
| 100 | |
| 101 | self.model, self.emb_model = create_model(self.node_size, hidden_size=self.hidden_size, l1=self.nu1, |
| 102 | l2=self.nu2) |
| 103 | self.model.compile(opt, [l_2nd(self.beta), l_1st(self.alpha)]) |
| 104 | self.get_embeddings() |
| 105 | |
| 106 | def train(self, batch_size=1024, epochs=1, initial_epoch=0, verbose=1): |
| 107 | adjacency = self.A.toarray().astype(np.float32) |
| 108 | laplacian = self.L.toarray().astype(np.float32) |
| 109 | if batch_size >= self.node_size: |
| 110 | if batch_size > self.node_size: |
| 111 | print('batch_size({0}) > node_size({1}),set batch_size = {1}'.format( |
| 112 | batch_size, self.node_size)) |
| 113 | batch_size = self.node_size |
| 114 | return self.model.fit( |
| 115 | adjacency, |
| 116 | [adjacency, laplacian], |
| 117 | batch_size=batch_size, |
| 118 | epochs=epochs, |
| 119 | initial_epoch=initial_epoch, |
| 120 | verbose=verbose, |
| 121 | shuffle=False, |
| 122 | ) |
| 123 | else: |
| 124 | steps_per_epoch = (self.node_size - 1) // batch_size + 1 |
| 125 | hist = History() |
| 126 | hist.set_model(self.model) |
| 127 | hist.on_train_begin() |
| 128 | logs = {} |
| 129 | for epoch in range(initial_epoch, epochs): |
| 130 | start_time = time.time() |
| 131 | losses = np.zeros(3) |
| 132 | for i in range(steps_per_epoch): |
| 133 | index = np.arange( |
| 134 | i * batch_size, min((i + 1) * batch_size, self.node_size)) |
| 135 | A_train = adjacency[index, :] |
| 136 | L_mat_train = laplacian[index][:, index] |
| 137 | batch_losses = np.asarray(self.model.train_on_batch(A_train, [A_train, L_mat_train])) |
| 138 | losses += batch_losses |