def __preprocess(self):
self.__graph = Graph.Read_GML(self.__graph_path)
self.__vcount = self.__graph.vcount()
self.__ecount = self.__graph.ecount()
if self.__return_vnge:
self.__von_Neumann_entropy = von_Neumann_entropy(self.__graph)
tik = time.time()
self.__one_dimensional_structural_entropy = one_dimensional_structural_entropy(self.__graph)
tok = time.time()
self.__time_structural_information = tok - tik
tik = time.time()
self.__approx_entropy_by_finger_hat = finger_hat_entropy(self.__graph)
tok = time.time()
self.__time_finger_hat = tok - tik
tik = time.time()
self.__approx_entropy_by_finger_tilde = finger_tilde_entropy(self.__graph)
tok = time.time()
self.__time_finger_tilde = tok - tik
entropy_by_slaq = np.zeros(10)
tik = time.time()
for i in range(10):
entropy_by_slaq[i] = slaq.vnge(self.__graph)
tok = time.time()
self.__time_slaq = (tok - tik) / 10
self.__approx_entropy_by_slaq = entropy_by_slaq.mean()
def read_gml(path):
g = Graph.Read_GML(path)
adj = g.get_adjacency()
n = adj.shape[0]
a = np.array([adj[i] for i in range(n)])
return a
def import_graph(graph_loc):
if isinstance(graph_loc, Graph):
return graph_loc
extension = graph_loc.split('.')[-1]
if extension == 'edgelist':
return Graph.Read_Edgelist(graph_loc)
elif extension == 'gml':
return Graph.Read_GML(graph_loc)
def read_gml(filename): g = Graph.Read_GML(filename) edgelist = g.get_edgelist() data = np.zeros((len(edgelist), 2), dtype=np.int) for i, edge in enumerate(edgelist): data[i, 0] = edge[0] data[i, 1] = edge[1] return data
def import_graph(folder, ego):
home = os.path.expanduser('~')
if not os.path.isfile('%s/GALLERY/%s/%s/Graphs/friends.gml' %
(home, folder, ego)):
return Graph.Formula('')
graph = Graph.Read_GML('%s/GALLERY/%s/%s/Graphs/friends.gml' %
(home, folder, ego))
graph['folder'] = folder
graph['ego'] = ego
return graph
def __preprocess(self):
self.__graph = Graph.Read_GML(self.__graph_path)
self.__ecount = self.__graph.ecount()
self.__vcount = self.__graph.vcount()
self.__sorted_degree_sequence = list(range(self.__vcount))
self.__von_Neumann_entropy = von_Neumann_entropy(self.__graph)
if self.__method == 'greedy':
self.__sorted_degree_sequence.sort(
key=lambda x: self.__graph.degree(x))
for deg in self.__graph.vs.degree():
self.__sum_dlogd += self.__xlogx(deg)
self.__structural_information = log(
2 * self.__ecount, 2) - self.__sum_dlogd / (2 * self.__ecount)
def __generate_anomalous_graph(self, idx):
anomalous_graph = Graph.Read_GML(
f'datasets/synthetic/anomaly-BA-{idx}.gml')
N = anomalous_graph.vcount()
anomalous_source = np.random.choice(N)
possible_targets = [
i for i in range(N)
if not anomalous_graph.are_connected(i, anomalous_source)
]
anomalous_targets = np.random.choice(possible_targets,
self.__ddos_param)
new_edges = [(anomalous_source, t) for t in anomalous_targets]
anomalous_graph.add_edges(new_edges)
return anomalous_graph
def run(self):
self.__start()
for w in self.__weight_range:
g = Graph.Read_GML(self.__graph_path)
g.es['weight'] = 1.0
for e in g.get_edgelist():
g[e[0], e[1]] = np.random.uniform(1, w)
laplacian = np.asarray(g.laplacian(weights='weight'))
structural_information = self.__compute_structural_information(
laplacian)
von_Neumann_entropy = self.__compute_von_Neumann_entropy(laplacian)
entropy_gap = structural_information - von_Neumann_entropy
logger.info(
f'structural information: ({structural_information:8.7f}), von Neumann entropy: ({von_Neumann_entropy:8.7f}), entropy gap: ({entropy_gap:8.7f})'
)
self.__quit()
def all_shortest_paths_and_LCS(self, lcs_pref_value="shortest_path"):
nx.write_gml(self.G.graph, "data/temp_graph.gml")
ig = Graph.Read_GML("data/temp_graph.gml")
dist = np.array(ig.shortest_paths())
self._dist_top_down = dist
concept_pos = [self.G.get_position(key) for key in self.G._concepts]
sim_m = dist[:, concept_pos]
s = sim_m.shape
if lcs_pref_value != "shortest_path":
return self.sim_leastCommonSubsummer(sim_m, lcs_pref_value)
l = s[1]
M = np.zeros((l, l))
LCS = np.zeros((l, l))
for i in range(l):
M_i_j = sim_m + sim_m[:, i][np.newaxis].T
arg_min_j = np.argmin(M_i_j, axis=0)
M[i, :] = M_i_j[arg_min_j, np.arange(l)]
LCS[i, :] = arg_min_j
self._SIM = M
self._LCS = LCS
print("done calculation all shortest distance")
return M, LCS,
def import_graph(self, graph_loc):
extension = graph_loc.split('.')[-1]
if extension == 'edgelist':
return Graph.Read_Edgelist(graph_loc)
elif extension == 'gml':
return Graph.Read_GML(graph_loc)
elif extension == 'graphml':
return Graph.Read(graph_loc)
elif extension == 'dl':
with open(graph_loc, 'r') as to_read:
data_reached = False
edge_list = []
for line in to_read:
if data_reached:
edge = line.split(' ')[0:2]
if edge in edge_list or [edge[1], edge[0]
] in edge_list:
continue
edge_list.append(edge)
elif line == 'data:\n':
data_reached = True
return Graph.TupleList(edge_list, directed=False)
def __init__(self,
fname,
g_fname,
config,
interaction=list(),
debug=False):
''' g_fname : string -- filename of input graph in GML
config : list of tuples -- node to qbit mapping
interaction : list of tuples -- qbit pairs
steps : maximum number of steps for mapping '''
self.fname = fname
self.g = Graph.Read_GML(g_fname)
self.config = config
self.interaction = interaction
self.gate_count = len(interaction)
self.steps = -1
self.qbits = []
# update graph with qbit positions based on config
for (node, qbit) in config:
v = self.g.vs.find(node)
v['qbit'] = qbit
self.qbits.append(qbit)
self.debug = debug
mapa.drawcountries(linewidth = 1.2, zorder = 2) # desenha linhas dos estados mapa.drawstates(linewidth = 0.5, zorder = 2) # cor dos continentes mapa.fillcontinents(color = '#c0f772', zorder = 1) # cor do oceano mapa.drawmapboundary(fill_color = '#49c4d1', zorder = 0) # divisoes do grid a = 68 # numero de divisoes na latitude b = 82 # numero de divisoes na longitude # abre o grafo rd = os.path.dirname(os.path.dirname(os.getcwd())) rd = rd + '/Resultados e Dados/Australia' grafo = gr.Read_GML(rd + '/LatLong05/grafosMes/grafo47_Nov-2006.gml') # lista com longitudes dos vertices longs = grafo.vs['longitude'] # lista com latitudes dos vertices lats = grafo.vs['latitude'] # lista com dados dos vertices dados = grafo.degree() del grafo # transforma lista de dados em uma matriz dados = np.array(dados) dados = dados.reshape(a, b)
max_partitions = None
while times:
temp_partitions = master.GRAPH_SETTINGS['detection_func'](graph, **master.GRAPH_SETTINGS['func_args'])
modularity = temp_partitions.modularity
if max_modularity < modularity:
max_modularity = modularity
max_partitions = temp_partitions
times -= 1
return max_partitions
if __name__ == '__main__':
test_graph = Graph.Read_GML(master.GRAPH_SETTINGS['path'])
partitions = choose_partitions(test_graph)
# for part in partitions:
# logger.info(f'{part}')
# test_graph.write_gml('test/before.gml')
# print(test_graph.get_edgelist())
i0 = 1
i1 = 2
#############################################################
#fastadd radomadd mindegreeadd betweenessadd maxdegreeadd
combine = CommunityCombine(graph=test_graph.copy(), partitions=partitions, index0=i0, index1=i1, **master.GRAPH_SETTINGS)
combine.run()
eval = CommunityEvaluation(graph=test_graph.copy(), partitions=partitions, index0=i0, index1=i1, ffname='fastadd',
**master.GRAPH_SETTINGS)
eval.run()
rd = rd + '/Resultados e Dados/Amazonas'
# lista com os nomes dos grafos
f = os.listdir(rd + "/grafosMes")
# ordena os nomes cronologicamente
f = ordenaNomesArquivos(f)
# listas para os dados dos grafos
deg = []
bet = []
clo = []
# obtencao dos dados dos grafos
for arquivo in f:
# abre o grafo mensal
g = Graph.Read_GML(rd + "/grafosMes/" + arquivo)
# obtem as informacoes de todos os vertices
deg.append(g.degree())
bet.append(g.betweenness())
clo.append(g.closeness())
del g
del f
# dados normalizados
# totais
t_deg = total2d(deg)
t_bet = total2d(bet)
t_clo = total2d(clo)
# zscores
in_edges += subgraph.ecount()
print(f"fraction: {in_edges / graph.ecount()}")
print("Degree Distribution: ")
print(graph.degree_distribution())
return parts.modularity
def desc_learners(learners: List[Learner]):
result = list()
for learner in learners:
result.append(
[
[round(val, 4) for val in learner._rows],
[round(val, 4) for val in learner._cols],
]
)
return json.dumps(result)
if __name__ == '__main__':
graph_name = "4_50_1_10_0.9"
test_graph = Graph.Read_GML(f"../data/gaussian/{graph_name}.gml")
desc(test_graph)
# test_graph.name = graph_name
#
# get_edges(test_graph, 1, fast_resistance, 1000, 1000)
from igraph import Graph
from igraph import summary
from igraph import plot, mean
from igraph import *
import plotly.plotly as py
import plotly.graph_objs as go
import plotly
import igraph
karate = Graph.Read_GML("karate.gml")
igraph.plot(karate)
#read edge list from a data file
el = Graph.Read_Ncol('karate.txt', directed=True)
#convert the edgelist to an igraph graph object
g = igraph.Graph.Read_Ncol('karate.txt')
#summary(karate)
#no of vertices
print("No of vertices", karate.vcount())
#no of edges
print("No of edges", karate.ecount())
#plot the graph
igraph.plot(g)
print("Degree of vertices", karate.degree())
print("Mean: ", mean(karate.degree()))
#print("Betweeness: ", karate.edge_betweenness())
#plotly.tools.set_credentials_file(username='******', api_key='yeBweYgKVZKMkFUfS3G2')
init_iter_num = 10000
iter_num = 1000
available_action = 10
edge_sum = 500
one_time_edge_num = 5
graph_names = [
# ('gaussian', '6_50_1_20_0.9'),
# ('gaussian', '11_28_1_5_0.9'),
('real', 'dblp_202'),
# ('lfr', '500_2.5_1.5_0.1_5_40'),
# ('gaussian', '10_50_1_10_0.9'),
# ('gaussian', '4_50_1_10_0.9'),
# ('lfr', '200_2.5_1.5_0.2_5_30')
]
for data_dir, graph_name in graph_names:
graph = Graph.Read_GML(f"data/{data_dir}/{graph_name}.gml")
for i in range(repeat):
copy_graph = graph.copy()
copy_graph.name = f"{graph_name}_{one_time_edge_num}"
runner = AdaptRunner(graph=copy_graph,
iter_num=iter_num,
init_iter_num=init_iter_num,
available_action=available_action,
edge_sum=edge_sum,
mode=13,
one_time_edge_num=one_time_edge_num,
init_with_membership=False)
runner.run()
return math.floor((y - lat_i) * 2)
# diretorio para resultados e dados
rd = os.path.dirname(os.getcwd())
rdAu = rd + '/Resultados e Dados/Australia'
# leitura dos arquivos gml dos grafos da Australia
fAu = os.listdir(rdAu + "/grafosMes") # lista com os nomes dos grafos
fAu = ordenaNomesArquivos(fAu) # ordena os nomes cronologicamente
# pega o primeiro grafo para fazer o teste
arquivo = fAu[0]
# abre o grafo
g = Graph.Read_GML(rdAu + "/LatLong05/grafosMes/" + arquivo)
print(g.summary())
labelsToInclude = []
for y in range(34, 66):
for x in range(14, 64):
labelsToInclude.append(str(x) + ',' + str(y))
verticesToDelete = []
for v in g.vs:
if v['name'] not in labelsToInclude:
verticesToDelete.append(v.index)
# gera as coordenadas das divisoes do grid
y = np.linspace(lat_i, lat_f, num=a)
x = np.linspace(long_i, long_f, num=b)
# transforma as listas de coordenadas em matrizes
xx, yy = np.meshgrid(x, y)
numMapa = 0
# percorre os arquivos
for arquivo in f:
ano = substringEntreChars(arquivo, '-', '.')
mes = substringEntreChars(arquivo, '_', '-')
# abre o grafo
grafo = gr.Read_GML(rd + '/grafosMes/' + arquivo)
# lista com longitudes dos vertices
longs = grafo.vs['longitude']
# lista com latitudes dos vertices
lats = grafo.vs['latitude']
# lista com dados dos vertices
dados_degree = grafo.degree()
dados_betweenness = grafo.betweenness()
dados_closeness = grafo.closeness()
del grafo
# transforma as listas de dados em matrizes
dados_degree = np.array(dados_degree)
dados_degree = dados_degree.reshape(a, b)
# obtencao dos dados da Africa
for arquivo in fAf: # percorre todos os grafos mensais em ordem
# guarda o ano do grafo
A = substringEntreChars(arquivo, '-', '.')
dados['ano'].append(A)
# guarda o mes do grafo
M = substringEntreChars(arquivo, '_', '-')
dados['mes'].append(M) # guarda mes do grafo
# guarda a regiao do grafo
dados['regiao'].append(0) # 0 -> Africa
# abre o grafo
g = Graph.Read_GML(rdAf + "/grafosMes/" + arquivo)
# calculo e armazenamento do grau medio
listaDado = g.degree() # listaDado contem os graus
dado = somaLista(listaDado)/len(listaDado) # dado contem a media
dados['mean_degree'].append(dado)
# calculo e armazenamento da variancia do grau
var = sum((i - dado) ** 2 for i in listaDado) / len(listaDado)
dados['variance_degree'].append(var)
del var
# calculo e armazenamento da betweenness media
listaDado = g.betweenness()
dado = somaLista(listaDado)/len(listaDado)
dados['mean_betweenness'].append(dado)
def __preprocess(self):
for i in range(self.__num_graph):
self.__graph_stream[i] = Graph.Read_GML(
f'datasets/synthetic/anomaly-BA-{i}.gml')
# gera as coordenadas das divisoes do grid
y = np.linspace(lat_i, lat_f, num = a)
x = np.linspace(long_i, long_f, num = b)
# transforma as listas de coordenadas em matrizes
xx, yy = np.meshgrid(x, y)
numMapa = 0
# percorre os arquivos
for arquivo in f:
ano = substringEntreChars(arquivo, '-', '.')
mes = substringEntreChars(arquivo, '_', '-')
# abre o grafo
grafo = gr.Read_GML(rd + '/LatLong05/grafosMes/' + arquivo)
# lista com longitudes dos vertices
longs = grafo.vs['longitude']
# lista com latitudes dos vertices
lats = grafo.vs['latitude']
# lista com dados dos vertices
dados_degree = grafo.degree()
dados_betweenness = grafo.betweenness()
dados_closeness = grafo.closeness()
del grafo
# transforma as listas de dados em matrizes
dados_degree = np.array(dados_degree)
dados_degree = dados_degree.reshape(a, b)
from core.gutil import GUtil
from core.learning.social_learning import SocialLearning
from igraph import Graph
import pickle
from core.learning.social_learning import Learner
def generate_learners(graph, rounds, actions, output_path=None):
gutil = GUtil(graph)
slearning = SocialLearning(gutil, actions, True, None)
slearning.emerge(rounds)
if not output_path: return slearning.learners
else:
file_name = output_path + f"/{graph.name}.learners"
with open(file_name, 'wb') as f:
obj = {'learners': slearning.learners, 'payoff': slearning.payoff}
pickle.dump(obj, f)
return slearning.learners
if __name__ == '__main__':
graph_name = "300_2.5_1.5_0.1_5_50"
graph = Graph.Read_GML("../data/lfr/" + graph_name + ".gml")
graph.name = graph_name
learners = generate_learners(graph, 10000, 5, '../data/learners')
from collections import Counter
print(Counter(learner.action for learner in learners))
mapa.drawcountries(linewidth=1.2, zorder=2) # desenha linhas dos estados mapa.drawstates(linewidth=0.5, zorder=2) # cor dos continentes mapa.fillcontinents(color='#c0f772', zorder=1) # cor do oceano mapa.drawmapboundary(fill_color='#49c4d1', zorder=0) # divisoes do grid a = 68 # numero de divisoes na latitude b = 82 # numero de divisoes na longitude # abre o grafo rd = os.path.dirname(os.path.dirname(os.getcwd())) rd = rd + '/Resultados e Dados/Australia' grafo = gr.Read_GML(rd + '/LatLong05/grafosMes/grafo84_Dez-2009.gml') # lista com longitudes dos vertices longs = grafo.vs['longitude'] # lista com latitudes dos vertices lats = grafo.vs['latitude'] # lista com dados dos vertices dados = grafo.degree() del grafo # transforma lista de dados em uma matriz dados = np.array(dados) dados = dados.reshape(a, b)
def load_unipartite_undirected_gml(file):
graph = Graph.Read_GML(file)
graph = delete_self_edges(graph)
return graph
path = expanduser('~/data/three/%s/statuses.jsons' % ego)
if isfile(path):
f = open(path, 'rb')
else:
gz = path + ".gz"
f = gzip.open(gz, 'rb')
return f
for ego in listdir('%s/data/three/' % home):
if ego[0] != 'a':
continue
print ego
graph = Graph.Read_GML('%s/GALLERY/three/%s/Graphs/friends.gml' %
(home, ego))
if len(graph.vs) == 0:
continue
if not 'name' in graph.vs[0].attribute_names():
continue
if not 'cluster' in graph.vs[0].attribute_names():
continue
cluster_per_alter = {v['name']: int(v['cluster']) for v in graph.vs}
clusters_per_status = {}
nb_per_cluster = [0] * (max([int(v['cluster']) for v in graph.vs]) + 1)
for v in graph.vs:
nb_per_cluster[int(v['cluster'])] += 1
statuses = open_statuses(ego)
for line in statuses:
# obtencao dos dados da Africa
for arquivo in fAf: # percorre todos os grafos mensais em ordem
# guarda o ano do grafo
A = substringEntreChars(arquivo, '-', '.')
dados['ano'].append(A)
# guarda o mes do grafo
M = substringEntreChars(arquivo, '_', '-')
dados['mes'].append(M) # guarda mes do grafo
# guarda a regiao do grafo
dados['regiao'].append(0) # 0 -> Africa
# abre o grafo
g = Graph.Read_GML(rdAf + "/grafosMes/" + arquivo)
# calculo e armazenamento do grau medio
listaDado = g.degree() # listaDado contem os graus
dado = somaLista(listaDado) / len(listaDado) # dado contem a media
dados['mean_degree'].append(dado)
# calculo e armazenamento da variancia do grau
var = sum((i - dado)**2 for i in listaDado) / len(listaDado)
dados['variance_degree'].append(var)
del var
# calculo e armazenamento da betweenness media
listaDado = g.betweenness()
dado = somaLista(listaDado) / len(listaDado)
dados['mean_betweenness'].append(dado)
