ohmnet.py 文件源码

def embed_multilayer(self):
        """Neural embedding of a multilayer network"""

        self.nets = self.relabel_nodes()

        # Return parameter p
        # It controls the likelihood of immediately revisiting a node in the walk

        # In-out parameter q
        # If q > 1: the random walk is biased towards nodes close to node t
        # If q < 1: the random walk is more inclined to visit nodes which
        #           are further away from node t
        all_walks = self.simulate_walks()

        all_nodes = self.get_all_nodes()
        internal_vectors = self.init_internal_vectors(all_nodes)

        tmp_fname = pjoin(self.out_dir, 'tmp.emb')
        total_examples = len(all_walks) * self.n_iter
        pushed_examples = 1000

        for itr in range(self.n_iter):
            # update leaf layers
            self.log.info('Iteration: %d' % itr)

            if itr == 0:
                self.model = Word2Vec(
                    sentences=all_walks, size=self.dimension,
                    window=self.window_size, min_count=0, sg=1,
                    workers=self.n_workers, iter=1, batch_words=pushed_examples)
            else:
                self.model.current_iteration = itr
                self.model.load_parent_word2vec_format(fname=tmp_fname)
                delta = (self.model.alpha - self.model.min_alpha) *\
                        pushed_examples / total_examples
                next_alpha = self.model.alpha - delta
                next_alpha = max(self.model.min_alpha, next_alpha)
                self.model.alpha = next_alpha
                self.log.info('Next alpha = %8.6f' % self.model.alpha)

                self.model.train(all_walks)

            leaf_vectors = self.get_leaf_vectors(self.model)
            internal_vectors = self.update_internal_vectors(
                all_nodes, leaf_vectors, internal_vectors)
            self.save_parent_word2vec_format(
                all_nodes, internal_vectors, tmp_fname)

        self.log.info('Done!')

        fname = pjoin(self.out_dir, 'leaf_vectors.emb')
        self.log.info('Saving leaf vectors: %s' % fname)
        self.model.save_word2vec_format(fname)

        fname = pjoin(self.out_dir, 'internal_vectors.emb')
        self.log.info('Saving internal vectors: %s' % fname)
        self.save_internal_word2vec_format(
            all_nodes, internal_vectors, fname)
        return self.model