import os
import graphs_drawing
from graph_features import initGraph
currentDirectory = str(os.getcwd())
#examples for drawing roi-graph.txt
graph_file = currentDirectory + r'/../data/roi-graph.txt'
gnx = initGraph.init_graph(draw=False,
file_name=graph_file,
directed=True,
Connected=True)
#the tags needs to be number 0-4
node_to_tag = {}
node_to_classification = {}
for node in gnx.nodes():
if node in ['1', '2', '5']:
node_to_tag[node] = 0
else:
node_to_tag[node] = 3
if node in ['1', '2', '4']:
node_to_classification[node] = 0
else:
node_to_classification[node] = 3
draw_file_name = currentDirectory + r'/roi-graph.html'
graphs_drawing.draw_grah(gnx, draw_file_name, node_to_tag,
node_to_classification)
def calc_fetures_vertices(file_input,
motif_path,
outputDirectory,
directed,
takeConnected,
fetures_list,
return_map=True):
######
# 1 - Degrees
# 2 - betweenes
# 3 - closeness
# 4 - bfs moments
# 5 - flow
# 6 - A.B
# 7 - motif3
# 8 - motif4
# 9 - k-core
# 10 - louvain
# 11 - page_rank
# 12 - hierarchyEnerg
######
########### load graph from file ##########
print(str(datetime.now()) + ' start reload graph')
# [ggt, gnx] = initGraph.init_graph(draw = False);
gnx = initGraph.init_graph(draw=False,
file_name=file_input,
directed=directed,
Connected=takeConnected)
print(str(datetime.now()) + ' finish reload graph')
map_fetures = {}
if ('general' in fetures_list):
try:
map_general = compute_specific_nav(gnx,
outputDirectory,
algo_name='general')
map_fetures[1] = map_general
except:
print('error in general:', sys.exc_info()[0])
print(sys.exc_info()[2])
traceback.print_exc()
if ('betweenness' in fetures_list):
try:
map_betweenness = compute_specific_nav(gnx,
outputDirectory,
algo_name='betweenness')
map_fetures[2] = map_betweenness
except:
print('error in betweeenness:', sys.exc_info()[0])
print(sys.exc_info()[2])
traceback.print_exc()
if ('closeness' in fetures_list):
try:
map_closeness = compute_specific_nav(gnx,
outputDirectory,
algo_name='closeness')
map_fetures[3] = map_closeness
except:
print('error in closeness:', sys.exc_info()[0])
print(sys.exc_info()[2])
traceback.print_exc()
if ('bfsmoments' in fetures_list):
try:
map_bfs = compute_specific_nav(gnx,
outputDirectory,
algo_name='bfsmoments')
map_fetures[4] = map_bfs
except:
print('error in bfsmoments:', sys.exc_info()[0])
print(sys.exc_info()[2])
traceback.print_exc()
if ('flow' in fetures_list):
try:
map_flow = compute_specific_nav(gnx,
outputDirectory,
algo_name='flow')
map_fetures[5] = map_flow
except:
print('error in flow:', sys.exc_info()[0])
print(sys.exc_info()[2])
traceback.print_exc()
if ('ab' in fetures_list):
try:
map_attracttor = compute_specific_nav(gnx,
outputDirectory,
algo_name='ab')
map_fetures[6] = map_attracttor
except:
print('error in attractor basin:', sys.exc_info()[0])
print(sys.exc_info()[2])
traceback.print_exc()
if ('motif3' in fetures_list):
try:
map_motif3 = compute_specific_nav(gnx,
outputDirectory,
algo_name='motifs3',
motif_variations_path=motif_path)
map_fetures[7] = map_motif3
except:
print('error in motif3:', sys.exc_info()[0])
print(sys.exc_info()[2])
traceback.print_exc()
if ('motif4' in fetures_list):
try:
map_motif4 = compute_specific_nav(gnx,
outputDirectory,
algo_name='motifs4',
motif_variations_path=motif_path)
map_fetures[8] = map_motif4
except:
print('error in motif4:', sys.exc_info()[0])
print(sys.exc_info()[2])
traceback.print_exc()
if ('kcore' in fetures_list):
try:
map_kcore = compute_specific_nav(gnx,
outputDirectory,
algo_name='kcore')
map_fetures[9] = map_kcore
except:
print('error in kcore:', sys.exc_info()[0])
print(sys.exc_info()[2])
traceback.print_exc()
if ('louvain' in fetures_list):
try:
map_louvain = compute_specific_nav(gnx,
outputDirectory,
algo_name='louvain')
map_fetures[10] = map_louvain
except:
print('error in louvain:', sys.exc_info()[0])
print(sys.exc_info()[2])
traceback.print_exc()
if ('page_rank' in fetures_list):
try:
map_pageRank = compute_specific_nav(gnx,
outputDirectory,
algo_name='page_rank')
map_fetures[11] = map_pageRank
except:
print('error in page_rank:', sys.exc_info()[0])
print(sys.exc_info()[2])
traceback.print_exc()
if ('fiedler_vector' in fetures_list):
try:
map_fiedlerVector = compute_specific_nav(
gnx, outputDirectory, algo_name='fiedler_vector')
map_fetures[12] = map_fiedlerVector
except:
print('error in fiedler_vector:', sys.exc_info()[0])
print(sys.exc_info()[2])
traceback.print_exc()
if ('hierarchy_energy' in fetures_list):
try:
map_hierarchyEnerg = compute_specific_nav(
gnx, outputDirectory, algo_name='hierarchy_energy')
map_fetures[13] = map_hierarchyEnerg
except:
print('error in hierarchy energy:', sys.exc_info()[0])
print(sys.exc_info()[2])
traceback.print_exc()
if ('eccentricity' in fetures_list):
try:
map_eccentricity = compute_specific_nav(gnx,
outputDirectory,
algo_name='eccentricity')
map_fetures[14] = map_eccentricity
except:
print('error in eccentricity:', sys.exc_info()[0])
print(sys.exc_info()[2])
traceback.print_exc()
if ('load_centrality' in fetures_list):
try:
map_load_centrality = compute_specific_nav(
gnx, outputDirectory, algo_name='load_centrality')
map_fetures[15] = map_load_centrality
except:
print('error in load_centrality:', sys.exc_info()[0])
print(sys.exc_info()[2])
traceback.print_exc()
if ('communicability_centrality' in fetures_list):
try:
map_communicability_centrality = compute_specific_nav(
gnx, outputDirectory, algo_name='communicability_centrality')
map_fetures[16] = map_communicability_centrality
except:
print('error in communicability centrality:', sys.exc_info()[0])
print(sys.exc_info()[2])
traceback.print_exc()
if ('average_neighbor_degree' in fetures_list):
try:
map_average_neighbor_degree = compute_specific_nav(
gnx, outputDirectory, algo_name='average_neighbor_degree')
map_fetures[17] = map_average_neighbor_degree
except:
print('error in average neighbor:', sys.exc_info()[0])
print(sys.exc_info()[2])
traceback.print_exc()
if ('mds' in fetures_list):
try:
file_name = outputDirectory + '/output/mds_nodes.txt'
map_fetures[18] = ReadFeatureFile.fileToMap_vertices(file_name)
except:
print('error in mds:', sys.exc_info()[0])
print(sys.exc_info()[2])
traceback.print_exc()
if (return_map):
return [gnx, map_fetures]
from graph_features.algo_vertices.isomap.compute_isomap import compute_isomap
from graph_features import initGraph
import os
graph_name = 'citeseer'
directed = True
base_path = os.getcwd()
if(directed):
base_path = base_path +'/../../../data/directed/'+graph_name
else:
base_path = base_path + '/../../../data/undirected/' +graph_name
file_input = base_path +'/input/'+graph_name+'.txt'
distance_matrix_file_name = base_path +'/results/'+graph_name+'_full_distance_matrix.txt'
#### load the graph undirected!!!! ######
gnx = initGraph.init_graph(draw=False,file_name = file_input,directed=False,Connected = True)
n_neighbors = 5
dim = 20
embedding_output_file = base_path+'/features/output/mds_nodes.txt'
compute_isomap(gnx, n_neighbors, dim, distance_matrix_file_name, embedding_output_file)
def calc_fetures_edges(file_input,
motif_path,
outputDirectory,
directed,
takeConnected=False,
fetures_list=[],
return_map=True):
print(str(datetime.now()) + ' start reload graph')
# [ggt, gnx] = initGraph.init_graph(draw = False);
gnx = initGraph.init_graph(draw=False,
file_name=file_input,
directed=directed,
Connected=takeConnected)
print(str(datetime.now()) + ' finish reload graph')
map_fetures = {}
new_edge_algo = ['min_cut', 'edge_flow', 'edge_betweenness']
if ('general' in fetures_list):
map_general = compute_specific_eav(gnx,
outputDirectory,
algo_name='general')
map_fetures[1] = map_general
if ('closeness' in fetures_list):
map_closeness = compute_specific_eav(gnx,
outputDirectory,
algo_name='closeness')
map_fetures[2] = map_closeness
if ('bfsmoments' in fetures_list):
map_bfsmoments = compute_specific_eav(gnx,
outputDirectory,
algo_name='bfsmoments')
map_fetures[3] = map_bfsmoments
if ('flow' in fetures_list):
map_flow = compute_specific_eav(gnx, outputDirectory, algo_name='flow')
map_fetures[4] = map_flow
if ('ab' in fetures_list):
map_ab = compute_specific_eav(gnx, outputDirectory, algo_name='ab')
map_fetures[5] = map_ab
if ('kcore' in fetures_list):
map_kcore = compute_specific_eav(gnx,
outputDirectory,
algo_name='kcore')
map_fetures[6] = map_kcore
if ('louvain' in fetures_list):
map_louvain = compute_specific_eav(gnx,
outputDirectory,
algo_name='louvain')
map_fetures[7] = map_louvain
if ('page_rank' in fetures_list):
map_page_rank = compute_specific_eav(gnx,
outputDirectory,
algo_name='page_rank')
map_fetures[8] = map_page_rank
if ('fiedler_vector' in fetures_list):
map_fiedler_vector = compute_specific_eav(gnx,
outputDirectory,
algo_name='fiedler_vector')
map_fetures[9] = map_fiedler_vector
if ('hierarchy_energy' in fetures_list):
map_hierarchy_energy = compute_specific_eav(
gnx, outputDirectory, algo_name='hierarchy_energy')
map_fetures[10] = map_hierarchy_energy
if ('eccentricity' in fetures_list):
map_eccentricity = compute_specific_eav(gnx,
outputDirectory,
algo_name='eccentricity')
map_fetures[11] = map_eccentricity
if ('load_centrality' in fetures_list):
map_load_centrality = compute_specific_eav(gnx,
outputDirectory,
algo_name='load_centrality')
map_fetures[12] = map_load_centrality
if ('communicability_centrality' in fetures_list):
map_communicability_centrality = compute_specific_eav(
gnx, outputDirectory, algo_name='communicability_centrality')
map_fetures[13] = map_communicability_centrality
if ('average_neighbor_degree' in fetures_list):
map_average_neighbor_degree = compute_specific_eav(
gnx, outputDirectory, algo_name='average_neighbor_degree')
map_fetures[14] = map_average_neighbor_degree
if ('edge_flow' in fetures_list):
map_average_neighbor_degree = compute_specific_eav(
gnx, outputDirectory, algo_name='edge_flow')
map_fetures[15] = map_average_neighbor_degree
if ('edge_betweenness' in fetures_list):
map_average_neighbor_degree = compute_specific_eav(
gnx, outputDirectory, algo_name='edge_betweenness')
map_fetures[16] = map_average_neighbor_degree
if ('motif3' in fetures_list):
file_name_edges = outputDirectory + '/output/motifs3_directed_edges.txt'
map_fetures[17] = ReadFeatureFile.fileToMap_edges(file_name_edges)
if ('motif4' in fetures_list):
file_name_edges = outputDirectory + '/output/motifs4_directed_edges.txt'
map_fetures[18] = ReadFeatureFile.fileToMap_edges(file_name_edges)
if ('mds' in fetures_list):
file_name_edges = outputDirectory + '/output/mds_edges.txt'
map_fetures[19] = ReadFeatureFile.fileToMap_edges(file_name_edges)
if (return_map):
return [gnx, map_fetures]
def calc_by_train_size(graph_name, test_sizes, f_output, random_state, load,
deep):
output_result_dir = {}
for test_size in test_sizes:
output_result_dir[
test_size] = './../data/result_social_sign/' + graph_name + '/' + str(
test_size) + '/'
if (not os.path.exists(output_result_dir[test_size])):
os.mkdir(output_result_dir[test_size])
if not load:
wdir = os.getcwd()
file_in = str(
wdir
) + r'/../data/directed/social_sign/' + graph_name + '/input/' + graph_name + '.txt'
classification_result = [graph_name + '-tags']
directory_tags_path = str(
wdir) + r'/../data/directed/social_sign/' + graph_name + '/tags/'
# file_in = str(wdir) + r'/../data/directed/social_sign/epinions/input/epinions.txt'
# classification_wiki_result = ['epinions-tags']
# directory_tags_path = str(wdir) + r'/../data/directed/social_sign/epinions/tags/'
# file_in = str(wdir) + r'/../data/roi-graph.txt'
# classification_wiki_result = ['roi-tags']
# directory_tags_path = str(wdir) + r'/../data/'
print(' start reload graph')
# [ggt, gnx] = initGraph.init_graph(draw = False);
gnx = initGraph.init_graph(draw=False,
file_name=file_in,
directed=True,
Connected=True)
print(' finish reload graph')
calculator = featuresCalculator()
features_list = featuresList.featuresList(True, 'edges').getFeatures()
features_list.remove('flow')
features_list.remove('ab')
features_list.remove('hierarchy_energy')
features_list.remove('edge_flow')
features_list.remove('edge_betweenness')
features_list.remove('motif4')
if (graph_name in ['epinions']):
features_list.remove('kcore')
print(features_list)
# output_dir = str(wdir) + r'/../data/directed/social_sign/epinions/features'
output_dir = str(
wdir
) + r'/../data/directed/social_sign/' + graph_name + '/features'
# output_dir = str(wdir) + r'/../data/'
result = calculator.calculateFeatures(features_list,
file_in,
output_dir,
True,
'edges',
parallel=False)
tagsLoader = TagsLoader(directory_tags_path, classification_result)
tagsLoader.load_edges()
# tags = tagsLoader.calssification_to_edge_to_tag['epinions-tags']
tags = tagsLoader.calssification_to_edge_to_tag[
classification_result[0]]
# tags = tagsLoader.calssification_to_edge_to_tag['roi-tags']
print(tagsLoader.calssification_to_edge_to_tag.keys())
remove_sign_zero(gnx, tags)
edges = gnx.edges()
print(len(edges))
print(len(gnx.nodes()))
print(len(tags))
s_e = set(edges)
s_t = set(tags.keys())
print(s_e.difference(s_t))
print(s_t.difference(s_e))
new_tags = []
for e in edges:
new_tags.append(tags[e])
# random_state = random.randint(0,len(edges))
# random_state = 2
X_train = {}
X_test = {}
Y_train = {}
Y_test = {}
for test_size in test_sizes:
x_train, x_test, y_train, y_test = train_test_split(
edges,
new_tags,
test_size=test_size,
random_state=random_state)
X_train[test_size] = x_train
X_test[test_size] = x_test
Y_train[test_size] = y_train
Y_test[test_size] = y_test
# print X_train
# print X_test
# print result[1]
train_features, test_features = calc_local_sign_features(
gnx, X_train, tags, result[1])
# print train_features
# print test_features
#
for test_size in train_features.keys():
with open(
output_result_dir[test_size] + 'train_features_' +
graph_name + '.dump', 'wb') as f:
pickle.dump(train_features[test_size], f)
with open(
output_result_dir[test_size] + 'test_features_' +
graph_name + '.dump', 'wb') as f:
pickle.dump(test_features[test_size], f)
#
else:
for test_size in test_sizes:
print(output_result_dir[test_size] + '/train_features_' +
graph_name + '.dump')
with open(
output_result_dir[test_size] + '/train_features_' +
graph_name + '.dump', 'rb') as f:
train_features_specific = pickle.load(f)
with open(
output_result_dir[test_size] + '/test_features_' +
graph_name + '.dump', 'rb') as f:
test_features_specific = pickle.load(f)
print(test_size)
print(graph_name)
f_output.writelines(str(test_size) + '\n')
# train_features_specific = train_features[test_size]
# test_features_specific = test_features[test_size]
print('local')
f_output.writelines('local\n')
perform_learning(train_features_specific,
test_features_specific,
f_output,
local=True,
gglobal=False,
deep=deep)
print('global')
f_output.writelines('global\n')
perform_learning(train_features_specific,
test_features_specific,
f_output,
local=False,
gglobal=True,
deep=deep)
print('Both')
f_output.writelines('Both\n')
perform_learning(train_features_specific,
test_features_specific,
f_output,
local=True,
gglobal=True,
deep=deep)
f_output.flush()