def _generate(self):
if self.ALWAYS_SAME:
np.random.seed(1) # to make all random values same
# skills of every person: every person has a list of s elements describing his/her skill values fall in [0-1].
if self.DISTRIBUTION == 'Uniform':
self.skills = np.random.rand(self.n, self.s)
elif self.DISTRIBUTION == 'Normal':
self.skills = np.random.randn(self.n, self.s) * 0.1666 + 0.5
else:
raise ValueError('ERROR in DISTRIBUTION value: ' % self.DISTRIBUTION)
# risk taking of every person: it is also a value between [0,1].
if self.DISTRIBUTION == 'Uniform':
self.risk_takings = np.random.rand(self.n)
elif self.DISTRIBUTION == 'Normal':
self.risk_takings = np.random.randn(self.n) * 0.1666 + 0.5
# network connectivity (or distance) is a matrix of n*n: we always can for any
# graph, compute the shortest path among all nodes
# and normalize it between [0,1]. We assume, relationships are not directed.
if self.ALWAYS_SAME:
# it keeps the same numbers which is helpful for debugging purposes
G = nx.to_undirected(nx.scale_free_graph(self.n, seed=1))
else:
# it changes the structure every time we run
G = nx.to_undirected(nx.scale_free_graph(self.n))
D = nx.floyd_warshall_numpy(G)
D /= np.max(D)
self.network_connectivity = D
def weighted_DiGraph(n,
seed=1.0,
mode='random',
weights='random',
handle_sinks=False,
pow_exp=1.0,
data_prefix=None):
if mode == 'ER':
G = nx.erdos_renyi_graph(n, p=0.1, directed=True, seed=seed)
elif mode == 'PL':
G = nx.scale_free_graph(n * 10, seed=seed)
G = nx.DiGraph(G)
G.remove_edges_from(G.selfloop_edges())
elif mode == 'BA':
G = nx.barabasi_albert_graph(n, 3, seed=None)
G = nx.DiGraph(G)
elif mode == 'random':
G = nx.scale_free_graph(n)
G = nx.DiGraph(G)
G.remove_edges_from(G.selfloop_edges())
elif data_prefix != None:
edgesTS, _, _ = readRealGraph("%s/%s.txt" % (data_prefix, mode))
G = getGraph(edgesTS)
G = nx.DiGraph(G)
G.remove_edges_from(G.selfloop_edges())
G = nx.DiGraph(getSubgraph(G, n))
else:
raise RuntimeError(
"You must provide 'data_prefix' to load real datasets.")
if handle_sinks:
for i in G.nodes():
if G.out_degree(i) == 0:
for j in G.nodes():
if i != j:
G.add_edge(i, j, weight=1.0)
print(nx.info(G))
if weights == 'random':
#w = np.random.uniform(1e-5, 1.0, G.number_of_edges())
w = 1 - np.random.power(pow_exp, size=G.number_of_edges())
w /= sum(w)
c = 0
for i in G.edges():
G[i[0]][i[1]]['weight'] = w[c]
c += 1
elif weights == 'uniform':
w = 1.0 / G.number_of_edges()
for i in G.edges():
G[i[0]][i[1]]['weight'] = w
else:
nrm = float(sum(G.out_degree(weight='weight').values()))
for i in G.edges(data=True):
G[i[0]][i[1]]['weight'] = i[-1]['weight'] / nrm
return G
def create_scale_free_graph(n):
"""Create an undirected and connected scale free graph with n nodes"""
_Gsf = nx.Graph(nx.scale_free_graph(n).to_undirected())
while not nx.is_connected(_Gsf):
_Gsf = nx.Graph(nx.scale_free_graph(n).to_undirected())
# Copy edges in a new graph and remove [...]
Gsf = _Gsf.copy()
for u, v in _Gsf.edges():
if u == v:
Gsf.remove_edge(u, v)
return Gsf
def generate_scale_free_graph(num_nodes=100,
active_time_percent=1.0,
max_time=3,
weight_distribution=(1.0, 1.0)):
graph = networkx.scale_free_graph(num_nodes)
graph = networkx.DiGraph(graph)
for edge in graph.edges():
if edge[0] != edge[1]:
graph[edge[0]][edge[1]]['weight'] = random.uniform(
weight_distribution[0], weight_distribution[1])
else:
graph[edge[0]][edge[1]]['weight'] = 0.001
source, destination = random.sample(graph.nodes(), 2)
while not networkx.has_path(graph, source, destination):
print source, destination
source, destination = random.sample(graph.nodes(), 2)
existence_for_node_time = {(source, 0): 1, (destination, max_time): 1}
for i in range(1, max_time + 1):
existence_for_node_time[(source, i)] = 0
for i in range(0, max_time):
existence_for_node_time[(destination, i)] = 0
for node in graph.nodes():
for i in range(0, max_time + 1):
if node != source and node != destination:
is_active = int(random.random() < active_time_percent)
existence_for_node_time[(node, i)] = is_active
print len(graph.edges())
return graph, existence_for_node_time, (source, destination)
def main(nodes=30):
# Model parameters
directory = 'test'
globalSharedParameters = {}
globalSharedParameters['infection_rate'] = 0.3
globalSharedParameters['inf_dur'] = "self.r.gauss(7, 2)"
# Output Parameters
statesToMonitor = [INFECTED, SUSCEPTIBLE, RECOVERED]
colours = ["r", "--g", ":k"]
mapping = {SUSCEPTIBLE: "w", INFECTED: "r", RECOVERED: "0.4"}
labels = ["Infected", "Susceptible", "Recovered"]
name = "SIR_scale_free"
titlePlot = "Simulation on scale free graph, %i trials, %i%% infection prob" \
% (TRIALS, 100 * globalSharedParameters['infection_rate'])
titleVisual = ""
# Network
G = nx.scale_free_graph(nodes)
states = [SUSCEPTIBLE for n in G.nodes()]
# run simulation
simulation = NetworkSimulation(G, states, agentClass, directory,
MAX_SIMULATION_TIME, TRIALS,
environmentAgent, **globalSharedParameters)
simulation.runSimulation()
# run visualisation
gif = AnimationCreator(directory, name, titleVisual, mapping)
gif.create_gif()
# plot results
p = PlotCreator(directory, name, titlePlot, statesToMonitor, colours,
labels)
p.plotSimulation()
def __init__(self, seed, link_type = "equal", datac = 0, n=100, h=10, namespace = None): Topo.__init__(self) G=nx.Graph() G=nx.scale_free_graph(n=n, seed=int(seed)) self.topify(G, h, link_type, namespace) if datac > 0: self.add_datacenter(n, h, datac)
def generateScaleFreeNetworks(n):
'''
Generate scale-free networks with n number of nodes
'''
G_scaleFree = nx.scale_free_graph(
n, seed=30
) # scale free graph with default probabilities (alpha=0.41, beta=0.54, gamma=0.05, delta_in=0.2, delta_out=0, create_using=None,)
np.random.seed(0)
def setDecimals(x):
decimal.getcontext().prec = 10 # 10 decimal points enough
return decimal.Decimal(0) + decimal.Decimal(x)
# this should include both boundaries as float gets close enough to 1 to make decimal round
edges = list(set(G_scaleFree.edges()))
scalefree_network = pd.DataFrame(edges,
columns=["userID1", "userID0"],
dtype=str)
scalefree_network = scalefree_network[
scalefree_network["userID0"] != scalefree_network["userID1"]]
for action in relationshipTypes:
scalefree_network[action] = np.random.uniform(
0, 1, scalefree_network.shape[0])
scalefree_network[action] = scalefree_network[action].apply(
lambda x: setDecimals(x)).astype(float)
scalefree_inflnetwork = scalefree_network[
scalefree_network.iloc[:, 2:].sum(axis=1) > 0]
return scalefree_inflnetwork
def generate_graph_sf(N):
'''
Generates a scale-free network. See networkx documentation on
the parameters, etc.
'''
alpha = 0.01
beta = 0.5
gamma = 0.49
G = nx.scale_free_graph(N, alpha=alpha, beta=beta, gamma=gamma)
j = nx.node_link_data(G)
nodes = j['nodes']
links = j['links']
node_names = [{"name": 'n%s' % x['id'], "infected": False} for x in nodes]
final_links = []
seen_links = set()
for link in links:
if link['source'] != link['target']: # ignore self-links
pairing = (link['source'], link['target'])
if not pairing in seen_links:
d = {
'source': 'n%s' % link['source'],
'target': 'n%s' % link['target'],
}
final_links.append(d)
seen_links.add(pairing)
seen_links.add(pairing[::-1])
return node_names, final_links, None
def run_scalefree(alpha=0.60,
beta=0.35,
gamma=0.05,
delta_in=0.2,
delta_out=0,
nodes=1000,
iterations=1000,
epsilon_control=0.1,
epsilon_damage=0.001,
random_load=True):
"""
Run on a scale-free graph. Returns (uncontrolled, controlled, df, costs).
If random_load is True, load is distributed randomly initially.
"""
# Generate graph and set up parameters
nodes = int(nodes)
iterations = int(iterations)
G = nx.scale_free_graph(nodes, alpha, beta, gamma, delta_in, delta_out)
G = G.to_undirected() # scale_free_graph() creates a digraph
# Maximum capacity is a node's degree
degrees = nx.degree(G)
C = np.array([degrees[i] for i in G.nodes()])
if random_load:
p = None
else:
p = {0: 0.52998, 1: 0.35651, 2: 0.11351}
G, L0 = sandpile.initialize_loads(G, p=p, C=C)
return do_run(G, L0, C, iterations, epsilon_control, epsilon_damage)
def generate_network(self, filename: str) -> None:
"""Generates a graph and saves its edgelist into a DataFrame.
Parameters
----------
filename: str
Name of the network
"""
n_nodes = self._n_entities
graph = nx.scale_free_graph(n_nodes)
# Add self-edges with random self activation weights
for node in graph.nodes():
graph.add_edge(node, node, weight=2 * np.random.random() - 1)
edgelist = [e for e in graph.edges.data()]
network_df = pd.DataFrame(columns=["Source", "Dest", "Indicator"])
# Positive or negative influence between genes
act_fn = lambda x: "-" if x < 0 else "+"
for edge in edgelist:
source, dest, weight_dict = edge
source_name = self._entity_names[source]
dest_name = self._entity_names[dest]
weight = weight_dict.get('weight', 2 * np.random.random() - 1)
data_to_append = {
"Source": source_name,
"Dest": dest_name,
"Indicator": act_fn(weight)
}
network_df = network_df.append(data_to_append, ignore_index=True)
# Save network file
logger.info("Saving network to file {}".format(filename))
network_df.to_csv(filename, sep='\t', index=False, header=False)
def testDegreeComp():
EC = MetabolicNetworkX()
EC.load_from_file('ecoli.txt')
ST = MetabolicNetworkX()
ST.loadXML('MODEL1507180063_url.xml') # Streptococcus thermophilus
ST.remove_disconnected()
SF = MetabolicNetworkX()
SF.mnetwork = nx.scale_free_graph(EC.mnetwork.number_of_nodes(), seed=2424)
R = MetabolicNetworkX()
R.mnetwork = nx.gnp_random_graph(EC.mnetwork.number_of_nodes(),
0.5,
seed=2424) # Erdös–Rényi (ER) model
print(
'Comparing Theoretical Scale free and Random Networks with Real Biological Data'
)
print('Mean Degree')
print(' E.coli: ', EC.mean_degree(), '\n', 'S.thermophilus: ',
ST.mean_degree(), '\n', 'Theoretical Scale Free:', SF.mean_degree(),
'\n', 'Theoretical Random:', R.mean_degree())
make_probdegree_plot(EC, 'Ecoli')
make_probdegree_plot(ST, 'Stermo', 'r')
make_probdegree_plot(SF, 'Theoretical Scale Free', 'b')
make_probdegree_plot(R, 'Theoretical Random', 'm')
def get_sample(metrictype):
g = nx.scale_free_graph(V).to_undirected()
# random weight allocations
g = get_weightsalloc(g)
## node rank on the basis of egr/weighted spectrum
if metrictype == 'egr':
ranks = self.get_egrnoderank(g)
elif metrictype == 'weightedspectrum':
ranks = self.get_wghtspectnoderank(g)
# ranks = np.array([2 if ind >= int(0.75*V) else 1 if (ind > int(0.25*V)) and (ind < int(0.75*V)) else 0 for ind in temp_ranks])
ranks = (ranks - min(ranks)) / (max(ranks) - min(ranks))
# ranks = np.array([1/(1+np.exp(-1*ind)) for ind in temp_ranks])
# input node feature with degree
degfeat = (np.sum(nx.adj_matrix(g).todense(), axis=1))
x = np.reshape(np.arange(V), (V, 1))
Idenfeat = enc.fit_transform(x).toarray()
feat = np.concatenate((Idenfeat, degfeat), axis=1)
# return temp_input, ranks, feat, g
return ranks, feat, g
def main():
G = nx.complete_graph(10)
#完全グラフ
G2 = nx.barbell_graph(10, 10)
#ようわからん
G3 = nx.watts_strogatz_graph(100, 15, 0.1)
#small world graph
#watts_strogatz_graph(n,k,p) n: number of node, k:nearest neoghbors,
G4 = nx.complete_bipartite_graph(3, 3)
#完全二部グラフ
G5 = nx.scale_free_graph(50)
G6 = nx.newman_watts_strogatz_graph(100, 10, 0.05)
G7 = nx.binomial_graph(10, 0.2)
# z=[int(random.gammavariate(alpha=9.0,beta=2.0)) for i in range(6)]
# G8 = nx.configuration_model(z)
# aseq = [1,2,1]
# bseq = [2,1,1]
# G8 = nx.configuration_model(aseq,bseq)
G8 = bp.random_graph(5, 5, 0.5)
pos = nx.spring_layout(G6)
# pos = nx.circular_layout(G5)
plt.axis('off')
nx.draw(G6, pos, with_labels=False)
plt.show()
def scale_free_network(n_nodes):
"""
returns the adjagency matrix of a scale free network
the network is undirected and weighted
"""
m = np.zeros((n_nodes, n_nodes))
G = nx.scale_free_graph(n_nodes) # ritorna diretto
G = nx.to_undirected(G)
A = nx.adjacency_matrix(G)
rows = A.nonzero()[0]
columns = A.nonzero()[1]
print(rows.shape, columns.shape)
for i in range(rows.shape[0]):
l, k = rows[i], columns[i]
r = np.random.uniform(0, 1)
m[l, k] = r
m[k, l] = r
return csr_matrix(m)
def semantic_network(n, seed=1):
#G = nx.scale_free_graph(n, alpha=0.05, gamma=0.41, delta_out=0.2, delta_in=0, seed=seed)
G = nx.scale_free_graph(n,seed=seed)
G.remove_edges_from(G.selfloop_edges())
G = nx.DiGraph(G)
return G
def get_system(N, v_in=5, D=1):
assert N >= 3, 'Cannot add FFL'
graph = nx.DiGraph(nx.scale_free_graph(N))
# add FFL
graph.remove_edges_from(itertools.product(range(3), repeat=2))
graph.add_edges_from([(0, 1), (1, 2), (0, 2)])
jacobian = np.asarray(nx.to_numpy_matrix(graph)).T
np.fill_diagonal(jacobian, -1)
external_influence = np.random.randint(0, 2, size=N) * v_in
fluctuation_vector = np.random.randint(0, 2, size=N) * D
initial_state = np.ones(N)
# drive FFL
external_influence[0] = v_in
fluctuation_vector[0] = D
external_influence[[1, 2]] = 0
fluctuation_vector[[1, 2]] = 0
jacobian[0, 0] = -2
jacobian[1, 1] = -2
jacobian[2, 1] = 2
# generate final system
system = SDESystem(jacobian, fluctuation_vector, external_influence,
initial_state)
#system.save('cache/embedded_system.pkl')
return system
def main():
output_dir = os.path.join("datasets", "synthetic_scale_free")
if not os.path.exists(output_dir):
os.makedirs(output_dir, exist_ok=True)
N = 1000
for seed in range(30):
d = os.path.join(output_dir, "{:02d}".format(seed))
if not os.path.exists(d):
os.makedirs(d, exist_ok=True)
g = nx.DiGraph(nx.scale_free_graph(N, seed=seed))
print("seed", seed, "number of nodes", len(g), "number of edges",
len(g.edges))
nx.set_edge_attributes(g, name="weight", values=1.)
nx.write_edgelist(g,
os.path.join(d, "edgelist.tsv.gz"),
delimiter="\t",
data=["weight"])
A = nx.adjacency_matrix(g, nodelist=sorted(g))
save_npz(os.path.join(d, "graph.npz"), A)
class GraphType:
BALANCED_TREE = ('Balanced tree', _balanced_tree)
BARBELL = ('Barbell', lambda n: nx.barbell_graph(int(n*.4), int(n*.3)))
CIRCULAR_LADDER = ('Circular ladder', lambda n: nx.circular_ladder_graph(int(n/2)))
COMPLETE = ('Complete', lambda n: nx.complete_graph(int(n)))
COMPLETE_BIPARTITE = ('Complete bipartite',
lambda n: nx.complete_bipartite_graph(int(n*.6), int(n*.4)))
CYCLE = ('Cycle', lambda n: nx.cycle_graph(int(n)))
GRID = ('Grid', lambda n: nx.grid_graph([int(np.sqrt(n))]*2))
HYPERCUBE = ('Hypercube', _hypercube)
LADDER = ('Ladder', lambda n: nx.ladder_graph(int(n/2)))
LOBSTER = ('Lobster', lambda n: nx.random_lobster(int(n / (1 + .7 + .7*.5)), .7, .5))
LOLLIPOP = ('Lollipop', lambda n: nx.lollipop_graph(int(n/2), int(n/2)))
PATH = ('Path', lambda n: nx.path_graph(int(n)))
REGULAR = ('Regular', lambda n: nx.random_regular_graph(np.random.randint(10)*2, n))
SCALEFREE = ('Scale-free', lambda n: nx.scale_free_graph(int(n)))
SHELL = ('Shell', lambda n: nx.random_shell_graph([(int(n*.1), int(n*.1), .2),
(int(n*.3), int(n*.3), .8),
(int(n*.6), int(n*.6), .5)]))
STAR = ('Star', lambda n: nx.star_graph(int(n - 1)))
WAXMAN = ('Waxman', lambda n: nx.waxman_graph(int(n)))
WHEEL = ('Wheel', lambda n: nx.wheel_graph(int(n)))
all = (BALANCED_TREE, BARBELL, CIRCULAR_LADDER, COMPLETE, COMPLETE_BIPARTITE,
CYCLE, GRID, HYPERCUBE, LADDER, LOBSTER, LOLLIPOP, PATH, REGULAR,
SCALEFREE, SHELL, STAR, WAXMAN, WHEEL)
def scale_free_graph(n, alpha=0.41, beta=0.54, gamma=0.05,
delta_in=0.2, delta_out=0,
create_using=None, seed=None):
G = nx.scale_free_graph(n, alpha=alpha, beta=beta, gamma=gamma,
delta_in=delta_in, delta_out=delta_out,
create_using=create_using, seed=seed)
return G
def createGraphsAndCommunities():
g = nx.scale_free_graph(500, alpha=0.40, beta=0.40, gamma=0.20)
g1 = nx.powerlaw_cluster_graph(500, 10, 0.2)
g2 = nx.barabasi_albert_graph(500, 10)
g3 = nx.newman_watts_strogatz_graph(500, 10, 0.2)
nx.write_graphml (g, direc+"sfg.graphml")
nx.write_graphml(g1, direc+"pcg.graphml")
nx.write_graphml(g2, direc+"bag.graphml")
nx.write_graphml(g3, direc+"nwsg.graphml")
graphs = {}
graphs["sfg"] = graph_tool.load_graph(direc+"sfg.graphml")
graphs["pcg"] = graph_tool.load_graph(direc+"pcg.graphml")
graphs["bag"] = graph_tool.load_graph(direc+"bag.graphml")
graphs["nwsg"] = graph_tool.load_graph(direc+"nwsg.graphml")
graphs["price"] = graph_tool.generation.price_network(1000)
for i,h in graphs.iteritems():
s = graph_tool.community.minimize_blockmodel_dl(h)
b = s.b
graph_tool.draw.graph_draw(h, vertex_fill_color=b, vertex_shape=b, output=direc+"block"+str(i)+".pdf")
com = graph_tool.community.community_structure(h, 10000, 20)
graph_tool.draw.graph_draw(h, vertex_fill_color=com, vertex_shape=com, output=direc+"community"+str(i)+".pdf")
state = graph_tool.community.minimize_nested_blockmodel_dl(h)
graph_tool.draw.draw_hierarchy(state, output=direc+"nestedblock"+str(i)+".pdf")
pagerank = graph_tool.centrality.pagerank(h)
graph_tool.draw.graph_draw(h, vertex_fill_color=pagerank, vertex_size = graph_tool.draw.prop_to_size(pagerank, mi=5, ma=15), vorder=pagerank, output=direc+"pagerank"+str(i)+".pdf")
h.set_reversed(is_reversed=True)
pagerank = graph_tool.centrality.pagerank(h)
graph_tool.draw.graph_draw(h, vertex_fill_color=pagerank, vertex_size = graph_tool.draw.prop_to_size(pagerank, mi=5, ma=15), vorder=pagerank, output=direc+"reversed_pagerank"+str(i)+".pdf")
def __init__(self, N): self.name = 'Default directed Scale-Free random graph DSF_%i' % N self.N = N self.G = nx.scale_free_graph(N) self.params = dict() self.state = None
def generate_graph_scale_free_structure(
output_gml='data/toy_scale_free_network.gml', ):
num_nodes = 500
g = nx.Graph(nx.scale_free_graph(num_nodes))
modularity_classes = compute_graph_modularity(g=g)
nodes_to_modularity = {}
for n in modularity_classes:
if not nodes_to_modularity.has_key(modularity_classes[n]):
nodes_to_modularity[modularity_classes[n]] = []
nodes_to_modularity[modularity_classes[n]].append(n)
sorted_classes = sorted(nodes_to_modularity.items(),
key=lambda x: len(x[1]),
reverse=True)
# Assign trump or hillary status
count = 0
for c in sorted_classes:
if count % 3 == 1:
l = 0
elif count % 3 == 2:
l = 1
else:
l = 7
attr_dict = dict(zip(c[1], [l for i in range(0, len(c[1]))]))
nx.set_node_attributes(g, 'trumporhillary', attr_dict)
count += 1
# Output gml
nx.write_gml(g, output_gml)
def __init__(self,
seed,
link_type="equal",
servers=0,
n=100,
h=0,
namespace=None):
Topo.__init__(self)
G = nx.Graph()
if not seed:
seed = random.randint(1, 10000)
G = nx.scale_free_graph(n=n, seed=int(seed))
G.remove_edges_from(G.selfloop_edges())
self.topify(G, h, link_type, namespace)
if servers > 0:
self.add_server(h, servers)
self.trim()
print(
"----------- Check cardinality of elements in simulation -----------"
)
print(self.switches())
print(self.hosts())
print(self.links())
def montar(self, tipo, quantidade_nós, taxa_conexão):
if(tipo == "gnp"):
self._g = nx.fast_gnp_random_graph(quantidade_nós, taxa_conexão)
print("G(n,p): qtd_nós = %d e taxa = %f" %(quantidade_nós, taxa_conexão))
else:
self._g = nx.scale_free_graph(quantidade_nós).to_undirected()
print("Livre de Escala: qtd_nós = %d" %(quantidade_nós))
nós = self._g.nodes(data=True)
self._adicionar_tipo(nós[0], True)
for i in range(1, len(nós)):
self._adicionar_tipo(nós[i])
latência_máxima = 1 #conexão entre duas placas geralment é menor que 1ms
transmissão_máxima = 1000 #Mbps
for aresta in self._g.edges(data=True):
latência = np.random.rand() * latência_máxima
transmissão = np.random.rand() * transmissão_máxima
latência_efetiva = latência/(1 - transmissão/transmissão_máxima)
aresta[2]["latência"] = latência
aresta[2]["latência_efetiva"] = latência_efetiva
self.latência_efetiva_média = nx.average_shortest_path_length(self._g, weight="latência_efetiva")
def simulate_network(n_genes, beta, delta, verbose=True):
# makes scale-free networks
t_0 = time.time()
alpha = (1.0 - beta) / 2
gamma = (1.0 - beta) / 2
n_neigh = []
G = nx.scale_free_graph(n_genes,
alpha=alpha,
beta=beta,
gamma=gamma,
delta_in=delta,
delta_out=delta)
if verbose:
print("\tgamma:", 1 + (1.0 + delta * (alpha + gamma)) / (alpha + beta))
# convert to undirected, with no self-loops or duplicated edges
G = G.to_undirected()
G.remove_edges_from(G.selfloop_edges())
G = nx.Graph(G)
# node degree distribution
for n in G.nodes():
n_neigh.append(len(G[n].keys()))
tmp = plt.hist(n_neigh, range=(1, 100), bins=50, density=True)
plt.show()
if verbose:
print_network_stats(G)
print("\tmin and max node degree: %s,%s" %
(max(n_neigh), min(n_neigh)))
print("runtime:", round(time.time() - t_0, 2), "s", file=sys.stderr)
return G
def get_overlay_topology(N, f_name=None):
g = nx.scale_free_graph(N)
g = g.to_undirected()
cg_list = nx.connected_component_subgraphs(g)
if f_name:
save_graph(cg_list[0], f_name)
# zdump(np.asarray(nx.to_numpy_matrix(cg_list[0])), 'overlay_adj.pkz')
return nx.to_scipy_sparse_matrix(cg_list[0])
def get_overlay_topology(N, f_name=None):
g = nx.scale_free_graph(N)
g = g.to_undirected()
cg_list = nx.connected_component_subgraphs(g)
if f_name:
save_graph(cg_list[0], f_name)
# zdump(np.asarray(nx.to_numpy_matrix(cg_list[0])), 'overlay_adj.pkz')
return nx.to_scipy_sparse_matrix(cg_list[0])
def draw_scale_free(n):
G = nx.scale_free_graph(n) # Generate scale free network with n nodes.
A = np.zeros((n, n))
for i in range(n):
for j in range(i, n):
if j in G[i]:
A[i][j] = 1
return A, G
def generate_scale_free(params={'n': 100}):
if 'seed' not in params.keys():
params['seed'] = None
G = nx.scale_free_graph(params['n'])
G = G.to_undirected()
return G, None
def test_read_from_nx(self):
import networkx as nx
gnx = nx.DiGraph(nx.scale_free_graph(1000))
glnx = lightnx.DiGraph()
glnx.add_edges_from(gnx.edges())
assert_equals(set(glnx.edges()), set(gnx.edges()))
assert_equals(set(glnx.successors(786)), set(gnx.successors(786)))
assert_equals(set(glnx.successors(0)), set(gnx.successors(0)))
assert_equals(set(glnx.predecessors(678)), set(gnx.predecessors(678)))
def graph_generator():
import networkx as nx
G = nx.scale_free_graph(
1000, alpha=0.43, beta=0.56, gamma=0.01
) ######## here we make a scale free network which is directed :) please notice : list(G.predecessors(n)) gives us the list of nodes that are following of node n, ie they can cause a change in state of node n and in the graph there is a arrow from them to node n, and list(G.neighbors(n)) gives us the list of nodes that are followers of node n, ie node n can cause a change in state of them and in the graph there is a arrow from node n to them
pos = nx.spring_layout(
G
) #this command makes a layout of position of all nodes (instead of spring_layout you can use fruchterman_reingold_layout or other layouts so you will have different figures for graph) ,since we want to have different color for different states of nodes so we have to first make a layout then in graph draw function we make node by different colores,in fact ( I seperated this command and also above command (G=nx.Graph()) from the function of graph draw for two reasons : 1- seperating pos command causes we have a fixed layout for all graph draw (for example if initial node is located in south west of picture of graph(in graph draw plot)then for any time we plot graph again (for example for different timesteps) then the initial infected node is still in south west of graph plot, so we can see spread of rumor and its expand from south west of graph during different timesteps 2- by seperating graph generator function (G = nx.Graph command) we save time because we perform this command only one time and for any times that we plot graph we would not use this command again, so plots will be made fastly
return G, pos
def scale_free(n, alpha=0.7, beta=0.25,
delta_in=0.2, delta_out=0.2):
g = nx.scale_free_graph(n, alpha=alpha,
beta=beta,
delta_in=delta_in, delta_out=delta_out)
g = nx2graph(g)
g = gtranspose(g)
addAring(g)
return g
def SF(self, n):
return nx.scale_free_graph(n,
alpha=0.01,
beta=0.495,
gamma=0.495,
delta_in=0,
delta_out=0.2,
create_using=None,
seed=None)
def setUp(self):
print("setUp")
tt = test_tools.TestTools(BASE, VERBOSE)
self.g1 = nx.scale_free_graph(10)
cyjs1 = test_tools.TestTools.networkx_to_cyjs(self.g1)
job_id = tt.submit_network_to_service('network_service_1/rt1', cyjs1)
res = tt.get_result(job_id, SLEEP_INTERVAL, 10)
cyjs2 = res.json()
self.g2 = tt.cyjs_to_networkx(cyjs2)
def setUp(self):
print("setUp")
tt = test_tools.TestTools(BASE, VERBOSE)
self.g1 = nx.scale_free_graph(10)
cyjs1 = test_tools.TestTools.networkx_to_cyjs(self.g1)
job_id = tt.submit_network_to_service('network_service_1/rt1', cyjs1)
res = tt.get_result(job_id, SLEEP_INTERVAL, 10)
cyjs2 = res.json()
self.g2 = tt.cyjs_to_networkx( cyjs2 )
class TestEstadoIncubandoSism(unittest.TestCase):
grafo = nx.scale_free_graph(100)
modelo = crear_modelo_SISM(grafo,
tiempo_incubacion=1,
tiempo_inf_mild=0,
tiempo_inf_grave=2,
probabilidad_de_estar_incubando=1,
probabilidad_deceso=1,
probabilidad_riesgo=0,
probabilidad_infecc_grave_riesgo=0,
probabilidad_infecc_grave=1,
probabilidad_deceso_riesgo=0)
nodo = 0
def test_el_estado_se_instancia_correctamente(self):
estado = EstadoInfectadoMildSISM(tiempo_infeccion=5)
self.assertEqual(estado.tiempo_infeccion, 5)
self.assertEqual(estado.__class__.__name__, ESTADO_INFECTADO_MILD)
def test_al_transicionar_el_tiempo_de_infeccion_se_reduce_una_unidad(self):
estado = EstadoInfectadoMildSISM(tiempo_infeccion=5)
self.grafo.nodes[self.nodo]['riesgo'] = False
self.grafo.graph['prob_de_deceso'] = 0
nuevo_estado = estado.transicionar(self.nodo, self.grafo)
self.assertEqual(nuevo_estado.tiempo_infeccion, 4)
def test_al_transicionar_si_el_tiempo_de_infeccion_no_es_cero_el_estado_no_cambia(
self):
estado = EstadoInfectadoMildSISM(tiempo_infeccion=5)
self.grafo.nodes[self.nodo]['riesgo'] = False
self.grafo.graph['prob_de_deceso'] = 0
nuevo_estado = estado.transicionar(self.nodo, self.grafo)
self.assertEqual(nuevo_estado.__class__.__name__,
ESTADO_INFECTADO_MILD)
def test_cuando_el_tiempo_de_infeccion_llega_a_cero_el_estado_pasa_a_susceptible(
self):
estado = EstadoInfectadoMildSISM(tiempo_infeccion=1)
self.grafo.nodes[self.nodo]['riesgo'] = False
self.grafo.graph['prob_de_deceso'] = 0
nuevo_estado = estado.transicionar(self.nodo, self.grafo)
self.assertEqual(nuevo_estado.__class__.__name__, ESTADO_SUSCEPTIBLE)
def ajax_build_graph_view(request, graph_id):
graph = get_object_or_404(Graph, id=graph_id)
size = graph.size
graph_type = graph.graph_type
if graph_type == 'random':
G = nx.gnp_random_graph(size,0.1)
else:
G = nx.scale_free_graph(size)
vega_graph = build_vega_graph(G)
return HttpResponse(vega_graph, mimetype="text/javascript")
def run(self):
# Run simulation for several type of networks, in this case Erdos-Renyi and Random Network
self.networks = [
{
'network': nx.scale_free_graph(n = self.nodes),
'name': 'ScaleFree'
},
{
'network': nx.erdos_renyi_graph(n = self.nodes, p = 0.1), # 0.2, 0.5
'name': 'ErdosRenyi'
},
{
'network': nx.random_regular_graph(n = self.nodes, d = 10),
'name': 'RandomNetwork'
}
]
for network in self.networks:
nxgraph = network['network']
graph = helper.convert_nxgraph_to_dict(nxgraph)
# write network in pajek
filename = 'pajek/'+ network['name'] + '_' + str(self.nodes) + '.net'
nx.write_pajek(nxgraph, filename)
for mu in self.mu_values:
print 'Starting...'
start_time = time.time()
# B beta (at least 51 values, B=0.02)
beta = 0.0
betas = []
averages = []
for i in range(0, 51):
start_time_beta = time.time()
sis_initial_model = sis.SIS(graph, mu, beta, self.p0)
simulation = mc.MonteCarlo(sis_initial_model, self.rep, self.t_max, self.t_trans)
total_average = simulation.run()
total_time_beta = time.time() - start_time_beta
betas.append(beta)
averages.append(total_average)
print 'B: {}, average: {}, time: {}s'.format(beta, total_average, total_time_beta)
beta += 0.02
total_time = time.time() - start_time
print 'total time: {}'.format(total_time)
# plot results and save in file
helper.plot_results(network['name'], self.nodes, mu, betas, averages)
helper.write_results(network['name'], self.nodes, mu, betas, averages)
break
def test_networkx_empty_edge_attribute(self):
print('\n---------- Edge Att Test 2 Start -----------\n')
g = nx.scale_free_graph(5)
cyjs = util.from_networkx(g)
# print(json.dumps(cyjs, indent=4))
# There is only one edge, so this should be OK...
edge = cyjs['elements']['edges'][0]
print(json.dumps(edge, indent=4))
self.assertEqual(3, len(edge['data']))
def make_sf(n = 200,
alpha = .41,
beta = .54,
gamma = .05):
g0 = nx.scale_free_graph(n = n,
alpha = alpha,
beta = beta,
gamma = gamma)
g = nx.DiGraph()
g.add_weighted_edges_from([[e[0],e[1],edge_weight_fun()]
for e in g0.edges()])
return g
def semantic_network(n, seed=1):
#G = nx.scale_free_graph(n, alpha=0.05, gamma=0.41, delta_out=0.2, delta_in=0, seed=seed)
G = nx.scale_free_graph(n,seed=seed)
G.remove_edges_from(G.selfloop_edges())
G = nx.DiGraph(G)
print G
print "Max out: ", max(G.out_degree(G.nodes_iter()).values())
print G.out_degree(G.nodes_iter())
print "Max in: ", max(G.in_degree(G.nodes_iter()).values())
print G.in_degree(G.nodes_iter())
return G
def randomNetwork(nodesNum=5):
"""
:returns: @todo
"""
edge_set=set()
rn=networkx.scale_free_graph(nodesNum)
for (s,t,a) in rn.edges(data=True):
if s==t:
rn.remove_edge(s,t)
continue
if (s,t) not in edge_set:
edge_set.add((s,t))
else:
rn.remove_edge(s,t)
rn2=networkx.DiGraph()
for (s,t) in rn.edges():
rn2.add_edge(str(s), str(t))
return rn2
def main(nodes=30):
# Model parameters
directory = 'test'
globalSharedParameters = {}
globalSharedParameters['infection_rate'] = 0.3
globalSharedParameters['inf_dur'] = "7"
# Network and initial states
G = nx.scale_free_graph(nodes)
states = [SUSCEPTIBLE for n in G.nodes()]
# run simulation
simulation = NetworkSimulation(G,
states,
agentClass,
directory,
MAX_SIMULATION_TIME,
TRIALS,
environmentAgent,
**globalSharedParameters)
simulation.runSimulation()
def main(nodes=30):
# Model parameters
directory = 'test'
globalSharedParameters = {}
globalSharedParameters['infection_rate'] = 0.3
globalSharedParameters['inf_dur'] = "self.r.gauss(7, 2)"
# Output Parameters
statesToMonitor = [INFECTED, SUSCEPTIBLE, RECOVERED]
colours = ["r", "--g", ":k"]
mapping = {SUSCEPTIBLE:"w", INFECTED:"r", RECOVERED:"0.4"}
labels = ["Infected", "Susceptible", "Recovered"]
name = "SIR_scale_free"
titlePlot = "Simulation on scale free graph, %i trials, %i%% infection prob" \
% (TRIALS, 100 * globalSharedParameters['infection_rate'])
titleVisual = ""
# Network
G = nx.scale_free_graph(nodes)
states = [SUSCEPTIBLE for n in G.nodes()]
# run simulation
simulation = NetworkSimulation(G,
states,
agentClass,
directory,
MAX_SIMULATION_TIME,
TRIALS,
environmentAgent,
**globalSharedParameters)
simulation.runSimulation()
# run visualisation
gif = AnimationCreator(directory, name, titleVisual, mapping)
gif.create_gif()
# plot results
p = PlotCreator(directory, name, titlePlot, statesToMonitor,
colours, labels)
p.plotSimulation()
def graphGenerators( n, graphName ) :
if (graphName == "star") :
return make_reflexive (nx.star_graph (n).to_directed ())
elif (graphName == "twostars") :
g = nx.star_graph (n)
h = nx.star_graph (n)
newLabels = { }
for i in range (n + 1) :
newLabels[i] = i + n + 1
h = nx.relabel_nodes (h, newLabels)
gh = nx.union (g, h)
if (g.degree (0) > 1) :
gh.add_edge (1, n + 1)
else :
gh.add_edge (0, n + 1)
gh.add_edge (n + 1, n + 2)
return gh.to_directed ()
elif (graphName == "complete") :
return nx.complete_graph (n).to_directed ()
elif (graphName == "scalefree") :
return nx.scale_free_graph (n)
def gen_sfn(n, num_parts=4, min_edge=1, max_edge=10, alpha=0.5, beta=0.45, gamma=0.05, delta_in=0.2, delta_out=0, create_using=None, seed=None):
G = nx.scale_free_graph(n=n, alpha=alpha, beta=beta, gamma=gamma, delta_in=delta_in, delta_out=delta_out, create_using=create_using, seed=seed)
adjacency = {}
neighbors = {}
for i in range(len(G)):
adjacency[i] = []
nbrs = {}
for j in G.neighbors(i):
adjacency[i].append(j)
nbrs[j] = randint(min_edge, max_edge)
neighbors[i] = nbrs
cuts, part_vert = part_graph(num_parts, adjacency)
nx.set_node_attributes(G, 'neighbors', neighbors)
parts = {}
for i in range(len(part_vert)):
parts[i] = part_vert[i]
nx.set_node_attributes(G, 'part', parts)
return G
def test_networkx_scale_free(self):
g = nx.scale_free_graph(100)
edge_count = g.number_of_edges()
g.graph["name"] = "scale_free_test"
cyjs_g = util.from_networkx(g)
print("\n---------- Scale free network Test Start -----------\n")
print("Edge count = " + str(edge_count))
# print(json.dumps(cyjs_g, indent=4))
self.assertIsNotNone(cyjs_g)
net_data = cyjs_g["data"]
self.assertIsNotNone(net_data)
self.assertEqual("scale_free_test", net_data["name"])
self.assertEqual(100, len(cyjs_g["elements"]["nodes"]))
self.assertEqual(edge_count, len(cyjs_g["elements"]["edges"]))
nodes = cyjs_g["elements"]["nodes"]
node0 = nodes[0]
self.assertEqual(type("1"), type(node0["data"]["id"]))
def test_networkx_scale_free(self):
g = nx.scale_free_graph(100)
edge_count = g.number_of_edges()
g.graph['name'] = 'scale_free_test'
cyjs_g = util.from_networkx(g)
print('\n---------- Scale free network Test Start -----------\n')
print('Edge count = ' + str(edge_count))
# print(json.dumps(cyjs_g, indent=4))
self.assertIsNotNone(cyjs_g)
net_data = cyjs_g['data']
self.assertIsNotNone(net_data)
self.assertEqual('scale_free_test', net_data['name'])
self.assertEqual(100, len(cyjs_g['elements']['nodes']))
self.assertEqual(edge_count, len(cyjs_g['elements']['edges']))
nodes = cyjs_g['elements']['nodes']
node0 = nodes[0]
self.assertEqual(type("1"), type(node0['data']['id']))
def run_scalefree(alpha=0.60, beta=0.35, gamma=0.05, delta_in=0.2, delta_out=0,
nodes=1000, iterations=1000,
epsilon_control=0.1, epsilon_damage=0.001,
random_load=True):
"""
Run on a scale-free graph. Returns (uncontrolled, controlled, df, costs).
If random_load is True, load is distributed randomly initially.
"""
# Generate graph and set up parameters
nodes = int(nodes)
iterations = int(iterations)
G = nx.scale_free_graph(nodes, alpha, beta, gamma, delta_in, delta_out)
G = G.to_undirected() # scale_free_graph() creates a digraph
# Maximum capacity is a node's degree
degrees = nx.degree(G)
C = np.array([degrees[i] for i in G.nodes()])
if random_load:
p = None
else:
p = {0: 0.52998, 1: 0.35651, 2: 0.11351}
G, L0 = sandpile.initialize_loads(G, p=p, C=C)
return do_run(G, L0, C, iterations, epsilon_control, epsilon_damage)
def demo2():
g = nx.scale_free_graph(30)
iterate(g)
def test_create_from_networkx(self):
networkx1 = nx.scale_free_graph(100)
network = self.client.network.create_from_networkx(networkx1)
self.assertIsNotNone(network)
#!/usr/bin/env python
"""
Random graph from given degree sequence.
Draw degree rank plot and graph with matplotlib.
"""
__author__ = """Aric Hagberg <*****@*****.**>"""
import networkx as nx
import matplotlib.pyplot as plt
import numpy as np
#G = nx.gnp_random_graph(100,0.02)
G1 = nx.scale_free_graph(100,alpha=0.05,beta=0.9,gamma=0.05)
G2= nx.scale_free_graph(100,alpha=0.9,beta=0.05,gamma=0.05)
nx.draw_circular(G1,node_color=range(100),cmap=plt.cm.Blues)
nx.draw_circular(G2,node_color=range(100),cmap=plt.cm.Blues)
ax=plt.subplot(111)
degree_sequence1=sorted(nx.degree(G1).values(),reverse=True) #degree sequence
degree_sequence2=sorted(nx.degree(G2).values(),reverse=True) #degree sequence
print degree_sequence1
print degree_sequence2
#print "Degree sequence", degree_sequence
ax.loglog(degree_sequence1,'bs',marker='o',label="aglomerado")
ax.loglog(degree_sequence2,'g^',marker='o',label="pouco-aglomerado")
print L2
#Get CC
CC2=NX.average_clustering(SW)
print CC2
#Get node degree distribution
DD=[]
for node in SW.nodes():
DD.append(SW.degree(node))
plt.hist(DD)
plt.show()
#Creating a scale-free graph
SF=NX.scale_free_graph(50) #number of nodes
#Draw network
NX.draw(SF, NX.shell_layout(SF))
plt.show()
#Get L
L2=NX.average_shortest_path_length(SF)
print L2
#Get node degree distribution
DD=[]
for node in SF.nodes():
DD.append(SF.degree(node))
plt.hist(DD)
plt.show()
def generate_data(file_name):
N=2000
n_seed = 100
G = nx.scale_free_graph(N,seed = 1)
print "finish generate scale free graph"
#purify data
net = []
net_reversed = []
random.seed(0)
for i in range(N):
net.append({})
net_reversed.append({})
for edge in G.edges():
if edge[0] != edge[1]:
weight = random.uniform(0.3,0.01)
net[edge[0]][edge[1]] = weight
net_reversed[edge[1]][edge[0]] = weight
del G
all_zeros = []
for i in range(N):
all_zeros.append(0)
def calc_self_product(A,tmp,net):
for i in range(N):
for j in range(N):
sum = tmp[i][j]
for item in net[j]:
sum += tmp[i][item]*net[j][item]
A[i][j] = sum
seed_set = []
delta = []
stamp = []
for i in range(N):
x = all_zeros[:]
x[i] = 1
for i in range(10):
x = trans(net_reversed,x,N)
sum = np.sum(x)
delta.append(sum)
stamp.append(0)
while len(seed_set) < n_seed:
index = -1
max = -1.0
for i in range(N):
if i not in seed_set and delta[i] >= max:
index, max = i,delta[i]
if stamp[index] == len(seed_set):
seed_set.append(index)
else:
x = all_zeros[:]
for item in seed_set:
x[item] = 1
x[index] = 1
for i in range(10):
x = trans(net_reversed,x,N)
sum1 = np.sum(x)
x = all_zeros[:]
for item in seed_set:
x[item] = 1
for i in range(10):
x = trans(net_reversed,x,N)
sum2 = np.sum(x)
delta[index] = sum1-sum2
stamp[index] = len(seed_set)
X1 = range(1,n_seed)
Y1 = []
for i in range(1,n_seed):
print i
index = seed_set[:i]
x = all_zeros[:]
for item in index:
x[item] = 1
for i in range(10):
x = trans(net_reversed,x,N)
sum = np.sum(x)
Y1.append(sum)
X2 = range(1,100)
Y2 = []
ave_num = 10
for n_random_seed in range(1,100):
sum = 0.0
for i in range(ave_num):
index = []
while len(index) != n_random_seed:
r = random.randint(0,N-1)
if r not in index:
index.append(r)
x = all_zeros[:]
for item in index:
x[item] = 1
for i in range(10):
x = trans(net_reversed,x,N)
sum += np.sum(x)
sum /= ave_num
Y2.append(sum)
with open(file_name,'w') as file:
print>>file,repr(X1)
print>>file,repr(Y1)
print>>file,repr(X2)
print>>file,repr(Y2)
r.append(sum)
return r
def activate(net_reversed,x,N):
for i in range(N):
if x[i]==0:
for item in net_reversed[i]:
if random.random() < net_reversed[i][item]:
x[i] = 1
break
return x
N=300
n_seed = 10
n_iteration_list = [200]
G = nx.scale_free_graph(N,seed = 1)
print "finish generate scale free graph"
#purify data
net = []
net_reversed = []
random.seed(0)
for i in range(N):
net.append({})
net_reversed.append({})
for edge in G.edges():
if edge[0] != edge[1]:
weight = random.uniform(0.3,0.01)
net[edge[0]][edge[1]] = weight
net_reversed[edge[1]][edge[0]] = weight
del G
import pytest
import os
from allegedb import ORM
import networkx as nx
scalefreestart = nx.MultiDiGraph(name='scale_free_graph_5')
scalefreestart.add_edges_from([(0, 1), (1, 2), (2, 0)])
testgraphs = [
nx.chvatal_graph(),
nx.scale_free_graph(5, create_using=scalefreestart),
# nx.chordal_cycle_graph(5, create_using=nx.MultiGraph(name='chordal_cycle_graph_5')),
# The standard networkx edges iterator decides to flip some edges about in arbitrary-seeming
# ways that I haven't been able to replicate and it doesn't seem worth it.
]
# have to name it after creation because it clears the create_using
path_graph_9 = nx.path_graph(9)
path_graph_9.name = 'path_graph_9'
testgraphs.append(path_graph_9)
@pytest.fixture
def db():
name = 'allegedb_load_test.db'
if os.path.exists(name):
os.remove(name)
with ORM('sqlite:///' + name) as orm:
for graph in testgraphs:
{
def new_scale_graph(num, gammat):
G = nx.scale_free_graph(num, 0.4, 0.59, 0.01, gammat, 0, None, None)
nx.draw(G)
plt.savefig("1.png")
return G
iterations, callback = FR_ITERATIONS, self.update_positions
if IS_VERY_LARGE_GRAPH(self.graph):
# Don't animate very large graphs
iterations, callback = 5, None
AnimationThread(iterations, callback).start()
def update_positions(self, positions):
self.positionsChanged.emit(positions)
return self._is_animating
def _update_positions(self, positions):
for node, pos in zip(self.nodes, positions*300):
node.setPos(*pos)
qApp.processEvents()
if __name__ == '__main__':
import sys
app = QtGui.QApplication(sys.argv)
widget = GraphView()
widget.show()
import networkx as nx
G = nx.scale_free_graph(int(sys.argv[1]) if len(sys.argv) > 1 else 100, seed=0)
widget.set_graph(G)
print('nodes', len(widget.nodes), 'edges', len(widget.edges))
for node in widget.nodes[:10]:
node.setHighlighted(True)
sys.exit(app.exec_())
import networkx as nx
import numpy as np
import pickle
# start at 44212
if __name__ == '__main__':
# Generate graphs (Warning: takes some time, see below dumped graphs) + TODO: investigate more parameters
scale_free_ns = [int(i) for i in np.logspace(5, 17, 200, base=2)]
# logspaced_scale_free = []
for n in scale_free_ns[173:]:
print("Generating ", n)
g = nx.scale_free_graph(n)
# logspaced_scale_free.append(g)
with open("benchmark/scale_free/5_17_200_{}.pickle".format(n), "wb") as f:
pickle.dump(g, f)
def test_basic_roundtrip(self):
g1 = nx.scale_free_graph(10)
cx1 = cxu.from_networkx(g1)
g2 = cxu.to_networkx(cx1)
self.assertTrue(nx.is_isomorphic(g1, g2, edge_match=cxu.edge_id_match))
