def main():
emb = n2v.Node2VecPathSnapEmbGensim()
graphs = [gc.Graph.init_facebook_wosn_2009_snowball_sampled_2000()]
feature_type = ft.FeatureType.DIFF_BIN_WITH_DIM
diff_type = dt.DiffType.DIFFERENCE
num_bins = 10
for graph in graphs:
# base_dir = "/run/user/1002/gvfs/sftp:host=alpha/home/mellers/"
save_info = sl.MemoryAccess(graph=str(graph),
embedding_type=str(emb),
num_iterations=30,
diff_type=diff_type,
use_remote_data=False)
classifier = [ # KNeighborsClassifier(),
# SVC(kernel="linear", probability=True),
# DecisionTreeClassifier(),
# RandomForestClassifier(),
# AdaBoostClassifier(),
# GaussianNB(),
MLPClassifier(max_iter=100000, hidden_layer_sizes=(
100,
100,
))
]
test(save_info=save_info,
graph=graph,
feature_type=feature_type,
num_of_bins=num_bins,
classifier=classifier)
def run_experiments(
graphs: List[gc.Graph],
embeddings: List[abs_emb.Embedding],
diff_types: List[dt.DiffType] = [
dt.DiffType.MOST_SIMILAR_EMBS_DIFF_ONE_INIT_CONTINUE
],
list_num_tr_graphs: List[int] = [10],
list_num_iter: List[int] = [1],
list_num_bins: List[int] = [10],
feature_type: ft.FeatureType = ft.FeatureType.DIFF_BIN_WITH_DIM,
num_test_eval: int = 5,
num_eval_iter: int = 1):
# what to train
embeddings = list(embeddings)
for graph in graphs:
for embedding in embeddings:
# how to train
for num_tr_graphs in list_num_tr_graphs:
num_iterations = max(num_eval_iter, max(list_num_iter))
save_info = sl.MemoryAccess(
graph=str(graph),
embedding_type=str(embedding),
num_iterations=num_iterations,
diff_type=dt.DiffType.
MOST_SIMILAR_EMBS_DIFF_ONE_INIT_CONTINUE)
tested_nodes, training_nodes = pe.train_embedding_per_graph(
graph=graph,
embedding=embedding,
save_info=save_info,
num_of_embeddings=num_iterations,
num_of_training_graphs=num_tr_graphs,
run_experiments_on_embedding=False,
num_of_test_evaluations_per_degree_level=num_test_eval)
for diff_type in diff_types:
save_info.set_diff_type(diff_type)
for num_iter in list_num_iter:
save_info.set_num_iter(num_iter)
for num_bins in list_num_bins:
cf.compute_training_features(
save_info=save_info,
graph=graph,
feature_type=feature_type,
num_of_bins=num_bins,
list_nodes_to_predict=tested_nodes,
nodes_to_train_on=training_nodes,
num_eval_iterations=num_eval_iter)
te.test(save_info=save_info,
graph=graph,
feature_type=feature_type,
num_of_bins=num_bins,
limit_num_training_graphs=num_tr_graphs,
list_nodes_to_predict=tested_nodes,
nodes_to_train_on=training_nodes,
num_eval_iterations=num_eval_iter)
def main():
emb = Line()
graph = gc.Graph.init_karate_club_graph()
save_info = sl.MemoryAccess(graph=str(graph),
embedding_type=str(emb),
num_iterations=1)
emb.train_embedding(graph=graph,
save_info=save_info,
removed_nodes=[],
num_of_embeddings=3)
return
def main():
graph = gc.Graph.init_karate_club_graph()
graph = gc.Graph.init_sampled_aps_pacs052030()
embedding_function = n2v.Node2VecPathSnapEmbGensim()
num_of_bins = 10
num_iterations = 30
# nodes_to_predict = list(graph.nodes)
save_info = sl.MemoryAccess(graph=str(graph),
embedding_type=str(embedding_function),
num_iterations=num_iterations)
for i in range(34):
removed_nodes = [i]
diff = save_info.load_diff_matrix(removed_nodes)
create_feature_from_diff_bins_with_dim(diff=diff,
removed_nodes=removed_nodes,
original_graph=graph,
num_of_bins=num_of_bins,
save_info=save_info,
save=True,
check_for_existing=False)
for j in range(34):
if i != j:
removed_nodes = [i, j]
diff = save_info.load_diff_matrix(removed_nodes)
create_feature_from_diff_bins_with_dim(
diff=diff,
removed_nodes=removed_nodes,
original_graph=graph,
num_of_bins=num_of_bins,
save_info=save_info,
save=True,
check_for_existing=False)
if save:
save_info.save_distance_matrix(removed_nodes, iteration, dm)
return dm
if __name__ == '__main__':
import embeddings.transE as em_transe
from embeddings import node2vec_gensim as em_node2vec
import networkx as nx
graph = nx.karate_club_graph()
embedding_function = em_transe.train_transe_embedding
save_info = sl.MemoryAccess(graph=str(graph),
embedding_type="TransE",
num_iterations=30)
embedding_transe = em_transe.train_transe_embedding_from_networkx(
nx.karate_club_graph(),
save_info=save_info,
removed_nodes=[],
iteration=0)
dm_transe = calc_distances(model=embedding_transe,
graph=graph,
save_info=save_info,
removed_nodes=[],
iteration=0,
save=False)
embedding_node2vec = em_node2vec.train_node2vec_embedding(
func_p(i)
'''
else:
if num_features == 0:
raise ValueError(
"no embeddings found to create training features for")
else:
print(
f"All features are already trained. Number of training features {num_features}"
)
if __name__ == '__main__':
import embeddings.node2vec_felix as n2v
graph = gc.Graph.init_karate_club_graph()
emb = n2v.Node2VecF()
save_info = sl.MemoryAccess(
graph=str(graph),
embedding_type="Node2Vec",
num_iterations=30,
diff_type=dt.DiffType.MOST_SIMILAR_EMBS_DIFF_ONE_INIT_CONTINUE.
set_iter(5))
compute_training_features(save_info=save_info,
graph=graph,
num_of_bins=10,
list_nodes_to_predict=[0],
nodes_to_train_on={0: [1, 2]})
dim: int,
walk_length: int,
num_of_walks_per_node: int,
window_size: int,
emb_description: str = None,
return_embedding: bool = False,
graph: Graph = None):
pass
if __name__ == "__main__":
os.chdir("..")
removed_node = 6
num_of_embeddings = 1
emb = Node2VecPathSnapEmbGensim()
base_graph = Graph.init_karate_club_graph()
graph = base_graph.delete_node(removed_node)
save_info = sl.MemoryAccess(graph=str(graph),
embedding_type="Node2Vec_Test",
num_iterations=num_of_embeddings)
emb.train_embedding(graph=graph,
save_info=save_info,
removed_nodes=[removed_node],
num_of_embeddings=num_of_embeddings)
# res = emb.load_embedding(graph=graph,save_info=save_info,iteration=0)
# print(res)