def remove_nodes(g):
"""
Modifies the INPUT graph by removing all nodes, whose degree is 2.
Is not used.
"""
g1 = g.copy()
nodes = []
le = nx.get_edge_attributes(g, 'length')
for i in g1.nodes():
if nx.degree(g1, i) == 2:
nodes = np.append(nodes, i)
for i in nodes:
i = int(i)
n = list(nx.neighbors(g, i))
le = nx.get_edge_attributes(g, 'length')
th = nx.get_edge_attributes(g, 'thick')
num = nx.get_edge_attributes(g, 'number')
if len(n)==1:
continue
else:
n1 = n[0]
n2 = n[1]
k1 = num[min(n1, i), max(i, n1), 0]
k2 = num[min(n2, i), max(i, n2), 0]
l = le[min(n1, i), max(i, n1), 0] + le[min(i, n2), max(i, n2), 0]
t = (th[min(n1, i), max(i, n1), 0] + th[min(i, n2), max(i, n2), 0])/2.
le.update({(min(n1, n2), max(n2, n1), 0): l})
th.update({(min(n1, n2), max(n2, n1), 0): t})
num.update({(min(n1, n2), max(n2, n1), 0): k1+k2})
g.remove_node(i)
g.add_edge(n1, n2, length = l, thick = t, number = k1 + k2)
return g
def weight_reshuffling(G,weight_tag='weight'):
'''
Input:
G: an undirected weighted network
IR_weight_cutoff: threshold on the minimum weight to reach
Output:
E: an undirected weighted graph with the same connectivity of G, but
reshuffled weights.
'''
print('Begin creation of weight reshuffled graph...');
weight_dictionary=nx.get_edge_attributes(G,'weight');
weight_sequence=weight_dictionary.values();
#preliminary scan of edge weights to define filtration steps
print('Preliminary scan of edge weights to define filtration steps...');
edge_weights=list(set(nx.get_edge_attributes(G,weight_tag).values()));
edge_weights=sorted(edge_weights, reverse=True);
print('Preliminary scan and sorting completed.');
E=nx.Graph();
E.add_nodes_from(G.nodes(data=True));
E.add_edges_from(G.edges());
E.remove_edges_from(E.selfloop_edges());
weight_sequence_temp=weight_sequence;
rn.shuffle(weight_sequence_temp);
print('Setting new weights.');
for e in E.edges_iter():
E.edge[e[0]][e[1]]['weight']=weight_sequence_temp[0];
weight_sequence_temp=weight_sequence_temp[1:];
print('Weights setup completed.');
return E
def _reproduce_sexually(self, partner): # TODO: Broken.
"""Sexual reproduction between two networks"""
inherited_state = -1 # -1 would be most recent
network_props = ['num_nodes']
node_props = ['threshold', 'energy_consumption', 'spontaneity']
# node_props = ['threshold']
edge_props = ['weight']
child = copy.deepcopy(self)
partner.children.append(child)
# partner.reproductive_energy_cost = self.reproductive_energy_cost
child.parents, child.children = [self, partner], []
if np.random.randint(0, 2) == 1:
internal_net = copy.deepcopy(self.internal)
child._cloned_from, child._not_cloned_from = self, partner
else:
internal_net = copy.deepcopy(partner.internal)
child._cloned_from, child._not_cloned_from = partner, self
# print "Kin with %d neurons, copied from net with %d neurons" %(internal_net.simdata[-1].number_of_nodes(), self.internal.simdata[-1].number_of_nodes())
child.set_internal_network(copy.deepcopy(internal_net), t0=self.t)
child.internal.simdata[inherited_state] = copy.copy(internal_net.simdata[inherited_state])
choices = np.random.randint(2, size=(2, len(node_props))) # randomly choose attributes
for j, n in enumerate(node_props):
p1 = nx.get_node_attributes(self.internal.simdata[inherited_state], n)
p2 = nx.get_node_attributes(partner.internal.simdata[inherited_state], n)
# add/remove nodal information based on the inherited number of nodes
# chosen = self if choices[0][j] else partner
# print "Using %s(N%d) for %s" %(chosen.ind_id, chosen.internal.simdata[inherited_state].number_of_nodes(), n)
utils.set_node_attributes(child.internal.simdata[inherited_state], n, p1 if choices[0][j] else p2)
for j, e in enumerate(edge_props):
p1 = nx.get_edge_attributes(self.internal.simdata[inherited_state], e)
p2 = nx.get_edge_attributes(partner.internal.simdata[inherited_state], e)
utils.set_edge_attributes(child.internal.simdata[inherited_state], n, p1 if choices[1][j] else p2)
return child
def normDAGl2Test(G_test, power):
kern = nx.get_edge_attributes(G_test, 'kern_unnorm')
tran = nx.get_edge_attributes(G_test, 'tran')
kern = OrderedDict(sorted(kern.items(), key=lambda t: t[0]))
val = kern.values()
key = kern.keys()
tran = OrderedDict(sorted(tran.items(), key=lambda t: t[0]))
tran = tran.values()
val = np.asarray(val, dtype=float)
tran = np.asarray(tran, dtype=float)
tran = np.log(1/tran) # logarithm weighting
tran[tran == np.inf] = 0
tran[np.isnan(tran)] = 0
if power == 2:
tran = np.square(tran)
if len(val.shape) == 2:
# kern = val/tran[:, None]
kern = val*tran[:, None] # avoid numeric problems when using logarithm weighting
kern = normalize(kern, norm='l2', axis=0)
else:
kern = val*tran
kern = kern/np.linalg.norm(kern)
kern = dict(zip(key, kern))
nx.set_edge_attributes(G_test, 'kern', kern)
return G_test
def build(self): ''' Produce a ``circuit``. ''' g = self._g voltages = nx.get_edge_attributes(g, '_voltage') resistances = nx.get_edge_attributes(g, '_resistance') sources = nx.get_edge_attributes(g, '_source') # class invariant of CircuitBuilder; no attribute ever appears without the other two assert set(voltages) == set(resistances) == set(sources) # this covers edges present in the initial graph (passed into the constructor) # which were not addressed via make_resistor and friends missing_edges = [e for e in g.edges() if (e not in voltages) and (e[::-1] not in voltages)] for e in missing_edges: voltages[e] = self._DEFAULT_VOLTAGE resistances[e] = self._DEFAULT_RESISTANCE sources[e] = e[0] copy = _copy_graph_without_attributes(g) nx.set_edge_attributes(copy, EATTR_VOLTAGE, voltages) nx.set_edge_attributes(copy, EATTR_RESISTANCE, resistances) nx.set_edge_attributes(copy, EATTR_SOURCE, sources) assert validate_circuit(copy) return copy
def short_branches():
"""
Visualization of short branches of the skeleton.
"""
data1_sk = glob.glob('/backup/yuliya/vsi05/skeletons_largdom/*.h5')
data1_sk.sort()
for i,j, k in zip(d[1][37:47], data1_sk[46:56], ell[1][37:47]):
g = nx.read_gpickle(i)
dat = tb.openFile(j)
skel = np.copy(dat.root.skel)
bra = np.copy(dat.root.branches)
mask = np.zeros_like(skel)
dat.close()
length = nx.get_edge_attributes(g, 'length')
number = nx.get_edge_attributes(g, 'number')
num_dict = {}
for m in number:
for v in number[m]:
num_dict.setdefault(v, []).append(m)
find_br = ndimage.find_objects(bra)
for l in list(length.keys()):
if length[l]<0.5*k: #Criteria
for b in number[l]:
mask[find_br[b-1]] = bra[find_br[b-1]]==b
mlab.figure(bgcolor=(1,1,1), size=(1200,1200))
mlab.contour3d(skel, colormap='hot')
mlab.contour3d(mask)
mlab.savefig('/backup/yuliya/vsi05/skeletons/short_bran/'+ i[42:-10] + '.png')
mlab.close()
def length_distr_total():
"""
Length distribution total (all images). For all the branches and broken ones.
d1 : array of lists of pathes for the break-ups dictionaries.
d : array of lists of pathes for the graphs
ell : array of lists of length scales
pa : list of experiment names (pathes)
"""
for data, data1, path, el in zip(d, d1, pa, ell):
l1 = list() #all branches
l2 = list() #breaking branches
u = 0
for i,j,le in zip(data, data1, el):
g = nx.read_gpickle(i)
br = np.load(j).item()
length = nx.get_edge_attributes(g, 'length')
l_mean = np.mean(np.asarray(length.values()))
number = nx.get_edge_attributes(g, 'number')
num_dict = {}
for k in number:
for v in number[k]:
num_dict.setdefault(v, []).append(k)
for k in length.values():
l1.append(k/float(1))
for k in br.keys():
for l in num_dict[k]:
l2.append(length[l]/float(1))
u+=1
hist1, bins1 = np.histogram(l1, np.arange(0, max(l1)+1, 0.06))
hist2, bins2 = np.histogram(l2, np.arange(0, max(l1)+1, 0.06))
center1 = (bins1[:-1] + bins1[1:])/2
center2 = (bins2[:-1] + bins2[1:])/2
#save to file if necessary
#np.save('/home/yuliya/codes/lengths/' + path + '/total_lno_all_len.npy', center1)
#np.save('/home/yuliya/codes/lengths/' + path + '/total_lno_break_len.npy', center2)
#np.save('/home/yuliya/codes/lengths/' + path + '/total_lno_all.npy', hist1/float(len(l1)))
#np.save('/home/yuliya/codes/lengths/' + path + '/total_lno_break.npy', hist2/float(len(l1)))
#Plot it
##plt.figure(2)
#hist1, bins1 = np.histogram(l1, np.arange(0, max(l1)+1, 0.06))
#hist2, bins2 = np.histogram(l2, np.arange(0, max(l2)+1, 0.06))
#center1 = (bins1[:-1] + bins1[1:])/2
#center2 = (bins2[:-1] + bins2[1:])/2
#plt.plot(center1, hist1/float(len(l1)), '.', color='red', label = 'all branches')
#plt.plot(center2, hist2/float(len(l1)), '.', color='blue', label = 'breaking branches')
#
"""
Probability as a function of length.
"""
hist1, bins1 = np.histogram(l1, np.arange(0, max(l1)+1, 0.1))
hist2, bins2 = np.histogram(l2, np.arange(0, max(l2)+1, 0.1))
center1 = (bins1[:-1] + bins1[1:])/2
plt.plot(center1, hist2/hist1.astype('float32'), '.', color='green', label = 'v35')
def init(G, uncon_comp_tups, contactor_tups):
nodes_number = G.nodes()
edges_number = G.edges()
node_name_data = nx.get_node_attributes(G, 'name')
edge_name_data = nx.get_edge_attributes(G, 'name')
edge_type_data = nx.get_edge_attributes(G, 'type')
node_type_data = nx.get_node_attributes(G, 'type')
declaration = '(set-option :print-success false)\n'
declaration += '(set-option :produce-models true)\n(set-logic QF_UF)\n'
for i in range(0, len(nodes_number)):
x = nodes_number[i]
node_type = node_type_data[x]
if node_type != 'dummy':
clause = '(declare-fun ' + node_name_data[x] + ' () Bool)\n'
if node_type == 'generator' or node_type=='APU' or node_type == 'rectifier_dc':
uncon_comp_tups.append(node_name_data[x])
declaration += clause
for i in range(0, len(edges_number)):
idx = edges_number[i]
edge_type = edge_type_data[idx]
if edge_type == 'contactor':
edge_name = edge_name_data[idx]
flag = 0
for j in range(0, len(contactor_tups)):
if edge_name == contactor_tups[j]:
flag = 1
break
if flag == 0: contactor_tups.append(edge_name)
for i in range(0, len(contactor_tups)):
clause = '(declare-fun ' + contactor_tups[i] + ' () Bool)\n'
declaration += clause
return declaration
def no_paralleling_set(name_tups, G):
nodes_number = G.nodes()
edge_type_data = nx.get_edge_attributes(G,'type')
node_name_data = nx.get_node_attributes(G,'name')
edge_name_data = nx.get_edge_attributes(G,'name')
num_tups = []
for i in range(0, len(name_tups)):
for j in range(0, len(nodes_number)):
x = nodes_number[j]
if node_name_data[x] == name_tups[i]:
num_tups.append(x)
#check if there's invalid input component
if j == len(nodes_number):
print 'Error: Component ' + e_bus_list[i] + ' Not Found'
exit()
specs_assert = ''
for i in range(0, len(num_tups)-1):
for j in range(i+1, len(num_tups)):
tups = list(nx.all_simple_paths(G, num_tups[i], num_tups[j]))
clause = '(assert (not'
if len(tups)>1: clause += ' (or'
if tups != []:
for k in range(0,len(tups)):
clause += ' (and'
one_path = tups[k]
for x in range(0,len(one_path)-1):
if edge_type_data[(one_path[x],one_path[x+1])]=='contactor':
clause += ' ' + edge_name_data[(one_path[x],one_path[x+1])]
clause += ')'
if len(tups)>1: clause += ')))\n'
else: clause += '))\n'
specs_assert += clause
return specs_assert
def no_paralleling(node1, node2, G):
nodes_number = G.nodes()
edge_type_data = nx.get_edge_attributes(G,'type')
node_name_data = nx.get_node_attributes(G,'name')
edge_name_data = nx.get_edge_attributes(G,'name')
num1 = num2 = 0
for i in range(0, len(nodes_number)):
x = nodes_number[i]
if node_name_data[x] == node1:
num1 = x
elif node_name_data[x] == node2:
num2 = x
#check if components are valid
if num1 == 0:
print 'Error: ' + node1 + ' Not Found'
exit()
if num2 == 0:
print 'Error: ' + node2 + ' Not Found'
exit()
tups = list(nx.all_simple_paths(G, num1, num2))
clause = '(assert (not'
if len(tups)>1: clause += ' (or'
if tups != []:
for k in range(0,len(tups)):
clause += ' (and'
one_path = tups[k]
for x in range(0,len(one_path)-1):
if edge_type_data[(one_path[x],one_path[x+1])]=='contactor':
clause += ' ' + edge_name_data[(one_path[x],one_path[x+1])]
clause += ')'
if len(tups)>1: clause += ')))\n'
else: clause += '))\n'
return clause
def compare_list(self, graph_list, types, h, D):
"""
Compute the all-pairs kernel values for a list of graph representations of verification tasks
"""
all_graphs_number_of_nodes = 0
node_labels = [0] * (h+1)
node_depth = [0] * len(graph_list)
edge_types = [0] * len(graph_list)
edge_truth = [0] * len(graph_list)
for it in range(h+1):
node_labels[it] = [0] * len(graph_list)
for i, g in enumerate(graph_list):
node_labels[0][i] = {key: self._compress(value)
for key, value in nx.get_node_attributes(g, 'label').items()}
node_depth[i] = nx.get_node_attributes(g, 'depth')
edge_types[i] = nx.get_edge_attributes(g, 'type')
edge_truth[i] = nx.get_edge_attributes(g, 'truth')
all_graphs_number_of_nodes += len([node for node in nx.nodes_iter(g) if node_depth[i][node] <= D])
# if i == 0:
# self._graph_to_dot(g, node_labels[0][i], "graph{}.dot".format(i))
# all_graphs_number_of_nodes is upper bound for number of possible edge labels
phi = np.zeros((all_graphs_number_of_nodes, len(graph_list)), dtype=np.uint64)
# h = 0
for i, g in enumerate(graph_list):
for node in g.nodes_iter():
if node_depth[i][node] <= D:
label = node_labels[0][i][node]
phi[self._compress(label), i] += 1
K = np.dot(phi.transpose(), phi)
# h > 0
for it in range(1, h+1):
# Todo check if the shape fits in all cases
phi = np.zeros((2*all_graphs_number_of_nodes, len(graph_list)), dtype=np.uint64)
print('Updating node labels of graphs in iteration {}'.format(it), flush=True)
# for each graph update edge labels
for i, g in tqdm(list(enumerate(graph_list))):
node_labels[it][i] = {}
for node in g.nodes_iter():
if node_depth[i][node] <= D:
label_collection = self._collect_labels(node, i, g, it-1, node_labels, node_depth, types, D, edge_types, edge_truth)
long_label = "_".join(str(x) for x in [np.concatenate([np.array([node_labels[it-1][i][node]]),
np.sort(label_collection)])])
node_labels[it][i][node] = self._compress(long_label)
phi[self._compress(long_label), i] += 1
# node_labels[it][i][node] = long_label
# phi[self._compress(long_label), i] += 1
# if i == 0:
# self._graph_to_dot(g, node_labels[it][i], "graph{}_it{}.dot".format(i, it))
K += np.dot(phi.transpose(), phi)
return K
def test_clear_delays(self):
topo = fnss.star_topology(12)
fnss.set_delays_constant(topo, 1, 'ms', None)
self.assertEqual(topo.number_of_edges(),
len(nx.get_edge_attributes(topo, 'delay')))
fnss.clear_delays(topo)
self.assertEqual(0, len(nx.get_edge_attributes(topo, 'delay')))
def _calc_attr_fuzzy_hist(self, G, attr, fuzzy_intervals):
"""
Computes the fuzzy histogram for an attribute. Returns the
number of elements in each bin
Args:
G: nx.Graph
attr: Attribute name
fuzzy_intervals: list(list(a,b,c,d)) defining a traperzoidal fuzzy histogram
Returns:
list(elem_per_bin)
"""
fi = fuzzy_intervals
vals = nx.get_edge_attributes(G, attr) if nx.get_edge_attributes(G, attr) else nx.get_node_attributes(G, attr)
vec = [0.0]*len(fi)
for elem in vals:
val = vals[elem]
for i, interval in enumerate(fi):
if (val >= interval[0]) and (val < interval[1]):
vec[i] += (val-interval[0]) / (interval[1]-interval[0])
elif (val >= interval[1]) and (val <= interval[2]):
vec[i] += 1
elif (val > interval[2]) and (val <= interval[3]):
vec[i] += (val-interval[3]) / (interval[2]-interval[3])
else:
pass
return vec
def aspect_rat_distr_total():
"""
Aspect ratio distribution.
d1 : list of pathes for the break-ups dictionaries. Used here for the
estimation of the necessary number of pairs.
d : list of pathes for the graphs
ell : list of length scales
pa : array of the pathes to the experiments folder (to save data)
"""
for data, data1, path, el in zip(d, d1, pa, ell):
l1 = list() #all branches
l2 = list() #breaking branches
u = 0
for i,j in zip(data, data1):
g = nx.read_gpickle(i)
br = np.load(j).item()
thick = nx.get_edge_attributes(g, 'thick')
m_th = np.mean(np.asarray(thick.values()))
length = nx.get_edge_attributes(g, 'length')
m_le = np.mean(np.asarray(length.values()))
number = nx.get_edge_attributes(g, 'number')
num_dict = {}
for k in number:
for v in number[k]:
num_dict.setdefault(v, []).append(k)
for k,l in zip(thick.values(), length.values()):
l1.append(float(l)*m_th/(m_le * k))
for k in br.keys():
for l in num_dict[k]:
l2.append(float(length[l] * m_th)/(m_le * thick[l]))
u+=1
hist1, bins1 = np.histogram(l1, np.arange(0, max(l1)+1, 0.3))
hist2, bins2 = np.histogram(l2, np.arange(0, max(l1)+1, 0.3))
center1 = (bins1[:-1] + bins1[1:])/2
center2 = (bins2[:-1] + bins2[1:])/2
# np.save('/home/yuliya/codes/lengths/' + path + '/total_arm_all_len.npy', center1)
# np.save('/home/yuliya/codes/lengths/' + path + '/total_arm_break_len.npy', center2)
# np.save('/home/yuliya/codes/lengths/' + path + '/total_arm_all.npy', hist1/float(len(l1)))
# np.save('/home/yuliya/codes/lengths/' + path + '/total_arm_break.npy', hist2/float(len(l1)))
plt.plot(center1, hist1/float(len(l1)), '.', color='red', label = 'all branches')
plt.plot(center2, hist2/float(len(l1)), '.', color='blue', label = 'breaking branches')
plt.legend()
plt.xlabel('l / d', fontsize=18)
plt.ylabel('P(l/d)', fontsize = 18)
"""
Probability as a function of aspect ratio.
"""
hist1, bins1 = np.histogram(l1, np.arange(0, max(l1)+1, 0.3))
hist2, bins2 = np.histogram(l2, np.arange(0, max(l1)+1, 0.3))
center1 = (bins1[:-1] + bins1[1:])/2
plt.plot(center1, hist2/hist1.astype('float32'), '.', color='red', label = 'v34')
plt.legend()
plt.xlabel('d / l', fontsize = 18)
plt.ylabel('Breakup Probability', fontsize = 18)
def populate_internal_edges(self):
for block in self.blocks:
weight = nx.get_edge_attributes(block, "weight")
capacity = nx.get_edge_attributes(block, "capacity")
for edge in block.edges():
self.add_edge(edge[0], edge[1],
weight=weight[edge],
capacity=capacity[edge])
def test_clear_weights(self):
# create new topology to avoid parameters pollution
G = fnss.star_topology(12)
fnss.set_weights_constant(G, 3, None)
self.assertEqual(G.number_of_edges(),
len(nx.get_edge_attributes(G, 'weight')))
fnss.clear_weights(G)
self.assertEqual(0, len(nx.get_edge_attributes(G, 'weight')))
def local_standard_weight_clique_rank_filtration(G,IR_weight_cutoff=None,verbose=False):
if IR_weight_cutoff==None:
IR_weight_cutoff=np.min(nx.get_edge_attributes(G,'weight').values());
print('Preliminary scan of edge weights to define filtration steps...');
edge_weights=nx.get_edge_attributes(G,'weight');
weight_edge = {}
for e,w in edge_weights.items():
if w not in weight_edge:
weight_edge[w] = []
weight_edge[w].append(e);
edge_weights=list(set(edge_weights.values()));
edge_weights=sorted(edge_weights, reverse=True);
max_index=len(edge_weights);
# Define the clique dictionary
Clique_dictionary={};
print('Constructing filtration...');
#Beginning of filtration construction
G_supplementary=nx.Graph();
#the max index will be used for the persistent homology computation
max_index=0;
current_nodes = []
for index,thr in enumerate(edge_weights):
new_nodes = [];
if thr>=IR_weight_cutoff:
G_supplementary.add_edges_from(weight_edge[thr]);
[new_nodes.extend(edge) for edge in weight_edge[thr]];
new_nodes = list(set(new_nodes));
## clique detection in partial graph, where there cliques are found only on the
## new nodes.
relevant_nodes = []
[relevant_nodes.extend(G_supplementary.neighbors(n)) for n in new_nodes];
relevant_nodes = list(set(relevant_nodes));
G_supp_supp = nx.subgraph(G_supplementary,relevant_nodes);
cliques=nx.find_cliques_recursive(G_supp_supp);
# adding cliques to the filtration
for clique in cliques: #loop on new clique
clique.sort();
for k in range(1,len(clique)+1): #loop on clique dimension to find missed faces of simplex
for subclique in itertools.combinations(clique,k):
if str(list(subclique)) not in Clique_dictionary:
Clique_dictionary[str(list(subclique))]=[];
Clique_dictionary[str(list(subclique))].append(str(index));
Clique_dictionary[str(list(subclique))].append(str(thr))
max_index=index;
print('Max filtration value: '+str(max_index));
print('Clique dictionary created.');
return Clique_dictionary;
def IsUnassigned(G, node1, node2):
for key in nx.get_edge_attributes(G, 'value').keys():
if(key[0] == node1 and key[1] == node2):
if (nx.get_edge_attributes(G, 'value')[key] == 'x'):
return True
else:
"Do nothing"
else:
"Continue search"
return False
def populate_internal_edges(self):
"""
Adds in each block in block list to the allocation graph. Blocks remain disjoint at this point.
"""
for block in self.blocks:
weight = nx.get_edge_attributes(block, "weight") # {edge: edge attribute for edge in block.edges()}
capacity = nx.get_edge_attributes(block, "capacity")
for edge in block.edges():
self.add_edge(edge[0], edge[1],
weight=weight[edge],
capacity=capacity[edge])
def read_network_from_file(edge_file, node_file):
""""""
'''
Get edge list, thresholds and nodes from file
Arguments:
edge_file [csv delimited .dat file]
format:
source_node [str] , target_node [str] , weight [bool]
node_file [csv delimited .dat file]
format:
node [str] , state [bool]
Outputs:
G [networkx Graph object]
NOTES:
weight = 1 if edge is inductive
weight = 0 if edge is inhibiting
state = 1 if expressed
state = 0 if not expressed
weight and state are boolean, but MUST be 0 or 1.
DO NOT USE 'True' and 'False'.
They will not be evaluated correctly.
'''
## read edge list with its weight from edge_file
G = nx.read_edgelist(edge_file, create_using=nx.DiGraph(), delimiter=',', nodetype=str, data=(('weight', int),))
## Raise error if weight is not a 0 or 1
for edge in nx.get_edge_attributes(G,'weight'):
weight = nx.get_edge_attributes(G,'weight')[edge]
if weight != 0 and weight != 1:
raise ValueError("All weights must be boolean, represented as either 0 or 1")
## read node list with its state from node_file
for line in open(node_file, 'r').readlines():
items = [x.strip() for x in line.rstrip().split(',')]
# print items
if line[0] == '#' or line=='':
continue
G.add_node(items[0], state=int(items[1]))
## Raise error if state is not a 0 or 1
for node in nx.get_node_attributes(G,'state'):
state = nx.get_node_attributes(G,'state')[node]
if state != 0 and state != 1:
raise ValueError("All states must be boolean, represented as either 0 or 1")
return G
def thick_distr_total():
"""
Thickness distributions for all images. For all the branches (hist1) and the broken ones (hist2).
"""
for data, data1, path, el in zip(d, d1, pa, ell):
l1 = list() #all branches
l2 = list() #breaking branches
u = 0
for i,j,le in zip(data, data1, el):
g = nx.read_gpickle(i)
br = np.load(j).item()
thick = nx.get_edge_attributes(g, 'thick')
th_mean = np.mean(np.asarray(thick.values()))
number = nx.get_edge_attributes(g, 'number')
num_dict = {}
for k in number:
for v in number[k]:
num_dict.setdefault(v, []).append(k)
for k in thick.values():
l1.append(k/float(th_mean))
for k in br.keys():
for l in num_dict[k]:
l2.append(thick[l]/float(th_mean))
u+=1
hist1, bins1 = np.histogram(l1, np.arange(0, max(l1)+1, 0.05))
hist2, bins2 = np.histogram(l2, np.arange(0, max(l1)+1, 0.05))
center1 = (bins1[:-1] + bins1[1:])/2
center2 = (bins2[:-1] + bins2[1:])/2
#write to file if necessary
# np.save('/home/yuliya/codes/lengths/' + path + '/total_rm_all_len.npy', center1)
# np.save('/home/yuliya/codes/lengths/' + path + '/total_rm_break_len.npy', center2)
# np.save('/home/yuliya/codes/lengths/' + path + '/total_rm_all.npy', hist1/float(len(l1)))
# np.save('/home/yuliya/codes/lengths/' + path + '/total_rm_break.npy', hist2/float(len(l1)))
plt.plot(center1, hist1/float(len(l1)), '.', color='red', label = 'all branches')
plt.plot(center2, hist2/float(len(l1)), '.', color='blue', label = 'breaking branches')
plt.legend()
plt.xlabel('d/l_typ', fontsize=18)
plt.ylabel('P(d/l_typ)', fontsize = 18)
"""
Probability as a function of thickness.
"""
hist1, bins1 = np.histogram(l1, np.arange(0, max(l1)+1, 0.02))
hist2, bins2 = np.histogram(l2, np.arange(0, max(l1)+1, 0.02))
center1 = (bins1[:-1] + bins1[1:])/2
plt.plot(center1, hist2/hist1.astype('float32'), '.', color='blue', label = 'v35')
plt.legend()
plt.xlabel('d/l_typ', fontsize=18)
plt.ylabel('P(d/l_typ)', fontsize = 18)
f = curve_fit(fit_d, center1[10:20], (hist2/hist1.astype('float32'))[10:20], p0=(1,0.2))[0]
plt.plot(center1, fit_d(center1, f[0], f[1]), '.', color='blue', label = 'fitting vsi05')
def generate_sample_data(mC, numforecasts, tsteps, samplesize, fixfc0=True, useThisLPT=None, useThisIPT=None):
gennet = copy.deepcopy(mC["netobj"].dinet)
# for policy evaluation, there are tsteps dicts, one for every t#_capacity. each dict maps an edge to a
# singleton-sized list of capacities
adpoutageattr = [[dict() for t in xrange(tsteps)] for nf in xrange(numforecasts)]
adpftdmgattr = [[dict() for t in xrange(tsteps)] for nf in xrange(numforecasts)]
# these attr dicts will have samplesize-sized capacity values
mcoutageattr = [[dict() for t in xrange(tsteps)] for nf in xrange(numforecasts)]
mcftdmgattr = [[dict() for t in xrange(tsteps)] for nf in xrange(numforecasts)]
## # for benchmarking, there is only 1 dict, but it maps an edge to a samplesize list of capacities
## lpoutageattr = [dict() for nf in xrange(numforecasts)]
## ipoutageattr = [dict() for nf in xrange(numforecasts)]
## # this gathers some stats on the samples generated, currently not in use
## outagepcts = dict(zip(mC["temp_var_insts"],[[] for i in xrange(len(mC["temp_var_insts"] )) ] ))
## # the SAA dicts may be at any time we want (typically either tsteps-1 or 0)
## if useThisLPT == None:
## useThisLPT = tsteps-1
## if useThisIPT == None:
## useThisIPT = tsteps-1
# specifies if we want the same forecast at time 0 for every separate forecast timeline
if fixfc0:
fixedepictr = mC["mcsim"].generate_distributions(gennet, 1)[0]
fixedattr = nx.get_edge_attributes(gennet, "t0_dmg_pct")
for nf in xrange(numforecasts):
mC["mcsim"].clear_scenarios(gennet)
if fixfc0:
mC["mcsim"].generate_distributions(gennet, tsteps, sfcastattr=fixedattr, sfcastepictr=fixedepictr)
else:
mC["mcsim"].generate_distributions(gennet, tsteps)
# generate samplesize+1 to get policy eval set and the rest for SAA test
mC["mcsim"].sample_scenarios(gennet, ksamples=1)
for t in xrange(tsteps):
adpftdmgattr[nf][t] = nx.get_edge_attributes(gennet, "t"+str(t)+"_dmg_pct")
adpoutageattr[nf][t] = nx.get_edge_attributes(gennet, "t"+str(t)+"_capacity")
mC["mcsim"].clear_scenarios(gennet)
mC["mcsim"].sample_scenarios(gennet, ksamples=samplesize)
for t in xrange(tsteps):
mcftdmgattr[nf][t] = nx.get_edge_attributes(gennet, "t"+str(t)+"_dmg_pct")
mcoutageattr[nf][t] = nx.get_edge_attributes(gennet, "t"+str(t)+"_capacity")
## lpftdmgattr[nf] = nx.get_edge_attributes(gennet, "t"+str(useThisLPT)+"_dmg_pct")
## lpoutageattr[nf] = nx.get_edge_attributes(gennet, "t"+str(useThisLPT)+"_capacity")
## ipftdmgattr[nf] = nx.get_edge_attributes(gennet, "t"+str(useThisIPT)+"_dmg_pct")
## ipoutageattr[nf] = nx.get_edge_attributes(gennet, "t"+str(useThisIPT)+"_capacity")
## for k,v in lpoutageattr[nf].iteritems():
## if k not in outagepcts:
## outagepcts[k] = []
## outagepcts[k].append(float(len([i for i in v if i == 0])) / len(v) )
# return remnants: lpftdmgattr, ipftdmgattr, adpoutageattr, lpoutageattr, ipoutageattr
return adpftdmgattr, adpoutageattr, mcftdmgattr, mcoutageattr
def update_winner(self, curnode):
"""."""
# find nearest unit and second nearest unit
winner1, winner2 = self.determine_2closest_vertices(curnode)
winnernode = winner1[0]
winnernode2 = winner2[0]
win_dist_from_node = winner1[1]
errorvectors = nx.get_node_attributes(self.graph, 'error')
error1 = errorvectors[winner1[0]]
# update the new error
newerror = error1 + win_dist_from_node**2
self.graph.add_node(winnernode, error=newerror)
# move the winner node towards current node
self.pos = nx.get_node_attributes(self.graph, 'pos')
newposition = self.get_new_position(self.pos[winnernode], curnode)
self.graph.add_node(winnernode, pos=newposition)
# now update all the neighbors distances and their ages
neighbors = nx.all_neighbors(self.graph, winnernode)
age_of_edges = nx.get_edge_attributes(self.graph, 'age')
for n in neighbors:
newposition = self.get_new_position_neighbors(self.pos[n], curnode)
self.graph.add_node(n, pos=newposition)
key = (int(winnernode), n)
if key in age_of_edges:
newage = age_of_edges[(int(winnernode), n)] + 1
else:
newage = age_of_edges[(n, int(winnernode))] + 1
self.graph.add_edge(winnernode, n, age=newage)
# no sense in what I am writing here, but with algorithm it goes perfect
# if winnner and 2nd winner are connected, update their age to zero
if (self.graph.get_edge_data(winnernode, winnernode2) is not None):
self.graph.add_edge(winnernode, winnernode2, age=0)
else:
# else create an edge between them
self.graph.add_edge(winnernode, winnernode2, age=0)
# if there are ages more than maximum allowed age, remove them
age_of_edges = nx.get_edge_attributes(self.graph, 'age')
for edge, age in iteritems(age_of_edges):
if age > self.max_age:
self.graph.remove_edge(edge[0], edge[1])
# if it causes isolated vertix, remove that vertex as well
for node in self.graph.nodes():
if not self.graph.neighbors(node):
self.graph.remove_node(node)
def overview(self):
O={}
for sn in self.SubNet.iteritems():
for ldp in self.LDP:
try:
O[sn[0]].update({ldp:nx.get_edge_attributes(sn[1],ldp)})
except:
O[sn[0]]={ldp:nx.get_edge_attributes(sn[1],ldp)}
return (O)
def isolate(component, G): nodes_number = G.nodes() edges_number = G.edges() edge_type_data = nx.get_edge_attributes(G,'type') node_name_data = nx.get_node_attributes(G,'name') edge_name_data = nx.get_edge_attributes(G,'name') comp2 = component if component[0] == 'T': comp1 = component + '_ac' comp2 = component + '_dc' comp_num1 = comp_num2 = comp_num = 0 for i in range(0, len(nodes_number)): x = nodes_number[i] if component[0] != 'T' and node_name_data[x] == component: comp_num = x break elif component[0] == 'T' and node_name_data[x] == comp2: comp_num2 = x comp_num1 = x + '_ac' break if i == len(nodes_number): print 'Error: ' + component + ' Not Found' exit() neighbor_idx = [] if component[0] != 'T': for i in range(0, len(edges_number)): if edges_number[i][0] == comp_num: neighbor_idx.append(edges_number[i]) else: for i in range(0, len(edges_number)): if edges_number[i][0] == comp_num1 or edges_number[i][0] == comp_num2: neighbor_idx.append(edges_number[i]) contactor_tups = [] for i in range(0, len(neighbor_idx)): idx = neighbor_idx[i] if edge_type_data[idx] == 'contactor': edge_name = edge_name_data[idx] contactor_tups.append(edge_name) if len(contactor_tups) == 0: clause = '' return clause clause = '(assert (=> (not ' + comp2 + ')' if len(contactor_tups) > 1: clause += ' (and ' for i in range(0, len(contactor_tups)): clause += '(not ' + contactor_tups[i] + ')' if len(contactor_tups) > 1: clause += ')))\n' elif len(contactor_tups) == 1: clause += '))\n' return clause
def length_distr_dyn():
"""
Length distributions evolving in time.
d1 : array of lists of pathes for the break-ups dictionaries.
d : array of lists of pathes for the graphs
ell : array of lists of length scales
pa : list of experiment names (pathes)
"""
av = [20, 12, 12, 13] #Number of images for avereging for each experiment. Here
#we use 20 images for one plot for v34 experiment etc.
for data, data1, path, el, a in zip(d, d1, pa, ell, av):
l1 = list() #all branches
l2 = list() #breaking branches
u = 0
count=0
co=0
for i,j,le in zip(data, data1, el):
g = nx.read_gpickle(i)
br = np.load(j).item()
length = nx.get_edge_attributes(g, 'length')
l_mean = np.mean(np.asarray(length.values()))
number = nx.get_edge_attributes(g, 'number')
num_dict = {}
for k in number:
for v in number[k]:
num_dict.setdefault(v, []).append(k)
for k in length.values():
l1.append(k/float(l_mean))
for k in br.keys():
for l in num_dict[k]:
l2.append(length[l]/float(l_mean))
u+=1
if count>a:
count=-1
hist1, bins1 = np.histogram(l1, np.arange(0, max(l1)+1, 0.06))
hist2, bins2 = np.histogram(l2, np.arange(0, max(l1)+1, 0.06))
center1 = (bins1[:-1] + bins1[1:])/2
center2 = (bins2[:-1] + bins2[1:])/2
#write to file if necessary
np.save('/home/yuliya/codes/lengths/' + path + '/dyn_lm_all_len' + str(co)+'.npy', center1)
np.save('/home/yuliya/codes/lengths/' + path + '/dyn_lm_break_len' + str(co)+'.npy', center2)
np.save('/home/yuliya/codes/lengths/' + path + '/dyn_lm_all' + str(co)+'.npy', hist1/float(len(l1)))
np.save('/home/yuliya/codes/lengths/' + path + '/dyn_lm_break' + str(co)+'.npy', hist2/float(len(l1)))
l1 = list()
l2 = list()
co+=1
count+=1
def test_decorating_edges(self):
"""
Test that decorating actually sets the proper value.
"""
new_graph = GRAPH.copy()
properties = {
"dummy": dict((e, "dummy") for e in new_graph.edges())
}
pydevDAG.Decorator.decorate_edges(new_graph, properties)
values = networkx.get_edge_attributes(new_graph, "dummy").values()
assert values and all(e == "dummy" for e in values)
others = networkx.get_edge_attributes(GRAPH, "dummy").values()
assert not others
def strength_rich_club_coefficient(G,ranking,thr,weight_name='weight',normalized=False): ''' Calculates the members of the rich club given the ranking and the coefficient, normalized on the randomized version of the network This does not work in general, needs to be improved Works now only for strength preserving randomization and strength ranking ''' from sets import Set club_nodes=[]; for n in G.nodes(): if ranking[n]>=thr: club_nodes.append(n); Club=nx.Graph(G.subgraph(club_nodes)); W_club=float(np.sum(nx.get_edge_attributes(Club,weight_name).values())); # print Club.number_of_nodes() Extended_club=nx.Graph(); for n in Club.nodes(): Extended_club.add_node(n); for nn in G.neighbors(n): Extended_club.add_edge(n,nn,weight=G[n][nn][weight_name]); print Extended_club.number_of_nodes() W_ext=float(np.sum(nx.get_edge_attributes(Extended_club,weight_name).values())); if normalized==True: RandomGraph=Phom.strength_preserving_reshuffling(G,weight_name).to_undirected(); club_nodes=[]; for n in RandomGraph.nodes(): if ranking[n]>=thr: club_nodes.append(n); Club=nx.Graph(RandomGraph.subgraph(club_nodes)); W_club_r=float(np.sum(nx.get_edge_attributes(Club,weight_name).values())); # print Club.number_of_nodes() Extended_club=nx.Graph(); for n in Club.nodes(): Extended_club.add_node(n); for nn in RandomGraph.neighbors(n): Extended_club.add_edge(n,nn,weight=RandomGraph[n][nn][weight_name]); print Extended_club.number_of_edges() W_ext_r=float(np.sum(nx.get_edge_attributes(Extended_club,weight_name).values())); ranking_random=ranking; return (W_club/W_ext)/(W_club_r/W_ext_r); else: return W_club/W_ext;
def form_big_spanning_tree(clouds):
original_g = nx.Graph()
if not clouds: return None
for cloud in clouds:
if not cloud.sites: return None
for site in cloud.sites:
if not site.switches: return None
original_g.add_edge(cloud, site.of_domain,weight=site.switches[0].dpid, site=site)
spt = nx.minimum_spanning_tree(original_g)
spt_att = nx.get_edge_attributes(spt, 'site')
original_g_att = nx.get_edge_attributes(original_g, 'site')
return set(original_g_att.itervalues()) - set(spt_att.itervalues())
def separate_conditional(klass, H, conditional_links=tuple()):
labels = nx.get_edge_attributes(H, 'label')
weights = nx.get_edge_attributes(H, 'weight')
Hstat = nx.DiGraph()
Hcond = nx.DiGraph()
Hstat.add_nodes_from(H.nodes())
Hcond.add_nodes_from(H.nodes())
for edgeref in H.edges():
edge = labels[edgeref]
weight = weights[edgeref]
if edge in conditional_links:
Hcond.add_edge(*edgeref, label=edge, weight=weight)
else:
Hstat.add_edge(*edgeref, label=edge, weight=weight)
return Hstat, Hcond
def cluster_subgraph_for_clustering(Graph,option='accumulate',
connected='yes',retain_clus='yes',
):
"""
option='accumulate' will accumulate the nodes and edges of the graph year on year
option='separate' will only keep the nodes year on year, edges from previous years will not be retained
connected='yes' will only use the largest connected component for each year
connected='no' will use all available nodes for each year
retain_clus='yes' will initialize the louvain calculation such that the previous year's cluster is used to initialize this year's cluster
retain_clus='no' will use a random initialization for the louvain calculation
res_louv is used to set the resolution parameter for the louvain clustering calculation
wei is used for the edge weight in the louvain clustering calculation
"""
# get node and edge year
node_yr=nx.get_node_attributes(Graph,'Year')
edge_yr=nx.get_edge_attributes(Graph,'Year')
# dictionarys to filter nodes and edges by year
n_year=int(max(node_yr.values())-min(node_yr.values()))+1
min_year=min(node_yr.values())
list_dict_node_year=[{} for i in range(n_year)]
list_dict_edge_year=[{} for i in range(n_year)]
for i in range(n_year):
if option=='accumulate':
list_dict_edge_year[i]={k:v for (k,v) in edge_yr.items() if v<=min_year+i}
list_dict_node_year[i]={k:v for (k,v) in node_yr.items() if v<=min_year+i}
elif option=='separate':
list_dict_edge_year[i]={k:v for (k,v) in edge_yr.items() if v==min_year+i}
list_dict_node_year[i]={k:v for (k,v) in node_yr.items() if v<=min_year+i}
else:
raise Exception("wrong keyword for option. use accumulate or separate only")
print('Input Graph has',Graph.number_of_nodes(),'nodes and',Graph.number_of_edges(),'edges')
H=[nx.Graph() for i in range(n_year)]
if option=='accumulate':
for i in range(n_year):
if connected=='no':
H[i]=nx.subgraph(Graph,list(list_dict_node_year[i].keys()))
elif connected=='yes':
H[i]=nx.subgraph(Graph,list(list_dict_node_year[i].keys()))
H[i]=max(nx.connected_component_subgraphs(H[i]), key=len)
#H[i].add_nodes_from(list(list_dict_node_year[i].keys()))
#H[i].add_edges_from(list(list_dict_edge_year[i].keys()))
else:
raise Exception("wrong keyword for connected. use yes or no only")
print('Year:',str(i+min_year),'--',H[i].number_of_nodes(),'nodes --',H[i].number_of_edges(),'edges')
elif option=='separate':
for i in range(n_year):
if connected=='no':
H[i]=nx.subgraph(Graph,list(list_dict_node_year[i].keys()))
elif connected=='yes':
H[i]=nx.subgraph(Graph,list(list_dict_node_year[i].keys()))
H[i]=max(nx.connected_component_subgraphs(H[i]), key=len)
#H[i].add_nodes_from(list(list_dict_node_year[i].keys()))
#H[i].add_edges_from(list(list_dict_edge_year[i].keys()))
else:
raise Exception("wrong keyword for connected. use yes or no only")
print('Year:',str(i+min_year),'--',H[i].number_of_nodes(),'nodes --',H[i].number_of_edges(),'edges')
del node_yr, edge_yr, n_year, min_year, list_dict_edge_year, list_dict_node_year
gc.collect()
return H
def nxp(gen='C2H4.gen', ffield='ffield.json', nn='T', threshold=0.1):
atoms = read(gen)
atom_name = atoms.get_chemical_symbols()
nn_ = True if nn == 'T' else False
ir = IRFF_NP(atoms=atoms, libfile=ffield, rcut=None, nn=nn_)
# ir.get_pot_energy(atoms)
# ir.logout()
ir.calculate_Delta(atoms)
natom = ir.natom
g = nx.Graph()
g.clear()
color = {'C': 'grey', 'H': 'yellow', 'O': 'red', 'N': 'blue'}
size = {'C': 400, 'H': 150, 'O': 300, 'N': 300}
nodeColor = []
nodeSize = []
labels0, labels1 = {}, {}
for i in range(natom):
c = color[atom_name[i]]
s = size[atom_name[i]]
nodeColor.append(c)
nodeSize.append(s)
g.add_node(atom_name[i] + str(i))
labels0[atom_name[i] +
str(i)] = atom_name[i] + str(i) + ':%4.3f' % ir.Deltap[i]
labels1[atom_name[i] +
str(i)] = atom_name[i] + str(i) + ':%4.3f' % ir.Delta[i]
edgew = []
for i in range(natom - 1):
for j in range(i + 1, natom):
if ir.r[i][j] < ir.r_cut[i][j]:
if ir.bop[i][j] >= threshold:
g.add_edge(atom_name[i] + str(i),
atom_name[j] + str(j),
BO0='%5.4f' % ir.bop[i][j])
edgew.append(2.0 * ir.bop[i][j])
pos = {} # pos = nx.spring_layout(g)
for i, a in enumerate(atoms):
pos[atom_name[i] + str(i)] = [a.x, a.y]
nx.draw(g,
pos,
node_color=nodeColor,
node_size=nodeSize,
width=edgew,
with_labels=False)
edge_labels = nx.get_edge_attributes(g, 'BO0')
nx.draw_networkx_edge_labels(g, pos, labels=edge_labels, font_size=8)
# nx.draw_networkx_labels(g,pos,labels=labels0,font_size=8)
plt.savefig('%s_bo0.eps' % gen.split('.')[0])
plt.close()
g = nx.Graph()
g.clear()
for i in range(natom):
g.add_node(atom_name[i] + str(i))
edgew = []
for i in range(natom - 1):
for j in range(i + 1, natom):
if ir.r[i][j] < ir.r_cut[i][j]:
if ir.bo0[i][j] >= threshold:
g.add_edge(atom_name[i] + str(i),
atom_name[j] + str(j),
BO1='%5.4f' % ir.bo0[i][j])
edgew.append(2.0 * ir.bo0[i][j])
nx.draw(g,
pos,
node_color=nodeColor,
node_size=nodeSize,
width=edgew,
with_labels=False)
edge_labels = nx.get_edge_attributes(g, 'BO1')
nx.draw_networkx_edge_labels(g, pos, labels=edge_labels, font_size=8)
# nx.draw_networkx_labels(g,pos,labels=labels1,font_size=8)
plt.savefig('%s_bo1.eps' % gen.split('.')[0])
plt.close()
ir.close()
def getWeymouthConst(self, arc):
weymouth = nx.get_edge_attributes(self.G, 'weymouth')
return float(weymouth[arc])
def getArcLength(self, arc):
length = nx.get_edge_attributes(self.G, 'length')
return float(length[arc])
def getArcName(self, arc):
name = nx.get_edge_attributes(self.G, 'name')
return name[arc]
def algo(G1, COST0,met=False,**kwds):
G=nx.Graph()
K,A,B,hmax,hmin=COST0[0],COST0[1],COST0[2],COST0[3],COST0[4]
if met == True:
G=nx.Graph()
j=nx.erdos_renyi_graph(G1,1)
for i in j.edges():
r=list(i)
e=np.random.random_integers(0,150)
G.add_edge(r[0],r[1],weight=e)
print ('edges, nodes','=',nx.number_of_edges(G),nx.number_of_nodes(G))
else:
G=G1;
print ('ENTRAN_GRA(e,n)=',len(G.edges()),len(G.nodes()))
InG,G,no_in=Grafo_inicial(G,hmax)
print ('no_in =',no_in)
"""nx.draw(InG)
plt.show()
no_in = [1,8]
for i in no_in:
try:
print i,InG.neighbors(i)
except nx.exception.NetworkXError:
pass"""
#print G.neighbors(31)
COVERh=nx.Graph()
COVERh.add_nodes_from(G)
COMPh=nx.number_connected_components(COVERh)
inf=m.factorial(10)
u=nx.get_edge_attributes(G,'weight')
print ('edges, nodes','=',nx.number_of_edges(G),nx.number_of_nodes(G))
def c(h):
if h <= 5:
costo=K*h*0.1
elif h <= hmin and h > 5:
costo=K
elif h<(hmax) and h > hmin:
costo=(A*h)+B
else:
costo=inf
return costo
def c_1(ci):
if ci > (c(hmin)):
l=np.ceil((ci-B)/A)
elif ci>(c(5)) and ci <=(c(hmin)):
l=hmin
else:
l=ci/(K*0.1)
return l
def beta(n1,n2,d):
try:
aux=(2.0*(u[(n1,n2)]))
except (IndexError, KeyError):
aux=(2.0*(u[(n2,n1)]))
HI=h[n1]+h[n2]+d
if HI<aux:
B =aux-HI
else:
B=0
return B
def nbrfun(n,d):
p=[]
r=set()
for i in range(0,nx.number_connected_components(COVERh)):
subgraph=(list(nx.connected_component_subgraphs(COVERh)))
p.append(subgraph[i])
for o in p[i].nodes():
if o==n:
r=set(G.neighbors(n)) - set(p[i].neighbors(n))
r=list(r)
L=[]
l=[]
for i in range(0,len(r)):
beTa=beta(n,r[i],d)
G.add_node(r[i],hinc=beTa)
G.add_node(r[i],cinc=(c(beTa + h[r[i]])- c(h[r[i]])))
l.append((r[i],(c(beTa+ h[r[i]])-c(h[r[i]]))))
l=dict(l)
va=l.values()
vk=list(l.keys())
Li=[]
va = list(va)
while len(va)>0:
mi=np.min(va)
#retirar valor minimo
d=va.index(mi)
L.append(vk[d])
vk.remove(vk[d])
va.remove(va[d])
va=[]
for i in range(0,nx.number_connected_components(COVERh)):
ri=list(set(L) & set(p[i].nodes()))
u=inf
for j in range(0,len(ri)):
if L.index(ri[j])< u:
try:
L.remove(L[u])
break
except (IndexError):
pass
u = L.index(ri[j])
return r, L
def START_TC_ALGO( h, n, dirac):
G.add_node(n,hinc=(dirac))
G.add_node(n,cinc=c(h[n]+dirac)-c(h[n]))
nbr, L= nbrfun(n,dirac)
rbest, kbest=inf,0
for k in range(1,len(L)+1):
sum=0
for i in range(0,k):
sum= (G.node[L[i]]['cinc'])+sum
rtemp= ((G.node[n]['cinc']) + sum)/(k)
if rtemp < rbest:
kbest,rbest=k,rtemp
L=L[:kbest]
ri=list(set(G.nodes()) - set(L))
for i in ri:
if i==n:
pass
else:
G. add_node(i,hinc=0)
incr= nx.get_node_attributes(G,'hinc')
return rbest,incr, L
for n in G.nodes():
G.add_node(n,hi=0)
for n in InG.nodes():
InG.add_node(n,hi=0)
while COMPh > 1:
rbest=inf
for n in G.nodes():
h=nx.get_node_attributes(G,'hi')
chn=c(h[n])
i,e=1,(c_1(chn+ 1))
H=[h[n],hmax]
while e < hmax:
H.append(e)
e= c_1(chn + (i))
i=i+1
for i in range(0, len(H)):
a=(H[i]-h[n])
if a<0:a=0
rtmp,incrtmp, mayl=START_TC_ALGO(h,n,a)
if (rtmp < rbest):
nodo,rbest,incrbest, mayL=n,rtmp,incrtmp, mayl
#print incrbest,nodo,mayL,rbest
for i in incrbest.keys():
for j in range (0,len(mayL)):
if (incrbest[i] >= 0) and (i==mayL[j]):
COVERh.add_edge(nodo,i)
for i in G.nodes():
G.add_node(i,hi=h[i]+incrbest[i])
COMPh=nx.number_connected_components(COVERh)
costo =0
for n in G.nodes():
costo=costo+(c(G.node[n]['hi']))
T=nx.minimum_spanning_tree(G)
u1 =nx.get_edge_attributes(T,'weight')
for n in T.nodes():
T.node[n]['hi']=0
for n in T.edges():
r=list(n)
aux=T.node[r[0]]['hi']+T.node[r[1]]['hi']
aux1=(2* u1[n])
if aux< aux1:
T.node[r[0]]['hi']=T.node[r[0]]['hi']+((aux1-aux)/2.0)
T.node[r[1]]['hi']=T.node[r[1]]['hi']+((aux1-aux)/2.0)
costo1 =0
for n in T.nodes():
costo1=costo1+(c(T.node[n]['hi']))
InGr=nx.Graph()
InGr.add_nodes_from(InG.nodes())
InGr.add_edges_from(COVERh.edges())
uw =nx.get_edge_attributes(COVERh,'weigth')
nw =nx.get_node_attributes(G,'hi')
u1 =nx.get_edge_attributes(T,'weight')
nx.set_node_attributes(InGr,nw,'hi')
print ('COVERh','=',nx.number_of_edges(COVERh),nx.number_of_nodes(COVERh))
print ('T','=',nx.number_of_edges(T),nx.number_of_nodes(T))
print ('COVERh','=',(nx.get_node_attributes(G,'hi')))
print ('T','=',(nx.get_node_attributes(T,'hi')))
print ('COVERh ed=',COVERh.edges())
print ('T ed=',T.edges())
return costo,costo1, InG,InGr, T
def spatial_points_merge(graph: GeoGraph,
points_gdf: gpd.GeoDataFrame,
inplace=False,
merge_direction="both",
node_filter=no_filter,
edge_filter=no_filter,
intersection_nodes_attr=None,
discretization_tol=None) -> GeoGraph:
"""Merge given points as node with a spatial merge. Points are projected on the closest edge of the
graph and an intersection node is added if necessary. If two nodes a given point and a node have the same name, with
equal coordinates, then the node is considered as already in the graph. A discretization tolerance is used for
indexing edges lines. New nodes created from the geodataframe have attributes described by other columns (except if
an attribute value is `nan`). When a point is projected on an edge, this edge is removed and replaced by two others
that connect the extremities to the intersection node. A reference to the original edge is kept on theses new edges
with the attribute ``settings.ORIGINAL_EDGE_KEY``. The original edge is the oldest parent of the new edge, to have
the direct parent, the attribute has to be cleant first.
Parameters
----------
graph : GeoGraph, GeoDiGraph, GeoMultiGraph or GeoMultiDiGraph
A GeoGraph or derived class describing a spatial graph.
points_gdf : gpd.GeoDataFrame
A list of point describing new nodes to add.
inplace : bool
If True, do operation inplace and return None. (Default value = False)
merge_direction : str
For directed graphs only:
* ``'both'``: 2 edges are added: graph -> new node and new node -> graph
* ``'in'``: 1 edge is added: new_node -> graph
* ``'out'``: 1 edge is added: graph -> new_node (Default value = "both")
node_filter :
A node filter (lambda) to exclude nodes (and by the way all concerned edges) from the projection
operation. (Default value = no_filter)
edge_filter :
An edge filter (lambda) to exclude edges on which the projection will not take place. (Default value = no_filter)
intersection_nodes_attr : dict
A dictionary of attributes (constant for all added intersection nodes). (Default value = None)
discretization_tol: float
A custom discretization tolerance for lines. If None, tolerance with the right order of magnitude is
pre-defined for some CRS. For more details, see ``gnx.get_default_discretization_tolerance`` method.
(Default value = None)
Returns
-------
None or GeoGraph
If not inplace, the created graph.
See Also
--------
spatial_graph_merge gnx.get_default_discretization_tolerance
"""
if not inplace:
graph = graph.copy()
# 1. Find closest edge for each point
graph_view = nx.graphviews.subgraph_view(graph,
filter_node=node_filter,
filter_edge=edge_filter)
edges_as_lines = nx.get_edge_attributes(graph_view,
graph.edges_geometry_key)
if len(edges_as_lines) == 0:
raise ValueError(
"No edge geometry has been found in the given merging edges, at least one edge geometry is"
" required for a merge operation")
points = points_gdf.geometry
points_coords = np.array([[p.x, p.y] for p in points])
if discretization_tol is None:
discretization_tol = get_default_discretization_tolerance(graph.crs)
lines_indexes = get_closest_line_from_points(points_coords,
edges_as_lines.values(),
discretization_tol)
edges_to_split = defaultdict(dict)
# Add node, intersection node and edge (node, intersection node)
for p, p_index, point in zip(range(len(points_gdf)), points_gdf.index,
points):
# 1.1 Add given node
if p_index in graph.nodes:
if coordinates_almost_equal([point.x, point.y],
graph.get_node_coordinates(p_index)):
continue
else:
node_name = get_new_node_unique_name(graph, p_index)
else:
node_name = p_index
node_info = {
c: points_gdf.at[p_index, c]
for c in points_gdf.columns
if not is_nan(points_gdf.at[p_index, c])
}
node_info[graph.nodes_geometry_key] = point
graph.add_node(node_name, **node_info)
# 1.2 Add projected node if necessary
closest_edge_name = list(edges_as_lines.keys())[lines_indexes[p]]
closest_line = edges_as_lines[closest_edge_name]
closest_line_length = closest_line.length
intersection_distance_on_line = closest_line.project(point)
# if the intersection point is on the edge
if 0 < intersection_distance_on_line < closest_line_length:
projected_point = closest_line.interpolate(
intersection_distance_on_line)
intersection_node_name = get_new_node_unique_name(
graph, settings.INTERSECTION_PREFIX + str(p_index))
intersection_node_info = {
graph.nodes_geometry_key: projected_point
}
if intersection_nodes_attr is not None:
intersection_node_info.update(intersection_nodes_attr)
graph.add_node(intersection_node_name, **intersection_node_info)
# Store line to modify
edges_to_split[closest_edge_name][
intersection_node_name] = intersection_distance_on_line
else: # if the intersection point is on of the two edge extremities
first_node = closest_edge_name[0]
first_node_point = graph.nodes[first_node][
graph.nodes_geometry_key]
second_node = closest_edge_name[1]
second_node_point = graph.nodes[second_node][
graph.nodes_geometry_key]
distance_to_first_extremity = euclidian_distance(
point, first_node_point)
distance_to_second_extremity = euclidian_distance(
point, second_node_point)
if distance_to_first_extremity < distance_to_second_extremity:
intersection_node_name = first_node
else:
intersection_node_name = second_node
# 1.3 Add edge : node <-> intersection_node
in_edge_data = {
graph.edges_geometry_key:
LineString([
graph.get_node_coordinates(node_name),
graph.get_node_coordinates(intersection_node_name)
])
}
if graph.is_directed():
out_edge_data = {
graph.edges_geometry_key:
LineString([
graph.get_node_coordinates(intersection_node_name),
graph.get_node_coordinates(node_name)
])
}
if merge_direction == "both":
graph.add_edge(node_name, intersection_node_name,
**in_edge_data)
graph.add_edge(intersection_node_name, node_name,
**out_edge_data)
elif merge_direction == "in":
graph.add_edge(node_name, intersection_node_name,
**in_edge_data)
else: # "out"
graph.add_edge(intersection_node_name, node_name,
**out_edge_data)
else:
graph.add_edge(node_name, intersection_node_name, **in_edge_data)
# 2. Split edges where a node have been projected
for e in edges_to_split:
intersection_nodes = edges_to_split[e]
if len(intersection_nodes) > 0:
initial_line = edges_as_lines[e]
# 2.1 remove initial edge and keep in memory the original edge
original_edge_data = {
settings.ORIGINAL_EDGE_KEY:
graph.edges[e].get(settings.ORIGINAL_EDGE_KEY, e)
}
if graph.has_edge(*e):
graph.remove_edge(*e)
# 2.2 cut the initial line
sorted_intersection_nodes = sorted(
intersection_nodes.keys(), key=lambda n: intersection_nodes[n])
distances_on_initial_line = [
intersection_nodes[n] for n in sorted_intersection_nodes
]
split_lines = []
cut_lines = split_line(initial_line, distances_on_initial_line[0])
split_lines.append(cut_lines[0])
for i in range(len(sorted_intersection_nodes) - 1):
cut_lines = split_line(
cut_lines[1], distances_on_initial_line[i + 1] -
distances_on_initial_line[i])
split_lines.append(cut_lines[0])
split_lines.append(cut_lines[1])
# 2.2 add intermediary edges
oriented_edge = get_line_ordered_edge(graph, e, initial_line)
first_edge_data = {
graph.edges_geometry_key: split_lines[0],
**original_edge_data
}
graph.add_edge(oriented_edge[0], sorted_intersection_nodes[0],
**first_edge_data)
last_edge_data = {
graph.edges_geometry_key: split_lines[-1],
**original_edge_data
}
graph.add_edge(sorted_intersection_nodes[-1], oriented_edge[1],
**last_edge_data)
for i in range(len(sorted_intersection_nodes) - 1):
edge_data = {
graph.edges_geometry_key: split_lines[i + 1],
**original_edge_data
}
graph.add_edge(sorted_intersection_nodes[i],
sorted_intersection_nodes[i + 1], **edge_data)
if not inplace:
return graph
G.add_edge(7, 10, length = 40) G.add_edge(9, 1, length = 50) G.add_edge(9, 11, length = 30) G.add_edge(9, 12, length = 40) G.add_edge(10, 12, length = 30) G.add_edge(10, 1, length = 40) G.add_edge(11, 1, length = 30) G.add_edge(11, 2, length = 40) G.add_edge(12, 2, length = 30) G.add_edge(1, 2, length = 30) path =nx.shortest_path (G, 7, 2, weight = 'length') path_length=nx.shortest_path_length(G,7,2,weight='length') print(path) print(path_length) # draw the graph edge_labels = nx.get_edge_attributes(G,'length') pos = nx.spring_layout(G) nx.draw_networkx_edge_labels(G, pos, edge_labels = edge_labels) nx.draw_networkx(G, pos) plt.show()
def plotMCWandGraph(X,
fs,
W,
remove_self_loops=True,
title=None,
save_path=None):
"""Plots the corresponding weighted undirected or directed graph topology
of the given adjacency matrix together with the corresponding multi-channel window
Parameters
----------
X : numpy array
Multi-channel window of shape (num_channels, num_samples)
fs : float
Sampling frequency
W : numpy array
Adjacency matrix with shape (L, L). Currently, this function only
supports L=8
remove_self_loops : bool, optional
if True, remove self loops in the graph, by default True
title : str, optional
Title of the plotted graph topology, by default None
"""
fig = plt.figure(facecolor="w", figsize=(12, 4))
ax1 = fig.add_subplot(121)
ax = fig.add_subplot(122)
## plot the mutli-channel signals
num_channels = X.shape[0]
num_samples = X.shape[1]
max_val = np.max(X)
node_colors = plt.cm.rainbow(np.linspace(0, 1, num_channels))
t = np.arange(0, num_samples, 1) / fs
ytick_pos = []
for i, c in zip(range(num_channels), node_colors):
y = X[i] + max_val * 1.5 * i
ax1.plot(t, y, c=c)
ytick_pos.append(np.min(y))
i += 1
ax1.set_yticks(ytick_pos)
ax1.set_yticklabels(
["CH1", "CH2", "CH3", "CH4", "CH5", "CH6", "CH7", "CH8"])
ax1.set_xlabel("time (s)")
if title is not None:
ax1.set_title("Multi-Channel Window - {}".format(title))
else:
ax1.set_title("Multi-Channel Window")
ax1.grid()
## plot the graph
if np.allclose(W, W.T):
graphIsDirected = False
else:
graphIsDirected = True
if remove_self_loops:
np.fill_diagonal(W, 0)
m = W.shape[0]
pos = getEllipticalCoordinates()
if graphIsDirected:
## plot directed weighted graph
G = nx.DiGraph()
for i in range(0, m):
for j in range(0, m):
G.add_edge(i + 1, j + 1, weight=W[i, j])
weights = list(nx.get_edge_attributes(G, 'weight').values())
weightColors = (weights - min(weights)) / (max(weights) - min(weights))
# plot the graph
nx.draw_networkx_nodes(G,
pos,
with_labels=True,
node_color=node_colors,
ax=ax)
nx.draw_networkx_edges(G,
pos,
arrows=True,
arrowsize=20,
arrowstyle='-|>',
width=2,
edge_color=weightColors,
edge_cmap=plt.cm.Greys,
edge_vmin=min(weightColors),
edge_vmax=max(weightColors),
connectionstyle='arc3, rad = 0.1',
ax=ax)
nx.draw_networkx_labels(G, pos)
# add colorbar
norm = mpl.colors.Normalize(vmin=min(weights), vmax=max(weights))
weightMap = plt.cm.ScalarMappable(cmap=plt.cm.Greys, norm=norm)
plt.axis('on')
plt.colorbar(weightMap)
if title is not None:
plt.title(title)
plt.show()
else:
## plot unidrected weighted graph
G = nx.Graph()
for i in range(0, m):
for j in range(0, m):
G.add_edge(i + 1, j + 1, weight=W[i, j])
weights = list(nx.get_edge_attributes(G, 'weight').values())
weightWidths = (weights - min(weights)) / (max(weights) -
min(weights)) * 5
weightColors = (weights - min(weights)) / (max(weights) - min(weights))
# plot the graph
nx.draw(G,
pos,
width=weightWidths,
with_labels=True,
edge_color=weightColors,
edge_cmap=plt.cm.Greys,
edge_vmin=min(weightColors),
edge_vmax=max(weightColors),
node_color=node_colors,
ax=ax)
## add a colorbar
norm = mpl.colors.Normalize(vmin=min(weights), vmax=max(weights))
weightMap = plt.cm.ScalarMappable(cmap=plt.cm.Greys, norm=norm)
plt.axis('on')
plt.colorbar(weightMap)
if title is not None:
plt.title("Graph - {}".format(title))
else:
plt.title("Graph")
if save_path is not None:
plt.savefig(save_path)
else:
plt.show()
def createWeightedGraph(W, remove_self_loops=True, title=None):
"""Plots the corresponding weighted undirecte or directed graph topology
of the given adjacency matrix.
Parameters
----------
W : numpy array
Adjacency matrix with shape (L, L). Currently, this function only
supports L=8
remove_self_loops : bool, optional
if True, remove self loops in the graph, by default True
title : str, optional
Title of the plotted graph topology, by default None
"""
if np.allclose(W, W.T):
graphIsDirected = False
else:
graphIsDirected = True
if remove_self_loops:
np.fill_diagonal(W, 0)
m = W.shape[0]
pos = getEllipticalCoordinates()
fig = plt.figure(facecolor="w")
ax = fig.add_subplot(111)
if graphIsDirected:
## plot directed weighted graph
G = nx.DiGraph()
for i in range(0, m):
for j in range(0, m):
G.add_edge(i + 1, j + 1, weight=W[i, j])
weights = list(nx.get_edge_attributes(G, 'weight').values())
weightColors = (weights - min(weights)) / (max(weights) - min(weights))
# plot the graph
nx.draw_networkx_nodes(G,
pos,
with_labels=True,
node_color='lightgreen',
ax=ax)
nx.draw_networkx_edges(G,
pos,
arrows=True,
arrowsize=20,
arrowstyle='-|>',
width=2,
edge_color=weightColors,
edge_cmap=plt.cm.Blues,
edge_vmin=min(weightColors),
edge_vmax=max(weightColors),
connectionstyle='arc3, rad = 0.1',
ax=ax)
nx.draw_networkx_labels(G, pos)
# add colorbar
norm = mpl.colors.Normalize(vmin=min(weights), vmax=max(weights))
weightMap = plt.cm.ScalarMappable(cmap=plt.cm.Blues, norm=norm)
plt.axis('on')
plt.colorbar(weightMap)
if title is not None:
plt.title(title)
plt.show()
else:
## plot unidrected weighted graph
G = nx.Graph()
for i in range(0, m):
for j in range(0, m):
G.add_edge(i + 1, j + 1, weight=W[i, j])
weights = list(nx.get_edge_attributes(G, 'weight').values())
weightWidths = (weights - min(weights)) / (max(weights) -
min(weights)) * 5
weightColors = (weights - min(weights)) / (max(weights) - min(weights))
# plot the graph
nx.draw(G,
pos,
width=weightWidths,
with_labels=True,
edge_color=weightColors,
edge_cmap=plt.cm.Blues,
edge_vmin=min(weightColors),
edge_vmax=max(weightColors),
node_color='lightgreen',
ax=ax)
## add a colorbar
norm = mpl.colors.Normalize(vmin=min(weights), vmax=max(weights))
weightMap = plt.cm.ScalarMappable(cmap=plt.cm.Blues, norm=norm)
plt.axis('on')
plt.colorbar(weightMap)
if title is not None:
plt.title(title)
plt.show()
def generateAttackGraph(self, network, demo=False):
"""
Building the attack graph of the network by a dict.
"""
plt.close()
counter = 0
sum = 0
G = nx.DiGraph()
attackerInitialNode = self.getAttackerInitialNode(network)
matrix = self.reachability.generateReachabilityMatrix(network)
attackerNodes = set()
attackerNodes.add(attackerInitialNode)
# currentAV = "network"
visitedNodes = list()
labeldict = {}
labeldict[attackerInitialNode] = attackerInitialNode.label
lastNode = None
while len(attackerNodes) > 0:
curNode = attackerNodes.pop()
lastNode = curNode
G.add_node(lastNode)
visitedNodes.append(curNode)
v1 = curNode.vulnerabilities
v1 = self.sortVul(v1)
for v in v1:
if demo is True:
vul = self.getVul(network["vulnerabilities"], v["id"])
else:
vul = v
if self.comparePriv(curNode.priv, vul.requires):
if self.comparePriv(vul.provides, curNode.priv):
curNode.priv = vul.provides
currentAV = vul.vector
G.add_node(vul)
weight = self.calcWeight(vul)
counter += 1
sum += weight
G.add_edge(lastNode, vul, weight=weight)
lastNode = vul
if vul.shortDesc != '':
labeldict[vul] = vul.shortDesc
else:
labeldict[vul] = vul.cve
destNodes = self.reachability.getReachableNodesFromNodes(
matrix, curNode, network["nodes"])
for n in destNodes:
v2 = n.vulnerabilities
for v in v2:
if demo is True:
vul = self.getVul(network["vulnerabilities"], v["id"])
else:
vul = v
# if Scanner.compareAV(currentAV,vul.vector):
if self.comparePriv("None",
vul.requires) or self.comparePriv(
curNode.priv, vul.requires):
# if self.comparePriv(vul.provides, n.priv):
n.priv = vul.provides
if vul.shortDesc != '':
labeldict[vul] = vul.shortDesc
else:
labeldict[vul] = vul.cve
G.add_node(vul)
weight = self.calcWeight(vul)
counter += 1
sum += weight
G.add_edge(lastNode, vul, weight=weight)
G.add_node(n)
G.add_edge(vul, n)
if n.label != '':
labeldict[n] = n.label
else:
labeldict[n] = n.name
if n not in visitedNodes:
attackerNodes.add(n)
pos = nx.spring_layout(G)
nx.draw(G, pos=pos, labels=labeldict, with_labels=True)
labels = nx.get_edge_attributes(G, 'weight')
nx.draw_networkx_edge_labels(G, pos, edge_labels=labels)
plt.savefig('Images//graph.png', format='PNG')
result = 0
if counter != 0:
result = sum / counter
answer = [result, G]
return answer
def getArcFlowMax(self, arc):
flowMax = nx.get_edge_attributes(self.G, 'flowMax')
return float(flowMax[arc])
def plot_nx_succession_diagram(G, pos=None, fig_dimensions=(None,None), nx_node_kwargs=None, nx_edge_kwargs=None,
draw_node_labels=True, labeling_convention='label', draw_edge_labels=False, nx_node_label_kwargs=None, nx_edge_label_kwargs=None):
"""Plot the input succession diagram. Requires matplotlib. For finer control
over plot appearance, it is recommended to plot g directly.
Parameters
----------
G : networkx.DiGraph
Labeled succession diagram, e.g., as is output from
export.networkx_succession_diagram_reduced_network_based().
fig_dimensions : (int,int)
Dimensions of the output figure. If (None,None), then the dimensions are
calculated based on the number of nodes in g (the default is (None,None)).
pos : str or graphviz_layout
Layout for the nodes; A dictionary with nodes as keys and positions as
values. Positions should be sequences of length 2. If none, we attempt to
use pydot/graphviz to construct a layout, otherwise we fall back to the
networkx planar_layout function (succession diagrams are always planar).
draw_node_labels : bool
Whether node labels should be drawn (True) or left as metadata (False)
(the default is True).
draw_edge_labels : bool
Whether edge labels should be drawn (True) or left as metadata (False);
only affects reduced-network-based (default) succession diagrams, not
motif-based succession diagrams. (The default value is False.)
labeling_convention : str
Whether edge labels should be just the stable motifs ('label') or all stabilized states ('states')
(the default is 'label').
nx_node_kwargs : dictionary
Keword arguments passed to nx.draw_networkx_nodes (in addition to G and pos).
If None, we pass {'node_size':50*G.number_of_nodes()} by default.
nx_edge_kwargs : dictionary
Keword arguments passed to nx.draw_networkx_edges (in addition to G and pos).
If None, we pass {'arrowstyle':'-|>','width':2,'arrowsize':30} by default.
nx_node_label_kwargs : dictionary
Keword arguments passed to nx.draw_networkx_labels (in addition to G and pos).
If None, we pass {'font_size':16} by default.
nx_edge_label_kwargs : dictionary
Keword arguments passed to nx.draw_networkx_edge_labels (in addition to G and pos).
If None, we pass {'font_size':16} by default.
"""
import matplotlib.pyplot as plt
if fig_dimensions == (None,None):
fig_dimensions=(2*(G.number_of_nodes()+2),G.number_of_nodes()+2)
if pos is None:
try:
from networkx.drawing.nx_agraph import graphviz_layout
pos = graphviz_layout(G, prog='dot')
except ImportError:
pos = nx.planar_layout(G)
plt.figure(figsize=fig_dimensions)
if nx_node_kwargs is None:
nx_node_kwargs = {'node_size':50*G.number_of_nodes()}
if nx_edge_kwargs is None:
nx_edge_kwargs = {'arrowstyle':'-|>','width':2,'arrowsize':30}
if nx_node_label_kwargs is None:
nx_node_label_kwargs = {'font_size':16}
if nx_edge_label_kwargs is None:
nx_edge_label_kwargs = {'font_size':16}
nx.drawing.draw_networkx_nodes(G, pos,**nx_node_kwargs)
nx.draw_networkx_edges(G, pos,**nx_edge_kwargs)
if draw_node_labels:
if labeling_convention=='label':
nx.drawing.draw_networkx_labels(G,pos, labels=dict(G.nodes('label')),**nx_node_label_kwargs)
else:
nx.drawing.draw_networkx_labels(G,pos, labels=dict(G.nodes('states')),**nx_node_label_kwargs)
if draw_edge_labels:
nx.drawing.draw_networkx_edge_labels(G,pos,edge_labels=nx.get_edge_attributes(G,'motif'),**nx_edge_label_kwargs)
plt.axis('off')
plt.show()
['Toronto', 'Calgary', 1500],
['Toronto', 'LA', 1800],
['Toronto', 'Chicago', 500],
['Denver', 'Urbana', 1000],
['Denver', 'Houston', 1500],
['Houston', 'LA', 1500],
['Denver', 'LA', 1000],],
columns = ['city1','city2','distance'])
# Construct a graph using MultiDiGraph from NetworkX library
G= nx.from_pandas_edgelist(df, 'city1', 'city2', edge_attr=['distance'],
create_using=nx.MultiDiGraph())
#print(len(G))
print(G.nodes())
print(G.edges(data=True))
# Draw the graph showing the City Names (Nodes) and Distances (Attributes)
edge_labels = nx.get_edge_attributes(G,'distance')
pos = nx.spring_layout(G)
nx.draw(G,pos, with_labels=True)
nx.draw_networkx_edge_labels(G,pos, labels = edge_labels)
#plt.show()
####################################################################################
# Start the algorithm by finding "NY" in the data frame (both city 1 and city2)
# Create the lists to store the information
# frontiers List is the list we are going to explore
# For this problem, we will set Origin = "NY", Destination = "LA"
Origin = 'Calgary'
Destination = 'Chicago'
frontiers = []
def edge_width(graph):
#assign edge width based on the score of the similarity between articles
edge_width = []
for key, value in nx.get_edge_attributes(graph, 'score').items():
edge_width.append(assign_thickness(value))
return edge_width
import matplotlib.pyplot as plt
import networkx as nx
import numpy as np
n = 50
G = nx.erdos_renyi_graph(n, 0.1, seed=None, directed=False)
pos = nx.spring_layout(G)
for u, v, d in G.edges(data=True):
d['weight'] = 1 + 10 * np.random.rand()
edges, weights = zip(*nx.get_edge_attributes(G, 'weight').items())
path = nx.shortest_path(G, source=0, target=G.number_of_nodes() - 1)
path_edges = set(zip(path, path[1:]))
nx.draw_networkx_nodes(G, pos, nodelist=path, node_color='r')
nx.draw_networkx_edges(G, pos, edgelist=path_edges, edge_color='r', width=10)
nx.draw(G,
pos,
node_color='b',
node_size=10,
edgelist=edges,
edge_color=weights,
width=2,
edge_cmap=plt.cm.Blues)
plt.show()
def entropy(G, sources=None, sinks=None):
"""
Compute entropy, equations from [1].
Entropy is a measure of uncertainty in a random variable.
In a water distribution network model, the random variable is
flow in the pipes and entropy can be used to measure alternate flow paths
when a network component fails. A network that carries maximum entropy
flow is considered reliable with multiple alternate paths.
Parameters
----------
G : NetworkX or WNTR graph
Entropy is computed using a directed graph based on pipe flow direction.
The 'weight' of each link is equal to the flow rate.
sources : list of strings, optional (default = all reservoirs)
List of node names to use as sources.
sinks : list of strings, optional (default = all nodes)
List of node names to use as sinks.
Returns
-------
S : dict
Node entropy, {node name: entropy value}
Shat : float
System entropy
Examples
--------
The following example computes entropy using Net3 flow directions at time 3600 s.
>>> inp_file = 'networks/Net3.inp'
>>> wn = wntr.network.WaterNetworkModel(inp_file)
>>> sim = wntr.sim.EpanetSimulator(wn)
>>> results = sim.run_sim()
>>> G = wn.get_graph_deep_copy()
>>> attr = results.link.loc['flowrate', 3600, :]
>>> G.weight_graph(link_attribute=attr)
>>> [S, Shat] = wntr.metrics.entropy(G)
>>> wntr.network.draw_graph(wn, node_attribute = S, title = 'Node entropy")
>>> Shat
4.05
References
-----------
[1] Awumah K, Goulter I, Bhatt SK. (1990). Assessment of reliability in
water distribution networks using entropy based measures. Stochastic
Hydrology and Hydraulics, 4(4), 309-320
"""
if G.is_directed() == False:
return
if sources is None:
sources = [
key for key, value in nx.get_node_attributes(G, 'type').items()
if value == 'reservoir'
]
if sinks is None:
sinks = G.nodes()
S = {}
Q = {}
for nodej in sinks:
if nodej in sources:
S[nodej] = 0 # nodej is the source
continue
sp = [] # simple path
if G.node[nodej]['type'] == 'junction':
for source in sources:
if nx.has_path(G, source, nodej):
simple_paths = _all_simple_paths(G, source, target=nodej)
sp = sp + ([p for p in simple_paths])
# all_simple_paths was modified to check 'has_path' in the
# loop, but this is still slow for large networks
# what if the network was skeletonized based on series pipes
# that have the same flow direction?
# what about duplicating paths that have pipes in series?
#print j, nodeid, len(sp)
if len(sp) == 0:
S[nodej] = np.nan # nodej is not connected to any sources
continue
sp = np.array(sp)
# Uj = set of nodes on the upstream ends of links incident on node j
Uj = G.predecessors(nodej)
# qij = flow in link from node i to node j
qij = []
# aij = number of equivalnet independent paths through the link from node i to node j
aij = []
for nodei in Uj:
mask = np.array([nodei in path for path in sp])
# NDij = number of paths through the link from node i to node j
NDij = sum(mask)
if NDij == 0:
continue
temp = sp[mask]
# MDij = links in the NDij path
MDij = [(t[idx], t[idx + 1]) for t in temp
for idx in range(len(t) - 1)]
flow = 0
for link in G[nodei][nodej].keys():
flow = flow + G[nodei][nodej][link]['weight']
qij.append(flow)
# dk = degree of link k in MDij
dk = Counter()
for elem in MDij:
# divide by the numnber of links between two nodes
dk[elem] += 1 / len(G[elem[0]][elem[1]].keys())
aij.append(
NDij *
(1 - float(sum(np.array(dk.values()) - 1)) / sum(dk.values())))
Q[nodej] = sum(qij) # Total flow into node j
# Equation 7
S[nodej] = 0
for idx in range(len(qij)):
if qij[idx] / Q[nodej] > 0:
S[nodej] = S[nodej] - \
qij[idx]/Q[nodej]*math.log(qij[idx]/Q[nodej]) + \
qij[idx]/Q[nodej]*math.log(aij[idx])
Q0 = sum(nx.get_edge_attributes(G, 'weight').values())
# Equation 3
Shat = 0
for nodej in sinks:
if not np.isnan(S[nodej]):
if nodej not in sources:
if Q[nodej] / Q0 > 0:
Shat = Shat + \
(Q[nodej]*S[nodej])/Q0 - \
Q[nodej]/Q0*math.log(Q[nodej]/Q0)
return [S, Shat]
def max_flow(id):
G = read_dot(
r"C:\Users\Charun\Desktop\CSC301-Assignment6\input_graphs\input_" +
str(id) + r".dot")
my_source = list(G.nodes)[0]
my_sink = list(G.nodes)[-1]
def my_build_residual_network(G, capacity):
R = nx.DiGraph()
R.add_nodes_from(G)
inf = float('inf')
# Extract edges with positive capacities. Self loops excluded.
edge_list = [
(u, v, attr) for u, v, attr in G.edges(data=True)
if u != v and float(attr.get(capacity, inf).replace('"', '')) > 0
]
inf = 3 * sum(
float(attr[capacity].replace('"', ''))
for u, v, attr in edge_list if capacity.replace('"', '') in attr
and attr[capacity] != inf) or 1
if G.is_directed():
for u, v, attr in edge_list:
r = min(float(attr.get(capacity, inf).replace('"', '')), inf)
if not R.has_edge(u, v):
# Both (u, v) and (v, u) must be present in the residual
# network.
R.add_edge(u, v, capacity=r)
R.add_edge(v, u, capacity=0)
else:
# The edge (u, v) was added when (v, u) was visited.
R[u][v]['capacity'] = r
else:
for u, v, attr in edge_list:
# Add a pair of edges with equal residual capacities.
r = min(attr.get(capacity, inf), inf)
R.add_edge(u, v, capacity=r)
R.add_edge(v, u, capacity=r)
# Record the value simulating infinity.
R.graph['inf'] = inf
return R
def my_edmonds_karp(G,
s,
t,
capacity='capacity',
residual=None,
value_only=False,
cutoff=None):
R = my_edmonds_karp_impl(G, s, t, capacity, residual, cutoff)
return R
def my_edmonds_karp_impl(G, s, t, capacity, residual, cutoff):
if s not in G:
raise Exception('source not in graph')
if t not in G:
raise Exception('sink not in graph')
if s == t:
raise Exception('source and sink need to be different nodes')
if residual is None:
R = my_build_residual_network(G, capacity)
else:
R = residual
for u in R:
for edge in R[u].values():
edge['flow'] = 0
if cutoff is None:
cutoff = float('inf')
R.graph['flow_value'] = my_edmonds_karp_core(R, s, t, cutoff)
return R
def my_edmonds_karp_core(R, s, t, cutoff):
residual_nodes = R.nodes
residual_pred = R.pred
residual_succ = R.succ
inf = R.graph['inf']
def augment(path):
flow = inf
my_iter = iter(path)
u = next(my_iter)
for v in my_iter:
attribute = residual_succ[u][v]
flow = min(flow, attribute['capacity'] - attribute['flow'])
u = v
my_iter = iter(path)
u = next(my_iter)
for v in my_iter:
residual_succ[u][v]['flow'] += flow
residual_succ[v][u]['flow'] -= flow
u = v
return flow
def bfs():
predecessor = {s: None}
queue_s = [s]
successor = {t: None}
queue_t = [t]
while True:
queue = []
if len(queue_s) <= len(queue_t):
for u in queue_s:
for v, attribute in residual_succ[u].items():
if v not in predecessor and attribute[
'flow'] < attribute['capacity']:
predecessor[v] = u
if v in successor:
return v, predecessor, successor
queue.append(v)
if not queue:
return None, None, None
queue_s = queue
else:
for u in queue_t:
for v, attribute in residual_pred[u].items():
if v not in successor and attribute[
'flow'] < attribute['capacity']:
successor[v] = u
if v in predecessor:
return v, predecessor, successor
queue.append(v)
if not queue:
return None, None, None
queue_t = queue
flow_value = 0
while flow_value < cutoff:
v, predecessor, successor = bfs()
if predecessor is None:
break
path = [v]
u = v
while u != s:
u = predecessor[u]
path.append(u)
path.reverse()
u = v
while u != t:
u = successor[u]
path.append(u)
flow_value += augment(path)
return flow_value
R = my_edmonds_karp(G, my_source, my_sink)
print(R.graph['flow_value'])
flow_attr = nx.get_edge_attributes(R, 'flow')
# remove non-participating edges
for k, v in flow_attr.items():
if float(v) <= 0:
R.remove_edge(k[0], k[1])
flow_attr = nx.get_edge_attributes(R, 'flow')
cap_attr = nx.get_edge_attributes(R, 'capacity')
labels = {}
for (k1, v1), (k2, v2) in zip(flow_attr.items(), cap_attr.items()):
labels[k1] = str(v1) + "/" + str(v2)
# Remove non participating nodes
for final_node in list(R.nodes):
if R.degree[final_node] == 0:
R.remove_node(final_node)
write_dot(
R,
r"C:\Users\Charun\Desktop\CSC301-Assignment6\output_graphs\output_" +
str(id) + r".dot")
pos = nx.spring_layout(R)
nx.draw(R, pos, with_labels=True)
nx.draw_networkx_edge_labels(R, pos, edge_labels=labels)
plt.savefig(
r"C:\Users\Charun\Desktop\CSC301-Assignment6\output_graphs\output_" +
str(id) + r".png")
plt.close()
G.clear()
R.clear()
def getArcDiameter(self, arc):
diameter = nx.get_edge_attributes(self.G, 'diameter')
return float(diameter[arc])
(n[0], n[3], 9), \
(n[1], n[2], 3), \
(n[1], n[4], 2), \
(n[3], n[5], 7), \
(n[2], n[6], 2), \
(n[2], n[5], 4), \
(n[5], n[6], 2), \
(n[4], n[6], 1), \
(n[6], n[7], 2),
(n[5], n[7], 5), }
G.add_nodes_from(nodes_labels)
G.add_weighted_edges_from(edges)
k = 1 / sqrt(5)
pos = nx.spring_layout(G, k=k, iterations=20, scale=0.8) #CHANGE FOR OVERLAPS
edges_labels = nx.get_edge_attributes(G, 'weight')
status = nx.info(G)
print(status)
print('Sortest path lenght = ',
nx.shortest_path_length(G, source=n[0], target=n[7], weight='weight'))
nx.draw(G, pos, with_labels=True)
path = nx.shortest_path(G, source=n[0], target=n[7], weight='weight')
path_edges = list(zip(path, path[1:]))
nx.draw_networkx_nodes(G, pos, nodelist=path, node_color='y')
nx.draw_networkx_edges(G, pos, edgelist=path_edges, edge_color='r', width=2)
nx.draw_networkx_edge_labels(G, pos, edge_labels=edges_labels)
plt.axis('equal')
plt.show()
def __get_edge_label_num(self, edge_label):
el = set()
for G in self.__graphs:
el = el | set(nx.get_edge_attributes(G, edge_label).values())
return len(el)
def get(self):
args = parser.parse_args()
print(args)
# todo remove this "hack"
concepts = config['concepts']['list']
target = config['concepts']['target']
query = """
copy (select positive, negative, """ + ", ".join(
concepts
) + """ from stream_events where spam is null and creation_time between to_timestamp(%s) and to_timestamp(%s))
to '/tmp/stream_events_classes.csv' with (format csv, header)
"""
cur = pg_conn.cursor()
# cur.execute(query, args['date_from'], args['date_to'])
cur.close()
df_no_spam = pd.read_csv("/tmp/stream_events_classes.csv")
for column in df_no_spam:
df_no_spam[column] = df_no_spam[column].map(
lambda x: x if pd.isna(x) else column)
tuples = []
for x in df_no_spam.itertuples():
t = []
for y in x[1:]:
if not pd.isna(y):
t.append(y)
if len(t):
tuples.append(tuple(sorted(t)))
tuples_len = len(tuples)
weights = dict()
weights[target] = 0
for c in concepts:
weights[c] = 0
itemsets, rules = apriori(tuples,
min_support=0.0001,
min_confidence=0.001)
if 'weights' not in args or args['weights'] is None:
args['weights'] = "{}"
parsed_weights = json.loads(args['weights'])
for c in weights:
if c not in parsed_weights:
continue
weights[c] = float(parsed_weights[c])
def activation(x, derivative=False):
return np.tanh(x) # x*(1-x) if derivative else 1/(1+np.exp(-x))
DG = nx.DiGraph()
DG.add_node(target)
print(nx.get_node_attributes(DG, target))
count_dict = itemsets[2]
concept_values = dict({target: 0})
for conc in concepts:
concept_values[conc] = 0
tneg = tuple(sorted([conc, 'negative']))
tpos = tuple(sorted([conc, 'positive']))
if tpos in count_dict:
concept_values[conc] += count_dict[tpos] / tuples_len
if tneg in count_dict:
concept_values[conc] -= count_dict[tneg] / tuples_len
DG.add_node(conc)
DG.add_weighted_edges_from([(conc, target, weights[conc])])
print("initial:", concept_values)
nx.set_node_attributes(DG, concept_values, 'cv')
EPOCHS = args['max_iters']
DGtmp = DG.copy()
DGresult = DG.copy()
tmp_concepts = concept_values.copy()
concepts_changes = dict()
for c in concept_values:
concepts_changes[c] = []
effective_iters = 0
for epoch in range(100):
old_cv = nx.get_node_attributes(DGresult, 'cv')
for c, inners in DGresult.pred.items():
tmp_concepts[c] = activation(old_cv[c] + np.sum([
old_cv[factor_conc] * fc_weight['weight']
for factor_conc, fc_weight in inners.items()
]))
concepts_changes[c].append(tmp_concepts[c])
nx.set_node_attributes(DGresult, tmp_concepts, 'cv')
effective_iters += 1
labels = nx.get_node_attributes(DGresult, 'cv')
for l, v in labels.items():
labels[l] = "{0} {1:.4f}".format(l, v)
res_cv = nx.get_node_attributes(DGresult, 'cv')
pos = nx.spring_layout(DGresult)
plt.clf()
cf = plt.gcf()
cf.set_size_inches(18, 10)
ax = cf.gca()
for c, inners in DGresult.pred.items():
nx.draw_networkx_nodes(DGresult,
pos,
nodelist=[c],
labels=labels,
node_color="blue",
node_size=500,
alpha=0.5,
ax=ax)
for inner in inners:
edge_color = 'red' if res_cv[inner] < 0 else 'green'
nx.draw_networkx_edges(DGresult,
pos,
edgelist=[(inner, c)],
width=3,
alpha=0.3,
edge_color=edge_color,
ax=ax)
nx.draw_networkx_labels(DGresult, pos, labels, font_size=10)
weight_edge_labels = nx.get_edge_attributes(DGresult, 'weight')
nx.draw_networkx_edge_labels(DGresult,
pos,
edge_labels=weight_edge_labels)
graph_img = 'static/images/plot.png'
# nx.draw(DGresult, with_labels=True, labels=labels, node_color='lightblue', weight=True, font_weight='normal')
plt.savefig(graph_img, format="PNG", dpi=100)
plt.clf()
conv_img = 'static/images/conv.png'
linspace = [i for i in range(effective_iters)]
for c in concepts_changes:
plt.plot(linspace, concepts_changes[c], label=c)
plt.legend()
plt.savefig(conv_img, format="PNG", dpi=100)
return {
'data': [
'http://116.203.70.12:8000/' + graph_img.split("/")[2],
'http://116.203.70.12:8000/' + conv_img.split("/")[2]
]
}, 200, {
'Access-Control-Allow-Origin': '*'
}
def getArcCost(self, arc):
cost = nx.get_edge_attributes(self.G, 'cost')
return float(cost[arc])
def run_iteration(G, test=False):
weight = nx.get_edge_attributes(G, "weight")
S_n = [n for n, v in G.nodes(data=True) if v['status'] == 'S']
E_n = [n for n, v in G.nodes(data=True) if v['status'] == 'E']
I_n = [n for n, v in G.nodes(data=True) if v['status'] == 'I']
H_n = [n for n, v in G.nodes(data=True) if v['status'] == 'H']
for i in I_n:
for neighbor in G.neighbors(i):
if G.nodes[neighbor]["status"] == "S":
# Multiplying by the weight of the edge is supposed to model decreased
# contact after a person is in quarentine
if random.random(
) < 0.004576659038901602 * G[i][neighbor]["weight"]:
G.nodes[neighbor]["status"] = "E"
G.nodes[neighbor]["days_since_E"] = 0
for e in E_n:
G.nodes[e]["days_since_E"] += 1
days_since_E = G.nodes[e]["days_since_E"]
if days_since_E == 14: # if you've been asymp for 14 days, you recover
G.nodes[e]["status"] = "R"
mu = 1.621
std = 0.418
prob = lognorm.pdf(days_since_E, s=std, scale=np.exp(mu)) * 0.8
if random.random() < prob:
G.nodes[e]["status"] = "I"
G.nodes[e]["days_since_I"] = 0
G.nodes[e]["onset of symptoms"] = random.normalvariate(5, 2.5)
for i in I_n:
G.nodes[i]["days_since_E"] += 1
G.nodes[i]["days_since_I"] += 1
days_since_I = G.nodes[i]["days_since_I"]
# Added social distancing after 5 days of being infected
if days_since_I > G.nodes[i]["onset of symptoms"]:
cn_edges = G.edges(i)
cn_edges = (e if e in weight else (e[1], e[0]) for e in cn_edges)
updated_edges = {
e: weight[e] * quarantine_infectivity
for e in cn_edges
}
nx.set_edge_attributes(G, name="weight", values=updated_edges)
dist = norm(10, 1)
prob = dist.pdf(days_since_I) * 0.1755
if random.random() < prob:
G.nodes[i]["status"] = "H"
G.nodes[i]["days_since_H"] = 0
if G.nodes[i]["days_since_E"] >= 14:
G.nodes[i]["status"] = "R"
for h in H_n:
G.nodes[h]["days_since_H"] += 1
G.nodes[h]["days_since_E"] += 1
if G.nodes[h]["days_since_E"] == 14:
if random.random() < 0.01:
G.nodes[h]["status"] = "D"
else:
G.nodes[h]["status"] = "R"
# If we do testing, we now update the nodes depending on the test passed in
if test == "random":
src.test_strategies.test_strat_random_sample(G, 50)
elif test == "high_connect":
prev_t = prev_tested[0].union(prev_tested[1], prev_tested[2],
prev_tested[3], prev_tested[4])
(tested, num_tested,
extra_tests) = src.test_strategies.test_strat_high_contact(
G, 150, 50, prev_t)
global ind_to_prev_tested
prev_tested[ind_to_prev_tested] = set(tested)
ind_to_prev_tested = (ind_to_prev_tested + 1) % 5
elif test == "pool_family":
src.test_strategies.test_strat_pool_family(G)
elif test == "most_infected":
src.test_strategies.test_strat_most_infected(G, 50)
def getArcFlowMin(self, arc):
flowMin = nx.get_edge_attributes(self.G, 'flowMin')
return float(flowMin[arc])
while True:
ind = argmax(tsd_2)
amax = unravel_index(ind, (NODES, NODES))
s_star = amax[0]
d_star = amax[1]
if tsd_2[s_star, d_star] > 0:
maxima.append([s_star, d_star])
tsd_2[s_star, d_star] = 0
else:
break
for couple in maxima:
s = couple[0]
d = couple[1]
if G.node[s]['n_lasers'] > 0:
if G.node[d]['n_photodiods'] > 0:
G.add_edge(s, d, flow=0)
G.node[s]['n_lasers'] -= 1
G.node[d]['n_photodiods'] -= 1
tsd_2[s_star][d_star] = 0
flows = routeTraffic(G, tsd, NODES)
fmax = max(flows)
print fmax
edge_labels = nx.get_edge_attributes(G, 'flow')
nx.draw_circular(G, with_labels=True, node_color='y')
plt.savefig("path.png")
G = nx.Graph()
nnodes = list(map(lambda v: v.id, graph.nodes))
G.add_nodes_from(nnodes)
paths = list(map(lambda e: e.graph(), D.tour))
x = list(map(lambda edge: edge.graph(), graph.edges))
y = list(map(lambda edge: edge.d, graph.edges))
peso = 0
for edge, d in zip(x, y):
if edge in paths:
G.add_edge(*edge, d=("%d" % d))
peso += d
plt.title("Peso del tour: {}\n".format(peso))
pos = nx.spring_layout(G)
edges = G.edges()
labels = nx.get_edge_attributes(G, 'd')
nx.draw_networkx(G, pos=pos,\
with_labels=True, \
width=1.0, \
node_size=1000, \
node_color='pink',\
alpha=0.9)
nx.draw_networkx_edge_labels(G, pos, labels)
plt.show()
def case1_synthesis(formulas, ts_files, alpha, radius, time_wp, lab_testing):
startFull = timeit.default_timer()
startOff = timeit.default_timer()
dfa_dict = {}
for ind, f in enumerate(formulas):
_, dfa_inf, bdd = twtl.translate(f, kind=DFAType.Infinity, norm=True)
logging.debug('\nEnd of translate\n\n')
logging.info('The bound of formula "%s" is (%d, %d)!', f, *bdd)
logging.info(
'Translated formula "%s" to infinity DFA of size (%d, %d)!', f,
*dfa_inf.size())
dfa_dict[ind + 1] = copy.deepcopy(
dfa_inf) # Note that the key is set to the agent number
logging.debug('\n\nStart policy computation\n')
ts_dict = {}
ets_dict = {}
for ind, ts_f in enumerate(ts_files):
ts_dict[ind + 1] = Ts(directed=True, multi=False)
ts_dict[ind + 1].read_from_file(ts_f)
ets_dict[ind + 1] = expand_duration_ts(ts_dict[ind + 1])
for ind in ts_dict:
print 'Size of TS:', ets_dict[ind].size()
# Get the nominal PA for each agent
pa_nom_dict = {}
norm_factor = {}
startPA = timeit.default_timer()
for key in dfa_dict:
logging.info('Constructing product automaton with infinity DFA!')
pa = ts_times_fsa(ets_dict[key], dfa_dict[key])
# Give length and weight attributes to all edges in pa
nom_weight_dict = {}
edges_all = nx.get_edge_attributes(ts_dict[key].g, 'edge_weight')
max_edge = max(edges_all, key=edges_all.get)
norm_factor[key] = edges_all[max_edge]
for pa_edge in pa.g.edges():
edge = (pa_edge[0][0], pa_edge[1][0], 0)
nom_weight_dict[pa_edge] = edges_all[edge] / norm_factor[key]
nx.set_edge_attributes(pa.g, 'edge_weight', nom_weight_dict)
nx.set_edge_attributes(pa.g, 'weight', 1)
logging.info('Product automaton size is: (%d, %d)', *pa.size())
# Make a copy of the nominal PA to change
pa_nom_dict[key] = copy.deepcopy(pa)
stopPA = timeit.default_timer()
print 'Run Time (s) to get all three PAs is: ', stopPA - startPA
for key in pa_nom_dict:
print 'Size of PA:', pa_nom_dict[key].size()
# Use alpha to perform weighted optimization of time and edge_weight and make this a
# new edge attribute to find "shortest path" over
for key in pa_nom_dict:
weight_dict = {}
time_weight = nx.get_edge_attributes(pa_nom_dict[key].g, 'weight')
edge_weight = nx.get_edge_attributes(pa_nom_dict[key].g, 'edge_weight')
for pa_edge in pa_nom_dict[key].g.edges():
weight_dict[pa_edge] = alpha * time_weight[pa_edge] + (
1 - alpha) * edge_weight[pa_edge]
# Append the multi-objective cost to the edge attribtues of the PA
nx.set_edge_attributes(pa_nom_dict[key].g, 'new_weight', weight_dict)
# Compute the energy (multi-objective cost function) for each agent's PA at every node
startEnergy = timeit.default_timer()
for key in pa_nom_dict:
compute_energy(pa_nom_dict[key])
stopEnergy = timeit.default_timer()
print 'Run Time (s) to get the moc energy function for all three PA: ', stopEnergy - startEnergy
# Compute optimal path in PA and project onto the TS
ts_policy_dict_nom = {}
pa_policy_dict_nom = {}
tau_dict_nom = {}
for key in pa_nom_dict:
ts_policy_dict_nom[key], pa_policy_dict_nom[key], tau_dict_nom[key] = \
compute_control_policy(pa_nom_dict[key], dfa_dict[key], dfa_dict[key].kind)
# Perform initial check on nominal control policies
for key in ts_policy_dict_nom:
if ts_policy_dict_nom[key] is None:
logging.info('No control policy found!')
# set empty control policies that will be iteratively updated
ts_control_policy_dict = {}
pa_control_policy_dict = {}
# Initialize policy variables
for key in ts_policy_dict_nom:
ts_control_policy_dict[key] = []
pa_control_policy_dict[key] = []
# Concatenate nominal policies for searching
policy_match, key_list, policy_match_index = update_policy_match(
ts_policy_dict_nom)
# Initialize vars, give nominal policies
iter_step = 0
running = True
traj_length = 0
ts_policy = copy.deepcopy(ts_policy_dict_nom)
pa_policy = copy.deepcopy(pa_policy_dict_nom)
tau_dict = tau_dict_nom
# Choose parameter for n-horizon local trajectory and information sharing,
# must be at least 2
num_hops = 2
# Get agent priority based on lowest energy
prev_states = {}
for key in ts_policy_dict_nom:
prev_states[key] = pa_policy_dict_nom[key][0]
priority = get_priority(pa_nom_dict, pa_policy_dict_nom, prev_states,
key_list)
# Create Agent energy dictionary for post-processing
agent_energy_dict = {}
for key in ts_policy_dict_nom:
agent_energy_dict[key] = []
# Print time statistics
stopOff = timeit.default_timer()
print 'Offline run time for all initial setup: ', stopOff - startOff
startOnline = timeit.default_timer()
# Execute takeoff command for all crazyflies in lab testing
if lab_testing:
startTakeoff = timeit.default_timer()
os.chdir("/home/ryan/crazyswarm/ros_ws/src/crazyswarm/scripts")
os.system(
"/home/ryan/crazyswarm/ros_ws/src/crazyswarm/scripts/twtl_takeoff.py"
) # make sure file is an executable
os.chdir("/home/ryan/Desktop/pyTWTL/src")
stopTakeoff = timeit.default_timer()
print 'Takeoff time, should be ~2.7sec: ', stopTakeoff - startTakeoff
# Iterate through all policies sequentially
while running:
while policy_match:
for p_ind, p_val in enumerate(priority):
if p_ind < 1:
weighted_nodes = {}
for i in range(num_hops):
weighted_nodes[i] = []
else:
# Get local neighborhood (n-hop) of nodes to search for a conflict
for k, key in enumerate(key_list):
if p_val == key:
node = policy_match[0][k]
break
# Note that communication range needs to be 2*H, the receding horizon length
local_set = get_neighborhood(node, ts_dict[p_val],
2 * num_hops)
one_hop_set = ts_dict[p_val].g.neighbors(node)
# Assign constraints for immediate transition
weighted_nodes = {}
weighted_nodes[0] = []
for pty in priority[0:p_ind]:
for k, key in enumerate(key_list):
if pty == key:
prev_node = policy_match[0][k]
if prev_node in one_hop_set:
weighted_nodes[0].append(prev_node)
# Check if downwash constraint needs to be added, mostly for physical testing
downwash_weight = downwash_check(k, ets_dict[key], policy_match[0], \
priority[0:k], key_list, radius)
if downwash_weight:
for downwash_node in downwash_weight:
if downwash_node not in weighted_nodes:
weighted_nodes[0].append(
downwash_node)
break
# Get constraints for later transitions
for pty in priority[0:p_ind]:
for k, key in enumerate(key_list):
if pty == key:
ts_length = len(ts_policy[key])
if ts_length >= num_hops:
for i in range(num_hops - 1):
if ts_policy[key][i + 1] in local_set:
try:
weighted_nodes[i + 1]
weighted_nodes[i + 1].append(
ts_policy[key][i + 1])
except KeyError:
weighted_nodes[i + 1] = [
ts_policy[key][i + 1]
]
else:
for i in range(ts_length - 1):
if ts_policy[key][i + 1] in local_set:
try:
weighted_nodes[i + 1]
weighted_nodes[i + 1].append(
ts_policy[key][i + 1])
except KeyError:
weighted_nodes[i + 1] = [
ts_policy[key][i + 1]
]
for i in range(num_hops - 1):
try:
weighted_nodes[i + 1]
except KeyError:
weighted_nodes[i + 1] = []
# Update constraint set with intersecting transitions
ts_prev_states = []
ts_index = []
if len(policy_match[0]) > 1 and traj_length >= 1:
for key in ts_control_policy_dict:
if len(ts_control_policy_dict[key]) == traj_length:
ts_prev_states.append(
ts_control_policy_dict[key][-1])
if ts_prev_states:
for p_ind2, p_val2 in enumerate(priority[0:p_ind + 1]):
if p_ind2 > 0:
for k_c, key in enumerate(key_list):
if p_val2 == key:
node = policy_match[0][k_c]
break
# Check if the trajectories will cross each other in transition
cross_weight = check_intersect(k_c, ets_dict[key], ts_prev_states, policy_match[0], \
priority[0:p_ind2], key_list, radius, time_wp)
if cross_weight:
for cross_node in cross_weight:
if cross_node not in weighted_nodes[0]:
weighted_nodes[0].append(
cross_node)
# Check if agents using same transition
for p_ind3, p_val3 in enumerate(
priority[0:p_ind2]):
for k, key in enumerate(key_list):
if p_val3 == key:
if ts_prev_states[k] == node:
if policy_match[0][
k] == ts_prev_states[
k_c]:
temp_node = policy_match[
0][k]
if temp_node not in weighted_nodes:
weighted_nodes[
0].append(
temp_node)
if node not in weighted_nodes:
weighted_nodes[
0].append(node)
break
else:
continue
break
else:
continue
break
else:
# Check if agents using same transition
for p_ind3, p_val3 in enumerate(
priority[0:p_ind2]):
for k, key in enumerate(key_list):
if p_val3 == key:
if ts_prev_states[k] == node:
if policy_match[0][
k] == ts_prev_states[
k_c]:
temp_node = policy_match[
0][k]
if temp_node not in weighted_nodes:
weighted_nodes[
0].append(
temp_node)
if node not in weighted_nodes:
weighted_nodes[
0].append(node)
break
else:
continue
break
else:
continue
break
# Compute local horizon function to account for receding horizon all the time
# while checking for termination
if traj_length >= 1:
init_loc = pa_control_policy_dict[p_val][-1]
# Compute receding horizon shortest path
ts_policy[p_val], pa_policy[p_val] = \
local_horizon(pa_nom_dict[p_val], weighted_nodes, num_hops, init_loc)
# Write updates to file
iter_step += 1
# write_to_iter_file(ts_policy[p_val], ts_dict[p_val], ets_dict[p_val], p_val, iter_step)
# Update policy match
policy_match, key_list, policy_match_index = update_policy_match(
ts_policy)
# Append trajectories
for key in ts_policy:
agent_energy_dict[key].append(
pa_nom_dict[key].g.node[pa_policy[key][0]]['energy'])
ts_control_policy_dict[key].append(ts_policy[key].pop(0))
pa_policy_temp = list(pa_policy[key])
pa_control_policy_dict[key].append(pa_policy_temp.pop(0))
pa_policy[key] = tuple(pa_policy_temp)
ts_write = policy_match.pop(0)
traj_length += 1
# publish this waypoint to a csv file
write_to_csv_iter(ts_dict, ts_write, key_list, time_wp)
# Execute waypoint in crazyswarm lab testing
if lab_testing:
startWaypoint = timeit.default_timer()
os.chdir("/home/ryan/crazyswarm/ros_ws/src/crazyswarm/scripts")
os.system(
"/home/ryan/crazyswarm/ros_ws/src/crazyswarm/scripts/twtl_waypoint.py"
) # make sure executable
os.chdir("/home/ryan/Desktop/pyTWTL/src")
stopWaypoint = timeit.default_timer()
print 'Waypoint time, should be ~2.0sec: ', stopWaypoint - startWaypoint
# Update policy_match now that a trajectory has finalized and policy_match is empty
if ts_policy:
# Remove keys from policies that have terminated
land_keys = []
for key, val in ts_policy.items():
if len(val) == 0:
land_keys.append(key)
del ts_policy[key]
del pa_policy[key]
# publish to the land csv file for lab testing
if land_keys:
if lab_testing:
write_to_land_file(land_keys)
os.chdir(
"/home/ryan/crazyswarm/ros_ws/src/crazyswarm/scripts"
)
os.system(
"/home/ryan/crazyswarm/ros_ws/src/crazyswarm/scripts/twtl_land.py"
) # make sure executable
os.chdir("/home/ryan/Desktop/pyTWTL/src")
if not ts_policy:
running = False
break
# Update policy match
policy_match, key_list, policy_match_index = update_policy_match(
ts_policy)
# Get agent priority based on lowest energy
for key in key_list:
prev_states[key] = pa_control_policy_dict[key][-1]
priority = get_priority(pa_nom_dict, pa_policy, prev_states,
key_list)
else:
running = False
# Print run time statistics
stopOnline = timeit.default_timer()
print 'Online run time for safe algorithm: ', stopOnline - startOnline
stopFull = timeit.default_timer()
print 'Full run time for safe algorithm: ', stopFull - startFull
# Print other statistics from simulation
print 'Number of iterations for run: ', iter_step
print 'Average time for itertion is: ', (stopOnline -
startOnline) / iter_step
print 'Number of full updates in run: ', traj_length
print 'Average update time for single step: ', (stopOnline -
startOnline) / traj_length
#print(agent_energy_dict)
#print(pa.g.neighbors)
#print(pa.g())
#print(ts_control_policy_dict)
#print(pa.size())
#print(pa.g.neighbors())
print(pa.g.edges())
pa_adj_st = nx.adjacency_matrix(
pa.g) # PA adjacaceny matrix, source and target
# print(pa_adj_st)
# print(pa_adj_st.todense())
#pa.visualize(draw = 'matplotlib')
#plt.show()
#print(pa_edge)
#print(pa_policy)
# Print energy statistics from run
# plot_energy(agent_energy_dict)
# Possibly just set the relaxation to the nominal + additional nodes added *** Change (10/28)
for key in pa_nom_dict:
tau_dict[key] = tau_dict_nom[key] + len(
ts_control_policy_dict[key]) - len(ts_policy_dict_nom[key])
# Write the nominal and final control policies to a file
for key in pa_nom_dict:
write_to_control_policy_file(ts_policy_dict_nom[key], pa_policy_dict_nom[key], \
tau_dict_nom[key], dfa_dict[key],ts_dict[key],ets_dict[key],\
ts_control_policy_dict[key], pa_control_policy_dict[key], tau_dict[key], key)
# Write the CSV files for experiments
for key in pa_nom_dict:
write_to_csv(ts_dict[key], ts_control_policy_dict[key], key, time_wp)
def prep_for_learning(ep_len, m, n, h, init_states, obstacles, pick_up_state,
delivery_state, rewards, rew_val, custom_flag,
custom_task):
# Create the environment and get the TS #
ts_start_time = timeit.default_timer()
disc = 1
TS, obs_mat, state_mat = create_ts(m, n, h)
path = '../data/ts_' + str(m) + 'x' + str(n) + 'x' + str(h) + '_1Ag_1.txt'
paths = [path]
bases = {init_states[0]: 'Base1'}
obs_mat = update_obs_mat(obs_mat, state_mat, m, obstacles, init_states[0])
TS = update_adj_mat_3D(m, n, h, TS, obs_mat)
create_input_file(TS, state_mat, obs_mat, paths[0], bases, disc, m, n, h,
0)
ts_file = paths
ts_dict = Ts(directed=True, multi=False)
ts_dict.read_from_file(ts_file[0])
ts = expand_duration_ts(ts_dict)
ts_timecost = timeit.default_timer() - ts_start_time
# Get the DFA #
dfa_start_time = timeit.default_timer()
pick_up = str(pick_up_state[0][0] * n + pick_up_state[0][1])
delivery = str(delivery_state[0][0] * n + delivery_state[0][1])
tf = str(ep_len) # time bound
if custom_flag == 1:
phi = custom_task
else:
phi = '([H^1 r' + pick_up + ']^[0, ' + tf + '] * [H^1 r' + delivery + ']^[0,' + tf + '])^[0, ' + tf + ']' # Construc the task according to pickup/delivery
_, dfa_inf, bdd = twtl.translate(
phi, kind=DFAType.Infinity, norm=True
) # states and sim. time ex. phi = '([H^1 r47]^[0, 30] * [H^1 r31]^[0, 30])^[0, 30]'
dfa_timecost = timeit.default_timer() - dfa_start_time
# Get the PA #
pa_start_time = timeit.default_timer()
alpha = 1
nom_weight_dict = {}
weight_dict = {}
pa_or = ts_times_fsa(ts, dfa_inf) # Original pa
edges_all = nx.get_edge_attributes(ts_dict.g, 'edge_weight')
max_edge = max(edges_all, key=edges_all.get)
norm_factor = edges_all[max_edge]
for pa_edge in pa_or.g.edges():
edge = (pa_edge[0][0], pa_edge[1][0], 0)
nom_weight_dict[pa_edge] = edges_all[edge] / norm_factor
nx.set_edge_attributes(pa_or.g, 'edge_weight', nom_weight_dict)
nx.set_edge_attributes(pa_or.g, 'weight', 1)
pa = copy.deepcopy(pa_or) # copy the pa
time_weight = nx.get_edge_attributes(pa.g, 'weight')
edge_weight = nx.get_edge_attributes(pa.g, 'edge_weight')
for pa_edge in pa.g.edges():
weight_dict[pa_edge] = alpha * time_weight[pa_edge] + (
1 - alpha) * edge_weight[pa_edge]
nx.set_edge_attributes(pa.g, 'new_weight', weight_dict)
pa_timecost = timeit.default_timer() - pa_start_time
# Compute the energy of the states #
energy_time = timeit.default_timer()
compute_energy(pa)
energy_dict = nx.get_node_attributes(pa.g, 'energy')
energy_pa = []
for ind in range(len(pa.g.nodes())):
energy_pa.append(pa.g.nodes([0])[ind][1].values()[0])
# projection of pa on ts #
init_state = [init_states[0][0] * n + init_states[0][1]]
pa2ts = []
for i in range(len(pa.g.nodes())):
if pa.g.nodes()[i][0] != 'Base1':
pa2ts.append(int(pa.g.nodes()[i][0].replace("r", "")))
else:
pa2ts.append(init_state[0])
i_s = i # Agent's initial location in pa
energy_timecost = timeit.default_timer() - pa_start_time
# TS adjacency matrix and source-target
TS_adj = TS
TS_s = []
TS_t = []
for i in range(len(TS_adj)):
for j in range(len(TS_adj)):
if TS_adj[i, j] != 0:
TS_s.append(i)
TS_t.append(j)
# pa adjacency matrix and source-target
pa_adj_st = nx.adjacency_matrix(pa.g)
pa_adj = pa_adj_st.todense()
pa_s = [] # source node
pa_t = [] # target node
for i in range(len(pa_adj)):
for j in range(len(pa_adj)):
if pa_adj[i, j] == 1:
pa_s.append(i)
pa_t.append(j)
# PA rewards matrix
rewards_ts = np.zeros(m * n)
rewards_pa = np.zeros(len(pa2ts))
rewards_ts_indexes = []
for i in range(len(rewards)):
rewards_ts_indexes.append(
rewards[i][0] * n + rewards[i][1]
) # rewards_ts_indexes[i] = rewards[i][0] * n + rewards[i][1]
rewards_ts[rewards_ts_indexes[i]] = rew_val
for i in range(len(rewards_pa)):
rewards_pa[i] = rewards_ts[pa2ts[i]]
# # Display some important info
print('##### PICK-UP and DELIVERY MISSION #####' + "\n")
print('Initial Location : ' + str(init_states[0]) + ' <---> Region ' +
str(init_state[0]))
print('Pick-up Location : ' + str(pick_up_state[0]) + ' <---> Region ' +
pick_up)
print('Delivery Location : ' + str(delivery_state[0]) + ' <---> Regions ' +
delivery)
print('Reward Locations : ' + str(rewards) + ' <---> Regions ' +
str(rewards_ts_indexes) + "\n")
print('State Matrix : ')
print(state_mat)
print("\n")
print('Mission Duration : ' + tf + ' time steps')
print('TWTL Task : ' + phi + "\n")
print('Computational Costst : TS created in ' + str(ts_timecost) +
' seconds')
# print(' TS created in ' + str(ts_timecost) + ' seconds')
print(' DFA created in ' + str(dfa_timecost) + ' seconds')
print(' PA created in ' + str(pa_timecost) + ' seconds')
print(' Energy of PA states calculated in ' +
str(energy_timecost) + ' seconds')
return i_s, pa, pa_s, pa_t, pa2ts, energy_pa, rewards_pa, pick_up
def draw_graph(grph,
filename,
edge_labels=True,
node_color='#AFAFAF',
edge_color='#CFCFCF',
plot=True,
store=False,
node_size=2000,
node_shape='o',
with_labels=True,
arrows=True):
"""
Draw a graph. This function will be removed in future versions.
Parameters
----------
grph : networkxGraph
A graph to draw.
edge_labels : boolean
Use nominal values of flow as edge label
node_color : dict or stringh
Hex color code oder matplotlib color for each node. If string, all
colors are the same.
edge_color : string
Hex color code oder matplotlib color for edge color.
plot : boolean
Show matplotlib plot.
node_size : integer
Size of nodes.
with_labels : boolean
Draw node labels.
arrows : boolean
Draw arrows on directed edges. Works only if an optimization_model has
been passed.
layout : string
networkx graph layout, one of: neato, dot, twopi, circo, fdp, sfdp.
"""
if type(node_color) is dict:
node_color = [node_color.get(g, '#AFAFAF') for g in grph.nodes()]
# set drawing options
options = {
#'prog': 'dot',
'with_labels': with_labels,
'node_color': node_color,
'edge_color': edge_color,
'node_size': node_size,
'node_shape': node_shape,
'arrows': arrows
}
labeldict = {node: node.replace('_', '\n') for node in grph.nodes}
# draw graph
plt.figure(figsize=(12, 6))
pos = nx.drawing.nx_agraph.graphviz_layout(grph,
prog='dot',
args="-Grankdir=LR")
nx.draw(grph, pos=pos, labels=labeldict, **options)
# add edge labels for all edges
if edge_labels is True and plt:
labels = nx.get_edge_attributes(grph, 'weight')
nx.draw_networkx_edge_labels(grph, pos=pos, edge_labels=labels)
if store is True:
plt.savefig(filename, dpi=100, bbox_inches='tight')
# show output
if plot is True:
plt.show()
