def main(data_set_name): dimensions = 1 input_file = './graph/' + data_set_name + '.tsv' output_file = '../data/' + data_set_name + '.emb' # Instatiate the embedding method with hyperparameters lle = LocallyLinearEmbedding(dimensions) # Load graph # graph = graph_util.loadGraphFromEdgeListTxt(input_file) graph = networkx.read_weighted_edgelist(input_file) # Learn embedding - accepts a networkx graph or file with edge list embeddings_array, t = lle.learn_embedding(graph, edge_f=None, is_weighted=True, no_python=True) embeddings = pandas.DataFrame(embeddings_array) embeddings.to_csv(output_file, sep=' ', na_rep=0.1)
def main(args): # Load edgelist G = graph_util.loadGraphFromEdgeListTxt(args.input, directed=args.directed) G = G.to_directed() # Preprocess the graph # G, _ = prep_graph(G) if args.method == 'gf': # GF takes embedding dimension (d), maximum iterations (max_iter), learning rate (eta), # regularization coefficient (regu) as inputs model = GraphFactorization(d=args.dimension, max_iter=args.max_iter, eta=args.eta, regu=args.regu) elif args.method == 'hope': # HOPE takes embedding dimension (d) and decay factor (beta) as inputs model = HOPE(d=args.dimension, beta=args.beta) elif args.method == 'lap': # LE takes embedding dimension (d) as input model = LaplacianEigenmaps(d=args.dimension) elif args.method == 'lle': # LLE takes embedding dimension (d) as input model = LocallyLinearEmbedding(d=args.dimension) elif args.method == 'sdne': encoder_layer_list = ast.literal_eval(args.encoder_list) # SDNE takes embedding dimension (d), seen edge reconstruction weight (beta), first order proximity weight # (alpha), lasso regularization coefficient (nu1), ridge regreesion coefficient (nu2), number of hidden layers # (K), size of each layer (n_units), number of iterations (n_ite), learning rate (xeta), size of batch (n_batch) # location of modelfile and weightfile save (modelfile and weightfile) as inputs model = SDNE(d=args.dimension, beta=args.beta, alpha=args.alpha, nu1=args.nu1, nu2=args.nu2, K=len(encoder_layer_list), n_units=encoder_layer_list, n_iter=args.max_iter, xeta=args.learning_rate, n_batch=args.bs) # , modelfile=['enc_model.json', 'dec_model.json'], weightfile=['enc_weights.hdf5', 'dec_weights.hdf5']) else: raise ValueError('The requested method does not exist!') # Learn the node embeddings Y, t = model.learn_embedding(graph=G, edge_f=None, is_weighted=args.weighted, no_python=True) Z = np.real_if_close(Y, tol=1000) # Save the node embeddings to a file np.savetxt(args.output, Z, delimiter=',', fmt='%f')
def __init__(self, dim=4, models=[]): # Initialize set of possible models # see "Graph Embedding Techniques, Applications, and Performance: A Survey" by # Goyal and Ferrera (2017) for a taxonomy of graph embedding methods if not models: # if no models specified, create some default ones # Presently all methods are "factorization based methods" # first method very expensive, unless C++ version installed # models.append(GraphFactorization(d=2, max_iter=100000, eta=1*10**-4, regu=1.0)) models.append(HOPE(d=dim, beta=0.01)) models.append(LaplacianEigenmaps(d=dim)) models.append(LocallyLinearEmbedding(d=dim)) # The following "random walk based" and "deep learning based" methods will be enabled in the future # models.append(node2vec(d=2, max_iter=1, walk_len=80, num_walks=10, con_size=10, ret_p=1, inout_p=1)) # models.append(SDNE(d=2, beta=5, alpha=1e-5, nu1=1e-6, nu2=1e-6, K=3,n_units=[50, 15,], rho=0.3, n_iter=50, xeta=0.01,n_batch=500, # modelfile=['./intermediate/enc_model.json', './intermediate/dec_model.json'], # weightfile=['./intermediate/enc_weights.hdf5', './intermediate/dec_weights.hdf5'])) self.models = models
def _get_embeddings(self, embedding_space): # You can comment out the methods you don't want to run models = list() for embed_method in self.embeddings: ## if embed_method == EMEDDINGS.GRAPH_FACTORIZATIONE_MBEDDINGS: ## models.append(GraphFactorization(embedding_space, 100000, 1 * 10 ** -4, 1.0)) if embed_method == EMEDDINGS.LAPLACIAN_EIGENMAPS_EMBEDDINGS: models.append(LaplacianEigenmaps(embedding_space)) if embed_method == EMEDDINGS.LOCALLY_LINEAR_EMBEDDING: models.append(LocallyLinearEmbedding(embedding_space)) if embed_method == EMEDDINGS.HOPE_EMBEDDING: models.append(HOPE(2 + 1, 0.01)) if embed_method == EMEDDINGS.NODE2VEC_EMBEDDING_EMBEDDINGS: models.append(node2vec(2, 1, 80, 10, 10, 1, 1)) # Embeddings I was unable to get working yet - it seems that HOPE converts k to k+1 for some reason.... # if embed_method == EMEDDINGS.SDNE_EMBEDDING_EMBEDDINGS: # models.append(SDNE(d=2, beta=5, alpha=1e-5, nu1=1e-6, nu2=1e-6, K=3,n_units=[50, 15,], rho=0.3, n_iter=50, xeta=0.01,n_batch=500, # modelfile=[base_path + '/intermediate/enc_model.json', base_path + '/intermediate/dec_model.json'], # weightfile=[base_path + '/intermediate/enc_weights.hdf5', base_path + '/intermediate/dec_weights.hdf5'])) return models
def locallyLinearEmbedding(netData, **kwargs): d = kwargs.get('d', 2) from gem.embedding.lle import LocallyLinearEmbedding emb = LocallyLinearEmbedding(d=d) return attMethods.GEMexport(netData, emb)