def learn_embeddings(self):
model = GraphFactorization(d=self.dim,
max_iter=10000,
eta=1 * 10**-4,
regu=1.0,
data_set='ds')
model.learn_embedding(self.graph)
self.embeddings = model.get_embedding()
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 main(data_set_name):
dimensions = 4
input_file = './graph/' + data_set_name + '.tsv'
output_file = './emb/' + data_set_name + '.emb'
# Instatiate the embedding method with hyperparameters
graph_factorization = GraphFactorization(dimensions, 1000, 1 * 10**-4, 1.0)
# Load graph
graph = graph_util.loadGraphFromEdgeListTxt(input_file)
# Learn embedding - accepts a networkx graph or file with edge list
embeddings_array, t = graph_factorization.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)
emb.setArgs(numUpdates=90,
outputPath='temp_emb.embeddings',
representSize=128,
window=10,
numNegSampling=5,
ratio=args.ratio)
emb.process()
emb_matrix = emb.getEmbeddings()
elif model == 'gf':
md = GraphFactorization(d=128,
max_iter=1000,
eta=1 * 10**-4,
regu=1.0,
data_set='sbm')
md.learn_embedding(G)
emb_matrix = md.get_embedding()
elif model == 'node2vec':
gra = node2vec.Graph(G, is_directed=isDirected, p=1, q=1)
gra.preprocess_transition_probs()
walks = gra.simulate_walks(num_walks=10, walk_length=80)
walks = [list(map(str, walk)) for walk in walks]
md = Word2Vec(walks,
size=128,
window=10,
min_count=0,
sg=1,
workers=4,
iter=1)
emb_matrix = np.zeros((1024, 128))